Fixes NB#134642, fixes a crash in on_header_view_model_changed
[modest] / tests / check_account-mgr.c
1 /* Copyright (c) 2006, Nokia Corporation
2  * All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  * * Redistributions of source code must retain the above copyright
9  *   notice, this list of conditions and the following disclaimer.
10  * * Redistributions in binary form must reproduce the above copyright
11  *   notice, this list of conditions and the following disclaimer in the
12  *   documentation and/or other materials provided with the distribution.
13  * * Neither the name of the Nokia Corporation nor the names of its
14  *   contributors may be used to endorse or promote products derived from
15  *   this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include <check.h>
31 #include <string.h>
32 #include <modest-defs.h>
33 #include <modest-conf.h>
34 #include <modest-account-mgr.h>
35 #include <modest-utils.h>
36 #include <gtk/gtk.h>
37 #include <modest-init.h>
38
39 /* ----------------------- Defines ---------------------- */
40
41 #define TEST_MODEST_ACCOUNT_NAME  "modest-unit-tests-àccount"
42
43 /* ------------------ Global variables ------------------ */
44
45 static ModestAccountMgr *account_mgr = NULL;
46
47 /* ---------------------- Fixtures --------------------- */
48
49 static void
50 fx_setup_default_account_mgr ()
51 {
52         fail_unless (gtk_init_check (NULL, NULL));
53
54         fail_unless (g_setenv (MODEST_DIR_ENV, ".modesttest", TRUE));
55         fail_unless (g_setenv (MODEST_NAMESPACE_ENV, "/apps/modesttest", TRUE));
56         fail_unless (modest_init (0, NULL), "Failed running modest_init");
57
58         account_mgr = modest_runtime_get_account_mgr ();
59         fail_unless (MODEST_IS_ACCOUNT_MGR (account_mgr),
60                      "modest_account_mgr_new failed");
61
62         /* cleanup old garbage (from previous runs)*/
63         if (modest_account_mgr_account_exists(account_mgr,
64                                               TEST_MODEST_ACCOUNT_NAME,
65                                               FALSE))
66                 modest_account_mgr_remove_account (account_mgr,
67                                                    TEST_MODEST_ACCOUNT_NAME);
68         if (modest_account_mgr_account_exists(account_mgr,
69                                               TEST_MODEST_ACCOUNT_NAME,
70                                               TRUE)) {
71                 modest_account_mgr_remove_server_account (account_mgr,
72                                                           TEST_MODEST_ACCOUNT_NAME);
73         }
74 }
75
76 /* ---------- add/exists/remove account tests  ---------- */
77
78 /**
79  * Test regular usage of 
80  * modest_account_mgr_add_account
81  * modest_account_mgr_add_server_account
82  * modest_account_mgr_account_exists
83  * modest_account_mgr_remove_account
84  *  - Test 1: Create anaccount
85  *  - Test 2: Check account exists
86  *  - Test 3: Remove account
87  *  - Test 4: Create a server account
88  *  - Test 5: Check server account exists
89  *  - Test 6: Remove server account
90  *  - Test 7: Check if a non-existing account exists
91  *  - Test 8: Check if a non-existing server account exists
92  */
93 START_TEST (test_add_exists_remove_account_regular)
94 {
95         gchar *name = NULL;
96         gchar *store_account = NULL;
97         gchar *transport_account = NULL;
98         gchar *hostname = NULL;
99         gchar *username = NULL;
100         gchar *password = NULL;
101         gint portnum;
102         ModestProtocolType proto;
103         gboolean result;
104         
105         name = g_strdup (TEST_MODEST_ACCOUNT_NAME);
106         /* Test 1 */
107         store_account = g_strdup ("imap://me@myserver");
108         transport_account = g_strdup ("local-smtp");
109         result = modest_account_mgr_add_account (account_mgr,
110                                                  name,
111                                                  "test display name",
112                                                  "user fullname",
113                                                  "user@email.com",
114                                                  MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY,
115                                                  store_account,
116                                                  transport_account, TRUE);
117         fail_unless (result,
118                      "modest_account_mgr_add_account failed:\n" \
119                      "name: %s\nstore: %s\ntransport: %s\n",
120                      name, store_account, transport_account, TRUE);
121         
122         g_free (store_account);
123         g_free (transport_account);
124
125         /* Test 2 */
126         result = modest_account_mgr_account_exists (account_mgr,
127                                                     name,
128                                                     FALSE);
129         fail_unless (result,
130                      "modest_account_mgr_account_exists failed: " \
131                      "Account with name \"%s\" should exist.\n", name);
132
133         /* Test 2b */
134         gchar *account_name_from_recipient;
135         account_name_from_recipient = modest_utils_get_account_name_from_recipient ("user@email.com");
136         fail_unless (account_name_from_recipient != NULL,
137                      "modest_utils_get_account_name_from_recipient failed: "\
138                      "From user@email.com should match account");
139         
140         /* Test 2c */
141         account_name_from_recipient = modest_utils_get_account_name_from_recipient ("egg@egg.com");
142         fail_unless (account_name_from_recipient == NULL,
143                      "modest_utils_get_account_name_from_recipient failed: "\
144                      "From egg@egg.com shouldn't match account");
145         
146
147         /* Test 3 */
148         result = modest_account_mgr_remove_account (account_mgr,
149                                                     name);
150         fail_unless (result,
151                      "modest_account_mgr_remove_account failed:\nname: %s\nerror: %s",
152                      name);
153
154
155         /* Test 4 */
156         hostname = g_strdup ("myhostname.mydomain.com");
157         username = g_strdup ("myusername");
158         password = g_strdup ("mypassword");
159         proto = MODEST_PROTOCOLS_TRANSPORT_SMTP;
160         portnum = 25;
161         result = modest_account_mgr_add_server_account (account_mgr,
162                                                         name,
163                                                         hostname,
164                                                         portnum,
165                                                         username,
166                                                         password,
167                                                         proto,
168                                                         MODEST_PROTOCOLS_CONNECTION_NONE,
169                                                         MODEST_PROTOCOLS_AUTH_NONE); 
170         fail_unless (result,
171                      "modest_account_mgr_add_server_account failed:\n" \
172                      "name: %s\nhostname: %s\nusername: %s\npassword: %s\nproto: %d",
173                      name, hostname, username, password, proto);
174
175         g_free (hostname);
176         g_free (username);
177         g_free (password);
178         
179         /* Test 5 */
180         result = modest_account_mgr_account_exists (account_mgr,name,TRUE);
181         fail_unless (result,
182                      "modest_account_mgr_account_exists failed: " \
183                      "Server account with name \"%s\" should exist. Error: %s", name);
184
185         /* Test 6 */
186         result = modest_account_mgr_remove_server_account (account_mgr,
187                                                            name);
188         fail_unless (result,
189                      "modest_account_mgr_remove_server_account failed:\nname: %s\nerror: %s",
190                      name);
191
192
193         /* Test 7 */
194         result = modest_account_mgr_account_exists (account_mgr,
195                                                     "a_name_that_does_not_exist",
196                                                     FALSE);
197         fail_unless (!result,
198                      "modest_account_mgr_exists_account does not return " \
199                      "FALSE when passing an account that does not exist");
200
201         /* Test 8 */
202         result = modest_account_mgr_account_exists (account_mgr,
203                                                     "a_name_that_does_not_exist",
204                                                     TRUE);
205         fail_unless (!result,
206                      "modest_account_mgr_exists_account does not return " \
207                      "FALSE when passing a server account that does not exist");
208         
209         g_free (name);
210 }
211 END_TEST
212
213 /**
214  * Test regular usage of 
215  * modest_account_mgr_add_account,
216  * modest_account_mgr_add_server_account
217  * modest_account_mgr_account_exists
218  * modest_account_mgr_remove_account
219  *  - Test 1: Create account with NULL account_mgr
220  *  - Test 2: Create account with NULL name
221  *  - Test 3: Create account with invalid name string
222  *  - Test 4: Create server account with NULL account_mgr
223  *  - Test 5: Create server account with NULL name
224  *  - Test 6: Create server account with invalid name string
225  *  - Test 7: Remove a non-existing account
226  *  - Test 8: Remove a non-existing server account (REMOVED)
227  *  - Test 9: Remove with NULL acount manager
228  *  - Test 10: Remove with NULL name
229  *  - Test 11: Check if an  account exists with NULL account_mgr
230  *  - Test 12: Check if a server account exists with a NULL account_mgr
231  *  - Test 13: Check if a NULL account exists
232  *  - Test 14: Check if a NULL server account exists
233  */
234 START_TEST (test_add_exists_remove_account_invalid)
235 {
236         gboolean result;
237
238         /* Test 1 */
239         result = modest_account_mgr_add_account (NULL,
240                                                  TEST_MODEST_ACCOUNT_NAME,
241                                                  "test display name",
242                                                  "user fullname",
243                                                  "user@email.com",
244                                                  MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY,
245                                                  "store_account",
246                                                  "transport_account", TRUE);
247         fail_unless (!result,
248                      "modest_account_mgr_add_account does not return FALSE when" \
249                      "passing a NULL ModestAccountMgr");
250
251         /* Test 2 */
252         result = modest_account_mgr_add_account (account_mgr,
253                                                  NULL,
254                                                  "test display name",
255                                                  "user fullname",
256                                                  "user@email.com",
257                                                  MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY,
258                                                  "store_account",
259                                                  "transport_account", TRUE);
260         fail_unless (!result,
261                      "modest_account_mgr_add_account does not return FALSE when" \
262                      "passing a NULL account name");
263
264         /* Test 3*/
265         result = modest_account_mgr_add_account (account_mgr,
266                                                  "ïnválid//accountñ//nÄméç",
267                                                  "test display name",
268                                                  "user fullname",
269                                                  "user@email.com",
270                                                  MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY,
271                                                  "store_account",
272                                                  "transport_account", TRUE);
273         fail_unless (!result,
274                      "modest_account_mgr_add_account does not return FALSE when" \
275                      "passing an invalid account name");
276
277         /* Test 4 */
278         result = modest_account_mgr_add_server_account (NULL,
279                                                         TEST_MODEST_ACCOUNT_NAME,
280                                                         "hostname",
281                                                         143,
282                                                         "username",
283                                                         "password",
284                                                         MODEST_PROTOCOLS_STORE_IMAP,
285                                                        MODEST_PROTOCOLS_CONNECTION_NONE,
286                                                        MODEST_PROTOCOLS_AUTH_NONE);
287         fail_unless (!result,
288                      "modest_account_mgr_add_server_account does not return " \
289                      "FALSE when passing a NULL ModestAccountMgr");
290
291         /* Test 5 */
292         result = modest_account_mgr_add_server_account (account_mgr,
293                                                         NULL,
294                                                         "hostname",
295                                                         143,
296                                                         "username",
297                                                         "password",
298                                                         MODEST_PROTOCOLS_STORE_IMAP,
299                                                         MODEST_PROTOCOLS_CONNECTION_NONE,
300                                                         MODEST_PROTOCOLS_AUTH_NONE); 
301         fail_unless (!result,
302                      "modest_account_mgr_add_server_account does not return " \
303                      "FALSE when passing a NULL account name");
304
305         /* Test 6 */
306         result = modest_account_mgr_add_server_account (account_mgr, 
307                                                         "ïnválid//accountñ//nÄméç",
308                                                         "hostname", 
309                                                         143,
310                                                         "username", 
311                                                         "password", 
312                                                         MODEST_PROTOCOLS_STORE_IMAP,
313                                                         MODEST_PROTOCOLS_CONNECTION_NONE,
314                                                         MODEST_PROTOCOLS_AUTH_NONE); 
315         fail_unless (!result, 
316                      "modest_account_mgr_add_server_account does not return " \
317                      "FALSE when passing an invalid account name"); 
318
319         /* Test 7 */
320         result = modest_account_mgr_remove_account (account_mgr,
321                                                     "a_name_that_does_not_exist");
322         fail_unless (!result,
323                      "modest_account_mgr_remove_acccount does not return FALSE " \
324                      "when trying to remove an account that does not exist");
325
326         /* Test 9 */
327         result = modest_account_mgr_remove_account (NULL,
328                                                     TEST_MODEST_ACCOUNT_NAME);
329         fail_unless (!result,
330                      "modest_account_mgr_remove_acccount does not return " \
331                      "FALSE when passing a NULL ModestAccountMgr");
332
333         /* Test 10 */
334         result = modest_account_mgr_remove_account (account_mgr,
335                                                     NULL);
336         fail_unless (!result,
337                      "modest_account_mgr_remove_acccount does not return " \
338                      "FALSE when passing a NULL account name");
339
340         /* Test 11 */
341         result = modest_account_mgr_account_exists (NULL,
342                                                     TEST_MODEST_ACCOUNT_NAME,
343                                                     TRUE);
344         fail_unless (!result,
345                      "modest_account_mgr_exists_account does not return " \
346                      "FALSE when passing a NULL ModestAccountMgr");
347
348         /* Test 12 */
349         result = modest_account_mgr_account_exists (NULL,
350                                                     TEST_MODEST_ACCOUNT_NAME,
351                                                     FALSE);
352         fail_unless (!result,
353                      "modest_account_mgr_exists_account does not return " \
354                      "FALSE when passing a NULL ModestAccountMgr");
355
356         /* Test 13 */
357         result = modest_account_mgr_account_exists (account_mgr,
358                                                     NULL,
359                                                     FALSE);
360         fail_unless (!result,
361                      "modest_account_mgr_exists_acccount does not return " \
362                      "FALSE when passing a NULL account name");
363
364         /* Test 14 */
365         result = modest_account_mgr_account_exists (account_mgr,
366                                                     NULL,
367                                                     TRUE);
368         fail_unless (!result,
369                      "modest_account_mgr_exists_account does not return " \
370                      "FALSE when passing a NULL server account name");
371 }
372 END_TEST
373
374 /* ------------------- Suite creation ------------------- */
375
376 static Suite*
377 account_mgr_suite (void)
378 {
379         Suite *suite = suite_create ("ModestAccountMgr");
380         TCase *tc = NULL;
381
382         /* Tests case for "add/exists/remove account" */
383         tc = tcase_create ("add_exists_remove_account");
384         tcase_add_checked_fixture (tc, 
385                                      fx_setup_default_account_mgr, NULL);
386         tcase_add_test (tc, test_add_exists_remove_account_regular);
387         tcase_add_test (tc, test_add_exists_remove_account_invalid);
388         suite_add_tcase (suite, tc);
389
390         return suite;
391 }
392
393 /* --------------------- Main program ------------------- */
394
395 gint
396 main ()
397 {
398         SRunner *srunner;
399         Suite   *suite;
400         int     failures;
401
402         suite   = account_mgr_suite ();
403         srunner = srunner_create (suite);
404         
405         srunner_run_all (srunner, CK_ENV);
406         failures = srunner_ntests_failed (srunner);
407         srunner_free (srunner);
408         
409         return failures;
410 }