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_attr_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_obj_cond)
339 {
340 struct {
341 const char *host;
342 int field;
343 const sdb_data_t value;
344 int expected_lt, expected_le, expected_eq, expected_ge, expected_gt;
345 } golden_data[] = {
346 /* last-update = 1 for all objects */
347 { "a", SDB_FIELD_LAST_UPDATE,
348 { SDB_TYPE_DATETIME, { .datetime = 1 } }, 0, 1, 1, 1, 0 },
349 { "a", SDB_FIELD_LAST_UPDATE,
350 { SDB_TYPE_DATETIME, { .datetime = 2 } }, 1, 1, 0, 0, 0 },
351 { "a", SDB_FIELD_LAST_UPDATE,
352 { SDB_TYPE_DATETIME, { .datetime = 0 } }, 0, 0, 0, 1, 1 },
353 /* age > 0 for all objects */
354 { "a", SDB_FIELD_AGE,
355 { SDB_TYPE_DATETIME, { .datetime = 0 } }, 0, 0, 0, 1, 1 },
356 /* interval = 0 for all objects */
357 { "a", SDB_FIELD_INTERVAL,
358 { SDB_TYPE_DATETIME, { .datetime = 0 } }, 0, 1, 1, 1, 0 },
359 { "a", SDB_FIELD_INTERVAL,
360 { SDB_TYPE_DATETIME, { .datetime = 1 } }, 1, 1, 0, 0, 0 },
361 /* type mismatch */
362 { "a", SDB_FIELD_LAST_UPDATE,
363 { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
364 { "a", SDB_FIELD_AGE,
365 { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
366 { "a", SDB_FIELD_INTERVAL,
367 { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
368 { "a", SDB_FIELD_BACKEND,
369 { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
370 };
372 int status;
373 size_t i;
375 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
376 sdb_store_obj_t *obj;
377 sdb_store_expr_t *expr;
378 sdb_store_cond_t *c;
379 char buf[1024];
380 size_t j;
382 struct {
383 sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *);
384 int expected;
385 } tests[] = {
386 { sdb_store_lt_matcher, golden_data[i].expected_lt },
387 { sdb_store_le_matcher, golden_data[i].expected_le },
388 { sdb_store_eq_matcher, golden_data[i].expected_eq },
389 { sdb_store_ge_matcher, golden_data[i].expected_ge },
390 { sdb_store_gt_matcher, golden_data[i].expected_gt },
391 };
393 obj = sdb_store_get_host(golden_data[i].host);
394 fail_unless(obj != NULL,
395 "sdb_store_get_host(%s) = NULL; expected: <host>",
396 golden_data[i].host);
398 sdb_data_format(&golden_data[i].value,
399 buf, sizeof(buf), SDB_UNQUOTED);
401 expr = sdb_store_expr_constvalue(&golden_data[i].value);
402 fail_unless(expr != NULL,
403 "sdb_store_expr_constvalue(%s) = NULL; expected: <expr>",
404 buf);
406 c = sdb_store_obj_cond(golden_data[i].field, expr);
407 sdb_object_deref(SDB_OBJ(expr));
408 fail_unless(c != NULL,
409 "sdb_store_obj_cond(%d, expr{%s}) = NULL; expected: <cond>",
410 golden_data[i].field, buf);
412 for (j = 0; j < SDB_STATIC_ARRAY_LEN(tests); ++j) {
413 sdb_store_matcher_t *m;
414 char m_str[1024];
416 m = tests[j].matcher(c);
417 fail_unless(m != NULL,
418 "sdb_store_<cond>_matcher() = NULL; expected: <matcher>");
420 status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
421 fail_unless(status == tests[j].expected,
422 "sdb_store_matcher_matches(%s, <obj>, NULL) = %d; "
423 "expected: %d",
424 sdb_store_matcher_tostring(m, m_str, sizeof(m_str)),
425 status, tests[j].expected);
427 sdb_object_deref(SDB_OBJ(m));
428 }
430 sdb_object_deref(SDB_OBJ(c));
431 sdb_object_deref(SDB_OBJ(obj));
432 }
433 }
434 END_TEST
436 START_TEST(test_store_match_op)
437 {
438 sdb_store_obj_t *obj;
440 sdb_store_matcher_t *always = sdb_store_name_matcher(SDB_HOST, "a", 0);
441 sdb_store_matcher_t *never = sdb_store_name_matcher(SDB_HOST, "z", 0);
443 struct {
444 const char *op;
445 sdb_store_matcher_t *left;
446 sdb_store_matcher_t *right;
447 int expected;
448 } golden_data[] = {
449 { "OR", always, always, 1 },
450 { "OR", always, never, 1 },
451 { "OR", never, always, 1 },
452 { "OR", never, never, 0 },
453 { "AND", always, always, 1 },
454 { "AND", always, never, 0 },
455 { "AND", never, always, 0 },
456 { "AND", never, never, 0 },
457 };
459 int status;
460 size_t i;
462 obj = sdb_store_get_host("a");
464 status = sdb_store_matcher_matches(always, obj, /* filter */ NULL);
465 fail_unless(status == 1,
466 "INTERNAL ERROR: 'always' did not match host");
467 status = sdb_store_matcher_matches(never, obj, /* filter */ NULL);
468 fail_unless(status == 0,
469 "INTERNAL ERROR: 'never' matches host");
471 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
472 sdb_store_matcher_t *m;
474 if (! strcmp(golden_data[i].op, "OR"))
475 m = sdb_store_dis_matcher(golden_data[i].left,
476 golden_data[i].right);
477 else if (! strcmp(golden_data[i].op, "AND"))
478 m = sdb_store_con_matcher(golden_data[i].left,
479 golden_data[i].right);
480 else {
481 fail("INTERNAL ERROR: unexpected operator %s", golden_data[i].op);
482 continue;
483 }
485 #define TO_NAME(v) (((v) == always) ? "always" \
486 : ((v) == never) ? "never" : "<unknown>")
488 status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
489 fail_unless(status == golden_data[i].expected,
490 "%s(%s, %s, NULL) = %d; expected: %d", golden_data[i].op,
491 TO_NAME(golden_data[i].left), TO_NAME(golden_data[i].right),
492 status, golden_data[i].expected);
494 #undef TO_NAME
496 sdb_object_deref(SDB_OBJ(m));
497 }
499 sdb_object_deref(SDB_OBJ(always));
500 sdb_object_deref(SDB_OBJ(never));
502 sdb_object_deref(SDB_OBJ(obj));
503 }
504 END_TEST
506 START_TEST(test_parse_cmp)
507 {
508 sdb_data_t hostname = { SDB_TYPE_STRING, { .string = "hostname" } };
509 sdb_data_t srvname = { SDB_TYPE_STRING, { .string = "srvname" } };
510 sdb_data_t attrname = { SDB_TYPE_STRING, { .string = "attrname" } };
512 sdb_store_matcher_t *check;
514 size_t i;
516 struct {
517 const char *obj_type;
518 const char *attr;
519 const char *op;
520 const sdb_data_t *value;
521 int expected;
522 } golden_data[] = {
523 { "host", NULL, "=", &hostname, MATCHER_NAME },
524 { "host", NULL, "!=", &hostname, MATCHER_NOT },
525 { "host", NULL, "=~", &hostname, MATCHER_NAME },
526 { "host", NULL, "!~", &hostname, MATCHER_NOT },
527 { "host", "attr", "=", &hostname, -1 },
528 { "host", "attr", "!=", &hostname, -1 },
529 { "host", NULL, "&^", &hostname, -1 },
530 { "host", NULL, "<", &hostname, -1 },
531 { "host", NULL, "<=", &hostname, -1 },
532 { "host", NULL, ">=", &hostname, -1 },
533 { "host", NULL, ">", &hostname, -1 },
534 { "host", NULL, "=", NULL, -1 },
535 { "service", NULL, "=", &srvname, MATCHER_NAME },
536 { "service", NULL, "!=", &srvname, MATCHER_NOT },
537 { "service", NULL, "=~", &srvname, MATCHER_NAME },
538 { "service", NULL, "!~", &srvname, MATCHER_NOT },
539 { "service", "attr", "=", &srvname, -1 },
540 { "service", "attr", "!=", &srvname, -1 },
541 { "service", NULL, "&^", &srvname, -1 },
542 { "service", NULL, "<", &srvname, -1 },
543 { "service", NULL, "<=", &srvname, -1 },
544 { "service", NULL, ">=", &srvname, -1 },
545 { "service", NULL, ">", &srvname, -1 },
546 { "service", NULL, "=", NULL, -1 },
547 { "attribute", NULL, "=", &attrname, MATCHER_NAME },
548 { "attribute", NULL, "!=", &attrname, MATCHER_NOT },
549 { "attribute", NULL, "=~", &attrname, MATCHER_NAME },
550 { "attribute", NULL, "!~", &attrname, MATCHER_NOT },
551 { "attribute", NULL, "<", &attrname, -1 },
552 { "attribute", NULL, "<=", &attrname, -1 },
553 { "attribute", NULL, ">=", &attrname, -1 },
554 { "attribute", NULL, ">", &attrname, -1 },
555 { "attribute", NULL, "=", NULL, -1 },
556 { "attribute", "attr", "=", &attrname, MATCHER_ATTR },
557 { "attribute", "attr", "!=", &attrname, MATCHER_NOT },
558 { "attribute", "attr", "=~", &attrname, MATCHER_ATTR },
559 { "attribute", "attr", "!~", &attrname, MATCHER_NOT },
560 { "attribute", "attr", "&^", &attrname, -1 },
561 { "attribute", "attr", "<", NULL, -1 },
562 { "attribute", "attr", "<", &attrname, MATCHER_LT },
563 { "attribute", "attr", "<=", &attrname, MATCHER_LE },
564 /* { "attribute", "attr", "=", &attrname, MATCHER_EQ }, */
565 { "attribute", "attr", ">=", &attrname, MATCHER_GE },
566 { "attribute", "attr", ">", &attrname, MATCHER_GT },
567 { "attribute", "attr", "IS", NULL, MATCHER_ISNULL },
568 { "attribute", "attr", "IS", &attrname, -1 },
569 { "foo", NULL, "=", &attrname, -1 },
570 { "foo", "attr", "=", &attrname, -1 },
571 };
573 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
574 sdb_store_expr_t *expr;
575 char buf[1024];
577 if (sdb_data_format(golden_data[i].value,
578 buf, sizeof(buf), SDB_UNQUOTED) < 0)
579 snprintf(buf, sizeof(buf), "ERR");
581 expr = sdb_store_expr_constvalue(golden_data[i].value);
582 fail_unless(expr != NULL || golden_data[i].value == NULL,
583 "sdb_store_expr_constvalue(%s) = NULL; expected: <expr>",
584 buf);
586 check = sdb_store_matcher_parse_cmp(golden_data[i].obj_type,
587 golden_data[i].attr, golden_data[i].op, expr);
588 sdb_object_deref(SDB_OBJ(expr));
590 if (golden_data[i].expected == -1) {
591 fail_unless(check == NULL,
592 "sdb_store_matcher_parse_cmp(%s, %s, %s, expr{%s}) = %p; "
593 "expected: NULL", golden_data[i].obj_type,
594 golden_data[i].attr, golden_data[i].op, buf, check);
595 continue;
596 }
598 fail_unless(check != NULL,
599 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) = %p; "
600 "expected: NULL", golden_data[i].obj_type,
601 golden_data[i].attr, golden_data[i].op, buf, check);
602 fail_unless(M(check)->type == golden_data[i].expected,
603 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) returned matcher "
604 "of type %d; expected: %d", golden_data[i].obj_type,
605 golden_data[i].attr, golden_data[i].op, buf,
606 M(check)->type, golden_data[i].expected);
608 sdb_object_deref(SDB_OBJ(check));
609 }
610 }
611 END_TEST
613 static int
614 scan_cb(sdb_store_obj_t *obj, void *user_data)
615 {
616 int *i = user_data;
618 fail_unless(obj != NULL,
619 "sdb_store_scan callback received NULL obj; expected: "
620 "<store base obj>");
621 fail_unless(i != NULL,
622 "sdb_store_scan callback received NULL user_data; "
623 "expected: <pointer to data>");
625 ++(*i);
626 return 0;
627 } /* scan_cb */
629 START_TEST(test_scan)
630 {
631 #define PTR_RE "0x[0-9a-f]+"
632 struct {
633 const char *query;
634 const char *filter;
635 int expected;
636 const char *tostring_re;
637 } golden_data[] = {
638 { "host = 'a'", NULL, 1,
639 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
640 { "host = 'a'", "host = 'x'", 0, /* filter never matches */
641 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
642 { "host = 'a'",
643 "NOT attribute.x = ''", 1, /* filter always matches */
644 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
645 { "host =~ 'a|b'", NULL, 2,
646 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
647 { "host =~ 'host'", NULL, 0,
648 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
649 { "host =~ '.'", NULL, 3,
650 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
651 { "service = 's1'", NULL, 2,
652 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
653 { "service = 's1'", "host = 'x'", 0, /* filter never matches */
654 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
655 { "service = 's1'",
656 "NOT attribute.x = ''", 2, /* filter always matches */
657 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
658 { "service =~ 's'", NULL, 2,
659 "OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}" },
660 { "service !~ 's'", NULL, 1,
661 "\\(NOT, OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}\\)" },
662 { "attribute = 'k1'", NULL, 1,
663 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
664 { "attribute = 'k1'", "host = 'x'", 0, /* filter never matches */
665 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
666 { "attribute = 'k1'",
667 "NOT attribute.x = ''", 1, /* filter always matches */
668 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
669 { "attribute = 'x'", NULL, 0,
670 "OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\}" },
671 { "attribute.k1 = 'v1'", NULL, 1,
672 "ATTR\\[k1\\]\\{ VALUE\\{ 'v1', \\(nil\\) \\} \\}" },
673 { "attribute.k1 IS NULL", NULL, 2,
674 "\\(IS NULL, ATTR\\[k1\\]\\)" },
675 { "attribute.x1 IS NULL", NULL, 3,
676 "\\(IS NULL, ATTR\\[x1\\]\\)" },
677 { "attribute.k1 IS NOT NULL", NULL, 1,
678 "\\(NOT, \\(IS NULL, ATTR\\[k1\\]\\)\\)" },
679 { "attribute.x1 IS NOT NULL", NULL, 0,
680 "\\(NOT, \\(IS NULL, ATTR\\[x1\\]\\)\\)" },
681 { "attribute.k2 < 123", NULL, 0,
682 "ATTR\\[k2\\]\\{ < 123 \\}" },
683 { "attribute.k2 <= 123", NULL, 1,
684 "ATTR\\[k2\\]\\{ <= 123 \\}" },
685 { "attribute.k2 >= 123", NULL, 1,
686 "ATTR\\[k2\\]\\{ >= 123 \\}" },
687 { "attribute.k2 > 123", NULL, 0,
688 "ATTR\\[k2\\]\\{ > 123 \\}" },
689 { "attribute.k2 = 123", NULL, 1,
690 "ATTR\\[k2\\]\\{ = 123 \\}" },
691 { "attribute.k2 != 123", NULL, 2,
692 "\\(NOT, ATTR\\[k2\\]\\{ = 123 \\}\\)" },
693 { "attribute.k1 != 'v1'", NULL, 2,
694 "\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v1', \\(nil\\) \\} \\}\\)" },
695 { "attribute.k1 != 'v2'", NULL, 3,
696 "\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v2', \\(nil\\) \\} \\}\\)" },
697 { "attribute != 'x' "
698 "AND attribute.y !~ 'x'", NULL, 3,
699 "\\(AND, "
700 "\\(NOT, OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\} \\}\\), "
701 "\\(NOT, ATTR\\[y\\]\\{ VALUE\\{ NULL, "PTR_RE" \\} \\}\\)\\)" },
702 };
704 int check, n;
705 size_t i;
707 n = 0;
708 check = sdb_store_scan(/* matcher */ NULL, /* filter */ NULL,
709 scan_cb, &n);
710 fail_unless(check == 0,
711 "sdb_store_scan() = %d; expected: 0", check);
712 fail_unless(n == 3,
713 "sdb_store_scan called callback %d times; expected: 3", (int)n);
715 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
716 sdb_store_matcher_t *m, *filter = NULL;
717 char buf[4096];
719 m = sdb_fe_parse_matcher(golden_data[i].query, -1);
720 fail_unless(m != NULL,
721 "sdb_fe_parse_matcher(%s, -1) = NULL; expected: <matcher>",
722 golden_data[i].query);
724 if (golden_data[i].filter) {
725 filter = sdb_fe_parse_matcher(golden_data[i].filter, -1);
726 fail_unless(filter != NULL,
727 "sdb_fe_parse_matcher(%s, -1) = NULL; "
728 "expected: <matcher>", golden_data[i].filter);
729 }
731 fail_unless(sdb_regmatches(golden_data[i].tostring_re,
732 sdb_store_matcher_tostring(m, buf, sizeof(buf))) == 0,
733 "sdb_fe_parse_matcher(%s, -1) = %s; expected: %s",
734 golden_data[i].query,
735 sdb_store_matcher_tostring(m, buf, sizeof(buf)),
736 golden_data[i].tostring_re);
738 n = 0;
739 sdb_store_scan(m, filter, scan_cb, &n);
740 fail_unless(n == golden_data[i].expected,
741 "sdb_store_scan(matcher{%s}, filter{%s}) found %d hosts; "
742 "expected: %d", golden_data[i].query, golden_data[i].filter,
743 n, golden_data[i].expected);
744 sdb_object_deref(SDB_OBJ(filter));
745 sdb_object_deref(SDB_OBJ(m));
746 }
747 }
748 END_TEST
750 Suite *
751 core_store_lookup_suite(void)
752 {
753 Suite *s = suite_create("core::store_lookup");
754 TCase *tc;
756 tc = tcase_create("core");
757 tcase_add_checked_fixture(tc, populate, sdb_store_clear);
758 tcase_add_test(tc, test_store_match_name);
759 tcase_add_test(tc, test_store_match_attr);
760 tcase_add_test(tc, test_attr_cond);
761 tcase_add_test(tc, test_obj_cond);
762 tcase_add_test(tc, test_store_match_op);
763 tcase_add_test(tc, test_parse_cmp);
764 tcase_add_test(tc, test_scan);
765 suite_add_tcase(s, tc);
767 return s;
768 } /* core_store_lookup_suite */
770 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */