82688833f2f1e1c3fa76cbc12a72bcac12f89d04
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 START_TEST(test_parse_field_cmp)
614 {
615 sdb_data_t datetime = { SDB_TYPE_DATETIME, { .datetime = 1 } };
616 sdb_data_t string = { SDB_TYPE_STRING, { .string = "s" } };
618 struct {
619 const char *field;
620 const char *op;
621 const sdb_data_t *value;
622 int expected;
623 } golden_data[] = {
624 { "last_update", "<", &datetime, MATCHER_LT },
625 { "last_update", "<=", &datetime, MATCHER_LE },
626 { "last_update", "=", &datetime, MATCHER_EQ },
627 { "last_update", ">=", &datetime, MATCHER_GE },
628 { "last_update", ">", &datetime, MATCHER_GT },
629 { "last_update", "!=", &datetime, MATCHER_NOT },
630 { "age", "<", &datetime, MATCHER_LT },
631 { "age", "<=", &datetime, MATCHER_LE },
632 { "age", "=", &datetime, MATCHER_EQ },
633 { "age", ">=", &datetime, MATCHER_GE },
634 { "age", ">", &datetime, MATCHER_GT },
635 { "age", "!=", &datetime, MATCHER_NOT },
636 { "interval", "<", &datetime, MATCHER_LT },
637 { "interval", "<=", &datetime, MATCHER_LE },
638 { "interval", "=", &datetime, MATCHER_EQ },
639 { "interval", ">=", &datetime, MATCHER_GE },
640 { "interval", ">", &datetime, MATCHER_GT },
641 { "interval", "!=", &datetime, MATCHER_NOT },
642 { "backend", "=", &string, MATCHER_EQ },
643 { "backend", "!=", &string, MATCHER_NOT },
644 /* the behavior for other operators on :backend
645 * is currently unspecified */
646 { "last_update", "=", NULL, -1 },
647 { "last_update", "IS", NULL, -1 },
648 { "age", "=", NULL, -1 },
649 { "interval", "=", NULL, -1 },
650 { "backend", "=", NULL, -1 },
651 { "backend", "=~", &string, -1 },
652 };
654 size_t i;
656 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
657 sdb_store_matcher_t *check;
658 sdb_store_expr_t *expr;
659 char buf[1024];
661 if (sdb_data_format(golden_data[i].value,
662 buf, sizeof(buf), SDB_UNQUOTED) < 0)
663 snprintf(buf, sizeof(buf), "ERR");
665 expr = sdb_store_expr_constvalue(golden_data[i].value);
666 fail_unless(expr != NULL || golden_data[i].value == NULL,
667 "sdb_store_expr_constvalue(%s) = NULL; expected: <expr>",
668 buf);
670 check = sdb_store_matcher_parse_field_cmp(golden_data[i].field,
671 golden_data[i].op, expr);
672 sdb_object_deref(SDB_OBJ(expr));
674 if (golden_data[i].expected == -1) {
675 fail_unless(check == NULL,
676 "sdb_store_matcher_parse_field_cmp(%s, %s, expr{%s}) = %p; "
677 "expected: NULL", golden_data[i].field,
678 golden_data[i].op, buf, check);
679 continue;
680 }
682 fail_unless(check != NULL,
683 "sdb_store_matcher_parse_field_cmp(%s, %s, %s) = %p; "
684 "expected: NULL", golden_data[i].field,
685 golden_data[i].op, buf, check);
686 fail_unless(M(check)->type == golden_data[i].expected,
687 "sdb_store_matcher_parse_field_cmp(%s, %s, %s) returned "
688 "matcher of type %d; expected: %d", golden_data[i].field,
689 golden_data[i].op, buf, M(check)->type,
690 golden_data[i].expected);
692 sdb_object_deref(SDB_OBJ(check));
693 }
694 }
695 END_TEST
697 static int
698 scan_cb(sdb_store_obj_t *obj, void *user_data)
699 {
700 int *i = user_data;
702 fail_unless(obj != NULL,
703 "sdb_store_scan callback received NULL obj; expected: "
704 "<store base obj>");
705 fail_unless(i != NULL,
706 "sdb_store_scan callback received NULL user_data; "
707 "expected: <pointer to data>");
709 ++(*i);
710 return 0;
711 } /* scan_cb */
713 START_TEST(test_scan)
714 {
715 #define PTR_RE "0x[0-9a-f]+"
716 struct {
717 const char *query;
718 const char *filter;
719 int expected;
720 const char *tostring_re;
721 } golden_data[] = {
722 { "host = 'a'", NULL, 1,
723 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
724 { "host = 'a'", "host = 'x'", 0, /* filter never matches */
725 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
726 { "host = 'a'",
727 "NOT attribute.x = ''", 1, /* filter always matches */
728 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
729 { "host =~ 'a|b'", NULL, 2,
730 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
731 { "host =~ 'host'", NULL, 0,
732 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
733 { "host =~ '.'", NULL, 3,
734 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
735 { "service = 's1'", NULL, 2,
736 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
737 { "service = 's1'", "host = 'x'", 0, /* filter never matches */
738 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
739 { "service = 's1'",
740 "NOT attribute.x = ''", 2, /* filter always matches */
741 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
742 { "service =~ 's'", NULL, 2,
743 "OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}" },
744 { "service !~ 's'", NULL, 1,
745 "\\(NOT, OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}\\)" },
746 { "attribute = 'k1'", NULL, 1,
747 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
748 { "attribute = 'k1'", "host = 'x'", 0, /* filter never matches */
749 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
750 { "attribute = 'k1'",
751 "NOT attribute.x = ''", 1, /* filter always matches */
752 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
753 { "attribute = 'x'", NULL, 0,
754 "OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\}" },
755 { "attribute.k1 = 'v1'", NULL, 1,
756 "ATTR\\[k1\\]\\{ VALUE\\{ 'v1', \\(nil\\) \\} \\}" },
757 { "attribute.k1 IS NULL", NULL, 2,
758 "\\(IS NULL, ATTR\\[k1\\]\\)" },
759 { "attribute.x1 IS NULL", NULL, 3,
760 "\\(IS NULL, ATTR\\[x1\\]\\)" },
761 { "attribute.k1 IS NOT NULL", NULL, 1,
762 "\\(NOT, \\(IS NULL, ATTR\\[k1\\]\\)\\)" },
763 { "attribute.x1 IS NOT NULL", NULL, 0,
764 "\\(NOT, \\(IS NULL, ATTR\\[x1\\]\\)\\)" },
765 { "attribute.k2 < 123", NULL, 0,
766 "ATTR\\[k2\\]\\{ < 123 \\}" },
767 { "attribute.k2 <= 123", NULL, 1,
768 "ATTR\\[k2\\]\\{ <= 123 \\}" },
769 { "attribute.k2 >= 123", NULL, 1,
770 "ATTR\\[k2\\]\\{ >= 123 \\}" },
771 { "attribute.k2 > 123", NULL, 0,
772 "ATTR\\[k2\\]\\{ > 123 \\}" },
773 { "attribute.k2 = 123", NULL, 1,
774 "ATTR\\[k2\\]\\{ = 123 \\}" },
775 { "attribute.k2 != 123", NULL, 2,
776 "\\(NOT, ATTR\\[k2\\]\\{ = 123 \\}\\)" },
777 { "attribute.k1 != 'v1'", NULL, 2,
778 "\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v1', \\(nil\\) \\} \\}\\)" },
779 { "attribute.k1 != 'v2'", NULL, 3,
780 "\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v2', \\(nil\\) \\} \\}\\)" },
781 { "attribute != 'x' "
782 "AND attribute.y !~ 'x'", NULL, 3,
783 "\\(AND, "
784 "\\(NOT, OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\} \\}\\), "
785 "\\(NOT, ATTR\\[y\\]\\{ VALUE\\{ NULL, "PTR_RE" \\} \\}\\)\\)" },
786 };
788 int check, n;
789 size_t i;
791 n = 0;
792 check = sdb_store_scan(/* matcher */ NULL, /* filter */ NULL,
793 scan_cb, &n);
794 fail_unless(check == 0,
795 "sdb_store_scan() = %d; expected: 0", check);
796 fail_unless(n == 3,
797 "sdb_store_scan called callback %d times; expected: 3", (int)n);
799 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
800 sdb_store_matcher_t *m, *filter = NULL;
801 char buf[4096];
803 m = sdb_fe_parse_matcher(golden_data[i].query, -1);
804 fail_unless(m != NULL,
805 "sdb_fe_parse_matcher(%s, -1) = NULL; expected: <matcher>",
806 golden_data[i].query);
808 if (golden_data[i].filter) {
809 filter = sdb_fe_parse_matcher(golden_data[i].filter, -1);
810 fail_unless(filter != NULL,
811 "sdb_fe_parse_matcher(%s, -1) = NULL; "
812 "expected: <matcher>", golden_data[i].filter);
813 }
815 fail_unless(sdb_regmatches(golden_data[i].tostring_re,
816 sdb_store_matcher_tostring(m, buf, sizeof(buf))) == 0,
817 "sdb_fe_parse_matcher(%s, -1) = %s; expected: %s",
818 golden_data[i].query,
819 sdb_store_matcher_tostring(m, buf, sizeof(buf)),
820 golden_data[i].tostring_re);
822 n = 0;
823 sdb_store_scan(m, filter, scan_cb, &n);
824 fail_unless(n == golden_data[i].expected,
825 "sdb_store_scan(matcher{%s}, filter{%s}) found %d hosts; "
826 "expected: %d", golden_data[i].query, golden_data[i].filter,
827 n, golden_data[i].expected);
828 sdb_object_deref(SDB_OBJ(filter));
829 sdb_object_deref(SDB_OBJ(m));
830 }
831 }
832 END_TEST
834 Suite *
835 core_store_lookup_suite(void)
836 {
837 Suite *s = suite_create("core::store_lookup");
838 TCase *tc;
840 tc = tcase_create("core");
841 tcase_add_checked_fixture(tc, populate, sdb_store_clear);
842 tcase_add_test(tc, test_store_match_name);
843 tcase_add_test(tc, test_store_match_attr);
844 tcase_add_test(tc, test_attr_cond);
845 tcase_add_test(tc, test_obj_cond);
846 tcase_add_test(tc, test_store_match_op);
847 tcase_add_test(tc, test_parse_cmp);
848 tcase_add_test(tc, test_parse_field_cmp);
849 tcase_add_test(tc, test_scan);
850 suite_add_tcase(s, tc);
852 return s;
853 } /* core_store_lookup_suite */
855 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */