test_res_prometheus.c File Reference

#include "asterisk.h"
#include <curl/curl.h>
#include "asterisk/test.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/res_prometheus.h"

Include dependency graph for test_res_prometheus.c:

Go to the source code of this file.

Macros
#define	CATEGORY   "/res/prometheus/"
#define	GLOBAL_USERAGENT   "asterisk-libcurl-agent/1.0"

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (metric_values)
	AST_TEST_DEFINE (metric_callback_register)
	AST_TEST_DEFINE (metric_register)
	AST_TEST_DEFINE (counter_to_string)
	AST_TEST_DEFINE (counter_create)
	AST_TEST_DEFINE (gauge_to_string)
	AST_TEST_DEFINE (gauge_create)
	AST_TEST_DEFINE (config_general_basic_auth)
	AST_TEST_DEFINE (config_general_enabled)
	AST_TEST_DEFINE (config_general_core_metrics)
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 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 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 35 of file test_res_prometheus.c.

Referenced by AST_TEST_DEFINE(), and load_module().

GLOBAL_USERAGENT

#define GLOBAL_USERAGENT   "asterisk-libcurl-agent/1.0"

Definition at line 57 of file test_res_prometheus.c.

Referenced by get_curl_instance().

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 829 of file test_res_prometheus.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 829 of file test_res_prometheus.c.

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 829 of file test_res_prometheus.c.

AST_TEST_DEFINE() [1/10]

AST_TEST_DEFINE

(

metric_values

)

Definition at line 117 of file test_res_prometheus.c.

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.

{
   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;
}

AST_TEST_DEFINE() [2/10]

AST_TEST_DEFINE

(

metric_callback_register

)

Definition at line 202 of file test_res_prometheus.c.

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.

{
   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;
}

AST_TEST_DEFINE() [3/10]

AST_TEST_DEFINE

(

metric_register

)

Definition at line 260 of file test_res_prometheus.c.

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.

{
   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;
}

AST_TEST_DEFINE() [4/10]

AST_TEST_DEFINE

(

counter_to_string

)

Definition at line 354 of file test_res_prometheus.c.

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.

{
   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;
}

AST_TEST_DEFINE() [5/10]

AST_TEST_DEFINE

(

counter_create

)

Definition at line 407 of file test_res_prometheus.c.

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.

{
   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;
}

AST_TEST_DEFINE() [6/10]

AST_TEST_DEFINE

(

gauge_to_string

)

Definition at line 437 of file test_res_prometheus.c.

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.

{
   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;
}

AST_TEST_DEFINE() [7/10]

AST_TEST_DEFINE

(

gauge_create

)

Definition at line 490 of file test_res_prometheus.c.

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.

{
   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;
}

AST_TEST_DEFINE() [8/10]

AST_TEST_DEFINE

(

config_general_basic_auth

)

Definition at line 520 of file test_res_prometheus.c.

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.

{
   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;
}

AST_TEST_DEFINE() [9/10]

AST_TEST_DEFINE

(

config_general_enabled

)

Definition at line 593 of file test_res_prometheus.c.

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

{
   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;
}

AST_TEST_DEFINE() [10/10]

AST_TEST_DEFINE

(

config_general_core_metrics

)

Definition at line 640 of file test_res_prometheus.c.

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(), prometheus_general_config::core_metrics_enabled, 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.

{
   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;
}

config_alloc()

static struct prometheus_general_config* config_alloc ( void  )

static

Definition at line 59 of file test_res_prometheus.c.

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

Referenced by AST_TEST_DEFINE(), and test_init_cb().

{
   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;
}

curl_free_wrapper()

static void curl_free_wrapper ( void *  ptr )

static

Definition at line 41 of file test_res_prometheus.c.

Referenced by AST_TEST_DEFINE().

{
   if (!ptr) {
      return;
   }

   curl_easy_cleanup(ptr);
}

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 94 of file test_res_prometheus.c.

References ast_free, ast_malloc, and ast_str_append().

Referenced by AST_TEST_DEFINE().

{
   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;
}

get_curl_instance()

static CURL* get_curl_instance ( void  )

static

Definition at line 76 of file test_res_prometheus.c.

References GLOBAL_USERAGENT, NULL, and server_uri.

Referenced by AST_TEST_DEFINE().

{
   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, GLOBAL_USERAGENT);
   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
   curl_easy_setopt(curl, CURLOPT_URL, server_uri);

   return curl;
}

load_module()

static int load_module ( void  )

static

Definition at line 799 of file test_res_prometheus.c.

References AST_MODFLAG_DEFAULT, AST_MODULE_INFO(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, AST_TEST_REGISTER, ast_test_register_cleanup(), ast_test_register_init(), ASTERISK_GPL_KEY, CATEGORY, process_config(), reload(), reload_module(), test_cleanup_cb(), test_init_cb(), and unload_module().

{
   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_init(CATEGORY, &test_init_cb);
   ast_test_register_cleanup(CATEGORY, &test_cleanup_cb);

   return AST_MODULE_LOAD_SUCCESS;
}

metric_values_get_counter_value_cb()

static void metric_values_get_counter_value_cb ( struct prometheus_metric *  metric )

static

Definition at line 112 of file test_res_prometheus.c.

References prometheus_metric::value.

Referenced by AST_TEST_DEFINE().

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

process_config()

static int process_config ( int  reload )

static

Definition at line 704 of file test_res_prometheus.c.

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, S_OR, and server_uri.

Referenced by load_module(), and reload_module().

{
   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;
}

prometheus_metric_callback()

static void prometheus_metric_callback ( struct ast_str **  output )

static

Definition at line 191 of file test_res_prometheus.c.

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

Referenced by AST_TEST_DEFINE().

{
   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);
}

prometheus_metric_free_wrapper()

static void prometheus_metric_free_wrapper ( void *  ptr )

static

Definition at line 50 of file test_res_prometheus.c.

References prometheus_metric_free(), and prometheus_metric_unregister().

Referenced by AST_TEST_DEFINE().

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

reload_module()

static int reload_module ( void  )

static

Definition at line 776 of file test_res_prometheus.c.

References process_config().

Referenced by load_module().

{
   return process_config(1);
}

test_cleanup_cb()

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

static

Definition at line 768 of file test_res_prometheus.c.

References ao2_cleanup, and prometheus_general_config_set().

Referenced by load_module().

{
   prometheus_general_config_set(module_config);
   ao2_cleanup(module_config);

   return 0;
}

test_init_cb()

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

static

Definition at line 750 of file test_res_prometheus.c.

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

Referenced by load_module().

{
   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;
}

unload_module()

static int unload_module ( void  )

static

Definition at line 781 of file test_res_prometheus.c.

References AST_TEST_UNREGISTER.

Referenced by load_module().

{
   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);

   return 0;
}

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 829 of file test_res_prometheus.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 829 of file test_res_prometheus.c.

module_config

struct prometheus_general_config* module_config

Definition at line 39 of file test_res_prometheus.c.

server_uri

char server_uri[512]

static

Definition at line 37 of file test_res_prometheus.c.

Referenced by get_curl_instance(), and process_config().