Enclose each test sandbox in a dedicated directory

Prevents them from interfering with each other.

Fixes #148.

diff --git a/test/Makefile.am b/test/Makefile.am
index ad29d3d17d3fc69d7e0a2641721dcb4358b07778..1a182544eeed4f2e85091b210cbd28a183c0a476 100644 (file)
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -108,4 +108,7 @@ EXTRA_DIST += rtr/db/rtr_db_mock.c
 EXTRA_DIST += tal/lacnic.tal
 EXTRA_DIST += xml/notification.xml
 
+clean-local:
+       rm -rf tmp/ # test sandboxes
+
 endif

diff --git a/test/cache/local_cache_test.c b/test/cache/local_cache_test.c
index 7d175d065a6455486c481cafe4a8c9596aa71add..d66be46e4192f8036d623ce384455a170940f493 100644 (file)
--- a/test/cache/local_cache_test.c
+++ b/test/cache/local_cache_test.c
@@ -15,6 +15,7 @@
 
 /* Mocks */
 
+#define CACHEDIR "tmp/cache"
 #define TAL_FILE "test.tal"
 
 static struct rpki_cache *cache;
@@ -92,6 +93,7 @@ http_download(struct rpki_uri *uri, bool *changed)
        return error;
 }
 
+MOCK(config_get_local_repository, char const *, CACHEDIR, void)
 MOCK_ABORT_INT(rrdp_update, struct rpki_uri *uri)
 
 /* Helpers */
@@ -99,7 +101,7 @@ MOCK_ABORT_INT(rrdp_update, struct rpki_uri *uri)
 static void
 setup_test(void)
 {
-       ck_assert_int_eq(0, system("rm -rf tmp/"));
+       ck_assert_int_eq(0, system("rm -rf " CACHEDIR));
 
        dl_error = false;
        cache = cache_create(TAL_FILE);
@@ -481,7 +483,7 @@ START_TEST(test_cache_cleanup_rsync)
                NODE("rsync://a.b.c/e/", 0, 1, true),
                NODE("rsync://a.b.c/f/", 0, 1, true),
                NULL);
-       ck_assert_int_eq(0, file_rm_rf("tmp/" TAL_FILE "/rsync/a.b.c/f"));
+       ck_assert_int_eq(0, file_rm_rf(CACHEDIR "/" TAL_FILE "/rsync/a.b.c/f"));
        cache_cleanup(cache);
        validate_cache(0, NODE("rsync://a.b.c/e/", 0, 1, true), NULL);
 
@@ -641,7 +643,7 @@ START_TEST(test_cache_cleanup_https)
            NODE("https://a.b.c/e", 0, 1, 1),
            NODE("https://a.b.c/f/g/h", 0, 1, 1),
            NULL);
-       ck_assert_int_eq(0, file_rm_rf("tmp/" TAL_FILE "/https/a.b.c/f/g/h"));
+       ck_assert_int_eq(0, file_rm_rf(CACHEDIR "/" TAL_FILE "/https/a.b.c/f/g/h"));
        cache_cleanup(cache);
        validate_cache(0, NODE("https://a.b.c/e", 0, 1, 1), NULL);
 
@@ -719,8 +721,7 @@ START_TEST(test_tal_json)
 
        setup_test();
 
-       ck_assert_int_eq(0, system("rm -rf tmp/"));
-       ck_assert_int_eq(0, system("mkdir -p tmp/" TAL_FILE));
+       ck_assert_int_eq(0, system("mkdir -p " CACHEDIR "/" TAL_FILE));
 
        add_node(cache, NODE("rsync://a.b.c/d", 0, 1, 0));
        add_node(cache, NODE("rsync://a.b.c/e", 1, 0, 0));
@@ -729,7 +730,7 @@ START_TEST(test_tal_json)
        add_node(cache, node("https://a/c", 0, 0, 1, 0, 1));
 
        json = build_tal_json(cache);
-       ck_assert_int_eq(0, json_dump_file(json, "tmp/" TAL_FILE "/" TAL_METAFILE, JSON_COMPACT));
+       ck_assert_int_eq(0, json_dump_file(json, CACHEDIR "/" TAL_FILE "/" TAL_METAFILE, JSON_COMPACT));
 
        str = json_dumps(json, /* JSON_INDENT(4) */ JSON_COMPACT);
        json_decref(json);

diff --git a/test/data_structure/path_builder_test.c b/test/data_structure/path_builder_test.c
index f6a822f1cb9416942830b183869a763438af7905..b60b4ae881a940f54498f168730fddffe9e6a095 100644 (file)
--- a/test/data_structure/path_builder_test.c
+++ b/test/data_structure/path_builder_test.c
@@ -7,6 +7,8 @@
 #include "mock.c"
 #include "data_structure/path_builder.c"
 
+__MOCK_ABORT(config_get_local_repository, char const *, "tmp/pb", void)
+
 #define CHECK_PB(_string, _capacity)                                   \
        ck_assert_str_eq(_string, pb.string);                           \
        ck_assert_uint_eq(strlen(_string), pb.len);                     \

diff --git a/test/mock.c b/test/mock.c
index 1f83bbe2897654bfc2add4aa748a139a784b9691..c5bfff431629d1a36e50878ac362d78ed536ca6e 100644 (file)
--- a/test/mock.c
+++ b/test/mock.c
@@ -113,7 +113,6 @@ v6addr2str2(struct in6_addr const *addr)
 
 MOCK_NULL(config_get_slurm, char const *, void)
 MOCK(config_get_tal, char const *, "tal/", void)
-MOCK(config_get_local_repository, char const *, "tmp", void)
 MOCK(config_get_mode, enum mode, STANDALONE, void)
 MOCK_TRUE(config_get_rsync_enabled, void)
 MOCK_UINT(config_get_rsync_priority, 50, void)

diff --git a/test/rsync/rsync_test.c b/test/rsync/rsync_test.c
index 5056ed8939fc64e36bd88f57062b54bf044f91fa..5df397084e740293068e67a6a3231a913d5d69ea 100644 (file)
--- a/test/rsync/rsync_test.c
+++ b/test/rsync/rsync_test.c
@@ -14,6 +14,9 @@ static char content[1024];
 
 /* Mocks */
 
+#define CACHEDIR "tmp/rsync"
+
+__MOCK_ABORT(config_get_local_repository, char const *, CACHEDIR, void)
 MOCK(config_get_rsync_program, char *, "rsync", void)
 MOCK_UINT(config_get_rsync_retry_count, 0, void)
 MOCK_UINT(config_get_rsync_retry_interval, 10, void)
@@ -70,9 +73,14 @@ init_content(void)
 static void
 init_tmp(void)
 {
-       int res = mkdir("tmp/", 0700);
-       if (res && errno != EEXIST)
-               pr_crit("Could not create tmp/: %s", strerror(errno));
+       int error;
+
+       error = system("rm -rf " CACHEDIR);
+       if (error)
+               pr_crit("system(rm): %d", error);
+       error = system("mkdir -p " CACHEDIR);
+       if (error)
+               pr_crit("system(mkdir): %d", error);
 }
 
 static void *
@@ -209,28 +217,28 @@ ensure_file_deleted(char const *name)
 START_TEST(full_rsync_timeout_test_1kb)
 {
        printf("1kb\n");
-       create_file("tmp/1kb", 1);
-       ensure_file_deleted("tmp/1kb-copy");
-       ck_assert_int_eq(0, rsync_download("tmp/1kb", "tmp/1kb-copy", false));
+       create_file(CACHEDIR "/1kb", 1);
+       ensure_file_deleted(CACHEDIR "/1kb-copy");
+       ck_assert_int_eq(0, rsync_download(CACHEDIR "/1kb", CACHEDIR "/1kb-copy", false));
 }
 END_TEST
 
 START_TEST(full_rsync_timeout_test_3kb)
 {
        printf("3kb\n");
-       create_file("tmp/3kb", 3);
-       ensure_file_deleted("tmp/3kb-copy");
-       ck_assert_int_eq(0, rsync_download("tmp/3kb", "tmp/3kb-copy", false));
+       create_file(CACHEDIR "/3kb", 3);
+       ensure_file_deleted(CACHEDIR"/3kb-copy");
+       ck_assert_int_eq(0, rsync_download(CACHEDIR "/3kb", CACHEDIR "/3kb-copy", false));
 }
 END_TEST
 
 START_TEST(full_rsync_timeout_test_5kb)
 {
        printf("5kb\n");
-       create_file("tmp/5kb", 5);
-       ensure_file_deleted("tmp/5kb-copy");
+       create_file(CACHEDIR "/5kb", 5);
+       ensure_file_deleted(CACHEDIR "/5kb-copy");
        /* Max speed is 1kbps, timeout is 4 seconds */
-       ck_assert_int_eq(EIO, rsync_download("tmp/5kb", "tmp/5kb-copy", false));
+       ck_assert_int_eq(EIO, rsync_download(CACHEDIR "/5kb", CACHEDIR "/5kb-copy", false));
 }
 END_TEST
 

diff --git a/test/rtr/db/db_table_test.c b/test/rtr/db/db_table_test.c
index fefb4ccb2240e47e8af8393692061a677b5244ce..b19ae4029f77274998b2ad8aaed7cfdf68e1ccc2 100644 (file)
--- a/test/rtr/db/db_table_test.c
+++ b/test/rtr/db/db_table_test.c
@@ -18,6 +18,8 @@
 static bool roas_found[TOTAL_ROAS];
 static unsigned int total_found;
 
+__MOCK_ABORT(config_get_local_repository, char const *, "tmp/dbt", void)
+
 static bool
 vrp_equals_v4(struct vrp const *vrp, uint8_t as, uint32_t addr,
     uint8_t prefix_len, uint8_t max_prefix_len)

diff --git a/test/rtr/db/vrps_test.c b/test/rtr/db/vrps_test.c
index cd91a62966a5214a4ce4b2925729c2ae82326ef2..63e93de9ec0de1842a0096dff4c2ceb3ad461045 100644 (file)
--- a/test/rtr/db/vrps_test.c
+++ b/test/rtr/db/vrps_test.c
@@ -72,6 +72,7 @@ MOCK_UINT(config_get_deltas_lifetime, deltas_lifetime, void)
 MOCK_ABORT_ENUM(config_get_output_format, output_format, void)
 MOCK_ABORT_INT(hash_local_file, char const *uri, unsigned char *result,
     unsigned int *result_len)
+__MOCK_ABORT(config_get_local_repository, char const *, "tmp/vrps", void)
 
 /* Test functions */
 

diff --git a/test/rtr/pdu_handler_test.c b/test/rtr/pdu_handler_test.c
index 20e277f647fd231cdead172df3da1406145ebabb..bff211162f8a41fb1bcdccda1f4018f400164782 100644 (file)
--- a/test/rtr/pdu_handler_test.c
+++ b/test/rtr/pdu_handler_test.c
@@ -23,8 +23,8 @@
 
 MOCK_INT(slurm_apply, 0, struct db_table *base, struct db_slurm **slurm)
 MOCK_ABORT_VOID(db_slurm_destroy, struct db_slurm *db)
-
 MOCK_VOID(output_print_data, struct db_table const *db)
+__MOCK_ABORT(config_get_local_repository, char const *, "tmp/pdu", void)
 
 /* Mocks end */
 

diff --git a/test/tal_test.c b/test/tal_test.c
index 916e881bf3ab10a4a8b97f6ba648c73fa00eaa88..4c7b04207f16ae7206fd44e643e5c7c440b9e475 100644 (file)
--- a/test/tal_test.c
+++ b/test/tal_test.c
@@ -14,6 +14,7 @@
 
 /* Mocks */
 
+MOCK(config_get_local_repository, char const *, "tmp/tal", void)
 MOCK_ABORT_VOID(cache_setup, void)
 MOCK(cache_create, struct rpki_cache *, NULL, char const *tal)
 MOCK_VOID(cache_destroy, struct rpki_cache *cache)

diff --git a/test/thread_pool_test.c b/test/thread_pool_test.c
index 071d08cc0d0abcb089e71241c88683ce469f760d..487e4891c734b5bef557a7743fdc5584b29481fc 100644 (file)
--- a/test/thread_pool_test.c
+++ b/test/thread_pool_test.c
@@ -7,6 +7,8 @@
 #include "mock.c"
 #include "thread/thread_pool.c"
 
