diff options
Diffstat (limited to 'test/src/gtest_fieldstat_interface.cpp')
| -rw-r--r-- | test/src/gtest_fieldstat_interface.cpp | 343 |
1 files changed, 343 insertions, 0 deletions
diff --git a/test/src/gtest_fieldstat_interface.cpp b/test/src/gtest_fieldstat_interface.cpp new file mode 100644 index 0000000..558f267 --- /dev/null +++ b/test/src/gtest_fieldstat_interface.cpp @@ -0,0 +1,343 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> +#include <gtest/gtest.h> +#include "fieldstat.h" +#include "fieldstat_internal.h" + +extern struct prometheus_endpoint_instance g_prometheus_endpoint_instance; + +TEST(FeildStatAPI, FieldStatInstanceNew) +{ + struct fieldstat_instance *instance = fieldstat_instance_new("test"); + EXPECT_NE(nullptr, instance); + EXPECT_STREQ("test", instance->name); + fieldstat_instance_free(instance); +} + + +TEST(FeildStatAPI, FieldStatEnablePrometheusEndpoint) +{ + int ret = 0; + + ret = fieldstat_global_enable_prometheus_endpoint(9020, "/metrcis"); + EXPECT_EQ(0, ret); + usleep(500 * 1000); + fieldstat_global_disable_prometheus_endpoint(); +} + +TEST(FeildStatAPI, FieldStatSetPrometheusOutput) +{ + struct fieldstat_instance *instance = NULL; + int ret_enable_prometheus_endpoint = 0; + int ret_set_prometheus_output = 0; + + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + + ret_enable_prometheus_endpoint = fieldstat_global_enable_prometheus_endpoint(9020, "/metrics"); + EXPECT_EQ(0, ret_enable_prometheus_endpoint); + + ret_set_prometheus_output = fieldstat_enable_prometheus_output(instance); + EXPECT_EQ(0, ret_set_prometheus_output); + + EXPECT_EQ(1, g_prometheus_endpoint_instance.running); + EXPECT_EQ(instance, g_prometheus_endpoint_instance.fs_instance[0]); + EXPECT_EQ(1, g_prometheus_endpoint_instance.fs_instance_cnt); + + usleep(500 * 1000); + fieldstat_global_disable_prometheus_endpoint(); + fieldstat_instance_free(instance); +} + + +TEST(FeildStatAPI, FieldStatSetLineProtocolServer) +{ + struct fieldstat_instance *instance = NULL; + int ret_set_line_protocol_server = 0; + + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + + ret_set_line_protocol_server = fieldstat_set_line_protocol_server(instance, "127.0.0.1", 8001); + + EXPECT_EQ(0, ret_set_line_protocol_server); + EXPECT_EQ(1, instance->line_protocol_output_enable); + EXPECT_NE(-1, instance->line_protocol_output.send_socket); + fieldstat_instance_free(instance); +} + +TEST(FeildStatAPI, FieldStatSetLocalOutput) +{ + struct fieldstat_instance *instance = NULL; + int ret_set_local_output = 0; + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + + ret_set_local_output = fieldstat_set_local_output(instance,"test.fs","default"); + EXPECT_EQ(0, ret_set_local_output); + + EXPECT_STREQ("test.fs", instance->local_output_filename); + EXPECT_STREQ("default", instance->local_output_format); + EXPECT_EQ(1, instance->local_output_enable); + fieldstat_instance_free(instance); +} + +TEST(FeildStatAPI, FieldStatBackgroundThreadDisable) +{ + struct fieldstat_instance *instance = NULL; + int ret_background_thread_disable = 0; + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + + ret_background_thread_disable = fieldstat_disable_background_thread(instance); + EXPECT_EQ(0, ret_background_thread_disable); + EXPECT_EQ(1, instance->background_thread_disable); + fieldstat_instance_free(instance); +} + +TEST(FeildStatAPI, FieldStatSetOutputInterval) +{ + struct fieldstat_instance *instance = NULL; + int ret_set_output_interval = 0; + + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + + ret_set_output_interval = fieldstat_set_output_interval(instance, 1); + EXPECT_EQ(0, ret_set_output_interval); + EXPECT_EQ(1, instance->output_interval_ms); + fieldstat_instance_free(instance); +} + +TEST(FeildStatAPI, FieldStatInstanceStart) +{ + struct fieldstat_instance *instance = NULL; + + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + + fieldstat_instance_start(instance); + usleep(500 * 1000); + fieldstat_instance_free(instance); +} + +TEST(FeildStatAPI, FieldStatRegister) +{ + struct fieldstat_instance * instance = NULL; + int metric_id = -1; + struct metric **in_block_metric = NULL; + struct fieldstat_tag tags[2]; + tags[0].value_type = 2; + tags[0].value_str = "127.0.0.1"; + tags[0].key = "dest_ip"; + + tags[1].value_type = 2; + tags[1].value_str = "127.0.0.1"; + tags[1].key = "src_ip"; + + + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + + metric_id = fieldstat_register(instance, FIELD_TYPE_COUNTER, "Traffic_bytes",NULL,0); + EXPECT_EQ(0, metric_id); + EXPECT_EQ(1, instance->metric_cnt); + EXPECT_NE(nullptr, instance->metric_block_list[0]); + in_block_metric = instance->metric_block_list[0]; + EXPECT_NE(nullptr, in_block_metric[0]); + + metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "Active_sessions", NULL, 0); + EXPECT_EQ(1, metric_id); + EXPECT_EQ(2, instance->metric_cnt); + EXPECT_NE(nullptr, in_block_metric[1]); + + metric_id = fieldstat_register(instance, FIELD_TYPE_COUNTER, "New_sessions", tags, sizeof(tags)/sizeof(tags[0])); + EXPECT_EQ(2, metric_id); + EXPECT_EQ(3, instance->metric_cnt); + EXPECT_NE(nullptr, in_block_metric[2]); + fieldstat_instance_free(instance); +} + +TEST(FieldStatAPI, FieldStatRegisterTable) +{ + struct fieldstat_instance * instance = NULL; + int table_id = -1; + struct table_metric *table = NULL; + + const char *shaping_column_name[] = {"packets","bytes"}; + const char *shaping_table_name = "shaping"; + enum field_type shaping_column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER}; + + const char *sc_column_name[] = {"sent_pkts", "send_bytes", "recv_pkts", "recv_bytes"}; + enum field_type sc_column_type[] = {FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER}; + const char *sc_table_name = "service_chaining"; + + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + + table_id = fieldstat_register_table(instance, shaping_table_name, shaping_column_name, shaping_column_type, sizeof(shaping_column_name)/sizeof(shaping_column_name[0])); + EXPECT_EQ(0, table_id); + EXPECT_NE(nullptr, instance->table_metrics[0]); + table = instance->table_metrics[0]; + EXPECT_EQ(2, table->column_cnt); + EXPECT_EQ(0, table->line_cnt); + EXPECT_EQ(nullptr, table->line_block[0]); + + + table_id = fieldstat_register_table(instance, sc_table_name, sc_column_name, sc_column_type, sizeof(sc_column_name)/sizeof(sc_column_name[0])); + + EXPECT_EQ(1, table_id); + EXPECT_NE(nullptr, instance->table_metrics[1]); + table = instance->table_metrics[1]; + EXPECT_EQ(4, table->column_cnt); + EXPECT_EQ(0, table->line_cnt); + EXPECT_EQ(nullptr, table->line_block[0]); + + fieldstat_instance_free(instance); +} + + +TEST(FieldStatAPI, FieldStatRegisterTableMetrics) +{ + struct fieldstat_instance * instance = NULL; + int table_id = -1; + + const char *sc_column_name[] = {"sent_pkts", "send_bytes", "recv_pkts", "recv_bytes"}; + enum field_type sc_column_type[] = {FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER}; + const char *sc_table_name = "service_chaining"; + + + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + table_id = fieldstat_register_table(instance, sc_table_name, sc_column_name, sc_column_type, sizeof(sc_column_name)/sizeof(sc_column_name[0])); + EXPECT_EQ(0, table_id); + fieldstat_instance_free(instance); +} + + +TEST(FeildStatAPI, FieldStatLocalOutputFormatJson) +{ + int metric_id = -1; + int ret_set_local_output = 0; + struct fieldstat_instance * instance = NULL; + int ret = 0; + + instance = fieldstat_instance_new("test"); + EXPECT_STREQ("test", instance->name); + + metric_id = fieldstat_register(instance, FIELD_TYPE_COUNTER, "Traffic_bytes",NULL,0); + EXPECT_EQ(0, metric_id); + + ret_set_local_output = fieldstat_set_local_output(instance,"test.json","json"); + EXPECT_EQ(0, ret_set_local_output); + instance->running = 1; + + ret = fieldstat_value_incrby(instance, metric_id, 10); + EXPECT_EQ(0, ret); + fieldstat_passive_output(instance); + sleep(1); + ret = fieldstat_value_incrby(instance, metric_id, 10); + sleep(1); + fieldstat_passive_output(instance); + EXPECT_EQ(0, ret); + instance->running = 0; + fieldstat_instance_free(instance); +} + +TEST(FeildStatAPI, FieldStatLineProtocolOutputTableMetric) +{ + int ret = 0; + int n_loops = 1; + struct fieldstat_instance * instance = NULL; + int table_id = -1; + int output_metric_ids[54] = {0}; + const char *telegraf_output_file = "/tmp/metrics.out"; + FILE *fp; + char line[2048] = {0}; + cJSON *cjson_metric = NULL; + cJSON *cjson_tags = NULL; + const char *compare = "{\"fields\":{\"alert_bytes\":0,\"allow_conn_num\":0,\"allow_in_bytes\":0,\"allow_in_packets\":0,\"allow_out_bytes\":0,"\ + "\"allow_out_packets\":0,\"block_bytes\":0,\"close_conn_num\":0,\"default_conn_num\":0,\"default_in_bytes\":0,"\ + "\"default_in_packets\":0,\"default_out_bytes\":0,\"default_out_packets\":0,\"deny_conn_num\":0,\"deny_in_bytes\":0,"\ + "\"deny_in_packets\":0,\"deny_out_bytes\":0,\"deny_out_packets\":0,\"established_conn_num\":0,\"intercept_conn_num\":0,"\ + "\"intercept_in_bytes\":0,\"intercept_in_packets\":0,\"intercept_out_bytes\":0,\"intercept_out_packets\":0,"\ + "\"ipv4_in_bytes\":0,\"ipv4_in_packets\":0,\"ipv4_out_packetsipv4_out_bytes\":0,\"ipv6_in_bytes\":0,\"ipv6_in_packets\":0,"\ + "\"ipv6_out_bytes\":0,\"ipv6_out_packets\":0,\"maybe_pinning_num\":0,\"monitor_conn_num\":0,\"monitor_in_bytes\":0,"\ + "\"monitor_in_packets\":0,\"monitor_out_bytes\":0,\"monitor_out_packets\":0,\"new_conn_num\":1000,\"not_pinning_num\":0,"\ + "\"pinning_num\":0,\"tcp_conn_num\":0,\"tcp_in_bytes\":0,\"tcp_in_packets\":0,\"tcp_out_bytes\":0,\"tcp_out_packets\":0,"\ + "\"total_in_bytes\":0,\"total_in_packets\":0,\"total_out_bytes\":0,\"total_out_packets\":0,\"udp_conn_num\":0,"\ + "\"udp_in_bytes\":0,\"udp_in_packets\":0,\"udp_out_bytes\":0,\"udp_out_packets\":0},\"name\":\"TRAFFIC\","\ + "\"tags\":{\"app_name\":\"tsg_statistic\",\"table_name\":\"network_activity\"}}"; + char *cjson_metric_str = NULL; + + const char *table_column_name[] = {"new_conn_num", "established_conn_num", "close_conn_num", "total_in_bytes", "total_out_bytes", "total_in_packets", + "total_out_packets", "default_conn_num", "default_in_bytes", "default_out_bytes", "default_in_packets", "default_out_packets", "allow_conn_num", + "allow_in_bytes", "allow_out_bytes", "allow_in_packets", "allow_out_packets", "deny_conn_num", "deny_in_bytes", "deny_out_bytes", "deny_in_packets", + "deny_out_packets", "monitor_conn_num", "monitor_in_bytes", "monitor_out_bytes", "monitor_in_packets", "monitor_out_packets", "intercept_conn_num", + "intercept_in_bytes", "intercept_out_bytes", "intercept_in_packets", "intercept_out_packets", "ipv4_in_packets", "ipv4_in_bytes", "ipv4_out_packets" + "ipv4_out_bytes", "ipv6_in_packets", "ipv6_in_bytes", "ipv6_out_packets", "ipv6_out_bytes", "tcp_conn_num", "tcp_in_packets", "tcp_in_bytes", + "tcp_out_packets", "tcp_out_bytes", "udp_conn_num", "udp_in_packets", "udp_in_bytes", "udp_out_packets", "udp_out_bytes", "alert_bytes", "block_bytes", + "pinning_num", "maybe_pinning_num", "not_pinning_num"}; + enum field_type table_column_type[54] = {FIELD_TYPE_COUNTER}; + + instance = fieldstat_instance_new("tsg_statistic"); + EXPECT_STREQ("tsg_statistic", instance->name); + + table_id = fieldstat_register_table(instance, "network_activity", table_column_name, table_column_type, sizeof(table_column_name)/sizeof(table_column_name[0])); + EXPECT_EQ(0, table_id); + ret = fieldstat_register_table_row(instance, table_id, "TRAFFIC", NULL, 0, output_metric_ids); + EXPECT_EQ(0, ret); + + ret = fieldstat_set_line_protocol_server(instance, "127.0.0.1", 8600); + EXPECT_EQ(0, ret); + EXPECT_EQ(4, instance->output_type); + ret = fieldstat_disable_background_thread(instance); + EXPECT_EQ(0, ret); + fieldstat_instance_start(instance); + fieldstat_value_incrby(instance, output_metric_ids[0], 1000); + ret = system("cat /dev/null > /tmp/metrics.out"); + sleep(1); + fieldstat_passive_output(instance); + sleep(1); + fp = fopen(telegraf_output_file, "r"); + EXPECT_NE(nullptr, fp); + int n_line = 0; + + while(!feof(fp)) + { + if(NULL == fgets(line, sizeof(line), fp)) + { + continue; + } + cjson_metric = cJSON_Parse(line); + EXPECT_NE(nullptr, cjson_metric); + cJSON_DeleteItemFromObject(cjson_metric, "timestamp"); + + cjson_tags = cJSON_GetObjectItem(cjson_metric, "tags"); + EXPECT_NE(nullptr, cjson_tags); + cJSON_DeleteItemFromObject(cjson_tags, "host"); + cjson_metric_str = cJSON_PrintUnformatted(cjson_metric); + EXPECT_NE(nullptr, cjson_metric_str); + if(cjson_metric_str) + { + EXPECT_STREQ(compare, cjson_metric_str); + free(cjson_metric_str); + cjson_metric_str = NULL; + } + cJSON_Delete(cjson_metric); + n_line++; + } + fclose(fp); + EXPECT_EQ(n_line, n_loops); + + fieldstat_instance_free(instance); + +} + + +int main(int argc, char *argv[]) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +}
\ No newline at end of file |