1 /*
2 * SysDB - t/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 *service_name;
94 const char *service_name_re;
96 const char *attr_name;
97 const char *attr_name_re;
98 const char *attr_value;
99 const char *attr_value_re;
101 int expected;
102 } golden_data[] = {
103 {
104 /* host */ NULL, NULL,
105 /* svc */ NULL, NULL,
106 /* attr */ NULL, NULL, NULL, NULL, 1
107 },
108 {
109 /* host */ "a", NULL,
110 /* svc */ NULL, NULL,
111 /* attr */ NULL, NULL, NULL, NULL, 1
112 },
113 {
114 /* host */ "b", NULL,
115 /* svc */ NULL, NULL,
116 /* attr */ NULL, NULL, NULL, NULL, 0
117 },
118 {
119 /* host */ NULL, "^a$",
120 /* svc */ NULL, NULL,
121 /* attr */ NULL, NULL, NULL, NULL, 1
122 },
123 {
124 /* host */ NULL, "^b$",
125 /* svc */ NULL, NULL,
126 /* attr */ NULL, NULL, NULL, NULL, 0
127 },
128 {
129 /* host */ "a", "^a$",
130 /* svc */ NULL, NULL,
131 /* attr */ NULL, NULL, NULL, NULL, 1
132 },
133 {
134 /* host */ "a", "^b$",
135 /* svc */ NULL, NULL,
136 /* attr */ NULL, NULL, NULL, NULL, 0
137 },
138 {
139 /* host */ "b", "^a$",
140 /* svc */ NULL, NULL,
141 /* attr */ NULL, NULL, NULL, NULL, 0
142 },
143 {
144 /* host */ "a", "^a$",
145 /* svc */ "s1", NULL,
146 /* attr */ NULL, NULL, NULL, NULL, 1
147 },
148 {
149 /* host */ "a", "^a$",
150 /* svc */ NULL, "^s1$",
151 /* attr */ NULL, NULL, NULL, NULL, 1
152 },
153 {
154 /* host */ "a", "^a$",
155 /* svc */ "s1", "^s1$",
156 /* attr */ NULL, NULL, NULL, NULL, 1
157 },
158 {
159 /* host */ "a", "^a$",
160 /* svc */ "x1", NULL,
161 /* attr */ NULL, NULL, NULL, NULL, 0
162 },
163 {
164 /* host */ "a", "^a$",
165 /* svc */ NULL, "x",
166 /* attr */ NULL, NULL, NULL, NULL, 0
167 },
168 {
169 /* host */ "a", "^a$",
170 /* svc */ "x1", "x",
171 /* attr */ NULL, NULL, NULL, NULL, 0
172 },
173 {
174 /* host */ "a", "^a$",
175 /* svc */ "s1", "x",
176 /* attr */ NULL, NULL, NULL, NULL, 0
177 },
178 {
179 /* host */ "a", "^a$",
180 /* svc */ "x1", "s",
181 /* attr */ NULL, NULL, NULL, NULL, 0
182 },
183 {
184 /* host */ "a", "^a$",
185 /* svc */ "s1", "^s1$",
186 /* attr */ "k1", NULL, NULL, NULL, 1
187 },
188 {
189 /* host */ "a", "^a$",
190 /* svc */ "s1", "^s1$",
191 /* attr */ NULL, "^k", NULL, NULL, 1
192 },
193 {
194 /* host */ "a", "^a$",
195 /* svc */ "s1", "^s1$",
196 /* attr */ NULL, NULL, "v1", NULL, 1
197 },
198 {
199 /* host */ "a", "^a$",
200 /* svc */ "s1", "^s1$",
201 /* attr */ NULL, NULL, NULL, "^v1$", 1
202 },
203 {
204 /* host */ "a", "^a$",
205 /* svc */ "s1", "^s1$",
206 /* attr */ "k1", "1", "v1", "1", 1
207 },
208 };
210 size_t i;
212 obj = sdb_store_get_host("a");
213 fail_unless(obj != NULL,
214 "sdb_store_get_host(a) = NULL; expected: <host>");
216 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
217 sdb_store_matcher_t *h, *s, *a, *n;
218 int status;
220 s = sdb_store_service_matcher(golden_data[i].service_name,
221 golden_data[i].service_name_re, NULL);
222 fail_unless(s != NULL,
223 "sdb_store_service_matcher() = NULL; expected: <matcher>");
225 a = sdb_store_attr_matcher(golden_data[i].attr_name,
226 golden_data[i].attr_name_re, golden_data[i].attr_value,
227 golden_data[i].attr_value_re);
228 fail_unless(a != NULL,
229 "sdb_store_attr_matcher() = NULL; expected: <matcher>");
231 h = sdb_store_host_matcher(golden_data[i].hostname,
232 golden_data[i].hostname_re, s, a);
233 fail_unless(h != NULL,
234 "sdb_store_host_matcher() = NULL: expected: <matcher>");
235 /* pass ownership to the host matcher */
236 sdb_object_deref(SDB_OBJ(s));
237 sdb_object_deref(SDB_OBJ(a));
239 status = sdb_store_matcher_matches(h, obj);
240 fail_unless(status == golden_data[i].expected,
241 "sdb_store_matcher_matches({{%s, %s},{%s, %s},"
242 "{%s, %s, %s, %s}}, <host a>) = %d; expected: %d",
243 golden_data[i].hostname, golden_data[i].hostname_re,
244 golden_data[i].service_name, golden_data[i].service_name_re,
245 golden_data[i].attr_name, golden_data[i].attr_name_re,
246 golden_data[i].attr_value, golden_data[i].attr_value_re,
247 status, golden_data[i].expected);
249 n = sdb_store_inv_matcher(h);
250 fail_unless(n != NULL,
251 "sdb_store_inv_matcher() = NULL; expected: <matcher>");
252 sdb_object_deref(SDB_OBJ(h));
254 /* now match the inverted set of objects */
255 status = sdb_store_matcher_matches(n, obj);
256 fail_unless(status == !golden_data[i].expected,
257 "sdb_store_matcher_matches(NOT{{%s, %s},{%s, %s},"
258 "{%s, %s, %s, %s}}, <host a>) = %d; expected: %d",
259 golden_data[i].hostname, golden_data[i].hostname_re,
260 golden_data[i].service_name, golden_data[i].service_name_re,
261 golden_data[i].attr_name, golden_data[i].attr_name_re,
262 golden_data[i].attr_value, golden_data[i].attr_value_re,
263 status, !golden_data[i].expected);
265 sdb_object_deref(SDB_OBJ(n));
266 }
267 }
268 END_TEST
270 START_TEST(test_store_match_op)
271 {
272 sdb_store_base_t *obj;
274 sdb_store_matcher_t *always = sdb_store_host_matcher(NULL, NULL, NULL, NULL);
275 sdb_store_matcher_t *never = sdb_store_host_matcher("a", "b", NULL, NULL);
277 struct {
278 const char *op;
279 sdb_store_matcher_t *left;
280 sdb_store_matcher_t *right;
281 int expected;
282 } golden_data[] = {
283 { "OR", always, always, 1 },
284 { "OR", always, never, 1 },
285 { "OR", never, always, 1 },
286 { "OR", never, never, 0 },
287 { "AND", always, always, 1 },
288 { "AND", always, never, 0 },
289 { "AND", never, always, 0 },
290 { "AND", never, never, 0 },
291 };
293 int status;
294 size_t i;
296 obj = sdb_store_get_host("a");
298 status = sdb_store_matcher_matches(always, obj);
299 fail_unless(status == 1,
300 "INTERNAL ERROR: 'always' did not match host");
301 status = sdb_store_matcher_matches(never, obj);
302 fail_unless(status == 0,
303 "INTERNAL ERROR: 'never' matches host");
305 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
306 sdb_store_matcher_t *m;
308 if (! strcmp(golden_data[i].op, "OR"))
309 m = sdb_store_dis_matcher(golden_data[i].left,
310 golden_data[i].right);
311 else if (! strcmp(golden_data[i].op, "AND"))
312 m = sdb_store_con_matcher(golden_data[i].left,
313 golden_data[i].right);
314 else {
315 fail("INTERNAL ERROR: unexpected operator %s", golden_data[i].op);
316 continue;
317 }
319 #define TO_NAME(v) (((v) == always) ? "always" \
320 : ((v) == never) ? "never" : "<unknown>")
322 status = sdb_store_matcher_matches(m, obj);
323 fail_unless(status == golden_data[i].expected,
324 "%s(%s, %s) = %d; expected: %d", golden_data[i].op,
325 TO_NAME(golden_data[i].left), TO_NAME(golden_data[i].right),
326 status, golden_data[i].expected);
328 #undef TO_NAME
330 sdb_object_deref(SDB_OBJ(m));
331 }
333 sdb_object_deref(SDB_OBJ(always));
334 sdb_object_deref(SDB_OBJ(never));
335 }
336 END_TEST
338 START_TEST(test_parse_cmp)
339 {
340 sdb_store_matcher_t *check;
342 size_t i;
344 struct {
345 const char *obj_type;
346 const char *attr;
347 const char *op;
348 const char *value;
349 int expected;
350 } golden_data[] = {
351 { "host", "name", "=", "hostname", MATCHER_HOST },
352 { "host", "name", "!=", "hostname", MATCHER_NOT },
353 { "host", "name", "=~", "hostname", MATCHER_HOST },
354 { "host", "name", "!~", "hostname", MATCHER_NOT },
355 { "host", "attr", "=", "hostname", -1 },
356 { "host", "attr", "!=", "hostname", -1 },
357 { "host", "name", "&^", "hostname", -1 },
358 { "service", "name", "=", "srvname", MATCHER_HOST },
359 { "service", "name", "!=", "srvname", MATCHER_NOT },
360 { "service", "name", "=~", "srvname", MATCHER_HOST },
361 { "service", "name", "!~", "srvname", MATCHER_NOT },
362 { "service", "attr", "=", "srvname", -1 },
363 { "service", "attr", "!=", "srvname", -1 },
364 { "service", "name", "&^", "srvname", -1 },
365 { "attribute", "name", "=", "attrname", MATCHER_HOST },
366 { "attribute", "name", "!=", "attrname", MATCHER_NOT },
367 { "attribute", "name", "=~", "attrname", MATCHER_HOST },
368 { "attribute", "name", "!~", "attrname", MATCHER_NOT },
369 { "attribute", "attr", "=", "attrname", MATCHER_HOST },
370 { "attribute", "attr", "!=", "attrname", MATCHER_NOT },
371 { "attribute", "attr", "=~", "attrname", MATCHER_HOST },
372 { "attribute", "attr", "!~", "attrname", MATCHER_NOT },
373 { "attribute", "attr", "&^", "attrname", -1 },
374 };
376 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
377 check = sdb_store_matcher_parse_cmp(golden_data[i].obj_type,
378 golden_data[i].attr, golden_data[i].op, golden_data[i].value);
380 if (golden_data[i].expected == -1) {
381 fail_unless(check == NULL,
382 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) = %p; "
383 "expected: NULL", golden_data[i].obj_type,
384 golden_data[i].attr, golden_data[i].op,
385 golden_data[i].value, check);
386 continue;
387 }
389 fail_unless(check != NULL,
390 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) = %p; "
391 "expected: NULL", golden_data[i].obj_type,
392 golden_data[i].attr, golden_data[i].op,
393 golden_data[i].value, check);
394 fail_unless(M(check)->type == golden_data[i].expected,
395 "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) returned matcher "
396 "of type %d; expected: %d", golden_data[i].obj_type,
397 golden_data[i].attr, golden_data[i].op, golden_data[i].value,
398 M(check)->type, golden_data[i].expected);
400 sdb_object_deref(SDB_OBJ(check));
401 }
402 }
403 END_TEST
405 static int
406 lookup_cb(sdb_store_base_t *obj, void *user_data)
407 {
408 int *i = user_data;
410 fail_unless(obj != NULL,
411 "sdb_store_lookup callback received NULL obj; expected: "
412 "<store base obj>");
413 fail_unless(i != NULL,
414 "sdb_store_lookup callback received NULL user_data; "
415 "expected: <pointer to data>");
417 ++(*i);
418 return 0;
419 } /* lookup_cb */
421 START_TEST(test_lookup)
422 {
423 struct {
424 const char *query;
425 int expected;
426 } golden_data[] = {
427 { "host.name = 'a'", 1 },
428 { "host.name =~ 'a|b'", 2 },
429 { "host.name =~ 'host'", 0 },
430 { "host.name =~ '.'", 3 },
431 { "service.name = 's1'", 2 },
432 { "service.name =~ 's'", 2 },
433 { "service.name !~ 's'", 1 },
434 { "attribute.name = 'k1'", 1 },
435 { "attribute.name = 'x'", 0 },
436 { "attribute.k1 = 'v1'", 1 },
437 { "attribute.k1 != 'v1'", 2 },
438 { "attribute.k1 != 'v2'", 3 },
439 };
441 size_t i;
442 int check, n;
444 i = 0;
445 check = sdb_store_lookup(NULL, lookup_cb, &i);
446 fail_unless(check == 0,
447 "sdb_store_lookup() = %d; expected: 0", check);
448 fail_unless(i == 3,
449 "sdb_store_lookup called callback %d times; expected: 3", (int)i);
451 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
452 sdb_store_matcher_t *m = sdb_fe_parse_matcher(golden_data[i].query, -1);
453 fail_unless(m != NULL,
454 "sdb_fe_parse_matcher(%s, -1) = NULL; expected: <matcher>",
455 golden_data[i].query);
457 n = 0;
458 sdb_store_lookup(m, lookup_cb, &n);
459 fail_unless(n == golden_data[i].expected,
460 "sdb_store_lookup(matcher{%s}) found %d hosts; expected: %d",
461 golden_data[i].query, n, golden_data[i].expected);
462 sdb_object_deref(SDB_OBJ(m));
463 }
464 }
465 END_TEST
467 Suite *
468 core_store_lookup_suite(void)
469 {
470 Suite *s = suite_create("core::store_lookup");
471 TCase *tc;
473 tc = tcase_create("core");
474 tcase_add_checked_fixture(tc, populate, sdb_store_clear);
475 tcase_add_test(tc, test_store_match);
476 tcase_add_test(tc, test_store_match_op);
477 tcase_add_test(tc, test_parse_cmp);
478 tcase_add_test(tc, test_lookup);
479 suite_add_tcase(s, tc);
481 return s;
482 } /* core_store_lookup_suite */
484 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */