From 8685e78c86ecd579078aaad961bd23eaba5e3e84 Mon Sep 17 00:00:00 2001 From: James Booth Date: Thu, 26 Dec 2013 13:37:22 +0000 Subject: [PATCH] Added mock_accounts and fixed tests --- Makefile.am | 2 +- src/config/accounts.c | 170 +++++++----- src/config/accounts.h | 68 ++--- src/main.c | 2 + tests/config/mock_accounts.c | 516 ++++++++++++++++++++++++++++++----- tests/config/mock_accounts.h | 90 ++++++ tests/test_cmd_account.c | 270 +++++++++--------- tests/test_cmd_connect.c | 58 ++-- tests/test_cmd_rooms.c | 7 +- 9 files changed, 847 insertions(+), 336 deletions(-) create mode 100644 tests/config/mock_accounts.h diff --git a/Makefile.am b/Makefile.am index f3634606..4aa18752 100644 --- a/Makefile.am +++ b/Makefile.am @@ -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 \ diff --git a/src/config/accounts.c b/src/config/accounts.c index 6431cd9e..2270e874 100644 --- a/src/config/accounts.c +++ b/src/config/accounts.c @@ -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; +} + diff --git a/src/config/accounts.h b/src/config/accounts.h index caa8e84c..ccccefdf 100644 --- a/src/config/accounts.h +++ b/src/config/accounts.h @@ -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 diff --git a/src/main.c b/src/main.c index 233feb6a..a87b9280 100644 --- a/src/main.c +++ b/src/main.c @@ -54,6 +54,8 @@ _init_modules(void) notifier_init_module(); statusbar_init_module(); titlebar_init_module(); + + accounts_init_module(); } int diff --git a/tests/config/mock_accounts.c b/tests/config/mock_accounts.c index 929a3b51..a40d4a67 100644 --- a/tests/config/mock_accounts.c +++ b/tests/config/mock_accounts.c @@ -23,168 +23,558 @@ #include #include #include +#include #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); +} diff --git a/tests/config/mock_accounts.h b/tests/config/mock_accounts.h new file mode 100644 index 00000000..84bfcc0a --- /dev/null +++ b/tests/config/mock_accounts.h @@ -0,0 +1,90 @@ +/* + * mock_accounts.h + * + * Copyright (C) 2012, 2013 James Booth + * + * 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 . + * + */ + +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); diff --git a/tests/test_cmd_account.c b/tests/test_cmd_account.c index b2650d8e..6d7a6d85 100644 --- a/tests/test_cmd_account.c +++ b/tests/test_cmd_account.c @@ -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); diff --git a/tests/test_cmd_connect.c b/tests/test_cmd_connect.c index 0095d144..6657c745 100644 --- a/tests/test_cmd_connect.c +++ b/tests/test_cmd_connect.c @@ -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); diff --git a/tests/test_cmd_rooms.c b/tests/test_cmd_rooms.c index 01aeecbe..bbd05471 100644 --- a/tests/test_cmd_rooms.c +++ b/tests/test_cmd_rooms.c @@ -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");