X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=t%2Funit%2Fcore%2Fstore_lookup_test.c;h=007fd05c042083cc14997b8df6967d1688d9bef6;hb=643b6cdd66f789baac6a4f13d1466f7688e22670;hp=805de03e7deb6f6645aaa37be3d85c4344680cc3;hpb=33c80b1c2a05192e6b912558f99d19a4d7f9ef06;p=sysdb.git

diff --git a/t/unit/core/store_lookup_test.c b/t/unit/core/store_lookup_test.c
index 805de03..007fd05 100644
--- a/t/unit/core/store_lookup_test.c
+++ b/t/unit/core/store_lookup_test.c
@@ -198,84 +198,9 @@ START_TEST(test_store_match_name)
 }
 END_TEST
 
-START_TEST(test_store_match_attr)
+START_TEST(test_cmp_attr)
 {
-	sdb_store_obj_t *obj;
-
-	struct {
-		const char *attr_name;
-		const char *attr_value;
-		_Bool re;
-
-		int expected;
-	} golden_data[] = {
-		{ "k1", NULL,   0, 1 },
-		{ "k",  NULL,   1, 0 },
-		{ "1",  NULL,   1, 0 },
-		{ "k3", NULL,   0, 0 },
-		{ "k3", NULL,   1, 0 },
-		{ "k1", "v1",   0, 1 },
-		{ "k1", "v1",   1, 1 },
-		{ "k1", "^v1$", 1, 1 },
-		{ "k1", "v",    1, 1 },
-		{ "k1", "1",    1, 1 },
-		{ "k1", "v2",   0, 0 },
-		{ "k1", "v2",   1, 0 },
-		{ "k",  "v1",   0, 0 },
-		{ "k",  "v1",   1, 0 },
-		{ "k3", "1",    0, 0 },
-		{ "k3", "1",    1, 0 },
-	};
-
-	size_t i;
-
-	obj = sdb_store_get_host("a");
-	fail_unless(obj != NULL,
-			"sdb_store_get_host(a) = NULL; expected: <host>");
-
-	fail_unless(sdb_store_attr_matcher(NULL, "re", 0) == NULL,
-			"sdb_store_attr_matcher(NULL, \"re\", 0) = <m>; expected: NULL");
-	fail_unless(sdb_store_attr_matcher(NULL, "re", 1) == NULL,
-			"sdb_store_attr_matcher(NULL, \"re\", 1) = <m>; expected: NULL");
-
-	for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
-		sdb_store_matcher_t *m, *n;
-		int status;
-
-		m = sdb_store_attr_matcher(golden_data[i].attr_name,
-				golden_data[i].attr_value, golden_data[i].re);
-		fail_unless(m != NULL,
-				"sdb_store_attr_matcher() = NULL; expected: <matcher>");
-
-		status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
-		fail_unless(status == golden_data[i].expected,
-				"sdb_store_matcher_matches(attribute[%s] = %s, "
-				"<host a>, NULL) = %d; expected: %d", golden_data[i].attr_name,
-				golden_data[i].attr_value, status, golden_data[i].expected);
-
-		n = sdb_store_inv_matcher(m);
-		fail_unless(n != NULL,
-				"sdb_store_inv_matcher() = NULL; expected: <matcher>");
-		sdb_object_deref(SDB_OBJ(m));
-
-		/* now match the inverted set of objects */
-		status = sdb_store_matcher_matches(n, obj, /* filter */ NULL);
-		fail_unless(status == !golden_data[i].expected,
-				"sdb_store_matcher_matches(attribute[%s] = %s, "
-				"<host a>, NULL) = %d; expected: %d",
-				golden_data[i].attr_name, golden_data[i].attr_value,
-				status, !golden_data[i].expected);
-
-		sdb_object_deref(SDB_OBJ(n));
-	}
-
-	sdb_object_deref(SDB_OBJ(obj));
-}
-END_TEST
-
-START_TEST(test_attr_cond)
-{
-	sdb_store_obj_t *obj;
+	sdb_store_obj_t *host;
 
 	struct {
 		const char *attr;
@@ -301,18 +226,19 @@ START_TEST(test_attr_cond)
 	int status;
 	size_t i;
 
-	obj = sdb_store_get_host("a");
-	fail_unless(obj != NULL,
+	host = sdb_store_get_host("a");
+	fail_unless(host != NULL,
 			"sdb_store_get_host(a) = NULL; expected: <host>");
 
 	for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
-		sdb_store_expr_t *expr;
-		sdb_store_cond_t *c;
-		char buf[1024];
+		sdb_store_expr_t *attr;
+		sdb_store_expr_t *value;
+		char value_str[1024];
 		size_t j;
 
 		struct {
-			sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *);
+			sdb_store_matcher_t *(*matcher)(sdb_store_expr_t *,
+					sdb_store_expr_t *);
 			int expected;
 		} tests[] = {
 			{ sdb_store_lt_matcher, golden_data[i].expected_lt },
@@ -323,38 +249,38 @@ START_TEST(test_attr_cond)
 		};
 
 		sdb_data_format(&golden_data[i].value,
-				buf, sizeof(buf), SDB_UNQUOTED);
+				value_str, sizeof(value_str), SDB_UNQUOTED);
 
-		expr = sdb_store_expr_constvalue(&golden_data[i].value);
-		fail_unless(expr != NULL,
-				"sdb_store_expr_constvalue(%s) = NULL; expected: <expr>",
-				buf);
+		attr = sdb_store_expr_attrvalue(golden_data[i].attr);
+		fail_unless(attr != NULL,
+				"sdb_store_expr_attrvalue(%s) = NULL; expected: <expr>",
+				golden_data[i].attr);
 
-		c = sdb_store_attr_cond(golden_data[i].attr, expr);
-		sdb_object_deref(SDB_OBJ(expr));
-		fail_unless(c != NULL,
-				"sdb_store_attr_cond(%s, expr{%s}) = NULL; expected: <cond>",
-				golden_data[i].attr, buf);
+		value = sdb_store_expr_constvalue(&golden_data[i].value);
+		fail_unless(value != NULL,
+				"sdb_store_expr_constvalue(%s) = NULL; expected: <expr>",
+				value_str);
 
 		for (j = 0; j < SDB_STATIC_ARRAY_LEN(tests); ++j) {
 			sdb_store_matcher_t *m;
 
-			m = tests[j].matcher(c);
+			m = tests[j].matcher(attr, value);
 			fail_unless(m != NULL,
 					"sdb_store_<cond>_matcher() = NULL; expected: <matcher>");
 
-			status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
+			status = sdb_store_matcher_matches(m, host, /* filter */ NULL);
 			fail_unless(status == tests[j].expected,
-					"sdb_store_matcher_matches(<m>, <obj>, NULL) = %d; "
+					"sdb_store_matcher_matches(<m>, <host>, NULL) = %d; "
 					"expected: %d", status, tests[j].expected);
 
 			sdb_object_deref(SDB_OBJ(m));
 		}
 
-		sdb_object_deref(SDB_OBJ(c));
+		sdb_object_deref(SDB_OBJ(attr));
+		sdb_object_deref(SDB_OBJ(value));
 	}
 
-	sdb_object_deref(SDB_OBJ(obj));
+	sdb_object_deref(SDB_OBJ(host));
 }
 END_TEST
 
@@ -424,11 +350,11 @@ START_TEST(test_cmp_obj)
 					sdb_store_expr_t *);
 			int expected;
 		} tests[] = {
-			{ sdb_store_cmp_lt, golden_data[i].expected_lt },
-			{ sdb_store_cmp_le, golden_data[i].expected_le },
-			{ sdb_store_cmp_eq, golden_data[i].expected_eq },
-			{ sdb_store_cmp_ge, golden_data[i].expected_ge },
-			{ sdb_store_cmp_gt, golden_data[i].expected_gt },
+			{ sdb_store_lt_matcher, golden_data[i].expected_lt },
+			{ sdb_store_le_matcher, golden_data[i].expected_le },
+			{ sdb_store_eq_matcher, golden_data[i].expected_eq },
+			{ sdb_store_ge_matcher, golden_data[i].expected_ge },
+			{ sdb_store_gt_matcher, golden_data[i].expected_gt },
 		};
 		char *op_str[] = { "<", "<=", "=", ">=", ">" };
 
@@ -556,7 +482,6 @@ START_TEST(test_parse_cmp)
 	sdb_data_t metricname = { SDB_TYPE_STRING,  { .string  = "metricname" } };
 	sdb_data_t srvname    = { SDB_TYPE_STRING,  { .string  = "srvname" } };
 	sdb_data_t attrname   = { SDB_TYPE_STRING,  { .string  = "attrname" } };
-	sdb_data_t attrvalue  = { SDB_TYPE_INTEGER, { .integer = 4711 } };
 
 	sdb_store_matcher_t *check;
 
@@ -564,75 +489,50 @@ START_TEST(test_parse_cmp)
 
 	struct {
 		const char *obj_type;
-		const char *attr;
 		const char *op;
 		const sdb_data_t *value;
 		int expected;
 	} golden_data[] = {
-		{ "host",      NULL,   "=",  &hostname,   MATCHER_NAME },
-		{ "host",      NULL,   "!=", &hostname,   MATCHER_NOT },
-		{ "host",      NULL,   "=~", &hostname,   MATCHER_NAME },
-		{ "host",      NULL,   "!~", &hostname,   MATCHER_NOT },
-		{ "host",      "attr", "=",  &hostname,   -1 },
-		{ "host",      "attr", "!=", &hostname,   -1 },
-		{ "host",      "attr", "!=", &attrvalue,  -1 },
-		{ "host",      "attr", "<=", &attrvalue,  -1 },
-		{ "host",      NULL,   "&^", &hostname,   -1 },
-		{ "host",      NULL,   "<",  &hostname,   -1 },
-		{ "host",      NULL,   "<=", &hostname,   -1 },
-		{ "host",      NULL,   ">=", &hostname,   -1 },
-		{ "host",      NULL,   ">",  &hostname,   -1 },
-		{ "host",      NULL,   "=",  NULL,        -1 },
-		{ "metric",    NULL,   "=",  &metricname, MATCHER_NAME },
-		{ "metric",    NULL,   "!=", &metricname, MATCHER_NOT },
-		{ "metric",    NULL,   "=~", &metricname, MATCHER_NAME },
-		{ "metric",    NULL,   "!~", &metricname, MATCHER_NOT },
-		{ "metric",    "attr", "=",  &metricname, -1 },
-		{ "metric",    "attr", "!=", &metricname, -1 },
-		{ "metric",    "attr", "!=", &attrvalue,  -1 },
-		{ "metric",    "attr", "<=", &attrvalue,  -1 },
-		{ "metric",    NULL,   "&^", &metricname, -1 },
-		{ "metric",    NULL,   "<",  &metricname, -1 },
-		{ "metric",    NULL,   "<=", &metricname, -1 },
-		{ "metric",    NULL,   ">=", &metricname, -1 },
-		{ "metric",    NULL,   ">",  &metricname, -1 },
-		{ "metric",    NULL,   "=",  NULL,        -1 },
-		{ "service",   NULL,   "=",  &srvname,    MATCHER_NAME },
-		{ "service",   NULL,   "!=", &srvname,    MATCHER_NOT },
-		{ "service",   NULL,   "=~", &srvname,    MATCHER_NAME },
-		{ "service",   NULL,   "!~", &srvname,    MATCHER_NOT },
-		{ "service",   "attr", "=",  &srvname,    -1 },
-		{ "service",   "attr", "!=", &srvname,    -1 },
-		{ "service",   "attr", "!=", &attrvalue,  -1 },
-		{ "service",   "attr", "<=", &attrvalue,  -1 },
-		{ "service",   NULL,   "&^", &srvname,    -1 },
-		{ "service",   NULL,   "<",  &srvname,    -1 },
-		{ "service",   NULL,   "<=", &srvname,    -1 },
-		{ "service",   NULL,   ">=", &srvname,    -1 },
-		{ "service",   NULL,   ">",  &srvname,    -1 },
-		{ "service",   NULL,   "=",  NULL,        -1 },
-		{ "attribute", NULL,   "=",  &attrname,   MATCHER_NAME },
-		{ "attribute", NULL,   "!=", &attrname,   MATCHER_NOT },
-		{ "attribute", NULL,   "=~", &attrname,   MATCHER_NAME },
-		{ "attribute", NULL,   "!~", &attrname,   MATCHER_NOT },
-		{ "attribute", NULL,   "<",  &attrname,   -1 },
-		{ "attribute", NULL,   "<=", &attrname,   -1 },
-		{ "attribute", NULL,   ">=", &attrname,   -1 },
-		{ "attribute", NULL,   ">",  &attrname,   -1 },
-		{ "attribute", NULL,   "=",  NULL,        -1 },
-		{ "attribute", "attr", "=",  &attrname,   MATCHER_ATTR },
-		{ "attribute", "attr", "!=", &attrname,   MATCHER_NOT },
-		{ "attribute", "attr", "=~", &attrname,   MATCHER_ATTR },
-		{ "attribute", "attr", "!~", &attrname,   MATCHER_NOT },
-		{ "attribute", "attr", "&^", &attrname,   -1 },
-		{ "attribute", "attr", "<",  NULL,        -1 },
-		{ "attribute", "attr", "<",  &attrname,   MATCHER_LT },
-		{ "attribute", "attr", "<=", &attrname,   MATCHER_LE },
-/*		{ "attribute", "attr", "=",  &attrname,   MATCHER_EQ }, */
-		{ "attribute", "attr", ">=", &attrname,   MATCHER_GE },
-		{ "attribute", "attr", ">",  &attrname,   MATCHER_GT },
-		{ "foo",       NULL,   "=",  &attrname,   -1 },
-		{ "foo",       "attr", "=",  &attrname,   -1 },
+		{ "host",      "=",  &hostname,   MATCHER_NAME },
+		{ "host",      "!=", &hostname,   MATCHER_NOT },
+		{ "host",      "=~", &hostname,   MATCHER_NAME },
+		{ "host",      "!~", &hostname,   MATCHER_NOT },
+		{ "host",      "&^", &hostname,   -1 },
+		{ "host",      "<",  &hostname,   -1 },
+		{ "host",      "<=", &hostname,   -1 },
+		{ "host",      ">=", &hostname,   -1 },
+		{ "host",      ">",  &hostname,   -1 },
+		{ "host",      "=",  NULL,        -1 },
+		{ "metric",    "=",  &metricname, MATCHER_NAME },
+		{ "metric",    "!=", &metricname, MATCHER_NOT },
+		{ "metric",    "=~", &metricname, MATCHER_NAME },
+		{ "metric",    "!~", &metricname, MATCHER_NOT },
+		{ "metric",    "&^", &metricname, -1 },
+		{ "metric",    "<",  &metricname, -1 },
+		{ "metric",    "<=", &metricname, -1 },
+		{ "metric",    ">=", &metricname, -1 },
+		{ "metric",    ">",  &metricname, -1 },
+		{ "metric",    "=",  NULL,        -1 },
+		{ "service",   "=",  &srvname,    MATCHER_NAME },
+		{ "service",   "!=", &srvname,    MATCHER_NOT },
+		{ "service",   "=~", &srvname,    MATCHER_NAME },
+		{ "service",   "!~", &srvname,    MATCHER_NOT },
+		{ "service",   "&^", &srvname,    -1 },
+		{ "service",   "<",  &srvname,    -1 },
+		{ "service",   "<=", &srvname,    -1 },
+		{ "service",   ">=", &srvname,    -1 },
+		{ "service",   ">",  &srvname,    -1 },
+		{ "service",   "=",  NULL,        -1 },
+		{ "attribute", "=",  &attrname,   MATCHER_NAME },
+		{ "attribute", "!=", &attrname,   MATCHER_NOT },
+		{ "attribute", "=~", &attrname,   MATCHER_NAME },
+		{ "attribute", "!~", &attrname,   MATCHER_NOT },
+		{ "attribute", "<",  &attrname,   -1 },
+		{ "attribute", "<=", &attrname,   -1 },
+		{ "attribute", ">=", &attrname,   -1 },
+		{ "attribute", ">",  &attrname,   -1 },
+		{ "attribute", "=",  NULL,        -1 },
+		{ "foo",       "=",  &attrname,   -1 },
 	};
 
 	for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
@@ -649,26 +549,25 @@ START_TEST(test_parse_cmp)
 				buf);
 
 		check = sdb_store_matcher_parse_cmp(golden_data[i].obj_type,
-				golden_data[i].attr, golden_data[i].op, expr);
+				golden_data[i].op, expr);
 		sdb_object_deref(SDB_OBJ(expr));
 
 		if (golden_data[i].expected == -1) {
 			fail_unless(check == NULL,
-					"sdb_store_matcher_parse_cmp(%s, %s, %s, expr{%s}) = %p; "
+					"sdb_store_matcher_parse_cmp(%s, %s, expr{%s}) = %p; "
 					"expected: NULL", golden_data[i].obj_type,
-					golden_data[i].attr, golden_data[i].op, buf, check);
+					golden_data[i].op, buf, check);
 			continue;
 		}
 
 		fail_unless(check != NULL,
-				"sdb_store_matcher_parse_cmp(%s, %s, %s, %s) = %p; "
+				"sdb_store_matcher_parse_cmp(%s, %s, %s) = %p; "
 				"expected: <expr>", golden_data[i].obj_type,
-				golden_data[i].attr, golden_data[i].op, buf, check);
+				golden_data[i].op, buf, check);
 		fail_unless(M(check)->type == golden_data[i].expected,
-				"sdb_store_matcher_parse_cmp(%s, %s, %s, %s) returned matcher "
+				"sdb_store_matcher_parse_cmp(%s, %s, %s) returned matcher "
 				"of type %d; expected: %d", golden_data[i].obj_type,
-				golden_data[i].attr, golden_data[i].op, buf,
-				M(check)->type, golden_data[i].expected);
+				golden_data[i].op, buf, M(check)->type, golden_data[i].expected);
 
 		sdb_object_deref(SDB_OBJ(check));
 	}
@@ -698,6 +597,7 @@ START_TEST(test_scan)
 		const char *filter;
 		int expected;
 	} golden_data[] = {
+		/* TODO: check the name of the expected hosts */
 		{ "host = 'a'", NULL,                  1 },
 		{ "host = 'a'", "host = 'x'",          0 }, /* filter never matches */
 		{ "host = 'a'",
@@ -722,10 +622,19 @@ START_TEST(test_scan)
 		{ "attribute = 'k1'", "host = 'x'",    0 }, /* filter never matches */
 		{ "attribute = 'k1'",
 			"NOT attribute['x'] = ''",         2 }, /* filter always matches */
+		{ "attribute =~ 'k'", NULL,            2 },
+		{ "attribute =~ '1'", NULL,            2 },
+		{ "attribute =~ '2'", NULL,            1 },
 		{ "attribute = 'x'", NULL,             0 },
+		{ "attribute =~ 'x'", NULL,            0 },
 		{ "attribute['k1'] = 'v1'", NULL,      1 },
+		{ "attribute['k1'] =~ 'v1'", NULL,     1 },
+		{ "attribute['k1'] =~ '^v1$'", NULL,   1 },
 		{ "attribute['k1'] =~ 'v'", NULL,      2 },
+		{ "attribute['k1'] =~ '1'", NULL,      1 },
 		{ "attribute['k1'] !~ 'v'", NULL,      1 },
+		{ "attribute['k1'] = 'v2'", NULL,      1 },
+		{ "attribute['k1'] =~ 'v2'", NULL,     1 },
 		{ "attribute['x1'] =~ 'v'", NULL,      0 },
 		{ "attribute['x1'] =~ 'NULL'", NULL,   0 },
 		{ "attribute['x1'] !~ 'v'", NULL,      3 },
@@ -792,8 +701,7 @@ core_store_lookup_suite(void)
 	tc = tcase_create("core");
 	tcase_add_checked_fixture(tc, populate, sdb_store_clear);
 	tcase_add_test(tc, test_store_match_name);
-	tcase_add_test(tc, test_store_match_attr);
-	tcase_add_test(tc, test_attr_cond);
+	tcase_add_test(tc, test_cmp_attr);
 	tcase_add_test(tc, test_cmp_obj);
 	tcase_add_test(tc, test_store_match_op);
 	tcase_add_test(tc, test_parse_cmp);