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 <notmuch-test.h>
  13
  14 int main (int argc, char** argv)
  15 {
  16    notmuch_database_t *db;
  17    notmuch_status_t stat = NOTMUCH_STATUS_SUCCESS;
  18    char *msg = NULL;
  19
  20    stat = notmuch_database_open_with_config (argv[1],
  21                                              NOTMUCH_DATABASE_MODE_READ_WRITE,
  22                                              NULL, NULL, &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 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 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         EXPECT0(notmuch_database_close (db));
 158         stat = notmuch_database_upgrade (db, NULL, NULL);
 159         printf ("%d\n", stat == NOTMUCH_STATUS_SUCCESS);
 160     }
 161 EOF
 162 cat <<EOF > EXPECTED
 163 == stdout ==
 164 1
 165 == stderr ==
 166 EOF
 167 test_expect_equal_file EXPECTED OUTPUT
 168
 169 test_begin_subtest "begin atomic section for a closed db"
 170 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 171     {
 172         EXPECT0(notmuch_database_close (db));
 173         stat = notmuch_database_begin_atomic (db);
 174         printf ("%d\n", stat == NOTMUCH_STATUS_SUCCESS ||
 175                         stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 176         stat = NOTMUCH_STATUS_SUCCESS;
 177     }
 178 EOF
 179 cat <<EOF > EXPECTED
 180 == stdout ==
 181 1
 182 == stderr ==
 183 EOF
 184 test_expect_equal_file EXPECTED OUTPUT
 185
 186 test_begin_subtest "end atomic section for a closed db"
 187 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 188     {
 189         EXPECT0(notmuch_database_close (db));
 190         EXPECT0(notmuch_database_begin_atomic (db));
 191         stat = notmuch_database_end_atomic (db);
 192         printf ("%d\n", stat == NOTMUCH_STATUS_SUCCESS ||
 193                         stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 194         stat = NOTMUCH_STATUS_SUCCESS;
 195     }
 196 EOF
 197 cat <<EOF > EXPECTED
 198 == stdout ==
 199 1
 200 == stderr ==
 201 EOF
 202 test_expect_equal_file EXPECTED OUTPUT
 203
 204 test_begin_subtest "get revision for a closed db"
 205 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 206     {
 207         const char *uuid;
 208         unsigned long rev;
 209
 210         EXPECT0(notmuch_database_close (db));
 211         rev = notmuch_database_get_revision (db, &uuid);
 212         printf ("%d\n", rev, uuid);
 213     }
 214 EOF
 215 cat <<EOF > EXPECTED
 216 == stdout ==
 217 53
 218 == stderr ==
 219 EOF
 220 test_expect_equal_file EXPECTED OUTPUT
 221
 222 test_begin_subtest "get directory for a closed db"
 223 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 224     {
 225         notmuch_directory_t *dir;
 226         EXPECT0(notmuch_database_close (db));
 227         stat = notmuch_database_get_directory (db, "/nonexistent", &dir);
 228         printf ("%d\n", stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 229     }
 230 EOF
 231 cat <<EOF > EXPECTED
 232 == stdout ==
 233 1
 234 == stderr ==
 235 A Xapian exception occurred finding/creating a directory: Database has been closed.
 236 EOF
 237 test_expect_equal_file EXPECTED OUTPUT
 238
 239 test_begin_subtest "index file with a closed db"
 240 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 241     {
 242         notmuch_message_t *msg;
 243         const char *path = talloc_asprintf(db, "%s/01:2,", argv[1]);
 244         EXPECT0(notmuch_database_close (db));
 245         stat = notmuch_database_index_file (db, path, NULL, &msg);
 246         printf ("%d\n", stat == NOTMUCH_STATUS_CLOSED_DATABASE);
 247     }
 248 EOF
 249 cat <<EOF > EXPECTED
 250 == stdout ==
 251 1
 252 == stderr ==
 253 Cannot write to a closed database.
 254 EOF
 255 test_expect_equal_file EXPECTED OUTPUT
 256
 257 generate_message '[filename]=relative_path'
 258 test_begin_subtest "index file (relative path)"
 259 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 260     {
 261         notmuch_message_t *msg;
 262         stat = notmuch_database_index_file (db, "relative_path", NULL, &msg);
 263         printf ("%d\n", stat == NOTMUCH_STATUS_SUCCESS);
 264     }
 265 EOF
 266 cat <<EOF > EXPECTED
 267 == stdout ==
 268 1
 269 == stderr ==
 270 EOF
 271 test_expect_equal_file EXPECTED OUTPUT
 272
 273 test_begin_subtest "index file (absolute path outside mail root)"
 274 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 275     {
 276         notmuch_message_t *msg;
 277         stat = notmuch_database_index_file (db, "/dev/zero", NULL, &msg);
 278         printf ("%d\n", stat == NOTMUCH_STATUS_FILE_ERROR);
 279     }
 280 EOF
 281 cat <<EOF > EXPECTED
 282 == stdout ==
 283 1
 284 == stderr ==
 285 Error opening /dev/zero: path outside mail root
 286 EOF
 287 test_expect_equal_file EXPECTED OUTPUT
 288
 289 test_begin_subtest "remove message file with a closed db"
 290 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 291     {
 292         EXPECT0(notmuch_database_close (db));
 293         stat = notmuch_database_remove_message (db, "01:2,");
 294         printf ("%d\n", stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 295     }
 296 EOF
 297 cat <<EOF > EXPECTED
 298 == stdout ==
 299 1
 300 == stderr ==
 301 A Xapian exception occurred finding/creating a directory: Database has been closed.
 302 EOF
 303 test_expect_equal_file EXPECTED OUTPUT
 304
 305 test_begin_subtest "find message by filename with a closed db"
 306 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 307     {
 308         notmuch_message_t *msg;
 309         EXPECT0(notmuch_database_close (db));
 310         stat = notmuch_database_find_message_by_filename (db, "01:2,", &msg);
 311         printf ("%d\n", stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 312     }
 313 EOF
 314 cat <<EOF > EXPECTED
 315 == stdout ==
 316 1
 317 == stderr ==
 318 A Xapian exception occurred finding/creating a directory: Database has been closed.
 319 EOF
 320 test_expect_equal_file EXPECTED OUTPUT
 321
 322 test_begin_subtest "Handle getting tags from closed database"
 323 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 324     {
 325         notmuch_tags_t *result;
 326         EXPECT0(notmuch_database_close (db));
 327         result = notmuch_database_get_all_tags (db);
 328         printf("%d\n", result == NULL);
 329         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 330     }
 331 EOF
 332 cat <<EOF > EXPECTED
 333 == stdout ==
 334 1
 335 == stderr ==
 336 A Xapian exception occurred getting tags: Database has been closed.
 337 EOF
 338 test_expect_equal_file EXPECTED OUTPUT
 339
 340 test_begin_subtest "get config from closed database"
 341 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 342     {
 343         char *result;
 344         EXPECT0(notmuch_database_close (db));
 345         stat = notmuch_database_get_config (db, "foo", &result);
 346         printf("%d\n", stat == NOTMUCH_STATUS_SUCCESS);
 347     }
 348 EOF
 349 cat <<EOF > EXPECTED
 350 == stdout ==
 351 1
 352 == stderr ==
 353 EOF
 354 test_expect_equal_file EXPECTED OUTPUT
 355
 356 test_begin_subtest "set config in closed database"
 357 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 358     {
 359         EXPECT0(notmuch_database_close (db));
 360         stat = notmuch_database_set_config (db, "foo", "bar");
 361         printf("%d\n", stat == NOTMUCH_STATUS_CLOSED_DATABASE);
 362     }
 363 EOF
 364 cat <<EOF > EXPECTED
 365 == stdout ==
 366 1
 367 == stderr ==
 368 Cannot write to a closed database.
 369 EOF
 370 test_expect_equal_file EXPECTED OUTPUT
 371
 372 test_begin_subtest "get indexopts from closed database"
 373 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 374     {
 375         notmuch_indexopts_t *result;
 376         EXPECT0(notmuch_database_close (db));
 377         result = notmuch_database_get_default_indexopts (db);
 378         printf("%d\n", result != NULL);
 379     }
 380 EOF
 381 cat <<EOF > EXPECTED
 382 == stdout ==
 383 1
 384 == stderr ==
 385 EOF
 386 test_expect_equal_file EXPECTED OUTPUT
 387
 388 test_begin_subtest "get decryption policy from closed database"
 389 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 390     {
 391         notmuch_indexopts_t *result;
 392         result = notmuch_database_get_default_indexopts (db);
 393         EXPECT0(notmuch_database_close (db));
 394         notmuch_decryption_policy_t policy = notmuch_indexopts_get_decrypt_policy (result);
 395         printf ("%d\n",  policy == NOTMUCH_DECRYPT_AUTO);
 396         notmuch_indexopts_destroy (result);
 397         printf ("SUCCESS\n");
 398     }
 399 EOF
 400 cat <<EOF > EXPECTED
 401 == stdout ==
 402 1
 403 SUCCESS
 404 == stderr ==
 405 EOF
 406 test_expect_equal_file EXPECTED OUTPUT
 407
 408 test_begin_subtest "set decryption policy with closed database"
 409 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 410     {
 411         notmuch_indexopts_t *result;
 412         result = notmuch_database_get_default_indexopts (db);
 413         EXPECT0(notmuch_database_close (db));
 414         notmuch_decryption_policy_t policy = notmuch_indexopts_get_decrypt_policy (result);
 415         stat = notmuch_indexopts_set_decrypt_policy (result, policy);
 416         printf("%d\n%d\n", policy == NOTMUCH_DECRYPT_AUTO, stat == NOTMUCH_STATUS_SUCCESS);
 417     }
 418 EOF
 419 cat <<EOF > EXPECTED
 420 == stdout ==
 421 1
 422 1
 423 == stderr ==
 424 EOF
 425 test_expect_equal_file EXPECTED OUTPUT
 426
 427 test_done