test_res_prometheus.c File Reference

#include "asterisk.h"
#include <curl/curl.h>
#include "asterisk/test.h"
#include "asterisk/module.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_basic.h"
#include "asterisk/config.h"
#include "asterisk/res_prometheus.h"
#include "../res/prometheus/prometheus_internal.h"

Include dependency graph for test_res_prometheus.c:

Go to the source code of this file.

Macros
#define	CATEGORY   "/res/prometheus/"

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (bridge_to_string)
	AST_TEST_DEFINE (config_general_basic_auth)
	AST_TEST_DEFINE (config_general_core_metrics)
	AST_TEST_DEFINE (config_general_enabled)
	AST_TEST_DEFINE (counter_create)
	AST_TEST_DEFINE (counter_to_string)
	AST_TEST_DEFINE (gauge_create)
	AST_TEST_DEFINE (gauge_to_string)
	AST_TEST_DEFINE (metric_callback_register)
	AST_TEST_DEFINE (metric_register)
	AST_TEST_DEFINE (metric_values)
static struct prometheus_general_config *	config_alloc (void)
static void	curl_free_wrapper (void *ptr)
static size_t	curl_write_string_callback (void *contents, size_t size, size_t nmemb, void *userdata)
static CURL *	get_curl_instance (void)
static int	load_module (void)
static int	match_count (const char *str, const char *needle)
static void	metric_values_get_counter_value_cb (struct prometheus_metric *metric)
static int	process_config (int reload)
static void	prometheus_metric_callback (struct ast_str **output)
static void	prometheus_metric_free_wrapper (void *ptr)
static int	reload_module (void)
static void	safe_bridge_destroy (struct ast_bridge *bridge)
static int	test_cleanup_cb (struct ast_test_info *info, struct ast_test *test)
static int	test_init_cb (struct ast_test_info *info, struct ast_test *test)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Prometheus Core Unit Tests" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .reload = reload_module, .unload = unload_module, .requires = "res_prometheus", }
static const struct ast_module_info *	ast_module_info = &__mod_info
struct prometheus_general_config *	module_config
static char	server_uri [512]

Macro Definition Documentation

CATEGORY

#define CATEGORY   "/res/prometheus/"

Definition at line 38 of file test_res_prometheus.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 897 of file test_res_prometheus.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 897 of file test_res_prometheus.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 897 of file test_res_prometheus.c.

AST_TEST_DEFINE() [1/11]

AST_TEST_DEFINE

(

bridge_to_string

)

Definition at line 725 of file test_res_prometheus.c.

{
    RAII_VAR(struct ast_bridge *, bridge1, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_bridge *, bridge2, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_bridge *, bridge3, NULL, safe_bridge_destroy);
    struct ast_str *response;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test producing bridge metrics";
        info->description =
            "This test covers checking the metrics produced by the\n"
            "bridge support of the basic Promtheus module.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    bridge1 = ast_bridge_basic_new();
    ast_test_validate(test, bridge1 != NULL);
 
    bridge2 = ast_bridge_base_new(AST_BRIDGE_CAPABILITY_HOLDING,
        AST_BRIDGE_FLAG_INVISIBLE,
        "test_res_prometheus", "test_bridge_invisible", NULL);
 
    bridge3 = ast_bridge_basic_new();
    ast_test_validate(test, bridge3 != NULL);
 
    response = prometheus_scrape_to_string();
    if (!response) {
        return AST_TEST_FAIL;
    }
 
    ast_test_status_update(test, " -> Retrieved: %s\n", ast_str_buffer(response));
    ast_test_validate(test, strstr(ast_str_buffer(response), "(null)") == NULL);
    ast_test_validate(test, strstr(ast_str_buffer(response), "asterisk_bridges_channels_count{") != NULL);
    ast_test_validate(test, match_count(ast_str_buffer(response), "# HELP asterisk_bridges_channels_count Number of channels in the bridge.") == 1);
    ast_free(response);
    return AST_TEST_PASS;
}

References ast_bridge_base_new(), ast_bridge_basic_new(), AST_BRIDGE_CAPABILITY_HOLDING, AST_BRIDGE_FLAG_INVISIBLE, ast_free, ast_str_buffer(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CATEGORY, sip_to_pjsip::info(), match_count(), NULL, prometheus_scrape_to_string(), RAII_VAR, safe_bridge_destroy(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [2/11]

AST_TEST_DEFINE

(

config_general_basic_auth

)

Definition at line 521 of file test_res_prometheus.c.

{
    RAII_VAR(CURL *, curl, NULL, curl_free_wrapper);
    struct prometheus_general_config *config;
    int res;
    long response_code;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test basic auth handling";
        info->description =
            "This test covers authentication of requests";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    config = config_alloc();
    if (!config) {
        return AST_TEST_NOT_RUN;
    }
    ast_string_field_set(config, auth_username, "foo");
    ast_string_field_set(config, auth_password, "bar");
    /* Prometheus module owns the ref after this call */
    prometheus_general_config_set(config);
    ao2_ref(config, -1);
 
    curl = get_curl_instance();
    if (!curl) {
        return AST_TEST_NOT_RUN;
    }
 
    ast_test_status_update(test, "Testing without auth credentials\n");
    ast_test_status_update(test, " -> CURLing request...\n");
    res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        ast_test_status_update(test, "Failed to execute CURL: %d\n", res);
        return AST_TEST_FAIL;
    }
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
    ast_test_status_update(test, " -> CURL returned %ld\n", response_code);
    ast_test_validate(test, response_code == 401);
 
    ast_test_status_update(test, "Testing with invalid auth credentials\n");
    ast_test_status_update(test, " -> CURLing request...\n");
    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
    curl_easy_setopt(curl, CURLOPT_USERPWD, "matt:jordan");
    res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        ast_test_status_update(test, "Failed to execute CURL: %d\n", res);
        return AST_TEST_FAIL;
    }
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
    ast_test_status_update(test, " -> CURL returned %ld\n", response_code);
    ast_test_validate(test, response_code == 401);
 
    ast_test_status_update(test, "Testing with valid auth credentials\n");
    ast_test_status_update(test, " -> CURLing request...\n");
    curl_easy_setopt(curl, CURLOPT_USERPWD, "foo:bar");
    res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        ast_test_status_update(test, "Failed to execute CURL: %d\n", res);
        return AST_TEST_FAIL;
    }
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
    ast_test_status_update(test, " -> CURL returned %ld\n", response_code);
    ast_test_validate(test, response_code == 200);
 
    return AST_TEST_PASS;
}

References ao2_ref, ast_string_field_set, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, prometheus_general_config::auth_password, prometheus_general_config::auth_username, CATEGORY, config, config_alloc(), curl_free_wrapper(), get_curl_instance(), sip_to_pjsip::info(), NULL, prometheus_general_config_set(), RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [3/11]

AST_TEST_DEFINE

(

config_general_core_metrics

)

Definition at line 641 of file test_res_prometheus.c.

{
    RAII_VAR(CURL *, curl, NULL, curl_free_wrapper);
    RAII_VAR(struct ast_str *, buffer, NULL, ast_free);
    struct prometheus_general_config *config;
    int res;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test producing core metrics";
        info->description =
            "This test covers the core metrics that are produced\n"
            "by the basic Prometheus module.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    buffer = ast_str_create(128);
    if (!buffer) {
        return AST_TEST_NOT_RUN;
    }
 
    config = config_alloc();
    if (!config) {
        return AST_TEST_NOT_RUN;
    }
    config->core_metrics_enabled = 1;
    /* Prometheus module owns the ref after this call */
    prometheus_general_config_set(config);
    ao2_ref(config, -1);
 
    curl = get_curl_instance();
    if (!curl) {
        return AST_TEST_NOT_RUN;
    }
 
    ast_test_status_update(test, " -> CURLing request...\n");
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_string_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
    res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        ast_test_status_update(test, "Failed to execute CURL: %d\n", res);
        return AST_TEST_FAIL;
    }
    ast_test_status_update(test, " -> Retrieved: %s\n", ast_str_buffer(buffer));
 
    ast_test_status_update(test, " -> Checking for core properties\n");
    ast_test_validate(test, strstr(ast_str_buffer(buffer), "asterisk_core_properties") != NULL);
 
    ast_test_status_update(test, " -> Checking for uptime\n");
    ast_test_validate(test, strstr(ast_str_buffer(buffer), "asterisk_core_uptime_seconds") != NULL);
 
    ast_test_status_update(test, " -> Checking for last reload\n");
    ast_test_validate(test, strstr(ast_str_buffer(buffer), "asterisk_core_last_reload_seconds") != NULL);
 
    ast_test_status_update(test, " -> Checking for scrape time\n");
    ast_test_validate(test, strstr(ast_str_buffer(buffer), "asterisk_core_scrape_time_ms") != NULL);
 
    return AST_TEST_PASS;
}

References ao2_ref, ast_free, ast_str_buffer(), ast_str_create, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CATEGORY, config, config_alloc(), curl_free_wrapper(), curl_write_string_callback(), get_curl_instance(), sip_to_pjsip::info(), NULL, prometheus_general_config_set(), RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [4/11]

AST_TEST_DEFINE

(

config_general_enabled

)

Definition at line 594 of file test_res_prometheus.c.

{
    RAII_VAR(CURL *, curl, NULL, curl_free_wrapper);
    struct prometheus_general_config *config;
    int res;
    long response_code;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test handling of enable/disable";
        info->description =
            "When disabled, the module should return a 503.\n"
            "This test verifies that it actually occurs.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    config = config_alloc();
    if (!config) {
        return AST_TEST_NOT_RUN;
    }
    config->enabled = 0;
    /* Prometheus module owns the ref after this call */
    prometheus_general_config_set(config);
    ao2_ref(config, -1);
 
    curl = get_curl_instance();
    if (!curl) {
        return AST_TEST_NOT_RUN;
    }
 
    ast_test_status_update(test, " -> CURLing request...\n");
    res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        ast_test_status_update(test, "Failed to execute CURL: %d\n", res);
        return AST_TEST_FAIL;
    }
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
    ast_test_status_update(test, " -> CURL returned %ld\n", response_code);
    ast_test_validate(test, response_code == 503);
 
    return AST_TEST_PASS;
}

References ao2_ref, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CATEGORY, config, config_alloc(), curl_free_wrapper(), get_curl_instance(), sip_to_pjsip::info(), NULL, prometheus_general_config_set(), RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [5/11]

AST_TEST_DEFINE

(

counter_create

)

Definition at line 408 of file test_res_prometheus.c.

{
    RAII_VAR(struct prometheus_metric *, metric, NULL, prometheus_metric_free_wrapper);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test creation (and destruction) of malloc'd counters";
        info->description =
            "This test covers creating a counter metric and destroying\n"
            "it. The metric should be malloc'd.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    metric = prometheus_counter_create("test_counter", "A test counter");
    ast_test_validate(test, metric != NULL);
    ast_test_validate(test, metric->type == PROMETHEUS_METRIC_COUNTER);
    ast_test_validate(test, metric->allocation_strategy = PROMETHEUS_METRIC_MALLOCD);
    ast_test_validate(test, !strcmp(metric->help, "A test counter"));
    ast_test_validate(test, !strcmp(metric->name, "test_counter"));
    ast_test_validate(test, !strcmp(metric->value, ""));
    ast_test_validate(test, metric->children.first == NULL);
    ast_test_validate(test, metric->children.last == NULL);
 
    return AST_TEST_PASS;
}

References AST_TEST_NOT_RUN, AST_TEST_PASS, CATEGORY, sip_to_pjsip::info(), NULL, prometheus_counter_create(), PROMETHEUS_METRIC_COUNTER, prometheus_metric_free_wrapper(), PROMETHEUS_METRIC_MALLOCD, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [6/11]

AST_TEST_DEFINE

(

counter_to_string

)

Definition at line 355 of file test_res_prometheus.c.

{
    struct prometheus_metric test_counter = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_COUNTER,
        "test_counter",
        "A test counter",
        NULL);
    struct prometheus_metric test_counter_child_one = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_COUNTER,
        "test_counter",
        "A test counter",
        NULL);
    struct prometheus_metric test_counter_child_two = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_COUNTER,
        "test_counter",
        "A test counter",
        NULL);
    RAII_VAR(struct ast_str *, buffer, NULL, ast_free);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test formatting of counters";
        info->description =
            "This test covers the formatting of printed counters";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    buffer = ast_str_create(128);
    if (!buffer) {
        return AST_TEST_FAIL;
    }
 
    PROMETHEUS_METRIC_SET_LABEL(&test_counter_child_one, 0, "key_one", "value_one");
    PROMETHEUS_METRIC_SET_LABEL(&test_counter_child_one, 1, "key_two", "value_one");
    PROMETHEUS_METRIC_SET_LABEL(&test_counter_child_two, 0, "key_one", "value_two");
    PROMETHEUS_METRIC_SET_LABEL(&test_counter_child_two, 1, "key_two", "value_two");
    AST_LIST_INSERT_TAIL(&test_counter.children, &test_counter_child_one, entry);
    AST_LIST_INSERT_TAIL(&test_counter.children, &test_counter_child_two, entry);
    prometheus_metric_to_string(&test_counter, &buffer);
    ast_test_validate(test, strcmp(ast_str_buffer(buffer),
        "# HELP test_counter A test counter\n"
        "# TYPE test_counter counter\n"
        "test_counter 0\n"
        "test_counter{key_one=\"value_one\",key_two=\"value_one\"} 0\n"
        "test_counter{key_one=\"value_two\",key_two=\"value_two\"} 0\n") == 0);
 
    return AST_TEST_PASS;
}

References ast_free, AST_LIST_INSERT_TAIL, ast_str_buffer(), ast_str_create, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, CATEGORY, prometheus_metric::children, sip_to_pjsip::info(), NULL, PROMETHEUS_METRIC_COUNTER, PROMETHEUS_METRIC_SET_LABEL, PROMETHEUS_METRIC_STATIC_INITIALIZATION, prometheus_metric_to_string(), RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [7/11]

AST_TEST_DEFINE

(

gauge_create

)

Definition at line 491 of file test_res_prometheus.c.

{
    RAII_VAR(struct prometheus_metric *, metric, NULL, prometheus_metric_free_wrapper);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test creation (and destruction) of malloc'd gauges";
        info->description =
            "This test covers creating a gauge metric and destroying\n"
            "it. The metric should be malloc'd.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    metric = prometheus_gauge_create("test_gauge", "A test gauge");
    ast_test_validate(test, metric != NULL);
    ast_test_validate(test, metric->type == PROMETHEUS_METRIC_GAUGE);
    ast_test_validate(test, metric->allocation_strategy = PROMETHEUS_METRIC_MALLOCD);
    ast_test_validate(test, !strcmp(metric->help, "A test gauge"));
    ast_test_validate(test, !strcmp(metric->name, "test_gauge"));
    ast_test_validate(test, !strcmp(metric->value, ""));
    ast_test_validate(test, metric->children.first == NULL);
    ast_test_validate(test, metric->children.last == NULL);
 
    return AST_TEST_PASS;
}

References AST_TEST_NOT_RUN, AST_TEST_PASS, CATEGORY, sip_to_pjsip::info(), NULL, prometheus_gauge_create(), prometheus_metric_free_wrapper(), PROMETHEUS_METRIC_GAUGE, PROMETHEUS_METRIC_MALLOCD, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [8/11]

AST_TEST_DEFINE

(

gauge_to_string

)

Definition at line 438 of file test_res_prometheus.c.

{
    struct prometheus_metric test_gauge = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_GAUGE,
        "test_gauge",
        "A test gauge",
        NULL);
    struct prometheus_metric test_gauge_child_one = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_GAUGE,
        "test_gauge",
        "A test gauge",
        NULL);
    struct prometheus_metric test_gauge_child_two = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_GAUGE,
        "test_gauge",
        "A test gauge",
        NULL);
    RAII_VAR(struct ast_str *, buffer, NULL, ast_free);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test formatting of gauges";
        info->description =
            "This test covers the formatting of printed gauges";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    buffer = ast_str_create(128);
    if (!buffer) {
        return AST_TEST_FAIL;
    }
 
    PROMETHEUS_METRIC_SET_LABEL(&test_gauge_child_one, 0, "key_one", "value_one");
    PROMETHEUS_METRIC_SET_LABEL(&test_gauge_child_one, 1, "key_two", "value_one");
    PROMETHEUS_METRIC_SET_LABEL(&test_gauge_child_two, 0, "key_one", "value_two");
    PROMETHEUS_METRIC_SET_LABEL(&test_gauge_child_two, 1, "key_two", "value_two");
    AST_LIST_INSERT_TAIL(&test_gauge.children, &test_gauge_child_one, entry);
    AST_LIST_INSERT_TAIL(&test_gauge.children, &test_gauge_child_two, entry);
    prometheus_metric_to_string(&test_gauge, &buffer);
    ast_test_validate(test, strcmp(ast_str_buffer(buffer),
        "# HELP test_gauge A test gauge\n"
        "# TYPE test_gauge gauge\n"
        "test_gauge 0\n"
        "test_gauge{key_one=\"value_one\",key_two=\"value_one\"} 0\n"
        "test_gauge{key_one=\"value_two\",key_two=\"value_two\"} 0\n") == 0);
 
    return AST_TEST_PASS;
}

References ast_free, AST_LIST_INSERT_TAIL, ast_str_buffer(), ast_str_create, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, CATEGORY, prometheus_metric::children, sip_to_pjsip::info(), NULL, PROMETHEUS_METRIC_GAUGE, PROMETHEUS_METRIC_SET_LABEL, PROMETHEUS_METRIC_STATIC_INITIALIZATION, prometheus_metric_to_string(), RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [9/11]

AST_TEST_DEFINE

(

metric_callback_register

)

Definition at line 203 of file test_res_prometheus.c.

{
    RAII_VAR(CURL *, curl, NULL, curl_free_wrapper);
    RAII_VAR(struct ast_str *, buffer, NULL, ast_free);
    int res;
    struct prometheus_callback callback = {
        .name = "test_callback",
        .callback_fn = &prometheus_metric_callback,
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test registration of callbacks";
        info->description =
            "This test covers callback registration. It registers\n"
            "a callback that is invoked when an HTTP request is made,\n"
            "and it verifies that during said callback the output to\n"
            "the response string is correctly appended to. It also verifies\n"
            "that unregistered callbacks are not invoked.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    buffer = ast_str_create(128);
    if (!buffer) {
        return AST_TEST_FAIL;
    }
 
    ast_test_validate(test, prometheus_callback_register(&callback) == 0);
 
    curl = get_curl_instance();
    if (!curl) {
        return AST_TEST_NOT_RUN;
    }
 
    ast_test_status_update(test, " -> CURLing request...\n");
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_string_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
    res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        ast_test_status_update(test, "Failed to execute CURL: %d\n", res);
        return AST_TEST_FAIL;
    }
 
    ast_test_status_update(test, " -> Retrieved: %s\n", ast_str_buffer(buffer));
    ast_test_validate(test, strstr(ast_str_buffer(buffer),
        "# HELP test_counter A test counter\n"
        "# TYPE test_counter counter\n"
        "test_counter 0\n") != NULL);
 
    prometheus_callback_unregister(&callback);
 
    return AST_TEST_PASS;
}

References ast_free, ast_str_buffer(), ast_str_create, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CATEGORY, curl_free_wrapper(), curl_write_string_callback(), get_curl_instance(), sip_to_pjsip::info(), prometheus_callback::name, NULL, prometheus_callback_register(), prometheus_callback_unregister(), prometheus_metric_callback(), RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [10/11]

AST_TEST_DEFINE

(

metric_register

)

Definition at line 261 of file test_res_prometheus.c.

{
    struct prometheus_metric test_counter = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_COUNTER,
        "test_counter",
        "A test counter",
        NULL);
    RAII_VAR(struct prometheus_metric *, test_gauge, NULL, prometheus_metric_free_wrapper);
    RAII_VAR(struct prometheus_metric *, test_gauge_child_one, NULL, prometheus_metric_free_wrapper);
    RAII_VAR(struct prometheus_metric *, test_gauge_child_two, NULL, prometheus_metric_free_wrapper);
    RAII_VAR(struct prometheus_metric *, bad_metric, NULL, prometheus_metric_free_wrapper);
    enum ast_test_result_state result;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test registration of metrics";
        info->description =
            "This test covers the following registration scenarios:\n"
            "- Nominal registration of simple metrics\n"
            "- Registration of metrics with different allocation strategies\n"
            "- Nested metrics with label families\n"
            "- Off nominal registration with simple name collisions\n"
            "- Off nominal registration with label collisions";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_status_update(test, "Testing nominal registration\n");
    ast_test_status_update(test, "-> Static metric\n");
    ast_test_validate_cleanup(test, prometheus_metric_register(&test_counter) == 0, result, metric_register_cleanup);
    ast_test_status_update(test, "-> Malloc'd metric\n");
    test_gauge = prometheus_gauge_create("test_gauge", "A test gauge");
    ast_test_validate(test, test_gauge != NULL);
    ast_test_validate_cleanup(test, prometheus_metric_register(test_gauge) == 0, result, metric_register_cleanup);
    ast_test_validate_cleanup(test, prometheus_metric_registered_count() == 2, result, metric_register_cleanup);
 
    ast_test_status_update(test, "Testing nominal registration of child metrics\n");
    test_gauge_child_one = prometheus_gauge_create("test_gauge", "A test gauge");
    ast_test_validate_cleanup(test, test_gauge_child_one != NULL, result, metric_register_cleanup);
    PROMETHEUS_METRIC_SET_LABEL(test_gauge_child_one, 0, "key_one", "value_one");
    PROMETHEUS_METRIC_SET_LABEL(test_gauge_child_one, 1, "key_two", "value_one");
    test_gauge_child_two = prometheus_gauge_create("test_gauge", "A test gauge");
    ast_test_validate_cleanup(test, test_gauge_child_two != NULL, result, metric_register_cleanup);
    PROMETHEUS_METRIC_SET_LABEL(test_gauge_child_two, 0, "key_one", "value_two");
    PROMETHEUS_METRIC_SET_LABEL(test_gauge_child_two, 1, "key_two", "value_two");
    ast_test_validate_cleanup(test, prometheus_metric_register(test_gauge_child_one) == 0, result, metric_register_cleanup);
    ast_test_validate_cleanup(test, prometheus_metric_register(test_gauge_child_two) == 0, result, metric_register_cleanup);
    ast_test_validate_cleanup(test, prometheus_metric_registered_count() == 2, result, metric_register_cleanup);
    ast_test_validate_cleanup(test, test_gauge->children.first == test_gauge_child_one, result, metric_register_cleanup);
    ast_test_validate_cleanup(test, test_gauge->children.last == test_gauge_child_two, result, metric_register_cleanup);
 
    ast_test_status_update(test, "Testing name collisions\n");
    bad_metric = prometheus_counter_create("test_counter", "A test counter");
    ast_test_validate_cleanup(test, bad_metric != NULL, result, metric_register_cleanup);
    ast_test_validate_cleanup(test, prometheus_metric_register(bad_metric) != 0, result, metric_register_cleanup);
    prometheus_metric_free(bad_metric);
    bad_metric = NULL;
 
    ast_test_status_update(test, "Testing label collisions\n");
    bad_metric = prometheus_gauge_create("test_gauge", "A test gauge");
    ast_test_validate_cleanup(test, bad_metric != NULL, result, metric_register_cleanup);
    PROMETHEUS_METRIC_SET_LABEL(bad_metric, 0, "key_one", "value_one");
    PROMETHEUS_METRIC_SET_LABEL(bad_metric, 1, "key_two", "value_one");
    ast_test_validate_cleanup(test, prometheus_metric_register(bad_metric) != 0, result, metric_register_cleanup);
    prometheus_metric_free(bad_metric);
    bad_metric = NULL;
 
    ast_test_status_update(test, "Testing removal of metrics\n");
    prometheus_metric_unregister(test_gauge_child_two);
    test_gauge_child_two = NULL;
 
    ast_test_validate_cleanup(test, prometheus_metric_registered_count() == 2, result, metric_register_cleanup);
    prometheus_metric_unregister(test_gauge);
    test_gauge = NULL;
 
    ast_test_validate_cleanup(test, prometheus_metric_registered_count() == 2, result, metric_register_cleanup);
    prometheus_metric_unregister(test_gauge_child_one);
    test_gauge_child_one = NULL;
 
    ast_test_validate_cleanup(test, prometheus_metric_registered_count() == 1, result, metric_register_cleanup);
    prometheus_metric_unregister(&test_counter);
 
    ast_test_validate_cleanup(test, prometheus_metric_registered_count() == 0, result, metric_register_cleanup);
 
    return AST_TEST_PASS;
 
