← Back to branch summary

~ubuntu-branches/ubuntu/natty/empathy/natty-updates

« back to all changes in this revision

Viewing changes to tests/check-empathy-irc-network-manager.c

Tags: upstream-0.22.0
Import upstream version 0.22.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/check-empathy-irc-network-manager.c
 
1
#include <stdlib.h>
 
2
#include <stdio.h>
 
3
#include <string.h>
 
4
#include <glib/gstdio.h>
 
5
 
 
6
#include <check.h>
 
7
#include "check-helpers.h"
 
8
#include "check-libempathy.h"
 
9
#include "check-irc-helper.h"
 
10
 
 
11
#include <libempathy/empathy-irc-network-manager.h>
 
12
 
 
13
#define GLOBAL_SAMPLE "default-irc-networks-sample.xml"
 
14
#define USER_SAMPLE "user-irc-networks-sample.xml"
 
15
#define USER_FILE "user-irc-networks.xml"
 
16
 
 
17
static gchar *
 
18
get_xml_file (const gchar *filename)
 
19
{
 
20
  return g_build_filename (g_getenv ("EMPATHY_SRCDIR"), "tests", "xml", filename, NULL);
 
21
}
 
22
 
 
23
static gchar *
 
24
get_user_xml_file (const gchar *filename)
 
25
{
 
26
  return g_build_filename (g_get_tmp_dir (), filename, NULL);
 
27
}
 
28
 
 
29
START_TEST (test_empathy_irc_network_manager_add)
 
30
{
 
31
  EmpathyIrcNetworkManager *mgr;
 
32
  EmpathyIrcNetwork *network;
 
33
  GSList *networks;
 
34
  gchar *name;
 
35
 
 
36
  mgr = empathy_irc_network_manager_new (NULL, NULL);
 
37
  fail_if (mgr == NULL);
 
38
 
 
39
  networks = empathy_irc_network_manager_get_networks (mgr);
 
40
  fail_if (networks != NULL);
 
41
 
 
42
  /* add a network */
 
43
  network = empathy_irc_network_new ("My Network");
 
44
  fail_if (network == NULL);
 
45
  empathy_irc_network_manager_add (mgr, network);
 
46
  g_object_unref (network);
 
47
 
 
48
  networks = empathy_irc_network_manager_get_networks (mgr);
 
49
  fail_if (g_slist_length (networks) != 1);
 
50
  g_object_get (networks->data, "name", &name, NULL);
 
51
  fail_if (name == NULL || strcmp (name, "My Network") != 0);
 
52
  g_free (name);
 
53
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
54
  g_slist_free (networks);
 
55
 
 
56
  /* add another network having the same name */
 
57
  network = empathy_irc_network_new ("My Network");
 
58
  fail_if (network == NULL);
 
59
  empathy_irc_network_manager_add (mgr, network);
 
60
  g_object_unref (network);
 
61
 
 
62
  networks = empathy_irc_network_manager_get_networks (mgr);
 
63
  fail_if (g_slist_length (networks) != 2);
 
64
  g_object_get (networks->data, "name", &name, NULL);
 
65
  fail_if (name == NULL || strcmp (name, "My Network") != 0);
 
66
  g_free (name);
 
67
  g_object_get (g_slist_next(networks)->data, "name", &name, NULL);
 
68
  fail_if (name == NULL || strcmp (name, "My Network") != 0);
 
69
  g_free (name);
 
70
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
71
  g_slist_free (networks);
 
72
 
 
73
  g_object_unref (mgr);
 
74
}
 
75
END_TEST
 
76
 
 
77
START_TEST (test_load_global_file)
 
78
{
 
79
  EmpathyIrcNetworkManager *mgr;
 
80
  gchar *global_file, *user_file;
 
81
  GSList *networks, *l;
 
82
  struct server_t freenode_servers[] = {
 
83
    { "irc.freenode.net", 6667, FALSE },
 
84
    { "irc.eu.freenode.net", 6667, FALSE }};
 
85
  struct server_t gimpnet_servers[] = {
 
86
    { "irc.gimp.org", 6667, FALSE },
 
87
    { "irc.us.gimp.org", 6667, FALSE }};
 
88
  struct server_t test_servers[] = {
 
89
    { "irc.test.org", 6669, TRUE }};
 
90
  struct server_t undernet_servers[] = {
 
91
    { "eu.undernet.org", 6667, FALSE }};
 
92
  gboolean network_checked[4];
 
93
  gchar *global_file_orig;
 
94
 
 
95
  global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 
96
  mgr = empathy_irc_network_manager_new (global_file_orig, NULL);
 
97
 
 
98
  g_object_get (mgr,
 
99
      "global-file", &global_file,
 
100
      "user-file", &user_file,
 
101
      NULL);
 
102
  fail_if (global_file == NULL || strcmp (global_file, global_file_orig) != 0);
 
103
  fail_if (user_file != NULL);
 
104
  g_free (global_file);
 
105
  g_free (global_file_orig);
 
106
  g_free (user_file);
 
107
 
 
108
  networks = empathy_irc_network_manager_get_networks (mgr);
 
109
  fail_if (g_slist_length (networks) != 4);
 
110
 
 
111
  network_checked[0] = network_checked[1] = network_checked[2] =
 
112
    network_checked[3] = FALSE;
 
113
  /* check networks and servers */
 
114
  for (l = networks; l != NULL; l = g_slist_next (l))
 
115
    {
 
116
      gchar *name;
 
117
 
 
118
      g_object_get (l->data, "name", &name, NULL);
 
119
      fail_if (name == NULL);
 
120
 
 
121
      if (strcmp (name, "Freenode") == 0)
 
122
        {
 
123
          check_network (l->data, "Freenode", "UTF-8", freenode_servers, 2);
 
124
          network_checked[0] = TRUE;
 
125
        }
 
126
      else if (strcmp (name, "GIMPNet") == 0)
 
127
        {
 
128
          check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 2);
 
129
          network_checked[1] = TRUE;
 
130
        }
 
131
      else if (strcmp (name, "Test Server") == 0)
 
132
        {
 
133
          check_network (l->data, "Test Server", "ISO-8859-1", test_servers, 1);
 
134
          network_checked[2] = TRUE;
 
135
        }
 
136
      else if (strcmp (name, "Undernet") == 0)
 
137
        {
 
138
          check_network (l->data, "Undernet", "UTF-8", undernet_servers, 1);
 
139
          network_checked[3] = TRUE;
 
140
        }
 
141
      else
 
142
        {
 
143
          fail_if (TRUE);
 
144
        }
 
145
 
 
146
      g_free (name);
 
147
    }
 
148
  fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2] ||
 
149
      !network_checked[3]);
 
150
 
 
151
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
152
  g_slist_free (networks);
 
153
  g_object_unref (mgr);
 
154
}
 
155
END_TEST
 
156
 
 
157
static gboolean
 
158
remove_network_named (EmpathyIrcNetworkManager *mgr,
 
159
                      const gchar *network_name)
 
160
{
 
161
  GSList *networks, *l;
 
162
  gboolean removed = FALSE;
 
163
 
 
164
  networks = empathy_irc_network_manager_get_networks (mgr);
 
165
 
 
166
  /* check networks and servers */
 
167
  for (l = networks; l != NULL && !removed; l = g_slist_next (l))
 
168
    {
 
169
      EmpathyIrcNetwork *network = l->data;
 
170
      gchar *name;
 
171
 
 
172
      g_object_get (network, "name", &name, NULL);
 
173
      fail_if (name == NULL);
 
174
 
 
175
      if (strcmp (name, network_name) == 0)
 
176
        {
 
177
          empathy_irc_network_manager_remove (mgr, network);
 
178
          removed = TRUE;
 
179
        }
 
180
 
 
181
      g_free (name);
 
182
    }
 
183
 
 
184
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
185
  g_slist_free (networks);
 
186
 
 
187
  return removed;
 
188
}
 
189
 
 
190
START_TEST (test_empathy_irc_network_manager_remove)
 
191
{
 
192
  EmpathyIrcNetworkManager *mgr;
 
193
  GSList *networks, *l;
 
194
  struct server_t freenode_servers[] = {
 
195
    { "irc.freenode.net", 6667, FALSE },
 
196
    { "irc.eu.freenode.net", 6667, FALSE }};
 
197
  struct server_t test_servers[] = {
 
198
    { "irc.test.org", 6669, TRUE }};
 
199
  struct server_t undernet_servers[] = {
 
200
    { "eu.undernet.org", 6667, FALSE }};
 
201
  gboolean network_checked[3];
 
202
  gboolean result;
 
203
  gchar *global_file_orig;
 
204
 
 
205
  global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 
206
  mgr = empathy_irc_network_manager_new (global_file_orig, NULL);
 
207
  g_free (global_file_orig);
 
208
 
 
209
  result = remove_network_named (mgr, "GIMPNet");
 
210
  fail_if (!result);
 
211
 
 
212
  networks = empathy_irc_network_manager_get_networks (mgr);
 
213
  fail_if (g_slist_length (networks) != 3);
 
214
 
 
215
  network_checked[0] = network_checked[1] = network_checked[2] = FALSE;
 
216
  /* check networks and servers */
 
217
  for (l = networks; l != NULL; l = g_slist_next (l))
 
218
    {
 
219
      gchar *name;
 
220
 
 
221
      g_object_get (l->data, "name", &name, NULL);
 
222
      fail_if (name == NULL);
 
223
 
 
224
      if (strcmp (name, "Freenode") == 0)
 
225
        {
 
226
          check_network (l->data, "Freenode", "UTF-8", freenode_servers, 2);
 
227
          network_checked[0] = TRUE;
 
228
        }
 
229
      else if (strcmp (name, "Test Server") == 0)
 
230
        {
 
231
          check_network (l->data, "Test Server", "ISO-8859-1", test_servers, 1);
 
232
          network_checked[1] = TRUE;
 
233
        }
 
234
      else if (strcmp (name, "Undernet") == 0)
 
235
        {
 
236
          check_network (l->data, "Undernet", "UTF-8", undernet_servers, 1);
 
237
          network_checked[2] = TRUE;
 
238
        }
 
239
      else
 
240
        {
 
241
          fail_if (TRUE);
 
242
        }
 
243
 
 
244
      g_free (name);
 
245
    }
 
246
  fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2]);
 
247
 
 
248
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
249
  g_slist_free (networks);
 
250
  g_object_unref (mgr);
 
251
}
 
252
END_TEST
 
253
 
 
254
static void
 
255
copy_user_file (void)
 
256
{
 
257
  gboolean result;
 
258
  gchar *buffer;
 
259
  gsize length;
 
260
  gchar *user_sample;
 
261
  gchar *user_file;
 
262
 
 
263
  user_sample = get_xml_file (USER_SAMPLE);
 
264
  result = g_file_get_contents (user_sample, &buffer, &length, NULL);
 
265
  fail_if (!result);
 
266
 
 
267
  user_file = get_user_xml_file (USER_FILE);
 
268
  result = g_file_set_contents (user_file, buffer, length, NULL);
 
269
  fail_if (!result);
 
270
 
 
271
  g_free (user_sample);
 
272
  g_free (user_file);
 
273
  g_free (buffer);
 
274
}
 
275
 
 
276
START_TEST (test_load_user_file)
 
277
{
 
278
  EmpathyIrcNetworkManager *mgr;
 
279
  gchar *global_file, *user_file;
 
280
  GSList *networks, *l;
 
281
  struct server_t gimpnet_servers[] = {
 
282
    { "irc.gimp.org", 6667, FALSE },
 
283
    { "irc.us.gimp.org", 6667, FALSE },
 
284
    { "irc.au.gimp.org", 6667, FALSE }};
 
285
  struct server_t my_server[] = {
 
286
    { "irc.mysrv.net", 7495, TRUE }};
 
287
  struct server_t another_server[] = {
 
288
    { "irc.anothersrv.be", 6660, FALSE }};
 
289
  gboolean network_checked[3];
 
290
  gchar *user_file_orig;
 
291
 
 
292
  copy_user_file ();
 
293
  user_file_orig = get_user_xml_file (USER_FILE);
 
294
  mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
 
295
 
 
296
  g_object_get (mgr,
 
297
      "global-file", &global_file,
 
298
      "user-file", &user_file,
 
299
      NULL);
 
300
  fail_if (global_file != NULL);
 
301
  fail_if (user_file == NULL || strcmp (user_file, user_file_orig) != 0);
 
302
  g_free (global_file);
 
303
  g_free (user_file);
 
304
  g_free (user_file_orig);
 
305
 
 
306
  networks = empathy_irc_network_manager_get_networks (mgr);
 
307
  fail_if (g_slist_length (networks) != 3);
 
308
 
 
309
  network_checked[0] = network_checked[1] = network_checked[2] = FALSE;
 
310
  /* check networks and servers */
 
311
  for (l = networks; l != NULL; l = g_slist_next (l))
 
312
    {
 
313
      gchar *name;
 
314
 
 
315
      g_object_get (l->data, "name", &name, NULL);
 
316
      fail_if (name == NULL);
 
317
 
 
318
      if (strcmp (name, "GIMPNet") == 0)
 
319
        {
 
320
          check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 3);
 
321
          network_checked[0] = TRUE;
 
322
        }
 
323
      else if (strcmp (name, "My Server") == 0)
 
324
        {
 
325
          check_network (l->data, "My Server", "UTF-8", my_server, 1);
 
326
          network_checked[1] = TRUE;
 
327
        }
 
328
      else if (strcmp (name, "Another Server") == 0)
 
329
        {
 
330
          check_network (l->data, "Another Server", "UTF-8", another_server, 1);
 
331
          network_checked[2] = TRUE;
 
332
        }
 
333
      else
 
334
        {
 
335
          fail_if (TRUE);
 
336
        }
 
337
 
 
338
      g_free (name);
 
339
    }
 
340
  fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2]);
 
341
 
 
342
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
343
  g_slist_free (networks);
 
344
  g_object_unref (mgr);
 
345
}
 
346
END_TEST
 
347
 
 
348
START_TEST (test_load_both_files)
 
349
{
 
350
  EmpathyIrcNetworkManager *mgr;
 
351
  gchar *global_file, *user_file;
 
352
  GSList *networks, *l;
 
353
  struct server_t freenode_servers[] = {
 
354
    { "irc.freenode.net", 6667, FALSE },
 
355
    { "irc.eu.freenode.net", 6667, FALSE }};
 
356
  struct server_t gimpnet_servers[] = {
 
357
    { "irc.gimp.org", 6667, FALSE },
 
358
    { "irc.us.gimp.org", 6667, FALSE },
 
359
    { "irc.au.gimp.org", 6667, FALSE }};
 
360
  struct server_t my_server[] = {
 
361
    { "irc.mysrv.net", 7495, TRUE }};
 
362
  struct server_t another_server[] = {
 
363
    { "irc.anothersrv.be", 6660, FALSE }};
 
364
  struct server_t undernet_servers[] = {
 
365
    { "eu.undernet.org", 6667, FALSE }};
 
366
  gboolean network_checked[5];
 
367
  gchar *global_file_orig, *user_file_orig;
 
368
 
 
369
  global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 
370
  user_file_orig = get_user_xml_file (USER_FILE);
 
371
  mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
 
372
 
 
373
  g_object_get (mgr,
 
374
      "global-file", &global_file,
 
375
      "user-file", &user_file,
 
376
      NULL);
 
377
  fail_if (global_file == NULL || strcmp (global_file, global_file_orig) != 0);
 
378
  fail_if (user_file == NULL || strcmp (user_file, user_file_orig) != 0);
 
379
  g_free (global_file);
 
380
  g_free (global_file_orig);
 
381
  g_free (user_file);
 
382
  g_free (user_file_orig);
 
383
 
 
384
  networks = empathy_irc_network_manager_get_networks (mgr);
 
385
  fail_if (g_slist_length (networks) != 5);
 
386
 
 
387
  network_checked[0] = network_checked[1] = network_checked[2] =
 
388
    network_checked[3] = network_checked[4] = FALSE;
 
389
  /* check networks and servers */
 
390
  for (l = networks; l != NULL; l = g_slist_next (l))
 
391
    {
 
392
      gchar *name;
 
393
 
 
394
      g_object_get (l->data, "name", &name, NULL);
 
395
      fail_if (name == NULL);
 
396
 
 
397
      if (strcmp (name, "Freenode") == 0)
 
398
        {
 
399
          check_network (l->data, "Freenode", "UTF-8", freenode_servers, 2);
 
400
          network_checked[0] = TRUE;
 
401
        }
 
402
      else if (strcmp (name, "GIMPNet") == 0)
 
403
        {
 
404
          check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 3);
 
405
          network_checked[1] = TRUE;
 
406
        }
 
407
      else if (strcmp (name, "My Server") == 0)
 
408
        {
 
409
          check_network (l->data, "My Server", "UTF-8", my_server, 1);
 
410
          network_checked[2] = TRUE;
 
411
        }
 
412
      else if (strcmp (name, "Another Server") == 0)
 
413
        {
 
414
          check_network (l->data, "Another Server", "UTF-8", another_server, 1);
 
415
          network_checked[3] = TRUE;
 
416
        }
 
417
      else if (strcmp (name, "Undernet") == 0)
 
418
        {
 
419
          check_network (l->data, "Undernet", "UTF-8", undernet_servers, 1);
 
420
          network_checked[4] = TRUE;
 
421
        }
 
422
      else
 
423
        {
 
424
          fail_if (TRUE);
 
425
        }
 
426
 
 
427
      g_free (name);
 
428
    }
 
429
  fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2] ||
 
430
      !network_checked[3] || !network_checked[4]);
 
431
 
 
432
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
433
  g_slist_free (networks);
 
434
  g_object_unref (mgr);
 
435
}
 
436
END_TEST
 
437
 
 
438
START_TEST (test_modify_user_file)
 
439
{
 
440
  EmpathyIrcNetworkManager *mgr;
 
441
  EmpathyIrcNetwork *network;
 
442
  EmpathyIrcServer *server;
 
443
  gchar *global_file, *user_file;
 
444
  GSList *networks, *l;
 
445
  struct server_t gimpnet_servers[] = {
 
446
    { "irc.gimp.org", 6667, TRUE },
 
447
    { "irc.us.gimp.org", 6668, FALSE }};
 
448
  struct server_t great_server[] = {
 
449
    { "irc.greatserver.com", 7873, TRUE }};
 
450
  struct server_t another_server[] = {
 
451
    { "irc.anothersrv.be", 6660, FALSE }};
 
452
  gboolean network_modified[2];
 
453
  gboolean network_checked[3];
 
454
  gchar *user_file_orig;
 
455
 
 
456
  copy_user_file ();
 
457
  user_file_orig = get_user_xml_file (USER_FILE);
 
458
  mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
 
459
 
 
460
  g_object_get (mgr,
 
461
      "global-file", &global_file,
 
462
      "user-file", &user_file,
 
463
      NULL);
 
464
  fail_if (global_file != NULL);
 
465
  fail_if (user_file == NULL || strcmp (user_file, user_file_orig) != 0);
 
466
  g_free (global_file);
 
467
  g_free (user_file);
 
468
 
 
469
  networks = empathy_irc_network_manager_get_networks (mgr);
 
470
  fail_if (g_slist_length (networks) != 3);
 
471
 
 
472
  network_modified[0] = network_modified[1] = FALSE;
 
473
  /* check networks and servers */
 
474
  for (l = networks; l != NULL; l = g_slist_next (l))
 
475
    {
 
476
      EmpathyIrcNetwork *network;
 
477
      gchar *name;
 
478
 
 
479
      network = l->data;
 
480
      g_object_get (network, "name", &name, NULL);
 
481
      fail_if (name == NULL);
 
482
 
 
483
      if (strcmp (name, "GIMPNet") == 0)
 
484
        {
 
485
          GSList *servers, *ll;
 
486
 
 
487
          /* change charset */
 
488
          g_object_set (network, "charset", "ISO-8859-1", NULL);
 
489
 
 
490
          servers = empathy_irc_network_get_servers (network);
 
491
          for (ll = servers; ll != NULL; ll = g_slist_next (ll))
 
492
            {
 
493
              EmpathyIrcServer *server;
 
494
              gchar *address;
 
495
 
 
496
              server = ll->data;
 
497
              g_object_get (server, "address", &address, NULL);
 
498
              if (strcmp (address, "irc.gimp.org") == 0)
 
499
                {
 
500
                  /* change SSL */
 
501
                  g_object_set (server, "ssl", TRUE, NULL);
 
502
                }
 
503
              else if (strcmp (address, "irc.us.gimp.org") == 0)
 
504
                {
 
505
                  /* change port */
 
506
                  g_object_set (server, "port", 6668, NULL);
 
507
                }
 
508
              else if (strcmp (address, "irc.au.gimp.org") == 0)
 
509
                {
 
510
                  /* remove this server */
 
511
                  empathy_irc_network_remove_server (network, server);
 
512
                }
 
513
              else
 
514
                {
 
515
                  fail_if (TRUE);
 
516
                }
 
517
 
 
518
              g_free (address);
 
519
            }
 
520
 
 
521
          network_modified[0] = TRUE;
 
522
 
 
523
          g_slist_foreach (servers, (GFunc) g_object_unref, NULL);
 
524
          g_slist_free (servers);
 
525
        }
 
526
      else if (strcmp (name, "My Server") == 0)
 
527
        {
 
528
          /* remove this network */
 
529
          empathy_irc_network_manager_remove (mgr, network);
 
530
          network_modified[1] = TRUE;
 
531
        }
 
532
      else if (strcmp (name, "Another Server") == 0)
 
533
        {
 
534
          /* Don't change this one */
 
535
        }
 
536
      else
 
537
        {
 
538
          fail_if (TRUE);
 
539
        }
 
540
 
 
541
      g_free (name);
 
542
    }
 
543
  fail_if (!network_modified[0] || !network_modified[1]);
 
544
 
 
545
  /* Add a new network */
 
546
  network = empathy_irc_network_new ("Great Server");
 
547
  server = empathy_irc_server_new ("irc.greatserver.com", 7873, TRUE);
 
548
  empathy_irc_network_append_server (network, server);
 
549
  empathy_irc_network_manager_add (mgr, network);
 
550
  g_object_unref (server);
 
551
  g_object_unref (network);
 
552
 
 
553
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
554
  g_slist_free (networks);
 
555
  g_object_unref (mgr);
 
556
 
 
557
 
 
558
  /* Now let's reload the file and check its contain */
 
559
  mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
 
560
  g_free (user_file_orig);
 
561
 
 
562
  networks = empathy_irc_network_manager_get_networks (mgr);
 
563
  fail_if (g_slist_length (networks) != 3);
 
564
 
 
565
  network_checked[0] = network_checked[1] = network_checked[2] = FALSE;
 
566
  /* check networks and servers */
 
567
  for (l = networks; l != NULL; l = g_slist_next (l))
 
568
    {
 
569
      gchar *name;
 
570
 
 
571
      g_object_get (l->data, "name", &name, NULL);
 
572
      fail_if (name == NULL);
 
573
 
 
574
      if (strcmp (name, "GIMPNet") == 0)
 
575
        {
 
576
          check_network (l->data, "GIMPNet", "ISO-8859-1", gimpnet_servers, 2);
 
577
          network_checked[0] = TRUE;
 
578
        }
 
579
      else if (strcmp (name, "Great Server") == 0)
 
580
        {
 
581
          check_network (l->data, "Great Server", "UTF-8", great_server, 1);
 
582
          network_checked[1] = TRUE;
 
583
        }
 
584
      else if (strcmp (name, "Another Server") == 0)
 
585
        {
 
586
          check_network (l->data, "Another Server", "UTF-8", another_server, 1);
 
587
          network_checked[2] = TRUE;
 
588
        }
 
589
      else
 
590
        {
 
591
          fail_if (TRUE);
 
592
        }
 
593
 
 
594
      g_free (name);
 
595
    }
 
596
  fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2]);
 
597
 
 
598
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
599
  g_slist_free (networks);
 
600
  g_object_unref (mgr);
 
601
}
 
602
END_TEST
 
603
 
 
604
START_TEST (test_modify_both_files)
 
605
{
 
606
  EmpathyIrcNetworkManager *mgr;
 
607
  EmpathyIrcNetwork *network;
 
608
  EmpathyIrcServer *server;
 
609
  gchar *global_file, *user_file;
 
610
  GSList *networks, *l;
 
611
  struct server_t gimpnet_servers[] = {
 
612
    { "irc.gimp.org", 6667, TRUE },
 
613
    { "irc.us.gimp.org", 6668, FALSE }};
 
614
  struct server_t great_server[] = {
 
615
    { "irc.greatserver.com", 7873, TRUE }};
 
616
  struct server_t another_server[] = {
 
617
    { "irc.anothersrv.be", 6660, FALSE }};
 
618
  struct server_t undernet_servers[] = {
 
619
    { "eu.undernet.org", 6667, FALSE },
 
620
    { "us.undernet.org", 6667, FALSE }};
 
621
  gboolean network_modified[4];
 
622
  gboolean network_checked[4];
 
623
  gchar *global_file_orig, *user_file_orig;
 
624
 
 
625
  copy_user_file ();
 
626
  global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 
627
  user_file_orig = get_user_xml_file (USER_FILE);
 
628
  mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
 
629
 
 
630
  g_object_get (mgr,
 
631
      "global-file", &global_file,
 
632
      "user-file", &user_file,
 
633
      NULL);
 
634
  fail_if (global_file == NULL || strcmp (global_file, global_file_orig) != 0);
 
635
  fail_if (user_file == NULL || strcmp (user_file, user_file_orig) != 0);
 
636
  g_free (global_file);
 
637
  g_free (global_file_orig);
 
638
  g_free (user_file);
 
639
  g_free (user_file_orig);
 
640
 
 
641
  networks = empathy_irc_network_manager_get_networks (mgr);
 
642
  fail_if (g_slist_length (networks) != 5);
 
643
 
 
644
  network_modified[0] = network_modified[1] = network_modified[2] =
 
645
    network_modified[3] = FALSE;
 
646
  /* check networks and servers */
 
647
  for (l = networks; l != NULL; l = g_slist_next (l))
 
648
    {
 
649
      EmpathyIrcNetwork *network;
 
650
      gchar *name;
 
651
 
 
652
      network = l->data;
 
653
      g_object_get (network, "name", &name, NULL);
 
654
      fail_if (name == NULL);
 
655
 
 
656
      if (strcmp (name, "GIMPNet") == 0)
 
657
        {
 
658
          /* Modify user network */
 
659
          GSList *servers, *ll;
 
660
 
 
661
          servers = empathy_irc_network_get_servers (network);
 
662
          for (ll = servers; ll != NULL; ll = g_slist_next (ll))
 
663
            {
 
664
              EmpathyIrcServer *server;
 
665
              gchar *address;
 
666
 
 
667
              server = ll->data;
 
668
              g_object_get (server, "address", &address, NULL);
 
669
              if (strcmp (address, "irc.gimp.org") == 0)
 
670
                {
 
671
                  /* change SSL */
 
672
                  g_object_set (server, "ssl", TRUE, NULL);
 
673
                }
 
674
              else if (strcmp (address, "irc.us.gimp.org") == 0)
 
675
                {
 
676
                  /* change port */
 
677
                  g_object_set (server, "port", 6668, NULL);
 
678
                }
 
679
              else if (strcmp (address, "irc.au.gimp.org") == 0)
 
680
                {
 
681
                  /* remove this server */
 
682
                  empathy_irc_network_remove_server (network, server);
 
683
                }
 
684
              else
 
685
                {
 
686
                  fail_if (TRUE);
 
687
                }
 
688
 
 
689
              g_free (address);
 
690
            }
 
691
 
 
692
          network_modified[0] = TRUE;
 
693
 
 
694
          g_slist_foreach (servers, (GFunc) g_object_unref, NULL);
 
695
          g_slist_free (servers);
 
696
        }
 
697
      else if (strcmp (name, "My Server") == 0)
 
698
        {
 
699
          /* remove user network */
 
700
          empathy_irc_network_manager_remove (mgr, network);
 
701
          network_modified[1] = TRUE;
 
702
        }
 
703
      else if (strcmp (name, "Freenode") == 0)
 
704
        {
 
705
          /* remove global network */
 
706
          empathy_irc_network_manager_remove (mgr, network);
 
707
          network_modified[2] = TRUE;
 
708
        }
 
709
      else if (strcmp (name, "Undernet") == 0)
 
710
        {
 
711
          /* modify global network */
 
712
          EmpathyIrcServer *server;
 
713
 
 
714
          server = empathy_irc_server_new ("us.undernet.org", 6667, FALSE);
 
715
          empathy_irc_network_append_server (network, server);
 
716
          g_object_unref (server);
 
717
 
 
718
          network_modified[3] = TRUE;
 
719
        }
 
720
      else if (strcmp (name, "Another Server") == 0)
 
721
        {
 
722
          /* Don't change this one */
 
723
        }
 
724
      else
 
725
        {
 
726
          fail_if (TRUE);
 
727
        }
 
728
 
 
729
      g_free (name);
 
730
    }
 
731
  fail_if (!network_modified[0] || !network_modified[1] || !network_modified[2]
 
732
      || !network_modified[3]);
 
733
 
 
734
  /* Add a new network */
 
735
  network = empathy_irc_network_new ("Great Server");
 
736
  server = empathy_irc_server_new ("irc.greatserver.com", 7873, TRUE);
 
737
  empathy_irc_network_append_server (network, server);
 
738
  empathy_irc_network_manager_add (mgr, network);
 
739
  g_object_unref (server);
 
740
  g_object_unref (network);
 
741
 
 
742
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
743
  g_slist_free (networks);
 
744
  g_object_unref (mgr);
 
745
 
 
746
 
 
747
  /* Now let's reload the file and check its contain */
 
748
  global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 
749
  user_file_orig = get_user_xml_file (USER_FILE);
 
750
  mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
 
751
  g_free (global_file_orig);
 
752
  g_free (user_file_orig);
 
753
 
 
754
  networks = empathy_irc_network_manager_get_networks (mgr);
 
755
  fail_if (g_slist_length (networks) != 4);
 
756
 
 
757
  network_checked[0] = network_checked[1] = network_checked[2] =
 
758
    network_checked[3] = FALSE;
 
759
  /* check networks and servers */
 
760
  for (l = networks; l != NULL; l = g_slist_next (l))
 
761
    {
 
762
      gchar *name;
 
763
 
 
764
      g_object_get (l->data, "name", &name, NULL);
 
765
      fail_if (name == NULL);
 
766
 
 
767
      if (strcmp (name, "GIMPNet") == 0)
 
768
        {
 
769
          check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 2);
 
770
          network_checked[0] = TRUE;
 
771
        }
 
772
      else if (strcmp (name, "Great Server") == 0)
 
773
        {
 
774
          check_network (l->data, "Great Server", "UTF-8", great_server, 1);
 
775
          network_checked[1] = TRUE;
 
776
        }
 
777
      else if (strcmp (name, "Another Server") == 0)
 
778
        {
 
779
          check_network (l->data, "Another Server", "UTF-8", another_server, 1);
 
780
          network_checked[2] = TRUE;
 
781
        }
 
782
      else if (strcmp (name, "Undernet") == 0)
 
783
        {
 
784
          check_network (l->data, "Undernet", "UTF-8", undernet_servers, 2);
 
785
          network_checked[3] = TRUE;
 
786
        }
 
787
      else
 
788
        {
 
789
          fail_if (TRUE);
 
790
        }
 
791
 
 
792
      g_free (name);
 
793
    }
 
794
  fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2] ||
 
795
      !network_checked[3]);
 
796
 
 
797
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
798
  g_slist_free (networks);
 
799
  g_object_unref (mgr);
 
800
}
 
801
END_TEST
 
802
 
 
803
START_TEST (test_empathy_irc_network_manager_find_network_by_address)
 
804
{
 
805
  EmpathyIrcNetworkManager *mgr;
 
806
  EmpathyIrcNetwork *network;
 
807
  struct server_t freenode_servers[] = {
 
808
    { "irc.freenode.net", 6667, FALSE },
 
809
    { "irc.eu.freenode.net", 6667, FALSE }};
 
810
  gchar *global_file_orig;
 
811
 
 
812
  global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 
813
  mgr = empathy_irc_network_manager_new (global_file_orig, NULL);
 
814
  g_free (global_file_orig);
 
815
 
 
816
  network = empathy_irc_network_manager_find_network_by_address (mgr,
 
817
      "irc.freenode.net");
 
818
  fail_if (network == NULL);
 
819
  check_network (network, "Freenode", "UTF-8", freenode_servers, 2);
 
820
 
 
821
  network = empathy_irc_network_manager_find_network_by_address (mgr,
 
822
      "irc.eu.freenode.net");
 
823
  fail_if (network == NULL);
 
824
  check_network (network, "Freenode", "UTF-8", freenode_servers, 2);
 
825
 
 
826
  network = empathy_irc_network_manager_find_network_by_address (mgr,
 
827
      "unknown");
 
828
  fail_if (network != NULL);
 
829
 
 
830
  g_object_unref (mgr);
 
831
}
 
832
END_TEST
 
833
 
 
834
START_TEST (test_no_modify_with_empty_user_file)
 
835
{
 
836
  EmpathyIrcNetworkManager *mgr;
 
837
  GSList *networks;
 
838
  gchar *global_file_orig;
 
839
  gchar *user_file_orig;
 
840
 
 
841
  /* user don't have a networks file yet */
 
842
  user_file_orig = get_user_xml_file (USER_FILE);
 
843
  g_unlink (user_file_orig);
 
844
 
 
845
  global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 
846
  mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
 
847
  g_free (global_file_orig);
 
848
  g_object_unref (mgr);
 
849
 
 
850
  /* We didn't modify anything so USER_FILE should be empty */
 
851
  mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
 
852
  g_free (user_file_orig);
 
853
 
 
854
  networks = empathy_irc_network_manager_get_networks (mgr);
 
855
  fail_if (g_slist_length (networks) != 0);
 
856
 
 
857
  g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 
858
  g_slist_free (networks);
 
859
  g_object_unref (mgr);
 
860
}
 
861
END_TEST
 
862
 
 
863
TCase *
 
864
make_empathy_irc_network_manager_tcase (void)
 
865
{
 
866
    TCase *tc = tcase_create ("empathy-irc-network-manager");
 
867
    tcase_add_test (tc, test_empathy_irc_network_manager_add);
 
868
    tcase_add_test (tc, test_load_global_file);
 
869
    tcase_add_test (tc, test_empathy_irc_network_manager_remove);
 
870
    tcase_add_test (tc, test_load_user_file);
 
871
    tcase_add_test (tc, test_load_both_files);
 
872
    tcase_add_test (tc, test_modify_user_file);
 
873
    tcase_add_test (tc, test_modify_both_files);
 
874
    tcase_add_test (tc, test_empathy_irc_network_manager_find_network_by_address);
 
875
    tcase_add_test (tc, test_no_modify_with_empty_user_file);
 
876
    return tc;
 
877
}