Update command/archive tests to use standard patterns.

Includes archiveCommon, archiveGet and archivePush.

Also fixed a test that was looking in repo instead of repo3 in the original archivePush to use the repo3 path as stated by the comment (line 879 in original tests and line 855 in new tests).

doc/xml/release.xml

@@ -96,6 +96,9 @@
                         <commit subject="Update info/manifest test to use standard patterns.">
                             <github-pull-request id="1444"/>
                         </commit>
+                        <commit subject="Update command/archive tests to use standard patterns.">
+                            <github-pull-request id="1449"/>
+                        </commit>
 
                         <release-item-contributor-list>
                             <release-item-contributor id="cynthia.shang"/>

test/src/module/command/archiveCommonTest.c

@@ -25,67 +25,61 @@ testRun(void)
     if (testBegin("archiveAsyncErrorClear() and archiveAsyncStatus()"))
     {
         StringList *argList = strLstNew();
-        strLstAddZ(argList, "--spool-path=" TEST_PATH);
+        hrnCfgArgRawZ(argList, cfgOptStanza, "db");
-        strLstAddZ(argList, "--archive-async");
+        hrnCfgArgRawZ(argList, cfgOptSpoolPath, TEST_PATH);
-        strLstAddZ(argList, "--archive-timeout=1");
+        hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
-        strLstAddZ(argList, "--stanza=db");
+        hrnCfgArgRawZ(argList, cfgOptArchiveTimeout, "1");
         HRN_CFG_LOAD(cfgCmdArchivePush, argList);
 
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("archiveAsyncStatus() - directory and status file not present");
+
         const String *segment = STRDEF("000000010000000100000001");
 
         TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false, true), false, "directory and status file not present");
         TEST_RESULT_BOOL(archiveAsyncStatus(archiveModeGet, segment, false, true), false, "directory and status file not present");
 
         // -------------------------------------------------------------------------------------------------------------------------
-        mkdir(TEST_PATH "/archive", 0750);
+        TEST_TITLE("archiveAsyncStatus() - directories present and status file not present");
-        mkdir(TEST_PATH "/archive/db", 0750);
+
-        mkdir(TEST_PATH "/archive/db/out", 0750);
+        HRN_STORAGE_PATH_CREATE(storageTest, "archive/db/out", .mode = 0750);
 
         TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false, true), false, "status file not present");
 
         // -------------------------------------------------------------------------------------------------------------------------
         TEST_TITLE("clear archive file errors");
 
-        const String *errorSegment = strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.error", strZ(segment));
+        HRN_STORAGE_PUT_EMPTY(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.error");
-        const String *errorGlobal = STRDEF(STORAGE_SPOOL_ARCHIVE_OUT "/global.error");
+        HRN_STORAGE_PUT_EMPTY(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/global.error");
 
-        storagePutP(storageNewWriteP(storageSpoolWrite(), errorSegment), NULL);
+        TEST_STORAGE_LIST(storageSpool(), STORAGE_SPOOL_ARCHIVE_OUT, "000000010000000100000001.error\nglobal.error\n");
-        storagePutP(storageNewWriteP(storageSpoolWrite(), errorGlobal), NULL);
 
         TEST_RESULT_VOID(archiveAsyncErrorClear(archiveModePush, segment), "clear error");
 
-        TEST_RESULT_BOOL(storageExistsP(storageSpool(), errorSegment), false, "    check segment error");
+        TEST_STORAGE_LIST_EMPTY(storageSpool(), STORAGE_SPOOL_ARCHIVE_OUT, .comment = "segment and global error cleared");
-        TEST_RESULT_BOOL(storageExistsP(storageSpool(), errorGlobal), false, "    check global error");
 
         // -------------------------------------------------------------------------------------------------------------------------
-        storagePutP(
+        TEST_TITLE("check ok file");
-            storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
+
-            BUFSTRDEF(BOGUS_STR));
+        HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.ok", BOGUS_STR);
         TEST_ERROR(
             archiveAsyncStatus(archiveModePush, segment, false, true), FormatError,
             "000000010000000100000001.ok content must have at least two lines");
 
-        storagePutP(
+        HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.ok", BOGUS_STR "\n");
-            storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
-            BUFSTRDEF(BOGUS_STR "\n"));
         TEST_ERROR(
             archiveAsyncStatus(archiveModePush, segment, false, true), FormatError,
             "000000010000000100000001.ok message must be > 0");
 
-        storagePutP(
+        HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.ok", BOGUS_STR "\nmessage");
-            storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
-            BUFSTRDEF(BOGUS_STR "\nmessage"));
         TEST_ERROR(
             archiveAsyncStatus(archiveModePush, segment, false, true),
             FormatError, "unable to convert base 10 string 'BOGUS' to int");
 
-        storagePutP(storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))), NULL);
+        HRN_STORAGE_PUT_EMPTY(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.ok");
         TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false, true), true, "ok file");
 
-        storagePutP(
+        HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.ok", "0\nwarning");
-            storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
-            BUFSTRDEF("0\nwarning"));
         TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false, true), true, "ok file with warning");
         TEST_RESULT_LOG("P00   WARN: warning");
 
@@ -97,36 +91,31 @@ testRun(void)
         TEST_RESULT_LOG("");
 
         // -------------------------------------------------------------------------------------------------------------------------
-        storagePutP(
+        TEST_TITLE("error status renamed to ok");
-            storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment))),
+
-            BUFSTRDEF("25\nerror"));
+        HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.ok", "25\nerror");
         TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false, true), true, "error status renamed to ok");
         TEST_RESULT_LOG(
             "P00   WARN: WAL segment '000000010000000100000001' was not pushed due to error [25] and was manually skipped: error");
-        TEST_RESULT_VOID(
+        HRN_STORAGE_REMOVE(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.ok", .errorOnMissing = true);
-            storageRemoveP(
-                storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.ok", strZ(segment)), .errorOnMissing = true),
-            "remove ok");
 
         // -------------------------------------------------------------------------------------------------------------------------
-        storagePutP(
+        TEST_TITLE("segment error file - AssertError");
-            storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.error", strZ(segment))), bufNew(0));
+
+        HRN_STORAGE_PUT_EMPTY(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.error");
         TEST_ERROR(
             archiveAsyncStatus(archiveModePush, segment, true, true), AssertError,
             "status file '000000010000000100000001.error' has no content");
 
-        storagePutP(
+        HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/000000010000000100000001.error", "25\nmessage");
-            storageNewWriteP(storageSpoolWrite(), strNewFmt(STORAGE_SPOOL_ARCHIVE_OUT "/%s.error", strZ(segment))),
-            BUFSTRDEF("25\nmessage"));
         TEST_ERROR(archiveAsyncStatus(archiveModePush, segment, true, true), AssertError, "message");
 
         TEST_RESULT_BOOL(archiveAsyncStatus(archiveModePush, segment, false, true), false, "suppress error");
 
         // -------------------------------------------------------------------------------------------------------------------------
-        storagePutP(
+        TEST_TITLE("global error file - ExecuteError");
-            storageNewWriteP(storageSpoolWrite(), STRDEF(STORAGE_SPOOL_ARCHIVE_OUT "/global.error")),
-            BUFSTRDEF("102\nexecute error"));
 
+        HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_OUT "/global.error", "102\nexecute error");
         TEST_ERROR(archiveAsyncStatus(archiveModePush, STRDEF("anyfile"), true, true), ExecuteError, "execute error");
     }
 
@@ -134,49 +123,40 @@ testRun(void)
     if (testBegin("archiveAsyncStatusErrorWrite() and archiveAsyncStatusOkWrite()"))
     {
         StringList *argList = strLstNew();
-        strLstAddZ(argList, "--spool-path=" TEST_PATH);
+        hrnCfgArgRawZ(argList, cfgOptStanza, "db");
-        strLstAddZ(argList, "--stanza=db");
+        hrnCfgArgRawZ(argList, cfgOptSpoolPath, TEST_PATH);
         hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
-        strLstAddZ(argList, "--" CFGOPT_ARCHIVE_ASYNC);
+        hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
         HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleAsync);
 
         const String *walSegment = STRDEF("000000010000000100000001");
 
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("archiveAsyncStatusErrorWrite()");
+
         TEST_RESULT_VOID(
-            archiveAsyncStatusErrorWrite(archiveModeGet, walSegment, 25, STRDEF("error message")), "write error");
+            archiveAsyncStatusErrorWrite(archiveModeGet, walSegment, 25, STRDEF("error message")), "write segment error");
-        TEST_RESULT_STR_Z(
+        TEST_STORAGE_GET(
-            strNewBuf(storageGetP(storageNewReadP(storageTest, STRDEF("archive/db/in/000000010000000100000001.error")))),
+            storageTest, "archive/db/in/000000010000000100000001.error", "25\nerror message", .remove = true,
-            "25\nerror message", "check error");
+            .comment = "check segment error and remove");
-        TEST_RESULT_VOID(
-            storageRemoveP(storageTest, STRDEF("archive/db/in/000000010000000100000001.error"), .errorOnMissing = true),
-            "remove error");
 
         TEST_RESULT_VOID(
             archiveAsyncStatusErrorWrite(archiveModeGet, NULL, 25, STRDEF("global error message")), "write global error");
-        TEST_RESULT_STR_Z(
+        TEST_STORAGE_GET(
-            strNewBuf(storageGetP(storageNewReadP(storageTest, STRDEF("archive/db/in/global.error")))),
+            storageTest, "archive/db/in/global.error", "25\nglobal error message", .remove = true,
-            "25\nglobal error message", "check global error");
+            .comment = "check global error and remove");
-        TEST_RESULT_VOID(
-            storageRemoveP(storageTest, STRDEF("archive/db/in/global.error"), .errorOnMissing = true),
-            "remove global error");
 
-        TEST_RESULT_VOID(
+        // -------------------------------------------------------------------------------------------------------------------------
-            archiveAsyncStatusOkWrite(archiveModeGet, walSegment, NULL), "write ok file");
+        TEST_TITLE("archiveAsyncStatusOkWrite()");
-        TEST_RESULT_STR_Z(
-            strNewBuf(storageGetP(storageNewReadP(storageTest, STRDEF("archive/db/in/000000010000000100000001.ok")))),
-            "", "check ok");
-        TEST_RESULT_VOID(
-            storageRemoveP(storageTest, STRDEF("archive/db/in/000000010000000100000001.ok"), .errorOnMissing = true),
-            "remove ok");
 
-        TEST_RESULT_VOID(
+        TEST_RESULT_VOID(archiveAsyncStatusOkWrite(archiveModeGet, walSegment, NULL), "write ok file");
-            archiveAsyncStatusOkWrite(archiveModeGet, walSegment, STRDEF("WARNING")), "write ok file with warning");
+        TEST_STORAGE_GET(
-        TEST_RESULT_STR_Z(
+            storageTest, "archive/db/in/000000010000000100000001.ok", "", .remove = true, .comment = "check ok and remove");
-            strNewBuf(storageGetP(storageNewReadP(storageTest, STRDEF("archive/db/in/000000010000000100000001.ok")))),
+
-            "0\nWARNING", "check ok warning");
+        TEST_RESULT_VOID(archiveAsyncStatusOkWrite(archiveModeGet, walSegment, STRDEF("WARNING")), "write ok file with warning");
-        TEST_RESULT_VOID(
+        TEST_STORAGE_GET(
-            storageRemoveP(storageTest, STRDEF("archive/db/in/000000010000000100000001.ok"), .errorOnMissing = true),
+            storageTest, "archive/db/in/000000010000000100000001.ok", "0\nWARNING", .remove = true,
-            "remove ok");
+            .comment = "check ok warning and remove");
     }
 
     // *****************************************************************************************************************************