metric_register_cleanup:
    prometheus_metric_unregister(&test_counter);
    return result;
}

References AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CATEGORY, sip_to_pjsip::info(), NULL, prometheus_counter_create(), prometheus_gauge_create(), PROMETHEUS_METRIC_COUNTER, prometheus_metric_free(), prometheus_metric_free_wrapper(), prometheus_metric_register(), prometheus_metric_registered_count(), PROMETHEUS_METRIC_SET_LABEL, PROMETHEUS_METRIC_STATIC_INITIALIZATION, prometheus_metric_unregister(), RAII_VAR, result, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [11/11]

AST_TEST_DEFINE

(

metric_values

)

Definition at line 118 of file test_res_prometheus.c.

{
    RAII_VAR(CURL *, curl, NULL, curl_free_wrapper);
    RAII_VAR(struct ast_str *, buffer, NULL, ast_free);
    int res;
    struct prometheus_metric test_counter_one = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_COUNTER,
        "test_counter_one",
        "A test counter",
        NULL);
    struct prometheus_metric test_counter_two = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_COUNTER,
        "test_counter_two",
        "A test counter",
        metric_values_get_counter_value_cb);
    enum ast_test_result_state result = AST_TEST_PASS;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = CATEGORY;
        info->summary = "Test value generation/respecting in metrics";
        info->description =
            "Metrics have two ways to provide values when the HTTP callback\n"
            "is invoked:\n"
            "1. By using the direct value that resides in the metric\n"
            "2. By providing a callback function to specify the value\n"
            "This test verifies that both function appropriately when the\n"
            "HTTP callback is called.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    buffer = ast_str_create(128);
    if (!buffer) {
        return AST_TEST_FAIL;
    }
 
    curl = get_curl_instance();
    if (!curl) {
        return AST_TEST_FAIL;
    }
 
    ast_test_validate_cleanup(test, prometheus_metric_register(&test_counter_one) == 0, result, metric_values_cleanup);
    ast_test_validate_cleanup(test, prometheus_metric_register(&test_counter_two) == 0, result, metric_values_cleanup);
    strcpy(test_counter_one.value, "1");
 
    ast_test_status_update(test, " -> CURLing request...\n");
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_string_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
    res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        ast_test_status_update(test, "Failed to execute CURL: %d\n", res);
        result = AST_TEST_FAIL;
        goto metric_values_cleanup;
    }
 
    ast_test_status_update(test, " -> Retrieved: %s\n", ast_str_buffer(buffer));
    ast_test_validate_cleanup(test, strstr(ast_str_buffer(buffer),
        "# HELP test_counter_one A test counter\n"
        "# TYPE test_counter_one counter\n"
        "test_counter_one 1\n"
        "# HELP test_counter_two A test counter\n"
        "# TYPE test_counter_two counter\n"
        "test_counter_two 2\n") != NULL, result, metric_values_cleanup);
 
metric_values_cleanup:
    prometheus_metric_unregister(&test_counter_one);
    prometheus_metric_unregister(&test_counter_two);
 
    return result;
}

References ast_free, ast_str_buffer(), ast_str_create, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CATEGORY, curl_free_wrapper(), curl_write_string_callback(), get_curl_instance(), sip_to_pjsip::info(), metric_values_get_counter_value_cb(), NULL, PROMETHEUS_METRIC_COUNTER, prometheus_metric_register(), PROMETHEUS_METRIC_STATIC_INITIALIZATION, prometheus_metric_unregister(), RAII_VAR, result, TEST_EXECUTE, TEST_INIT, and prometheus_metric::value.

config_alloc()

static struct prometheus_general_config * config_alloc ( void  )

static

Definition at line 60 of file test_res_prometheus.c.

{
    struct prometheus_general_config *config;
 
    config = prometheus_general_config_alloc();
    if (!config) {
        return NULL;
    }
 
    /* Set what we need on the config for most tests */
    ast_string_field_set(config, uri, "test_metrics");
    config->enabled = 1;
    config->core_metrics_enabled = 0;
 
    return config;
}

References ast_string_field_set, config, NULL, prometheus_general_config_alloc(), and prometheus_general_config::uri.

Referenced by AST_TEST_DEFINE(), and test_init_cb().

curl_free_wrapper()

static void curl_free_wrapper ( void *  ptr )

static

Definition at line 44 of file test_res_prometheus.c.

{
    if (!ptr) {
        return;
    }
 
    curl_easy_cleanup(ptr);
}

Referenced by AST_TEST_DEFINE().

curl_write_string_callback()

static size_t curl_write_string_callback ( void *  contents, size_t  size, size_t  nmemb, void *  userdata  )

static

Definition at line 95 of file test_res_prometheus.c.

{
    struct ast_str **buffer = userdata;
    size_t realsize = size * nmemb;
    char *rawdata;
 
    rawdata = ast_malloc(realsize + 1);
    if (!rawdata) {
        return 0;
    }
    memcpy(rawdata, contents, realsize);
    rawdata[realsize] = 0;
    ast_str_append(buffer, 0, "%s", rawdata);
    ast_free(rawdata);
 
    return realsize;
}

References ast_free, ast_malloc, ast_str_append(), and contents.

Referenced by AST_TEST_DEFINE().

get_curl_instance()

static CURL * get_curl_instance ( void  )

static

Definition at line 77 of file test_res_prometheus.c.

{
    CURL *curl;
 
    curl = curl_easy_init();
    if (!curl) {
        return NULL;
    }
 
    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 180);
    curl_easy_setopt(curl, CURLOPT_USERAGENT, AST_CURL_USER_AGENT);
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
    curl_easy_setopt(curl, CURLOPT_URL, server_uri);
 
    return curl;
}

References AST_CURL_USER_AGENT, NULL, and server_uri.

Referenced by AST_TEST_DEFINE().

load_module()

static int load_module ( void  )

static

Definition at line 865 of file test_res_prometheus.c.

