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 == stderr ==
 423 EOF
 424 unset MAILDIR
 425 test_expect_equal_file EXPECTED OUTPUT.clean
 426
 427 backup_database
 428 test_begin_subtest "override config from \${NOTMUCH_CONFIG}"
 429 notmuch config set test.key1 overridden
 430 # second argument omitted to make argv[2] == NULL
 431 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 432 {
 433    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 434    printf("test.key1 = %s\n", val);
 435    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 436    printf("test.key2 = %s\n", val);
 437 }
 438 EOF
 439 notmuch config set test.key1
 440 cat <<'EOF' >EXPECTED
 441 == stdout ==
 442 test.key1 = overridden
 443 test.key2 = testvalue2
 444 == stderr ==
 445 EOF
 446 test_expect_equal_file EXPECTED OUTPUT
 447 restore_database
 448
 449 backup_database
 450 test_begin_subtest "override config from \${HOME}/.notmuch-config"
 451 ovconfig=${HOME}/.notmuch-config
 452 cp ${NOTMUCH_CONFIG} ${ovconfig}
 453 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 454 unset NOTMUCH_CONFIG
 455 notmuch --config=${ovconfig} config set test.key1 overridden-home
 456 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 457 {
 458    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 459    printf("test.key1 = %s\n", val);
 460    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 461    printf("test.key2 = %s\n", val);
 462 }
 463 EOF
 464 rm -f ${ovconfig}
 465 NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 466 cat <<'EOF' >EXPECTED
 467 == stdout ==
 468 test.key1 = overridden-home
 469 test.key2 = testvalue2
 470 == stderr ==
 471 EOF
 472 test_expect_equal_file EXPECTED OUTPUT
 473 restore_database
 474
 475 backup_database
 476 test_begin_subtest "override config from \${XDG_CONFIG_HOME}/notmuch"
 477 ovconfig=${HOME}/.config/notmuch/default/config
 478 mkdir -p $(dirname ${ovconfig})
 479 cp ${NOTMUCH_CONFIG} ${ovconfig}
 480 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 481 unset NOTMUCH_CONFIG
 482 notmuch --config=${ovconfig} config set test.key1 overridden-xdg
 483 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 484 {
 485    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 486    printf("test.key1 = %s\n", val);
 487    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 488    printf("test.key2 = %s\n", val);
 489 }
 490 EOF
 491 rm -f ${ovconfig}
 492 NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 493 cat <<'EOF' >EXPECTED
 494 == stdout ==
 495 test.key1 = overridden-xdg
 496 test.key2 = testvalue2
 497 == stderr ==
 498 EOF
 499 test_expect_equal_file EXPECTED OUTPUT
 500 restore_database
 501
 502 backup_database
 503 test_begin_subtest "override config from \${XDG_CONFIG_HOME}/notmuch with profile"
 504 ovconfig=${HOME}/.config/notmuch/work/config
 505 mkdir -p $(dirname ${ovconfig})
 506 cp ${NOTMUCH_CONFIG} ${ovconfig}
 507 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 508 unset NOTMUCH_CONFIG
 509 notmuch --config=${ovconfig} config set test.key1 overridden-xdg-profile
 510 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% work
 511 {
 512    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 513    printf("test.key1 = %s\n", val);
 514    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 515    printf("test.key2 = %s\n", val);
 516 }
 517 EOF
 518 rm -f ${ovconfig}
 519 NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 520 cat <<'EOF' >EXPECTED
 521 == stdout ==
 522 test.key1 = overridden-xdg-profile
 523 test.key2 = testvalue2
 524 == stderr ==
 525 EOF
 526 test_expect_equal_file EXPECTED OUTPUT
 527 restore_database
 528
 529 backup_database
 530 test_begin_subtest "override config from \${HOME}/.notmuch-config.work (via args)"
 531 ovconfig=${HOME}/.notmuch-config.work
 532 cp ${NOTMUCH_CONFIG} ${ovconfig}
 533 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 534 unset NOTMUCH_CONFIG
 535 notmuch --config=${ovconfig} config set test.key1 overridden-profile
 536 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% work
 537 {
 538    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 539    printf("test.key1 = %s\n", val);
 540    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 541    printf("test.key2 = %s\n", val);
 542 }
 543 EOF
 544 #rm -f ${ovconfig}
 545 NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 546 cat <<'EOF' >EXPECTED
 547 == stdout ==
 548 test.key1 = overridden-profile
 549 test.key2 = testvalue2
 550 == stderr ==
 551 EOF
 552 test_expect_equal_file EXPECTED OUTPUT
 553 restore_database
 554
 555 test_begin_subtest "no config, fail to open database"
 556 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 557 unset NOTMUCH_CONFIG
 558 cat c_head - c_tail <<'EOF' | test_C %NULL% '' %NULL%
 559 {
 560    printf("NOT RUN");
 561 }
 562 EOF
 563 NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 564 cat <<'EOF' >EXPECTED
 565 == stdout ==
 566 == stderr ==
 567 error opening database
 568 No database found
 569 Error: could not locate database.
 570
 571 EOF
 572 test_expect_equal_file EXPECTED OUTPUT
 573
 574 test_begin_subtest "open database from NOTMUCH_DATABASE"
 575 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 576 unset NOTMUCH_CONFIG
 577 export NOTMUCH_DATABASE=${MAIL_DIR}
 578 cat c_head - c_tail <<'EOF' | test_C %NULL% '' %NULL%
 579 {
 580    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 581    printf("test.key1 = %s\n", val);
 582    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 583    printf("test.key2 = %s\n", val);
 584 }
 585 EOF
 586 export NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 587 unset NOTMUCH_DATABASE
 588 cat <<'EOF' >EXPECTED
 589 == stdout ==
 590 test.key1 = testvalue1
 591 test.key2 = testvalue2
 592 == stderr ==
 593 EOF
 594 test_expect_equal_file EXPECTED OUTPUT
 595
 596 test_begin_subtest "NOTMUCH_DATABASE overrides config"
 597 cp notmuch-config notmuch-config.bak
 598 notmuch config set database.path /nonexistent
 599 export NOTMUCH_DATABASE=${MAIL_DIR}
 600 cat c_head - c_tail <<'EOF' | test_C %NULL% '' %NULL%
 601 {
 602    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 603    printf("test.key1 = %s\n", val);
 604    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 605    printf("test.key2 = %s\n", val);
 606 }
 607 EOF
 608 NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 609 unset NOTMUCH_DATABASE
 610 cat <<'EOF' >EXPECTED
 611 == stdout ==
 612 test.key1 = testvalue1
 613 test.key2 = testvalue2
 614 == stderr ==
 615 EOF
 616 cp notmuch-config.bak notmuch-config
 617 test_expect_equal_file EXPECTED OUTPUT
 618
 619 cat <<EOF > c_head2
 620 #include <string.h>
 621 #include <stdlib.h>
 622 #include <notmuch-test.h>
 623
 624 int main (int argc, char** argv)
 625 {
 626    notmuch_database_t *db;
 627    char *val;
 628    notmuch_status_t stat;
 629    char *msg = NULL;
 630
 631    for (int i = 1; i < argc; i++)
 632       if (strcmp (argv[i], "%NULL%") == 0) argv[i] = NULL;
 633
 634    stat = notmuch_database_load_config (argv[1],
 635                                         argv[2],
 636                                         argv[3],
 637                                         &db,
 638                                         &msg);
 639    if (stat != NOTMUCH_STATUS_SUCCESS  && stat != NOTMUCH_STATUS_NO_CONFIG) {
 640      fprintf (stderr, "error opening database\n%d: %s\n%s\n", stat,
 641               notmuch_status_to_string (stat), msg ? msg : "");
 642      exit (1);
 643    }
 644 EOF
 645
 646
 647 test_begin_subtest "notmuch_database_get_config (ndlc)"
 648 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 649 {
 650    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 651    printf("test.key1 = %s\n", val);
 652    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 653    printf("test.key2 = %s\n", val);
 654 }
 655 EOF
 656 cat <<'EOF' >EXPECTED
 657 == stdout ==
 658 test.key1 = testvalue1
 659 test.key2 = testvalue2
 660 == stderr ==
 661 EOF
 662 test_expect_equal_file EXPECTED OUTPUT
 663
 664
 665 test_begin_subtest "notmuch_database_get_config_list: all pairs (ndlc)"
 666 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 667 {
 668    notmuch_config_list_t *list;
 669    EXPECT0(notmuch_database_get_config_list (db, "", &list));
 670    for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
 671       printf("%s %s\n", notmuch_config_list_key (list), notmuch_config_list_value(list));
 672    }
 673    notmuch_config_list_destroy (list);
 674 }
 675 EOF
 676 cat <<'EOF' >EXPECTED
 677 == stdout ==
 678 aaabefore beforeval
 679 key with spaces value, with, spaces!
 680 test.key1 testvalue1
 681 test.key2 testvalue2
 682 zzzafter afterval
 683 == stderr ==
 684 EOF
 685 test_expect_equal_file EXPECTED OUTPUT
 686
 687 test_begin_subtest "notmuch_database_get_config_list: one prefix (ndlc)"
 688 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 689 {
 690    notmuch_config_list_t *list;
 691    EXPECT0(notmuch_database_get_config_list (db, "test.key", &list));
 692    for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
 693       printf("%s %s\n", notmuch_config_list_key (list), notmuch_config_list_value(list));
 694    }
 695    notmuch_config_list_destroy (list);
 696 }
 697 EOF
 698 cat <<'EOF' >EXPECTED
 699 == stdout ==
 700 test.key1 testvalue1
 701 test.key2 testvalue2
 702 == stderr ==
 703 EOF
 704 test_expect_equal_file EXPECTED OUTPUT
 705
 706 test_begin_subtest "list by keys (ndlc)"
 707 notmuch config set search.exclude_tags "foo;bar;fub"
 708 notmuch config set new.ignore "sekrit_junk"
 709 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 710 {
 711     notmuch_config_key_t key;
 712     for (key = NOTMUCH_CONFIG_FIRST;
 713          key < NOTMUCH_CONFIG_LAST;
 714          key = (notmuch_config_key_t)(key + 1)) {
 715         const char *val = notmuch_config_get (db, key);
 716         printf("%x: '%s'\n", key, val ? val : "NULL" );
 717     }
 718 }
 719 EOF
 720 cat <<'EOF' >EXPECTED
 721 == stdout ==
 722 0: 'MAIL_DIR'
 723 1: 'MAIL_DIR'
 724 2: 'MAIL_DIR/.notmuch/hooks'
 725 3: 'MAIL_DIR/.notmuch/backups'
 726 4: 'foo;bar;fub'
 727 5: 'unread;inbox'
 728 6: 'sekrit_junk'
 729 7: 'true'
 730 8: 'test_suite@notmuchmail.org'
 731 9: 'test_suite_other@notmuchmail.org;test_suite@otherdomain.org'
 732 a: 'Notmuch Test Suite'
 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@FQDN'
 763 09: 'NULL'
 764 10: 'USER_FULL_NAME'
 765 == stderr ==
 766 EOF
 767 test_expect_equal_file EXPECTED OUTPUT.clean
 768
 769 backup_database
 770 test_begin_subtest "override config from \${HOME}/.notmuch-config (ndlc)"
 771 ovconfig=${HOME}/.notmuch-config
 772 cp ${NOTMUCH_CONFIG} ${ovconfig}
 773 old_NOTMUCH_CONFIG=${NOTMUCH_CONFIG}
 774 unset NOTMUCH_CONFIG
 775 notmuch --config=${ovconfig} config set test.key1 overridden-home
 776 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} %NULL% %NULL%
 777 {
 778    EXPECT0(notmuch_database_get_config (db, "test.key1", &val));
 779    printf("test.key1 = %s\n", val);
 780    EXPECT0(notmuch_database_get_config (db, "test.key2", &val));
 781    printf("test.key2 = %s\n", val);
 782 }
 783 EOF
 784 rm -f ${ovconfig}
 785 NOTMUCH_CONFIG=${old_NOTMUCH_CONFIG}
 786 cat <<'EOF' >EXPECTED
 787 == stdout ==
 788 test.key1 = overridden-home
 789 test.key2 = testvalue2
 790 == stderr ==
 791 EOF
 792 test_expect_equal_file EXPECTED OUTPUT
 793 restore_database
 794
 795 test_begin_subtest "notmuch_config_get_pairs: prefix (ndlc)"
 796 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 797 {
 798    notmuch_config_pairs_t *list;
 799    for (list =  notmuch_config_get_pairs (db, "user.");
 800         notmuch_config_pairs_valid (list);
 801         notmuch_config_pairs_move_to_next (list)) {
 802      printf("%s %s\n", notmuch_config_pairs_key (list), notmuch_config_pairs_value(list));
 803    }
 804    notmuch_config_pairs_destroy (list);
 805 }
 806 EOF
 807 cat <<'EOF' >EXPECTED
 808 == stdout ==
 809 user.name Notmuch Test Suite
 810 user.other_email test_suite_other@notmuchmail.org;test_suite@otherdomain.org
 811 user.primary_email test_suite@notmuchmail.org
 812 == stderr ==
 813 EOF
 814 test_expect_equal_file EXPECTED OUTPUT
 815
 816 test_begin_subtest "notmuch_config_get_pairs: all pairs (ndlc)"
 817 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR} ${NOTMUCH_CONFIG} %NULL%
 818 {
 819    notmuch_config_pairs_t *list;
 820    for (list =  notmuch_config_get_pairs (db, "");
 821         notmuch_config_pairs_valid (list);
 822         notmuch_config_pairs_move_to_next (list)) {
 823      printf("%s %s\n", notmuch_config_pairs_key (list), notmuch_config_pairs_value(list));
 824    }
 825    notmuch_config_pairs_destroy (list);
 826 }
 827 EOF
 828 cat <<'EOF' >EXPECTED
 829 == stdout ==
 830 aaabefore beforeval
 831 database.backup_dir MAIL_DIR/.notmuch/backups
 832 database.hook_dir MAIL_DIR/.notmuch/hooks
 833 database.mail_root MAIL_DIR
 834 database.path MAIL_DIR
 835 key with spaces value, with, spaces!
 836 maildir.synchronize_flags true
 837 new.ignore sekrit_junk
 838 new.tags unread;inbox
 839 search.exclude_tags foo;bar;fub
 840 test.key1 testvalue1
 841 test.key2 testvalue2
 842 user.name Notmuch Test Suite
 843 user.other_email test_suite_other@notmuchmail.org;test_suite@otherdomain.org
 844 user.primary_email test_suite@notmuchmail.org
 845 zzzafter afterval
 846 == stderr ==
 847 EOF
 848 test_expect_equal_file EXPECTED OUTPUT
 849
 850 test_done