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 };
59 size_t i;
61 for (i = 0; i < SDB_STATIC_ARRAY_LEN(hosts); ++i) {
62 int status = sdb_store_host(hosts[i], 1);
63 fail_unless(status == 0,
64 "sdb_store_host(%s, 1) = %d; expected: 0",
65 hosts[i], status);
66 }
68 for (i = 0; i < SDB_STATIC_ARRAY_LEN(services); ++i) {
69 int status = sdb_store_service(services[i].host,
70 services[i].service, 1);
71 fail_unless(status == 0,
72 "sdb_store_service(%s, %s, 1) = %d; expected: 0",
73 services[i].host, services[i].service, status);
74 }
76 for (i = 0; i < SDB_STATIC_ARRAY_LEN(attrs); ++i) {
77 int status = sdb_store_attribute(attrs[i].host,
78 attrs[i].name, &attrs[i].value, 1);
79 fail_unless(status == 0,
80 "sdb_store_attribute(%s, %s, <val>, 1) = %d; expected: 0",
81 attrs[i].host, attrs[i].name, status);
82 }
83 } /* populate */
85 START_TEST(test_store_match)
86 {
87 sdb_store_base_t *obj;
89 struct {
90 const char *hostname;
91 const char *hostname_re;
93 const char *attr_name;
94 const char *attr_name_re;
95 const char *attr_value;
96 const char *attr_value_re;
98 int expected;
99 } golden_data[] = {
100 {
101 /* host */ NULL, NULL,
102 /* attr */ NULL, NULL, NULL, NULL, 1
103 },
104 {
105 /* host */ "a", NULL,
106 /* attr */ NULL, NULL, NULL, NULL, 1
107 },
108 {
109 /* host */ "b", NULL,
110 /* attr */ NULL, NULL, NULL, NULL, 0
111 },
112 {
113 /* host */ NULL, "^a$",
114 /* attr */ NULL, NULL, NULL, NULL, 1
115 },
116 {
117 /* host */ NULL, "^b$",
118 /* attr */ NULL, NULL, NULL, NULL, 0
119 },
120 {
121 /* host */ "a", "^a$",
122 /* attr */ NULL, NULL, NULL, NULL, 1
123 },
124 {
125 /* host */ "a", "^b$",
126 /* attr */ NULL, NULL, NULL, NULL, 0
127 },
128 {
129 /* host */ "b", "^a$",
130 /* attr */ NULL, NULL, NULL, NULL, 0
131 },
132 {
133 /* host */ "a", "^a$",
134 /* attr */ "k1", NULL, NULL, NULL, 1
135 },
136 {
137 /* host */ "a", "^a$",
138 /* attr */ NULL, "^k", NULL, NULL, 1
139 },
140 {
141 /* host */ "a", "^a$",
142 /* attr */ NULL, NULL, "v1", NULL, 1
143 },
144 {
145 /* host */ "a", "^a$",
146 /* attr */ NULL, NULL, NULL, "^v1$", 1
147 },
148 {
149 /* host */ "a", "^a$",
150 /* attr */ "k1", "1", "v1", "1", 1
151 },
152 };
154 size_t i;
156 obj = sdb_store_get_host("a");
157 fail_unless(obj != NULL,
158 "sdb_store_get_host(a) = NULL; expected: <host>");
160 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
161 sdb_store_matcher_t *h, *a, *n;
162 int status;
164 a = sdb_store_attr_matcher(golden_data[i].attr_name,
165 golden_data[i].attr_name_re, golden_data[i].attr_value,
166 golden_data[i].attr_value_re);
167 fail_unless(a != NULL,
168 "sdb_store_attr_matcher() = NULL; expected: <matcher>");
170 h = sdb_store_host_matcher(golden_data[i].hostname,
171 golden_data[i].hostname_re, a);
172 fail_unless(h != NULL,
173 "sdb_store_host_matcher() = NULL: expected: <matcher>");
174 /* pass ownership to the host matcher */
175 sdb_object_deref(SDB_OBJ(a));
177 status = sdb_store_matcher_matches(h, obj);
178 fail_unless(status == golden_data[i].expected,
179 "sdb_store_matcher_matches({{%s, %s},"
180 "{%s, %s, %s, %s}}, <host a>) = %d; expected: %d",
181 golden_data[i].hostname, golden_data[i].hostname_re,
182 golden_data[i].attr_name, golden_data[i].attr_name_re,
183 golden_data[i].attr_value, golden_data[i].attr_value_re,
184 status, golden_data[i].expected);
186 n = sdb_store_inv_matcher(h);
187 fail_unless(n != NULL,
188 "sdb_store_inv_matcher() = NULL; expected: <matcher>");
189 sdb_object_deref(SDB_OBJ(h));
191 /* now match the inverted set of objects */
192 status = sdb_store_matcher_matches(n, obj);
193 fail_unless(status == !golden_data[i].expected,
194 "sdb_store_matcher_matches(NOT{{%s, %s},"
195 "{%s, %s, %s, %s}}, <host a>) = %d; expected: %d",
196 golden_data[i].hostname, golden_data[i].hostname_re,
197 golden_data[i].attr_name, golden_data[i].attr_name_re,
198 golden_data[i].attr_value, golden_data[i].attr_value_re,
199 status, !golden_data[i].expected);
201 sdb_object_deref(SDB_OBJ(n));
202 }
204 sdb_object_deref(SDB_OBJ(obj));
205 }
206 END_TEST
208 START_TEST(test_store_match_name)
209 {
210 sdb_store_base_t *obj;
212 struct {
213 int type;
214 const char *name;
215 _Bool re;
217 int expected;
218 } golden_data[] = {
219 { SDB_HOST, NULL, 0, 1 },
220 { SDB_HOST, NULL, 1, 1 },
221 { SDB_HOST, "a", 0, 1 },
222 { SDB_HOST, "a", 1, 1 },
223 { SDB_HOST, "b", 0, 0 },
224 { SDB_HOST, "b", 1, 0 },
225 { SDB_HOST, "^a$", 1, 1 },
226 { SDB_HOST, "^b$", 1, 0 },
227 { SDB_HOST, "^a$", 0, 0 },
228 { SDB_HOST, "^b$", 0, 0 },
229 { SDB_SERVICE, NULL, 0, 1 },
230 { SDB_SERVICE, NULL, 1, 1 },
231 { SDB_SERVICE, "s1", 0, 1 },
232 { SDB_SERVICE, "s2", 0, 1 },
233 { SDB_SERVICE, "s3", 0, 0 },
234 { SDB_SERVICE, "s4", 0, 0 },
235 { SDB_SERVICE, "^s1$", 1, 1 },
236 { SDB_SERVICE, "^s1$", 0, 0 },
237 { SDB_SERVICE, "x1", 0, 0 },
238 { SDB_SERVICE, "x1", 1, 0 },
239 { SDB_SERVICE, "x", 1, 0 },
240 { SDB_ATTRIBUTE, NULL, 0, 1 },
241 { SDB_ATTRIBUTE, NULL, 1, 1 },
242 { SDB_ATTRIBUTE, "k1", 0, 1 },
243 { SDB_ATTRIBUTE, "k2", 0, 0 },
244 { SDB_ATTRIBUTE, "k3", 0, 0 },
245 { SDB_ATTRIBUTE, "k", 1, 1 },
246 { SDB_ATTRIBUTE, "1", 1, 1 },
247 { SDB_ATTRIBUTE, "2", 1, 0 },
248 };
250 size_t i;
252 obj = sdb_store_get_host("a");
253 fail_unless(obj != NULL,
254 "sdb_store_get_host(a) = NULL; expected: <host>");
256 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
257 sdb_store_matcher_t *m, *n;
258 char buf[1024];
259 int status;
261 m = sdb_store_name_matcher(golden_data[i].type,
262 golden_data[i].name, golden_data[i].re);
263 fail_unless(m != NULL,
264 "sdb_store_service_matcher(%d, %s, %d) = NULL; expected: <matcher>",
265 golden_data[i].type, golden_data[i].name, golden_data[i].re);
267 status = sdb_store_matcher_matches(m, obj);
268 fail_unless(status == golden_data[i].expected,
269 "sdb_store_matcher_matches(%s, <host a>) = %d; expected: %d",
270 sdb_store_matcher_tostring(m, buf, sizeof(buf)),
271 status, golden_data[i].expected);
273 n = sdb_store_inv_matcher(m);
274 fail_unless(n != NULL,
275 "sdb_store_inv_matcher() = NULL; expected: <matcher>");
276 sdb_object_deref(SDB_OBJ(m));
278 /* now match the inverted set of objects */
279 status = sdb_store_matcher_matches(n, obj);
280 fail_unless(status == !golden_data[i].expected,
281 "sdb_store_matcher_matches(%s, <host a>) = %d; expected: %d",
282 sdb_store_matcher_tostring(n, buf, sizeof(buf)),
283 status, golden_data[i].expected);
285 sdb_object_deref(SDB_OBJ(n));
286 }
288 sdb_object_deref(SDB_OBJ(obj));
289 }
290 END_TEST
292 START_TEST(test_store_match_op)
293 {
294 sdb_store_base_t *obj;
296 sdb_store_matcher_t *always = sdb_store_host_matcher(NULL, NULL, NULL);
297 sdb_store_matcher_t *never = sdb_store_host_matcher("a", "b", NULL);
299 struct {
300 const char *op;
301 sdb_store_matcher_t *left;
302 sdb_store_matcher_t *right;
303 int expected;
304 } golden_data[] = {
305 { "OR", always, always, 1 },
306 { "OR", always, never, 1 },
307 { "OR", never, always, 1 },
308 { "OR", never, never, 0 },
309 { "AND", always, always, 1 },
310 { "AND", always, never, 0 },
311 { "AND", never, always, 0 },
312 { "AND", never, never, 0 },
313 };
315 int status;
316 size_t i;
318 obj = sdb_store_get_host("a");
320 status = sdb_store_matcher_matches(always, obj);
321 fail_unless(status == 1,
322 "INTERNAL ERROR: 'always' did not match host");
323 status = sdb_store_matcher_matches(never, obj);
324 fail_unless(status == 0,
325 "INTERNAL ERROR: 'never' matches host");
327 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
328 sdb_store_matcher_t *m;
330 if (! strcmp(golden_data[i].op, "OR"))
331 m = sdb_store_dis_matcher(golden_data[i].left,
332 golden_data[i].right);
333 else if (! strcmp(golden_data[i].op, "AND"))
334 m = sdb_store_con_matcher(golden_data[i].left,
335 golden_data[i].right);
336 else {
337 fail("INTERNAL ERROR: unexpected operator %s", golden_data[i].op);
338 continue;
339 }
341 #define TO_NAME(v) (((v) == always) ? "always" \
342 : ((v) == never) ? "never" : "<unknown>")
344 status = sdb_store_matcher_matches(m, obj);
345 fail_unless(status == golden_data[i].expected,
346 "%s(%s, %s) = %d; expected: %d", golden_data[i].op,
347 TO_NAME(golden_data[i].left), TO_NAME(golden_data[i].right),
348 status, golden_data[i].expected);
350 #undef TO_NAME
352 sdb_object_deref(SDB_OBJ(m));
353 }
355 sdb_object_deref(SDB_OBJ(always));
356 sdb_object_deref(SDB_OBJ(never));
358 sdb_object_deref(SDB_OBJ(obj));
359 }
360 END_TEST
362 START_TEST(test_parse_cmp)
363 {
364 sdb_store_matcher_t *check;
366 size_t i;
368 struct {
369 const char *obj_type;
370 const char *attr;
371 const char *op;
372 const char *value;
373 int expected;
374 } golden_data[] = {
375 { "host", "name", "=", "hostname", MATCHER_NAME },
376 { "host", "name", "!=", "hostname", MATCHER_NOT },
377 { "host", "name", "=~", "hostname", MATCHER_NAME },
378 { "host", "name", "!~", "hostname", MATCHER_NOT },
379 { "host", "attr", "=", "hostname", -1 },
380 { "host", "attr", "!=", "hostname", -1 },
381 { "host", "name", "&^", "hostname", -1 },
382 { "service", "name", "=", "srvname", MATCHER_NAME },
383 { "service", "name", "!=", "srvname", MATCHER_NOT },
384 { "service", "name", "=~", "srvname", MATCHER_NAME },
385 { "service", "name", "!~", "srvname", MATCHER_NOT },
386 { "service", "attr", "=", "srvname", -1 },
387 { "service", "attr", "!=", "srvname", -1 },
388 { "service", "name", "&^", "srvname", -1 },
389 { "attribute", "name", "=", "attrname", MATCHER_NAME },
390 { "attribute", "name", "!=", "attrname", MATCHER_NOT },
391 { "attribute", "name", "=~", "attrname", MATCHER_NAME },
392 { "attribute", "name", "!~", "attrname", MATCHER_NOT },
393 { "attribute", "attr", "=", "attrname", MATCHER_HOST },
394 { "attribute", "attr", "!=", "attrname", MATCHER_NOT },
395 { "attribute", "attr", "=~", "attrname", MATCHER_HOST },
396 { "attribute", "attr", "!~", "attrname", MATCHER_NOT },
397 { "attribute", "attr", "&^", "attrname", -1 },
398 };
400 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
401 check = sdb_store_matcher_parse_cmp(golden_data[i].obj_type,
402 golden_data[i].attr, golden_data[i].op, golden_data[i].value);
404 if (golden_data[i].expected == -1) {
405 fail_unless(check == NULL,
406 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) = %p; "
407 "expected: NULL", golden_data[i].obj_type,
408 golden_data[i].attr, golden_data[i].op,
409 golden_data[i].value, check);
410 continue;
411 }
413 fail_unless(check != NULL,
414 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) = %p; "
415 "expected: NULL", golden_data[i].obj_type,
416 golden_data[i].attr, golden_data[i].op,
417 golden_data[i].value, check);
418 fail_unless(M(check)->type == golden_data[i].expected,
419 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) returned matcher "
420 "of type %d; expected: %d", golden_data[i].obj_type,
421 golden_data[i].attr, golden_data[i].op, golden_data[i].value,
422 M(check)->type, golden_data[i].expected);
424 sdb_object_deref(SDB_OBJ(check));
425 }
426 }
427 END_TEST
429 static int
430 lookup_cb(sdb_store_base_t *obj, void *user_data)
431 {
432 int *i = user_data;
434 fail_unless(obj != NULL,
435 "sdb_store_lookup callback received NULL obj; expected: "
436 "<store base obj>");
437 fail_unless(i != NULL,
438 "sdb_store_lookup callback received NULL user_data; "
439 "expected: <pointer to data>");
441 ++(*i);
442 return 0;
443 } /* lookup_cb */
445 START_TEST(test_lookup)
446 {
447 #define PTR_RE "0x[0-9a-f]+"
448 struct {
449 const char *query;
450 int expected;
451 const char *tostring_re;
452 } golden_data[] = {
453 { "host.name = 'a'", 1,
454 "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
455 { "host.name =~ 'a|b'", 2,
456 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
457 { "host.name =~ 'host'", 0,
458 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
459 { "host.name =~ '.'", 3,
460 "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
461 { "service.name = 's1'", 2,
462 "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
463 { "service.name =~ 's'", 2,
464 "OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}" },
465 { "service.name !~ 's'", 1,
466 "\\(NOT, OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}\\)" },
467 { "attribute.name = 'k1'", 1,
468 "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
469 { "attribute.name = 'x'", 0,
470 "OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\}" },
471 { "attribute.k1 = 'v1'", 1,
472 "HOST\\{ NAME\\{ NULL, \\(nil\\) \\}, ATTR\\{ "
473 "NAME\\{ 'k1', \\(nil\\) }, VALUE\\{ 'v1', \\(nil\\) \\} "
474 "\\} \\}" },
475 { "attribute.k1 != 'v1'", 2,
476 "\\(NOT, HOST\\{ NAME\\{ NULL, \\(nil\\) \\}, ATTR\\{ "
477 "NAME\\{ 'k1', \\(nil\\) }, VALUE\\{ 'v1', \\(nil\\) \\} "
478 "\\} \\})" },
479 { "attribute.k1 != 'v2'", 3,
480 "\\(NOT, HOST\\{ NAME\\{ NULL, \\(nil\\) \\}, ATTR\\{ "
481 "NAME\\{ 'k1', \\(nil\\) }, VALUE\\{ 'v2', \\(nil\\) \\} "
482 "\\} \\})" },
483 { "attribute.name != 'x' "
484 "AND attribute.y !~ 'x'", 3,
485 "\\(AND, \\(NOT, OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\} "
486 "\\}\\), \\(NOT, HOST\\{ NAME\\{ NULL, \\(nil\\) \\}, ATTR\\{ "
487 "NAME\\{ 'y', \\(nil\\) }, VALUE\\{ NULL, "PTR_RE" \\} "
488 "\\} \\}\\)\\)" },
489 };
491 int check, n;
492 size_t i;
494 n = 0;
495 check = sdb_store_lookup(NULL, lookup_cb, &n);
496 fail_unless(check == 0,
497 "sdb_store_lookup() = %d; expected: 0", check);
498 fail_unless(n == 3,
499 "sdb_store_lookup called callback %d times; expected: 3", (int)n);
501 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
502 sdb_store_matcher_t *m;
503 char buf[4096];
505 m = sdb_fe_parse_matcher(golden_data[i].query, -1);
506 fail_unless(m != NULL,
507 "sdb_fe_parse_matcher(%s, -1) = NULL; expected: <matcher>",
508 golden_data[i].query);
509 fail_unless(sdb_regmatches(golden_data[i].tostring_re,
510 sdb_store_matcher_tostring(m, buf, sizeof(buf))) == 0,
511 "sdb_fe_parse_matcher(%s, -1) = %s; expected: %s",
512 golden_data[i].query,
513 sdb_store_matcher_tostring(m, buf, sizeof(buf)),
514 golden_data[i].tostring_re);
516 n = 0;
517 sdb_store_lookup(m, lookup_cb, &n);
518 fail_unless(n == golden_data[i].expected,
519 "sdb_store_lookup(matcher{%s}) found %d hosts; expected: %d",
520 golden_data[i].query, n, golden_data[i].expected);
521 sdb_object_deref(SDB_OBJ(m));
522 }
523 }
524 END_TEST
526 Suite *
527 core_store_lookup_suite(void)
528 {
529 Suite *s = suite_create("core::store_lookup");
530 TCase *tc;
532 tc = tcase_create("core");
533 tcase_add_checked_fixture(tc, populate, sdb_store_clear);
534 tcase_add_test(tc, test_store_match);
535 tcase_add_test(tc, test_store_match_name);
536 tcase_add_test(tc, test_store_match_op);
537 tcase_add_test(tc, test_parse_cmp);
538 tcase_add_test(tc, test_lookup);
539 suite_add_tcase(s, tc);
541 return s;
542 } /* core_store_lookup_suite */
544 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */