1adece554b031c6f94712b2a4977aa6ed2715e63
1 /*
2 * SysDB - t/unit/core/store_lookup_test.c
3 * Copyright (C) 2014 Sebastian 'tokkee' Harl <sh@tokkee.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
17 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
28 #include "core/store.h"
29 #include "core/store-private.h"
30 #include "frontend/parser.h"
31 #include "libsysdb_test.h"
33 #include <check.h>
34 #include <string.h>
36 static void
37 populate(void)
38 {
39 const char *hosts[] = { "a", "b", "c" };
41 struct {
42 const char *host;
43 const char *service;
44 } services[] = {
45 { "a", "s1" },
46 { "a", "s2" },
47 { "b", "s1" },
48 { "b", "s3" },
49 };
51 struct {
52 const char *host;
53 const char *name;
54 sdb_data_t value;
55 } attrs[] = {
56 { "a", "k1", { SDB_TYPE_STRING, { .string = "v1" } } },
57 { "a", "k2", { SDB_TYPE_INTEGER, { .integer = 123 } } },
58 };
60 size_t i;
62 for (i = 0; i < SDB_STATIC_ARRAY_LEN(hosts); ++i) {
63 int status = sdb_store_host(hosts[i], 1);
64 fail_unless(status == 0,
65 "sdb_store_host(%s, 1) = %d; expected: 0",
66 hosts[i], status);
67 }
69 for (i = 0; i < SDB_STATIC_ARRAY_LEN(services); ++i) {
70 int status = sdb_store_service(services[i].host,
71 services[i].service, 1);
72 fail_unless(status == 0,
73 "sdb_store_service(%s, %s, 1) = %d; expected: 0",
74 services[i].host, services[i].service, status);
75 }
77 for (i = 0; i < SDB_STATIC_ARRAY_LEN(attrs); ++i) {
78 int status = sdb_store_attribute(attrs[i].host,
79 attrs[i].name, &attrs[i].value, 1);
80 fail_unless(status == 0,
81 "sdb_store_attribute(%s, %s, <val>, 1) = %d; expected: 0",
82 attrs[i].host, attrs[i].name, status);
83 }
84 } /* populate */
86 START_TEST(test_store_match_name)
87 {
88 sdb_store_obj_t *obj;
90 struct {
91 int type;
92 const char *name;
93 _Bool re;
95 int expected;
96 } golden_data[] = {
97 { SDB_HOST, NULL, 0, 1 },
98 { SDB_HOST, NULL, 1, 1 },
99 { SDB_HOST, "a", 0, 1 },
100 { SDB_HOST, "a", 1, 1 },
101 { SDB_HOST, "b", 0, 0 },
102 { SDB_HOST, "b", 1, 0 },
103 { SDB_HOST, "^a$", 1, 1 },
104 { SDB_HOST, "^b$", 1, 0 },
105 { SDB_HOST, "^a$", 0, 0 },
106 { SDB_HOST, "^b$", 0, 0 },
107 { SDB_SERVICE, NULL, 0, 1 },
108 { SDB_SERVICE, NULL, 1, 1 },
109 { SDB_SERVICE, "s1", 0, 1 },
110 { SDB_SERVICE, "s2", 0, 1 },
111 { SDB_SERVICE, "s3", 0, 0 },
112 { SDB_SERVICE, "s4", 0, 0 },
113 { SDB_SERVICE, "^s1$", 1, 1 },
114 { SDB_SERVICE, "^s1$", 0, 0 },
115 { SDB_SERVICE, "x1", 0, 0 },
116 { SDB_SERVICE, "x1", 1, 0 },
117 { SDB_SERVICE, "x", 1, 0 },
118 { SDB_ATTRIBUTE, NULL, 0, 1 },
119 { SDB_ATTRIBUTE, NULL, 1, 1 },
120 { SDB_ATTRIBUTE, "k1", 0, 1 },
121 { SDB_ATTRIBUTE, "k2", 0, 1 },
122 { SDB_ATTRIBUTE, "k3", 0, 0 },
123 { SDB_ATTRIBUTE, "k4", 0, 0 },
124 { SDB_ATTRIBUTE, "k", 1, 1 },
125 { SDB_ATTRIBUTE, "1", 1, 1 },
126 { SDB_ATTRIBUTE, "3", 1, 0 },
127 };
129 size_t i;
131 obj = sdb_store_get_host("a");
132 fail_unless(obj != NULL,
133 "sdb_store_get_host(a) = NULL; expected: <host>");
135 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
136 sdb_store_matcher_t *m, *n;
137 char buf[1024];
138 int status;
140 m = sdb_store_name_matcher(golden_data[i].type,
141 golden_data[i].name, golden_data[i].re);
142 fail_unless(m != NULL,
143 "sdb_store_service_matcher(%d, %s, %d) = NULL; "
144 "expected: <matcher>", golden_data[i].type,
145 golden_data[i].name, golden_data[i].re);
147 status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
148 fail_unless(status == golden_data[i].expected,
149 "sdb_store_matcher_matches(%s, <host a>, NULL) = %d; "
150 "expected: %d",
151 sdb_store_matcher_tostring(m, buf, sizeof(buf)),
152 status, golden_data[i].expected);
154 n = sdb_store_inv_matcher(m);
155 fail_unless(n != NULL,
156 "sdb_store_inv_matcher() = NULL; expected: <matcher>");
157 sdb_object_deref(SDB_OBJ(m));
159 /* now match the inverted set of objects */
160 status = sdb_store_matcher_matches(n, obj, /* filter */ NULL);
161 fail_unless(status == !golden_data[i].expected,
162 "sdb_store_matcher_matches(%s, <host a>, NULL) = %d; "
163 "expected: %d",
164 sdb_store_matcher_tostring(n, buf, sizeof(buf)),
165 status, !golden_data[i].expected);
167 sdb_object_deref(SDB_OBJ(n));
168 }
170 sdb_object_deref(SDB_OBJ(obj));
171 }
172 END_TEST
174 START_TEST(test_store_match_attr)
175 {
176 sdb_store_obj_t *obj;
178 struct {
179 const char *attr_name;
180 const char *attr_value;
181 _Bool re;
183 int expected;
184 } golden_data[] = {
185 { "k1", NULL, 0, 1 },
186 { "k", NULL, 1, 0 },
187 { "1", NULL, 1, 0 },
188 { "k3", NULL, 0, 0 },
189 { "k3", NULL, 1, 0 },
190 { "k1", "v1", 0, 1 },
191 { "k1", "v1", 1, 1 },
192 { "k1", "^v1$", 1, 1 },
193 { "k1", "v", 1, 1 },
194 { "k1", "1", 1, 1 },
195 { "k1", "v2", 0, 0 },
196 { "k1", "v2", 1, 0 },
197 { "k", "v1", 0, 0 },
198 { "k", "v1", 1, 0 },
199 { "k3", "1", 0, 0 },
200 { "k3", "1", 1, 0 },
201 };
203 size_t i;
205 obj = sdb_store_get_host("a");
206 fail_unless(obj != NULL,
207 "sdb_store_get_host(a) = NULL; expected: <host>");
209 fail_unless(sdb_store_attr_matcher(NULL, "re", 0) == NULL,
210 "sdb_store_attr_matcher(NULL, \"re\", 0) = <m>; expected: NULL");
211 fail_unless(sdb_store_attr_matcher(NULL, "re", 1) == NULL,
212 "sdb_store_attr_matcher(NULL, \"re\", 1) = <m>; expected: NULL");
214 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
215 sdb_store_matcher_t *m, *n;
216 char buf[1024];
217 int status;
219 m = sdb_store_attr_matcher(golden_data[i].attr_name,
220 golden_data[i].attr_value, golden_data[i].re);
221 fail_unless(m != NULL,
222 "sdb_store_attr_matcher() = NULL; expected: <matcher>");
224 status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
225 fail_unless(status == golden_data[i].expected,
226 "sdb_store_matcher_matches({%s, <host a>, NULL) = %d; "
227 "expected: %d",
228 sdb_store_matcher_tostring(m, buf, sizeof(buf)),
229 status, golden_data[i].expected);
231 n = sdb_store_inv_matcher(m);
232 fail_unless(n != NULL,
233 "sdb_store_inv_matcher() = NULL; expected: <matcher>");
234 sdb_object_deref(SDB_OBJ(m));
236 /* now match the inverted set of objects */
237 status = sdb_store_matcher_matches(n, obj, /* filter */ NULL);
238 fail_unless(status == !golden_data[i].expected,
239 "sdb_store_matcher_matches({%s, <host a>, NULL) = %d; "
240 "expected: %d",
241 sdb_store_matcher_tostring(n, buf, sizeof(buf)),
242 status, !golden_data[i].expected);
244 sdb_object_deref(SDB_OBJ(n));
245 }
247 sdb_object_deref(SDB_OBJ(obj));
248 }
249 END_TEST
251 START_TEST(test_store_cond)
252 {
253 sdb_store_obj_t *obj;
255 struct {
256 const char *attr;
257 const sdb_data_t value;
258 int expected_lt, expected_le, expected_eq, expected_ge, expected_gt;
259 } golden_data[] = {
260 { "k1", { SDB_TYPE_STRING, { .string = "v1" } }, 0, 1, 1, 1, 0 },
261 { "k1", { SDB_TYPE_STRING, { .string = "v2" } }, 1, 1, 0, 0, 0 },
262 { "k1", { SDB_TYPE_STRING, { .string = "v0" } }, 0, 0, 0, 1, 1 },
263 { "k2", { SDB_TYPE_INTEGER, { .integer = 123 } }, 0, 1, 1, 1, 0 },
264 { "k2", { SDB_TYPE_INTEGER, { .integer = 124 } }, 1, 1, 0, 0, 0 },
265 { "k2", { SDB_TYPE_INTEGER, { .integer = 122 } }, 0, 0, 0, 1, 1 },
266 /* key does not exist */
267 { "k3", { SDB_TYPE_STRING, { .string = "v1" } }, 0, 0, 0, 0, 0 },
268 { "k3", { SDB_TYPE_STRING, { .string = "123" } }, 0, 0, 0, 0, 0 },
269 { "k3", { SDB_TYPE_INTEGER, { .integer = 123 } }, 0, 0, 0, 0, 0 },
270 /* type mismatch */
271 { "k1", { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
272 { "k2", { SDB_TYPE_STRING, { .string = "123" } }, 0, 0, 0, 0, 0 },
273 };
275 int status;
276 size_t i;
278 obj = sdb_store_get_host("a");
279 fail_unless(obj != NULL,
280 "sdb_store_get_host(a) = NULL; expected: <host>");
282 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
283 sdb_store_expr_t *expr;
284 sdb_store_cond_t *c;
285 char buf[1024];
286 size_t j;
288 struct {
289 sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *);
290 int *expected;
291 } tests[] = {
292 { sdb_store_lt_matcher, &golden_data[i].expected_lt },
293 { sdb_store_le_matcher, &golden_data[i].expected_le },
294 { sdb_store_eq_matcher, &golden_data[i].expected_eq },
295 { sdb_store_ge_matcher, &golden_data[i].expected_ge },
296 { sdb_store_gt_matcher, &golden_data[i].expected_gt },
297 };
299 sdb_data_format(&golden_data[i].value,
300 buf, sizeof(buf), SDB_UNQUOTED);
302 expr = sdb_store_expr_constvalue(&golden_data[i].value);
303 fail_unless(expr != NULL,
304 "sdb_store_expr_constvalue(%s) = NULL; expected: <expr>",
305 buf);
307 c = sdb_store_attr_cond(golden_data[i].attr, expr);
308 sdb_object_deref(SDB_OBJ(expr));
309 fail_unless(c != NULL,
310 "sdb_store_attr_cond(%s, expr{%s}) = NULL; expected: <cond>",
311 golden_data[i].attr, buf);
313 for (j = 0; j < SDB_STATIC_ARRAY_LEN(tests); ++j) {
314 sdb_store_matcher_t *m;
315 char m_str[1024];
317 m = tests[j].matcher(c);
318 fail_unless(m != NULL,
319 "sdb_store_<cond>_matcher() = NULL; expected: <matcher>");
321 status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
322 fail_unless(status == *tests[j].expected,
323 "sdb_store_matcher_matches(%s, <obj>, NULL) = %d; "
324 "expected: %d",
325 sdb_store_matcher_tostring(m, m_str, sizeof(m_str)),
326 status, *tests[j].expected);
328 sdb_object_deref(SDB_OBJ(m));
329 }
331 sdb_object_deref(SDB_OBJ(c));
332 }
334 sdb_object_deref(SDB_OBJ(obj));
335 }
336 END_TEST
338 START_TEST(test_store_match_op)
339 {
340 sdb_store_obj_t *obj;
342 sdb_store_matcher_t *always = sdb_store_name_matcher(SDB_HOST, "a", 0);
343 sdb_store_matcher_t *never = sdb_store_name_matcher(SDB_HOST, "z", 0);
345 struct {
346 const char *op;
347 sdb_store_matcher_t *left;
348 sdb_store_matcher_t *right;
349 int expected;
350 } golden_data[] = {
351 { "OR", always, always, 1 },
352 { "OR", always, never, 1 },
353 { "OR", never, always, 1 },
354 { "OR", never, never, 0 },
355 { "AND", always, always, 1 },
356 { "AND", always, never, 0 },
357 { "AND", never, always, 0 },
358 { "AND", never, never, 0 },
359 };
361 int status;
362 size_t i;
364 obj = sdb_store_get_host("a");
366 status = sdb_store_matcher_matches(always, obj, /* filter */ NULL);
367 fail_unless(status == 1,
368 "INTERNAL ERROR: 'always' did not match host");
369 status = sdb_store_matcher_matches(never, obj, /* filter */ NULL);
370 fail_unless(status == 0,
371 "INTERNAL ERROR: 'never' matches host");
373 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
374 sdb_store_matcher_t *m;
376 if (! strcmp(golden_data[i].op, "OR"))
377 m = sdb_store_dis_matcher(golden_data[i].left,
378 golden_data[i].right);
379 else if (! strcmp(golden_data[i].op, "AND"))
380 m = sdb_store_con_matcher(golden_data[i].left,
381 golden_data[i].right);
382 else {
383 fail("INTERNAL ERROR: unexpected operator %s", golden_data[i].op);
384 continue;
385 }
387 #define TO_NAME(v) (((v) == always) ? "always" \
388 : ((v) == never) ? "never" : "<unknown>")
390 status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
391 fail_unless(status == golden_data[i].expected,
392 "%s(%s, %s, NULL) = %d; expected: %d", golden_data[i].op,
393 TO_NAME(golden_data[i].left), TO_NAME(golden_data[i].right),
394 status, golden_data[i].expected);
396 #undef TO_NAME
398 sdb_object_deref(SDB_OBJ(m));
399 }
401 sdb_object_deref(SDB_OBJ(always));
402 sdb_object_deref(SDB_OBJ(never));
404 sdb_object_deref(SDB_OBJ(obj));
405 }
406 END_TEST
408 START_TEST(test_parse_cmp)
409 {
410 sdb_data_t hostname = { SDB_TYPE_STRING, { .string = "hostname" } };
411 sdb_data_t srvname = { SDB_TYPE_STRING, { .string = "srvname" } };
412 sdb_data_t attrname = { SDB_TYPE_STRING, { .string = "attrname" } };
414 sdb_store_matcher_t *check;
416 size_t i;
418 struct {
419 const char *obj_type;
420 const char *attr;
421 const char *op;
422 const sdb_data_t *value;
423 int expected;
424 } golden_data[] = {
425 { "host", NULL, "=", &hostname, MATCHER_NAME },
426 { "host", NULL, "!=", &hostname, MATCHER_NOT },
427 { "host", NULL, "=~", &hostname, MATCHER_NAME },
428 { "host", NULL, "!~", &hostname, MATCHER_NOT },
429 { "host", "attr", "=", &hostname, -1 },
430 { "host", "attr", "!=", &hostname, -1 },
431 { "host", NULL, "&^", &hostname, -1 },
432 { "host", NULL, "<", &hostname, -1 },
433 { "host", NULL, "<=", &hostname, -1 },
434 { "host", NULL, ">=", &hostname, -1 },
435 { "host", NULL, ">", &hostname, -1 },
436 { "host", NULL, "=", NULL, -1 },
437 { "service", NULL, "=", &srvname, MATCHER_NAME },
438 { "service", NULL, "!=", &srvname, MATCHER_NOT },
439 { "service", NULL, "=~", &srvname, MATCHER_NAME },
440 { "service", NULL, "!~", &srvname, MATCHER_NOT },
441 { "service", "attr", "=", &srvname, -1 },
442 { "service", "attr", "!=", &srvname, -1 },
443 { "service", NULL, "&^", &srvname, -1 },
444 { "service", NULL, "<", &srvname, -1 },
445 { "service", NULL, "<=", &srvname, -1 },
446 { "service", NULL, ">=", &srvname, -1 },
447 { "service", NULL, ">", &srvname, -1 },
448 { "service", NULL, "=", NULL, -1 },
449 { "attribute", NULL, "=", &attrname, MATCHER_NAME },
450 { "attribute", NULL, "!=", &attrname, MATCHER_NOT },
451 { "attribute", NULL, "=~", &attrname, MATCHER_NAME },
452 { "attribute", NULL, "!~", &attrname, MATCHER_NOT },
453 { "attribute", NULL, "<", &attrname, -1 },
454 { "attribute", NULL, "<=", &attrname, -1 },
455 { "attribute", NULL, ">=", &attrname, -1 },
456 { "attribute", NULL, ">", &attrname, -1 },
457 { "attribute", NULL, "=", NULL, -1 },
458 { "attribute", "attr", "=", &attrname, MATCHER_ATTR },
459 { "attribute", "attr", "!=", &attrname, MATCHER_NOT },
460 { "attribute", "attr", "=~", &attrname, MATCHER_ATTR },
461 { "attribute", "attr", "!~", &attrname, MATCHER_NOT },
462 { "attribute", "attr", "&^", &attrname, -1 },
463 { "attribute", "attr", "<", NULL, -1 },
464 { "attribute", "attr", "<", &attrname, MATCHER_LT },
465 { "attribute", "attr", "<=", &attrname, MATCHER_LE },
466 /* { "attribute", "attr", "=", &attrname, MATCHER_EQ }, */
467 { "attribute", "attr", ">=", &attrname, MATCHER_GE },
468 { "attribute", "attr", ">", &attrname, MATCHER_GT },
469 { "attribute", "attr", "IS", NULL, MATCHER_ISNULL },
470 { "attribute", "attr", "IS", &attrname, -1 },
471 { "foo", NULL, "=", &attrname, -1 },
472 { "foo", "attr", "=", &attrname, -1 },
473 };
475 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
476 sdb_store_expr_t *expr;
477 char buf[1024];
479 if (sdb_data_format(golden_data[i].value,
480 buf, sizeof(buf), SDB_UNQUOTED) < 0)
481 snprintf(buf, sizeof(buf), "ERR");
483 expr = sdb_store_expr_constvalue(golden_data[i].value);
484 fail_unless(expr != NULL || golden_data[i].value == NULL,
485 "sdb_store_expr_constvalue(%s) = NULL; expected: <expr>",
486 buf);
488 check = sdb_store_matcher_parse_cmp(golden_data[i].obj_type,
489 golden_data[i].attr, golden_data[i].op, expr);
490 sdb_object_deref(SDB_OBJ(expr));
492 if (golden_data[i].expected == -1) {
493 fail_unless(check == NULL,
494 "sdb_store_matcher_parse_cmp(%s, %s, %s, expr{%s}) = %p; "
495 "expected: NULL", golden_data[i].obj_type,
496 golden_data[i].attr, golden_data[i].op, buf, check);
497 continue;
498 }
500 fail_unless(check != NULL,
501 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) = %p; "
502 "expected: NULL", golden_data[i].obj_type,
503 golden_data[i].attr, golden_data[i].op, buf, check);
504 fail_unless(M(check)->type == golden_data[i].expected,
505 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) returned matcher "
506 "of type %d; expected: %d", golden_data[i].obj_type,
507 golden_data[i].attr, golden_data[i].op, buf,
508 M(check)->type, golden_data[i].expected);
510 sdb_object_deref(SDB_OBJ(check));
511 }
512 }
513 END_TEST
515 static int
516 scan_cb(sdb_store_obj_t *obj, void *user_data)
517 {
518 int *i = user_data;
520 fail_unless(obj != NULL,
521 "sdb_store_scan callback received NULL obj; expected: "
522 "<store base obj>");
523 fail_unless(i != NULL,
524 "sdb_store_scan callback received NULL user_data; "
525 "expected: <pointer to data>");
527 ++(*i);
528 return 0;
529 } /* scan_cb */
531 START_TEST(test_scan)
532 {
533 #define PTR_RE "0x[0-9a-f]+"
534 struct {
535 const char *query;
536 const char *filter;
537 int expected;
538 const char *tostring_re;
539 } golden_data[] = {
540 { "host = 'a'", NULL, 1,
541 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
542 { "host = 'a'", "host = 'x'", 0, /* filter never matches */
543 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
544 { "host = 'a'",
545 "NOT attribute.x = ''", 1, /* filter always matches */
546 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
547 { "host =~ 'a|b'", NULL, 2,
548 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
549 { "host =~ 'host'", NULL, 0,
550 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
551 { "host =~ '.'", NULL, 3,
552 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
553 { "service = 's1'", NULL, 2,
554 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
555 { "service = 's1'", "host = 'x'", 0, /* filter never matches */
556 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
557 { "service = 's1'",
558 "NOT attribute.x = ''", 2, /* filter always matches */
559 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
560 { "service =~ 's'", NULL, 2,
561 "OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}" },
562 { "service !~ 's'", NULL, 1,
563 "\\(NOT, OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}\\)" },
564 { "attribute = 'k1'", NULL, 1,
565 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
566 { "attribute = 'k1'", "host = 'x'", 0, /* filter never matches */
567 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
568 { "attribute = 'k1'",
569 "NOT attribute.x = ''", 1, /* filter always matches */
570 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
571 { "attribute = 'x'", NULL, 0,
572 "OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\}" },
573 { "attribute.k1 = 'v1'", NULL, 1,
574 "ATTR\\[k1\\]\\{ VALUE\\{ 'v1', \\(nil\\) \\} \\}" },
575 { "attribute.k1 IS NULL", NULL, 2,
576 "\\(IS NULL, ATTR\\[k1\\]\\)" },
577 { "attribute.x1 IS NULL", NULL, 3,
578 "\\(IS NULL, ATTR\\[x1\\]\\)" },
579 { "attribute.k1 IS NOT NULL", NULL, 1,
580 "\\(NOT, \\(IS NULL, ATTR\\[k1\\]\\)\\)" },
581 { "attribute.x1 IS NOT NULL", NULL, 0,
582 "\\(NOT, \\(IS NULL, ATTR\\[x1\\]\\)\\)" },
583 { "attribute.k2 < 123", NULL, 0,
584 "ATTR\\[k2\\]\\{ < 123 \\}" },
585 { "attribute.k2 <= 123", NULL, 1,
586 "ATTR\\[k2\\]\\{ <= 123 \\}" },
587 { "attribute.k2 >= 123", NULL, 1,
588 "ATTR\\[k2\\]\\{ >= 123 \\}" },
589 { "attribute.k2 > 123", NULL, 0,
590 "ATTR\\[k2\\]\\{ > 123 \\}" },
591 { "attribute.k2 = 123", NULL, 1,
592 "ATTR\\[k2\\]\\{ = 123 \\}" },
593 { "attribute.k2 != 123", NULL, 2,
594 "\\(NOT, ATTR\\[k2\\]\\{ = 123 \\}\\)" },
595 { "attribute.k1 != 'v1'", NULL, 2,
596 "\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v1', \\(nil\\) \\} \\}\\)" },
597 { "attribute.k1 != 'v2'", NULL, 3,
598 "\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v2', \\(nil\\) \\} \\}\\)" },
599 { "attribute != 'x' "
600 "AND attribute.y !~ 'x'", NULL, 3,
601 "\\(AND, "
602 "\\(NOT, OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\} \\}\\), "
603 "\\(NOT, ATTR\\[y\\]\\{ VALUE\\{ NULL, "PTR_RE" \\} \\}\\)\\)" },
604 };
606 int check, n;
607 size_t i;
609 n = 0;
610 check = sdb_store_scan(/* matcher */ NULL, /* filter */ NULL,
611 scan_cb, &n);
612 fail_unless(check == 0,
613 "sdb_store_scan() = %d; expected: 0", check);
614 fail_unless(n == 3,
615 "sdb_store_scan called callback %d times; expected: 3", (int)n);
617 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
618 sdb_store_matcher_t *m, *filter = NULL;
619 char buf[4096];
621 m = sdb_fe_parse_matcher(golden_data[i].query, -1);
622 fail_unless(m != NULL,
623 "sdb_fe_parse_matcher(%s, -1) = NULL; expected: <matcher>",
624 golden_data[i].query);
626 if (golden_data[i].filter) {
627 filter = sdb_fe_parse_matcher(golden_data[i].filter, -1);
628 fail_unless(filter != NULL,
629 "sdb_fe_parse_matcher(%s, -1) = NULL; "
630 "expected: <matcher>", golden_data[i].filter);
631 }
633 fail_unless(sdb_regmatches(golden_data[i].tostring_re,
634 sdb_store_matcher_tostring(m, buf, sizeof(buf))) == 0,
635 "sdb_fe_parse_matcher(%s, -1) = %s; expected: %s",
636 golden_data[i].query,
637 sdb_store_matcher_tostring(m, buf, sizeof(buf)),
638 golden_data[i].tostring_re);
640 n = 0;
641 sdb_store_scan(m, filter, scan_cb, &n);
642 fail_unless(n == golden_data[i].expected,
643 "sdb_store_scan(matcher{%s}, filter{%s}) found %d hosts; "
644 "expected: %d", golden_data[i].query, golden_data[i].filter,
645 n, golden_data[i].expected);
646 sdb_object_deref(SDB_OBJ(filter));
647 sdb_object_deref(SDB_OBJ(m));
648 }
649 }
650 END_TEST
652 Suite *
653 core_store_lookup_suite(void)
654 {
655 Suite *s = suite_create("core::store_lookup");
656 TCase *tc;
658 tc = tcase_create("core");
659 tcase_add_checked_fixture(tc, populate, sdb_store_clear);
660 tcase_add_test(tc, test_store_match_name);
661 tcase_add_test(tc, test_store_match_attr);
662 tcase_add_test(tc, test_store_cond);
663 tcase_add_test(tc, test_store_match_op);
664 tcase_add_test(tc, test_parse_cmp);
665 tcase_add_test(tc, test_scan);
666 suite_add_tcase(s, tc);
668 return s;
669 } /* core_store_lookup_suite */
671 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */