aniani/profanity
1
0
Fork 0
mirror of https://github.com/profanity-im/profanity.git synced 2024-09-22 19:45:54 -04:00
Code

Added mock_accounts and fixed tests

Browse Source
This commit is contained in:
James Booth 2013-12-26 13:37:22 +00:00
parent b83b262d47
commit 8685e78c86
9 changed files with 847 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -62,8 +62,8 @@ test_sources = \
src/config/theme.c src/config/theme.h \
tests/xmpp/mock_xmpp.h tests/xmpp/mock_xmpp.c \
tests/ui/mock_ui.h tests/ui/mock_ui.c \
tests/config/mock_accounts.h tests/config/mock_accounts.c \
tests/log/mock_log.c \
tests/config/mock_accounts.c \
tests/test_autocomplete.c \
tests/test_common.c \
tests/test_cmd_connect.c \

170
src/config/accounts.c
View File

@ -55,8 +55,8 @@ static void _fix_legacy_accounts(const char * const account_name);
static void _save_accounts(void);
static gchar * _get_accounts_file(void);
void
accounts_load(void)
static void
_accounts_load(void)
{
log_info("Loading accounts");
all_ac = autocomplete_new();
@ -85,40 +85,40 @@ accounts_load(void)
g_strfreev(account_names);
}
void
accounts_close(void)
static void
_accounts_close(void)
{
autocomplete_free(all_ac);
autocomplete_free(enabled_ac);
g_key_file_free(accounts);
}
char *
accounts_find_enabled(char *prefix)
static char *
_accounts_find_enabled(char *prefix)
{
return autocomplete_complete(enabled_ac, prefix);
}
char *
accounts_find_all(char *prefix)
static char *
_accounts_find_all(char *prefix)
{
return autocomplete_complete(all_ac, prefix);
}
void
accounts_reset_all_search(void)
static void
_accounts_reset_all_search(void)
{
autocomplete_reset(all_ac);
}
void
accounts_reset_enabled_search(void)
static void
_accounts_reset_enabled_search(void)
{
autocomplete_reset(enabled_ac);
}
void
accounts_add(const char *account_name, const char *altdomain)
static void
_accounts_add(const char *account_name, const char *altdomain)
{
// set account name and resource
const char *barejid = account_name;
@ -168,14 +168,14 @@ accounts_add(const char *account_name, const char *altdomain)
jid_destroy(jid);
}
gchar**
accounts_get_list(void)
static gchar**
_accounts_get_list(void)
{
return g_key_file_get_groups(accounts, NULL);
}
ProfAccount*
accounts_get_account(const char * const name)
static ProfAccount*
_accounts_get_account(const char * const name)
{
if (!g_key_file_has_group(accounts, name)) {
return NULL;
@ -292,8 +292,8 @@ accounts_get_account(const char * const name)
}
}
char *
accounts_create_full_jid(ProfAccount *account)
static char *
_accounts_create_full_jid(ProfAccount *account)
{
if (account->resource != NULL) {
return create_fulljid(account->jid, account->resource);
@ -302,8 +302,8 @@ accounts_create_full_jid(ProfAccount *account)
}
}
void
accounts_free_account(ProfAccount *account)
static void
_accounts_free_account(ProfAccount *account)
{
if (account != NULL) {
free(account->name);
@ -319,8 +319,8 @@ accounts_free_account(ProfAccount *account)
}
}
gboolean
accounts_enable(const char * const name)
static gboolean
_accounts_enable(const char * const name)
{
if (g_key_file_has_group(accounts, name)) {
g_key_file_set_boolean(accounts, name, "enabled", TRUE);
@ -332,8 +332,8 @@ accounts_enable(const char * const name)
}
}
gboolean
accounts_disable(const char * const name)
static gboolean
_accounts_disable(const char * const name)
{
if (g_key_file_has_group(accounts, name)) {
g_key_file_set_boolean(accounts, name, "enabled", FALSE);
@ -345,8 +345,8 @@ accounts_disable(const char * const name)
}
}
gboolean
accounts_rename(const char * const account_name, const char * const new_name)
static gboolean
_accounts_rename(const char * const account_name, const char * const new_name)
{
if (g_key_file_has_group(accounts, new_name)) {
return FALSE;
@ -393,15 +393,15 @@ accounts_rename(const char * const account_name, const char * const new_name)
return TRUE;
}
gboolean
accounts_account_exists(const char * const account_name)
static gboolean
_accounts_account_exists(const char * const account_name)
{
return g_key_file_has_group(accounts, account_name);
}
void
accounts_set_jid(const char * const account_name, const char * const value)
static void
_accounts_set_jid(const char * const account_name, const char * const value)
{
Jid *jid = jid_create(value);
if (jid != NULL) {
@ -426,8 +426,8 @@ accounts_set_jid(const char * const account_name, const char * const value)
}
}
void
accounts_set_server(const char * const account_name, const char * const value)
static void
_accounts_set_server(const char * const account_name, const char * const value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "server", value);
@ -435,8 +435,8 @@ accounts_set_server(const char * const account_name, const char * const value)
}
}
void
accounts_set_resource(const char * const account_name, const char * const value)
static void
_accounts_set_resource(const char * const account_name, const char * const value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "resource", value);
@ -444,8 +444,8 @@ accounts_set_resource(const char * const account_name, const char * const value)
}
}
void
accounts_set_password(const char * const account_name, const char * const value)
static void
_accounts_set_password(const char * const account_name, const char * const value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "password", value);
@ -453,8 +453,8 @@ accounts_set_password(const char * const account_name, const char * const value)
}
}
void
accounts_clear_password(const char * const account_name)
static void
_accounts_clear_password(const char * const account_name)
{
if (accounts_account_exists(account_name)) {
g_key_file_remove_key(accounts, account_name, "password", NULL);
@ -462,8 +462,8 @@ accounts_clear_password(const char * const account_name)
}
}
void
accounts_set_muc_service(const char * const account_name, const char * const value)
static void
_accounts_set_muc_service(const char * const account_name, const char * const value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "muc.service", value);
@ -471,8 +471,8 @@ accounts_set_muc_service(const char * const account_name, const char * const val
}
}
void
accounts_set_muc_nick(const char * const account_name, const char * const value)
static void
_accounts_set_muc_nick(const char * const account_name, const char * const value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "muc.nick", value);
@ -480,8 +480,8 @@ accounts_set_muc_nick(const char * const account_name, const char * const value)
}
}
void
accounts_set_priority_online(const char * const account_name, const gint value)
static void
_accounts_set_priority_online(const char * const account_name, const gint value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_integer(accounts, account_name, "priority.online", value);
@ -489,8 +489,8 @@ accounts_set_priority_online(const char * const account_name, const gint value)
}
}
void
accounts_set_priority_chat(const char * const account_name, const gint value)
static void
_accounts_set_priority_chat(const char * const account_name, const gint value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_integer(accounts, account_name, "priority.chat", value);
@ -498,8 +498,8 @@ accounts_set_priority_chat(const char * const account_name, const gint value)
}
}
void
accounts_set_priority_away(const char * const account_name, const gint value)
static void
_accounts_set_priority_away(const char * const account_name, const gint value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_integer(accounts, account_name, "priority.away", value);
@ -507,8 +507,8 @@ accounts_set_priority_away(const char * const account_name, const gint value)
}
}
void
accounts_set_priority_xa(const char * const account_name, const gint value)
static void
_accounts_set_priority_xa(const char * const account_name, const gint value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_integer(accounts, account_name, "priority.xa", value);
@ -516,8 +516,8 @@ accounts_set_priority_xa(const char * const account_name, const gint value)
}
}
void
accounts_set_priority_dnd(const char * const account_name, const gint value)
static void
_accounts_set_priority_dnd(const char * const account_name, const gint value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_integer(accounts, account_name, "priority.dnd", value);
@ -525,8 +525,8 @@ accounts_set_priority_dnd(const char * const account_name, const gint value)
}
}
void
accounts_set_priority_all(const char * const account_name, const gint value)
static void
_accounts_set_priority_all(const char * const account_name, const gint value)
{
if (accounts_account_exists(account_name)) {
accounts_set_priority_online(account_name, value);
@ -538,8 +538,8 @@ accounts_set_priority_all(const char * const account_name, const gint value)
}
}
gint
accounts_get_priority_for_presence_type(const char * const account_name,
static gint
_accounts_get_priority_for_presence_type(const char * const account_name,
resource_presence_t presence_type)
{
gint result;
@ -569,8 +569,8 @@ accounts_get_priority_for_presence_type(const char * const account_name,
return result;
}
void
accounts_set_last_presence(const char * const account_name, const char * const value)
static void
_accounts_set_last_presence(const char * const account_name, const char * const value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "presence.last", value);
@ -578,8 +578,8 @@ accounts_set_last_presence(const char * const account_name, const char * const v
}
}
void
accounts_set_login_presence(const char * const account_name, const char * const value)
static void
_accounts_set_login_presence(const char * const account_name, const char * const value)
{
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "presence.login", value);
@ -587,8 +587,8 @@ accounts_set_login_presence(const char * const account_name, const char * const
}
}
resource_presence_t
accounts_get_last_presence(const char * const account_name)
static resource_presence_t
_accounts_get_last_presence(const char * const account_name)
{
resource_presence_t result;
gchar *setting = g_key_file_get_string(accounts, account_name, "presence.last", NULL);
@ -615,8 +615,8 @@ accounts_get_last_presence(const char * const account_name)
return result;
}
resource_presence_t
accounts_get_login_presence(const char * const account_name)
static resource_presence_t
_accounts_get_login_presence(const char * const account_name)
{
resource_presence_t result;
gchar *setting = g_key_file_get_string(accounts, account_name, "presence.login", NULL);
@ -717,3 +717,41 @@ _get_accounts_file(void)
return result;
}
void
accounts_init_module(void)
{
accounts_load = _accounts_load;
accounts_close = _accounts_close;
accounts_find_all = _accounts_find_all;
accounts_find_enabled = _accounts_find_enabled;
accounts_reset_all_search = _accounts_reset_all_search;
accounts_reset_enabled_search = _accounts_reset_enabled_search;
accounts_add = _accounts_add;
accounts_get_list = _accounts_get_list;
accounts_get_account = _accounts_get_account;
accounts_free_account = _accounts_free_account;
accounts_enable = _accounts_enable;
accounts_disable = _accounts_disable;
accounts_rename = _accounts_rename;
accounts_account_exists = _accounts_account_exists;
accounts_set_jid = _accounts_set_jid;
accounts_set_server = _accounts_set_server;
accounts_set_resource = _accounts_set_resource;
accounts_set_password = _accounts_set_password;
accounts_set_muc_service = _accounts_set_muc_service;
accounts_set_muc_nick = _accounts_set_muc_nick;
accounts_set_last_presence = _accounts_set_last_presence;
accounts_set_login_presence = _accounts_set_login_presence;
accounts_get_last_presence = _accounts_get_last_presence;
accounts_get_login_presence = _accounts_get_login_presence;
accounts_set_priority_online = _accounts_set_priority_online;
accounts_set_priority_chat = _accounts_set_priority_chat;
accounts_set_priority_away = _accounts_set_priority_away;
accounts_set_priority_xa = _accounts_set_priority_xa;
accounts_set_priority_dnd = _accounts_set_priority_dnd;
accounts_set_priority_all = _accounts_set_priority_all;
accounts_get_priority_for_presence_type = _accounts_get_priority_for_presence_type;
accounts_clear_password = _accounts_clear_password;
accounts_create_full_jid = _accounts_create_full_jid;
}

68
src/config/accounts.h
View File

@ -46,41 +46,43 @@ typedef struct prof_account_t {
GSList *room_history;
} ProfAccount;
void accounts_load(void);
void accounts_close(void);
void accounts_init_module(void);
char * accounts_find_all(char *prefix);
char * accounts_find_enabled(char *prefix);
void accounts_reset_all_search(void);
void accounts_reset_enabled_search(void);
void accounts_add(const char *jid, const char *altdomain);
gchar** accounts_get_list(void);
ProfAccount* accounts_get_account(const char * const name);
void accounts_free_account(ProfAccount *account);
gboolean accounts_enable(const char * const name);
gboolean accounts_disable(const char * const name);
gboolean accounts_rename(const char * const account_name,
void (*accounts_load)(void);
void (*accounts_close)(void);
char * (*accounts_find_all)(char *prefix);
char * (*accounts_find_enabled)(char *prefix);
void (*accounts_reset_all_search)(void);
void (*accounts_reset_enabled_search)(void);
void (*accounts_add)(const char *jid, const char *altdomain);
gchar** (*accounts_get_list)(void);
ProfAccount* (*accounts_get_account)(const char * const name);
void (*accounts_free_account)(ProfAccount *account);
gboolean (*accounts_enable)(const char * const name);
gboolean (*accounts_disable)(const char * const name);
gboolean (*accounts_rename)(const char * const account_name,
const char * const new_name);
gboolean accounts_account_exists(const char * const account_name);
void accounts_set_jid(const char * const account_name, const char * const value);
void accounts_set_server(const char * const account_name, const char * const value);
void accounts_set_resource(const char * const account_name, const char * const value);
void accounts_set_password(const char * const account_name, const char * const value);
void accounts_set_muc_service(const char * const account_name, const char * const value);
void accounts_set_muc_nick(const char * const account_name, const char * const value);
void accounts_set_last_presence(const char * const account_name, const char * const value);
void accounts_set_login_presence(const char * const account_name, const char * const value);
resource_presence_t accounts_get_login_presence(const char * const account_name);
resource_presence_t accounts_get_last_presence(const char * const account_name);
void accounts_set_priority_online(const char * const account_name, const gint value);
void accounts_set_priority_chat(const char * const account_name, const gint value);
void accounts_set_priority_away(const char * const account_name, const gint value);
void accounts_set_priority_xa(const char * const account_name, const gint value);
void accounts_set_priority_dnd(const char * const account_name, const gint value);
void accounts_set_priority_all(const char * const account_name, const gint value);
gint accounts_get_priority_for_presence_type(const char * const account_name,
gboolean (*accounts_account_exists)(const char * const account_name);
void (*accounts_set_jid)(const char * const account_name, const char * const value);
void (*accounts_set_server)(const char * const account_name, const char * const value);
void (*accounts_set_resource)(const char * const account_name, const char * const value);
void (*accounts_set_password)(const char * const account_name, const char * const value);
void (*accounts_set_muc_service)(const char * const account_name, const char * const value);
void (*accounts_set_muc_nick)(const char * const account_name, const char * const value);
void (*accounts_set_last_presence)(const char * const account_name, const char * const value);
void (*accounts_set_login_presence)(const char * const account_name, const char * const value);
resource_presence_t (*accounts_get_login_presence)(const char * const account_name);
resource_presence_t (*accounts_get_last_presence)(const char * const account_name);
void (*accounts_set_priority_online)(const char * const account_name, const gint value);
void (*accounts_set_priority_chat)(const char * const account_name, const gint value);
void (*accounts_set_priority_away)(const char * const account_name, const gint value);
void (*accounts_set_priority_xa)(const char * const account_name, const gint value);
void (*accounts_set_priority_dnd)(const char * const account_name, const gint value);
void (*accounts_set_priority_all)(const char * const account_name, const gint value);
gint (*accounts_get_priority_for_presence_type)(const char * const account_name,
resource_presence_t presence_type);
void accounts_clear_password(const char * const account_name);
char * accounts_create_full_jid(ProfAccount *account);
void (*accounts_clear_password)(const char * const account_name);
char * (*accounts_create_full_jid)(ProfAccount *account);
#endif

2
src/main.c
View File

@ -54,6 +54,8 @@ _init_modules(void)
notifier_init_module();
statusbar_init_module();
titlebar_init_module();
accounts_init_module();
}
int

516
tests/config/mock_accounts.c
View File

@ -23,168 +23,558 @@
#include <glib.h>
#include <setjmp.h>
#include <cmocka.h>
#include <string.h>
#include "config/accounts.h"
void accounts_load(void) {}
void accounts_close(void) {}
// mocks and stubs
char * accounts_find_all(char *prefix)
{
return (char *)mock();
}
char * accounts_find_enabled(char *prefix)
{
return (char *)mock();
}
void accounts_reset_all_search(void) {}
void accounts_reset_enabled_search(void) {}
void accounts_add(const char *jid, const char *altdomain)
{
check_expected(jid);
}
gchar** accounts_get_list(void)
{
return (gchar **)mock();
}
ProfAccount* accounts_get_account(const char * const name)
static ProfAccount *
_mock_accounts_get_account(const char * const name)
{
check_expected(name);
return (ProfAccount *)mock();
}
void accounts_free_account(ProfAccount *account)
static char *
_mock_accounts_create_full_jid(ProfAccount *account)
{
check_expected(account);
return (char *)mock();
}
void
_stub_accounts_free_account(ProfAccount *account)
{
// do nothing
}
void
_mock_accounts_free_account(ProfAccount *account)
{
check_expected(account);
}
gboolean accounts_enable(const char * const name)
gchar **
_mock_accounts_get_list(void)
{
return (gchar **)mock();
}
void
_mock_accounts_add(const char *account_name, const char *altdomain)
{
check_expected(account_name);
check_expected(altdomain);
}
void
_stub_accounts_add(const char *account_name, const char *altdomain)
{
// do nothing
}
static gboolean
_mock_accounts_enable(const char * const name)
{
check_expected(name);
return (gboolean)mock();
}
gboolean accounts_disable(const char * const name)
static gboolean
_mock_accounts_disable(const char * const name)
{
check_expected(name);
return (gboolean)mock();
}
gboolean accounts_rename(const char * const account_name,
const char * const new_name)
static gboolean
_mock_accounts_rename(const char * const account_name, const char * const new_name)
{
check_expected(account_name);
check_expected(new_name);
return (gboolean)mock();
}
gboolean accounts_account_exists(const char * const account_name)
static gboolean
_mock_accounts_account_exists(const char * const account_name)
{
check_expected(account_name);
return (gboolean)mock();
}
void accounts_set_jid(const char * const account_name, const char * const value)
static void
_mock_accounts_set_jid(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_server(const char * const account_name, const char * const value)
static void
_stub_accounts_set_jid(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_accounts_set_resource(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_resource(const char * const account_name, const char * const value)
static void
_stub_accounts_set_resource(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_accounts_set_server(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_password(const char * const account_name, const char * const value)
static void
_stub_accounts_set_server(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_accounts_set_password(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_muc_service(const char * const account_name, const char * const value)
static void
_stub_accounts_set_password(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_accounts_set_muc_service(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_muc_nick(const char * const account_name, const char * const value)
static void
_stub_accounts_set_muc_service(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_accounts_set_muc_nick(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_last_presence(const char * const account_name, const char * const value) {}
static void
_stub_accounts_set_muc_nick(const char * const account_name, const char * const value)
{
// do nothing
}
void accounts_set_login_presence(const char * const account_name, const char * const value)
static void
_mock_accounts_set_priority_online(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
resource_presence_t accounts_get_login_presence(const char * const account_name)
{
return (resource_presence_t)mock();
}
resource_presence_t accounts_get_last_presence(const char * const account_name)
{
return (resource_presence_t)mock();
}
void accounts_set_priority_online(const char * const account_name, const gint value)
static void
_mock_accounts_set_priority_chat(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_priority_chat(const char * const account_name, const gint value)
static void
_mock_accounts_set_priority_away(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_priority_away(const char * const account_name, const gint value)
static void
_mock_accounts_set_priority_xa(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_priority_xa(const char * const account_name, const gint value)
static void
_mock_accounts_set_priority_dnd(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_priority_dnd(const char * const account_name, const gint value)
static void
_mock_accounts_set_login_presence(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_priority_all(const char * const account_name, const gint value) {}
gint accounts_get_priority_for_presence_type(const char * const account_name,
resource_presence_t presence_type)
static void
_stub_accounts_set_login_presence(const char * const account_name, const char * const value)
{
return (gint)mock();
}
void accounts_clear_password(const char * const account_name) {}
// set up functions
char * accounts_create_full_jid(ProfAccount *account)
void
mock_accounts_get_account(void)
{
return (char *)mock();
accounts_get_account = _mock_accounts_get_account;
}
void
mock_accounts_create_full_jid(void)
{
accounts_create_full_jid = _mock_accounts_create_full_jid;
}
void
stub_accounts_free_account(void)
{
accounts_free_account = _stub_accounts_free_account;
}
void
mock_accounts_free_account(void)
{
accounts_free_account = _mock_accounts_free_account;
}
void
mock_accounts_get_list(void)
{
accounts_get_list = _mock_accounts_get_list;
}
void
mock_accounts_add(void)
{
accounts_add = _mock_accounts_add;
}
void
stub_accounts_add(void)
{
accounts_add = _stub_accounts_add;
}
void
mock_accounts_enable(void)
{
accounts_enable = _mock_accounts_enable;
}
void
mock_accounts_disable(void)
{
accounts_disable = _mock_accounts_disable;
}
void
mock_accounts_rename(void)
{
accounts_rename = _mock_accounts_rename;
}
void
mock_accounts_account_exists(void)
{
accounts_account_exists = _mock_accounts_account_exists;
}
void
mock_accounts_set_jid(void)
{
accounts_set_jid = _mock_accounts_set_jid;
}
void
stub_accounts_set_jid(void)
{
accounts_set_jid = _stub_accounts_set_jid;
}
void
mock_accounts_set_resource(void)
{
accounts_set_resource = _mock_accounts_set_resource;
}
void
stub_accounts_set_resource(void)
{
accounts_set_resource = _stub_accounts_set_resource;
}
void
mock_accounts_set_server(void)
{
accounts_set_server = _mock_accounts_set_server;
}
void
stub_accounts_set_server(void)
{
accounts_set_server = _stub_accounts_set_server;
}
void
mock_accounts_set_password(void)
{
accounts_set_password = _mock_accounts_set_password;
}
void
stub_accounts_set_password(void)
{
accounts_set_password = _stub_accounts_set_password;
}
void
mock_accounts_set_muc_service(void)
{
accounts_set_muc_service = _mock_accounts_set_muc_service;
}
void
stub_accounts_set_muc_service(void)
{
accounts_set_muc_service = _stub_accounts_set_muc_service;
}
void
mock_accounts_set_muc_nick(void)
{
accounts_set_muc_nick = _mock_accounts_set_muc_nick;
}
void
stub_accounts_set_muc_nick(void)
{
accounts_set_muc_nick = _stub_accounts_set_muc_nick;
}
void
mock_accounts_set_priorities(void)
{
accounts_set_priority_online = _mock_accounts_set_priority_online;
accounts_set_priority_chat = _mock_accounts_set_priority_chat;
accounts_set_priority_away = _mock_accounts_set_priority_away;
accounts_set_priority_xa = _mock_accounts_set_priority_xa;
accounts_set_priority_dnd = _mock_accounts_set_priority_dnd;
}
void
mock_accounts_set_login_presence(void)
{
accounts_set_login_presence = _mock_accounts_set_login_presence;
}
void
stub_accounts_set_login_presence(void)
{
accounts_set_login_presence = _stub_accounts_set_login_presence;
}
// mock behaviours
void
accounts_get_account_expect_and_return(const char * const name, ProfAccount *account)
{
expect_string(_mock_accounts_get_account, name, name);
will_return(_mock_accounts_get_account, account);
}
void
accounts_get_account_return(ProfAccount *account)
{
expect_any(_mock_accounts_get_account, name);
will_return(_mock_accounts_get_account, account);
}
void
accounts_create_full_jid_return(char *fulljid)
{
expect_any(_mock_accounts_create_full_jid, account);
if (fulljid != NULL) {
will_return(_mock_accounts_create_full_jid, strdup(fulljid));
} else {
will_return(_mock_accounts_create_full_jid, NULL);
}
}
void
accounts_free_account_expect(ProfAccount *account)
{
expect_memory(_mock_accounts_free_account, account, account, sizeof(ProfAccount));
}
void
accounts_get_list_return(gchar **accounts)
{
will_return(_mock_accounts_get_list, accounts);
}
void
accounts_add_expect_account_name(char *account_name)
{
expect_any(_mock_accounts_add, altdomain);
expect_string(_mock_accounts_add, account_name, account_name);
}
void
accounts_enable_expect(char *name)
{
expect_string(_mock_accounts_enable, name, name);
will_return(_mock_accounts_enable, TRUE);
}
void
accounts_enable_return(gboolean result)
{
expect_any(_mock_accounts_enable, name);
will_return(_mock_accounts_enable, result);
}
void
accounts_disable_expect(char *name)
{
expect_string(_mock_accounts_disable, name, name);
will_return(_mock_accounts_disable, TRUE);
}
void
accounts_disable_return(gboolean result)
{
expect_any(_mock_accounts_disable, name);
will_return(_mock_accounts_disable, result);
}
void
accounts_rename_expect(char *account_name, char *new_name)
{
expect_string(_mock_accounts_rename, account_name, account_name);
expect_string(_mock_accounts_rename, new_name, new_name);
will_return(_mock_accounts_rename, TRUE);
}
void
accounts_rename_return(gboolean result)
{
expect_any(_mock_accounts_rename, account_name);
expect_any(_mock_accounts_rename, new_name);
will_return(_mock_accounts_rename, result);
}
void
accounts_account_exists_expect(char *account_name)
{
expect_string(_mock_accounts_account_exists, account_name, account_name);
will_return(_mock_accounts_account_exists, TRUE);
}
void
accounts_account_exists_return(gboolean result)
{
expect_any(_mock_accounts_account_exists, account_name);
will_return(_mock_accounts_account_exists, result);
}
void
accounts_set_jid_expect(char *account_name, char *jid)
{
expect_string(_mock_accounts_set_jid, account_name, account_name);
expect_string(_mock_accounts_set_jid, value, jid);
}
void
accounts_set_resource_expect(char *account_name, char *resource)
{
expect_string(_mock_accounts_set_resource, account_name, account_name);
expect_string(_mock_accounts_set_resource, value, resource);
}
void
accounts_set_server_expect(char *account_name, char *server)
{
expect_string(_mock_accounts_set_server, account_name, account_name);
expect_string(_mock_accounts_set_server, value, server);
}
void
accounts_set_password_expect(char *account_name, char *password)
{
expect_string(_mock_accounts_set_password, account_name, account_name);
expect_string(_mock_accounts_set_password, value, password);
}
void
accounts_set_muc_service_expect(char *account_name, char *service)
{
expect_string(_mock_accounts_set_muc_service, account_name, account_name);
expect_string(_mock_accounts_set_muc_service, value, service);
}
void
accounts_set_muc_nick_expect(char *account_name, char *nick)
{
expect_string(_mock_accounts_set_muc_nick, account_name, account_name);
expect_string(_mock_accounts_set_muc_nick, value, nick);
}
void
accounts_set_priority_online_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_online, account_name, account_name);
expect_value(_mock_accounts_set_priority_online, value, priority);
}
void
accounts_set_priority_chat_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_chat, account_name, account_name);
expect_value(_mock_accounts_set_priority_chat, value, priority);
}
void
accounts_set_priority_away_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_away, account_name, account_name);
expect_value(_mock_accounts_set_priority_away, value, priority);
}
void
accounts_set_priority_xa_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_xa, account_name, account_name);
expect_value(_mock_accounts_set_priority_xa, value, priority);
}
void
accounts_set_priority_dnd_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_dnd, account_name, account_name);
expect_value(_mock_accounts_set_priority_dnd, value, priority);
}
void
accounts_set_login_presence_expect(char *account_name, char *presence)
{
expect_string(_mock_accounts_set_login_presence, account_name, account_name);
expect_string(_mock_accounts_set_login_presence, value, presence);
}

90
tests/config/mock_accounts.h Normal file
View File

@ -0,0 +1,90 @@
/*
* mock_accounts.h
*
* Copyright (C) 2012, 2013 James Booth <boothj5@gmail.com>
*
* This file is part of Profanity.
*
* Profanity is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Profanity is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY {} without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Profanity. If not, see <http://www.gnu.org/licenses/>.
*
*/
void mock_accounts_get_account(void);
void accounts_get_account_expect_and_return(const char * const name, ProfAccount *account);
void accounts_get_account_return(ProfAccount *account);
void mock_accounts_create_full_jid(void);
void accounts_create_full_jid_return(char *fulljid);
void mock_accounts_free_account(void);
void stub_accounts_free_account(void);
void accounts_free_account_expect(ProfAccount *account);
void mock_accounts_get_list(void);
void accounts_get_list_return(gchar **accounts);
void mock_accounts_add(void);
void stub_accounts_add(void);
void accounts_add_expect_account_name(char *account_name);
void mock_accounts_enable(void);
void accounts_enable_expect(char *name);
void accounts_enable_return(gboolean result);
void mock_accounts_disable(void);
void accounts_disable_expect(char *name);
void accounts_disable_return(gboolean result);
void mock_accounts_rename(void);
void accounts_rename_expect(char *account_name, char *new_name);
void accounts_rename_return(gboolean result);
void mock_accounts_account_exists(void);
void accounts_account_exists_expect(char *account_name);
void accounts_account_exists_return(gboolean result);
void mock_accounts_set_jid(void);
void stub_accounts_set_jid(void);
void accounts_set_jid_expect(char *account_name, char *jid);
void mock_accounts_set_resource(void);
void stub_accounts_set_resource(void);
void accounts_set_resource_expect(char *account_name, char *resource);
void mock_accounts_set_server(void);
void stub_accounts_set_server(void);
void accounts_set_server_expect(char *account_name, char *server);
void mock_accounts_set_password(void);
void stub_accounts_set_password(void);
void accounts_set_password_expect(char *account_name, char *password);
void mock_accounts_set_muc_service(void);
void stub_accounts_set_muc_service(void);
void accounts_set_muc_service_expect(char *account_name, char *service);
void mock_accounts_set_muc_nick(void);
void stub_accounts_set_muc_nick(void);
void accounts_set_muc_nick_expect(char *account_name, char *nick);
void mock_accounts_set_priorities(void);
void accounts_set_priority_online_expect(char *account_name, gint priority);
void accounts_set_priority_chat_expect(char *account_name, gint priority);
void accounts_set_priority_away_expect(char *account_name, gint priority);
void accounts_set_priority_xa_expect(char *account_name, gint priority);
void accounts_set_priority_dnd_expect(char *account_name, gint priority);
void mock_accounts_set_login_presence(void);
void stub_accounts_set_login_presence(void);
void accounts_set_login_presence_expect(char *account_name, char *presence);

270
tests/test_cmd_account.c
View File

@ -12,6 +12,9 @@
#include "ui/ui.h"
#include "ui/mock_ui.h"
#include "config/accounts.h"
#include "config/mock_accounts.h"
#include "command/commands.h"
void cmd_account_shows_usage_when_not_connected_and_no_args(void **state)
@ -34,6 +37,8 @@ void cmd_account_shows_usage_when_not_connected_and_no_args(void **state)
void cmd_account_shows_account_when_connected_and_no_args(void **state)
{
mock_cons_show_account();
mock_accounts_get_account();
stub_accounts_free_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
ProfAccount *account = malloc(sizeof(ProfAccount));
gchar *args[] = { NULL };
@ -41,13 +46,10 @@ void cmd_account_shows_account_when_connected_and_no_args(void **state)
mock_connection_status(JABBER_CONNECTED);
mock_connection_account_name("account_name");
expect_any(accounts_get_account, name);
will_return(accounts_get_account, account);
accounts_get_account_return(account);
expect_cons_show_account(account);
expect_any(accounts_free_account, account);
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -58,6 +60,7 @@ void cmd_account_shows_account_when_connected_and_no_args(void **state)
void cmd_account_list_shows_accounts(void **state)
{
mock_cons_show_account_list();
mock_accounts_get_list();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "list", NULL };
@ -67,7 +70,7 @@ void cmd_account_list_shows_accounts(void **state)
accounts[2] = strdup("account3");
accounts[3] = NULL;
will_return(accounts_get_list, accounts);
accounts_get_list_return(accounts);
expect_cons_show_account_list(accounts);
@ -95,11 +98,11 @@ void cmd_account_show_shows_usage_when_no_arg(void **state)
void cmd_account_show_shows_message_when_account_does_not_exist(void **state)
{
mock_cons_show();
mock_accounts_get_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "show", "account_name", NULL };
expect_any(accounts_get_account, name);
will_return(accounts_get_account, NULL);
accounts_get_account_return(NULL);
expect_cons_show("No such account.");
expect_cons_show("");
@ -113,17 +116,16 @@ void cmd_account_show_shows_message_when_account_does_not_exist(void **state)
void cmd_account_show_shows_account_when_exists(void **state)
{
mock_cons_show_account();
mock_accounts_get_account();
stub_accounts_free_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "show", "account_name", NULL };
ProfAccount *account = malloc(sizeof(ProfAccount));
expect_any(accounts_get_account, name);
will_return(accounts_get_account, account);
accounts_get_account_return(account);
expect_cons_show_account(account);
expect_any(accounts_free_account, account);
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -148,10 +150,11 @@ void cmd_account_add_shows_usage_when_no_arg(void **state)
void cmd_account_add_adds_account(void **state)
{
stub_cons_show();
mock_accounts_add();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "add", "new_account", NULL };
expect_string(accounts_add, jid, "new_account");
accounts_add_expect_account_name("new_account");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -162,11 +165,10 @@ void cmd_account_add_adds_account(void **state)
void cmd_account_add_shows_message(void **state)
{
mock_cons_show();
stub_accounts_add();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "add", "new_account", NULL };
expect_any(accounts_add, jid);
expect_cons_show("Account created.");;
expect_cons_show("");
@ -194,11 +196,11 @@ void cmd_account_enable_shows_usage_when_no_arg(void **state)
void cmd_account_enable_enables_account(void **state)
{
stub_cons_show();
mock_accounts_enable();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "enable", "account_name", NULL };
expect_string(accounts_enable, name, "account_name");
will_return(accounts_enable, TRUE);
accounts_enable_expect("account_name");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -209,11 +211,11 @@ void cmd_account_enable_enables_account(void **state)
void cmd_account_enable_shows_message_when_enabled(void **state)
{
mock_cons_show();
mock_accounts_enable();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "enable", "account_name", NULL };
expect_any(accounts_enable, name);
will_return(accounts_enable, TRUE);
accounts_enable_return(TRUE);
expect_cons_show("Account enabled.");
expect_cons_show("");
@ -227,11 +229,11 @@ void cmd_account_enable_shows_message_when_enabled(void **state)
void cmd_account_enable_shows_message_when_account_doesnt_exist(void **state)
{
mock_cons_show();
mock_accounts_enable();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "enable", "account_name", NULL };
expect_any(accounts_enable, name);
will_return(accounts_enable, FALSE);
accounts_enable_return(FALSE);
expect_cons_show("No such account: account_name");
expect_cons_show("");
@ -260,11 +262,11 @@ void cmd_account_disable_shows_usage_when_no_arg(void **state)
void cmd_account_disable_disables_account(void **state)
{
stub_cons_show();
mock_accounts_disable();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "disable", "account_name", NULL };
expect_string(accounts_disable, name, "account_name");
will_return(accounts_disable, TRUE);
accounts_disable_expect("account_name");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -275,11 +277,11 @@ void cmd_account_disable_disables_account(void **state)
void cmd_account_disable_shows_message_when_disabled(void **state)
{
mock_cons_show();
mock_accounts_disable();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "disable", "account_name", NULL };
expect_any(accounts_disable, name);
will_return(accounts_disable, TRUE);
accounts_disable_return(TRUE);
expect_cons_show("Account disabled.");
expect_cons_show("");
@ -293,11 +295,11 @@ void cmd_account_disable_shows_message_when_disabled(void **state)
void cmd_account_disable_shows_message_when_account_doesnt_exist(void **state)
{
mock_cons_show();
mock_accounts_disable();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "disable", "account_name", NULL };
expect_any(accounts_disable, name);
will_return(accounts_disable, FALSE);
accounts_disable_return(FALSE);
expect_cons_show("No such account: account_name");
expect_cons_show("");
@ -341,12 +343,11 @@ void cmd_account_rename_shows_usage_when_one_arg(void **state)
void cmd_account_rename_renames_account(void **state)
{
stub_cons_show();
mock_accounts_rename();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "rename", "original_name", "new_name", NULL };
expect_string(accounts_rename, account_name, "original_name");
expect_string(accounts_rename, new_name, "new_name");
will_return(accounts_rename, TRUE);
accounts_rename_expect("original_name", "new_name");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -357,12 +358,11 @@ void cmd_account_rename_renames_account(void **state)
void cmd_account_rename_shows_message_when_renamed(void **state)
{
mock_cons_show();
mock_accounts_rename();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "rename", "original_name", "new_name", NULL };
expect_any(accounts_rename, account_name);
expect_any(accounts_rename, new_name);
will_return(accounts_rename, TRUE);
accounts_rename_return(TRUE);
expect_cons_show("Account renamed.");
expect_cons_show("");
@ -376,12 +376,11 @@ void cmd_account_rename_shows_message_when_renamed(void **state)
void cmd_account_rename_shows_message_when_not_renamed(void **state)
{
mock_cons_show();
mock_accounts_rename();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "rename", "original_name", "new_name", NULL };
expect_any(accounts_rename, account_name);
expect_any(accounts_rename, new_name);
will_return(accounts_rename, FALSE);
accounts_rename_return(FALSE);
expect_cons_show("Either account original_name doesn't exist, or account new_name already exists.");
expect_cons_show("");
@ -440,11 +439,11 @@ void cmd_account_set_shows_usage_when_two_args(void **state)
void cmd_account_set_checks_account_exists(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "a_property", "a_value", NULL };
expect_string(accounts_account_exists, account_name, "a_account");
will_return(accounts_account_exists, FALSE);
accounts_account_exists_expect("a_account");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -455,11 +454,11 @@ void cmd_account_set_checks_account_exists(void **state)
void cmd_account_set_shows_message_when_account_doesnt_exist(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "a_property", "a_value", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, FALSE);
accounts_account_exists_return(FALSE);
expect_cons_show("Account a_account doesn't exist");
expect_cons_show("");
@ -473,11 +472,11 @@ void cmd_account_set_shows_message_when_account_doesnt_exist(void **state)
void cmd_account_set_jid_shows_message_for_malformed_jid(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "jid", "@malformed", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_cons_show("Malformed jid: @malformed");
@ -490,20 +489,18 @@ void cmd_account_set_jid_shows_message_for_malformed_jid(void **state)
void cmd_account_set_jid_sets_barejid(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
mock_accounts_set_jid();
stub_accounts_set_resource();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "jid", "a_local@a_domain/a_resource", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_jid, account_name, "a_account");
expect_string(accounts_set_jid, value, "a_local@a_domain");
accounts_set_jid_expect("a_account", "a_local@a_domain");
expect_cons_show("Updated jid for account a_account: a_local@a_domain");
expect_any(accounts_set_resource, account_name);
expect_any(accounts_set_resource, value);
expect_cons_show_calls(2);
gboolean result = cmd_account(args, *help);
@ -515,19 +512,17 @@ void cmd_account_set_jid_sets_barejid(void **state)
void cmd_account_set_jid_sets_resource(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
stub_accounts_set_jid();
mock_accounts_set_resource();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "jid", "a_local@a_domain/a_resource", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
expect_any(accounts_set_jid, account_name);
expect_any(accounts_set_jid, value);
accounts_account_exists_return(TRUE);
expect_cons_show_calls(1);
expect_string(accounts_set_resource, account_name, "a_account");
expect_string(accounts_set_resource, value, "a_resource");
accounts_set_resource_expect("a_account", "a_resource");
expect_cons_show("Updated resource for account a_account: a_resource");
expect_cons_show("");
@ -541,14 +536,14 @@ void cmd_account_set_jid_sets_resource(void **state)
void cmd_account_set_server_sets_server(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_server();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "server", "a_server", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_server, account_name, "a_account");
expect_string(accounts_set_server, value, "a_server");
accounts_set_server_expect("a_account", "a_server");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -559,14 +554,12 @@ void cmd_account_set_server_sets_server(void **state)
void cmd_account_set_server_shows_message(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
stub_accounts_set_server();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "server", "a_server", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
expect_any(accounts_set_server, account_name);
expect_any(accounts_set_server, value);
accounts_account_exists_return(TRUE);
expect_cons_show("Updated server for account a_account: a_server");
expect_cons_show("");
@ -580,14 +573,14 @@ void cmd_account_set_server_shows_message(void **state)
void cmd_account_set_resource_sets_resource(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_resource();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "resource", "a_resource", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_resource, account_name, "a_account");
expect_string(accounts_set_resource, value, "a_resource");
accounts_set_resource_expect("a_account", "a_resource");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -598,14 +591,12 @@ void cmd_account_set_resource_sets_resource(void **state)
void cmd_account_set_resource_shows_message(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
stub_accounts_set_resource();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "resource", "a_resource", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
expect_any(accounts_set_resource, account_name);
expect_any(accounts_set_resource, value);
accounts_account_exists_return(TRUE);
expect_cons_show("Updated resource for account a_account: a_resource");
expect_cons_show("");
@ -619,14 +610,14 @@ void cmd_account_set_resource_shows_message(void **state)
void cmd_account_set_password_sets_password(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_password();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "password", "a_password", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_password, account_name, "a_account");
expect_string(accounts_set_password, value, "a_password");
accounts_set_password_expect("a_account", "a_password");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -637,14 +628,12 @@ void cmd_account_set_password_sets_password(void **state)
void cmd_account_set_password_shows_message(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
stub_accounts_set_password();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "password", "a_password", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
expect_any(accounts_set_password, account_name);
expect_any(accounts_set_password, value);
accounts_account_exists_return(TRUE);
expect_cons_show("Updated password for account a_account");
expect_cons_show("");
@ -658,14 +647,14 @@ void cmd_account_set_password_shows_message(void **state)
void cmd_account_set_muc_sets_muc(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_muc_service();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "muc", "a_muc", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_muc_service, account_name, "a_account");
expect_string(accounts_set_muc_service, value, "a_muc");
accounts_set_muc_service_expect("a_account", "a_muc");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -676,14 +665,12 @@ void cmd_account_set_muc_sets_muc(void **state)
void cmd_account_set_muc_shows_message(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
stub_accounts_set_muc_service();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "muc", "a_muc", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
expect_any(accounts_set_muc_service, account_name);
expect_any(accounts_set_muc_service, value);
accounts_account_exists_return(TRUE);
expect_cons_show("Updated muc service for account a_account: a_muc");
expect_cons_show("");
@ -697,14 +684,14 @@ void cmd_account_set_muc_shows_message(void **state)
void cmd_account_set_nick_sets_nick(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_muc_nick();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "nick", "a_nick", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_muc_nick, account_name, "a_account");
expect_string(accounts_set_muc_nick, value, "a_nick");
accounts_set_muc_nick_expect("a_account", "a_nick");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -715,14 +702,12 @@ void cmd_account_set_nick_sets_nick(void **state)
void cmd_account_set_nick_shows_message(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
stub_accounts_set_muc_nick();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "nick", "a_nick", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
expect_any(accounts_set_muc_nick, account_name);
expect_any(accounts_set_muc_nick, value);
accounts_account_exists_return(TRUE);
expect_cons_show("Updated muc nick for account a_account: a_nick");
expect_cons_show("");
@ -736,11 +721,12 @@ void cmd_account_set_nick_shows_message(void **state)
void cmd_account_set_status_shows_message_when_invalid_status(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
stub_accounts_set_login_presence();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "status", "bad_status", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_cons_show("Invalid status: bad_status");
expect_cons_show("");
@ -754,14 +740,14 @@ void cmd_account_set_status_shows_message_when_invalid_status(void **state)
void cmd_account_set_status_sets_status_when_valid(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_login_presence();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "status", "away", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_login_presence, account_name, "a_account");
expect_string(accounts_set_login_presence, value, "away");
accounts_set_login_presence_expect("a_account", "away");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -772,14 +758,14 @@ void cmd_account_set_status_sets_status_when_valid(void **state)
void cmd_account_set_status_sets_status_when_last(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_login_presence();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "status", "last", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_login_presence, account_name, "a_account");
expect_string(accounts_set_login_presence, value, "last");
accounts_set_login_presence_expect("a_account", "last");
gboolean result = cmd_account(args, *help);
assert_true(result);
@ -790,14 +776,12 @@ void cmd_account_set_status_sets_status_when_last(void **state)
void cmd_account_set_status_shows_message_when_set_valid(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
stub_accounts_set_login_presence();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "status", "away", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
expect_any(accounts_set_login_presence, account_name);
expect_any(accounts_set_login_presence, value);
accounts_account_exists_return(TRUE);
expect_cons_show("Updated login status for account a_account: away");
expect_cons_show("");
@ -811,14 +795,12 @@ void cmd_account_set_status_shows_message_when_set_valid(void **state)
void cmd_account_set_status_shows_message_when_set_last(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
stub_accounts_set_login_presence();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "status", "last", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
expect_any(accounts_set_login_presence, account_name);
expect_any(accounts_set_login_presence, value);
accounts_account_exists_return(TRUE);
expect_cons_show("Updated login status for account a_account: last");
expect_cons_show("");
@ -832,11 +814,11 @@ void cmd_account_set_status_shows_message_when_set_last(void **state)
void cmd_account_set_invalid_presence_string_priority_shows_message(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "blah", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_cons_show("Invalid property: blah");
expect_cons_show("");
@ -850,11 +832,11 @@ void cmd_account_set_invalid_presence_string_priority_shows_message(void **state
void cmd_account_set_last_priority_shows_message(void **state)
{
mock_cons_show();
mock_accounts_account_exists();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "last", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_cons_show("Invalid property: last");
expect_cons_show("");
@ -868,14 +850,14 @@ void cmd_account_set_last_priority_shows_message(void **state)
void cmd_account_set_online_priority_sets_preference(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_priorities();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "online", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_priority_online, account_name, "a_account");
expect_value(accounts_set_priority_online, value, 10);
accounts_set_priority_online_expect("a_account", 10);
mock_connection_status(JABBER_DISCONNECTED);
@ -888,14 +870,14 @@ void cmd_account_set_online_priority_sets_preference(void **state)
void cmd_account_set_chat_priority_sets_preference(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_priorities();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "chat", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_priority_chat, account_name, "a_account");
expect_value(accounts_set_priority_chat, value, 10);
accounts_set_priority_chat_expect("a_account", 10);
mock_connection_status(JABBER_DISCONNECTED);
@ -908,14 +890,14 @@ void cmd_account_set_chat_priority_sets_preference(void **state)
void cmd_account_set_away_priority_sets_preference(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_priorities();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "away", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_priority_away, account_name, "a_account");
expect_value(accounts_set_priority_away, value, 10);
accounts_set_priority_away_expect("a_account", 10);
mock_connection_status(JABBER_DISCONNECTED);
@ -928,14 +910,14 @@ void cmd_account_set_away_priority_sets_preference(void **state)
void cmd_account_set_xa_priority_sets_preference(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_priorities();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "xa", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_priority_xa, account_name, "a_account");
expect_value(accounts_set_priority_xa, value, 10);
accounts_set_priority_xa_expect("a_account", 10);
mock_connection_status(JABBER_DISCONNECTED);
@ -948,14 +930,14 @@ void cmd_account_set_xa_priority_sets_preference(void **state)
void cmd_account_set_dnd_priority_sets_preference(void **state)
{
stub_cons_show();
mock_accounts_account_exists();
mock_accounts_set_priorities();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "set", "a_account", "dnd", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
accounts_account_exists_return(TRUE);
expect_string(accounts_set_priority_dnd, account_name, "a_account");
expect_value(accounts_set_priority_dnd, value, 10);
accounts_set_priority_dnd_expect("a_account", 10);
mock_connection_status(JABBER_DISCONNECTED);

58
tests/test_cmd_connect.c
View File

@ -14,6 +14,8 @@
#include "command/commands.h"
#include "config/accounts.h"
#include "config/mock_accounts.h"
static jabber_conn_status_t _mock_jabber_connect_with_details_no_altdomain(const char * const jid,
const char * const passwd, const char * const altdomain)
@ -85,14 +87,14 @@ void cmd_connect_shows_message_when_undefined(void **state)
void cmd_connect_when_no_account(void **state)
{
mock_cons_show();
mock_accounts_get_account();
mock_ui_ask_password();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "user@server.org", NULL };
mock_connection_status(JABBER_DISCONNECTED);
expect_string(accounts_get_account, name, "user@server.org");
will_return(accounts_get_account, NULL);
accounts_get_account_expect_and_return("user@server.org", NULL);
mock_ui_ask_password_returns("password");
@ -113,13 +115,13 @@ void cmd_connect_with_altdomain_when_provided(void **state)
{
stub_ui_ask_password();
stub_cons_show();
mock_accounts_get_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "user@server.org", "altdomain" };
mock_connection_status(JABBER_DISCONNECTED);
expect_any(accounts_get_account, name);
will_return(accounts_get_account, NULL);
accounts_get_account_return(NULL);
jabber_connect_with_details = _mock_jabber_connect_with_details_altdomain;
expect_string(_mock_jabber_connect_with_details_altdomain, altdomain, "altdomain");
@ -136,13 +138,13 @@ void cmd_connect_fail_message(void **state)
stub_cons_show();
mock_cons_show_error();
stub_ui_ask_password();
mock_accounts_get_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "user@server.org", NULL };
mock_connection_status(JABBER_DISCONNECTED);
expect_any(accounts_get_account, name);
will_return(accounts_get_account, NULL);
accounts_get_account_return(NULL);
jabber_connect_with_details = _mock_jabber_connect_with_details_result;
will_return(_mock_jabber_connect_with_details_result, JABBER_DISCONNECTED);
@ -159,13 +161,13 @@ void cmd_connect_lowercases_argument(void **state)
{
stub_cons_show();
stub_ui_ask_password();
mock_accounts_get_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "USER@server.ORG", NULL };
mock_connection_status(JABBER_DISCONNECTED);
expect_string(accounts_get_account, name, "user@server.org");
will_return(accounts_get_account, NULL);
accounts_get_account_expect_and_return("user@server.org", NULL);
jabber_connect_with_details = _mock_jabber_connect_with_details_result;
will_return(_mock_jabber_connect_with_details_result, JABBER_CONNECTING);
@ -180,6 +182,9 @@ void cmd_connect_asks_password_when_not_in_account(void **state)
{
stub_cons_show();
stub_ui_ask_password();
mock_accounts_get_account();
mock_accounts_create_full_jid();
stub_accounts_free_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "jabber_org", NULL };
ProfAccount *account = malloc(sizeof(ProfAccount));
@ -187,16 +192,13 @@ void cmd_connect_asks_password_when_not_in_account(void **state)
mock_connection_status(JABBER_DISCONNECTED);
expect_any(accounts_get_account, name);
will_return(accounts_get_account, account);
accounts_get_account_return(account);
will_return(accounts_create_full_jid, strdup("user@jabber.org"));
accounts_create_full_jid_return("user@jabber.org");
jabber_connect_with_account = _mock_jabber_connect_with_account_result;
will_return(_mock_jabber_connect_with_account_result, JABBER_CONNECTING);
expect_any(accounts_free_account, account);
gboolean result = cmd_connect(args, *help);
assert_true(result);
@ -207,6 +209,9 @@ void cmd_connect_asks_password_when_not_in_account(void **state)
void cmd_connect_shows_message_when_connecting_with_account(void **state)
{
mock_cons_show();
mock_accounts_get_account();
mock_accounts_create_full_jid();
stub_accounts_free_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "jabber_org", NULL };
ProfAccount *account = malloc(sizeof(ProfAccount));
@ -215,18 +220,15 @@ void cmd_connect_shows_message_when_connecting_with_account(void **state)
mock_connection_status(JABBER_DISCONNECTED);
expect_any(accounts_get_account, name);
will_return(accounts_get_account, account);
accounts_get_account_return(account);
will_return(accounts_create_full_jid, strdup("user@jabber.org/laptop"));
accounts_create_full_jid_return("user@jabber.org/laptop");
expect_cons_show("Connecting with account jabber_org as user@jabber.org/laptop");
jabber_connect_with_account = _mock_jabber_connect_with_account_result;
will_return(_mock_jabber_connect_with_account_result, JABBER_CONNECTING);
expect_any(accounts_free_account, account);
gboolean result = cmd_connect(args, *help);
assert_true(result);
@ -237,6 +239,9 @@ void cmd_connect_shows_message_when_connecting_with_account(void **state)
void cmd_connect_connects_with_account(void **state)
{
stub_cons_show();
mock_accounts_get_account();
mock_accounts_create_full_jid();
stub_accounts_free_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "jabber_org", NULL };
ProfAccount *account = malloc(sizeof(ProfAccount));
@ -245,17 +250,14 @@ void cmd_connect_connects_with_account(void **state)
mock_connection_status(JABBER_DISCONNECTED);
expect_any(accounts_get_account, name);
will_return(accounts_get_account, account);
accounts_get_account_return(account);
will_return(accounts_create_full_jid, strdup("user@jabber.org/laptop"));
accounts_create_full_jid_return("user@jabber.org/laptop");
jabber_connect_with_account = _mock_jabber_connect_with_account_result_check;
expect_memory(_mock_jabber_connect_with_account_result_check, account, account, sizeof(ProfAccount));
will_return(_mock_jabber_connect_with_account_result_check, JABBER_CONNECTING);
expect_any(accounts_free_account, account);
gboolean result = cmd_connect(args, *help);
assert_true(result);
@ -266,21 +268,23 @@ void cmd_connect_connects_with_account(void **state)
void cmd_connect_frees_account_after_connecting(void **state)
{
stub_cons_show();
mock_accounts_get_account();
mock_accounts_create_full_jid();
mock_accounts_free_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "jabber_org", NULL };
ProfAccount *account = malloc(sizeof(ProfAccount));
mock_connection_status(JABBER_DISCONNECTED);
expect_any(accounts_get_account, name);
will_return(accounts_get_account, account);
accounts_get_account_return(account);
will_return(accounts_create_full_jid, strdup("user@jabber.org/laptop"));
accounts_create_full_jid_return("user@jabber.org/laptop");
jabber_connect_with_account = _mock_jabber_connect_with_account_result;
will_return(_mock_jabber_connect_with_account_result, JABBER_CONNECTING);
expect_memory(accounts_free_account, account, account, sizeof(ProfAccount));
accounts_free_account_expect(account);
gboolean result = cmd_connect(args, *help);
assert_true(result);

7
tests/test_cmd_rooms.c
View File

@ -11,6 +11,9 @@
#include "ui/ui.h"
#include "ui/mock_ui.h"
#include "config/accounts.h"
#include "config/mock_accounts.h"
#include "command/commands.h"
static void test_with_connection_status(jabber_conn_status_t status)
@ -54,6 +57,7 @@ void cmd_rooms_shows_message_when_undefined(void **state)
void cmd_rooms_uses_account_default_when_no_arg(void **state)
{
mock_accounts_get_account();
CommandHelp *help = malloc(sizeof(CommandHelp));
ProfAccount *account = malloc(sizeof(ProfAccount));
account->muc_service = "default_conf_server";
@ -62,8 +66,7 @@ void cmd_rooms_uses_account_default_when_no_arg(void **state)
mock_connection_status(JABBER_CONNECTED);
mock_connection_account_name("account_name");
expect_string(accounts_get_account, name, "account_name");
will_return(accounts_get_account, account);
accounts_get_account_return(account);
expect_room_list_request("default_conf_server");