{
    if (process_config(0)) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    AST_TEST_REGISTER(metric_values);
    AST_TEST_REGISTER(metric_callback_register);
    AST_TEST_REGISTER(metric_register);
 
    AST_TEST_REGISTER(counter_to_string);
    AST_TEST_REGISTER(counter_create);
    AST_TEST_REGISTER(gauge_to_string);
    AST_TEST_REGISTER(gauge_create);
 
    AST_TEST_REGISTER(config_general_enabled);
    AST_TEST_REGISTER(config_general_basic_auth);
    AST_TEST_REGISTER(config_general_core_metrics);
 
    AST_TEST_REGISTER(bridge_to_string);
 
    ast_test_register_init(CATEGORY, &test_init_cb);
    ast_test_register_cleanup(CATEGORY, &test_cleanup_cb);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, AST_TEST_REGISTER, CATEGORY, process_config(), test_cleanup_cb(), and test_init_cb().

match_count()

static int match_count ( const char *  str, const char *  needle  )

static

Definition at line 713 of file test_res_prometheus.c.

{
    int count = 0;
 
    while ((str = strstr(str, needle))) {
        str += strlen(needle);
        count++;
    }
 
    return count;
}

References str.

Referenced by AST_TEST_DEFINE().

metric_values_get_counter_value_cb()

static void metric_values_get_counter_value_cb ( struct prometheus_metric *  metric )

static

Definition at line 113 of file test_res_prometheus.c.

{
    strcpy(metric->value, "2");
}

References prometheus_metric::value.

Referenced by AST_TEST_DEFINE().

process_config()

static int process_config ( int  reload )

static

Definition at line 768 of file test_res_prometheus.c.

{
    struct ast_config *config;
    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    const char *bindaddr;
    const char *bindport;
    const char *prefix;
    const char *enabled;
 
    config = ast_config_load("http.conf", config_flags);
    if (!config || config == CONFIG_STATUS_FILEINVALID) {
        ast_log(AST_LOG_NOTICE, "HTTP config file is invalid; declining load");
        return -1;
    } else if (config == CONFIG_STATUS_FILEUNCHANGED) {
        return 0;
    }
 
    enabled = ast_config_option(config, "general", "enabled");
    if (!enabled || ast_false(enabled)) {
        ast_config_destroy(config);
        ast_log(AST_LOG_NOTICE, "HTTP server is disabled; declining load");
        return -1;
    }
 
    /* Construct our Server URI */
    bindaddr = ast_config_option(config, "general", "bindaddr");
    if (!bindaddr) {
        ast_config_destroy(config);
        ast_log(AST_LOG_NOTICE, "HTTP config file fails to specify 'bindaddr'; declining load");
        return -1;
    }
 
    bindport = ast_config_option(config, "general", "bindport");
    if (!bindport) {
        bindport = "8088";
    }
 
    prefix = ast_config_option(config, "general", "prefix");
 
    snprintf(server_uri, sizeof(server_uri), "http://%s:%s%s/test_metrics", bindaddr, bindport, S_OR(prefix, ""));
 
    ast_config_destroy(config);
 
    return 0;
}

References ast_config_destroy(), ast_config_load, ast_config_option(), ast_false(), ast_log, AST_LOG_NOTICE, bindaddr, config, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, enabled, prefix, reload(), S_OR, and server_uri.

Referenced by load_module(), and reload_module().

prometheus_metric_callback()

static void prometheus_metric_callback ( struct ast_str **  output )

static

Definition at line 192 of file test_res_prometheus.c.

{
    struct prometheus_metric test_counter = PROMETHEUS_METRIC_STATIC_INITIALIZATION(
        PROMETHEUS_METRIC_COUNTER,
        "test_counter",
        "A test counter",
        NULL);
 
    prometheus_metric_to_string(&test_counter, output);
}

References NULL, PROMETHEUS_METRIC_COUNTER, PROMETHEUS_METRIC_STATIC_INITIALIZATION, and prometheus_metric_to_string().

Referenced by AST_TEST_DEFINE().

prometheus_metric_free_wrapper()

static void prometheus_metric_free_wrapper ( void *  ptr )

static

Definition at line 53 of file test_res_prometheus.c.

{
    if (prometheus_metric_unregister(ptr)) {
        prometheus_metric_free(ptr);
    }
}

References prometheus_metric_free(), and prometheus_metric_unregister().

Referenced by AST_TEST_DEFINE().

reload_module()

static int reload_module ( void  )

static

Definition at line 840 of file test_res_prometheus.c.

{
    return process_config(1);
}

References process_config().

safe_bridge_destroy()

static void safe_bridge_destroy ( struct ast_bridge *  bridge )

static

Definition at line 705 of file test_res_prometheus.c.

{
    if (!bridge) {
        return;
    }
    ast_bridge_destroy(bridge, 0);
}

References ast_bridge_destroy().

Referenced by AST_TEST_DEFINE().

test_cleanup_cb()

static int test_cleanup_cb ( struct ast_test_info *  info, struct ast_test *  test  )

static

Definition at line 832 of file test_res_prometheus.c.

{
    prometheus_general_config_set(module_config);
    ao2_cleanup(module_config);
 
    return 0;
}

References ao2_cleanup, and prometheus_general_config_set().

Referenced by load_module().

test_init_cb()

static int test_init_cb ( struct ast_test_info *  info, struct ast_test *  test  )

static

Definition at line 814 of file test_res_prometheus.c.

{
    struct prometheus_general_config *new_module_config;
 
    new_module_config = config_alloc();
    if (!new_module_config) {
        return -1;
    }
 
    module_config = prometheus_general_config_get();
    prometheus_general_config_set(new_module_config);
 
    /* Allow the module to own the ref */
    ao2_ref(new_module_config, -1);
 
    return 0;
}

References ao2_ref, config_alloc(), prometheus_general_config_get(), and prometheus_general_config_set().

Referenced by load_module().

unload_module()

static int unload_module ( void  )

static

Definition at line 845 of file test_res_prometheus.c.

{
    AST_TEST_UNREGISTER(metric_values);
    AST_TEST_UNREGISTER(metric_callback_register);
    AST_TEST_UNREGISTER(metric_register);
 
    AST_TEST_UNREGISTER(counter_to_string);
    AST_TEST_UNREGISTER(counter_create);
    AST_TEST_UNREGISTER(gauge_to_string);
    AST_TEST_UNREGISTER(gauge_create);
 
    AST_TEST_UNREGISTER(config_general_enabled);
    AST_TEST_UNREGISTER(config_general_basic_auth);
    AST_TEST_UNREGISTER(config_general_core_metrics);
 
    AST_TEST_UNREGISTER(bridge_to_string);
 
    return 0;
}

References AST_TEST_UNREGISTER.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Prometheus Core Unit Tests" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .reload = reload_module, .unload = unload_module, .requires = "res_prometheus", }

static

Definition at line 897 of file test_res_prometheus.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 897 of file test_res_prometheus.c.

module_config

struct prometheus_general_config* module_config

Definition at line 42 of file test_res_prometheus.c.

server_uri

char server_uri[512]

static

Definition at line 40 of file test_res_prometheus.c.

Referenced by get_curl_instance(), and process_config().