t/unit/frontend/parser_test.c

   1 /*
   2  * SysDB - t/unit/frontend/parser_test.c
   3  * Copyright (C) 2013-2015 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  */
  27
  28 #include "frontend/connection.h"
  29 #include "frontend/parser.h"
  30 #include "core/store-private.h"
  31 #include "core/object.h"
  32 #include "libsysdb_test.h"
  33
  34 #include <check.h>
  35 #include <limits.h>
  36
  37 /*
  38  * tests
  39  */
  40
  41 struct {
  42         const char *query;
  43         int len;
  44         int expected;
  45         sdb_conn_state_t expected_cmd;
  46 } parse_data[] = {
  47         /* empty commands */
  48         { NULL,                  -1, -1, 0 },
  49         { "",                    -1,  0, 0 },
  50         { ";",                   -1,  0, 0 },
  51         { ";;",                  -1,  0, 0 },
  52
  53         /* FETCH commands */
  54         { "FETCH host 'host'",   -1,  1, SDB_CONNECTION_FETCH  },
  55         { "FETCH host 'host' FILTER "
  56           "age > 60s",           -1,  1, SDB_CONNECTION_FETCH  },
  57         { "FETCH service "
  58           "'host'.'service'",    -1,  1, SDB_CONNECTION_FETCH  },
  59         { "FETCH metric "
  60           "'host'.'metric'",     -1,  1, SDB_CONNECTION_FETCH  },
  61
  62         /* LIST commands */
  63         { "LIST hosts",          -1,  1, SDB_CONNECTION_LIST   },
  64         { "LIST hosts -- foo",   -1,  1, SDB_CONNECTION_LIST   },
  65         { "LIST hosts;",         -1,  1, SDB_CONNECTION_LIST   },
  66         { "LIST hosts; INVALID", 11,  1, SDB_CONNECTION_LIST   },
  67         { "LIST hosts FILTER "
  68           "age > 60s",           -1,  1, SDB_CONNECTION_LIST   },
  69         { "LIST services",       -1,  1, SDB_CONNECTION_LIST   },
  70         { "LIST services FILTER "
  71           "age > 60s",           -1,  1, SDB_CONNECTION_LIST   },
  72         { "LIST metrics",        -1,  1, SDB_CONNECTION_LIST   },
  73         { "LIST metrics FILTER "
  74           "age > 60s",           -1,  1, SDB_CONNECTION_LIST   },
  75
  76         /* LOOKUP commands */
  77         { "LOOKUP hosts",        -1,  1, SDB_CONNECTION_LOOKUP },
  78         { "LOOKUP hosts MATCHING "
  79           "name = 'host'",       -1,  1, SDB_CONNECTION_LOOKUP },
  80         { "LOOKUP hosts MATCHING NOT "
  81           "name = 'host'",       -1,  1, SDB_CONNECTION_LOOKUP },
  82         { "LOOKUP hosts MATCHING "
  83           "name =~ 'p' AND "
  84           "ANY service =~ 'p'",  -1,  1, SDB_CONNECTION_LOOKUP },
  85         { "LOOKUP hosts MATCHING NOT "
  86           "name =~ 'p' AND "
  87           "ANY service =~ 'p'",  -1,  1, SDB_CONNECTION_LOOKUP },
  88         { "LOOKUP hosts MATCHING "
  89           "name =~ 'p' AND "
  90           "ANY service =~ 'p' OR "
  91           "ANY service =~ 'r'",  -1,  1, SDB_CONNECTION_LOOKUP },
  92         { "LOOKUP hosts MATCHING NOT "
  93           "name =~ 'p' AND "
  94           "ANY service =~ 'p' OR "
  95           "ANY service =~ 'r'",  -1,  1, SDB_CONNECTION_LOOKUP },
  96         { "LOOKUP hosts MATCHING "
  97           "name =~ 'p' "
  98           "FILTER age > 1D",    -1,   1, SDB_CONNECTION_LOOKUP },
  99         { "LOOKUP hosts MATCHING "
 100           "name =~ 'p' "
 101           "FILTER age > 1D AND "
 102           "interval < 240s" ,   -1,   1, SDB_CONNECTION_LOOKUP },
 103         { "LOOKUP hosts MATCHING "
 104           "name =~ 'p' "
 105           "FILTER NOT age>1D",  -1,   1, SDB_CONNECTION_LOOKUP },
 106         { "LOOKUP hosts MATCHING "
 107           "name =~ 'p' "
 108           "FILTER age>"
 109           "interval",           -1,   1, SDB_CONNECTION_LOOKUP },
 110         { "LOOKUP hosts MATCHING "
 111           "host.name =~ 'p'",   -1,   1, SDB_CONNECTION_LOOKUP },
 112         { "LOOKUP services",    -1,   1, SDB_CONNECTION_LOOKUP },
 113         { "LOOKUP services MATCHING ANY "
 114           "attribute =~ 'a'",   -1,   1, SDB_CONNECTION_LOOKUP },
 115         { "LOOKUP services MATCHING "
 116           "host.name = 'p'",    -1,   1, SDB_CONNECTION_LOOKUP },
 117         { "LOOKUP services MATCHING "
 118           "service.name = 'p'", -1,   1, SDB_CONNECTION_LOOKUP },
 119         { "LOOKUP metrics",     -1,   1, SDB_CONNECTION_LOOKUP },
 120         { "LOOKUP metrics MATCHING ANY "
 121           "attribute =~ 'a'",   -1,   1, SDB_CONNECTION_LOOKUP },
 122         { "LOOKUP metrics MATCHING "
 123           "host.name = 'p'",    -1,   1, SDB_CONNECTION_LOOKUP },
 124         { "LOOKUP metrics MATCHING "
 125           "metric.name = 'p'",  -1,   1, SDB_CONNECTION_LOOKUP },
 126
 127         /* TIMESERIES commands */
 128         { "TIMESERIES 'host'.'metric' "
 129           "START 2014-01-01 "
 130           "END 2014-12-31 "
 131           "23:59:59",            -1,  1, SDB_CONNECTION_TIMESERIES },
 132         { "TIMESERIES 'host'.'metric' "
 133           "START 2014-02-02 "
 134           "14:02",               -1,  1, SDB_CONNECTION_TIMESERIES },
 135         { "TIMESERIES 'host'.'metric' "
 136           "END 2014-02-02",      -1,  1, SDB_CONNECTION_TIMESERIES },
 137         { "TIMESERIES "
 138           "'host'.'metric'",     -1,  1, SDB_CONNECTION_TIMESERIES },
 139
 140         /* STORE commands */
 141         { "STORE host 'host'",   -1,  1, SDB_CONNECTION_STORE_HOST },
 142         { "STORE host 'host' "
 143           "LAST UPDATE "
 144           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_HOST },
 145         { "STORE host attribute "
 146           "'host'.'key' 123",    -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 147         { "STORE host attribute "
 148           "'host'.'key' 123 "
 149           "LAST UPDATE "
 150           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 151         { "STORE service "
 152           "'host'.'svc'",        -1,  1, SDB_CONNECTION_STORE_SERVICE },
 153         { "STORE service "
 154           "'host'.'svc' "
 155           "LAST UPDATE "
 156           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_SERVICE },
 157         { "STORE service attribute "
 158           "'host'.'svc'.'key' "
 159           "123",                 -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 160         { "STORE service attribute "
 161           "'host'.'svc'.'key' "
 162           "123 "
 163           "LAST UPDATE "
 164           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 165         { "STORE metric "
 166           "'host'.'metric'",     -1,  1, SDB_CONNECTION_STORE_METRIC },
 167         { "STORE metric "
 168           "'host'.'metric' "
 169           "LAST UPDATE "
 170           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_METRIC },
 171         { "STORE metric "
 172           "'host'.'metric' "
 173           "STORE 'typ' 'id' "
 174           "LAST UPDATE "
 175           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_METRIC },
 176         { "STORE metric attribute "
 177           "'host'.'metric'.'key' "
 178           "123",                 -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 179         { "STORE metric attribute "
 180           "'host'.'metric'.'key' "
 181           "123 "
 182           "LAST UPDATE "
 183           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 184
 185         /* string constants */
 186         { "LOOKUP hosts MATCHING "
 187           "name = ''''",         -1,  1, SDB_CONNECTION_LOOKUP },
 188         { "LOOKUP hosts MATCHING "
 189           "name = '''foo'",      -1,  1, SDB_CONNECTION_LOOKUP },
 190         { "LOOKUP hosts MATCHING "
 191           "name = 'f''oo'",      -1,  1, SDB_CONNECTION_LOOKUP },
 192         { "LOOKUP hosts MATCHING "
 193           "name = 'foo'''",      -1,  1, SDB_CONNECTION_LOOKUP },
 194         { "LOOKUP hosts MATCHING "
 195           "name = '''",          -1, -1, 0 },
 196
 197         /* numeric constants */
 198         { "LOOKUP hosts MATCHING "
 199           "attribute['foo'] = "
 200           "1234",                -1,  1, SDB_CONNECTION_LOOKUP },
 201         { "LOOKUP hosts MATCHING "
 202           "attribute['foo'] != "
 203           "+234",                -1,  1, SDB_CONNECTION_LOOKUP },
 204         { "LOOKUP hosts MATCHING "
 205           "attribute['foo'] < "
 206           "-234",                -1,  1, SDB_CONNECTION_LOOKUP },
 207         { "LOOKUP hosts MATCHING "
 208           "attribute['foo'] > "
 209           "12.4",                -1,  1, SDB_CONNECTION_LOOKUP },
 210         { "LOOKUP hosts MATCHING "
 211           "attribute['foo'] <= "
 212           "12. + .3",            -1,  1, SDB_CONNECTION_LOOKUP },
 213         { "LOOKUP hosts MATCHING "
 214           "attribute['foo'] <= "
 215           "'f' || 'oo'",         -1,  1, SDB_CONNECTION_LOOKUP },
 216         { "LOOKUP hosts MATCHING "
 217           "attribute['foo'] >= "
 218           ".4",                  -1,  1, SDB_CONNECTION_LOOKUP },
 219         { "LOOKUP hosts MATCHING "
 220           "attribute['foo'] = "
 221           "+12e3",               -1,  1, SDB_CONNECTION_LOOKUP },
 222         { "LOOKUP hosts MATCHING "
 223           "attribute['foo'] = "
 224           "+12e-3",              -1,  1, SDB_CONNECTION_LOOKUP },
 225         { "LOOKUP hosts MATCHING "
 226           "attribute['foo'] = "
 227           "-12e+3",              -1,  1, SDB_CONNECTION_LOOKUP },
 228
 229         /* date, time, interval constants */
 230         { "LOOKUP hosts MATCHING "
 231           "attribute['foo'] = "
 232           "1 Y 42D",             -1,  1, SDB_CONNECTION_LOOKUP },
 233         { "LOOKUP hosts MATCHING "
 234           "attribute['foo'] = "
 235           "1s 42D",              -1,  1, SDB_CONNECTION_LOOKUP },
 236         /*
 237          * TODO: Something like 1Y42D should work as well but it doesn't since
 238          * the scanner will tokenize it into {digit}{identifier} :-/
 239          *
 240         { "LOOKUP hosts MATCHING "
 241           "attribute['foo'] = "
 242           "1Y42D",               -1,  1, SDB_CONNECTION_LOOKUP },
 243          */
 244
 245         /* array constants */
 246         { "LOOKUP hosts MATCHING "
 247           "backend = ['foo']",   -1,  1, SDB_CONNECTION_LOOKUP },
 248         { "LOOKUP hosts MATCHING "
 249           "backend = ['a','b']", -1,  1, SDB_CONNECTION_LOOKUP },
 250
 251         /* valid operand types */
 252         { "LOOKUP hosts MATCHING "
 253           "age * 1 > 0s",        -1,  1, SDB_CONNECTION_LOOKUP },
 254         { "LOOKUP hosts MATCHING "
 255           "age / 1 > 0s",        -1,  1, SDB_CONNECTION_LOOKUP },
 256         { "LOOKUP hosts MATCHING "
 257           "name > ''",           -1,  1, SDB_CONNECTION_LOOKUP },
 258         { "LOOKUP hosts MATCHING "
 259           "name >= ''",          -1,  1, SDB_CONNECTION_LOOKUP },
 260         { "LOOKUP hosts MATCHING "
 261           "name != ''",          -1,  1, SDB_CONNECTION_LOOKUP },
 262         { "LOOKUP hosts MATCHING "
 263           "name = ''",           -1,  1, SDB_CONNECTION_LOOKUP },
 264         { "LOOKUP hosts MATCHING "
 265           "name <= ''",          -1,  1, SDB_CONNECTION_LOOKUP },
 266         { "LOOKUP hosts MATCHING "
 267           "name < ''",           -1,  1, SDB_CONNECTION_LOOKUP },
 268
 269         /* NULL */
 270         { "LOOKUP hosts MATCHING "
 271           "attribute['foo'] "
 272           "IS NULL",             -1,  1, SDB_CONNECTION_LOOKUP },
 273         { "LOOKUP hosts MATCHING "
 274           "attribute['foo'] "
 275           "IS NOT NULL",         -1,  1, SDB_CONNECTION_LOOKUP },
 276         { "LOOKUP hosts MATCHING "
 277           "NOT attribute['foo'] "
 278           "IS NULL",             -1,  1, SDB_CONNECTION_LOOKUP },
 279         { "LOOKUP hosts MATCHING "
 280           "ANY service IS NULL", -1, -1, 0 },
 281
 282         /* invalid numeric constants */
 283         { "LOOKUP hosts MATCHING "
 284           "attribute['foo'] = "
 285           "+-12e+3",             -1, -1, 0 },
 286         { "LOOKUP hosts MATCHING "
 287           "attribute['foo'] = "
 288           "-12e-+3",             -1, -1, 0 },
 289         { "LOOKUP hosts MATCHING "
 290           "attribute['foo'] = "
 291           "e+3",                 -1, -1, 0 },
 292         { "LOOKUP hosts MATCHING "
 293           "attribute['foo'] = "
 294           "3e",                  -1, -1, 0 },
 295         /* following SQL standard, we don't support hex numbers */
 296         { "LOOKUP hosts MATCHING "
 297           "attribute['foo'] = "
 298           "0x12",                -1, -1, 0 },
 299
 300         /* invalid expressions */
 301         { "LOOKUP hosts MATCHING "
 302           "attribute['foo'] = "
 303           "1.23 + 'foo'",        -1, -1, 0 },
 304         { "LOOKUP hosts MATCHING "
 305           "attr['foo'] = 1.23",  -1, -1, 0 },
 306         { "LOOKUP hosts MATCHING "
 307           "attr['foo'] IS NULL", -1, -1, 0 },
 308
 309         /* type mismatches */
 310         { "LOOKUP hosts MATCHING "
 311           "age > 0",             -1, -1, 0 },
 312         { "LOOKUP hosts MATCHING "
 313           "age >= 0",            -1, -1, 0 },
 314         { "LOOKUP hosts MATCHING "
 315           "age = 0",             -1, -1, 0 },
 316         { "LOOKUP hosts MATCHING "
 317           "age != 0",            -1, -1, 0 },
 318         { "LOOKUP hosts MATCHING "
 319           "age <= 0",            -1, -1, 0 },
 320         { "LOOKUP hosts MATCHING "
 321           "age < 0",             -1, -1, 0 },
 322         { "LOOKUP hosts MATCHING "
 323           "age + 1 > 0s",        -1, -1, 0 },
 324         { "LOOKUP hosts MATCHING "
 325           "age - 1 > 0s",        -1, -1, 0 },
 326         /* datetime <mul/div> integer is allowed */
 327         { "LOOKUP hosts MATCHING "
 328           "age || 1 > 0s",       -1, -1, 0 },
 329         { "LOOKUP hosts MATCHING "
 330           "name + 1 = ''",       -1, -1, 0 },
 331         { "LOOKUP hosts MATCHING "
 332           "name - 1 = ''",       -1, -1, 0 },
 333         { "LOOKUP hosts MATCHING "
 334           "name * 1 = ''",       -1, -1, 0 },
 335         { "LOOKUP hosts MATCHING "
 336           "name / 1 = ''",       -1, -1, 0 },
 337         { "LOOKUP hosts MATCHING "
 338           "name % 1 = ''",       -1, -1, 0 },
 339
 340         /* comments */
 341         { "/* some comment */",  -1,  0, 0 },
 342         { "-- another comment",  -1,  0, 0 },
 343
 344         /* syntax errors */
 345         { "INVALID",             -1, -1, 0 },
 346         { "FETCH host",          -1, -1, 0 },
 347         { "FETCH 'host'",        -1, -1, 0 },
 348         { "LIST hosts; INVALID", -1, -1, 0 },
 349         { "/* some incomplete",  -1, -1, 0 },
 350
 351         /* invalid LIST commands */
 352         { "LIST",                -1, -1, 0 },
 353         { "LIST foo",            -1, -1, 0 },
 354         { "LIST hosts MATCHING "
 355           "name = 'host'",       -1, -1, 0 },
 356         { "LIST foo FILTER "
 357           "age > 60s",           -1, -1, 0 },
 358
 359         /* invalid FETCH commands */
 360         { "FETCH host 'host' MATCHING "
 361           "name = 'host'",       -1, -1, 0 },
 362         { "FETCH service 'host'",-1, -1, 0 },
 363         { "FETCH metric 'host'", -1, -1, 0 },
 364         { "FETCH host "
 365           "'host'.'localhost'",  -1, -1, 0 },
 366         { "FETCH foo 'host'",    -1, -1, 0 },
 367         { "FETCH foo 'host' FILTER "
 368           "age > 60s",           -1, -1, 0 },
 369
 370         /* invalid LOOKUP commands */
 371         { "LOOKUP foo",          -1, -1, 0 },
 372         { "LOOKUP foo MATCHING "
 373           "name = 'host'",       -1, -1, 0 },
 374         { "LOOKUP foo FILTER "
 375           "age > 60s",           -1, -1, 0 },
 376         { "LOOKUP foo MATCHING "
 377           "name = 'host' FILTER "
 378           "age > 60s",           -1, -1, 0 },
 379         { "LOOKUP hosts MATCHING "
 380           "attribute['foo'] <= "
 381           "f || 'oo'",           -1, -1, 0 },
 382         { "LOOKUP hosts MATCHING "
 383           "attribute['foo'] <= "
 384           "'f' || oo",           -1, -1, 0 },
 385         { "LOOKUP hosts MATCHING "
 386           "ANY host = 'host'",   -1, -1, 0 },
 387         { "LOOKUP hosts MATCHING "
 388           "service.name = 's'",  -1, -1, 0 },
 389         { "LOOKUP services MATCHING "
 390           "ANY host = 'host'",   -1, -1, 0 },
 391         { "LOOKUP services MATCHING "
 392           "ANY service = 'svc'", -1, -1, 0 },
 393         { "LOOKUP services MATCHING "
 394           "ANY metric = 'm'",    -1, -1, 0 },
 395         { "LOOKUP services MATCHING "
 396           "metric.name = 'm'",   -1, -1, 0 },
 397         { "LOOKUP metrics MATCHING "
 398           "ANY host = 'host'",   -1, -1, 0 },
 399         { "LOOKUP metrics MATCHING "
 400           "ANY service = 'svc'", -1, -1, 0 },
 401         { "LOOKUP metrics MATCHING "
 402           "ANY metric = 'm'",    -1, -1, 0 },
 403         { "LOOKUP metrics MATCHING "
 404           "service.name = 'm'",  -1, -1, 0 },
 405
 406         /* invalid STORE commands */
 407         { "STORE host "
 408           "'obj'.'host'",        -1, -1, 0 },
 409         { "STORE host attribute "
 410           ".'key' 123",          -1, -1, 0 },
 411         { "STORE host attribute "
 412           "'o'.'h'.'key' 123",   -1, -1, 0 },
 413         { "STORE service 'svc'", -1, -1, 0 },
 414         { "STORE service "
 415           "'host'.'svc' "
 416           "STORE 'typ' 'id' "
 417           "LAST UPDATE "
 418           "2015-02-01",          -1, -1, 0 },
 419         { "STORE service attribute "
 420           "'svc'.'key' 123",     -1, -1, 0 },
 421         { "STORE metric 'm'",    -1, -1, 0 },
 422         { "STORE metric "
 423           "'host'.'metric' "
 424           "STORE 'typ'.'id' "
 425           "LAST UPDATE "
 426           "2015-02-01",          -1, -1, 0 },
 427         { "STORE metric attribute "
 428           "'metric'.'key' 123",  -1, -1, 0 },
 429 };
 430
 431 START_TEST(test_parse)
 432 {
 433         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 434         sdb_llist_t *check;
 435         sdb_object_t *obj;
 436         _Bool ok;
 437
 438         check = sdb_fe_parse(parse_data[_i].query,
 439                         parse_data[_i].len, errbuf);
 440         if (parse_data[_i].expected < 0)
 441                 ok = check == 0;
 442         else
 443                 ok = sdb_llist_len(check) == (size_t)parse_data[_i].expected;
 444
 445         fail_unless(ok, "sdb_fe_parse(%s) = %p (len: %zu); expected: %d "
 446                         "(parser error: %s)", parse_data[_i].query, check,
 447                         sdb_llist_len(check), parse_data[_i].expected,
 448                         sdb_strbuf_string(errbuf));
 449
 450         if (! check) {
 451                 sdb_strbuf_destroy(errbuf);
 452                 return;
 453         }
 454
 455         if ((! parse_data[_i].expected_cmd)
 456                         || (parse_data[_i].expected <= 0)) {
 457                 sdb_llist_destroy(check);
 458                 sdb_strbuf_destroy(errbuf);
 459                 return;
 460         }
 461
 462         obj = sdb_llist_get(check, 0);
 463         fail_unless(SDB_CONN_NODE(obj)->cmd == parse_data[_i].expected_cmd,
 464                         "sdb_fe_parse(%s)->cmd = %i; expected: %d",
 465                         parse_data[_i].query, SDB_CONN_NODE(obj)->cmd,
 466                         parse_data[_i].expected_cmd);
 467
 468         sdb_object_deref(obj);
 469         sdb_llist_destroy(check);
 470         sdb_strbuf_destroy(errbuf);
 471 }
 472 END_TEST
 473
 474 struct {
 475         const char *expr;
 476         int len;
 477         int expected;
 478 } parse_matcher_data[] = {
 479         /* empty expressions */
 480         { NULL,                           -1, -1 },
 481         { "",                             -1, -1 },
 482
 483         /* match hosts by name */
 484         { "name < 'localhost'",           -1,  MATCHER_LT },
 485         { "name <= 'localhost'",          -1,  MATCHER_LE },
 486         { "name = 'localhost'",           -1,  MATCHER_EQ },
 487         { "name != 'localhost'",          -1,  MATCHER_NE },
 488         { "name >= 'localhost'",          -1,  MATCHER_GE },
 489         { "name > 'localhost'",           -1,  MATCHER_GT },
 490         { "name =~ 'host'",               -1,  MATCHER_REGEX },
 491         { "name !~ 'host'",               -1,  MATCHER_NREGEX },
 492         { "name = 'localhost' -- foo",    -1,  MATCHER_EQ },
 493         { "name = 'host' <garbage>",      13,  MATCHER_EQ },
 494         { "name &^ 'localhost'",          -1,  -1 },
 495         /* match by backend */
 496         { "ANY backend < 'be'",           -1,  MATCHER_ANY },
 497         { "ANY backend <= 'be'",          -1,  MATCHER_ANY },
 498         { "ANY backend = 'be'",           -1,  MATCHER_ANY },
 499         { "ANY backend != 'be'",          -1,  MATCHER_ANY },
 500         { "ANY backend >= 'be'",          -1,  MATCHER_ANY },
 501         { "ANY backend > 'be'",           -1,  MATCHER_ANY },
 502         { "ALL backend < 'be'",           -1,  MATCHER_ALL },
 503         { "ALL backend <= 'be'",          -1,  MATCHER_ALL },
 504         { "ALL backend = 'be'",           -1,  MATCHER_ALL },
 505         { "ALL backend != 'be'",          -1,  MATCHER_ALL },
 506         { "ALL backend >= 'be'",          -1,  MATCHER_ALL },
 507         { "ALL backend > 'be'",           -1,  MATCHER_ALL },
 508         { "ANY backend &^ 'be'",          -1,  -1 },
 509         /* match hosts by service */
 510         { "ANY service < 'name'",         -1,  MATCHER_ANY },
 511         { "ANY service <= 'name'",        -1,  MATCHER_ANY },
 512         { "ANY service = 'name'",         -1,  MATCHER_ANY },
 513         { "ANY service != 'name'",        -1,  MATCHER_ANY },
 514         { "ANY service >= 'name'",        -1,  MATCHER_ANY },
 515         { "ANY service > 'name'",         -1,  MATCHER_ANY },
 516         { "ANY service =~ 'pattern'",     -1,  MATCHER_ANY },
 517         { "ANY service !~ 'pattern'",     -1,  MATCHER_ANY },
 518         { "ANY service &^ 'name'",        -1,  -1 },
 519         { "ALL service < 'name'",         -1,  MATCHER_ALL },
 520         { "ALL service <= 'name'",        -1,  MATCHER_ALL },
 521         { "ALL service = 'name'",         -1,  MATCHER_ALL },
 522         { "ALL service != 'name'",        -1,  MATCHER_ALL },
 523         { "ALL service >= 'name'",        -1,  MATCHER_ALL },
 524         { "ALL service > 'name'",         -1,  MATCHER_ALL },
 525         { "ALL service =~ 'pattern'",     -1,  MATCHER_ALL },
 526         { "ALL service !~ 'pattern'",     -1,  MATCHER_ALL },
 527         { "ALL service &^ 'name'",        -1,  -1 },
 528         /* match hosts by metric */
 529         { "ANY metric < 'name'",          -1,  MATCHER_ANY },
 530         { "ANY metric <= 'name'",         -1,  MATCHER_ANY },
 531         { "ANY metric = 'name'",          -1,  MATCHER_ANY },
 532         { "ANY metric != 'name'",         -1,  MATCHER_ANY },
 533         { "ANY metric >= 'name'",         -1,  MATCHER_ANY },
 534         { "ANY metric > 'name'",          -1,  MATCHER_ANY },
 535         { "ANY metric =~ 'pattern'",      -1,  MATCHER_ANY },
 536         { "ANY metric !~ 'pattern'",      -1,  MATCHER_ANY },
 537         { "ANY metric &^ 'pattern'",      -1,  -1 },
 538         { "ALL metric < 'name'",          -1,  MATCHER_ALL },
 539         { "ALL metric <= 'name'",         -1,  MATCHER_ALL },
 540         { "ALL metric = 'name'",          -1,  MATCHER_ALL },
 541         { "ALL metric != 'name'",         -1,  MATCHER_ALL },
 542         { "ALL metric >= 'name'",         -1,  MATCHER_ALL },
 543         { "ALL metric > 'name'",          -1,  MATCHER_ALL },
 544         { "ALL metric =~ 'pattern'",      -1,  MATCHER_ALL },
 545         { "ALL metric !~ 'pattern'",      -1,  MATCHER_ALL },
 546         { "ALL metric &^ 'pattern'",      -1,  -1 },
 547         /* match hosts by attribute */
 548         { "ANY attribute < 'name'",       -1,  MATCHER_ANY },
 549         { "ANY attribute <= 'name'",      -1,  MATCHER_ANY },
 550         { "ANY attribute = 'name'",       -1,  MATCHER_ANY },
 551         { "ANY attribute != 'name'",      -1,  MATCHER_ANY },
 552         { "ANY attribute >= 'name'",      -1,  MATCHER_ANY },
 553         { "ANY attribute > 'name'",       -1,  MATCHER_ANY },
 554         { "ANY attribute =~ 'pattern'",   -1,  MATCHER_ANY },
 555         { "ANY attribute !~ 'pattern'",   -1,  MATCHER_ANY },
 556         { "ANY attribute &^ 'pattern'",   -1,  -1 },
 557         { "ALL attribute < 'name'",       -1,  MATCHER_ALL },
 558         { "ALL attribute <= 'name'",      -1,  MATCHER_ALL },
 559         { "ALL attribute = 'name'",       -1,  MATCHER_ALL },
 560         { "ALL attribute != 'name'",      -1,  MATCHER_ALL },
 561         { "ALL attribute >= 'name'",      -1,  MATCHER_ALL },
 562         { "ALL attribute > 'name'",       -1,  MATCHER_ALL },
 563         { "ALL attribute =~ 'pattern'",   -1,  MATCHER_ALL },
 564         { "ALL attribute !~ 'pattern'",   -1,  MATCHER_ALL },
 565         { "ALL attribute &^ 'pattern'",   -1,  -1 },
 566         /* composite expressions */
 567         { "name =~ 'pattern' AND "
 568           "ANY service =~ 'pattern'",     -1,  MATCHER_AND },
 569         { "name =~ 'pattern' OR "
 570           "ANY service =~ 'pattern'",     -1,  MATCHER_OR },
 571         { "NOT name = 'host'",            -1,  MATCHER_NOT },
 572         /* numeric expressions */
 573         { "attribute['foo'] < 123",       -1,  MATCHER_LT },
 574         { "attribute['foo'] <= 123",      -1,  MATCHER_LE },
 575         { "attribute['foo'] = 123",       -1,  MATCHER_EQ },
 576         { "attribute['foo'] >= 123",      -1,  MATCHER_GE },
 577         { "attribute['foo'] > 123",       -1,  MATCHER_GT },
 578         /* datetime expressions */
 579         { "attribute['foo'] = "
 580           "2014-08-16",                   -1,  MATCHER_EQ },
 581         { "attribute['foo'] = "
 582           "17:23",                        -1,  MATCHER_EQ },
 583         { "attribute['foo'] = "
 584           "17:23:53",                     -1,  MATCHER_EQ },
 585         { "attribute['foo'] = "
 586           "17:23:53.123",                 -1,  MATCHER_EQ },
 587         { "attribute['foo'] = "
 588           "17:23:53.123456789",           -1,  MATCHER_EQ },
 589         { "attribute['foo'] = "
 590           "2014-08-16 17:23",             -1,  MATCHER_EQ },
 591         { "attribute['foo'] = "
 592           "2014-08-16 17:23:53",          -1,  MATCHER_EQ },
 593         /* NULL; while this is an implementation detail,
 594          * IS NULL currently maps to an equality matcher */
 595         { "attribute['foo'] IS NULL",     -1,  MATCHER_ISNULL },
 596         { "attribute['foo'] IS NOT NULL", -1,  MATCHER_ISNNULL },
 597         /* array expressions */
 598         { "backend < ['a']",              -1,  MATCHER_LT },
 599         { "backend <= ['a']",             -1,  MATCHER_LE },
 600         { "backend = ['a']",              -1,  MATCHER_EQ },
 601         { "backend != ['a']",             -1,  MATCHER_NE },
 602         { "backend >= ['a']",             -1,  MATCHER_GE },
 603         { "backend > ['a']",              -1,  MATCHER_GT },
 604         { "backend &^ ['a']",             -1,  -1 },
 605
 606         /* object field matchers */
 607         { "name < 'a'",                   -1,  MATCHER_LT },
 608         { "name <= 'a'",                  -1,  MATCHER_LE },
 609         { "name = 'a'",                   -1,  MATCHER_EQ },
 610         { "name != 'a'",                  -1,  MATCHER_NE },
 611         { "name >= 'a'",                  -1,  MATCHER_GE },
 612         { "name > 'a'",                   -1,  MATCHER_GT },
 613         { "last_update < 2014-10-01",     -1,  MATCHER_LT },
 614         { "last_update <= 2014-10-01",    -1,  MATCHER_LE },
 615         { "last_update = 2014-10-01",     -1,  MATCHER_EQ },
 616         { "last_update != 2014-10-01",    -1,  MATCHER_NE },
 617         { "last_update >= 2014-10-01",    -1,  MATCHER_GE },
 618         { "last_update > 2014-10-01",     -1,  MATCHER_GT },
 619         { "Last_Update >= 24D",           -1,  MATCHER_GE },
 620         { "age < 20s",                    -1,  MATCHER_LT },
 621         { "age <= 20s",                   -1,  MATCHER_LE },
 622         { "age = 20s",                    -1,  MATCHER_EQ },
 623         { "age != 20s",                   -1,  MATCHER_NE },
 624         { "age >= 20s",                   -1,  MATCHER_GE },
 625         { "age > 20s",                    -1,  MATCHER_GT },
 626         { "AGE <= 1m",                    -1,  MATCHER_LE },
 627         { "age > 1M",                     -1,  MATCHER_GT },
 628         { "age != 20Y",                   -1,  MATCHER_NE },
 629         { "age <= 2 * interval",          -1,  MATCHER_LE },
 630         { "interval < 20s",               -1,  MATCHER_LT },
 631         { "interval <= 20s",              -1,  MATCHER_LE },
 632         { "interval = 20s",               -1,  MATCHER_EQ },
 633         { "interval != 20s",              -1,  MATCHER_NE },
 634         { "interval >= 20s",              -1,  MATCHER_GE },
 635         { "interval > 20s",               -1,  MATCHER_GT },
 636         { "'be' IN backend",              -1,  MATCHER_IN },
 637
 638         /* check operator precedence */
 639         { "name = 'name' OR "
 640           "ANY service = 'name' AND "
 641           "ANY attribute = 'name' OR "
 642           "attribute['foo'] = 'bar'",     -1,  MATCHER_OR },
 643         { "name = 'name' AND "
 644           "ANY service = 'name' AND "
 645           "ANY attribute = 'name' OR "
 646           "attribute['foo'] = 'bar'",     -1,  MATCHER_OR },
 647         { "name = 'name' AND "
 648           "ANY service = 'name' OR "
 649           "ANY attribute = 'name' AND "
 650           "attribute['foo'] = 'bar'",     -1,  MATCHER_OR },
 651         { "(name = 'name' OR "
 652           "ANY service = 'name') AND "
 653           "(ANY attribute = 'name' OR "
 654           "attribute['foo'] = 'bar')",    -1,  MATCHER_AND },
 655         { "NOT name = 'name' OR "
 656           "ANY service = 'name'",         -1,  MATCHER_OR },
 657         { "NOT name = 'name' OR "
 658           "NOT ANY service = 'name'",     -1,  MATCHER_OR },
 659         { "NOT (name = 'name' OR "
 660           "NOT ANY service = 'name')",    -1,  MATCHER_NOT },
 661
 662         /* syntax errors */
 663         { "LIST",                         -1, -1 },
 664         { "foo &^ bar",                   -1, -1 },
 665         { "invalid",                      -1, -1 },
 666 };
 667
 668 START_TEST(test_parse_matcher)
 669 {
 670         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 671         sdb_store_matcher_t *m;
 672
 673         m = sdb_fe_parse_matcher(parse_matcher_data[_i].expr,
 674                         parse_matcher_data[_i].len, errbuf);
 675
 676         if (parse_matcher_data[_i].expected < 0) {
 677                 fail_unless(m == NULL,
 678                                 "sdb_fe_parse_matcher(%s) = %p; expected: NULL",
 679                                 parse_matcher_data[_i].expr, m);
 680                 sdb_object_deref(SDB_OBJ(m));
 681                 sdb_strbuf_destroy(errbuf);
 682                 return;
 683         }
 684
 685         fail_unless(m != NULL, "sdb_fe_parse_matcher(%s) = NULL; "
 686                         "expected: <matcher> (parser error: %s)",
 687                         parse_matcher_data[_i].expr, sdb_strbuf_string(errbuf));
 688         fail_unless(M(m)->type == parse_matcher_data[_i].expected,
 689                         "sdb_fe_parse_matcher(%s) returned matcher of type %d; "
 690                         "expected: %d", parse_matcher_data[_i].expr, M(m)->type,
 691                         parse_matcher_data[_i].expected);
 692
 693         sdb_object_deref(SDB_OBJ(m));
 694         sdb_strbuf_destroy(errbuf);
 695 }
 696 END_TEST
 697
 698 struct {
 699         const char *expr;
 700         int len;
 701         int expected;
 702 } parse_expr_data[] = {
 703         /* empty expressions */
 704         { NULL,                   -1, INT_MAX },
 705         { "",                     -1, INT_MAX },
 706
 707         /* constant expressions */
 708         { "'localhost'",          -1, 0 },
 709         { "123",                  -1, 0 },
 710         { "2014-08-16",           -1, 0 },
 711         { "17:23",                -1, 0 },
 712         { "17:23:53",             -1, 0 },
 713         { "17:23:53.123",         -1, 0 },
 714         { "17:23:53.123456789",   -1, 0 },
 715         { "2014-08-16 17:23",     -1, 0 },
 716         { "2014-08-16 17:23:53",  -1, 0 },
 717         { "10s",                  -1, 0 },
 718         { "60m",                  -1, 0 },
 719         { "10Y 24D 1h",           -1, 0 },
 720
 721         { "123 + 456",            -1, 0 },
 722         { "'foo' || 'bar'",       -1, 0 },
 723         { "456 - 123",            -1, 0 },
 724         { "1.2 * 3.4",            -1, 0 },
 725         { "1.2 / 3.4",            -1, 0 },
 726         { "5 % 2",                -1, 0 },
 727
 728         /* queryable fields */
 729         { "last_update",          -1, FIELD_VALUE },
 730         { "AGE",                  -1, FIELD_VALUE },
 731         { "interval",             -1, FIELD_VALUE },
 732         { "Last_Update",          -1, FIELD_VALUE },
 733         { "backend",              -1, FIELD_VALUE },
 734
 735         /* attributes */
 736         { "attribute['foo']",     -1, ATTR_VALUE },
 737
 738         /* arithmetic expressions */
 739         { "age + age",            -1, SDB_DATA_ADD },
 740         { "age - age",            -1, SDB_DATA_SUB },
 741         { "age * age",            -1, SDB_DATA_MUL },
 742         { "age / age",            -1, SDB_DATA_DIV },
 743         { "age % age",            -1, SDB_DATA_MOD },
 744         { "age || age",           -1, SDB_DATA_CONCAT },
 745
 746         /* operator precedence */
 747         { "age + age * age",      -1, SDB_DATA_ADD },
 748         { "age * age + age",      -1, SDB_DATA_ADD },
 749         { "age + age - age",      -1, SDB_DATA_SUB },
 750         { "age - age + age",      -1, SDB_DATA_ADD },
 751         { "(age + age) * age",    -1, SDB_DATA_MUL },
 752         { "age + (age * age)",    -1, SDB_DATA_ADD },
 753
 754         /* syntax errors */
 755         { "LIST",                 -1, INT_MAX },
 756         { "foo &^ bar",           -1, INT_MAX },
 757         { "invalid",              -1, INT_MAX },
 758 };
 759
 760 START_TEST(test_parse_expr)
 761 {
 762         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 763         sdb_store_expr_t *e;
 764
 765         e = sdb_fe_parse_expr(parse_expr_data[_i].expr,
 766                         parse_expr_data[_i].len, errbuf);
 767
 768         if (parse_expr_data[_i].expected == INT_MAX) {
 769                 fail_unless(e == NULL,
 770                                 "sdb_fe_parse_expr(%s) = %p; expected: NULL",
 771                                 parse_expr_data[_i].expr, e);
 772                 sdb_object_deref(SDB_OBJ(e));
 773                 sdb_strbuf_destroy(errbuf);
 774                 return;
 775         }
 776
 777         fail_unless(e != NULL, "sdb_fe_parse_expr(%s) = NULL; "
 778                         "expected: <expr> (parser error: %s)",
 779                         parse_expr_data[_i].expr, sdb_strbuf_string(errbuf));
 780         fail_unless(e->type == parse_expr_data[_i].expected,
 781                         "sdb_fe_parse_expr(%s) returned expression of type %d; "
 782                         "expected: %d", parse_expr_data[_i].expr, e->type,
 783                         parse_expr_data[_i].expected);
 784
 785         sdb_object_deref(SDB_OBJ(e));
 786         sdb_strbuf_destroy(errbuf);
 787 }
 788 END_TEST
 789
 790 Suite *
 791 fe_parser_suite(void)
 792 {
 793         Suite *s = suite_create("frontend::parser");
 794         TCase *tc;
 795
 796         tc = tcase_create("core");
 797         TC_ADD_LOOP_TEST(tc, parse);
 798         TC_ADD_LOOP_TEST(tc, parse_matcher);
 799         TC_ADD_LOOP_TEST(tc, parse_expr);
 800         suite_add_tcase(s, tc);
 801
 802         return s;
 803 } /* util_parser_suite */
 804
 805 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 806