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