Added tests for sdb_fe_parse_expr() and fixed the implementation.

[sysdb.git] / t / unit / frontend / parser_test.c

diff --git a/t/unit/frontend/parser_test.c b/t/unit/frontend/parser_test.c
index 1412ee56fa88d5c1a73e937a2bd2c982d5c6fa6b..844e739ca9d72b01c94fd66a1e2c2c04ef63bac1 100644 (file)
--- a/t/unit/frontend/parser_test.c
+++ b/t/unit/frontend/parser_test.c
@@ -32,6 +32,7 @@
 #include "libsysdb_test.h"
 
 #include <check.h>
+#include <limits.h>
 
 /*
  * tests
@@ -90,18 +91,18 @@ START_TEST(test_parse)
                  "service =~ 'r'",      -1,  1, CONNECTION_LOOKUP },
                { "LOOKUP hosts MATCHING "
                  "host =~ 'p' "
-                 "FILTER :age > 1D",    -1,  1, CONNECTION_LOOKUP },
+                 "FILTER .age > 1D",    -1,  1, CONNECTION_LOOKUP },
                { "LOOKUP hosts MATCHING "
                  "host =~ 'p' "
-                 "FILTER :age > 1D AND "
-                 ":interval < 240s" ,   -1,  1, CONNECTION_LOOKUP },
+                 "FILTER .age > 1D AND "
+                 ".interval < 240s" ,   -1,  1, CONNECTION_LOOKUP },
                { "LOOKUP hosts MATCHING "
                  "host =~ 'p' "
-                 "FILTER NOT :age>1D",  -1,  1, CONNECTION_LOOKUP },
+                 "FILTER NOT .age>1D",  -1,  1, CONNECTION_LOOKUP },
                { "LOOKUP hosts MATCHING "
                  "host =~ 'p' "
-                 "FILTER :age>"
-                 ":interval",           -1,  1, CONNECTION_LOOKUP },
+                 "FILTER .age>"
+                 ".interval",           -1,  1, CONNECTION_LOOKUP },
 
                { "TIMESERIES 'host'.'metric' "
                  "START 2014-01-01 "
@@ -143,6 +144,9 @@ START_TEST(test_parse)
                { "LOOKUP hosts MATCHING "
                  "attribute[foo] <= "
                  "12. + .3",            -1,  1, CONNECTION_LOOKUP },
+               { "LOOKUP hosts MATCHING "
+                 "attribute[foo] <= "
+                 "'f' || 'oo'",         -1,  1, CONNECTION_LOOKUP },
                { "LOOKUP hosts MATCHING "
                  "attribute[foo] >= "
                  ".4",                  -1,  1, CONNECTION_LOOKUP },
@@ -241,6 +245,12 @@ START_TEST(test_parse)
                { "LOOKUP foo MATCHING "
                  "host = 'host' FILTER "
                  "host = 'host'",       -1, -1, 0 },
+               { "LOOKUP hosts MATCHING "
+                 "attribute[foo] <= "
+                 "f || 'oo'",           -1, -1, 0 },
+               { "LOOKUP hosts MATCHING "
+                 "attribute[foo] <= "
+                 "'f' || oo",           -1, -1, 0 },
        };
 
        size_t i;
@@ -341,14 +351,14 @@ START_TEST(test_parse_matcher)
                { "attribute[foo] IS NOT NULL", -1,  MATCHER_NOT },
 
                /* object field matchers */
-               { ":last_update < 10s",         -1,  MATCHER_LT },
-               { ":AGE <= 1m",                 -1,  MATCHER_LE },
-               { ":interval = 10h",            -1,  MATCHER_EQ },
-               { ":Last_Update >= 24D",        -1,  MATCHER_GE },
-               { ":age > 1M",                  -1,  MATCHER_GT },
-               { ":age != 20Y",                -1,  MATCHER_NOT },
-               { ":backend != 'be'",           -1,  MATCHER_NOT },
-               { ":age <= 2 * :interval",      -1,  MATCHER_LE },
+               { ".last_update < 10s",         -1,  MATCHER_LT },
+               { ".AGE <= 1m",                 -1,  MATCHER_LE },
+               { ".interval = 10h",            -1,  MATCHER_EQ },
+               { ".Last_Update >= 24D",        -1,  MATCHER_GE },
+               { ".age > 1M",                  -1,  MATCHER_GT },
+               { ".age != 20Y",                -1,  MATCHER_NOT },
+               { ".backend != 'be'",           -1,  MATCHER_NOT },
+               { ".age <= 2 * .interval",      -1,  MATCHER_LE },
 
                /* check operator precedence */
                { "host = 'name' OR "
@@ -377,6 +387,7 @@ START_TEST(test_parse_matcher)
                /* syntax errors */
                { "LIST",                       -1, -1 },
                { "foo &^ bar",                 -1, -1 },
+               { ".invalid",                   -1, -1 },
        };
 
        size_t i;
@@ -404,6 +415,72 @@ START_TEST(test_parse_matcher)
 }
 END_TEST
 
+START_TEST(test_parse_expr)
+{
+       struct {
+               const char *expr;
+               int len;
+               int expected;
+       } golden_data[] = {
+               /* empty expressions */
+               { NULL,                  -1, INT_MAX },
+               { "",                    -1, INT_MAX },
+
+               /* constant expressions */
+               { "'localhost'",         -1, 0 },
+               { "123",                 -1, 0 },
+               { "2014-08-16",          -1, 0 },
+               { "17:23",               -1, 0 },
+               { "17:23:53",            -1, 0 },
+               { "17:23:53.123",        -1, 0 },
+               { "17:23:53.123456789",  -1, 0 },
+               { "2014-08-16 17:23",    -1, 0 },
+               { "2014-08-16 17:23:53", -1, 0 },
+               { "10s",                 -1, 0 },
+               { "60m",                 -1, 0 },
+               { "10Y 24D 1h",          -1, 0 },
+
+               /* queryable fields */
+               { ".last_update",        -1, FIELD_VALUE },
+               { ".AGE",                -1, FIELD_VALUE },
+               { ".interval",           -1, FIELD_VALUE },
+               { ".Last_Update",        -1, FIELD_VALUE },
+               { ".backend",            -1, FIELD_VALUE },
+
+               /* attributes */
+               { "attribute[foo]",      -1, ATTR_VALUE },
+
+               /* syntax errors */
+               { "LIST",                -1, INT_MAX },
+               { "foo &^ bar",          -1, INT_MAX },
+               { ".invalid",            -1, INT_MAX },
+       };
+
+       size_t i;
+
+       for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
+               sdb_store_expr_t *e;
+               e = sdb_fe_parse_expr(golden_data[i].expr, golden_data[i].len);
+
+               if (golden_data[i].expected == INT_MAX) {
+                       fail_unless(e == NULL,
+                                       "sdb_fe_parse_expr(%s) = %p; expected: NULL",
+                                       golden_data[i].expr, e);
+                       continue;
+               }
+
+               fail_unless(e != NULL, "sdb_fe_parse_expr(%s) = NULL; "
+                               "expected: <expr>", golden_data[i].expr);
+               fail_unless(e->type == golden_data[i].expected,
+                               "sdb_fe_parse_expr(%s) returned expression of type %d; "
+                               "expected: %d", golden_data[i].expr, e->type,
+                               golden_data[i].expected);
+
+               sdb_object_deref(SDB_OBJ(e));
+       }
+}
+END_TEST
+
 Suite *
 fe_parser_suite(void)
 {
@@ -413,6 +490,7 @@ fe_parser_suite(void)
        tc = tcase_create("core");
        tcase_add_test(tc, test_parse);
        tcase_add_test(tc, test_parse_matcher);
+       tcase_add_test(tc, test_parse_expr);
        suite_add_tcase(s, tc);
 
        return s;