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