+__MOCK_ABORT(config_get_local_repository, char const *, "tmp/thread", void)
+
 static void
 thread_work(void *arg)
 {

diff --git a/test/types/address_test.c b/test/types/address_test.c
index dfc6adae725fdb3c6f9aa26b4aa11ea8c07bda65..edd5d53d64271fca25eaa6f2f93873d51b961544 100644 (file)
--- a/test/types/address_test.c
+++ b/test/types/address_test.c
@@ -7,7 +7,7 @@
 #include "mock.c"
 #include "types/address.c"
 
-/* Tests */
+__MOCK_ABORT(config_get_local_repository, char const *, "tmp/address", void)
 
 static void
 test_range4(uint32_t min, uint32_t max, bool valid)

diff --git a/test/types/uri_test.c b/test/types/uri_test.c
index d8439db1c52a49b6aa64e38bc8e2dfd3a665f927..90f1c3ee305056a62fc5ffe91633d27f6703d8ba 100644 (file)
--- a/test/types/uri_test.c
+++ b/test/types/uri_test.c
@@ -11,12 +11,14 @@
 
 /* Mocks */
 
+#define CACHEDIR "tmp/uri"
+
 static struct rpki_uri *notif;
 
+MOCK(config_get_local_repository, char const *, CACHEDIR, void)
 MOCK(state_retrieve, struct validation *, NULL, void)
 MOCK(validation_tal, struct tal *, NULL, struct validation *state)
 MOCK(tal_get_file_name, char const *, "test.tal", struct tal *tal)
-
 MOCK_ABORT_INT(rrdp_update, struct rpki_uri *uri)
 
 /* Tests */
@@ -38,42 +40,42 @@ START_TEST(test_constructor)
 
        ck_assert_int_eq(0, URI_CREATE_HTTP(uri, "https://a.b.c"));
        ck_assert_str_eq("https://a.b.c", uri_get_global(uri));
-       ck_assert_str_eq("tmp/test.tal/https/a.b.c", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/https/a.b.c", uri_get_local(uri));
        uri_refput(uri);
 
        ck_assert_int_eq(0, URI_CREATE_HTTP(uri, "https://a.b.c/"));
        ck_assert_str_eq("https://a.b.c/", uri_get_global(uri));
-       ck_assert_str_eq("tmp/test.tal/https/a.b.c", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/https/a.b.c", uri_get_local(uri));
        uri_refput(uri);
 
        ck_assert_int_eq(0, URI_CREATE_HTTP(uri, "https://a.b.c/d"));
        ck_assert_str_eq("https://a.b.c/d", uri_get_global(uri));
-       ck_assert_str_eq("tmp/test.tal/https/a.b.c/d", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/https/a.b.c/d", uri_get_local(uri));
        uri_refput(uri);
 
        ck_assert_int_eq(0, URI_CREATE_HTTP(uri, "https://a.b.c/d/e"));
        ck_assert_str_eq("https://a.b.c/d/e", uri_get_global(uri));
-       ck_assert_str_eq("tmp/test.tal/https/a.b.c/d/e", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/https/a.b.c/d/e", uri_get_local(uri));
        uri_refput(uri);
 
        ck_assert_int_eq(0, URI_CREATE_HTTP(uri, "https://a.b.c/d/.."));
        ck_assert_str_eq("https://a.b.c/d/..", uri_get_global(uri));
-       ck_assert_str_eq("tmp/test.tal/https/a.b.c", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/https/a.b.c", uri_get_local(uri));
        uri_refput(uri);
 
        ck_assert_int_eq(0, URI_CREATE_HTTP(uri, "https://a.b.c/."));
        ck_assert_str_eq("https://a.b.c/.", uri_get_global(uri));
-       ck_assert_str_eq("tmp/test.tal/https/a.b.c", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/https/a.b.c", uri_get_local(uri));
        uri_refput(uri);
 
        ck_assert_int_eq(0, URI_CREATE_HTTP(uri, "https://a.b.c/././d/././e/./."));
        ck_assert_str_eq("https://a.b.c/././d/././e/./.", uri_get_global(uri));
-       ck_assert_str_eq("tmp/test.tal/https/a.b.c/d/e", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/https/a.b.c/d/e", uri_get_local(uri));
        uri_refput(uri);
 
        ck_assert_int_eq(0, URI_CREATE_HTTP(uri, "https://a.b.c/a/b/.././.."));
        ck_assert_str_eq("https://a.b.c/a/b/.././..", uri_get_global(uri));
-       ck_assert_str_eq("tmp/test.tal/https/a.b.c", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/https/a.b.c", uri_get_local(uri));
        uri_refput(uri);
 
        ck_assert_int_eq(-EINVAL, URI_CREATE_HTTP(uri, "https://a.b.c/.."));
@@ -150,13 +152,13 @@ START_TEST(check_caged)
 
        ck_assert_int_eq(0, uri_create(&notif, "test.tal", UT_HTTPS, true, NULL, "https://a.b.c/d/e.xml"));
        ck_assert_int_eq(0, uri_create(&uri, "test.tal", UT_CAGED, false, notif, "rsync://x.y.z/v/w.cer"));
-       ck_assert_str_eq("tmp/test.tal/rrdp/a.b.c/d/e.xml/x.y.z/v/w.cer", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/rrdp/a.b.c/d/e.xml/x.y.z/v/w.cer", uri_get_local(uri));
        uri_refput(uri);
        uri_refput(notif);
 
        ck_assert_int_eq(0, uri_create(&notif, "test.tal", UT_HTTPS, true, NULL, "https://a.b.c"));
        ck_assert_int_eq(0, uri_create(&uri, "test.tal", UT_CAGED, false, notif, "rsync://w"));
-       ck_assert_str_eq("tmp/test.tal/rrdp/a.b.c/w", uri_get_local(uri));
+       ck_assert_str_eq(CACHEDIR "/test.tal/rrdp/a.b.c/w", uri_get_local(uri));
        uri_refput(uri);
        uri_refput(notif);
 }