git migration: Refactor the ASTERISK_FILE_VERSION macro
[asterisk/asterisk.git] / tests / test_res_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 Application API.
21  * \author\verbatim David M. Lee, II <dlee@digium.com> \endverbatim
22  *
23  * \ingroup tests
24  */
25
26 /*** MODULEINFO
27         <depend>TEST_FRAMEWORK</depend>
28         <depend>res_stasis</depend>
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_REGISTER_FILE()
35
36 #include "asterisk/module.h"
37 #include "asterisk/test.h"
38 #include "asterisk/stasis_app.h"
39
40 static const char *test_category = "/stasis/res/";
41
42 AST_TEST_DEFINE(app_invoke_dne)
43 {
44         int res;
45
46         switch (cmd) {
47         case TEST_INIT:
48                 info->name = __func__;
49                 info->category = test_category;
50                 info->summary = "Test stasis app invocation.";
51                 info->description = "Test stasis app invocation.";
52                 return AST_TEST_NOT_RUN;
53         case TEST_EXECUTE:
54                 break;
55         }
56
57         res = stasis_app_send("i-am-not-an-app", ast_json_null());
58         ast_test_validate(test, -1 == res);
59
60         return AST_TEST_PASS;
61 }
62
63 struct app_data {
64         int invocations;
65         struct ast_json *messages;
66 };
67
68 static void app_data_dtor(void *obj)
69 {
70         struct app_data *actual = obj;
71
72         ast_json_unref(actual->messages);
73         actual->messages = NULL;
74 }
75
76 static struct app_data *app_data_create(void)
77 {
78         struct app_data *res = ao2_alloc(sizeof(struct app_data), app_data_dtor);
79
80         if (!res) {
81                 return NULL;
82         }
83
84         res->messages = ast_json_array_create();
85         return res;
86 }
87
88 static void test_handler(void *data, const char *app_name, struct ast_json *message)
89 {
90         struct app_data *actual = data;
91         int res;
92         ++(actual->invocations);
93         res = ast_json_array_append(actual->messages, ast_json_copy(message));
94         ast_assert(res == 0);
95 }
96
97 AST_TEST_DEFINE(app_invoke_one)
98 {
99         RAII_VAR(struct app_data *, app_data, NULL, ao2_cleanup);
100         RAII_VAR(char *, app_name, NULL, stasis_app_unregister);
101         RAII_VAR(struct ast_json *, expected_message, NULL, ast_json_unref);
102         RAII_VAR(struct ast_json *, message, NULL, ast_json_unref);
103         int res;
104
105         switch (cmd) {
106         case TEST_INIT:
107                 info->name = __func__;
108                 info->category = test_category;
109                 info->summary = "Test stasis app invocation.";
110                 info->description = "Test stasis app invocation.";
111                 return AST_TEST_NOT_RUN;
112         case TEST_EXECUTE:
113                 break;
114         }
115
116         app_name = "test-handler";
117
118         app_data = app_data_create();
119
120         stasis_app_register(app_name, test_handler, app_data);
121         message = ast_json_pack("{ s: o }", "test-message", ast_json_null());
122         expected_message = ast_json_pack("[o]", ast_json_ref(message));
123
124         res = stasis_app_send(app_name, message);
125         ast_test_validate(test, 0 == res);
126         ast_test_validate(test, 1 == app_data->invocations);
127         ast_test_validate(test, ast_json_equal(expected_message, app_data->messages));
128
129         return AST_TEST_PASS;
130 }
131
132 AST_TEST_DEFINE(app_replaced)
133 {
134         RAII_VAR(struct app_data *, app_data1, NULL, ao2_cleanup);
135         RAII_VAR(struct app_data *, app_data2, NULL, ao2_cleanup);
136         RAII_VAR(char *, app_name, NULL, stasis_app_unregister);
137         RAII_VAR(struct ast_json *, expected_message1, NULL, ast_json_unref);
138         RAII_VAR(struct ast_json *, message, NULL, ast_json_unref);
139         RAII_VAR(struct ast_json *, expected_message2, NULL, ast_json_unref);
140         int res;
141
142         switch (cmd) {
143         case TEST_INIT:
144                 info->name = __func__;
145                 info->category = test_category;
146                 info->summary = "Test stasis app invocation.";
147                 info->description = "Test stasis app invocation.";
148                 return AST_TEST_NOT_RUN;
149         case TEST_EXECUTE:
150                 break;
151         }
152
153         app_name = "test-handler";
154
155         app_data1 = app_data_create();
156         app_data2 = app_data_create();
157
158         stasis_app_register(app_name, test_handler, app_data1);
159         stasis_app_register(app_name, test_handler, app_data2);
160         expected_message1 = ast_json_pack("[{s: s, s: s}]",
161                 "type", "ApplicationReplaced",
162                 "application", app_name);
163         message = ast_json_pack("{ s: o }", "test-message", ast_json_null());
164         expected_message2 = ast_json_pack("[o]", ast_json_ref(message));
165
166         res = stasis_app_send(app_name, message);
167         ast_test_validate(test, 0 == res);
168         ast_test_validate(test, 1 == app_data1->invocations);
169         ast_test_validate(test, ast_json_equal(expected_message1, app_data1->messages));
170         ast_test_validate(test, 1 == app_data2->invocations);
171         ast_test_validate(test, ast_json_equal(expected_message2, app_data2->messages));
172
173         return AST_TEST_PASS;
174 }
175
176 static int unload_module(void)
177 {
178         AST_TEST_UNREGISTER(app_invoke_dne);
179         AST_TEST_UNREGISTER(app_invoke_one);
180         AST_TEST_UNREGISTER(app_replaced);
181         stasis_app_unref();
182         return 0;
183 }
184
185 static int load_module(void)
186 {
187         stasis_app_ref();
188         AST_TEST_REGISTER(app_replaced);
189         AST_TEST_REGISTER(app_invoke_one);
190         AST_TEST_REGISTER(app_invoke_dne);
191         return AST_MODULE_LOAD_SUCCESS;
192 }
193
194 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Stasis Core testing",
195         .load = load_module,
196         .unload = unload_module,
197         .nonoptreq = "res_stasis",
198         );