summaryrefslogtreecommitdiffstats
path: root/fluent-bit/tests/runtime/filter_expect.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--fluent-bit/tests/runtime/filter_expect.c555
1 files changed, 555 insertions, 0 deletions
diff --git a/fluent-bit/tests/runtime/filter_expect.c b/fluent-bit/tests/runtime/filter_expect.c
new file mode 100644
index 00000000..dad1b637
--- /dev/null
+++ b/fluent-bit/tests/runtime/filter_expect.c
@@ -0,0 +1,555 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+#include <fluent-bit.h>
+#include <fluent-bit/flb_time.h>
+#include <fluent-bit/flb_sds.h>
+#include "flb_tests_runtime.h"
+
+struct test_ctx {
+ flb_ctx_t *flb; /* Fluent Bit library context */
+ int i_ffd; /* Input fd */
+ int f_ffd; /* Filter fd */
+ int o_ffd; /* Output fd */
+};
+
+pthread_mutex_t result_mutex = PTHREAD_MUTEX_INITIALIZER;
+int num_output = 0;
+static int get_output_num()
+{
+ int ret;
+ pthread_mutex_lock(&result_mutex);
+ ret = num_output;
+ pthread_mutex_unlock(&result_mutex);
+
+ return ret;
+}
+
+static void set_output_num(int num)
+{
+ pthread_mutex_lock(&result_mutex);
+ num_output = num;
+ pthread_mutex_unlock(&result_mutex);
+}
+
+static void clear_output_num()
+{
+ set_output_num(0);
+}
+
+/* Callback to check expected results */
+static int cb_check_result_json(void *record, size_t size, void *data)
+{
+ char *p;
+ char *expected;
+ char *result;
+ int num = get_output_num();
+
+ set_output_num(num+1);
+
+ expected = (char *) data;
+ result = (char *) record;
+
+ p = strstr(result, expected);
+ if (!TEST_CHECK(p != NULL)) {
+ TEST_MSG("Expected to find: '%s' in result '%s'",
+ expected, result);
+ }
+ /*
+ * If you want to debug your test
+ *
+ * printf("Expect: '%s' in result '%s'", expected, result);
+ */
+ flb_free(record);
+ return 0;
+}
+
+
+static struct test_ctx *test_ctx_create(struct flb_lib_out_cb *data)
+{
+ int i_ffd;
+ int f_ffd;
+ int o_ffd;
+ struct test_ctx *ctx;
+
+ ctx = flb_malloc(sizeof(struct test_ctx));
+ if (!ctx) {
+ flb_errno();
+ return NULL;
+ }
+
+ /* Service config */
+ ctx->flb = flb_create();
+ flb_service_set(ctx->flb,
+ "Flush", "0.200000000",
+ "Grace", "1",
+ "Log_Level", "Error",
+ NULL);
+
+ /* Input */
+ i_ffd = flb_input(ctx->flb, (char *) "lib", NULL);
+ TEST_CHECK(i_ffd >= 0);
+ flb_input_set(ctx->flb, i_ffd, "tag", "test", NULL);
+ ctx->i_ffd = i_ffd;
+
+ /* Filter configuration */
+ f_ffd = flb_filter(ctx->flb, (char *) "expect", NULL);
+ TEST_CHECK(f_ffd >= 0);
+ flb_filter_set(ctx->flb, f_ffd,
+ "match", "*", "action", "result_key",
+ "result_key", "result",
+ NULL);
+ ctx->f_ffd = f_ffd;
+
+ /* Output */
+ o_ffd = flb_output(ctx->flb, (char *) "lib", (void *) data);
+ TEST_CHECK(o_ffd >= 0);
+ flb_output_set(ctx->flb, o_ffd,
+ "match", "test",
+ "format", "json",
+ NULL);
+ ctx->o_ffd = o_ffd;
+
+ return ctx;
+}
+
+static void test_ctx_destroy(struct test_ctx *ctx)
+{
+ flb_stop(ctx->flb);
+ flb_destroy(ctx->flb);
+ flb_free(ctx);
+}
+
+void flb_test_key_exists_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":\"val\"}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":true";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_exists", "key",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+void flb_test_key_exists_not_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":\"val\"}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":false";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_exists", "not_key",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+void flb_test_key_not_exists_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":\"val\"}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":true";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_not_exists", "not_key",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+void flb_test_key_not_exists_not_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":\"val\"}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":false";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_not_exists", "key",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+void flb_test_key_val_is_null_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":null}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":true";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_val_is_null", "key",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+void flb_test_key_val_is_null_not_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":\"val\"}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":false";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_val_is_null", "key",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+void flb_test_key_val_is_not_null_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":\"val\"}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":true";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_val_is_not_null", "key",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+void flb_test_key_val_is_not_null_not_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":null}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":false";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_val_is_not_null", "key",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+void flb_test_key_val_eq_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":\"val\"}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":true";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_val_eq", "key val",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+void flb_test_key_val_eq_not_matched()
+{
+ struct flb_lib_out_cb cb_data;
+ struct test_ctx *ctx;
+ int len;
+ int ret;
+ int bytes;
+ char *input = "[0, {\"key\":\"val\"}]";
+
+ clear_output_num();
+ cb_data.cb = cb_check_result_json;
+ cb_data.data = "\"result\":false";
+
+ ctx = test_ctx_create(&cb_data);
+ if (!TEST_CHECK(ctx != NULL)) {
+ TEST_MSG("test_ctx_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = flb_filter_set(ctx->flb, ctx->f_ffd,
+ "key_val_eq", "not_key val",
+ NULL);
+ TEST_CHECK(ret == 0);
+
+ /* Start the engine */
+ ret = flb_start(ctx->flb);
+ TEST_CHECK(ret == 0);
+
+ /* Ingest data samples */
+ len = strlen(input);
+ bytes = flb_lib_push(ctx->flb, ctx->i_ffd, input, len);
+ TEST_CHECK(bytes == len);
+ flb_time_msleep(500);
+
+ ret = get_output_num();
+ if (!TEST_CHECK(ret > 0)) {
+ TEST_MSG("no output");
+ }
+
+ test_ctx_destroy(ctx);
+}
+
+
+TEST_LIST = {
+ {"key_exists_matched", flb_test_key_exists_matched},
+ {"key_exists_not_matched", flb_test_key_exists_not_matched},
+ {"key_not_exists_matched", flb_test_key_not_exists_matched},
+ {"key_not_exists_not_matched", flb_test_key_not_exists_not_matched},
+ {"key_val_is_null_matched", flb_test_key_val_is_null_matched},
+ {"key_val_is_null_not_matched", flb_test_key_val_is_null_not_matched},
+ {"key_val_is_not_null_matched", flb_test_key_val_is_not_null_matched},
+ {"key_val_is_not_null_not_matched", flb_test_key_val_is_not_null_not_matched},
+ {"key_val_eq_matched", flb_test_key_val_eq_matched},
+ {"key_val_eq_not_matched", flb_test_key_val_eq_not_matched},
+ {NULL, NULL}
+};
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-12 07:40:11 +0000