Add vtable and methods for to_json and to_ami for Stasis messages
[asterisk/asterisk.git] / tests / test_stasis.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * David M. Lee, II <dlee@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file \brief Test Stasis message bus.
21  *
22  * \author\verbatim David M. Lee, II <dlee@digium.com> \endverbatim
23  *
24  * \ingroup tests
25  */
26
27 /*** MODULEINFO
28         <depend>TEST_FRAMEWORK</depend>
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
35
36 #include "asterisk/astobj2.h"
37 #include "asterisk/module.h"
38 #include "asterisk/stasis.h"
39 #include "asterisk/stasis_message_router.h"
40 #include "asterisk/test.h"
41
42 static const char *test_category = "/stasis/core/";
43
44 static struct ast_json *fake_json(struct stasis_message *message)
45 {
46         const char *text = stasis_message_data(message);
47
48         return ast_json_string_create(text);
49 }
50
51 static struct ast_manager_event_blob *fake_ami(struct stasis_message *message)
52 {
53         RAII_VAR(struct ast_manager_event_blob *, res, NULL, ao2_cleanup);
54         const char *text = stasis_message_data(message);
55
56         res = ast_manager_event_blob_create(EVENT_FLAG_TEST, "FakeMI",
57                 "Message: %s", text);
58
59         if (res == NULL) {
60                 return NULL;
61         }
62
63         ao2_ref(res, +1);
64         return res;
65 }
66
67 static struct stasis_message_vtable fake_vtable = {
68         .to_json = fake_json,
69         .to_ami = fake_ami
70 };
71
72 AST_TEST_DEFINE(message_type)
73 {
74         RAII_VAR(struct stasis_message_type *, uut, NULL, ao2_cleanup);
75
76         switch (cmd) {
77         case TEST_INIT:
78                 info->name = __func__;
79                 info->category = test_category;
80                 info->summary = "Test basic message_type functions";
81                 info->description = "Test basic message_type functions";
82                 return AST_TEST_NOT_RUN;
83         case TEST_EXECUTE:
84                 break;
85         }
86
87         ast_test_validate(test, NULL == stasis_message_type_create(NULL, NULL));
88         uut = stasis_message_type_create("SomeMessage", NULL);
89         ast_test_validate(test, 0 == strcmp(stasis_message_type_name(uut), "SomeMessage"));
90
91         return AST_TEST_PASS;
92 }
93
94 AST_TEST_DEFINE(message)
95 {
96         RAII_VAR(struct stasis_message_type *, type, NULL, ao2_cleanup);
97         RAII_VAR(struct stasis_message *, uut, NULL, ao2_cleanup);
98         RAII_VAR(char *, data, NULL, ao2_cleanup);
99         char *expected = "SomeData";
100         struct timeval expected_timestamp;
101         struct timeval time_diff;
102
103         switch (cmd) {
104         case TEST_INIT:
105                 info->name = __func__;
106                 info->category = test_category;
107                 info->summary = "Test basic message functions";
108                 info->description = "Test basic message functions";
109                 return AST_TEST_NOT_RUN;
110         case TEST_EXECUTE:
111                 break;
112         }
113
114
115         type = stasis_message_type_create("SomeMessage", NULL);
116
117         ast_test_validate(test, NULL == stasis_message_create(NULL, NULL));
118         ast_test_validate(test, NULL == stasis_message_create(type, NULL));
119
120         data = ao2_alloc(strlen(expected) + 1, NULL);
121         strcpy(data, expected);
122         expected_timestamp = ast_tvnow();
123         uut = stasis_message_create(type, data);
124
125         ast_test_validate(test, NULL != uut);
126         ast_test_validate(test, type == stasis_message_type(uut));
127         ast_test_validate(test, 0 == strcmp(expected, stasis_message_data(uut)));
128         ast_test_validate(test, 2 == ao2_ref(data, 0)); /* uut has ref to data */
129
130         time_diff = ast_tvsub(*stasis_message_timestamp(uut), expected_timestamp);
131         /* 10ms is certainly long enough for the two calls to complete */
132         ast_test_validate(test, time_diff.tv_sec == 0);
133         ast_test_validate(test, time_diff.tv_usec < 10000);
134
135         ao2_ref(uut, -1);
136         uut = NULL;
137         ast_test_validate(test, 1 == ao2_ref(data, 0)); /* uut unreffed data */
138
139         return AST_TEST_PASS;
140 }
141
142 struct consumer {
143         ast_mutex_t lock;
144         ast_cond_t out;
145         struct stasis_message **messages_rxed;
146         size_t messages_rxed_len;
147         int ignore_subscriptions;
148         int complete;
149 };
150
151 static void consumer_dtor(void *obj) {
152         struct consumer *consumer = obj;
153
154         ast_mutex_destroy(&consumer->lock);
155         ast_cond_destroy(&consumer->out);
156
157         while (consumer->messages_rxed_len > 0) {
158                 ao2_cleanup(consumer->messages_rxed[--consumer->messages_rxed_len]);
159         }
160         ast_free(consumer->messages_rxed);
161         consumer->messages_rxed = NULL;
162 }
163
164 static struct consumer *consumer_create(int ignore_subscriptions) {
165         RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
166
167         consumer = ao2_alloc(sizeof(*consumer), consumer_dtor);
168
169         if (!consumer) {
170                 return NULL;
171         }
172
173         consumer->ignore_subscriptions = ignore_subscriptions;
174         consumer->messages_rxed = ast_malloc(0);
175         if (!consumer->messages_rxed) {
176                 return NULL;
177         }
178
179         ast_mutex_init(&consumer->lock);
180         ast_cond_init(&consumer->out, NULL);
181
182         ao2_ref(consumer, +1);
183         return consumer;
184 }
185
186 static void consumer_exec(void *data, struct stasis_subscription *sub, struct stasis_topic *topic, struct stasis_message *message)
187 {
188         struct consumer *consumer = data;
189         RAII_VAR(struct consumer *, consumer_needs_cleanup, NULL, ao2_cleanup);
190         SCOPED_MUTEX(lock, &consumer->lock);
191
192         if (!consumer->ignore_subscriptions || stasis_message_type(message) != stasis_subscription_change_type()) {
193
194                 ++consumer->messages_rxed_len;
195                 consumer->messages_rxed = ast_realloc(consumer->messages_rxed, sizeof(*consumer->messages_rxed) * consumer->messages_rxed_len);
196                 ast_assert(consumer->messages_rxed != NULL);
197                 consumer->messages_rxed[consumer->messages_rxed_len - 1] = message;
198                 ao2_ref(message, +1);
199         }
200
201         if (stasis_subscription_final_message(sub, message)) {
202                 consumer->complete = 1;
203                 consumer_needs_cleanup = consumer;
204         }
205
206         ast_cond_signal(&consumer->out);
207 }
208
209 static int consumer_wait_for(struct consumer *consumer, size_t expected_len)
210 {
211         struct timeval start = ast_tvnow();
212         struct timespec end = {
213                 .tv_sec = start.tv_sec + 30,
214                 .tv_nsec = start.tv_usec * 1000
215         };
216
217         SCOPED_MUTEX(lock, &consumer->lock);
218
219         while (consumer->messages_rxed_len < expected_len) {
220                 int r = ast_cond_timedwait(&consumer->out, &consumer->lock, &end);
221                 if (r == ETIMEDOUT) {
222                         break;
223                 }
224                 ast_assert(r == 0); /* Not expecting any othet types of errors */
225         }
226         return consumer->messages_rxed_len;
227 }
228
229 static int consumer_wait_for_completion(struct consumer *consumer)
230 {
231         struct timeval start = ast_tvnow();
232         struct timespec end = {
233                 .tv_sec = start.tv_sec + 30,
234                 .tv_nsec = start.tv_usec * 1000
235         };
236
237         SCOPED_MUTEX(lock, &consumer->lock);
238
239         while (!consumer->complete) {
240                 int r = ast_cond_timedwait(&consumer->out, &consumer->lock, &end);
241                 if (r == ETIMEDOUT) {
242                         break;
243                 }
244                 ast_assert(r == 0); /* Not expecting any othet types of errors */
245         }
246         return consumer->complete;
247 }
248
249 static int consumer_should_stay(struct consumer *consumer, size_t expected_len)
250 {
251         struct timeval start = ast_tvnow();
252         struct timeval diff = {
253                 .tv_sec = 0,
254                 .tv_usec = 100000 /* wait for 100ms */
255         };
256         struct timeval end_tv = ast_tvadd(start, diff);
257         struct timespec end = {
258                 .tv_sec = end_tv.tv_sec,
259                 .tv_nsec = end_tv.tv_usec * 1000
260         };
261
262         SCOPED_MUTEX(lock, &consumer->lock);
263
264         while (consumer->messages_rxed_len == expected_len) {
265                 int r = ast_cond_timedwait(&consumer->out, &consumer->lock, &end);
266                 if (r == ETIMEDOUT) {
267                         break;
268                 }
269                 ast_assert(r == 0); /* Not expecting any othet types of errors */
270         }
271         return consumer->messages_rxed_len;
272 }
273
274 AST_TEST_DEFINE(subscription_messages)
275 {
276         RAII_VAR(struct stasis_topic *, topic, NULL, ao2_cleanup);
277         RAII_VAR(struct stasis_subscription *, uut, NULL, stasis_unsubscribe);
278         RAII_VAR(char *, test_data, NULL, ao2_cleanup);
279         RAII_VAR(struct stasis_message_type *, test_message_type, NULL, ao2_cleanup);
280         RAII_VAR(struct stasis_message *, test_message, NULL, ao2_cleanup);
281         RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
282         RAII_VAR(char *, expected_uniqueid, NULL, ast_free);
283         int complete;
284         struct stasis_subscription_change *change;
285
286         switch (cmd) {
287         case TEST_INIT:
288                 info->name = __func__;
289                 info->category = test_category;
290                 info->summary = "Test subscribe/unsubscribe messages";
291                 info->description = "Test subscribe/unsubscribe messages";
292                 return AST_TEST_NOT_RUN;
293         case TEST_EXECUTE:
294                 break;
295         }
296
297         topic = stasis_topic_create("TestTopic");
298         ast_test_validate(test, NULL != topic);
299
300         consumer = consumer_create(0);
301         ast_test_validate(test, NULL != consumer);
302
303         uut = stasis_subscribe(topic, consumer_exec, consumer);
304         ast_test_validate(test, NULL != uut);
305         ao2_ref(consumer, +1);
306         expected_uniqueid = ast_strdup(stasis_subscription_uniqueid(uut));
307
308         uut = stasis_unsubscribe(uut);
309         complete = consumer_wait_for_completion(consumer);
310         ast_test_validate(test, 1 == complete);
311
312         ast_test_validate(test, 2 == consumer->messages_rxed_len);
313         ast_test_validate(test, stasis_subscription_change_type() == stasis_message_type(consumer->messages_rxed[0]));
314         ast_test_validate(test, stasis_subscription_change_type() == stasis_message_type(consumer->messages_rxed[1]));
315
316         change = stasis_message_data(consumer->messages_rxed[0]);
317         ast_test_validate(test, topic == change->topic);
318         ast_test_validate(test, 0 == strcmp("Subscribe", change->description));
319         ast_test_validate(test, 0 == strcmp(expected_uniqueid, change->uniqueid));
320
321         change = stasis_message_data(consumer->messages_rxed[1]);
322         ast_test_validate(test, topic == change->topic);
323         ast_test_validate(test, 0 == strcmp("Unsubscribe", change->description));
324         ast_test_validate(test, 0 == strcmp(expected_uniqueid, change->uniqueid));
325
326         return AST_TEST_PASS;
327 }
328
329 AST_TEST_DEFINE(publish)
330 {
331         RAII_VAR(struct stasis_topic *, topic, NULL, ao2_cleanup);
332         RAII_VAR(struct stasis_subscription *, uut, NULL, stasis_unsubscribe);
333         RAII_VAR(char *, test_data, NULL, ao2_cleanup);
334         RAII_VAR(struct stasis_message_type *, test_message_type, NULL, ao2_cleanup);
335         RAII_VAR(struct stasis_message *, test_message, NULL, ao2_cleanup);
336         RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
337         int actual_len;
338         const char *actual;
339
340         switch (cmd) {
341         case TEST_INIT:
342                 info->name = __func__;
343                 info->category = test_category;
344                 info->summary = "Test simple subscriptions";
345                 info->description = "Test simple subscriptions";
346                 return AST_TEST_NOT_RUN;
347         case TEST_EXECUTE:
348                 break;
349         }
350
351         topic = stasis_topic_create("TestTopic");
352         ast_test_validate(test, NULL != topic);
353
354         consumer = consumer_create(1);
355         ast_test_validate(test, NULL != consumer);
356
357         uut = stasis_subscribe(topic, consumer_exec, consumer);
358         ast_test_validate(test, NULL != uut);
359         ao2_ref(consumer, +1);
360
361         test_data = ao2_alloc(1, NULL);
362         ast_test_validate(test, NULL != test_data);
363         test_message_type = stasis_message_type_create("TestMessage", NULL);
364         test_message = stasis_message_create(test_message_type, test_data);
365
366         stasis_publish(topic, test_message);
367
368         actual_len = consumer_wait_for(consumer, 1);
369         ast_test_validate(test, 1 == actual_len);
370         actual = stasis_message_data(consumer->messages_rxed[0]);
371         ast_test_validate(test, test_data == actual);
372
373         return AST_TEST_PASS;
374 }
375
376 AST_TEST_DEFINE(unsubscribe_stops_messages)
377 {
378         RAII_VAR(struct stasis_topic *, topic, NULL, ao2_cleanup);
379         RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
380         RAII_VAR(struct stasis_subscription *, uut, NULL, stasis_unsubscribe);
381         RAII_VAR(char *, test_data, NULL, ao2_cleanup);
382         RAII_VAR(struct stasis_message_type *, test_message_type, NULL, ao2_cleanup);
383         RAII_VAR(struct stasis_message *, test_message, NULL, ao2_cleanup);
384         int actual_len;
385
386         switch (cmd) {
387         case TEST_INIT:
388                 info->name = __func__;
389                 info->category = test_category;
390                 info->summary = "Test simple subscriptions";
391                 info->description = "Test simple subscriptions";
392                 return AST_TEST_NOT_RUN;
393         case TEST_EXECUTE:
394                 break;
395         }
396
397         topic = stasis_topic_create("TestTopic");
398         ast_test_validate(test, NULL != topic);
399
400         consumer = consumer_create(1);
401         ast_test_validate(test, NULL != consumer);
402
403         uut = stasis_subscribe(topic, consumer_exec, consumer);
404         ast_test_validate(test, NULL != uut);
405         ao2_ref(consumer, +1);
406
407         uut = stasis_unsubscribe(uut);
408
409         test_data = ao2_alloc(1, NULL);
410         ast_test_validate(test, NULL != test_data);
411         test_message_type = stasis_message_type_create("TestMessage", NULL);
412         test_message = stasis_message_create(test_message_type, test_data);
413
414         stasis_publish(topic, test_message);
415
416         actual_len = consumer_should_stay(consumer, 0);
417         ast_test_validate(test, 0 == actual_len);
418
419         return AST_TEST_PASS;
420 }
421
422 AST_TEST_DEFINE(forward)
423 {
424         RAII_VAR(struct stasis_topic *, parent_topic, NULL, ao2_cleanup);
425         RAII_VAR(struct stasis_topic *, topic, NULL, ao2_cleanup);
426
427         RAII_VAR(struct consumer *, parent_consumer, NULL, ao2_cleanup);
428         RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
429
430         RAII_VAR(struct stasis_subscription *, forward_sub, NULL, stasis_unsubscribe);
431         RAII_VAR(struct stasis_subscription *, parent_sub, NULL, stasis_unsubscribe);
432         RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
433
434         RAII_VAR(char *, test_data, NULL, ao2_cleanup);
435         RAII_VAR(struct stasis_message_type *, test_message_type, NULL, ao2_cleanup);
436         RAII_VAR(struct stasis_message *, test_message, NULL, ao2_cleanup);
437         int actual_len;
438
439         switch (cmd) {
440         case TEST_INIT:
441                 info->name = __func__;
442                 info->category = test_category;
443                 info->summary = "Test sending events to a parent topic";
444                 info->description = "Test sending events to a parent topic.\n"
445                         "This test creates three topics (one parent, two children)\n"
446                         "and publishes a message to one child, and verifies it's\n"
447                         "only seen by that child and the parent";
448                 return AST_TEST_NOT_RUN;
449         case TEST_EXECUTE:
450                 break;
451         }
452
453         parent_topic = stasis_topic_create("ParentTestTopic");
454         ast_test_validate(test, NULL != parent_topic);
455         topic = stasis_topic_create("TestTopic");
456         ast_test_validate(test, NULL != topic);
457
458         forward_sub = stasis_forward_all(topic, parent_topic);
459         ast_test_validate(test, NULL != forward_sub);
460
461         parent_consumer = consumer_create(1);
462         ast_test_validate(test, NULL != parent_consumer);
463         consumer = consumer_create(1);
464         ast_test_validate(test, NULL != consumer);
465
466         parent_sub = stasis_subscribe(parent_topic, consumer_exec, parent_consumer);
467         ast_test_validate(test, NULL != parent_sub);
468         ao2_ref(parent_consumer, +1);
469         sub = stasis_subscribe(topic, consumer_exec, consumer);
470         ast_test_validate(test, NULL != sub);
471         ao2_ref(consumer, +1);
472
473         test_data = ao2_alloc(1, NULL);
474         ast_test_validate(test, NULL != test_data);
475         test_message_type = stasis_message_type_create("TestMessage", NULL);
476         test_message = stasis_message_create(test_message_type, test_data);
477
478         stasis_publish(topic, test_message);
479
480         actual_len = consumer_wait_for(consumer, 1);
481         ast_test_validate(test, 1 == actual_len);
482         actual_len = consumer_wait_for(parent_consumer, 1);
483         ast_test_validate(test, 1 == actual_len);
484
485         return AST_TEST_PASS;
486 }
487
488 AST_TEST_DEFINE(interleaving)
489 {
490         RAII_VAR(struct stasis_topic *, parent_topic, NULL, ao2_cleanup);
491         RAII_VAR(struct stasis_topic *, topic1, NULL, ao2_cleanup);
492         RAII_VAR(struct stasis_topic *, topic2, NULL, ao2_cleanup);
493
494         RAII_VAR(struct stasis_message_type *, test_message_type, NULL, ao2_cleanup);
495
496         RAII_VAR(char *, test_data, NULL, ao2_cleanup);
497
498         RAII_VAR(struct stasis_message *, test_message1, NULL, ao2_cleanup);
499         RAII_VAR(struct stasis_message *, test_message2, NULL, ao2_cleanup);
500         RAII_VAR(struct stasis_message *, test_message3, NULL, ao2_cleanup);
501
502         RAII_VAR(struct stasis_subscription *, forward_sub1, NULL, stasis_unsubscribe);
503         RAII_VAR(struct stasis_subscription *, forward_sub2, NULL, stasis_unsubscribe);
504         RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
505
506         RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
507
508         int actual_len;
509
510         switch (cmd) {
511         case TEST_INIT:
512                 info->name = __func__;
513                 info->category = test_category;
514                 info->summary = "Test sending interleaved events to a parent topic";
515                 info->description = "Test sending events to a parent topic.\n"
516                         "This test creates three topics (one parent, two children)\n"
517                         "and publishes messages alternately between the children.\n"
518                         "It verifies that the messages are received in the expected\n"
519                         "order.";
520                 return AST_TEST_NOT_RUN;
521         case TEST_EXECUTE:
522                 break;
523         }
524
525         test_message_type = stasis_message_type_create("test", NULL);
526         ast_test_validate(test, NULL != test_message_type);
527
528         test_data = ao2_alloc(1, NULL);
529         ast_test_validate(test, NULL != test_data);
530
531         test_message1 = stasis_message_create(test_message_type, test_data);
532         ast_test_validate(test, NULL != test_message1);
533         test_message2 = stasis_message_create(test_message_type, test_data);
534         ast_test_validate(test, NULL != test_message2);
535         test_message3 = stasis_message_create(test_message_type, test_data);
536         ast_test_validate(test, NULL != test_message3);
537
538         parent_topic = stasis_topic_create("ParentTestTopic");
539         ast_test_validate(test, NULL != parent_topic);
540         topic1 = stasis_topic_create("Topic1");
541         ast_test_validate(test, NULL != topic1);
542         topic2 = stasis_topic_create("Topic2");
543         ast_test_validate(test, NULL != topic2);
544
545         forward_sub1 = stasis_forward_all(topic1, parent_topic);
546         ast_test_validate(test, NULL != forward_sub1);
547         forward_sub2 = stasis_forward_all(topic2, parent_topic);
548         ast_test_validate(test, NULL != forward_sub2);
549
550         consumer = consumer_create(1);
551         ast_test_validate(test, NULL != consumer);
552
553         sub = stasis_subscribe(parent_topic, consumer_exec, consumer);
554         ast_test_validate(test, NULL != sub);
555         ao2_ref(consumer, +1);
556
557         stasis_publish(topic1, test_message1);
558         stasis_publish(topic2, test_message2);
559         stasis_publish(topic1, test_message3);
560
561         actual_len = consumer_wait_for(consumer, 3);
562         ast_test_validate(test, 3 == actual_len);
563
564         ast_test_validate(test, test_message1 == consumer->messages_rxed[0]);
565         ast_test_validate(test, test_message2 == consumer->messages_rxed[1]);
566         ast_test_validate(test, test_message3 == consumer->messages_rxed[2]);
567
568         return AST_TEST_PASS;
569 }
570
571 struct cache_test_data {
572         char *id;
573         char *value;
574 };
575
576 static void cache_test_data_dtor(void *obj)
577 {
578         struct cache_test_data *data = obj;
579         ast_free(data->id);
580         ast_free(data->value);
581 }
582
583 static struct stasis_message *cache_test_message_create(struct stasis_message_type *type, const char *name, const char *value)
584 {
585         RAII_VAR(struct cache_test_data *, data, NULL, ao2_cleanup);
586
587         data = ao2_alloc(sizeof(*data), cache_test_data_dtor);
588         if (data == NULL) {
589                 return NULL;
590         }
591
592         ast_assert(name != NULL);
593         ast_assert(value != NULL);
594
595         data->id = ast_strdup(name);
596         data->value = ast_strdup(value);
597         if (!data->id || !data->value) {
598                 return NULL;
599         }
600
601         return stasis_message_create(type, data);
602 }
603
604 static const char *cache_test_data_id(struct stasis_message *message) {
605         struct cache_test_data *cachable = stasis_message_data(message);
606
607         if (0 != strcmp("Cacheable", stasis_message_type_name(stasis_message_type(message)))) {
608                 return NULL;
609         }
610         return cachable->id;
611 }
612
613 AST_TEST_DEFINE(cache_passthrough)
614 {
615         RAII_VAR(struct stasis_message_type *, non_cache_type, NULL, ao2_cleanup);
616         RAII_VAR(struct stasis_topic *, topic, NULL, ao2_cleanup);
617         RAII_VAR(struct stasis_caching_topic *, caching_topic, NULL, stasis_caching_unsubscribe);
618         RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
619         RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
620         RAII_VAR(struct stasis_message *, test_message, NULL, ao2_cleanup);
621         int actual_len;
622         struct stasis_message_type *actual_type;
623
624         switch (cmd) {
625         case TEST_INIT:
626                 info->name = __func__;
627                 info->category = test_category;
628                 info->summary = "Test passing messages through cache topic unscathed.";
629                 info->description = "Test passing messages through cache topic unscathed.";
630                 return AST_TEST_NOT_RUN;
631         case TEST_EXECUTE:
632                 break;
633         }
634
635         non_cache_type = stasis_message_type_create("NonCacheable", NULL);
636         ast_test_validate(test, NULL != non_cache_type);
637         topic = stasis_topic_create("SomeTopic");
638         ast_test_validate(test, NULL != topic);
639         caching_topic = stasis_caching_topic_create(topic, cache_test_data_id);
640         ast_test_validate(test, NULL != caching_topic);
641         consumer = consumer_create(1);
642         ast_test_validate(test, NULL != consumer);
643         sub = stasis_subscribe(stasis_caching_get_topic(caching_topic), consumer_exec, consumer);
644         ast_test_validate(test, NULL != sub);
645         ao2_ref(consumer, +1);
646
647         test_message = cache_test_message_create(non_cache_type, "1", "1");
648         ast_test_validate(test, NULL != test_message);
649
650         stasis_publish(topic, test_message);
651
652         actual_len = consumer_wait_for(consumer, 1);
653         ast_test_validate(test, 1 == actual_len);
654
655         actual_type = stasis_message_type(consumer->messages_rxed[0]);
656         ast_test_validate(test, non_cache_type == actual_type);
657
658         ast_test_validate(test, test_message == consumer->messages_rxed[0]);
659
660         return AST_TEST_PASS;
661 }
662
663 AST_TEST_DEFINE(cache)
664 {
665         RAII_VAR(struct stasis_message_type *, cache_type, NULL, ao2_cleanup);
666         RAII_VAR(struct stasis_topic *, topic, NULL, ao2_cleanup);
667         RAII_VAR(struct stasis_caching_topic *, caching_topic, NULL, stasis_caching_unsubscribe);
668         RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
669         RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
670         RAII_VAR(struct stasis_message *, test_message1_1, NULL, ao2_cleanup);
671         RAII_VAR(struct stasis_message *, test_message2_1, NULL, ao2_cleanup);
672         RAII_VAR(struct stasis_message *, test_message2_2, NULL, ao2_cleanup);
673         RAII_VAR(struct stasis_message *, test_message1_clear, NULL, ao2_cleanup);
674         int actual_len;
675         struct stasis_cache_update *actual_update;
676
677         switch (cmd) {
678         case TEST_INIT:
679                 info->name = __func__;
680                 info->category = test_category;
681                 info->summary = "Test passing messages through cache topic unscathed.";
682                 info->description = "Test passing messages through cache topic unscathed.";
683                 return AST_TEST_NOT_RUN;
684         case TEST_EXECUTE:
685                 break;
686         }
687
688         cache_type = stasis_message_type_create("Cacheable", NULL);
689         ast_test_validate(test, NULL != cache_type);
690         topic = stasis_topic_create("SomeTopic");
691         ast_test_validate(test, NULL != topic);
692         caching_topic = stasis_caching_topic_create(topic, cache_test_data_id);
693         ast_test_validate(test, NULL != caching_topic);
694         consumer = consumer_create(1);
695         ast_test_validate(test, NULL != consumer);
696         sub = stasis_subscribe(stasis_caching_get_topic(caching_topic), consumer_exec, consumer);
697         ast_test_validate(test, NULL != sub);
698         ao2_ref(consumer, +1);
699
700         test_message1_1 = cache_test_message_create(cache_type, "1", "1");
701         ast_test_validate(test, NULL != test_message1_1);
702         test_message2_1 = cache_test_message_create(cache_type, "2", "1");
703         ast_test_validate(test, NULL != test_message2_1);
704
705         /* Post a couple of snapshots */
706         stasis_publish(topic, test_message1_1);
707         stasis_publish(topic, test_message2_1);
708         actual_len = consumer_wait_for(consumer, 2);
709         ast_test_validate(test, 2 == actual_len);
710
711         /* Check for new snapshot messages */
712         ast_test_validate(test, stasis_cache_update_type() == stasis_message_type(consumer->messages_rxed[0]));
713         actual_update = stasis_message_data(consumer->messages_rxed[0]);
714         ast_test_validate(test, topic == actual_update->topic);
715         ast_test_validate(test, NULL == actual_update->old_snapshot);
716         ast_test_validate(test, test_message1_1 == actual_update->new_snapshot);
717         ast_test_validate(test, test_message1_1 == stasis_cache_get(caching_topic, cache_type, "1"));
718         /* stasis_cache_get returned a ref, so unref test_message1_1 */
719         ao2_ref(test_message1_1, -1);
720
721         ast_test_validate(test, stasis_cache_update_type() == stasis_message_type(consumer->messages_rxed[1]));
722         actual_update = stasis_message_data(consumer->messages_rxed[1]);
723         ast_test_validate(test, topic == actual_update->topic);
724         ast_test_validate(test, NULL == actual_update->old_snapshot);
725         ast_test_validate(test, test_message2_1 == actual_update->new_snapshot);
726         ast_test_validate(test, test_message2_1 == stasis_cache_get(caching_topic, cache_type, "2"));
727         /* stasis_cache_get returned a ref, so unref test_message2_1 */
728         ao2_ref(test_message2_1, -1);
729
730         /* Update snapshot 2 */
731         test_message2_2 = cache_test_message_create(cache_type, "2", "2");
732         ast_test_validate(test, NULL != test_message2_2);
733         stasis_publish(topic, test_message2_2);
734
735         actual_len = consumer_wait_for(consumer, 3);
736         ast_test_validate(test, 3 == actual_len);
737
738         actual_update = stasis_message_data(consumer->messages_rxed[2]);
739         ast_test_validate(test, topic == actual_update->topic);
740         ast_test_validate(test, test_message2_1 == actual_update->old_snapshot);
741         ast_test_validate(test, test_message2_2 == actual_update->new_snapshot);
742         ast_test_validate(test, test_message2_2 == stasis_cache_get(caching_topic, cache_type, "2"));
743         /* stasis_cache_get returned a ref, so unref test_message2_2 */
744         ao2_ref(test_message2_2, -1);
745
746         /* Clear snapshot 1 */
747         test_message1_clear = stasis_cache_clear_create(test_message1_1);
748         ast_test_validate(test, NULL != test_message1_clear);
749         stasis_publish(topic, test_message1_clear);
750
751         actual_len = consumer_wait_for(consumer, 4);
752         ast_test_validate(test, 4 == actual_len);
753
754         actual_update = stasis_message_data(consumer->messages_rxed[3]);
755         ast_test_validate(test, topic == actual_update->topic);
756         ast_test_validate(test, test_message1_1 == actual_update->old_snapshot);
757         ast_test_validate(test, NULL == actual_update->new_snapshot);
758         ast_test_validate(test, NULL == stasis_cache_get(caching_topic, cache_type, "1"));
759
760         return AST_TEST_PASS;
761 }
762
763 AST_TEST_DEFINE(cache_dump)
764 {
765         RAII_VAR(struct stasis_message_type *, cache_type, NULL, ao2_cleanup);
766         RAII_VAR(struct stasis_topic *, topic, NULL, ao2_cleanup);
767         RAII_VAR(struct stasis_caching_topic *, caching_topic, NULL, stasis_caching_unsubscribe);
768         RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
769         RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
770         RAII_VAR(struct stasis_message *, test_message1_1, NULL, ao2_cleanup);
771         RAII_VAR(struct stasis_message *, test_message2_1, NULL, ao2_cleanup);
772         RAII_VAR(struct stasis_message *, test_message2_2, NULL, ao2_cleanup);
773         RAII_VAR(struct stasis_message *, test_message1_clear, NULL, ao2_cleanup);
774         RAII_VAR(struct ao2_container *, cache_dump, NULL, ao2_cleanup);
775         int actual_len;
776         struct ao2_iterator i;
777         void *obj;
778
779         switch (cmd) {
780         case TEST_INIT:
781                 info->name = __func__;
782                 info->category = test_category;
783                 info->summary = "Test passing messages through cache topic unscathed.";
784                 info->description = "Test passing messages through cache topic unscathed.";
785                 return AST_TEST_NOT_RUN;
786         case TEST_EXECUTE:
787                 break;
788         }
789
790         cache_type = stasis_message_type_create("Cacheable", NULL);
791         ast_test_validate(test, NULL != cache_type);
792         topic = stasis_topic_create("SomeTopic");
793         ast_test_validate(test, NULL != topic);
794         caching_topic = stasis_caching_topic_create(topic, cache_test_data_id);
795         ast_test_validate(test, NULL != caching_topic);
796         consumer = consumer_create(1);
797         ast_test_validate(test, NULL != consumer);
798         sub = stasis_subscribe(stasis_caching_get_topic(caching_topic), consumer_exec, consumer);
799         ast_test_validate(test, NULL != sub);
800         ao2_ref(consumer, +1);
801
802         test_message1_1 = cache_test_message_create(cache_type, "1", "1");
803         ast_test_validate(test, NULL != test_message1_1);
804         test_message2_1 = cache_test_message_create(cache_type, "2", "1");
805         ast_test_validate(test, NULL != test_message2_1);
806
807         /* Post a couple of snapshots */
808         stasis_publish(topic, test_message1_1);
809         stasis_publish(topic, test_message2_1);
810         actual_len = consumer_wait_for(consumer, 2);
811         ast_test_validate(test, 2 == actual_len);
812
813         /* Check the cache */
814         cache_dump = stasis_cache_dump(caching_topic, NULL);
815         ast_test_validate(test, NULL != cache_dump);
816         ast_test_validate(test, 2 == ao2_container_count(cache_dump));
817         i = ao2_iterator_init(cache_dump, 0);
818         while ((obj = ao2_iterator_next(&i))) {
819                 RAII_VAR(struct stasis_message *, actual_cache_entry, obj, ao2_cleanup);
820                 ast_test_validate(test, actual_cache_entry == test_message1_1 || actual_cache_entry == test_message2_1);
821         }
822
823         /* Update snapshot 2 */
824         test_message2_2 = cache_test_message_create(cache_type, "2", "2");
825         ast_test_validate(test, NULL != test_message2_2);
826         stasis_publish(topic, test_message2_2);
827
828         actual_len = consumer_wait_for(consumer, 3);
829         ast_test_validate(test, 3 == actual_len);
830
831         /* Check the cache */
832         cache_dump = stasis_cache_dump(caching_topic, NULL);
833         ast_test_validate(test, NULL != cache_dump);
834         ast_test_validate(test, 2 == ao2_container_count(cache_dump));
835         i = ao2_iterator_init(cache_dump, 0);
836         while ((obj = ao2_iterator_next(&i))) {
837                 RAII_VAR(struct stasis_message *, actual_cache_entry, obj, ao2_cleanup);
838                 ast_test_validate(test, actual_cache_entry == test_message1_1 || actual_cache_entry == test_message2_2);
839         }
840
841         /* Clear snapshot 1 */
842         test_message1_clear = stasis_cache_clear_create(test_message1_1);
843         ast_test_validate(test, NULL != test_message1_clear);
844         stasis_publish(topic, test_message1_clear);
845
846         actual_len = consumer_wait_for(consumer, 4);
847         ast_test_validate(test, 4 == actual_len);
848
849         /* Check the cache */
850         cache_dump = stasis_cache_dump(caching_topic, NULL);
851         ast_test_validate(test, NULL != cache_dump);
852         ast_test_validate(test, 1 == ao2_container_count(cache_dump));
853         i = ao2_iterator_init(cache_dump, 0);
854         while ((obj = ao2_iterator_next(&i))) {
855                 RAII_VAR(struct stasis_message *, actual_cache_entry, obj, ao2_cleanup);
856                 ast_test_validate(test, actual_cache_entry == test_message2_2);
857         }
858
859         /* Dump the cache to ensure that it has no subscription change items in it since those aren't cached */
860         ao2_cleanup(cache_dump);
861         cache_dump = stasis_cache_dump(caching_topic, stasis_subscription_change_type());
862         ast_test_validate(test, 0 == ao2_container_count(cache_dump));
863
864         return AST_TEST_PASS;
865 }
866
867 AST_TEST_DEFINE(route_conflicts)
868 {
869         RAII_VAR(struct stasis_topic *, topic, NULL, ao2_cleanup);
870         RAII_VAR(struct stasis_message_router *, uut, NULL, stasis_message_router_unsubscribe);
871         RAII_VAR(struct stasis_message_type *, test_message_type, NULL, ao2_cleanup);
872         RAII_VAR(struct consumer *, consumer1, NULL, ao2_cleanup);
873         RAII_VAR(struct consumer *, consumer2, NULL, ao2_cleanup);
874         int ret;
875
876         switch (cmd) {
877         case TEST_INIT:
878                 info->name = __func__;
879                 info->category = test_category;
880                 info->summary =
881                         "Multiple routes to the same message_type should fail";
882                 info->description =
883                         "Multiple routes to the same message_type should fail";
884                 return AST_TEST_NOT_RUN;
885         case TEST_EXECUTE:
886                 break;
887         }
888
889         topic = stasis_topic_create("TestTopic");
890         ast_test_validate(test, NULL != topic);
891
892         consumer1 = consumer_create(1);
893         ast_test_validate(test, NULL != consumer1);
894         consumer2 = consumer_create(1);
895         ast_test_validate(test, NULL != consumer2);
896
897         test_message_type = stasis_message_type_create("TestMessage", NULL);
898         ast_test_validate(test, NULL != test_message_type);
899
900         uut = stasis_message_router_create(topic);
901         ast_test_validate(test, NULL != uut);
902
903         ret = stasis_message_router_add(
904                 uut, test_message_type, consumer_exec, consumer1);
905         ast_test_validate(test, 0 == ret);
906         ret = stasis_message_router_add(
907                 uut, test_message_type, consumer_exec, consumer2);
908         ast_test_validate(test, 0 != ret);
909
910         return AST_TEST_PASS;
911 }
912
913 AST_TEST_DEFINE(router)
914 {
915         RAII_VAR(struct stasis_topic *, topic, NULL, ao2_cleanup);
916         RAII_VAR(struct stasis_message_router *, uut, NULL, stasis_message_router_unsubscribe);
917         RAII_VAR(char *, test_data, NULL, ao2_cleanup);
918         RAII_VAR(struct stasis_message_type *, test_message_type1, NULL, ao2_cleanup);
919         RAII_VAR(struct stasis_message_type *, test_message_type2, NULL, ao2_cleanup);
920         RAII_VAR(struct stasis_message_type *, test_message_type3, NULL, ao2_cleanup);
921         RAII_VAR(struct consumer *, consumer1, NULL, ao2_cleanup);
922         RAII_VAR(struct consumer *, consumer2, NULL, ao2_cleanup);
923         RAII_VAR(struct consumer *, consumer3, NULL, ao2_cleanup);
924         RAII_VAR(struct stasis_message *, test_message1, NULL, ao2_cleanup);
925         RAII_VAR(struct stasis_message *, test_message2, NULL, ao2_cleanup);
926         RAII_VAR(struct stasis_message *, test_message3, NULL, ao2_cleanup);
927         int actual_len, ret;
928         struct stasis_message *actual;
929
930         switch (cmd) {
931         case TEST_INIT:
932                 info->name = __func__;
933                 info->category = test_category;
934                 info->summary = "Test simple message routing";
935                 info->description = "Test simple message routing";
936                 return AST_TEST_NOT_RUN;
937         case TEST_EXECUTE:
938                 break;
939         }
940
941         topic = stasis_topic_create("TestTopic");
942         ast_test_validate(test, NULL != topic);
943
944         consumer1 = consumer_create(1);
945         ast_test_validate(test, NULL != consumer1);
946         consumer2 = consumer_create(1);
947         ast_test_validate(test, NULL != consumer2);
948         consumer3 = consumer_create(1);
949         ast_test_validate(test, NULL != consumer3);
950
951         test_message_type1 = stasis_message_type_create("TestMessage1", NULL);
952         ast_test_validate(test, NULL != test_message_type1);
953         test_message_type2 = stasis_message_type_create("TestMessage2", NULL);
954         ast_test_validate(test, NULL != test_message_type2);
955         test_message_type3 = stasis_message_type_create("TestMessage3", NULL);
956         ast_test_validate(test, NULL != test_message_type3);
957
958         uut = stasis_message_router_create(topic);
959         ast_test_validate(test, NULL != uut);
960
961         ret = stasis_message_router_add(
962                 uut, test_message_type1, consumer_exec, consumer1);
963         ast_test_validate(test, 0 == ret);
964         ao2_ref(consumer1, +1);
965         ret = stasis_message_router_add(
966                 uut, test_message_type2, consumer_exec, consumer2);
967         ast_test_validate(test, 0 == ret);
968         ao2_ref(consumer2, +1);
969         ret = stasis_message_router_set_default(uut, consumer_exec, consumer3);
970         ast_test_validate(test, 0 == ret);
971         ao2_ref(consumer3, +1);
972
973         test_data = ao2_alloc(1, NULL);
974         ast_test_validate(test, NULL != test_data);
975         test_message1 = stasis_message_create(test_message_type1, test_data);
976         ast_test_validate(test, NULL != test_message1);
977         test_message2 = stasis_message_create(test_message_type2, test_data);
978         ast_test_validate(test, NULL != test_message2);
979         test_message3 = stasis_message_create(test_message_type3, test_data);
980         ast_test_validate(test, NULL != test_message3);
981
982         stasis_publish(topic, test_message1);
983         stasis_publish(topic, test_message2);
984         stasis_publish(topic, test_message3);
985
986         actual_len = consumer_wait_for(consumer1, 1);
987         ast_test_validate(test, 1 == actual_len);
988         actual_len = consumer_wait_for(consumer2, 1);
989         ast_test_validate(test, 1 == actual_len);
990         actual_len = consumer_wait_for(consumer3, 1);
991         ast_test_validate(test, 1 == actual_len);
992
993         actual = consumer1->messages_rxed[0];
994         ast_test_validate(test, test_message1 == actual);
995
996         actual = consumer2->messages_rxed[0];
997         ast_test_validate(test, test_message2 == actual);
998
999         actual = consumer3->messages_rxed[0];
1000         ast_test_validate(test, test_message3 == actual);
1001
1002         /* consumer1 and consumer2 do not get the final message. */
1003         ao2_cleanup(consumer1);
1004         ao2_cleanup(consumer2);
1005
1006         return AST_TEST_PASS;
1007 }
1008
1009 AST_TEST_DEFINE(no_to_json)
1010 {
1011         RAII_VAR(struct stasis_message_type *, type, NULL, ao2_cleanup);
1012         RAII_VAR(struct stasis_message *, uut, NULL, ao2_cleanup);
1013         RAII_VAR(char *, data, NULL, ao2_cleanup);
1014         RAII_VAR(struct ast_json *, actual, NULL, ast_json_unref);
1015         char *expected = "SomeData";
1016
1017         switch (cmd) {
1018         case TEST_INIT:
1019                 info->name = __func__;
1020                 info->category = test_category;
1021                 info->summary = "Test message to_json function";
1022                 info->description = "Test message to_json function";
1023                 return AST_TEST_NOT_RUN;
1024         case TEST_EXECUTE:
1025                 break;
1026         }
1027
1028         /* Test NULL */
1029         actual = stasis_message_to_json(NULL);
1030         ast_test_validate(test, NULL == actual);
1031
1032         /* Test message with NULL to_json function */
1033         type = stasis_message_type_create("SomeMessage", NULL);
1034
1035         data = ao2_alloc(strlen(expected) + 1, NULL);
1036         strcpy(data, expected);
1037         uut = stasis_message_create(type, data);
1038         ast_test_validate(test, NULL != uut);
1039
1040         actual = stasis_message_to_json(uut);
1041         ast_test_validate(test, NULL == actual);
1042
1043         return AST_TEST_PASS;
1044 }
1045
1046 AST_TEST_DEFINE(to_json)
1047 {
1048         RAII_VAR(struct stasis_message_type *, type, NULL, ao2_cleanup);
1049         RAII_VAR(struct stasis_message *, uut, NULL, ao2_cleanup);
1050         RAII_VAR(char *, data, NULL, ao2_cleanup);
1051         RAII_VAR(struct ast_json *, actual, NULL, ast_json_unref);
1052         const char *expected_text = "SomeData";
1053         RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
1054
1055         switch (cmd) {
1056         case TEST_INIT:
1057                 info->name = __func__;
1058                 info->category = test_category;
1059                 info->summary = "Test message to_json function when NULL";
1060                 info->description = "Test message to_json function when NULL";
1061                 return AST_TEST_NOT_RUN;
1062         case TEST_EXECUTE:
1063                 break;
1064         }
1065
1066         type = stasis_message_type_create("SomeMessage", &fake_vtable);
1067
1068         data = ao2_alloc(strlen(expected_text) + 1, NULL);
1069         strcpy(data, expected_text);
1070         uut = stasis_message_create(type, data);
1071         ast_test_validate(test, NULL != uut);
1072
1073         expected = ast_json_string_create(expected_text);
1074         actual = stasis_message_to_json(uut);
1075         ast_test_validate(test, ast_json_equal(expected, actual));
1076
1077         return AST_TEST_PASS;
1078 }
1079
1080 AST_TEST_DEFINE(no_to_ami)
1081 {
1082         RAII_VAR(struct stasis_message_type *, type, NULL, ao2_cleanup);
1083         RAII_VAR(struct stasis_message *, uut, NULL, ao2_cleanup);
1084         RAII_VAR(char *, data, NULL, ao2_cleanup);
1085         RAII_VAR(struct ast_manager_event_blob *, actual, NULL, ao2_cleanup);
1086         char *expected = "SomeData";
1087
1088         switch (cmd) {
1089         case TEST_INIT:
1090                 info->name = __func__;
1091                 info->category = test_category;
1092                 info->summary = "Test message to_ami function when NULL";
1093                 info->description = "Test message to_ami function when NULL";
1094                 return AST_TEST_NOT_RUN;
1095         case TEST_EXECUTE:
1096                 break;
1097         }
1098
1099         /* Test NULL */
1100         actual = stasis_message_to_ami(NULL);
1101         ast_test_validate(test, NULL == actual);
1102
1103         /* Test message with NULL to_ami function */
1104         type = stasis_message_type_create("SomeMessage", NULL);
1105
1106         data = ao2_alloc(strlen(expected) + 1, NULL);
1107         strcpy(data, expected);
1108         uut = stasis_message_create(type, data);
1109         ast_test_validate(test, NULL != uut);
1110
1111         actual = stasis_message_to_ami(uut);
1112         ast_test_validate(test, NULL == actual);
1113
1114         return AST_TEST_PASS;
1115 }
1116
1117 AST_TEST_DEFINE(to_ami)
1118 {
1119         RAII_VAR(struct stasis_message_type *, type, NULL, ao2_cleanup);
1120         RAII_VAR(struct stasis_message *, uut, NULL, ao2_cleanup);
1121         RAII_VAR(char *, data, NULL, ao2_cleanup);
1122         RAII_VAR(struct ast_manager_event_blob *, actual, NULL, ao2_cleanup);
1123         const char *expected_text = "SomeData";
1124         const char *expected = "Message: SomeData";
1125
1126         switch (cmd) {
1127         case TEST_INIT:
1128                 info->name = __func__;
1129                 info->category = test_category;
1130                 info->summary = "Test message to_ami function";
1131                 info->description = "Test message to_ami function";
1132                 return AST_TEST_NOT_RUN;
1133         case TEST_EXECUTE:
1134                 break;
1135         }
1136
1137         type = stasis_message_type_create("SomeMessage", &fake_vtable);
1138
1139         data = ao2_alloc(strlen(expected_text) + 1, NULL);
1140         strcpy(data, expected_text);
1141         uut = stasis_message_create(type, data);
1142         ast_test_validate(test, NULL != uut);
1143
1144         actual = stasis_message_to_ami(uut);
1145         ast_test_validate(test, strcmp(expected, actual->extra_fields) == 0);
1146
1147         return AST_TEST_PASS;
1148 }
1149
1150 static int unload_module(void)
1151 {
1152         AST_TEST_UNREGISTER(message_type);
1153         AST_TEST_UNREGISTER(message);
1154         AST_TEST_UNREGISTER(subscription_messages);
1155         AST_TEST_UNREGISTER(publish);
1156         AST_TEST_UNREGISTER(unsubscribe_stops_messages);
1157         AST_TEST_UNREGISTER(forward);
1158         AST_TEST_UNREGISTER(cache_passthrough);
1159         AST_TEST_UNREGISTER(cache);
1160         AST_TEST_UNREGISTER(cache_dump);
1161         AST_TEST_UNREGISTER(route_conflicts);
1162         AST_TEST_UNREGISTER(router);
1163         AST_TEST_UNREGISTER(interleaving);
1164         AST_TEST_UNREGISTER(no_to_json);
1165         AST_TEST_UNREGISTER(to_json);
1166         AST_TEST_UNREGISTER(no_to_ami);
1167         AST_TEST_UNREGISTER(to_ami);
1168         return 0;
1169 }
1170
1171 static int load_module(void)
1172 {
1173         AST_TEST_REGISTER(message_type);
1174         AST_TEST_REGISTER(message);
1175         AST_TEST_REGISTER(subscription_messages);
1176         AST_TEST_REGISTER(publish);
1177         AST_TEST_REGISTER(unsubscribe_stops_messages);
1178         AST_TEST_REGISTER(forward);
1179         AST_TEST_REGISTER(cache_passthrough);
1180         AST_TEST_REGISTER(cache);
1181         AST_TEST_REGISTER(cache_dump);
1182         AST_TEST_REGISTER(route_conflicts);
1183         AST_TEST_REGISTER(router);
1184         AST_TEST_REGISTER(interleaving);
1185         AST_TEST_REGISTER(no_to_json);
1186         AST_TEST_REGISTER(to_json);
1187         AST_TEST_REGISTER(no_to_ami);
1188         AST_TEST_REGISTER(to_ami);
1189         return AST_MODULE_LOAD_SUCCESS;
1190 }
1191
1192 AST_MODULE_INFO(ASTERISK_GPL_KEY, 0, "Stasis testing",
1193                 .load = load_module,
1194                 .unload = unload_module
1195         );