]> git.cworth.org Git - notmuch-old/blob - test/T562-lib-database.sh
Merge branch 'release'
[notmuch-old] / 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 lib/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 lib/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