git.notmuchmail.org Git - notmuch/blob - test/T590-libconfig.sh

   1 #!/usr/bin/env bash
   2 test_description="library config API"
   3
   4 . $(dirname "$0")/test-lib.sh || exit 1
   5
   6 add_email_corpus
   7
   8 _libconfig_sanitize() {
   9     ${NOTMUCH_PYTHON} /dev/fd/3 3<<'EOF'
  10 import os, sys, pwd, socket
  11
  12 pw = pwd.getpwuid(os.getuid())
  13 user = pw.pw_name
  14 name = pw.pw_gecos.partition(",")[0]
  15
  16 for l in sys.stdin:
  17     if l[:4] == "08: ":
  18         l = l.replace(user, "USERNAME", 1)
  19     elif l[:4] == "10: ":
  20         l = l.replace("'" + name, "'USER_FULL_NAME", 1)
  21     sys.stdout.write(l)
  22 EOF
  23 }
  24
  25 cat <<EOF > c_head
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <notmuch-test.h>
  29
  30 int main (int argc, char** argv)
  31 {
  32    notmuch_database_t *db;
  33    char *val;
  34    notmuch_status_t stat;
  35    char *msg = NULL;
  36
  37    for (int i = 1; i < argc; i++)
  38       if (strcmp (argv[i], "%NULL%") == 0) argv[i] = NULL;
  39
  40    stat = notmuch_database_open_with_config (argv[1],
  41                                               NOTMUCH_DATABASE_MODE_READ_WRITE,
  42                                               argv[2],
  43                                               argv[3],
  44                                               &db,
  45                                               &msg);
  46    if (stat != NOTMUCH_STATUS_SUCCESS) {
  47      fprintf (stderr, "error opening database\n%s\n%s\n", notmuch_status_to_string (stat), msg ? msg : "");
  48      exit (1);
  49    }
  50 EOF
  51
  52 cat <<EOF > c_tail
  53    EXPECT0(notmuch_database_destroy(db));
  54 }
  55 EOF
  56
  57 test_begin_subtest "notmuch_database_{set,get}_config"
  58 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG}
  59 {
  60    EXPECT0(notmuch_database_set_config (db, "test.key1", "testvalue1"));
  61    EXPECT0(notmuch_database_set_config (db, "test.key2", "testvalue2"));
  62    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
  63    printf("test.key1 = %s\n", val);
  64    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
  65    printf("test.key2 = %s\n", val);
  66 }
  67 EOF
  68 cat <<'EOF' >EXPECTED
  69 == stdout ==
  70 test.key1 = testvalue1
  71 test.key2 = testvalue2
  72 == stderr ==
  73 EOF
  74 test_expect_equal_file EXPECTED OUTPUT
  75
  76
  77 test_begin_subtest "notmuch_database_get_config_list: empty list"
  78 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
  79 {
  80    notmuch_config_list_t *list;
  81    EXPECT0(notmuch_database_get_config_list (db, "nonexistent", &list));
  82    printf("valid = %d\n", notmuch_config_list_valid (list));
  83    notmuch_config_list_destroy (list);
  84 }
  85 EOF
  86 cat <<'EOF' >EXPECTED
  87 == stdout ==
  88 valid = 0
  89 == stderr ==
  90 EOF
  91 test_expect_equal_file EXPECTED OUTPUT
  92
  93 test_begin_subtest "notmuch_database_get_config_list: closed db"
  94 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
  95 {
  96    notmuch_config_list_t *list;
  97    EXPECT0(notmuch_database_close (db));
  98    stat = notmuch_database_get_config_list (db, "nonexistent", &list);
  99    printf("%d\n", stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 100 }
 101 EOF
 102 cat <<'EOF' >EXPECTED
 103 == stdout ==
 104 1
 105 == stderr ==
 106 EOF
 107 test_expect_equal_file EXPECTED OUTPUT
 108
 109 test_begin_subtest "notmuch_database_get_config_list: all pairs"
 110 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 111 {
 112    notmuch_config_list_t *list;
 113    EXPECT0(notmuch_database_set_config (db, "zzzafter", "afterval"));
 114    EXPECT0(notmuch_database_set_config (db, "aaabefore", "beforeval"));
 115    EXPECT0(notmuch_database_get_config_list (db, "", &list));
 116    for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
 117       printf("%s %s\n", notmuch_config_list_key (list), notmuch_config_list_value(list));
 118    }
 119    notmuch_config_list_destroy (list);
 120 }
 121 EOF
 122 cat <<'EOF' >EXPECTED
 123 == stdout ==
 124 aaabefore beforeval
 125 test.key1 testvalue1
 126 test.key2 testvalue2
 127 zzzafter afterval
 128 == stderr ==
 129 EOF
 130 test_expect_equal_file EXPECTED OUTPUT
 131
 132 test_begin_subtest "notmuch_database_get_config_list: all pairs (closed db)"
 133 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 134 {
 135    notmuch_config_list_t *list;
 136    EXPECT0(notmuch_database_get_config_list (db, "", &list));
 137    EXPECT0(notmuch_database_close (db));
 138    for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
 139       printf("%s %d\n", notmuch_config_list_key (list), NULL == notmuch_config_list_value(list));
 140    }
 141    notmuch_config_list_destroy (list);
 142 }
 143 EOF
 144 cat <<'EOF' >EXPECTED
 145 == stdout ==
 146 aaabefore 1
 147 test.key1 1
 148 test.key2 1
 149 zzzafter 1
 150 == stderr ==
 151 EOF
 152 test_expect_equal_file EXPECTED OUTPUT
 153
 154 test_begin_subtest "notmuch_database_get_config_list: one prefix"
 155 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 156 {
 157    notmuch_config_list_t *list;
 158    EXPECT0(notmuch_database_get_config_list (db, "test.key", &list));
 159    for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
 160       printf("%s %s\n", notmuch_config_list_key (list), notmuch_config_list_value(list));
 161    }
 162    notmuch_config_list_destroy (list);
 163 }
 164 EOF
 165 cat <<'EOF' >EXPECTED
 166 == stdout ==
 167 test.key1 testvalue1
 168 test.key2 testvalue2
 169 == stderr ==
 170 EOF
 171 test_expect_equal_file EXPECTED OUTPUT
 172
 173 test_begin_subtest "dump config"
 174 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 175 {
 176     EXPECT0(notmuch_database_set_config (db, "key with spaces", "value, with, spaces!"));
 177 }
 178 EOF
 179 notmuch dump --include=config >OUTPUT
 180 cat <<'EOF' >EXPECTED
 181 #notmuch-dump batch-tag:3 config
 182 #@ aaabefore beforeval
 183 #@ key%20with%20spaces value,%20with,%20spaces%21
 184 #@ test.key1 testvalue1
 185 #@ test.key2 testvalue2
 186 #@ zzzafter afterval
 187 EOF
 188 test_expect_equal_file EXPECTED OUTPUT
 189
 190 test_begin_subtest "restore config"
 191 notmuch dump --include=config >EXPECTED
 192 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 193 {
 194     EXPECT0(notmuch_database_set_config (db, "test.key1", "mutatedvalue"));
 195 }
 196 EOF
 197 notmuch restore --include=config <EXPECTED
 198 notmuch dump --include=config >OUTPUT
 199 test_expect_equal_file EXPECTED OUTPUT
 200
 201 backup_database
 202 test_begin_subtest "override config from file"
 203 notmuch config set test.key1 overridden
 204 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG}
 205 {
 206    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 207    printf("test.key1 = %s\n", val);
 208    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 209    printf("test.key2 = %s\n", val);
 210 }
 211 EOF
 212 cat <<'EOF' >EXPECTED
 213 == stdout ==
 214 test.key1 = overridden
 215 test.key2 = testvalue2
 216 == stderr ==
 217 EOF
 218 test_expect_equal_file EXPECTED OUTPUT
 219 restore_database
 220
 221 test_begin_subtest "NOTMUCH_CONFIG_HOOK_DIR: traditional"
 222 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 223 {
 224    const char *val = notmuch_config_get (db, NOTMUCH_CONFIG_HOOK_DIR);
 225    printf("database.hook_dir = %s\n", val);
 226 }
 227 EOF
 228 cat <<'EOF' >EXPECTED
 229 == stdout ==
 230 database.hook_dir = MAIL_DIR/.notmuch/hooks
 231 == stderr ==
 232 EOF
 233 test_expect_equal_file EXPECTED OUTPUT
 234
 235 test_begin_subtest "NOTMUCH_CONFIG_HOOK_DIR: xdg"
 236 dir="${HOME}/.config/notmuch/default/hooks"
 237 mkdir -p $dir
 238 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 239 {
 240    const char *val = notmuch_config_get (db, NOTMUCH_CONFIG_HOOK_DIR);
 241    printf("database.hook_dir = %s\n", val);
 242 }
 243 EOF
 244 cat <<'EOF' >EXPECTED
 245 == stdout ==
 246 database.hook_dir = CWD/home/.config/notmuch/default/hooks
 247 == stderr ==
 248 EOF
 249 rmdir $dir
 250 test_expect_equal_file EXPECTED OUTPUT
 251
 252 test_begin_subtest "notmuch_config_get_values"
 253 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 254 {
 255     notmuch_config_values_t *values;
 256     EXPECT0(notmuch_config_set (db, NOTMUCH_CONFIG_NEW_TAGS, "a;b;c"));
 257     for (values = notmuch_config_get_values (db, NOTMUCH_CONFIG_NEW_TAGS);
 258          notmuch_config_values_valid (values);
 259          notmuch_config_values_move_to_next (values))
 260     {
 261           puts (notmuch_config_values_get (values));
 262     }
 263 }
 264 EOF
 265 cat <<'EOF' >EXPECTED
 266 == stdout ==
 267 a
 268 b
 269 c
 270 == stderr ==
 271 EOF
 272 test_expect_equal_file EXPECTED OUTPUT
 273 restore_database
 274
 275 test_begin_subtest "notmuch_config_get_values_string"
 276 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 277 {
 278     notmuch_config_values_t *values;
 279     EXPECT0(notmuch_database_set_config (db, "test.list", "x;y;z"));
 280     for (values = notmuch_config_get_values_string (db, "test.list");
 281          notmuch_config_values_valid (values);
 282          notmuch_config_values_move_to_next (values))
 283     {
 284           puts (notmuch_config_values_get (values));
 285     }
 286 }
 287 EOF
 288 cat <<'EOF' >EXPECTED
 289 == stdout ==
 290 x
 291 y
 292 z
 293 == stderr ==
 294 EOF
 295 test_expect_equal_file EXPECTED OUTPUT
 296 restore_database
 297
 298 test_begin_subtest "notmuch_config_get_values (restart)"
 299 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 300 {
 301     notmuch_config_values_t *values;
 302     EXPECT0(notmuch_config_set (db, NOTMUCH_CONFIG_NEW_TAGS, "a;b;c"));
 303     for (values = notmuch_config_get_values (db, NOTMUCH_CONFIG_NEW_TAGS);
 304          notmuch_config_values_valid (values);
 305          notmuch_config_values_move_to_next (values))
 306     {
 307           puts (notmuch_config_values_get (values));
 308     }
 309     for (notmuch_config_values_start (values);
 310          notmuch_config_values_valid (values);
 311          notmuch_config_values_move_to_next (values))
 312     {
 313           puts (notmuch_config_values_get (values));
 314     }
 315 }
 316 EOF
 317 cat <<'EOF' >EXPECTED
 318 == stdout ==
 319 a
 320 b
 321 c
 322 a
 323 b
 324 c
 325 == stderr ==
 326 EOF
 327 test_expect_equal_file EXPECTED OUTPUT
 328 restore_database
 329
 330 backup_database
 331 test_begin_subtest "notmuch_config_get_values, trailing ;"
 332 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 333 {
 334     notmuch_config_values_t *values;
 335     EXPECT0(notmuch_config_set (db, NOTMUCH_CONFIG_NEW_TAGS, "a;b;c"));
 336     for (values = notmuch_config_get_values (db, NOTMUCH_CONFIG_NEW_TAGS);
 337          notmuch_config_values_valid (values);
 338          notmuch_config_values_move_to_next (values))
 339     {
 340           puts (notmuch_config_values_get (values));
 341     }
 342 }
 343 EOF
 344 cat <<'EOF' >EXPECTED
 345 == stdout ==
 346 a
 347 b
 348 c
 349 == stderr ==
 350 EOF
 351 test_expect_equal_file EXPECTED OUTPUT
 352 restore_database
 353
 354 backup_database
 355 test_begin_subtest "get config by key"
 356 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG}
 357 {
 358    printf("before = %s\n", notmuch_config_get (db, NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS));
 359    EXPECT0(notmuch_database_set_config (db, "maildir.synchronize_flags", "false"));
 360    printf("after = %s\n", notmuch_config_get (db, NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS));
 361 }
 362 EOF
 363 cat <<'EOF' >EXPECTED
 364 == stdout ==
 365 before = true
 366 after = false
 367 == stderr ==
 368 EOF
 369 test_expect_equal_file EXPECTED OUTPUT
 370 restore_database
 371
 372 backup_database
 373 test_begin_subtest "set config by key"
 374 notmuch config set test.key1 overridden
 375 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG}
 376 {
 377    printf("before = %s\n", notmuch_config_get (db, NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS));
 378    EXPECT0(notmuch_config_set (db, NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS, "false"));
 379    printf("after = %s\n", notmuch_config_get (db, NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS));
 380 }
 381 EOF
 382 cat <<'EOF' >EXPECTED
 383 == stdout ==
 384 before = true
 385 after = false
 386 == stderr ==
 387 EOF
 388 test_expect_equal_file EXPECTED OUTPUT
 389 restore_database
 390
 391 test_begin_subtest "load default values"
 392 export MAILDIR=${MAIL_DIR}
 393 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} '' %NULL%
 394 {
 395     notmuch_config_key_t key;
 396     for (key = NOTMUCH_CONFIG_FIRST;
 397          key < NOTMUCH_CONFIG_LAST;
 398          key = (notmuch_config_key_t)(key + 1)) {
 399         const char *val = notmuch_config_get (db, key);
 400         printf("%02d: '%s'\n", key, val ? val : "NULL" );
 401     }
 402 }
 403 EOF
 404
 405 _libconfig_sanitize < OUTPUT > OUTPUT.clean
 406
 407 cat <<'EOF' >EXPECTED
 408 == stdout ==
 409 00: 'MAIL_DIR'
 410 01: 'MAIL_DIR'
 411 02: 'MAIL_DIR/.notmuch/hooks'
 412 03: 'MAIL_DIR/.notmuch/backups'
 413 04: ''
 414 05: 'unread;inbox'
 415 06: ''
 416 07: 'true'
 417 08: 'USERNAME@localhost'
 418 09: 'NULL'
 419 10: 'USER_FULL_NAME'
 420 11: '8000'
 421 == stderr ==
 422 EOF
 423 unset MAILDIR
 424 test_expect_equal_file EXPECTED OUTPUT.clean
 425
 426 backup_database
 427 test_begin_subtest "override config from \${NOTMUCH_CONFIG}"
 428 notmuch config set test.key1 overridden
 429 # second argument omitted to make argv[2] == NULL
 430 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 431 {
 432    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 433    printf("test.key1 = %s\n", val);
 434    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 435    printf("test.key2 = %s\n", val);
 436 }
 437 EOF
 438 notmuch config set test.key1
 439 cat <<'EOF' >EXPECTED
 440 == stdout ==
 441 test.key1 = overridden
 442 test.key2 = testvalue2
 443 == stderr ==
 444 EOF
 445 test_expect_equal_file EXPECTED OUTPUT
 446 restore_database
 447
 448 backup_database
 449 test_begin_subtest "override config from \${HOME}/.notmuch-config"
 450 ovconfig=${HOME}/.notmuch-config
 451 cp ${NOTMUCH_CONFIG} ${ovconfig}
 452 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 453 unset NOTMUCH_CONFIG
 454 notmuch --config=${ovconfig} config set test.key1 overridden-home
 455 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 456 {
 457    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 458    printf("test.key1 = %s\n", val);
 459    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 460    printf("test.key2 = %s\n", val);
 461 }
 462 EOF
 463 rm -f ${ovconfig}
 464 export NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 465 cat <<'EOF' >EXPECTED
 466 == stdout ==
 467 test.key1 = overridden-home
 468 test.key2 = testvalue2
 469 == stderr ==
 470 EOF
 471 test_expect_equal_file EXPECTED OUTPUT
 472 restore_database
 473
 474 backup_database
 475 test_begin_subtest "override config from \${XDG_CONFIG_HOME}/notmuch"
 476 ovconfig=${HOME}/.config/notmuch/default/config
 477 mkdir -p $(dirname ${ovconfig})
 478 cp ${NOTMUCH_CONFIG} ${ovconfig}
 479 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 480 unset NOTMUCH_CONFIG
 481 notmuch --config=${ovconfig} config set test.key1 overridden-xdg
 482 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 483 {
 484    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 485    printf("test.key1 = %s\n", val);
 486    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 487    printf("test.key2 = %s\n", val);
 488 }
 489 EOF
 490 rm -f ${ovconfig}
 491 export NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 492 cat <<'EOF' >EXPECTED
 493 == stdout ==
 494 test.key1 = overridden-xdg
 495 test.key2 = testvalue2
 496 == stderr ==
 497 EOF
 498 test_expect_equal_file EXPECTED OUTPUT
 499 restore_database
 500
 501 backup_database
 502 test_begin_subtest "override config from \${XDG_CONFIG_HOME}/notmuch with profile"
 503 ovconfig=${HOME}/.config/notmuch/work/config
 504 mkdir -p $(dirname ${ovconfig})
 505 cp ${NOTMUCH_CONFIG} ${ovconfig}
 506 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 507 unset NOTMUCH_CONFIG
 508 notmuch --config=${ovconfig} config set test.key1 overridden-xdg-profile
 509 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% work
 510 {
 511    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 512    printf("test.key1 = %s\n", val);
 513    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 514    printf("test.key2 = %s\n", val);
 515 }
 516 EOF
 517 rm -f ${ovconfig}
 518 export NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 519 cat <<'EOF' >EXPECTED
 520 == stdout ==
 521 test.key1 = overridden-xdg-profile
 522 test.key2 = testvalue2
 523 == stderr ==
 524 EOF
 525 test_expect_equal_file EXPECTED OUTPUT
 526 restore_database
 527
 528 backup_database
 529 test_begin_subtest "override config from \${HOME}/.notmuch-config.work (via args)"
 530 ovconfig=${HOME}/.notmuch-config.work
 531 cp ${NOTMUCH_CONFIG} ${ovconfig}
 532 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 533 unset NOTMUCH_CONFIG
 534 notmuch --config=${ovconfig} config set test.key1 overridden-profile
 535 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% work
 536 {
 537    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 538    printf("test.key1 = %s\n", val);
 539    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 540    printf("test.key2 = %s\n", val);
 541 }
 542 EOF
 543 #rm -f ${ovconfig}
 544 export NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 545 cat <<'EOF' >EXPECTED
 546 == stdout ==
 547 test.key1 = overridden-profile
 548 test.key2 = testvalue2
 549 == stderr ==
 550 EOF
 551 test_expect_equal_file EXPECTED OUTPUT
 552 restore_database
 553
 554 test_begin_subtest "no config, fail to open database"
 555 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 556 unset NOTMUCH_CONFIG
 557 cat c_head - c_tail <<'EOF' | test_C %NULL% '' %NULL%
 558 {
 559    printf("NOT RUN");
 560 }
 561 EOF
 562 export NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 563 cat <<'EOF' >EXPECTED
 564 == stdout ==
 565 == stderr ==
 566 error opening database
 567 No database found
 568 Error: could not locate database.
 569
 570 EOF
 571 test_expect_equal_file EXPECTED OUTPUT
 572
 573 test_begin_subtest "open database from NOTMUCH_DATABASE"
 574 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 575 unset NOTMUCH_CONFIG
 576 export NOTMUCH_DATABASE=${MAIL_DIR}
 577 cat c_head - c_tail <<'EOF' | test_C %NULL% '' %NULL%
 578 {
 579    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 580    printf("test.key1 = %s\n", val);
 581    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 582    printf("test.key2 = %s\n", val);
 583 }
 584 EOF
 585 export NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 586 unset NOTMUCH_DATABASE
 587 cat <<'EOF' >EXPECTED
 588 == stdout ==
 589 test.key1 = testvalue1
 590 test.key2 = testvalue2
 591 == stderr ==
 592 EOF
 593 test_expect_equal_file EXPECTED OUTPUT
 594
 595 test_begin_subtest "NOTMUCH_DATABASE overrides config"
 596 cp notmuch-config notmuch-config.bak
 597 notmuch config set database.path /nonexistent
 598 export NOTMUCH_DATABASE=${MAIL_DIR}
 599 cat c_head - c_tail <<'EOF' | test_C %NULL% '' %NULL%
 600 {
 601    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 602    printf("test.key1 = %s\n", val);
 603    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 604    printf("test.key2 = %s\n", val);
 605 }
 606 EOF
 607 export NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 608 unset NOTMUCH_DATABASE
 609 cat <<'EOF' >EXPECTED
 610 == stdout ==
 611 test.key1 = testvalue1
 612 test.key2 = testvalue2
 613 == stderr ==
 614 EOF
 615 cp notmuch-config.bak notmuch-config
 616 test_expect_equal_file EXPECTED OUTPUT
 617
 618 cat <<EOF > c_head2
 619 #include <string.h>
 620 #include <stdlib.h>
 621 #include <notmuch-test.h>
 622
 623 int main (int argc, char** argv)
 624 {
 625    notmuch_database_t *db;
 626    char *val;
 627    notmuch_status_t stat;
 628    char *msg = NULL;
 629
 630    for (int i = 1; i < argc; i++)
 631       if (strcmp (argv[i], "%NULL%") == 0) argv[i] = NULL;
 632
 633    stat = notmuch_database_load_config (argv[1],
 634                                         argv[2],
 635                                         argv[3],
 636                                         &db,
 637                                         &msg);
 638    if (stat != NOTMUCH_STATUS_SUCCESS  && stat != NOTMUCH_STATUS_NO_CONFIG) {
 639      fprintf (stderr, "error opening database\n%d: %s\n%s\n", stat,
 640               notmuch_status_to_string (stat), msg ? msg : "");
 641      exit (1);
 642    }
 643 EOF
 644
 645
 646 test_begin_subtest "notmuch_database_get_config (ndlc)"
 647 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 648 {
 649    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 650    printf("test.key1 = %s\n", val);
 651    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 652    printf("test.key2 = %s\n", val);
 653 }
 654 EOF
 655 cat <<'EOF' >EXPECTED
 656 == stdout ==
 657 test.key1 = testvalue1
 658 test.key2 = testvalue2
 659 == stderr ==
 660 EOF
 661 test_expect_equal_file EXPECTED OUTPUT
 662
 663
 664 test_begin_subtest "notmuch_database_get_config_list: all pairs (ndlc)"
 665 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 666 {
 667    notmuch_config_list_t *list;
 668    EXPECT0(notmuch_database_get_config_list (db, "", &list));
 669    for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
 670       printf("%s %s\n", notmuch_config_list_key (list), notmuch_config_list_value(list));
 671    }
 672    notmuch_config_list_destroy (list);
 673 }
 674 EOF
 675 cat <<'EOF' >EXPECTED
 676 == stdout ==
 677 aaabefore beforeval
 678 key with spaces value, with, spaces!
 679 test.key1 testvalue1
 680 test.key2 testvalue2
 681 zzzafter afterval
 682 == stderr ==
 683 EOF
 684 test_expect_equal_file EXPECTED OUTPUT
 685
 686 test_begin_subtest "notmuch_database_get_config_list: one prefix (ndlc)"
 687 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 688 {
 689    notmuch_config_list_t *list;
 690    EXPECT0(notmuch_database_get_config_list (db, "test.key", &list));
 691    for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
 692       printf("%s %s\n", notmuch_config_list_key (list), notmuch_config_list_value(list));
 693    }
 694    notmuch_config_list_destroy (list);
 695 }
 696 EOF
 697 cat <<'EOF' >EXPECTED
 698 == stdout ==
 699 test.key1 testvalue1
 700 test.key2 testvalue2
 701 == stderr ==
 702 EOF
 703 test_expect_equal_file EXPECTED OUTPUT
 704
 705 test_begin_subtest "list by keys (ndlc)"
 706 notmuch config set search.exclude_tags "foo;bar;fub"
 707 notmuch config set new.ignore "sekrit_junk"
 708 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 709 {
 710     notmuch_config_key_t key;
 711     for (key = NOTMUCH_CONFIG_FIRST;
 712          key < NOTMUCH_CONFIG_LAST;
 713          key = (notmuch_config_key_t)(key + 1)) {
 714         const char *val = notmuch_config_get (db, key);
 715         printf("%02d: '%s'\n", key, val ? val : "NULL" );
 716     }
 717 }
 718 EOF
 719 cat <<'EOF' >EXPECTED
 720 == stdout ==
 721 00: 'MAIL_DIR'
 722 01: 'MAIL_DIR'
 723 02: 'MAIL_DIR/.notmuch/hooks'
 724 03: 'MAIL_DIR/.notmuch/backups'
 725 04: 'foo;bar;fub'
 726 05: 'unread;inbox'
 727 06: 'sekrit_junk'
 728 07: 'true'
 729 08: 'test_suite@notmuchmail.org'
 730 09: 'test_suite_other@notmuchmail.org;test_suite@otherdomain.org'
 731 10: 'Notmuch Test Suite'
 732 11: '8000'
 733 == stderr ==
 734 EOF
 735 test_expect_equal_file EXPECTED OUTPUT
 736
 737 test_begin_subtest "load default values (ndlc, nonexistent config)"
 738 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} /nonexistent %NULL%
 739 {
 740     notmuch_config_key_t key;
 741     for (key = NOTMUCH_CONFIG_FIRST;
 742          key < NOTMUCH_CONFIG_LAST;
 743          key = (notmuch_config_key_t)(key + 1)) {
 744         const char *val = notmuch_config_get (db, key);
 745         printf("%02d: '%s'\n", key, val ? val : "NULL" );
 746     }
 747 }
 748 EOF
 749
 750 _libconfig_sanitize < OUTPUT > OUTPUT.clean
 751
 752 cat <<'EOF' >EXPECTED
 753 == stdout ==
 754 00: 'MAIL_DIR'
 755 01: 'MAIL_DIR'
 756 02: 'MAIL_DIR/.notmuch/hooks'
 757 03: 'MAIL_DIR/.notmuch/backups'
 758 04: ''
 759 05: 'unread;inbox'
 760 06: ''
 761 07: 'true'
 762 08: 'USERNAME@localhost'
 763 09: 'NULL'
 764 10: 'USER_FULL_NAME'
 765 11: '8000'
 766 == stderr ==
 767 EOF
 768 test_expect_equal_file EXPECTED OUTPUT.clean
 769
 770 backup_database
 771 test_begin_subtest "override config from \${HOME}/.notmuch-config (ndlc)"
 772 ovconfig=${HOME}/.notmuch-config
 773 cp ${NOTMUCH_CONFIG} ${ovconfig}
 774 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 775 unset NOTMUCH_CONFIG
 776 notmuch --config=${ovconfig} config set test.key1 overridden-home
 777 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 778 {
 779    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 780    printf("test.key1 = %s\n", val);
 781    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 782    printf("test.key2 = %s\n", val);
 783 }
 784 EOF
 785 rm -f ${ovconfig}
 786 export NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 787 cat <<'EOF' >EXPECTED
 788 == stdout ==
 789 test.key1 = overridden-home
 790 test.key2 = testvalue2
 791 == stderr ==
 792 EOF
 793 test_expect_equal_file EXPECTED OUTPUT
 794 restore_database
 795
 796 test_begin_subtest "notmuch_config_get_pairs: prefix (ndlc)"
 797 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 798 {
 799    notmuch_config_pairs_t *list;
 800    for (list =  notmuch_config_get_pairs (db, "user.");
 801         notmuch_config_pairs_valid (list);
 802         notmuch_config_pairs_move_to_next (list)) {
 803      printf("%s %s\n", notmuch_config_pairs_key (list), notmuch_config_pairs_value(list));
 804    }
 805    notmuch_config_pairs_destroy (list);
 806 }
 807 EOF
 808 cat <<'EOF' >EXPECTED
 809 == stdout ==
 810 user.name Notmuch Test Suite
 811 user.other_email test_suite_other@notmuchmail.org;test_suite@otherdomain.org
 812 user.primary_email test_suite@notmuchmail.org
 813 == stderr ==
 814 EOF
 815 test_expect_equal_file EXPECTED OUTPUT
 816
 817 test_begin_subtest "notmuch_config_get_pairs: all pairs (ndlc)"
 818 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 819 {
 820    notmuch_config_pairs_t *list;
 821    for (list =  notmuch_config_get_pairs (db, "");
 822         notmuch_config_pairs_valid (list);
 823         notmuch_config_pairs_move_to_next (list)) {
 824      printf("%s %s\n", notmuch_config_pairs_key (list), notmuch_config_pairs_value(list));
 825    }
 826    notmuch_config_pairs_destroy (list);
 827 }
 828 EOF
 829 cat <<'EOF' >EXPECTED
 830 == stdout ==
 831 aaabefore beforeval
 832 database.autocommit 8000
 833 database.backup_dir MAIL_DIR/.notmuch/backups
 834 database.hook_dir MAIL_DIR/.notmuch/hooks
 835 database.mail_root MAIL_DIR
 836 database.path MAIL_DIR
 837 key with spaces value, with, spaces!
 838 maildir.synchronize_flags true
 839 new.ignore sekrit_junk
 840 new.tags unread;inbox
 841 search.exclude_tags foo;bar;fub
 842 test.key1 testvalue1
 843 test.key2 testvalue2
 844 user.name Notmuch Test Suite
 845 user.other_email test_suite_other@notmuchmail.org;test_suite@otherdomain.org
 846 user.primary_email test_suite@notmuchmail.org
 847 zzzafter afterval
 848 == stderr ==
 849 EOF
 850 test_expect_equal_file EXPECTED OUTPUT
 851
 852 cat <<EOF > c_head3
 853 #include <notmuch-test.h>
 854 int main (int argc, char **argv) {
 855   notmuch_status_t stat;
 856   notmuch_database_t *db = NULL;
 857 EOF
 858
 859 cat <<EOF > c_tail3
 860   printf("db == NULL: %d\n", db == NULL);
 861 }
 862 EOF
 863
 864 test_begin_subtest "open: database set to null on missing config"
 865 cat c_head3 - c_tail3 <<'EOF' | test_C ${MAIL_DIR}
 866   notmuch_status_t st = notmuch_database_open_with_config(argv[1],
 867                                                           NOTMUCH_DATABASE_MODE_READ_ONLY,
 868                                                           "/nonexistent", NULL, &db, NULL);
 869 EOF
 870 cat <<EOF> EXPECTED
 871 == stdout ==
 872 db == NULL: 1
 873 == stderr ==
 874 EOF
 875 test_expect_equal_file EXPECTED OUTPUT
 876
 877 test_begin_subtest "open: database set to null on missing config (env)"
 878 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 879 NOTMUCH_CONFIG="/nonexistent"
 880 cat c_head3 - c_tail3 <<'EOF' | test_C ${MAIL_DIR}
 881   notmuch_status_t st = notmuch_database_open_with_config(argv[1],
 882                                                           NOTMUCH_DATABASE_MODE_READ_ONLY,
 883                                                           NULL, NULL, &db, NULL);
 884 EOF
 885 NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 886 cat <<EOF> EXPECTED
 887 == stdout ==
 888 db == NULL: 1
 889 == stderr ==
 890 EOF
 891 test_expect_equal_file EXPECTED OUTPUT
 892
 893 test_begin_subtest "create: database set to null on missing config"
 894 cat c_head3 - c_tail3 <<'EOF' | test_C ${MAIL_DIR} "/nonexistent"
 895   notmuch_status_t st = notmuch_database_create_with_config(argv[1],argv[2], NULL, &db, NULL);
 896 EOF
 897 cat <<EOF> EXPECTED
 898 == stdout ==
 899 db == NULL: 1
 900 == stderr ==
 901 EOF
 902 test_expect_equal_file EXPECTED OUTPUT
 903
 904 test_begin_subtest "create: database set to null on missing config (env)"
 905 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 906 NOTMUCH_CONFIG="/nonexistent"
 907 cat c_head3 - c_tail3 <<'EOF' | test_C ${MAIL_DIR}
 908   notmuch_status_t st = notmuch_database_create_with_config(argv[1],
 909                                                           NULL, NULL, &db, NULL);
 910 EOF
 911 NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 912 cat <<EOF> EXPECTED
 913 == stdout ==
 914 db == NULL: 1
 915 == stderr ==
 916 EOF
 917 test_expect_equal_file EXPECTED OUTPUT
 918
 919 test_done