diff options
Diffstat (limited to 'tests/test_stasis_http.c')
-rw-r--r-- | tests/test_stasis_http.c | 547 |
1 files changed, 547 insertions, 0 deletions
diff --git a/tests/test_stasis_http.c b/tests/test_stasis_http.c new file mode 100644 index 000000000..953c1023f --- /dev/null +++ b/tests/test_stasis_http.c @@ -0,0 +1,547 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2013, Digium, Inc. + * + * David M. Lee, II <dlee@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! + * \file \brief Test Stasis HTTP API. + * \author\verbatim David M. Lee, II <dlee@digium.com> \endverbatim + * + * \ingroup tests + */ + +/*** MODULEINFO + <depend>TEST_FRAMEWORK</depend> + <depend>res_stasis_http</depend> + <support_level>core</support_level> + ***/ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include "asterisk/module.h" +#include "asterisk/test.h" +#include "asterisk/stasis_http.h" + +/*!@{*/ + +/*! + * \internal + * The following code defines a simple RESTful API for unit testing. The + * response encodes the inputs of the invocation. The invocation_count + * counter is also incremented. + * + * - /foo (GET) + * - /foo/bar (GET, POST) + * - /foo/{bam} (GET) + * - /foo/{bam}/bang (GET, POST, DE1LETE) + */ + +static int invocation_count; + +/*! + * \internal + * Shared code for all handlers + */ +static void handler(const char *name, + int response_code, + struct ast_variable *get_params, + struct ast_variable *path_vars, + struct ast_variable *headers, + struct stasis_http_response *response) +{ + struct ast_json *message = ast_json_pack("{s: s, s: {}, s: {}, s: {}}", + "name", name, + "get_params", + "path_vars", + "headers"); + struct ast_json *get_params_obj = ast_json_object_get(message, "get_params"); + struct ast_json *path_vars_obj = ast_json_object_get(message, "path_vars"); + struct ast_json *headers_obj = ast_json_object_get(message, "headers"); + + for (; get_params != NULL; get_params = get_params->next) { + ast_json_object_set(get_params_obj, get_params->name, ast_json_string_create(get_params->value)); + } + + for (; path_vars != NULL; path_vars = path_vars->next) { + ast_json_object_set(path_vars_obj, path_vars->name, ast_json_string_create(path_vars->value)); + } + + for (; headers != NULL; headers = headers->next) { + ast_json_object_set(headers_obj, headers->name, ast_json_string_create(headers->value)); + } + + ++invocation_count; + response->response_code = response_code; + response->message = message; +} + +/*! + * \internal + * Macro to reduce the handler definition boiler-plate. + */ +#define HANDLER(name, response_code) \ + static void name(struct ast_variable *get_params, \ + struct ast_variable *path_vars, \ + struct ast_variable *headers, \ + struct stasis_http_response *response) \ + { \ + handler(#name, response_code, get_params, path_vars, headers, response); \ + } + +HANDLER(bang_get, 200) +HANDLER(bang_post, 200) +HANDLER(bang_delete, 204) +HANDLER(bar_get, 200) +HANDLER(bar_post, 200) +HANDLER(bam_get, 200) +HANDLER(foo_get, 200) + +static struct stasis_rest_handlers bang = { + .path_segment = "bang", + .callbacks = { + [AST_HTTP_GET] = bang_get, + [AST_HTTP_POST] = bang_post, + [AST_HTTP_DELETE] = bang_delete, + }, + .num_children = 0 +}; +static struct stasis_rest_handlers bar = { + .path_segment = "bar", + .callbacks = { + [AST_HTTP_GET] = bar_get, + [AST_HTTP_POST] = bar_post, + }, + .num_children = 0 +}; +static struct stasis_rest_handlers bam = { + .path_segment = "bam", + .is_wildcard = 1, + .callbacks = { + [AST_HTTP_GET] = bam_get, + }, + .num_children = 1, + .children = { &bang } +}; +static struct stasis_rest_handlers test_root = { + .path_segment = "foo", + .callbacks = { + [AST_HTTP_GET] = foo_get, + }, + .num_children = 3, + .children = { &bar, &bam, &bang } +}; +/*!@}*/ + +/*! + * \internal + * \c stasis_http_response constructor. + */ +static struct stasis_http_response *response_alloc(void) +{ + struct stasis_http_response *resp = ast_calloc(1, sizeof(struct stasis_http_response)); + resp->headers = ast_str_create(24); + return resp; +} + +/*! + * \internal + * \c stasis_http_response destructor. + */ +static void response_free(struct stasis_http_response *resp) +{ + ast_free(resp->headers); + ast_json_unref(resp->message); + ast_free(resp); +} + +/*! + * \ internal + * Setup test fixture for invocation tests. + */ +static void *setup_invocation_test(void) { + int r; + invocation_count = 0; + r = stasis_http_add_handler(&test_root); + ast_assert(r == 0); + return NULL; +} + +/*! + * \ internal + * Tear down test fixture for invocation tests. + */ +static void tear_down_invocation_test(void *ignore) { + stasis_http_remove_handler(&test_root); +} + + +AST_TEST_DEFINE(get_docs) +{ + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + RAII_VAR(struct ast_variable *, headers, NULL, ast_variables_destroy); + struct ast_json *basePathJson; + const char *basePath; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test simple API get."; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + headers = ast_variable_new("Host", "stasis.asterisk.org", __FILE__); + stasis_http_get_docs("resources.json", headers, response); + ast_test_validate(test, 200 == response->response_code); + + /* basePath should be relative to the Host header */ + basePathJson = ast_json_object_get(response->message, "basePath"); + ast_test_validate(test, NULL != basePathJson); + basePath = ast_json_string_get(basePathJson); + ast_test_validate(test, 0 == strcmp("http://stasis.asterisk.org/stasis", basePath)); + + return AST_TEST_PASS; +} + +AST_TEST_DEFINE(get_docs_nohost) +{ + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + struct ast_variable *headers = NULL; + struct ast_json *basePathJson; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test API get without a Host header"; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + stasis_http_get_docs("resources.json", headers, response); + ast_test_validate(test, 200 == response->response_code); + + /* basePath should be relative to the Host header */ + basePathJson = ast_json_object_get(response->message, "basePath"); + ast_test_validate(test, NULL == basePathJson); + + return AST_TEST_PASS; +} + +AST_TEST_DEFINE(get_docs_notfound) +{ + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + struct ast_variable *headers = NULL; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test API get for invalid resource"; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + stasis_http_get_docs("i-am-not-a-resource.json", headers, response); + ast_test_validate(test, 404 == response->response_code); + + return AST_TEST_PASS; +} + +AST_TEST_DEFINE(get_docs_hackerz) +{ + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + struct ast_variable *headers = NULL; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test API get for a file outside the rest-api path"; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + stasis_http_get_docs("../../../../sbin/asterisk", headers, response); + ast_test_validate(test, 404 == response->response_code); + + return AST_TEST_PASS; +} + +AST_TEST_DEFINE(invoke_get) +{ + RAII_VAR(void *, fixture, setup_invocation_test(), tear_down_invocation_test); + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref); + struct ast_variable *get_params = NULL; + struct ast_variable *headers = NULL; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test simple GET of an HTTP resource."; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + get_params = ast_variable_new("get1", "get-one", __FILE__); + ast_assert(get_params != NULL); + get_params->next = ast_variable_new("get2", "get-two", __FILE__); + ast_assert(get_params->next != NULL); + + headers = ast_variable_new("head1", "head-one", __FILE__); + ast_assert(headers != NULL); + headers->next = ast_variable_new("head2", "head-two", __FILE__); + ast_assert(headers->next != NULL); + + expected = ast_json_pack("{s: s, s: {s: s, s: s}, s: {s: s, s: s}, s: {}}", + "name", "foo_get", + "get_params", + "get1", "get-one", + "get2", "get-two", + "headers", + "head1", "head-one", + "head2", "head-two", + "path_vars"); + + stasis_http_invoke("foo", AST_HTTP_GET, get_params, headers, response); + + ast_test_validate(test, 1 == invocation_count); + ast_test_validate(test, 200 == response->response_code); + ast_test_validate(test, ast_json_equal(expected, response->message)); + + return AST_TEST_PASS; +} + +AST_TEST_DEFINE(invoke_wildcard) +{ + RAII_VAR(void *, fixture, setup_invocation_test(), tear_down_invocation_test); + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref); + struct ast_variable *get_params = NULL; + struct ast_variable *headers = NULL; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test GET of a wildcard resource."; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + expected = ast_json_pack("{s: s, s: {}, s: {}, s: {s: s}}", + "name", "bam_get", + "get_params", + "headers", + "path_vars", + "bam", "foshizzle"); + + stasis_http_invoke("foo/foshizzle", AST_HTTP_GET, get_params, headers, response); + + ast_test_validate(test, 1 == invocation_count); + ast_test_validate(test, 200 == response->response_code); + ast_test_validate(test, ast_json_equal(expected, response->message)); + + return AST_TEST_PASS; +} + +AST_TEST_DEFINE(invoke_delete) +{ + RAII_VAR(void *, fixture, setup_invocation_test(), tear_down_invocation_test); + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref); + struct ast_variable *get_params = NULL; + struct ast_variable *headers = NULL; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test DELETE of an HTTP resource."; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + expected = ast_json_pack("{s: s, s: {}, s: {}, s: {s: s}}", + "name", "bang_delete", + "get_params", + "headers", + "path_vars", + "bam", "foshizzle"); + + stasis_http_invoke("foo/foshizzle/bang", AST_HTTP_DELETE, get_params, headers, response); + + ast_test_validate(test, 1 == invocation_count); + ast_test_validate(test, 204 == response->response_code); + ast_test_validate(test, ast_json_equal(expected, response->message)); + + return AST_TEST_PASS; +} + +AST_TEST_DEFINE(invoke_post) +{ + RAII_VAR(void *, fixture, setup_invocation_test(), tear_down_invocation_test); + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref); + struct ast_variable *get_params = NULL; + struct ast_variable *headers = NULL; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test POST of an HTTP resource."; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + get_params = ast_variable_new("get1", "get-one", __FILE__); + ast_assert(get_params != NULL); + get_params->next = ast_variable_new("get2", "get-two", __FILE__); + ast_assert(get_params->next != NULL); + + headers = ast_variable_new("head1", "head-one", __FILE__); + ast_assert(headers != NULL); + headers->next = ast_variable_new("head2", "head-two", __FILE__); + ast_assert(headers->next != NULL); + + expected = ast_json_pack("{s: s, s: {s: s, s: s}, s: {s: s, s: s}, s: {}}", + "name", "bar_post", + "get_params", + "get1", "get-one", + "get2", "get-two", + "headers", + "head1", "head-one", + "head2", "head-two", + "path_vars"); + + stasis_http_invoke("foo/bar", AST_HTTP_POST, get_params, headers, response); + + ast_test_validate(test, 1 == invocation_count); + ast_test_validate(test, 200 == response->response_code); + ast_test_validate(test, ast_json_equal(expected, response->message)); + + return AST_TEST_PASS; +} + +AST_TEST_DEFINE(invoke_bad_post) +{ + RAII_VAR(void *, fixture, setup_invocation_test(), tear_down_invocation_test); + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + struct ast_variable *get_params = NULL; + struct ast_variable *headers = NULL; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test POST on a resource that doesn't support it."; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + stasis_http_invoke("foo", AST_HTTP_POST, get_params, headers, response); + + ast_test_validate(test, 0 == invocation_count); + ast_test_validate(test, 405 == response->response_code); + + return AST_TEST_PASS; +} + +AST_TEST_DEFINE(invoke_not_found) +{ + RAII_VAR(void *, fixture, setup_invocation_test(), tear_down_invocation_test); + RAII_VAR(struct stasis_http_response *, response, response_alloc(), response_free); + struct ast_variable *get_params = NULL; + struct ast_variable *headers = NULL; + + switch (cmd) { + case TEST_INIT: + info->name = __func__; + info->category = "/stasis/http/"; + info->summary = "Test GET on a resource that does not exist."; + info->description = "Test Stasis HTTP binding logic."; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + stasis_http_invoke("foo/fizzle/i-am-not-a-resource", AST_HTTP_GET, get_params, headers, response); + + ast_test_validate(test, 0 == invocation_count); + ast_test_validate(test, 404 == response->response_code); + + return AST_TEST_PASS; +} + +static int unload_module(void) +{ + AST_TEST_UNREGISTER(get_docs); + AST_TEST_UNREGISTER(get_docs_nohost); + AST_TEST_UNREGISTER(get_docs_notfound); + AST_TEST_UNREGISTER(get_docs_hackerz); + AST_TEST_UNREGISTER(invoke_get); + AST_TEST_UNREGISTER(invoke_wildcard); + AST_TEST_UNREGISTER(invoke_delete); + AST_TEST_UNREGISTER(invoke_post); + AST_TEST_UNREGISTER(invoke_bad_post); + AST_TEST_UNREGISTER(invoke_not_found); + return 0; +} + +static int load_module(void) +{ + AST_TEST_REGISTER(get_docs); + AST_TEST_REGISTER(get_docs_nohost); + AST_TEST_REGISTER(get_docs_notfound); + AST_TEST_REGISTER(get_docs_hackerz); + AST_TEST_REGISTER(invoke_get); + AST_TEST_REGISTER(invoke_wildcard); + AST_TEST_REGISTER(invoke_delete); + AST_TEST_REGISTER(invoke_post); + AST_TEST_REGISTER(invoke_bad_post); + AST_TEST_REGISTER(invoke_not_found); + return AST_MODULE_LOAD_SUCCESS; +} + +AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Stasis HTTP testing", + .load = load_module, + .unload = unload_module, + .nonoptreq = "res_stasis_http", + ); |