@@ -197,8 +177,16 @@ testRun(void)
     // *****************************************************************************************************************************
     if (testBegin("walPath()"))
     {
+        StringList *argList = strLstNew();
+        hrnCfgArgRawZ(argList, cfgOptStanza, "db");
+        hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
+        HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
+
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("absolute and relative paths");
+
         const String *pgPath = storagePathP(storageTest, STRDEF("pg"));
-        storagePathCreateP(storageTest, pgPath);
+        HRN_STORAGE_PATH_CREATE(storageTest, strZ(pgPath));
 
         TEST_RESULT_STR_Z(walPath(STRDEF("/absolute/path"), pgPath, STRDEF("test")), "/absolute/path", "absolute path");
 
@@ -206,6 +194,9 @@ testRun(void)
         TEST_RESULT_STR(
             walPath(STRDEF("relative/path"), pgPath, STRDEF("test")), strNewFmt("%s/relative/path", strZ(pgPath)), "relative path");
 
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("symlink path");
+
         const String *pgPathLink = storagePathP(storageTest, STRDEF("pg-link"));
         THROW_ON_SYS_ERROR_FMT(
             symlink(strZ(pgPath), strZ(pgPathLink)) == -1, FileOpenError, "unable to create symlink '%s' to '%s'", strZ(pgPath),
@@ -216,6 +207,9 @@ testRun(void)
             walPath(STRDEF("relative/path"), pgPathLink, STRDEF("test")), strNewFmt("%s/relative/path", strZ(pgPathLink)),
             "relative path");
 
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("path errors");
+
         THROW_ON_SYS_ERROR(chdir("/") != 0, PathMissingError, "unable to chdir()");
         TEST_ERROR(
             walPath(STRDEF("relative/path"), pgPathLink, STRDEF("test")), OptionInvalidValueError,
@@ -234,15 +228,17 @@ testRun(void)
     {
         // Load configuration to set repo-path and stanza
         StringList *argList = strLstNew();
-        strLstAddZ(argList, "--stanza=db");
+        hrnCfgArgRawZ(argList, cfgOptStanza, "db");
         hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
-        strLstAddZ(argList, "--repo-path=" TEST_PATH);
+        hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH);
-        strLstAddZ(argList, "archive-get");
         HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
 
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("no path or segment");
+
         TEST_RESULT_STR(walSegmentFind(storageRepo(), STRDEF("9.6-2"), STRDEF("123456781234567812345678"), 0), NULL, "no path");
 
-        storagePathCreateP(storageTest, STRDEF("archive/db/9.6-2/1234567812345678"));
+        HRN_STORAGE_PATH_CREATE(storageTest, "archive/db/9.6-2/1234567812345678");
         TEST_RESULT_STR(
             walSegmentFind(storageRepo(), STRDEF("9.6-2"), STRDEF("123456781234567812345678"), 0), NULL, "no segment");
         TEST_ERROR(
@@ -252,6 +248,9 @@ testRun(void)
             "HINT: check the PostgreSQL server log for errors.\n"
             "HINT: run the 'start' command if the stanza was previously stopped.");
 
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("timeout");
+
         // Check timeout by making the wal segment appear after 250ms
         HARNESS_FORK_BEGIN()
         {
@@ -259,12 +258,9 @@ testRun(void)
             {
                 sleepMSec(250);
 
-                storagePutP(
+                HRN_STORAGE_PUT_EMPTY(
-                    storageNewWriteP(
+                    storageTest,
-                        storageTest,
+                    "archive/db/9.6-2/1234567812345678/123456781234567812345678-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
-                        STRDEF(
-                            "archive/db/9.6-2/1234567812345678/123456781234567812345678-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")),
-                    NULL);
             }
             HARNESS_FORK_CHILD_END();
 
@@ -278,11 +274,11 @@ testRun(void)
         }
         HARNESS_FORK_END();
 
-        storagePutP(
+        // -------------------------------------------------------------------------------------------------------------------------
-            storageNewWriteP(
+        TEST_TITLE("duplicate");
-                storageTest,
+
-                STRDEF("archive/db/9.6-2/1234567812345678/123456781234567812345678-bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.gz")),
+        HRN_STORAGE_PUT_EMPTY(
-            NULL);
+            storageTest, "archive/db/9.6-2/1234567812345678/123456781234567812345678-bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.gz");
 
         TEST_ERROR(
             walSegmentFind(storageRepo(), STRDEF("9.6-2"), STRDEF("123456781234567812345678"), 0),
@@ -292,6 +288,9 @@ testRun(void)
                 ", 123456781234567812345678-bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.gz"
                 "\nHINT: are multiple primaries archiving to this stanza?");
 
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("partial not found");
+
         TEST_RESULT_STR(
             walSegmentFind(storageRepo(), STRDEF("9.6-2"), STRDEF("123456781234567812345678.partial"), 0), NULL,
             "did not find partial segment");
@@ -300,12 +299,19 @@ testRun(void)
     // *****************************************************************************************************************************
     if (testBegin("walSegmentNext()"))
     {
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("beginning and end range");
+
         TEST_RESULT_STR_Z(
             walSegmentNext(STRDEF("000000010000000100000001"), 16 * 1024 * 1024, PG_VERSION_10), "000000010000000100000002",
             "get next");
         TEST_RESULT_STR_Z(
             walSegmentNext(STRDEF("0000000100000001000000FE"), 16 * 1024 * 1024, PG_VERSION_93), "0000000100000001000000FF",
             "get next");
+
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("check overflow by version");
+
         TEST_RESULT_STR_Z(
             walSegmentNext(STRDEF("0000009900000001000000FF"), 16 * 1024 * 1024, PG_VERSION_93), "000000990000000200000000",
             "get next overflow >= 9.3");
@@ -323,9 +329,16 @@ testRun(void)
     // *****************************************************************************************************************************
     if (testBegin("walSegmentRange()"))
     {
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("single segment");
+
         TEST_RESULT_STRLST_Z(
             walSegmentRange(STRDEF("000000010000000100000000"), 16 * 1024 * 1024, PG_VERSION_92, 1), "000000010000000100000000\n",
             "get single");
+
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("check range by version");
+
         TEST_RESULT_STRLST_Z(
             walSegmentRange(STRDEF("0000000100000001000000FD"), 16 * 1024 * 1024, PG_VERSION_92, 4),
             "0000000100000001000000FD\n0000000100000001000000FE\n000000010000000200000000\n000000010000000200000001\n",

test/src/module/command/archiveGetTest.c

@@ -23,20 +23,25 @@ testRun(void)
     if (testBegin("queueNeed()"))
     {
         StringList *argList = strLstNew();
-        strLstAddZ(argList, "--stanza=test1");
+        hrnCfgArgRawZ(argList, cfgOptStanza, "test1");
-        strLstAddZ(argList, "--archive-async");
+        hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
         hrnCfgArgRawZ(argList, cfgOptPgPath, "/unused");
-        strLstAddZ(argList, "--spool-path=" TEST_PATH "/spool");
+        hrnCfgArgRawZ(argList, cfgOptSpoolPath, TEST_PATH "/spool");
         HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
 
         size_t queueSize = 16 * 1024 * 1024;
         size_t walSegmentSize = 16 * 1024 * 1024;
 
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("path missing");
+
         TEST_ERROR(
             queueNeed(STRDEF("000000010000000100000001"), false, queueSize, walSegmentSize, PG_VERSION_92),
             PathMissingError, "unable to list file info for missing path '" TEST_PATH "/spool/archive/test1/in'");
 
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("queue size too small");
+
         HRN_STORAGE_PATH_CREATE(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN);
 
         TEST_RESULT_STRLST_Z(
@@ -44,6 +49,8 @@ testRun(void)
             "000000010000000100000001\n000000010000000100000002\n", "queue size smaller than min");
 
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("queue empty");
+
         queueSize = (16 * 1024 * 1024) * 3;
 
         TEST_RESULT_STRLST_Z(
@@ -51,6 +58,8 @@ testRun(void)
             "000000010000000100000001\n000000010000000100000002\n000000010000000100000003\n", "empty queue");
 
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("pg version earlier than 9.3");
+
         Buffer *walSegmentBuffer = bufNew(walSegmentSize);
         memset(bufPtr(walSegmentBuffer), 0, walSegmentSize);
 
@@ -61,8 +70,7 @@ testRun(void)
             queueNeed(STRDEF("0000000100000001000000FE"), false, queueSize, walSegmentSize, PG_VERSION_92),
             "000000010000000200000000\n000000010000000200000001\n", "queue has wal < 9.3");
 
-        TEST_RESULT_STRLST_Z(
+        TEST_STORAGE_LIST(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN, "0000000100000001000000FE\n", .comment = "check queue");
-            storageListP(storageSpoolWrite(), STRDEF(STORAGE_SPOOL_ARCHIVE_IN)), "0000000100000001000000FE\n", "check queue");
 
         // -------------------------------------------------------------------------------------------------------------------------
         TEST_TITLE("pg >= 9.3 and ok/junk status files");
@@ -341,25 +349,28 @@ testRun(void)
 
         TEST_RESULT_VOID(cmdArchiveGetAsync(), "archive async");
 
-        #define TEST_WARN                                                                                                          \
-            "repo2: [ArchiveMismatchError] unable to retrieve the archive id for database version '10' and system-id"              \
-                " '18072658121562454734'"
-
         TEST_RESULT_LOG(
             "P00   INFO: get 3 WAL file(s) from archive: 0000000100000001000000FE...000000010000000200000000\n"
-            "P00   WARN: " TEST_WARN "\n"
+            "P00   WARN: repo2: [ArchiveMismatchError] unable to retrieve the archive id for database version '10' and system-id"
+                " '18072658121562454734'\n"
             "P01 DETAIL: found 0000000100000001000000FE in the repo1: 10-1 archive\n"
             "P00 DETAIL: unable to find 0000000100000001000000FF in the archive");
 
         TEST_STORAGE_GET(
-            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FE.ok", "0\n" TEST_WARN, .remove = true);
+            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FE.ok",
+            "0\n"
+            "repo2: [ArchiveMismatchError] unable to retrieve the archive id for database version '10' and system-id"
+            " '18072658121562454734'",
+            .remove = true);
         TEST_STORAGE_GET(
-            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FF.ok", "0\n" TEST_WARN, .remove = true);
+            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FF.ok",
+            "0\n"
+            "repo2: [ArchiveMismatchError] unable to retrieve the archive id for database version '10' and system-id"
+            " '18072658121562454734'",
+            .remove = true);
         TEST_STORAGE_GET_EMPTY(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FE", .remove = true);
         TEST_STORAGE_LIST_EMPTY(storageSpool(), STORAGE_SPOOL_ARCHIVE_IN);
 
-        #undef TEST_WARN
-
         // -------------------------------------------------------------------------------------------------------------------------
         TEST_TITLE("error on duplicates now that no segments are missing, repo with bad perms");
 
@@ -379,17 +390,12 @@ testRun(void)
 
         TEST_RESULT_VOID(cmdArchiveGetAsync(), "archive async");
 
-        #define TEST_WARN1                                                                                                         \
-            "repo2: [PathOpenError] unable to list file info for path '" TEST_PATH "/repo2/archive/test2/10-1"                     \
-                "/0000000100000001': [13] Permission denied"
-        #define TEST_WARN2                                                                                                         \
-            "repo2: [PathOpenError] unable to list file info for path '" TEST_PATH "/repo2/archive/test2/10-1"                     \
-                "/0000000100000002': [13] Permission denied"
-
         TEST_RESULT_LOG(
             "P00   INFO: get 3 WAL file(s) from archive: 0000000100000001000000FE...000000010000000200000000\n"
-            "P00   WARN: " TEST_WARN1 "\n"
+            "P00   WARN: repo2: [PathOpenError] unable to list file info for path '" TEST_PATH "/repo2/archive/test2/10-1"
-            "P00   WARN: " TEST_WARN2 "\n"
+                "/0000000100000001': [13] Permission denied\n"
+            "P00   WARN: repo2: [PathOpenError] unable to list file info for path '" TEST_PATH "/repo2/archive/test2/10-1"
+                "/0000000100000002': [13] Permission denied\n"
             "P01 DETAIL: found 0000000100000001000000FE in the repo1: 10-1 archive\n"
             "P01 DETAIL: found 0000000100000001000000FF in the repo1: 10-1 archive\n"
             "P00   WARN: [ArchiveDuplicateError] duplicates found for WAL segment 000000010000000200000000:\n"
@@ -399,10 +405,18 @@ testRun(void)
 
         TEST_STORAGE_GET_EMPTY(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FE", .remove = true);
         TEST_STORAGE_GET(
-            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FE.ok", "0\n" TEST_WARN1, .remove = true);
+            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FE.ok",
+            "0\n"
+            "repo2: [PathOpenError] unable to list file info for path '" TEST_PATH "/repo2/archive/test2/10-1/0000000100000001':"
+                " [13] Permission denied",
+            .remove = true);
         TEST_STORAGE_GET_EMPTY(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FF", .remove = true);
         TEST_STORAGE_GET(
-            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FF.ok", "0\n" TEST_WARN1, .remove = true);
+            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/0000000100000001000000FF.ok",
+            "0\n"
+            "repo2: [PathOpenError] unable to list file info for path '" TEST_PATH "/repo2/archive/test2/10-1/0000000100000001':"
+                " [13] Permission denied",
+            .remove = true);
         TEST_STORAGE_GET(
             storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000200000000.error",
             "45\n"
@@ -410,15 +424,13 @@ testRun(void)
             "repo1: 10-1/0000000100000002/000000010000000200000000-bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, 10-1/0000000100000002"
                 "/000000010000000200000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
             "HINT: are multiple primaries archiving to this stanza?\n"
-            TEST_WARN2,
+            "repo2: [PathOpenError] unable to list file info for path '" TEST_PATH "/repo2/archive/test2/10-1"                     \
+                "/0000000100000002': [13] Permission denied",
             .remove = true);
         TEST_STORAGE_LIST_EMPTY(storageSpool(), STORAGE_SPOOL_ARCHIVE_IN);
 
         HRN_STORAGE_MODE(storageRepoIdxWrite(1), STORAGE_REPO_ARCHIVE "/10-1");
 
-        #undef TEST_WARN1
-        #undef TEST_WARN2
-
         // -------------------------------------------------------------------------------------------------------------------------
         TEST_TITLE("error on duplicates");
 
@@ -479,21 +491,21 @@ testRun(void)
 
         TEST_RESULT_VOID(cmdArchiveGetAsync(), "archive async");
 
-        #define TEST_WARN1                                                                                                         \
-            "repo3: [ArchiveMismatchError] unable to retrieve the archive id for database version '10' and system-id"              \
-                " '18072658121562454734'"
-        #define TEST_WARN2                                                                                                         \
-            "repo1: 10-1/0000000100000002/000000010000000200000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz"                    \
-                " [FormatError] unexpected eof in compressed data"
-
         TEST_RESULT_LOG(
             "P00   INFO: get 1 WAL file(s) from archive: 000000010000000200000000\n"
-            "P00   WARN: " TEST_WARN1 "\n"
+            "P00   WARN: repo3: [ArchiveMismatchError] unable to retrieve the archive id for database version '10' and system-id"
-            "P01   WARN: " TEST_WARN2 "\n"
+                " '18072658121562454734'\n"
+            "P01   WARN: repo1: 10-1/0000000100000002/000000010000000200000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz"
+                " [FormatError] unexpected eof in compressed data\n"
             "P01 DETAIL: found 000000010000000200000000 in the repo2: 10-1 archive");
 
         TEST_STORAGE_GET(
-            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000200000000.ok", "0\n" TEST_WARN1 "\n" TEST_WARN2,
+            storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000200000000.ok",
+            "0\n"
+            "repo3: [ArchiveMismatchError] unable to retrieve the archive id for database version '10' and system-id"
+                " '18072658121562454734'\n"
+            "repo1: 10-1/0000000100000002/000000010000000200000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz"
+                " [FormatError] unexpected eof in compressed data",
             .remove = true);
         TEST_STORAGE_GET_EMPTY(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000200000000", .remove = true);
         TEST_STORAGE_LIST_EMPTY(storageSpool(), STORAGE_SPOOL_ARCHIVE_IN);
@@ -511,24 +523,26 @@ testRun(void)
 
         TEST_RESULT_VOID(cmdArchiveGetAsync(), "archive async");
 
-        #define TEST_WARN3                                                                                                         \
-            "repo2: 10-1/0000000100000002/000000010000000200000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz"                    \
-                " [FormatError] unexpected eof in compressed data"
-
         TEST_RESULT_LOG(
             "P00   INFO: get 1 WAL file(s) from archive: 000000010000000200000000\n"
-            "P00   WARN: " TEST_WARN1 "\n"
+            "P00   WARN: repo3: [ArchiveMismatchError] unable to retrieve the archive id for database version '10' and system-id"
+                " '18072658121562454734'\n"
             "P01   WARN: [FileReadError] raised from local-1 shim protocol: unable to get 000000010000000200000000:\n"
-            "            " TEST_WARN2 "\n"
+            "            repo1: 10-1/0000000100000002/000000010000000200000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz"
-            "            " TEST_WARN3);
+                " [FormatError] unexpected eof in compressed data\n"
+            "            repo2: 10-1/0000000100000002/000000010000000200000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz"
+                " [FormatError] unexpected eof in compressed data");
 
         TEST_STORAGE_GET(
             storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000200000000.error",
             "42\n"
             "raised from local-1 shim protocol: unable to get 000000010000000200000000:\n"
-            TEST_WARN2 "\n"
+            "repo1: 10-1/0000000100000002/000000010000000200000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz"
-            TEST_WARN3 "\n"
+                " [FormatError] unexpected eof in compressed data\n"
-            TEST_WARN1,
+            "repo2: 10-1/0000000100000002/000000010000000200000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz"
+                " [FormatError] unexpected eof in compressed data\n"
+            "repo3: [ArchiveMismatchError] unable to retrieve the archive id for database version '10' and system-id"
+                " '18072658121562454734'",
             .remove = true);
         TEST_STORAGE_LIST(
             storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN, "000000010000000200000000.pgbackrest.tmp\n", .remove = true);
@@ -571,7 +585,6 @@ testRun(void)
     {
         harnessLogLevelSet(logLevelDetail);
 
-        // Arguments that must be included. Use raw config here because we need to keep the
         StringList *argBaseList = strLstNew();
         hrnCfgArgRawZ(argBaseList, cfgOptPgPath, TEST_PATH "/pg");
         hrnCfgArgRawZ(argBaseList, cfgOptRepoPath, TEST_PATH "/repo");
@@ -588,12 +601,16 @@ testRun(void)
         TEST_ERROR(cmdArchiveGet(), HostInvalidError, "archive-get command must be run on the PostgreSQL host");
 
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("segment parameter not specified");
+
         argList = strLstDup(argBaseList);
         HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
 
         TEST_ERROR(cmdArchiveGet(), ParamRequiredError, "WAL segment to get required");
 
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("path parameter not specified");
+
         argList = strLstDup(argBaseList);
         strLstAddZ(argList, "000000010000000100000001");
         HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
@@ -601,6 +618,8 @@ testRun(void)
         TEST_ERROR(cmdArchiveGet(), ParamRequiredError, "path to copy WAL segment required");
 
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("no valid repo");
+
         HRN_STORAGE_PUT(
             storagePgWrite(), PG_PATH_GLOBAL "/" PG_FILE_PGCONTROL,
             hrnPgControlToBuffer((PgControl){.version = PG_VERSION_10, .systemId = 0xFACEFACEFACEFACE}));
@@ -623,10 +642,12 @@ testRun(void)
                 " scheme.");
 
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("no valid repo - async");
+
         argList = strLstDup(argBaseList);
+        hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
         strLstAddZ(argList, "00000001.history");
         strLstAddZ(argList, TEST_PATH "/pg/pg_wal/RECOVERYHISTORY");
-        strLstAddZ(argList, "--archive-async");
         HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
 
         TEST_ERROR(cmdArchiveGet(), RepoInvalidError, "unable to find a valid repository");
@@ -643,8 +664,10 @@ testRun(void)
             "            HINT: use --no-archive-check to disable archive checks during backup if you have an alternate archiving"
                 " scheme.");
 
-        // Make sure the process times out when there is nothing to get
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("WAL not found - timeout");
+
+        // Make sure the process times out when there is nothing to get
         argList = strLstDup(argBaseList);
         hrnCfgArgRawZ(argList, cfgOptSpoolPath, TEST_PATH "/spool");
         hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
@@ -658,8 +681,9 @@ testRun(void)
             cmdArchiveGet(), ArchiveTimeoutError,
             "unable to get WAL file '000000010000000100000001' from the archive asynchronously after 1 second(s)");
 
-        // Check for missing WAL
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("check for missing WAL");
+
         HRN_STORAGE_PUT_EMPTY(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000100000001.ok");
 
         TEST_ERROR(
@@ -670,8 +694,9 @@ testRun(void)
             storageExistsP(storageSpool(), STRDEF(STORAGE_SPOOL_ARCHIVE_IN "/000000010000000100000001.ok")), false,
             "check OK file was removed");
 
-        // Write out a WAL segment for success
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("write WAL segment for success");
+
         HRN_STORAGE_PATH_CREATE(storagePgWrite(), "pg_wal");
         HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000100000001", "SHOULD-BE-A-REAL-WAL-FILE");
 
@@ -682,11 +707,13 @@ testRun(void)
         TEST_STORAGE_LIST_EMPTY(storageSpool(), STORAGE_SPOOL_ARCHIVE_IN);
         TEST_STORAGE_LIST(storagePgWrite(), "pg_wal", "RECOVERYXLOG\n", .remove = true);
 
-        // Write more WAL segments (in this case queue should be full)
         // -------------------------------------------------------------------------------------------------------------------------
-        strLstAddZ(argList, "--archive-get-queue-max=48");
+        TEST_TITLE("write WAL segments for success - queue full");
+
+        hrnCfgArgRawZ(argList, cfgOptArchiveGetQueueMax, "48");
         HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
 
+        // Write more WAL segments (in this case queue should be full)
         HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000100000001", "SHOULD-BE-A-REAL-WAL-FILE");
         HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000100000001.ok", "0\nwarning about x");
         HRN_STORAGE_PUT_Z(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN "/000000010000000100000002", "SHOULD-BE-A-REAL-WAL-FILE");
@@ -700,8 +727,10 @@ testRun(void)
         TEST_STORAGE_LIST(storagePgWrite(), "pg_wal", "RECOVERYXLOG\n", .remove = true);
         TEST_STORAGE_LIST(storageSpoolWrite(), STORAGE_SPOOL_ARCHIVE_IN, "000000010000000100000002\n", .remove = true);
 
-        // Make sure the process times out when it can't get a lock
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("unable to get lock");
+
+        // Make sure the process times out when it can't get a lock
         HARNESS_FORK_BEGIN()
         {
             HARNESS_FORK_CHILD_BEGIN(0, true)
@@ -749,6 +778,8 @@ testRun(void)
         HARNESS_FORK_END();
 
         // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("too many parameters specified");
+
         strLstAddZ(argList, BOGUS_STR);
         HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
 
@@ -1029,9 +1060,9 @@ testRun(void)
         // -------------------------------------------------------------------------------------------------------------------------
         TEST_TITLE("unable to get from one repo");
 
-        HRN_STORAGE_PUT(
+        HRN_STORAGE_PUT_EMPTY(
             storageRepoIdxWrite(0),
-            STORAGE_REPO_ARCHIVE "/10-2/01ABCDEF01ABCDEF01ABCDEF-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz", NULL);
+            STORAGE_REPO_ARCHIVE "/10-2/01ABCDEF01ABCDEF01ABCDEF-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.gz");
 
         TEST_RESULT_INT(cmdArchiveGet(), 0, "get");
 
@@ -1070,8 +1101,7 @@ testRun(void)
 
         TEST_RESULT_INT(cmdArchiveGet(), 0, "get");
 
-        TEST_RESULT_LOG(
+        TEST_RESULT_LOG("P00   INFO: found 01ABCDEF01ABCDEF01ABCDEF in the repo2: 10-1 archive");
-            "P00   INFO: found 01ABCDEF01ABCDEF01ABCDEF in the repo2: 10-1 archive");
 
         // -------------------------------------------------------------------------------------------------------------------------
         TEST_TITLE("no segments to find with existing ok file");