ari:Add application/json parameter support
[asterisk/asterisk.git] / tests / test_ari.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 ARI 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_ari</depend>
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
35
36 #include "asterisk/module.h"
37 #include "asterisk/test.h"
38 #include "asterisk/ari.h"
39
40 /*!@{*/
41
42 /*!
43  * \internal
44  * The following code defines a simple RESTful API for unit testing. The
45  * response encodes the inputs of the invocation. The invocation_count
46  * counter is also incremented.
47  *
48  *  - /foo (GET)
49  *  - /foo/bar (GET, POST)
50  *  - /foo/{bam} (GET)
51  *  - /foo/{bam}/bang (GET, POST, DE1LETE)
52  */
53
54 static int invocation_count;
55
56 /*!
57  * \internal
58  * Shared code for all handlers
59  */
60 static void handler(const char *name,
61                     int response_code,
62                     struct ast_variable *get_params,
63                     struct ast_variable *path_vars,
64                     struct ast_variable *headers,
65                     struct ast_ari_response *response)
66 {
67         struct ast_json *message = ast_json_pack("{s: s, s: {}, s: {}, s: {}}",
68                                                  "name", name,
69                                                  "get_params",
70                                                  "path_vars",
71                                                  "headers");
72         struct ast_json *get_params_obj = ast_json_object_get(message, "get_params");
73         struct ast_json *path_vars_obj = ast_json_object_get(message, "path_vars");
74         struct ast_json *headers_obj = ast_json_object_get(message, "headers");
75
76         for (; get_params != NULL; get_params = get_params->next) {
77                 ast_json_object_set(get_params_obj, get_params->name, ast_json_string_create(get_params->value));
78         }
79
80         for (; path_vars != NULL; path_vars = path_vars->next) {
81                 ast_json_object_set(path_vars_obj, path_vars->name, ast_json_string_create(path_vars->value));
82         }
83
84         for (; headers != NULL; headers = headers->next) {
85                 ast_json_object_set(headers_obj, headers->name, ast_json_string_create(headers->value));
86         }
87
88         ++invocation_count;
89         response->response_code = response_code;
90         response->message = message;
91 }
92
93 /*!
94  * \internal
95  * Macro to reduce the handler definition boiler-plate.
96  */
97 #define HANDLER(name, response_code)                                    \
98         static void name(struct ast_tcptls_session_instance *ser,       \
99                 struct ast_variable *get_params,                        \
100                 struct ast_variable *path_vars,                         \
101                 struct ast_variable *headers,                           \
102                 struct ast_ari_response *response)                      \
103         {                                                               \
104                 handler(#name, response_code, get_params, path_vars, headers, response); \
105         }
106
107 HANDLER(bang_get, 200)
108 HANDLER(bang_post, 200)
109 HANDLER(bang_delete, 204)
110 HANDLER(bar_get, 200)
111 HANDLER(bar_post, 200)
112 HANDLER(bam_get, 200)
113 HANDLER(foo_get, 200)
114
115 static struct stasis_rest_handlers bang = {
116         .path_segment = "bang",
117         .callbacks = {
118                 [AST_HTTP_GET] = bang_get,
119                 [AST_HTTP_POST] = bang_post,
120                 [AST_HTTP_DELETE] = bang_delete,
121         },
122         .num_children = 0
123 };
124 static struct stasis_rest_handlers bar = {
125         .path_segment = "bar",
126         .callbacks = {
127                 [AST_HTTP_GET] = bar_get,
128                 [AST_HTTP_POST] = bar_post,
129         },
130         .num_children = 0
131 };
132 static struct stasis_rest_handlers bam = {
133         .path_segment = "bam",
134         .is_wildcard = 1,
135         .callbacks = {
136                 [AST_HTTP_GET] = bam_get,
137         },
138         .num_children = 1,
139         .children = { &bang }
140 };
141 static struct stasis_rest_handlers test_root = {
142         .path_segment = "foo",
143         .callbacks = {
144                 [AST_HTTP_GET] = foo_get,
145         },
146         .num_children = 3,
147         .children = { &bar, &bam, &bang }
148 };
149 /*!@}*/
150
151 /*!
152  * \internal
153  * \c ast_ari_response constructor.
154  */
155 static struct ast_ari_response *response_alloc(void)
156 {
157         struct ast_ari_response *resp = ast_calloc(1, sizeof(struct ast_ari_response));
158         resp->headers = ast_str_create(24);
159         return resp;
160 }
161
162 /*!
163  * \internal
164  * \c ast_ari_response destructor.
165  */
166 static void response_free(struct ast_ari_response *resp)
167 {
168         if (!resp) {
169                 return;
170         }
171         ast_free(resp->headers);
172         ast_json_unref(resp->message);
173         ast_free(resp);
174 }
175
176 /*!
177  * \ internal
178  * Setup test fixture for invocation tests.
179  */
180 static void *setup_invocation_test(void) {
181         int r;
182         invocation_count = 0;
183         r = ast_ari_add_handler(&test_root);
184         ast_assert(r == 0);
185         return &invocation_count;
186 }
187
188 /*!
189  * \ internal
190  * Tear down test fixture for invocation tests.
191  */
192 static void tear_down_invocation_test(void *ignore) {
193         if (!ignore) {
194                 return;
195         }
196         ast_ari_remove_handler(&test_root);
197 }
198
199
200 AST_TEST_DEFINE(get_docs)
201 {
202         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
203         RAII_VAR(struct ast_variable *, headers, NULL, ast_variables_destroy);
204         struct ast_json *basePathJson;
205         const char *basePath;
206
207         switch (cmd) {
208         case TEST_INIT:
209                 info->name = __func__;
210                 info->category = "/res/ari/";
211                 info->summary = "Test simple API get.";
212                 info->description = "Test ARI binding logic.";
213                 return AST_TEST_NOT_RUN;
214         case TEST_EXECUTE:
215                 break;
216         }
217
218         response = response_alloc();
219         headers = ast_variable_new("Host", "stasis.asterisk.org", __FILE__);
220         ast_ari_get_docs("resources.json", headers, response);
221         ast_test_validate(test, 200 == response->response_code);
222
223         /* basePath should be relative to the Host header */
224         basePathJson = ast_json_object_get(response->message, "basePath");
225         ast_test_validate(test, NULL != basePathJson);
226         basePath = ast_json_string_get(basePathJson);
227         ast_test_validate(test, 0 == strcmp("http://stasis.asterisk.org/ari", basePath));
228
229         return AST_TEST_PASS;
230 }
231
232 AST_TEST_DEFINE(get_docs_nohost)
233 {
234         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
235         struct ast_variable *headers = NULL;
236         struct ast_json *basePathJson;
237
238         switch (cmd) {
239         case TEST_INIT:
240                 info->name = __func__;
241                 info->category = "/res/ari/";
242                 info->summary = "Test API get without a Host header";
243                 info->description = "Test ARI binding logic.";
244                 return AST_TEST_NOT_RUN;
245         case TEST_EXECUTE:
246                 break;
247         }
248
249         response = response_alloc();
250         ast_ari_get_docs("resources.json", headers, response);
251         ast_test_validate(test, 200 == response->response_code);
252
253         /* basePath should be relative to the Host header */
254         basePathJson = ast_json_object_get(response->message, "basePath");
255         ast_test_validate(test, NULL == basePathJson);
256
257         return AST_TEST_PASS;
258 }
259
260 AST_TEST_DEFINE(get_docs_notfound)
261 {
262         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
263         struct ast_variable *headers = NULL;
264
265         switch (cmd) {
266         case TEST_INIT:
267                 info->name = __func__;
268                 info->category = "/res/ari/";
269                 info->summary = "Test API get for invalid resource";
270                 info->description = "Test ARI binding logic.";
271                 return AST_TEST_NOT_RUN;
272         case TEST_EXECUTE:
273                 break;
274         }
275
276         response = response_alloc();
277         ast_ari_get_docs("i-am-not-a-resource.json", headers, response);
278         ast_test_validate(test, 404 == response->response_code);
279
280         return AST_TEST_PASS;
281 }
282
283 AST_TEST_DEFINE(get_docs_hackerz)
284 {
285         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
286         struct ast_variable *headers = NULL;
287
288         switch (cmd) {
289         case TEST_INIT:
290                 info->name = __func__;
291                 info->category = "/res/ari/";
292                 info->summary = "Test API get for a file outside the rest-api path";
293                 info->description = "Test ARI binding logic.";
294                 return AST_TEST_NOT_RUN;
295         case TEST_EXECUTE:
296                 break;
297         }
298
299         response = response_alloc();
300         ast_ari_get_docs("../../../../sbin/asterisk", headers, response);
301         ast_test_validate(test, 404 == response->response_code);
302
303         return AST_TEST_PASS;
304 }
305
306 AST_TEST_DEFINE(invoke_get)
307 {
308         RAII_VAR(void *, fixture, NULL, tear_down_invocation_test);
309         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
310         RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
311         struct ast_variable *get_params = NULL;
312         struct ast_variable *headers = NULL;
313
314         switch (cmd) {
315         case TEST_INIT:
316                 info->name = __func__;
317                 info->category = "/res/ari/";
318                 info->summary = "Test simple GET of an HTTP resource.";
319                 info->description = "Test ARI binding logic.";
320                 return AST_TEST_NOT_RUN;
321         case TEST_EXECUTE:
322                 break;
323         }
324
325         fixture = setup_invocation_test();
326         response = response_alloc();
327         get_params = ast_variable_new("get1", "get-one", __FILE__);
328         ast_assert(get_params != NULL);
329         get_params->next = ast_variable_new("get2", "get-two", __FILE__);
330         ast_assert(get_params->next != NULL);
331
332         headers = ast_variable_new("head1", "head-one", __FILE__);
333         ast_assert(headers != NULL);
334         headers->next = ast_variable_new("head2", "head-two", __FILE__);
335         ast_assert(headers->next != NULL);
336
337         expected = ast_json_pack("{s: s, s: {s: s, s: s}, s: {s: s, s: s}, s: {}}",
338                                  "name", "foo_get",
339                                  "get_params",
340                                  "get1", "get-one",
341                                  "get2", "get-two",
342                                  "headers",
343                                  "head1", "head-one",
344                                  "head2", "head-two",
345                                  "path_vars");
346
347         ast_ari_invoke(NULL, "foo", AST_HTTP_GET, get_params, headers, response);
348
349         ast_test_validate(test, 1 == invocation_count);
350         ast_test_validate(test, 200 == response->response_code);
351         ast_test_validate(test, ast_json_equal(expected, response->message));
352
353         return AST_TEST_PASS;
354 }
355
356 AST_TEST_DEFINE(invoke_wildcard)
357 {
358         RAII_VAR(void *, fixture, NULL, tear_down_invocation_test);
359         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
360         RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
361         struct ast_variable *get_params = NULL;
362         struct ast_variable *headers = NULL;
363
364         switch (cmd) {
365         case TEST_INIT:
366                 info->name = __func__;
367                 info->category = "/res/ari/";
368                 info->summary = "Test GET of a wildcard resource.";
369                 info->description = "Test ARI binding logic.";
370                 return AST_TEST_NOT_RUN;
371         case TEST_EXECUTE:
372                 break;
373         }
374
375         fixture = setup_invocation_test();
376         response = response_alloc();
377         expected = ast_json_pack("{s: s, s: {}, s: {}, s: {s: s}}",
378                                  "name", "bam_get",
379                                  "get_params",
380                                  "headers",
381                                  "path_vars",
382                                  "bam", "foshizzle");
383
384         ast_ari_invoke(NULL, "foo/foshizzle", AST_HTTP_GET, get_params, headers, response);
385
386         ast_test_validate(test, 1 == invocation_count);
387         ast_test_validate(test, 200 == response->response_code);
388         ast_test_validate(test, ast_json_equal(expected, response->message));
389
390         return AST_TEST_PASS;
391 }
392
393 AST_TEST_DEFINE(invoke_delete)
394 {
395         RAII_VAR(void *, fixture, NULL, tear_down_invocation_test);
396         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
397         RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
398         struct ast_variable *get_params = NULL;
399         struct ast_variable *headers = NULL;
400
401         switch (cmd) {
402         case TEST_INIT:
403                 info->name = __func__;
404                 info->category = "/res/ari/";
405                 info->summary = "Test DELETE of an HTTP resource.";
406                 info->description = "Test ARI binding logic.";
407                 return AST_TEST_NOT_RUN;
408         case TEST_EXECUTE:
409                 break;
410         }
411
412         fixture = setup_invocation_test();
413         response = response_alloc();
414         expected = ast_json_pack("{s: s, s: {}, s: {}, s: {s: s}}",
415                                  "name", "bang_delete",
416                                  "get_params",
417                                  "headers",
418                                  "path_vars",
419                                  "bam", "foshizzle");
420
421         ast_ari_invoke(NULL, "foo/foshizzle/bang", AST_HTTP_DELETE, get_params, headers, response);
422
423         ast_test_validate(test, 1 == invocation_count);
424         ast_test_validate(test, 204 == response->response_code);
425         ast_test_validate(test, ast_json_equal(expected, response->message));
426
427         return AST_TEST_PASS;
428 }
429
430 AST_TEST_DEFINE(invoke_post)
431 {
432         RAII_VAR(void *, fixture, NULL, tear_down_invocation_test);
433         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
434         RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
435         struct ast_variable *get_params = NULL;
436         struct ast_variable *headers = NULL;
437
438         switch (cmd) {
439         case TEST_INIT:
440                 info->name = __func__;
441                 info->category = "/res/ari/";
442                 info->summary = "Test POST of an HTTP resource.";
443                 info->description = "Test ARI binding logic.";
444                 return AST_TEST_NOT_RUN;
445         case TEST_EXECUTE:
446                 break;
447         }
448
449         fixture = setup_invocation_test();
450         response = response_alloc();
451         get_params = ast_variable_new("get1", "get-one", __FILE__);
452         ast_assert(get_params != NULL);
453         get_params->next = ast_variable_new("get2", "get-two", __FILE__);
454         ast_assert(get_params->next != NULL);
455
456         headers = ast_variable_new("head1", "head-one", __FILE__);
457         ast_assert(headers != NULL);
458         headers->next = ast_variable_new("head2", "head-two", __FILE__);
459         ast_assert(headers->next != NULL);
460
461         expected = ast_json_pack("{s: s, s: {s: s, s: s}, s: {s: s, s: s}, s: {}}",
462                                  "name", "bar_post",
463                                  "get_params",
464                                  "get1", "get-one",
465                                  "get2", "get-two",
466                                  "headers",
467                                  "head1", "head-one",
468                                  "head2", "head-two",
469                                  "path_vars");
470
471         ast_ari_invoke(NULL, "foo/bar", AST_HTTP_POST, get_params, headers, response);
472
473         ast_test_validate(test, 1 == invocation_count);
474         ast_test_validate(test, 200 == response->response_code);
475         ast_test_validate(test, ast_json_equal(expected, response->message));
476
477         return AST_TEST_PASS;
478 }
479
480 AST_TEST_DEFINE(invoke_bad_post)
481 {
482         RAII_VAR(void *, fixture, NULL, tear_down_invocation_test);
483         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
484         struct ast_variable *get_params = NULL;
485         struct ast_variable *headers = NULL;
486
487         switch (cmd) {
488         case TEST_INIT:
489                 info->name = __func__;
490                 info->category = "/res/ari/";
491                 info->summary = "Test POST on a resource that doesn't support it.";
492                 info->description = "Test ARI binding logic.";
493                 return AST_TEST_NOT_RUN;
494         case TEST_EXECUTE:
495                 break;
496         }
497
498         fixture = setup_invocation_test();
499         response = response_alloc();
500         ast_ari_invoke(NULL, "foo", AST_HTTP_POST, get_params, headers, response);
501
502         ast_test_validate(test, 0 == invocation_count);
503         ast_test_validate(test, 405 == response->response_code);
504
505         return AST_TEST_PASS;
506 }
507
508 AST_TEST_DEFINE(invoke_not_found)
509 {
510         RAII_VAR(void *, fixture, NULL, tear_down_invocation_test);
511         RAII_VAR(struct ast_ari_response *, response, NULL, response_free);
512         struct ast_variable *get_params = NULL;
513         struct ast_variable *headers = NULL;
514
515         switch (cmd) {
516         case TEST_INIT:
517                 info->name = __func__;
518                 info->category = "/res/ari/";
519                 info->summary = "Test GET on a resource that does not exist.";
520                 info->description = "Test ARI binding logic.";
521                 return AST_TEST_NOT_RUN;
522         case TEST_EXECUTE:
523                 break;
524         }
525
526         fixture = setup_invocation_test();
527         response = response_alloc();
528         ast_ari_invoke(NULL, "foo/fizzle/i-am-not-a-resource", AST_HTTP_GET, get_params, headers, response);
529
530         ast_test_validate(test, 0 == invocation_count);
531         ast_test_validate(test, 404 == response->response_code);
532
533         return AST_TEST_PASS;
534 }
535
536 static int unload_module(void)
537 {
538         AST_TEST_UNREGISTER(get_docs);
539         AST_TEST_UNREGISTER(get_docs_nohost);
540         AST_TEST_UNREGISTER(get_docs_notfound);
541         AST_TEST_UNREGISTER(get_docs_hackerz);
542         AST_TEST_UNREGISTER(invoke_get);
543         AST_TEST_UNREGISTER(invoke_wildcard);
544         AST_TEST_UNREGISTER(invoke_delete);
545         AST_TEST_UNREGISTER(invoke_post);
546         AST_TEST_UNREGISTER(invoke_bad_post);
547         AST_TEST_UNREGISTER(invoke_not_found);
548         return 0;
549 }
550
551 static int load_module(void)
552 {
553         AST_TEST_REGISTER(get_docs);
554         AST_TEST_REGISTER(get_docs_nohost);
555         AST_TEST_REGISTER(get_docs_notfound);
556         AST_TEST_REGISTER(get_docs_hackerz);
557         AST_TEST_REGISTER(invoke_get);
558         AST_TEST_REGISTER(invoke_wildcard);
559         AST_TEST_REGISTER(invoke_delete);
560         AST_TEST_REGISTER(invoke_post);
561         AST_TEST_REGISTER(invoke_bad_post);
562         AST_TEST_REGISTER(invoke_not_found);
563         return AST_MODULE_LOAD_SUCCESS;
564 }
565
566 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "ARI testing",
567         .load = load_module,
568         .unload = unload_module,
569         .nonoptreq = "res_ari",
570         );