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