git migration: Refactor the ASTERISK_FILE_VERSION macro
[asterisk/asterisk.git] / tests / test_bucket.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \brief Bucket Unit Tests
22  *
23  * \author Joshua Colp <jcolp@digium.com>
24  *
25  */
26
27 /*** MODULEINFO
28         <depend>TEST_FRAMEWORK</depend>
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_REGISTER_FILE()
35
36 #include <sys/stat.h>
37
38 #include "asterisk/test.h"
39 #include "asterisk/module.h"
40 #include "asterisk/bucket.h"
41 #include "asterisk/logger.h"
42 #include "asterisk/json.h"
43 #include "asterisk/file.h"
44
45 /*! \brief Test state structure for scheme wizards */
46 struct bucket_test_state {
47         /*! \brief Whether the object has been created or not */
48         unsigned int created:1;
49         /*! \brief Whether the object has been updated or not */
50         unsigned int updated:1;
51         /*! \brief Whether the object has been deleted or not */
52         unsigned int deleted:1;
53 };
54
55 /*! \brief Global scope structure for testing bucket wizards */
56 static struct bucket_test_state bucket_test_wizard_state;
57
58 static void bucket_test_wizard_clear(void)
59 {
60         bucket_test_wizard_state.created = 0;
61         bucket_test_wizard_state.updated = 0;
62         bucket_test_wizard_state.deleted = 0;
63 }
64
65 static int bucket_test_wizard_create(const struct ast_sorcery *sorcery, void *data, void *object)
66 {
67         if (bucket_test_wizard_state.created) {
68                 return -1;
69         }
70
71         bucket_test_wizard_state.created = 1;
72
73         return 0;
74 }
75
76 static int bucket_test_wizard_update(const struct ast_sorcery *sorcery, void *data, void *object)
77 {
78         if (bucket_test_wizard_state.updated) {
79                 return -1;
80         }
81
82         bucket_test_wizard_state.updated = 1;
83
84         return 0;
85 }
86
87 static void *bucket_test_wizard_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type,
88         const char *id)
89 {
90         if (!strcmp(type, "bucket")) {
91                 return ast_bucket_alloc(id);
92         } else if (!strcmp(type, "file")) {
93                 return ast_bucket_file_alloc(id);
94         } else {
95                 return NULL;
96         }
97 }
98
99 static int bucket_test_wizard_delete(const struct ast_sorcery *sorcery, void *data, void *object)
100 {
101         if (bucket_test_wizard_state.deleted) {
102                 return -1;
103         }
104
105         bucket_test_wizard_state.deleted = 1;
106
107         return 0;
108 }
109
110 static struct ast_sorcery_wizard bucket_test_wizard = {
111         .name = "test",
112         .create = bucket_test_wizard_create,
113         .retrieve_id = bucket_test_wizard_retrieve_id,
114         .delete = bucket_test_wizard_delete,
115 };
116
117 static struct ast_sorcery_wizard bucket_file_test_wizard = {
118         .name = "test",
119         .create = bucket_test_wizard_create,
120         .update = bucket_test_wizard_update,
121         .retrieve_id = bucket_test_wizard_retrieve_id,
122         .delete = bucket_test_wizard_delete,
123 };
124
125 AST_TEST_DEFINE(bucket_scheme_register)
126 {
127         switch (cmd) {
128         case TEST_INIT:
129                 info->name = "bucket_scheme_register_unregister";
130                 info->category = "/main/bucket/";
131                 info->summary = "bucket scheme registration/unregistration unit test";
132                 info->description =
133                         "Test registration and unregistration of bucket scheme";
134                 return AST_TEST_NOT_RUN;
135         case TEST_EXECUTE:
136                 break;
137         }
138
139         if (!ast_bucket_scheme_register("", NULL, NULL, NULL, NULL)) {
140                 ast_test_status_update(test, "Successfully registered a Bucket scheme without name or wizards\n");
141                 return AST_TEST_FAIL;
142         }
143
144         if (!ast_bucket_scheme_register("test", &bucket_test_wizard, &bucket_file_test_wizard, NULL, NULL)) {
145                 ast_test_status_update(test, "Successfully registered a Bucket scheme twice\n");
146                 return AST_TEST_FAIL;
147         }
148
149         return AST_TEST_PASS;
150 }
151
152 AST_TEST_DEFINE(bucket_alloc)
153 {
154         RAII_VAR(struct ast_bucket *, bucket, NULL, ao2_cleanup);
155
156         switch (cmd) {
157         case TEST_INIT:
158                 info->name = "bucket_alloc";
159                 info->category = "/main/bucket/";
160                 info->summary = "bucket allocation unit test";
161                 info->description =
162                         "Test allocation of buckets";
163                 return AST_TEST_NOT_RUN;
164         case TEST_EXECUTE:
165                 break;
166         }
167
168         if ((bucket = ast_bucket_alloc(""))) {
169                 ast_test_status_update(test, "Allocated a bucket with no URI provided\n");
170                 return AST_TEST_FAIL;
171         }
172
173         if (!(bucket = ast_bucket_alloc("test:///tmp/bob"))) {
174                 ast_test_status_update(test, "Failed to allocate bucket\n");
175                 return AST_TEST_FAIL;
176         }
177
178         if (strcmp(ast_sorcery_object_get_id(bucket), "test:///tmp/bob")) {
179                 ast_test_status_update(test, "URI within allocated bucket is '%s' and should be test:///tmp/bob\n",
180                         ast_sorcery_object_get_id(bucket));
181                 return AST_TEST_FAIL;
182         }
183
184         if (strcmp(bucket->scheme, "test")) {
185                 ast_test_status_update(test, "Scheme within allocated bucket is '%s' and should be test\n",
186                         bucket->scheme);
187                 return AST_TEST_FAIL;
188         }
189
190         return AST_TEST_PASS;
191 }
192
193 AST_TEST_DEFINE(bucket_create)
194 {
195         RAII_VAR(struct ast_bucket *, bucket, NULL, ao2_cleanup);
196
197         switch (cmd) {
198         case TEST_INIT:
199                 info->name = "bucket_create";
200                 info->category = "/main/bucket/";
201                 info->summary = "bucket creation unit test";
202                 info->description =
203                         "Test creation of buckets";
204                 return AST_TEST_NOT_RUN;
205         case TEST_EXECUTE:
206                 break;
207         }
208
209         if (!(bucket = ast_bucket_alloc("test:///tmp/bob"))) {
210                 ast_test_status_update(test, "Failed to allocate bucket\n");
211                 return AST_TEST_FAIL;
212         }
213
214         bucket_test_wizard_clear();
215
216         if (ast_bucket_create(bucket)) {
217                 ast_test_status_update(test, "Failed to create bucket with URI '%s'\n",
218                         ast_sorcery_object_get_id(bucket));
219                 return AST_TEST_FAIL;
220         }
221
222         if (!bucket_test_wizard_state.created) {
223                 ast_test_status_update(test, "Bucket creation returned success but scheme implementation never actually created it\n");
224                 return AST_TEST_FAIL;
225         }
226
227         if (!ast_bucket_create(bucket)) {
228                 ast_test_status_update(test, "Successfully created bucket with URI '%s' twice\n",
229                         ast_sorcery_object_get_id(bucket));
230                 return AST_TEST_FAIL;
231         }
232
233         return AST_TEST_PASS;
234 }
235
236 AST_TEST_DEFINE(bucket_delete)
237 {
238         RAII_VAR(struct ast_bucket *, bucket, NULL, ao2_cleanup);
239
240         switch (cmd) {
241         case TEST_INIT:
242                 info->name = "bucket_delete";
243                 info->category = "/main/bucket/";
244                 info->summary = "bucket deletion unit test";
245                 info->description =
246                         "Test deletion of buckets";
247                 return AST_TEST_NOT_RUN;
248         case TEST_EXECUTE:
249                 break;
250         }
251
252         if (!(bucket = ast_bucket_alloc("test:///tmp/bob"))) {
253                 ast_test_status_update(test, "Failed to allocate bucket\n");
254                 return AST_TEST_FAIL;
255         }
256
257         bucket_test_wizard_clear();
258
259         if (ast_bucket_delete(bucket)) {
260                 ast_test_status_update(test, "Failed to delete bucket with URI '%s'\n",
261                         ast_sorcery_object_get_id(bucket));
262                 return AST_TEST_FAIL;
263         }
264
265         if (!bucket_test_wizard_state.deleted) {
266                 ast_test_status_update(test, "Bucket deletion returned success but scheme implementation never actually deleted it\n");
267                 return AST_TEST_FAIL;
268         }
269
270         if (!ast_bucket_delete(bucket)) {
271                 ast_test_status_update(test, "Successfully deleted bucket with URI '%s' twice\n",
272                         ast_sorcery_object_get_id(bucket));
273                 return AST_TEST_FAIL;
274         }
275
276         return AST_TEST_PASS;
277 }
278
279 AST_TEST_DEFINE(bucket_json)
280 {
281         RAII_VAR(struct ast_bucket *, bucket, NULL, ao2_cleanup);
282         RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
283         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
284
285         switch (cmd) {
286         case TEST_INIT:
287                 info->name = "bucket_json";
288                 info->category = "/main/bucket/";
289                 info->summary = "bucket json unit test";
290                 info->description =
291                         "Test creation of JSON for a bucket";
292                 return AST_TEST_NOT_RUN;
293         case TEST_EXECUTE:
294                 break;
295         }
296
297         if (!(bucket = ast_bucket_alloc("test:///tmp/bob"))) {
298                 ast_test_status_update(test, "Failed to allocate bucket\n");
299                 return AST_TEST_FAIL;
300         }
301
302         ast_str_container_add(bucket->buckets, "test:///tmp/bob/joe");
303         ast_str_container_add(bucket->files, "test:///tmp/bob/recording.wav");
304
305         expected = ast_json_pack("{s: s, s: s, s: [s], s: s, s: [s], s: s}",
306                 "modified", "0.000000", "created", "0.000000",
307                 "buckets", "test:///tmp/bob/joe",
308                 "scheme", "test",
309                 "files", "test:///tmp/bob/recording.wav",
310                 "id", "test:///tmp/bob");
311         if (!expected) {
312                 ast_test_status_update(test, "Could not produce JSON for expected bucket value\n");
313                 return AST_TEST_FAIL;
314         }
315
316         json = ast_bucket_json(bucket);
317         if (!json) {
318                 ast_test_status_update(test, "Could not produce JSON for a valid bucket\n");
319                 return AST_TEST_FAIL;
320         }
321
322         if (!ast_json_equal(json, expected)) {
323                 ast_test_status_update(test, "Bucket JSON does not match expected output\n");
324                 return AST_TEST_FAIL;
325         }
326
327         return AST_TEST_PASS;
328 }
329
330 AST_TEST_DEFINE(bucket_retrieve)
331 {
332         RAII_VAR(struct ast_bucket *, bucket, NULL, ao2_cleanup);
333
334         switch (cmd) {
335         case TEST_INIT:
336                 info->name = "bucket_retrieve";
337                 info->category = "/main/bucket/";
338                 info->summary = "bucket retrieval unit test";
339                 info->description =
340                         "Test retrieval of buckets";
341                 return AST_TEST_NOT_RUN;
342         case TEST_EXECUTE:
343                 break;
344         }
345
346         if (!(bucket = ast_bucket_retrieve("test://tmp/bob"))) {
347                 ast_test_status_update(test, "Failed to retrieve known valid bucket\n");
348                 return AST_TEST_FAIL;
349         }
350
351         return AST_TEST_PASS;
352 }
353
354 AST_TEST_DEFINE(bucket_file_alloc)
355 {
356         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
357
358         switch (cmd) {
359         case TEST_INIT:
360                 info->name = "bucket_file_alloc";
361                 info->category = "/main/bucket/";
362                 info->summary = "bucket file allocation unit test";
363                 info->description =
364                         "Test allocation of bucket files";
365                 return AST_TEST_NOT_RUN;
366         case TEST_EXECUTE:
367                 break;
368         }
369
370         if ((file = ast_bucket_file_alloc(""))) {
371                 ast_test_status_update(test, "Allocated a file with no URI provided\n");
372                 return AST_TEST_FAIL;
373         }
374
375         if (!(file = ast_bucket_file_alloc("test:///tmp/bob"))) {
376                 ast_test_status_update(test, "Failed to allocate file\n");
377                 return AST_TEST_FAIL;
378         }
379
380         if (ast_strlen_zero(file->path)) {
381                 ast_test_status_update(test, "Expected temporary path in allocated file");
382                 return AST_TEST_FAIL;
383         }
384
385         if (strcmp(ast_sorcery_object_get_id(file), "test:///tmp/bob")) {
386                 ast_test_status_update(test, "URI within allocated file is '%s' and should be test:///tmp/bob\n",
387                         ast_sorcery_object_get_id(file));
388                 return AST_TEST_FAIL;
389         }
390
391         if (strcmp(file->scheme, "test")) {
392                 ast_test_status_update(test, "Scheme within allocated file is '%s' and should be test\n",
393                         file->scheme);
394                 return AST_TEST_FAIL;
395         }
396
397         return AST_TEST_PASS;
398 }
399
400 AST_TEST_DEFINE(bucket_file_create)
401 {
402         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
403
404         switch (cmd) {
405         case TEST_INIT:
406                 info->name = "bucket_file_create";
407                 info->category = "/main/bucket/";
408                 info->summary = "file creation unit test";
409                 info->description =
410                         "Test creation of files";
411                 return AST_TEST_NOT_RUN;
412         case TEST_EXECUTE:
413                 break;
414         }
415
416         if (!(file = ast_bucket_file_alloc("test:///tmp/bob"))) {
417                 ast_test_status_update(test, "Failed to allocate file\n");
418                 return AST_TEST_FAIL;
419         }
420
421         bucket_test_wizard_clear();
422
423         if (ast_bucket_file_create(file)) {
424                 ast_test_status_update(test, "Failed to create file with URI '%s'\n",
425                         ast_sorcery_object_get_id(file));
426                 return AST_TEST_FAIL;
427         }
428
429         if (!bucket_test_wizard_state.created) {
430                 ast_test_status_update(test, "Bucket file creation returned success but scheme implementation never actually created it\n");
431                 return AST_TEST_FAIL;
432         }
433
434         if (!ast_bucket_file_create(file)) {
435                 ast_test_status_update(test, "Successfully created file with URI '%s' twice\n",
436                         ast_sorcery_object_get_id(file));
437                 return AST_TEST_FAIL;
438         }
439
440         return AST_TEST_PASS;
441 }
442
443 AST_TEST_DEFINE(bucket_file_copy)
444 {
445         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
446         RAII_VAR(struct ast_bucket_file *, copy, NULL, ao2_cleanup);
447         FILE *temporary;
448         struct stat old, new;
449         RAII_VAR(struct ast_bucket_metadata *, metadata, NULL, ao2_cleanup);
450
451         switch (cmd) {
452         case TEST_INIT:
453                 info->name = "bucket_file_copy";
454                 info->category = "/main/bucket/";
455                 info->summary = "bucket file copying unit test";
456                 info->description =
457                         "Test copying of bucket files";
458                 return AST_TEST_NOT_RUN;
459         case TEST_EXECUTE:
460                 break;
461         }
462
463         if (!(file = ast_bucket_file_alloc("test:///tmp/bob"))) {
464                 ast_test_status_update(test, "Failed to allocate file\n");
465                 return AST_TEST_FAIL;
466         }
467
468         ast_bucket_file_metadata_set(file, "bob", "joe");
469
470         if (!(temporary = fopen(file->path, "w"))) {
471                 ast_test_status_update(test, "Failed to open temporary file '%s'\n", file->path);
472                 return AST_TEST_FAIL;
473         }
474
475         fprintf(temporary, "bob");
476         fclose(temporary);
477
478         if (!(copy = ast_bucket_file_copy(file, "test:///tmp/bob2"))) {
479                 ast_test_status_update(test, "Failed to copy file '%s' to test:///tmp/bob2\n",
480                         ast_sorcery_object_get_id(file));
481                 return AST_TEST_FAIL;
482         }
483
484         if (stat(file->path, &old)) {
485                 ast_test_status_update(test, "Failed to retrieve information on old file '%s'\n", file->path);
486                 return AST_TEST_FAIL;
487         }
488
489         if (stat(copy->path, &new)) {
490                 ast_test_status_update(test, "Failed to retrieve information on copy file '%s'\n", copy->path);
491                 return AST_TEST_FAIL;
492         }
493
494         if (old.st_size != new.st_size) {
495                 ast_test_status_update(test, "Copying of underlying temporary file failed\n");
496                 return AST_TEST_FAIL;
497         }
498
499         if (ao2_container_count(file->metadata) != ao2_container_count(copy->metadata)) {
500                 ast_test_status_update(test, "Number of metadata entries does not match original\n");
501                 return AST_TEST_FAIL;
502         }
503
504         metadata = ast_bucket_file_metadata_get(copy, "bob");
505         if (!metadata) {
506                 ast_test_status_update(test, "Copy of file does not have expected metadata\n");
507                 return AST_TEST_FAIL;
508         }
509
510         if (strcmp(metadata->value, "joe")) {
511                 ast_test_status_update(test, "Copy of file contains metadata for 'bob' but value is not what it should be\n");
512                 return AST_TEST_FAIL;
513         }
514
515         return AST_TEST_PASS;
516 }
517
518 AST_TEST_DEFINE(bucket_file_retrieve)
519 {
520         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
521
522         switch (cmd) {
523         case TEST_INIT:
524                 info->name = "bucket_file_retrieve";
525                 info->category = "/main/bucket/";
526                 info->summary = "file retrieval unit test";
527                 info->description =
528                         "Test retrieval of files";
529                 return AST_TEST_NOT_RUN;
530         case TEST_EXECUTE:
531                 break;
532         }
533
534         if (!(file = ast_bucket_file_retrieve("test://tmp/bob"))) {
535                 ast_test_status_update(test, "Failed to retrieve known valid file\n");
536                 return AST_TEST_FAIL;
537         }
538
539         return AST_TEST_PASS;
540 }
541
542 AST_TEST_DEFINE(bucket_file_update)
543 {
544         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
545
546         switch (cmd) {
547         case TEST_INIT:
548                 info->name = "bucket_file_update";
549                 info->category = "/main/bucket/";
550                 info->summary = "file updating unit test";
551                 info->description =
552                         "Test updating of files";
553                 return AST_TEST_NOT_RUN;
554         case TEST_EXECUTE:
555                 break;
556         }
557
558         if (!(file = ast_bucket_file_alloc("test:///tmp/bob"))) {
559                 ast_test_status_update(test, "Failed to allocate file\n");
560                 return AST_TEST_FAIL;
561         }
562
563         bucket_test_wizard_clear();
564
565         if (ast_bucket_file_update(file)) {
566                 ast_test_status_update(test, "Failed to update file with URI '%s'\n",
567                         ast_sorcery_object_get_id(file));
568                 return AST_TEST_FAIL;
569         }
570
571         if (!bucket_test_wizard_state.updated) {
572                 ast_test_status_update(test, "Successfully returned file was updated, but it was not\n");
573                 return AST_TEST_FAIL;
574         }
575
576         if (!ast_bucket_file_update(file)) {
577                 ast_test_status_update(test, "Successfully updated file with URI '%s' twice\n",
578                         ast_sorcery_object_get_id(file));
579                 return AST_TEST_FAIL;
580         }
581
582         return AST_TEST_PASS;
583 }
584
585 AST_TEST_DEFINE(bucket_file_delete)
586 {
587         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
588
589         switch (cmd) {
590         case TEST_INIT:
591                 info->name = "bucket_file_delete";
592                 info->category = "/main/bucket/";
593                 info->summary = "file deletion unit test";
594                 info->description =
595                         "Test deletion of files";
596                 return AST_TEST_NOT_RUN;
597         case TEST_EXECUTE:
598                 break;
599         }
600
601         if (!(file = ast_bucket_file_alloc("test:///tmp/bob"))) {
602                 ast_test_status_update(test, "Failed to allocate file\n");
603                 return AST_TEST_FAIL;
604         }
605
606         bucket_test_wizard_clear();
607
608         if (ast_bucket_file_delete(file)) {
609                 ast_test_status_update(test, "Failed to delete file with URI '%s'\n",
610                         ast_sorcery_object_get_id(file));
611                 return AST_TEST_FAIL;
612         }
613
614         if (!bucket_test_wizard_state.deleted) {
615                 ast_test_status_update(test, "Bucket file deletion returned success but scheme implementation never actually deleted it\n");
616                 return AST_TEST_FAIL;
617         }
618
619         if (!ast_bucket_file_delete(file)) {
620                 ast_test_status_update(test, "Successfully deleted file with URI '%s' twice\n",
621                         ast_sorcery_object_get_id(file));
622                 return AST_TEST_FAIL;
623         }
624
625         return AST_TEST_PASS;
626 }
627
628 AST_TEST_DEFINE(bucket_file_metadata_set)
629 {
630         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
631         RAII_VAR(struct ast_bucket_metadata *, metadata, NULL, ao2_cleanup);
632
633         switch (cmd) {
634         case TEST_INIT:
635                 info->name = "bucket_file_metadata_set";
636                 info->category = "/main/bucket/";
637                 info->summary = "file metadata setting unit test";
638                 info->description =
639                         "Test setting of metadata on files";
640                 return AST_TEST_NOT_RUN;
641         case TEST_EXECUTE:
642                 break;
643         }
644
645         if (!(file = ast_bucket_file_alloc("test:///tmp/bob"))) {
646                 ast_test_status_update(test, "Failed to allocate file\n");
647                 return AST_TEST_FAIL;
648         }
649
650         if (ao2_container_count(file->metadata) != 0) {
651                 ast_test_status_update(test, "Newly allocated file has metadata count of '%d' when should be 0\n",
652                         ao2_container_count(file->metadata));
653                 return AST_TEST_FAIL;
654         }
655
656         if (ast_bucket_file_metadata_set(file, "bob", "joe")) {
657                 ast_test_status_update(test, "Failed to set metadata 'bob' to 'joe' on newly allocated file\n");
658                 return AST_TEST_FAIL;
659         }
660
661         if (!(metadata = ao2_find(file->metadata, "bob", OBJ_KEY))) {
662                 ast_test_status_update(test, "Failed to find set metadata 'bob' on newly allocated file\n");
663                 return AST_TEST_FAIL;
664         }
665
666         if (strcmp(metadata->value, "joe")) {
667                 ast_test_status_update(test, "Metadata has value '%s' when should be 'joe'\n",
668                         metadata->value);
669                 return AST_TEST_FAIL;
670         }
671
672         ao2_cleanup(metadata);
673         metadata = NULL;
674
675         if (ast_bucket_file_metadata_set(file, "bob", "fred")) {
676                 ast_test_status_update(test, "Failed to overwrite metadata 'bob' with new value 'fred'\n");
677                 return AST_TEST_FAIL;
678         }
679
680         if (!(metadata = ao2_find(file->metadata, "bob", OBJ_KEY))) {
681                 ast_test_status_update(test, "Failed to find overwritten metadata 'bob' on newly allocated file\n");
682                 return AST_TEST_FAIL;
683         }
684
685         if (strcmp(metadata->value, "fred")) {
686                 ast_test_status_update(test, "Metadata has value '%s' when should be 'fred'\n",
687                         metadata->value);
688                 return AST_TEST_FAIL;
689         }
690
691         return AST_TEST_PASS;
692 }
693
694 AST_TEST_DEFINE(bucket_file_metadata_unset)
695 {
696         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
697         RAII_VAR(struct ast_bucket_metadata *, metadata, NULL, ao2_cleanup);
698
699         switch (cmd) {
700         case TEST_INIT:
701                 info->name = "bucket_file_metadata_unset";
702                 info->category = "/main/bucket/";
703                 info->summary = "file metadata unsetting unit test";
704                 info->description =
705                         "Test unsetting of metadata on files";
706                 return AST_TEST_NOT_RUN;
707         case TEST_EXECUTE:
708                 break;
709         }
710
711         if (!(file = ast_bucket_file_alloc("test:///tmp/bob"))) {
712                 ast_test_status_update(test, "Failed to allocate file\n");
713                 return AST_TEST_FAIL;
714         }
715
716         if (ast_bucket_file_metadata_set(file, "bob", "joe")) {
717                 ast_test_status_update(test, "Failed to set metadata 'bob' to 'joe' on newly allocated file\n");
718                 return AST_TEST_FAIL;
719         }
720
721         if (ast_bucket_file_metadata_unset(file, "bob")) {
722                 ast_test_status_update(test, "Failed to unset metadata 'bob' on newly allocated file\n");
723                 return AST_TEST_FAIL;
724         }
725
726         if ((metadata = ao2_find(file->metadata, "bob", OBJ_KEY))) {
727                 ast_test_status_update(test, "Metadata 'bob' was unset, but can still be found\n");
728                 return AST_TEST_FAIL;
729         }
730
731         return AST_TEST_PASS;
732 }
733
734 AST_TEST_DEFINE(bucket_file_metadata_get)
735 {
736         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
737         RAII_VAR(struct ast_bucket_metadata *, metadata, NULL, ao2_cleanup);
738
739         switch (cmd) {
740         case TEST_INIT:
741                 info->name = "bucket_file_metadata_get";
742                 info->category = "/main/bucket/";
743                 info->summary = "file metadata getting unit test";
744                 info->description =
745                         "Test getting of metadata on files";
746                 return AST_TEST_NOT_RUN;
747         case TEST_EXECUTE:
748                 break;
749         }
750
751         if (!(file = ast_bucket_file_alloc("test:///tmp/bob"))) {
752                 ast_test_status_update(test, "Failed to allocate file\n");
753                 return AST_TEST_FAIL;
754         }
755
756         if (ast_bucket_file_metadata_set(file, "bob", "joe")) {
757                 ast_test_status_update(test, "Failed to set metadata 'bob' to 'joe' on newly allocated file\n");
758                 return AST_TEST_FAIL;
759         }
760
761         if (!(metadata = ast_bucket_file_metadata_get(file, "bob"))) {
762                 ast_test_status_update(test, "Failed to retrieve metadata 'bob' that was just set\n");
763                 return AST_TEST_FAIL;
764         }
765
766         if (strcmp(metadata->value, "joe")) {
767                 ast_test_status_update(test, "Retrieved metadata value is '%s' while it should be 'joe'\n",
768                         metadata->value);
769                 return AST_TEST_FAIL;
770         }
771
772         return AST_TEST_PASS;
773 }
774
775 AST_TEST_DEFINE(bucket_file_json)
776 {
777         RAII_VAR(struct ast_bucket_file *, file, NULL, ao2_cleanup);
778         RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
779         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
780
781         switch (cmd) {
782         case TEST_INIT:
783                 info->name = "bucket_file_json";
784                 info->category = "/main/bucket/";
785                 info->summary = "file json unit test";
786                 info->description =
787                         "Test creation of JSON for a file";
788                 return AST_TEST_NOT_RUN;
789         case TEST_EXECUTE:
790                 break;
791         }
792
793         if (!(file = ast_bucket_file_alloc("test:///tmp/bob"))) {
794                 ast_test_status_update(test, "Failed to allocate bucket\n");
795                 return AST_TEST_FAIL;
796         }
797
798         if (ast_bucket_file_metadata_set(file, "bob", "joe")) {
799                 ast_test_status_update(test, "Failed to set metadata 'bob' to 'joe' on newly allocated file\n");
800                 return AST_TEST_FAIL;
801         }
802
803         expected = ast_json_pack("{s: s, s: s, s: s, s: s, s: {s :s}}",
804                 "modified", "0.000000", "created", "0.000000", "scheme", "test",
805                 "id", "test:///tmp/bob", "metadata", "bob", "joe");
806         if (!expected) {
807                 ast_test_status_update(test, "Could not produce JSON for expected bucket file value\n");
808                 return AST_TEST_FAIL;
809         }
810
811         json = ast_bucket_file_json(file);
812         if (!json) {
813                 ast_test_status_update(test, "Could not produce JSON for a valid file\n");
814                 return AST_TEST_FAIL;
815         }
816
817         if (!ast_json_equal(json, expected)) {
818                 ast_test_status_update(test, "Bucket file JSON does not match expected output\n");
819                 return AST_TEST_FAIL;
820         }
821
822         return AST_TEST_PASS;
823 }
824
825 static int unload_module(void)
826 {
827         AST_TEST_UNREGISTER(bucket_scheme_register);
828         AST_TEST_UNREGISTER(bucket_alloc);
829         AST_TEST_UNREGISTER(bucket_create);
830         AST_TEST_UNREGISTER(bucket_delete);
831         AST_TEST_UNREGISTER(bucket_retrieve);
832         AST_TEST_UNREGISTER(bucket_json);
833         AST_TEST_UNREGISTER(bucket_file_alloc);
834         AST_TEST_UNREGISTER(bucket_file_create);
835         AST_TEST_UNREGISTER(bucket_file_copy);
836         AST_TEST_UNREGISTER(bucket_file_retrieve);
837         AST_TEST_UNREGISTER(bucket_file_update);
838         AST_TEST_UNREGISTER(bucket_file_delete);
839         AST_TEST_UNREGISTER(bucket_file_metadata_set);
840         AST_TEST_UNREGISTER(bucket_file_metadata_unset);
841         AST_TEST_UNREGISTER(bucket_file_metadata_get);
842         AST_TEST_UNREGISTER(bucket_file_json);
843         return 0;
844 }
845
846 static int load_module(void)
847 {
848         if (ast_bucket_scheme_register("test", &bucket_test_wizard, &bucket_file_test_wizard,
849                 ast_bucket_file_temporary_create, ast_bucket_file_temporary_destroy)) {
850                 ast_log(LOG_ERROR, "Failed to register Bucket test wizard scheme implementation\n");
851                 return AST_MODULE_LOAD_FAILURE;
852         }
853
854         AST_TEST_REGISTER(bucket_scheme_register);
855         AST_TEST_REGISTER(bucket_alloc);
856         AST_TEST_REGISTER(bucket_create);
857         AST_TEST_REGISTER(bucket_delete);
858         AST_TEST_REGISTER(bucket_retrieve);
859         AST_TEST_REGISTER(bucket_json);
860         AST_TEST_REGISTER(bucket_file_alloc);
861         AST_TEST_REGISTER(bucket_file_create);
862         AST_TEST_REGISTER(bucket_file_copy);
863         AST_TEST_REGISTER(bucket_file_retrieve);
864         AST_TEST_REGISTER(bucket_file_update);
865         AST_TEST_REGISTER(bucket_file_delete);
866         AST_TEST_REGISTER(bucket_file_metadata_set);
867         AST_TEST_REGISTER(bucket_file_metadata_unset);
868         AST_TEST_REGISTER(bucket_file_metadata_get);
869         AST_TEST_REGISTER(bucket_file_json);
870         return AST_MODULE_LOAD_SUCCESS;
871 }
872
873 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Bucket test module");