git.notmuchmail.org Git - notmuch/blob - test/T562-lib-database.sh

   1 #!/usr/bin/env bash
   2 test_description="notmuch_database_* API"
   3
   4 . $(dirname "$0")/test-lib.sh || exit 1
   5
   6 add_email_corpus
   7
   8 test_begin_subtest "building database"
   9 test_expect_success "NOTMUCH_NEW"
  10
  11 cat <<EOF > c_head
  12 #include <stdio.h>
  13 #include <notmuch.h>
  14 #include <notmuch-test.h>
  15 #include <talloc.h>
  16 int main (int argc, char** argv)
  17 {
  18    notmuch_database_t *db;
  19    notmuch_status_t stat = NOTMUCH_STATUS_SUCCESS;
  20    char *msg = NULL;
  21
  22    stat = notmuch_database_open_verbose (argv[1], NOTMUCH_DATABASE_MODE_READ_WRITE, &db, &msg);
  23    if (stat != NOTMUCH_STATUS_SUCCESS) {
  24      fprintf (stderr, "error opening database: %d %s\n", stat, msg ? msg : "");
  25      exit (1);
  26    }
  27 EOF
  28
  29 cat <<'EOF' > c_tail
  30    if (stat) {
  31        const char *stat_str = notmuch_database_status_string (db);
  32        if (stat_str)
  33            fputs (stat_str, stderr);
  34     }
  35
  36 }
  37 EOF
  38
  39 test_begin_subtest "get status_string with closed db"
  40 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
  41     {
  42         const char *str;
  43         EXPECT0(notmuch_database_close (db));
  44         str = notmuch_database_status_string (db);
  45         printf("%d\n", str == NULL);
  46     }
  47 EOF
  48 cat <<EOF > EXPECTED
  49 == stdout ==
  50 1
  51 == stderr ==
  52 EOF
  53 test_expect_equal_file EXPECTED OUTPUT
  54
  55 test_begin_subtest "get path with closed db"
  56 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
  57     {
  58         const char *path;
  59         EXPECT0(notmuch_database_close (db));
  60         path = notmuch_database_get_path (db);
  61         printf("%s\n", path);
  62     }
  63 EOF
  64 cat <<EOF > EXPECTED
  65 == stdout ==
  66 MAIL_DIR
  67 == stderr ==
  68 EOF
  69 test_expect_equal_file EXPECTED OUTPUT
  70
  71 test_begin_subtest "get version with closed db"
  72 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
  73     {
  74         unsigned int version;
  75         EXPECT0(notmuch_database_close (db));
  76         version = notmuch_database_get_version (db);
  77         printf ("%u\n", version);
  78         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
  79     }
  80 EOF
  81 cat <<EOF > EXPECTED
  82 == stdout ==
  83 0
  84 == stderr ==
  85 A Xapian exception occurred at lib/database.cc:XXX: Database has been closed
  86 EOF
  87 test_expect_equal_file EXPECTED OUTPUT
  88
  89 test_begin_subtest "re-close a closed db"
  90 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
  91     {
  92         EXPECT0(notmuch_database_close (db));
  93         stat = notmuch_database_close (db);
  94         printf ("%d\n", stat);
  95     }
  96 EOF
  97 cat <<EOF > EXPECTED
  98 == stdout ==
  99 0
 100 == stderr ==
 101 EOF
 102 test_expect_equal_file EXPECTED OUTPUT
 103
 104 test_begin_subtest "destroy a closed db"
 105 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 106     {
 107         unsigned int version;
 108         EXPECT0(notmuch_database_close (db));
 109         stat = notmuch_database_destroy (db);
 110         printf ("%d\n", stat);
 111     }
 112 EOF
 113 cat <<EOF > EXPECTED
 114 == stdout ==
 115 0
 116 == stderr ==
 117 EOF
 118 test_expect_equal_file EXPECTED OUTPUT
 119
 120 test_begin_subtest "destroy an open db"
 121 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 122     {
 123         unsigned int version;
 124         stat = notmuch_database_destroy (db);
 125         printf ("%d\n", stat);
 126     }
 127 EOF
 128 cat <<EOF > EXPECTED
 129 == stdout ==
 130 0
 131 == stderr ==
 132 EOF
 133 test_expect_equal_file EXPECTED OUTPUT
 134
 135 test_begin_subtest "check a closed db for upgrade"
 136 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 137     {
 138         notmuch_bool_t ret;
 139
 140         EXPECT0(notmuch_database_close (db));
 141         ret = notmuch_database_needs_upgrade (db);
 142         printf ("%d\n", ret == FALSE);
 143         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 144     }
 145 EOF
 146 cat <<EOF > EXPECTED
 147 == stdout ==
 148 1
 149 == stderr ==
 150 A Xapian exception occurred at lib/database.cc:XXX: Database has been closed
 151 EOF
 152 test_expect_equal_file EXPECTED OUTPUT
 153
 154 test_begin_subtest "upgrade a closed db"
 155 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 156     {
 157         notmuch_bool_t ret;
 158
 159         EXPECT0(notmuch_database_close (db));
 160         stat = notmuch_database_upgrade (db, NULL, NULL);
 161         printf ("%d\n", ret == NOTMUCH_STATUS_SUCCESS);
 162     }
 163 EOF
 164 cat <<EOF > EXPECTED
 165 == stdout ==
 166 1
 167 == stderr ==
 168 EOF
 169 test_expect_equal_file EXPECTED OUTPUT
 170
 171 test_begin_subtest "begin atomic section for a closed db"
 172 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 173     {
 174         EXPECT0(notmuch_database_close (db));
 175         stat = notmuch_database_begin_atomic (db);
 176         printf ("%d\n", stat == NOTMUCH_STATUS_SUCCESS ||
 177                         stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 178         stat = NOTMUCH_STATUS_SUCCESS;
 179     }
 180 EOF
 181 cat <<EOF > EXPECTED
 182 == stdout ==
 183 1
 184 == stderr ==
 185 EOF
 186 test_expect_equal_file EXPECTED OUTPUT
 187
 188 test_begin_subtest "end atomic section for a closed db"
 189 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 190     {
 191         EXPECT0(notmuch_database_close (db));
 192         EXPECT0(notmuch_database_begin_atomic (db));
 193         stat = notmuch_database_end_atomic (db);
 194         printf ("%d\n", stat == NOTMUCH_STATUS_SUCCESS ||
 195                         stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 196         stat = NOTMUCH_STATUS_SUCCESS;
 197     }
 198 EOF
 199 cat <<EOF > EXPECTED
 200 == stdout ==
 201 1
 202 == stderr ==
 203 EOF
 204 test_expect_equal_file EXPECTED OUTPUT
 205
 206 test_begin_subtest "get revision for a closed db"
 207 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 208     {
 209         const char *uuid;
 210         unsigned long rev;
 211
 212         EXPECT0(notmuch_database_close (db));
 213         rev = notmuch_database_get_revision (db, &uuid);
 214         printf ("%d\n", rev, uuid);
 215     }
 216 EOF
 217 cat <<EOF > EXPECTED
 218 == stdout ==
 219 53
 220 == stderr ==
 221 EOF
 222 test_expect_equal_file EXPECTED OUTPUT
 223
 224 test_begin_subtest "get directory for a closed db"
 225 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 226     {
 227         notmuch_directory_t *dir;
 228         EXPECT0(notmuch_database_close (db));
 229         stat = notmuch_database_get_directory (db, "/nonexistent", &dir);
 230         printf ("%d\n", stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 231     }
 232 EOF
 233 cat <<EOF > EXPECTED
 234 == stdout ==
 235 1
 236 == stderr ==
 237 A Xapian exception occurred finding/creating a directory: Database has been closed.
 238 EOF
 239 test_expect_equal_file EXPECTED OUTPUT
 240
 241 test_begin_subtest "index file with a closed db"
 242 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 243     {
 244         notmuch_message_t *msg;
 245         const char *path = talloc_asprintf(db, "%s/01:2,", argv[1]);
 246         EXPECT0(notmuch_database_close (db));
 247         stat = notmuch_database_index_file (db, path, NULL, &msg);
 248         printf ("%d\n", stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 249     }
 250 EOF
 251 cat <<EOF > EXPECTED
 252 == stdout ==
 253 1
 254 == stderr ==
 255 A Xapian exception occurred finding message: Database has been closed.
 256 EOF
 257 test_expect_equal_file EXPECTED OUTPUT
 258
 259 generate_message '[filename]=relative_path'
 260 test_begin_subtest "index file (relative path)"
 261 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 262     {
 263         notmuch_message_t *msg;
 264         stat = notmuch_database_index_file (db, "relative_path", NULL, &msg);
 265         printf ("%d\n", stat == NOTMUCH_STATUS_SUCCESS);
 266     }
 267 EOF
 268 cat <<EOF > EXPECTED
 269 == stdout ==
 270 1
 271 == stderr ==
 272 EOF
 273 test_expect_equal_file EXPECTED OUTPUT
 274
 275 test_begin_subtest "index file (absolute path outside mail root)"
 276 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 277     {
 278         notmuch_message_t *msg;
 279         stat = notmuch_database_index_file (db, "/dev/zero", NULL, &msg);
 280         printf ("%d\n", stat == NOTMUCH_STATUS_FILE_ERROR);
 281     }
 282 EOF
 283 cat <<EOF > EXPECTED
 284 == stdout ==
 285 1
 286 == stderr ==
 287 Error opening /dev/zero: path outside mail root
 288 EOF
 289 test_expect_equal_file EXPECTED OUTPUT
 290
 291 test_begin_subtest "remove message file with a closed db"
 292 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 293     {
 294         EXPECT0(notmuch_database_close (db));
 295         stat = notmuch_database_remove_message (db, "01:2,");
 296         printf ("%d\n", stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 297     }
 298 EOF
 299 cat <<EOF > EXPECTED
 300 == stdout ==
 301 1
 302 == stderr ==
 303 A Xapian exception occurred finding/creating a directory: Database has been closed.
 304 EOF
 305 test_expect_equal_file EXPECTED OUTPUT
 306
 307 test_begin_subtest "find message by filename with a closed db"
 308 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 309     {
 310         notmuch_message_t *msg;
 311         EXPECT0(notmuch_database_close (db));
 312         stat = notmuch_database_find_message_by_filename (db, "01:2,", &msg);
 313         printf ("%d\n", stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 314     }
 315 EOF
 316 cat <<EOF > EXPECTED
 317 == stdout ==
 318 1
 319 == stderr ==
 320 A Xapian exception occurred finding/creating a directory: Database has been closed.
 321 EOF
 322 test_expect_equal_file EXPECTED OUTPUT
 323
 324 test_begin_subtest "Handle getting tags from closed database"
 325 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 326     {
 327         notmuch_tags_t *result;
 328         EXPECT0(notmuch_database_close (db));
 329         result = notmuch_database_get_all_tags (db);
 330         printf("%d\n",  result == NULL);
 331         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 332     }
 333 EOF
 334 cat <<EOF > EXPECTED
 335 == stdout ==
 336 1
 337 == stderr ==
 338 A Xapian exception occurred getting tags: Database has been closed.
 339 EOF
 340 test_expect_equal_file EXPECTED OUTPUT
 341
 342 test_begin_subtest "get config from closed database"
 343 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 344     {
 345         const char *result;
 346         EXPECT0(notmuch_database_close (db));
 347         stat = notmuch_database_get_config (db, "foo", &result);
 348         printf("%d\n",  stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 349     }
 350 EOF
 351 cat <<EOF > EXPECTED
 352 == stdout ==
 353 1
 354 == stderr ==
 355 Error: A Xapian exception occurred getting metadata: Database has been closed
 356 EOF
 357 test_expect_equal_file EXPECTED OUTPUT
 358
 359 test_begin_subtest "set config in closed database"
 360 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 361     {
 362         EXPECT0(notmuch_database_close (db));
 363         stat = notmuch_database_set_config (db, "foo", "bar");
 364         printf("%d\n",  stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 365     }
 366 EOF
 367 cat <<EOF > EXPECTED
 368 == stdout ==
 369 1
 370 == stderr ==
 371 Error: A Xapian exception occurred setting metadata: Database has been closed
 372 EOF
 373 test_expect_equal_file EXPECTED OUTPUT
 374
 375 test_begin_subtest "get indexopts from closed database"
 376 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 377     {
 378         notmuch_indexopts_t *result;
 379         EXPECT0(notmuch_database_close (db));
 380         result = notmuch_database_get_default_indexopts (db);
 381         printf("%d\n",  result == NULL);
 382     }
 383 EOF
 384 cat <<EOF > EXPECTED
 385 == stdout ==
 386 1
 387 == stderr ==
 388 EOF
 389 test_expect_equal_file EXPECTED OUTPUT
 390
 391 test_begin_subtest "get decryption policy from closed database"
 392 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 393     {
 394         notmuch_indexopts_t *result;
 395         result = notmuch_database_get_default_indexopts (db);
 396         EXPECT0(notmuch_database_close (db));
 397         notmuch_decryption_policy_t policy = notmuch_indexopts_get_decrypt_policy (result);
 398         printf ("%d\n",  policy == NOTMUCH_DECRYPT_AUTO);
 399         notmuch_indexopts_destroy (result);
 400         printf ("SUCCESS\n");
 401     }
 402 EOF
 403 cat <<EOF > EXPECTED
 404 == stdout ==
 405 1
 406 SUCCESS
 407 == stderr ==
 408 EOF
 409 test_expect_equal_file EXPECTED OUTPUT
 410
 411 test_begin_subtest "set decryption policy with closed database"
 412 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 413     {
 414         notmuch_indexopts_t *result;
 415         result = notmuch_database_get_default_indexopts (db);
 416         EXPECT0(notmuch_database_close (db));
 417         notmuch_decryption_policy_t policy = notmuch_indexopts_get_decrypt_policy (result);
 418         stat = notmuch_indexopts_set_decrypt_policy (result, policy);
 419         printf("%d\n%d\n",  policy == NOTMUCH_DECRYPT_AUTO, stat == NOTMUCH_STATUS_SUCCESS);
 420     }
 421 EOF
 422 cat <<EOF > EXPECTED
 423 == stdout ==
 424 1
 425 1
 426 == stderr ==
 427 EOF
 428 test_expect_equal_file EXPECTED OUTPUT
 429
 430 test_done