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 <assert.h>
35 #include <check.h>
36 #include <string.h>
38 static void
39 populate(void)
40 {
41 const char *hosts[] = { "a", "b", "c" };
43 struct {
44 const char *host;
45 const char *metric;
46 } metrics[] = {
47 { "a", "m1" },
48 { "b", "m1" },
49 { "b", "m2" },
50 };
52 struct {
53 const char *host;
54 const char *service;
55 } services[] = {
56 { "a", "s1" },
57 { "a", "s2" },
58 { "b", "s1" },
59 { "b", "s3" },
60 };
62 struct {
63 const char *host;
64 const char *name;
65 sdb_data_t value;
66 } attrs[] = {
67 { "a", "k1", { SDB_TYPE_STRING, { .string = "v1" } } },
68 { "a", "k2", { SDB_TYPE_INTEGER, { .integer = 123 } } },
69 { "b", "k1", { SDB_TYPE_STRING, { .string = "v2" } } },
70 };
72 size_t i;
74 for (i = 0; i < SDB_STATIC_ARRAY_LEN(hosts); ++i) {
75 int status = sdb_store_host(hosts[i], 1);
76 fail_unless(status == 0,
77 "sdb_store_host(%s, 1) = %d; expected: 0",
78 hosts[i], status);
79 }
81 for (i = 0; i < SDB_STATIC_ARRAY_LEN(metrics); ++i) {
82 int status = sdb_store_metric(metrics[i].host,
83 metrics[i].metric, /* store */ NULL, 1);
84 fail_unless(status == 0,
85 "sdb_store_metric(%s, %s, NULL, 1) = %d; expected: 0",
86 metrics[i].host, metrics[i].metric, status);
87 }
89 for (i = 0; i < SDB_STATIC_ARRAY_LEN(services); ++i) {
90 int status = sdb_store_service(services[i].host,
91 services[i].service, 1);
92 fail_unless(status == 0,
93 "sdb_store_service(%s, %s, 1) = %d; expected: 0",
94 services[i].host, services[i].service, status);
95 }
97 for (i = 0; i < SDB_STATIC_ARRAY_LEN(attrs); ++i) {
98 int status = sdb_store_attribute(attrs[i].host,
99 attrs[i].name, &attrs[i].value, 1);
100 fail_unless(status == 0,
101 "sdb_store_attribute(%s, %s, <val>, 1) = %d; expected: 0",
102 attrs[i].host, attrs[i].name, status);
103 }
104 } /* populate */
106 struct {
107 int type;
108 char *name;
109 _Bool re;
111 int expected;
112 } cmp_name_data[] = {
113 { SDB_HOST, "a", 0, 1 },
114 { SDB_HOST, "a", 1, 1 },
115 { SDB_HOST, "b", 0, 0 },
116 { SDB_HOST, "b", 1, 0 },
117 { SDB_HOST, "^a$", 1, 1 },
118 { SDB_HOST, "^b$", 1, 0 },
119 { SDB_HOST, "^a$", 0, 0 },
120 { SDB_HOST, "^b$", 0, 0 },
121 { SDB_METRIC, "m1", 0, 1 },
122 { SDB_METRIC, "m1", 1, 1 },
123 { SDB_METRIC, "^m1$", 1, 1 },
124 { SDB_METRIC, "m", 1, 1 },
125 { SDB_METRIC, "s", 1, 0 },
126 { SDB_METRIC, "m2", 0, 0 },
127 { SDB_METRIC, "x1", 0, 0 },
128 { SDB_METRIC, "x1", 1, 0 },
129 { SDB_SERVICE, "s1", 0, 1 },
130 { SDB_SERVICE, "s2", 0, 1 },
131 { SDB_SERVICE, "s3", 0, 0 },
132 { SDB_SERVICE, "s4", 0, 0 },
133 { SDB_SERVICE, "^s1$", 1, 1 },
134 { SDB_SERVICE, "^s1$", 0, 0 },
135 { SDB_SERVICE, "x1", 0, 0 },
136 { SDB_SERVICE, "x1", 1, 0 },
137 { SDB_SERVICE, "x", 1, 0 },
138 { SDB_ATTRIBUTE, "k1", 0, 1 },
139 { SDB_ATTRIBUTE, "k2", 0, 1 },
140 { SDB_ATTRIBUTE, "k3", 0, 0 },
141 { SDB_ATTRIBUTE, "k4", 0, 0 },
142 { SDB_ATTRIBUTE, "k", 1, 1 },
143 { SDB_ATTRIBUTE, "1", 1, 1 },
144 { SDB_ATTRIBUTE, "3", 1, 0 },
145 };
147 START_TEST(test_cmp_name)
148 {
149 sdb_store_obj_t *host;
150 sdb_data_t datum;
151 sdb_store_expr_t *obj, *value;
152 sdb_store_matcher_t *m, *n;
153 int status;
155 host = sdb_store_get_host("a");
156 fail_unless(host != NULL,
157 "sdb_store_get_host(a) = NULL; expected: <host>");
159 datum.type = SDB_TYPE_STRING;
160 datum.data.string = cmp_name_data[_i].name;
162 obj = sdb_store_expr_fieldvalue(SDB_FIELD_NAME);
163 fail_unless(obj != NULL,
164 "sdb_store_expr_fieldvalue(SDB_STORE_NAME) = NULL; "
165 "expected: <expr>");
166 value = sdb_store_expr_constvalue(&datum);
167 fail_unless(value != NULL,
168 "sdb_store_expr_constvalue(%s) = NULL; "
169 "expected: <expr>", cmp_name_data[_i].name);
171 if (cmp_name_data[_i].re)
172 m = sdb_store_regex_matcher(obj, value);
173 else
174 m = sdb_store_eq_matcher(obj, value);
175 if (cmp_name_data[_i].type != SDB_HOST) {
176 sdb_store_matcher_t *tmp;
177 tmp = sdb_store_any_matcher(cmp_name_data[_i].type, m);
178 sdb_object_deref(SDB_OBJ(m));
179 m = tmp;
180 }
181 sdb_object_deref(SDB_OBJ(obj));
182 sdb_object_deref(SDB_OBJ(value));
183 fail_unless(m != NULL,
184 "sdb_store_%s_matcher(%s, %s) = NULL; "
185 "expected: <matcher>",
186 cmp_name_data[_i].re ? "regex" : "eq",
187 SDB_STORE_TYPE_TO_NAME(cmp_name_data[_i].type),
188 cmp_name_data[_i].name);
190 status = sdb_store_matcher_matches(m, host, /* filter */ NULL);
191 fail_unless(status == cmp_name_data[_i].expected,
192 "sdb_store_matcher_matches(%s->%s, <host a>, NULL) = %d; "
193 "expected: %d", SDB_STORE_TYPE_TO_NAME(cmp_name_data[_i].type),
194 cmp_name_data[_i].name, status, cmp_name_data[_i].expected);
196 n = sdb_store_inv_matcher(m);
197 fail_unless(n != NULL,
198 "sdb_store_inv_matcher() = NULL; expected: <matcher>");
199 sdb_object_deref(SDB_OBJ(m));
201 /* now match the inverted set of objects */
202 status = sdb_store_matcher_matches(n, host, /* filter */ NULL);
203 fail_unless(status == !cmp_name_data[_i].expected,
204 "sdb_store_matcher_matches(%s->%s, <host a>, NULL) = %d; "
205 "expected: %d", SDB_STORE_TYPE_TO_NAME(cmp_name_data[_i].type),
206 cmp_name_data[_i].name, status, !cmp_name_data[_i].expected);
208 sdb_object_deref(SDB_OBJ(n));
209 sdb_object_deref(SDB_OBJ(host));
210 }
211 END_TEST
213 struct {
214 const char *attr;
215 const sdb_data_t value;
216 int expected_lt, expected_le, expected_eq, expected_ge, expected_gt;
217 } cmp_attr_data[] = {
218 { "k1", { SDB_TYPE_STRING, { .string = "v1" } }, 0, 1, 1, 1, 0 },
219 { "k1", { SDB_TYPE_STRING, { .string = "v2" } }, 1, 1, 0, 0, 0 },
220 { "k1", { SDB_TYPE_STRING, { .string = "v0" } }, 0, 0, 0, 1, 1 },
221 { "k1", { SDB_TYPE_STRING, { .string = "0" } }, 0, 0, 0, 1, 1 },
222 { "k2", { SDB_TYPE_INTEGER, { .integer = 123 } }, 0, 1, 1, 1, 0 },
223 { "k2", { SDB_TYPE_INTEGER, { .integer = 124 } }, 1, 1, 0, 0, 0 },
224 { "k2", { SDB_TYPE_INTEGER, { .integer = 122 } }, 0, 0, 0, 1, 1 },
225 /* key does not exist */
226 { "k3", { SDB_TYPE_STRING, { .string = "v1" } }, 0, 0, 0, 0, 0 },
227 { "k3", { SDB_TYPE_STRING, { .string = "123" } }, 0, 0, 0, 0, 0 },
228 { "k3", { SDB_TYPE_INTEGER, { .integer = 123 } }, 0, 0, 0, 0, 0 },
229 /* type mismatch */
230 { "k1", { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 1, 1 },
231 { "k2", { SDB_TYPE_STRING, { .string = "123" } }, 0, 1, 1, 1, 0 },
232 };
234 START_TEST(test_cmp_attr)
235 {
236 sdb_store_obj_t *host;
237 sdb_store_expr_t *attr;
238 sdb_store_expr_t *value;
239 char value_str[1024];
240 int status;
241 size_t j;
243 struct {
244 sdb_store_matcher_t *(*matcher)(sdb_store_expr_t *,
245 sdb_store_expr_t *);
246 int expected;
247 } tests[] = {
248 { sdb_store_lt_matcher, cmp_attr_data[_i].expected_lt },
249 { sdb_store_le_matcher, cmp_attr_data[_i].expected_le },
250 { sdb_store_eq_matcher, cmp_attr_data[_i].expected_eq },
251 { sdb_store_ge_matcher, cmp_attr_data[_i].expected_ge },
252 { sdb_store_gt_matcher, cmp_attr_data[_i].expected_gt },
253 };
255 const char *op_str[] = { "<", "<=", "=", ">=", ">" };
256 assert(SDB_STATIC_ARRAY_LEN(tests) == SDB_STATIC_ARRAY_LEN(op_str));
258 host = sdb_store_get_host("a");
259 fail_unless(host != NULL,
260 "sdb_store_get_host(a) = NULL; expected: <host>");
262 sdb_data_format(&cmp_attr_data[_i].value,
263 value_str, sizeof(value_str), SDB_UNQUOTED);
265 attr = sdb_store_expr_attrvalue(cmp_attr_data[_i].attr);
266 fail_unless(attr != NULL,
267 "sdb_store_expr_attrvalue(%s) = NULL; expected: <expr>",
268 cmp_attr_data[_i].attr);
270 value = sdb_store_expr_constvalue(&cmp_attr_data[_i].value);
271 fail_unless(value != NULL,
272 "sdb_store_expr_constvalue(%s) = NULL; expected: <expr>",
273 value_str);
275 for (j = 0; j < SDB_STATIC_ARRAY_LEN(tests); ++j) {
276 sdb_store_matcher_t *m;
278 m = tests[j].matcher(attr, value);
279 fail_unless(m != NULL,
280 "sdb_store_<cond>_matcher() = NULL; expected: <matcher>");
282 status = sdb_store_matcher_matches(m, host, /* filter */ NULL);
283 fail_unless(status == tests[j].expected,
284 "sdb_store_matcher_matches(<attr[%s] %s %s>, "
285 "<host>, NULL) = %d; expected: %d",
286 cmp_attr_data[_i].attr, op_str[j], value_str,
287 status, tests[j].expected);
289 sdb_object_deref(SDB_OBJ(m));
290 }
292 sdb_object_deref(SDB_OBJ(attr));
293 sdb_object_deref(SDB_OBJ(value));
294 sdb_object_deref(SDB_OBJ(host));
295 }
296 END_TEST
298 struct {
299 const char *host;
300 int field;
301 const sdb_data_t value;
302 int expected_lt, expected_le, expected_eq, expected_ge, expected_gt;
303 } cmp_obj_data[] = {
304 { "b", SDB_FIELD_NAME,
305 { SDB_TYPE_STRING, { .string = "a" } }, 0, 0, 0, 1, 1 },
306 { "b", SDB_FIELD_NAME,
307 { SDB_TYPE_STRING, { .string = "b" } }, 0, 1, 1, 1, 0 },
308 { "b", SDB_FIELD_NAME,
309 { SDB_TYPE_STRING, { .string = "c" } }, 1, 1, 0, 0, 0 },
310 /* last-update = 1 for all objects */
311 { "a", SDB_FIELD_LAST_UPDATE,
312 { SDB_TYPE_DATETIME, { .datetime = 1 } }, 0, 1, 1, 1, 0 },
313 { "a", SDB_FIELD_LAST_UPDATE,
314 { SDB_TYPE_DATETIME, { .datetime = 2 } }, 1, 1, 0, 0, 0 },
315 { "a", SDB_FIELD_LAST_UPDATE,
316 { SDB_TYPE_DATETIME, { .datetime = 0 } }, 0, 0, 0, 1, 1 },
317 /* age > 0 for all objects */
318 { "a", SDB_FIELD_AGE,
319 { SDB_TYPE_DATETIME, { .datetime = 0 } }, 0, 0, 0, 1, 1 },
320 /* interval = 0 for all objects */
321 { "a", SDB_FIELD_INTERVAL,
322 { SDB_TYPE_DATETIME, { .datetime = 0 } }, 0, 1, 1, 1, 0 },
323 { "a", SDB_FIELD_INTERVAL,
324 { SDB_TYPE_DATETIME, { .datetime = 1 } }, 1, 1, 0, 0, 0 },
325 /* type mismatch */
326 { "a", SDB_FIELD_LAST_UPDATE,
327 { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
328 { "a", SDB_FIELD_AGE,
329 { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
330 { "a", SDB_FIELD_INTERVAL,
331 { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
332 { "a", SDB_FIELD_BACKEND,
333 { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
334 { "a", SDB_FIELD_BACKEND,
335 { SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
336 /* (64bit) integer value without zero-bytes */
337 { "a", SDB_FIELD_BACKEND,
338 { SDB_TYPE_INTEGER, { .integer = 0xffffffffffffffffL } },
339 0, 0, 0, 0, 0 },
340 };
342 START_TEST(test_cmp_obj)
343 {
344 sdb_store_obj_t *host;
345 sdb_store_expr_t *field;
346 sdb_store_expr_t *value;
347 char value_str[1024];
348 int status;
349 size_t j;
351 struct {
352 sdb_store_matcher_t *(*matcher)(sdb_store_expr_t *,
353 sdb_store_expr_t *);
354 int expected;
355 } tests[] = {
356 { sdb_store_lt_matcher, cmp_obj_data[_i].expected_lt },
357 { sdb_store_le_matcher, cmp_obj_data[_i].expected_le },
358 { sdb_store_eq_matcher, cmp_obj_data[_i].expected_eq },
359 { sdb_store_ge_matcher, cmp_obj_data[_i].expected_ge },
360 { sdb_store_gt_matcher, cmp_obj_data[_i].expected_gt },
361 };
362 char *op_str[] = { "<", "<=", "=", ">=", ">" };
364 assert(SDB_STATIC_ARRAY_LEN(tests) == SDB_STATIC_ARRAY_LEN(op_str));
366 host = sdb_store_get_host(cmp_obj_data[_i].host);
367 fail_unless(host != NULL,
368 "sdb_store_get_host(%s) = NULL; expected: <host>",
369 cmp_obj_data[_i].host);
371 sdb_data_format(&cmp_obj_data[_i].value,
372 value_str, sizeof(value_str), SDB_UNQUOTED);
374 field = sdb_store_expr_fieldvalue(cmp_obj_data[_i].field);
375 fail_unless(field != NULL,
376 "sdb_store_expr_fieldvalue(%d) = NULL; "
377 "expected: <expr>", cmp_obj_data[_i].field);
379 value = sdb_store_expr_constvalue(&cmp_obj_data[_i].value);
380 fail_unless(value != NULL,
381 "sdb_store_expr_constvalue(%s) = NULL; "
382 "expected: <expr>", value_str);
384 for (j = 0; j < SDB_STATIC_ARRAY_LEN(tests); ++j) {
385 char m_str[1024];
386 sdb_store_matcher_t *m;
388 snprintf(m_str, sizeof(m_str), "%s %s %s",
389 SDB_FIELD_TO_NAME(cmp_obj_data[_i].field),
390 op_str[j], value_str);
392 m = tests[j].matcher(field, value);
393 fail_unless(m != NULL,
394 "sdb_store_<cond>_matcher() = NULL; expected: <matcher>");
396 status = sdb_store_matcher_matches(m, host, /* filter */ NULL);
397 fail_unless(status == tests[j].expected,
398 "sdb_store_matcher_matches(<%s>, <host '%s'>, NULL) = %d; "
399 "expected: %d", m_str, cmp_obj_data[_i].host, status,
400 tests[j].expected);
402 sdb_object_deref(SDB_OBJ(m));
403 }
405 sdb_object_deref(SDB_OBJ(field));
406 sdb_object_deref(SDB_OBJ(value));
407 sdb_object_deref(SDB_OBJ(host));
408 }
409 END_TEST
411 START_TEST(test_store_match_op)
412 {
413 sdb_store_obj_t *obj;
415 sdb_data_t d = { SDB_TYPE_STRING, { .string = "a" } };
416 sdb_store_expr_t *e = sdb_store_expr_constvalue(&d);
418 sdb_store_matcher_t *always = sdb_store_isnnull_matcher(e);
419 sdb_store_matcher_t *never = sdb_store_isnull_matcher(e);
421 struct {
422 const char *op;
423 sdb_store_matcher_t *left;
424 sdb_store_matcher_t *right;
425 int expected;
426 } golden_data[] = {
427 { "OR", always, always, 1 },
428 { "OR", always, never, 1 },
429 { "OR", never, always, 1 },
430 { "OR", never, never, 0 },
431 { "AND", always, always, 1 },
432 { "AND", always, never, 0 },
433 { "AND", never, always, 0 },
434 { "AND", never, never, 0 },
435 };
437 int status;
438 size_t i;
440 obj = sdb_store_get_host("a");
442 status = sdb_store_matcher_matches(always, obj, /* filter */ NULL);
443 fail_unless(status == 1,
444 "INTERNAL ERROR: 'always' did not match host");
445 status = sdb_store_matcher_matches(never, obj, /* filter */ NULL);
446 fail_unless(status == 0,
447 "INTERNAL ERROR: 'never' matches host");
449 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
450 sdb_store_matcher_t *m;
452 if (! strcmp(golden_data[i].op, "OR"))
453 m = sdb_store_dis_matcher(golden_data[i].left,
454 golden_data[i].right);
455 else if (! strcmp(golden_data[i].op, "AND"))
456 m = sdb_store_con_matcher(golden_data[i].left,
457 golden_data[i].right);
458 else {
459 fail("INTERNAL ERROR: unexpected operator %s", golden_data[i].op);
460 continue;
461 }
463 #define TO_NAME(v) (((v) == always) ? "always" \
464 : ((v) == never) ? "never" : "<unknown>")
466 status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
467 fail_unless(status == golden_data[i].expected,
468 "%s(%s, %s, NULL) = %d; expected: %d", golden_data[i].op,
469 TO_NAME(golden_data[i].left), TO_NAME(golden_data[i].right),
470 status, golden_data[i].expected);
472 #undef TO_NAME
474 sdb_object_deref(SDB_OBJ(m));
475 }
477 sdb_object_deref(SDB_OBJ(always));
478 sdb_object_deref(SDB_OBJ(never));
479 sdb_object_deref(SDB_OBJ(e));
481 sdb_object_deref(SDB_OBJ(obj));
482 }
483 END_TEST
485 static int
486 scan_cb(sdb_store_obj_t *obj, sdb_store_matcher_t *filter, void *user_data)
487 {
488 int *i = user_data;
490 if (! sdb_store_matcher_matches(filter, obj, NULL))
491 return 0;
493 fail_unless(obj != NULL,
494 "sdb_store_scan callback received NULL obj; expected: "
495 "<store base obj>");
496 fail_unless(i != NULL,
497 "sdb_store_scan callback received NULL user_data; "
498 "expected: <pointer to data>");
500 ++(*i);
501 return 0;
502 } /* scan_cb */
504 struct {
505 const char *query;
506 const char *filter;
507 int expected;
508 } scan_data[] = {
509 /* TODO: check the name of the expected hosts */
510 { "name = 'a'", NULL, 1 },
511 { "name = 'a'", "name = 'x'", 0 }, /* filter never matches */
512 { "name = 'a'",
513 "NOT attribute['x'] = ''", 1 }, /* filter always matches */
514 { "name =~ 'a|b'", NULL, 2 },
515 { "name =~ 'host'", NULL, 0 },
516 { "name =~ '.'", NULL, 3 },
517 { "ANY backend = 'backend'", NULL, 0 },
518 { "ALL backend = ''", NULL, 3 }, /* backend is empty */
519 { "backend = ['backend']", NULL, 0 },
520 { "backend != ['backend']", NULL, 3 },
521 { "backend < ['backend']", NULL, 3 },
522 { "backend <= ['backend']", NULL, 3 },
523 { "backend >= ['backend']", NULL, 0 },
524 { "backend > ['backend']", NULL, 0 },
525 { "ANY metric = 'm1'", NULL, 2 },
526 { "ANY metric= 'm1'", "name = 'x'", 0 }, /* filter never matches */
527 { "ANY metric = 'm1'",
528 "NOT attribute['x'] = ''", 2 }, /* filter always matches */
529 { "ANY metric =~ 'm'", NULL, 2 },
530 { "ALL metric =~ 'm'", NULL, 3 },
531 { "ANY metric =~ 'm'", "name !~ '1'", 1 },
532 { "ANY metric =~ 'm'", "name !~ 'm'", 0 },
533 { "ALL metric =~ '1'", NULL, 2 },
534 { "ALL metric =~ '2'", NULL, 1 },
535 { "ANY metric !~ 'm'", NULL, 0 },
536 { "ALL metric !~ 'm'", NULL, 1 },
537 { "ANY metric =~ 'x'", NULL, 0 },
538 { "ANY service = 's1'", NULL, 2 },
539 { "ANY service = 's1'", "name = 'x'", 0 }, /* filter never matches */
540 { "ANY service = 's1'",
541 "NOT attribute['x'] = ''", 2 }, /* filter always matches */
542 { "ANY service =~ 's'", NULL, 2 },
543 { "ANY service =~ 's'", "name !~ 's'", 0 },
544 { "ANY service =~ 's'", "name !~ '1'", 2 },
545 { "ANY service !~ 's'", NULL, 0 },
546 { "ANY attribute = 'k1'", NULL, 2 },
547 { "ANY attribute = 'k1'", "name = 'x'",0 }, /* filter never matches */
548 { "ANY attribute = 'k1'",
549 "NOT attribute['x'] = ''", 2 }, /* filter always matches */
550 { "ANY attribute =~ 'k'", NULL, 2 },
551 { "ANY attribute =~ 'k'",
552 "name !~ '1'", 1 },
553 { "ANY attribute =~ 'k'",
554 "name !~ 'k'", 0 },
555 { "ANY attribute =~ '1'", NULL, 2 },
556 { "ANY attribute =~ '2'", NULL, 1 },
557 { "ANY attribute = 'x'", NULL, 0 },
558 { "ANY attribute =~ 'x'", NULL, 0 },
559 { "ALL attribute = 'k1'", NULL, 2 },
560 { "host.name = 'a'", NULL, 1 },
561 { "host.attribute['k1'] =~ 'v1'",
562 NULL, 1 },
563 { "host.attribute['x1'] IS NULL",
564 NULL, 3 },
565 { "attribute['k1'] = 'v1'", NULL, 1 },
566 { "attribute['k1'] = 'v1'",
567 "name != 'k1'", 0 },
568 { "attribute['k1'] =~ 'v1'", NULL, 1 },
569 { "attribute['k1'] =~ '^v1$'", NULL, 1 },
570 { "attribute['k1'] =~ 'v'", NULL, 2 },
571 { "attribute['k1'] =~ '1'", NULL, 1 },
572 { "attribute['k1'] !~ 'v'", NULL, 0 },
573 { "attribute['k1'] = 'v2'", NULL, 1 },
574 { "attribute['k1'] =~ 'v2'", NULL, 1 },
575 { "attribute['x1'] =~ 'v'", NULL, 0 },
576 { "attribute['x1'] =~ 'NULL'", NULL, 0 },
577 { "attribute['x1'] !~ 'v'", NULL, 0 },
578 { "attribute['k1'] IS NULL", NULL, 1 },
579 { "attribute['x1'] IS NULL", NULL, 3 },
580 { "attribute['k1'] IS NOT NULL", NULL, 2 },
581 { "attribute['x1'] IS NOT NULL", NULL, 0 },
582 { "attribute['k2'] < 123", NULL, 0 },
583 { "attribute['k2'] <= 123", NULL, 1 },
584 { "attribute['k2'] >= 123", NULL, 1 },
585 { "attribute['k2'] > 123", NULL, 0 },
586 { "attribute['k2'] = 123", NULL, 1 },
587 { "attribute['k2'] != 123", NULL, 0 },
588 { "attribute['k1'] != 'v1'", NULL, 1 },
589 { "attribute['k1'] != 'v2'", NULL, 1 },
590 { "ANY attribute != 'x' "
591 "AND attribute['k1'] !~ 'x'", NULL, 2 },
592 };
594 START_TEST(test_scan)
595 {
596 sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
597 sdb_store_matcher_t *m, *filter = NULL;
598 int check, n;
600 n = 0;
601 check = sdb_store_scan(SDB_HOST, /* matcher */ NULL, /* filter */ NULL,
602 scan_cb, &n);
603 fail_unless(check == 0,
604 "sdb_store_scan() = %d; expected: 0", check);
605 fail_unless(n == 3,
606 "sdb_store_scan called callback %d times; expected: 3", (int)n);
608 m = sdb_fe_parse_matcher(scan_data[_i].query, -1, errbuf);
609 fail_unless(m != NULL,
610 "sdb_fe_parse_matcher(%s, -1) = NULL; expected: <matcher> "
611 "(parser error: %s)", scan_data[_i].query,
612 sdb_strbuf_string(errbuf));
614 if (scan_data[_i].filter) {
615 filter = sdb_fe_parse_matcher(scan_data[_i].filter, -1, errbuf);
616 fail_unless(filter != NULL,
617 "sdb_fe_parse_matcher(%s, -1) = NULL; "
618 "expected: <matcher> (parser error: %s)",
619 scan_data[_i].filter, sdb_strbuf_string(errbuf));
620 }
622 n = 0;
623 sdb_store_scan(SDB_HOST, m, filter, scan_cb, &n);
624 fail_unless(n == scan_data[_i].expected,
625 "sdb_store_scan(HOST, matcher{%s}, filter{%s}) "
626 "found %d hosts; expected: %d", scan_data[_i].query,
627 scan_data[_i].filter, n, scan_data[_i].expected);
629 sdb_object_deref(SDB_OBJ(filter));
630 sdb_object_deref(SDB_OBJ(m));
631 sdb_strbuf_destroy(errbuf);
632 }
633 END_TEST
635 Suite *
636 core_store_lookup_suite(void)
637 {
638 Suite *s = suite_create("core::store_lookup");
639 TCase *tc;
641 tc = tcase_create("core");
642 tcase_add_checked_fixture(tc, populate, sdb_store_clear);
643 TC_ADD_LOOP_TEST(tc, cmp_name);
644 TC_ADD_LOOP_TEST(tc, cmp_attr);
645 TC_ADD_LOOP_TEST(tc, cmp_obj);
646 TC_ADD_LOOP_TEST(tc, scan);
647 tcase_add_test(tc, test_store_match_op);
648 suite_add_tcase(s, tc);
650 return s;
651 } /* core_store_lookup_suite */
653 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */