← Back to branch summary

~ubuntu-branches/ubuntu/wily/dovecot/wily

« back to all changes in this revision

Viewing changes to src/doveadm/dsync/test-dsync-brain.c

  • Committer: Package Import Robot
  • Author(s): Jaldhar H. Vyas
  • Date: 2013-09-09 00:57:32 UTC
  • mfrom: (1.13.11)
  • mto: (4.8.5 experimental) (1.16.1)
  • mto: This revision was merged to the branch mainline in revision 97.
  • Revision ID: package-import@ubuntu.com-20130909005732-dn1eell8srqbhh0e
Tags: upstream-2.2.5
Import upstream version 2.2.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/doveadm/dsync/test-dsync-brain.c
1
 
/* Copyright (c) 2009-2012 Dovecot authors, see the included COPYING file */
2
 
 
3
 
#include "lib.h"
4
 
#include "array.h"
5
 
#include "dsync-brain-private.h"
6
 
#include "test-dsync-worker.h"
7
 
#include "test-dsync-common.h"
8
 
 
9
 
struct master_service *master_service;
10
 
static struct test_dsync_worker *src_test_worker, *dest_test_worker;
11
 
 
12
 
struct dsync_brain_mailbox_sync *
13
 
dsync_brain_msg_sync_init(struct dsync_brain *brain,
14
 
                          const ARRAY_TYPE(dsync_brain_mailbox) *mailboxes)
15
 
{
16
 
        struct dsync_brain_mailbox_sync *sync;
17
 
 
18
 
        sync = i_new(struct dsync_brain_mailbox_sync, 1);
19
 
        sync->brain = brain;
20
 
        i_array_init(&sync->mailboxes, array_count(mailboxes));
21
 
        array_append_array(&sync->mailboxes, mailboxes);
22
 
        return sync;
23
 
}
24
 
void dsync_brain_msg_sync_more(struct dsync_brain_mailbox_sync *sync ATTR_UNUSED) {}
25
 
 
26
 
void dsync_brain_msg_sync_deinit(struct dsync_brain_mailbox_sync **_sync)
27
 
{
28
 
        array_free(&(*_sync)->mailboxes);
29
 
        i_free(*_sync);
30
 
}
31
 
 
32
 
static void mailboxes_set_guids(struct dsync_mailbox *boxes)
33
 
{
34
 
        for (; boxes->name != NULL; boxes++) {
35
 
                dsync_str_sha_to_guid(t_strconcat("box-", boxes->name, NULL),
36
 
                                      &boxes->mailbox_guid);
37
 
                dsync_str_sha_to_guid(boxes->name, &boxes->name_sha1);
38
 
        }
39
 
}
40
 
 
41
 
static void mailboxes_send_to_worker(struct test_dsync_worker *test_worker,
42
 
                                     struct dsync_mailbox *boxes)
43
 
{
44
 
        unsigned int i;
45
 
 
46
 
        for (i = 0; boxes[i].name != NULL; i++) {
47
 
                test_worker->box_iter.next_box = &boxes[i];
48
 
                test_worker->worker.input_callback(test_worker->worker.input_context);
49
 
        }
50
 
        test_worker->box_iter.last = TRUE;
51
 
        test_worker->worker.input_callback(test_worker->worker.input_context);
52
 
}
53
 
 
54
 
static void subscriptions_send_to_worker(struct test_dsync_worker *test_worker)
55
 
{
56
 
        test_worker->subs_iter.last_subs = TRUE;
57
 
        test_worker->subs_iter.last_unsubs = TRUE;
58
 
        test_worker->worker.input_callback(test_worker->worker.input_context);
59
 
}
60
 
 
61
 
static bool
62
 
test_dsync_mailbox_create_equals(const struct dsync_mailbox *cbox,
63
 
                                 const struct dsync_mailbox *obox)
64
 
{
65
 
        return strcmp(cbox->name, obox->name) == 0 &&
66
 
                memcmp(cbox->mailbox_guid.guid, obox->mailbox_guid.guid,
67
 
                       sizeof(cbox->mailbox_guid.guid)) == 0 &&
68
 
                memcmp(cbox->name_sha1.guid, obox->name_sha1.guid,
69
 
                       sizeof(cbox->name_sha1.guid)) == 0 &&
70
 
                cbox->uid_validity == obox->uid_validity &&
71
 
                cbox->uid_next == 1 && cbox->highest_modseq == 0;
72
 
}
73
 
 
74
 
static bool
75
 
test_dsync_mailbox_delete_equals(const struct dsync_mailbox *dbox,
76
 
                                 const struct dsync_mailbox *obox)
77
 
{
78
 
        return memcmp(dbox->mailbox_guid.guid, obox->mailbox_guid.guid,
79
 
                      sizeof(dbox->mailbox_guid.guid)) == 0 &&
80
 
                dbox->last_change == obox->last_change;
81
 
}
82
 
 
83
 
static void
84
 
test_dsync_mailbox_update(const struct dsync_mailbox *bbox,
85
 
                          const struct dsync_mailbox *box)
86
 
{
87
 
        struct test_dsync_box_event src_event, dest_event;
88
 
 
89
 
        test_assert(test_dsync_worker_next_box_event(src_test_worker, &src_event));
90
 
        test_assert(test_dsync_worker_next_box_event(dest_test_worker, &dest_event));
91
 
        test_assert(src_event.type == dest_event.type &&
92
 
                    dsync_mailboxes_equal(&src_event.box, &dest_event.box));
93
 
 
94
 
        test_assert(src_event.type == LAST_BOX_TYPE_UPDATE);
95
 
        test_assert(dsync_mailboxes_equal(&src_event.box, box));
96
 
        test_assert(dsync_mailboxes_equal(bbox, box));
97
 
}
98
 
 
99
 
static int
100
 
dsync_brain_mailbox_name_cmp(const struct dsync_brain_mailbox *box1,
101
 
                             const struct dsync_brain_mailbox *box2)
102
 
{
103
 
        return strcmp(box1->box.name, box2->box.name);
104
 
}
105
 
 
106
 
static void test_dsync_brain(void)
107
 
{
108
 
        static struct dsync_mailbox src_boxes[] = {
109
 
                { "box1", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
110
 
                { "box2", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
111
 
                { "box3", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
112
 
                { "box4", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
113
 
                { "box5", '/', { { 0, } }, { { 0, } }, 1234567890, 5433, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
114
 
                { "box6", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123124ULL, 3636, 0, ARRAY_INIT },
115
 
                { "boxx", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
116
 
                { "boxd1", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
117
 
                { "boxd2", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, DSYNC_MAILBOX_FLAG_DELETED_MAILBOX, ARRAY_INIT },
118
 
                { NULL, 0, { { 0, } }, { { 0, } }, 0, 0, 0, 0, 0, 0, 0, ARRAY_INIT }
119
 
        };
120
 
        static struct dsync_mailbox dest_boxes[] = {
121
 
                { "box1", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
122
 
                { "box2", '/', { { 0, } }, { { 0, } }, 1234567891, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
123
 
                { "box3", '/', { { 0, } }, { { 0, } }, 1234567890, 5433, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
124
 
                { "box4", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123124ULL, 3636, 0, ARRAY_INIT },
125
 
                { "box5", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
126
 
                { "box6", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
127
 
                { "boxy", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
128
 
                { "boxd1", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, DSYNC_MAILBOX_FLAG_DELETED_MAILBOX, ARRAY_INIT },
129
 
                { "boxd2", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 3636, 0, ARRAY_INIT },
130
 
                { NULL, 0, { { 0, } }, { { 0, } }, 0, 0, 0, 0, 0, 0, 0, ARRAY_INIT }
131
 
        };
132
 
        struct dsync_brain *brain;
133
 
        struct dsync_worker *src_worker, *dest_worker;
134
 
        struct test_dsync_box_event box_event;
135
 
        const struct dsync_brain_mailbox *brain_boxes;
136
 
        unsigned int i, count;
137
 
 
138
 
        test_begin("dsync brain");
139
 
 
140
 
        mailboxes_set_guids(src_boxes);
141
 
        mailboxes_set_guids(dest_boxes);
142
 
 
143
 
        src_worker = dsync_worker_init_test();
144
 
        dest_worker = dsync_worker_init_test();
145
 
        src_test_worker = (struct test_dsync_worker *)src_worker;
146
 
        dest_test_worker = (struct test_dsync_worker *)dest_worker;
147
 
 
148
 
        brain = dsync_brain_init(src_worker, dest_worker, NULL,
149
 
                                 DSYNC_BRAIN_FLAG_LOCAL);
150
 
        dsync_brain_sync(brain);
151
 
 
152
 
        /* have brain read the mailboxes */
153
 
        mailboxes_send_to_worker(src_test_worker, src_boxes);
154
 
        mailboxes_send_to_worker(dest_test_worker, dest_boxes);
155
 
 
156
 
        subscriptions_send_to_worker(src_test_worker);
157
 
        subscriptions_send_to_worker(dest_test_worker);
158
 
 
159
 
        test_assert(brain->state == DSYNC_STATE_SYNC_MSGS);
160
 
 
161
 
        /* check that it created/deleted missing mailboxes */
162
 
        test_assert(test_dsync_worker_next_box_event(dest_test_worker, &box_event));
163
 
        test_assert(box_event.type == LAST_BOX_TYPE_DELETE);
164
 
        test_assert(test_dsync_mailbox_delete_equals(&box_event.box, &dest_boxes[8]));
165
 
 
166
 
        test_assert(test_dsync_worker_next_box_event(src_test_worker, &box_event));
167
 
        test_assert(box_event.type == LAST_BOX_TYPE_DELETE);
168
 
        test_assert(test_dsync_mailbox_delete_equals(&box_event.box, &src_boxes[7]));
169
 
 
170
 
        test_assert(test_dsync_worker_next_box_event(dest_test_worker, &box_event));
171
 
        test_assert(box_event.type == LAST_BOX_TYPE_CREATE);
172
 
        test_assert(test_dsync_mailbox_create_equals(&box_event.box, &src_boxes[6]));
173
 
 
174
 
        test_assert(test_dsync_worker_next_box_event(src_test_worker, &box_event));
175
 
        test_assert(box_event.type == LAST_BOX_TYPE_CREATE);
176
 
        test_assert(test_dsync_mailbox_create_equals(&box_event.box, &dest_boxes[6]));
177
 
 
178
 
        test_assert(!test_dsync_worker_next_box_event(src_test_worker, &box_event));
179
 
        test_assert(!test_dsync_worker_next_box_event(dest_test_worker, &box_event));
180
 
 
181
 
        array_sort(&brain->mailbox_sync->mailboxes,
182
 
                   dsync_brain_mailbox_name_cmp);
183
 
 
184
 
        /* check mailbox updates */
185
 
        brain->state++;
186
 
        dsync_brain_sync(brain);
187
 
        test_assert(brain->state == DSYNC_STATE_SYNC_UPDATE_MAILBOXES);
188
 
        dsync_brain_sync(brain);
189
 
        test_assert(brain->state == DSYNC_STATE_SYNC_END);
190
 
 
191
 
        brain_boxes = array_get(&brain->mailbox_sync->mailboxes, &count);
192
 
        test_assert(count == 7);
193
 
        for (i = 0; i < 5; i++) {
194
 
                test_assert(dsync_mailboxes_equal(brain_boxes[i].src, &src_boxes[i+1]));
195
 
                test_assert(dsync_mailboxes_equal(brain_boxes[i].dest, &dest_boxes[i+1]));
196
 
        }
197
 
        test_assert(dsync_mailboxes_equal(brain_boxes[5].src, &src_boxes[6]));
198
 
        test_assert(brain_boxes[5].dest == NULL);
199
 
        test_assert(brain_boxes[6].src == NULL);
200
 
        test_assert(dsync_mailboxes_equal(brain_boxes[6].dest, &dest_boxes[6]));
201
 
 
202
 
        test_dsync_mailbox_update(&brain_boxes[0].box, &src_boxes[1]);
203
 
        test_dsync_mailbox_update(&brain_boxes[1].box, &dest_boxes[2]);
204
 
        test_dsync_mailbox_update(&brain_boxes[2].box, &dest_boxes[3]);
205
 
        test_dsync_mailbox_update(&brain_boxes[3].box, &src_boxes[4]);
206
 
        test_dsync_mailbox_update(&brain_boxes[4].box, &src_boxes[5]);
207
 
        test_dsync_mailbox_update(&brain_boxes[5].box, &src_boxes[6]);
208
 
        test_dsync_mailbox_update(&brain_boxes[6].box, &dest_boxes[6]);
209
 
 
210
 
        test_assert(!test_dsync_worker_next_box_event(src_test_worker, &box_event));
211
 
        test_assert(!test_dsync_worker_next_box_event(dest_test_worker, &box_event));
212
 
 
213
 
        dsync_brain_deinit(&brain);
214
 
        dsync_worker_deinit(&src_worker);
215
 
        dsync_worker_deinit(&dest_worker);
216
 
 
217
 
        test_end();
218
 
}
219
 
 
220
 
static void test_dsync_brain_full(void)
221
 
{
222
 
        static struct dsync_mailbox boxes[] = {
223
 
                { "box1", '/', { { 0, } }, { { 0, } }, 1234567890, 5432, 0, 1, 123123123123ULL, 2352, 0, ARRAY_INIT },
224
 
                { NULL, 0, { { 0, } }, { { 0, } }, 0, 0, 0, 0, 0, 0, 0, ARRAY_INIT }
225
 
        };
226
 
        struct dsync_brain *brain;
227
 
        struct dsync_worker *src_worker, *dest_worker;
228
 
        struct test_dsync_box_event box_event;
229
 
        const struct dsync_brain_mailbox *brain_boxes;
230
 
        unsigned int count;
231
 
 
232
 
        test_begin("dsync brain full");
233
 
 
234
 
        mailboxes_set_guids(boxes);
235
 
 
236
 
        src_worker = dsync_worker_init_test();
237
 
        dest_worker = dsync_worker_init_test();
238
 
        src_test_worker = (struct test_dsync_worker *)src_worker;
239
 
        dest_test_worker = (struct test_dsync_worker *)dest_worker;
240
 
 
241
 
        brain = dsync_brain_init(src_worker, dest_worker, NULL,
242
 
                                 DSYNC_BRAIN_FLAG_FULL_SYNC |
243
 
                                 DSYNC_BRAIN_FLAG_LOCAL);
244
 
        dsync_brain_sync(brain);
245
 
 
246
 
        /* have brain read the mailboxes */
247
 
        mailboxes_send_to_worker(src_test_worker, boxes);
248
 
        mailboxes_send_to_worker(dest_test_worker, boxes);
249
 
 
250
 
        subscriptions_send_to_worker(src_test_worker);
251
 
        subscriptions_send_to_worker(dest_test_worker);
252
 
 
253
 
        test_assert(brain->state == DSYNC_STATE_SYNC_MSGS);
254
 
 
255
 
        test_assert(!test_dsync_worker_next_box_event(src_test_worker, &box_event));
256
 
        test_assert(!test_dsync_worker_next_box_event(dest_test_worker, &box_event));
257
 
 
258
 
        /* check mailbox updates */
259
 
        brain->state++;
260
 
        dsync_brain_sync(brain);
261
 
        test_assert(brain->state == DSYNC_STATE_SYNC_UPDATE_MAILBOXES);
262
 
        dsync_brain_sync(brain);
263
 
        test_assert(brain->state == DSYNC_STATE_SYNC_END);
264
 
 
265
 
        brain_boxes = array_get(&brain->mailbox_sync->mailboxes, &count);
266
 
        test_assert(count == 1);
267
 
        test_assert(dsync_mailboxes_equal(brain_boxes[0].src, &boxes[0]));
268
 
        test_assert(dsync_mailboxes_equal(brain_boxes[0].dest, &boxes[0]));
269
 
        test_dsync_mailbox_update(&brain_boxes[0].box, &boxes[0]);
270
 
 
271
 
        test_assert(!test_dsync_worker_next_box_event(src_test_worker, &box_event));
272
 
        test_assert(!test_dsync_worker_next_box_event(dest_test_worker, &box_event));
273
 
 
274
 
        dsync_brain_deinit(&brain);
275
 
        dsync_worker_deinit(&src_worker);
276
 
        dsync_worker_deinit(&dest_worker);
277
 
 
278
 
        test_end();
279
 
}
280
 
 
281
 
int main(void)
282
 
{
283
 
        static void (*test_functions[])(void) = {
284
 
                test_dsync_brain,
285
 
                test_dsync_brain_full,
286
 
                NULL
287
 
        };
288
 
        return test_run(test_functions);
289
 
}