db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-01-18 04:58:51 +02:00
Code Issues Releases Activity

Replace harnessCfgLoad*() functions with HRN_CFG_LOAD() macro.

Browse Source 
HRN_CFG_LOAD() handles the majority of test configuration loads and has various options for special cases.

It was not clear when to use harnessCfgLoadRaw() vs harnessCfgLoad(). Now "raw" functionality is granular and enabled by parameters, e.g. noStd.
This commit is contained in:
David Steele 2021-06-01 09:03:44 -04:00
parent c1277677a3
commit 8250990afb
36 changed files with 573 additions and 615 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
CONTRIBUTING.md
View File

@ -234,7 +234,7 @@ pgbackrest/test/test.pl --vm=none --dry-run
P00 INFO: test begin - log level info
P00 INFO: builds required: bin
--> P00 INFO: 68 tests selected
P00 INFO: P1-T01/68 - vm=none, module=common, test=error
[filtered 65 lines of output]
P00 INFO: P1-T67/68 - vm=none, module=performance, test=type
@ -253,12 +253,12 @@ pgbackrest/test/test.pl --vm=none --dev --vm-out --module=common --test=wait
P00 INFO: cleanup old data
P00 INFO: builds required: none
P00 INFO: 1 test selected
P00 INFO: P1-T1/1 - vm=none, module=common, test=wait
run 1 - waitNew(), waitMore, and waitFree()
l0018 expect AssertError: assertion 'waitTime <= 999999000' failed
run 1/1 ------------- l0021 0ms wait
l0025 new wait
l0026 check remaining time
@ -283,9 +283,9 @@ pgbackrest/test/test.pl --vm=none --dev --vm-out --module=common --test=wait
l0062 lower range check
l0063 upper range check
l0065 free wait
TESTS COMPLETED SUCCESSFULLY
P00 INFO: P1-T1/1 - vm=none, module=common, test=wait
P00 INFO: tested modules have full coverage
P00 INFO: writing C coverage report
@ -305,7 +305,7 @@ pgbackrest/test/test.pl --vm=none --dev --module=postgres
P00 INFO: cleanup old data
P00 INFO: builds required: none
P00 INFO: 2 tests selected
P00 INFO: P1-T1/2 - vm=none, module=postgres, test=client
P00 INFO: P1-T2/2 - vm=none, module=postgres, test=interface
P00 INFO: tested modules have full coverage
@ -345,7 +345,7 @@ pgbackrest/test/test.pl --vm=u18 --dev --module=mock --test=archive --run=2
P00 INFO: bin dependencies have changed for none, rebuilding...
P00 INFO: build bin for none (/home/vagrant/test/bin/none)
P00 INFO: 1 test selected
P00 INFO: P1-T1/1 - vm=u18, module=mock, test=archive, run=2
P00 INFO: no code modules had all tests run required for coverage
P00 INFO: TESTS COMPLETED SUCCESSFULLY
@ -392,14 +392,14 @@ if (testBegin("expireBackup()"))
#### Setting up the command to be run
The [harnessConfig.h](https://github.com/pgbackrest/pgbackrest/blob/master/test/src/common/harnessConfig.h) describes a list of functions that should be used when configuration options are required for a command being tested. Options are set in a `StringList` which must be defined and passed to the function `harnessCfgLoad()` with the command. For example, the following will set up a test to run `pgbackrest --repo-path=test/test-0/repo info` command on multiple repositories, one of which is encrypted:
The [harnessConfig.h](https://github.com/pgbackrest/pgbackrest/blob/master/test/src/common/harnessConfig.h) describes a list of functions that should be used when configuration options are required for a command being tested. Options are set in a `StringList` which must be defined and passed to the `HRN_CFG_LOAD()` macro with the command. For example, the following will set up a test to run `pgbackrest --repo-path=test/test-0/repo info` command on multiple repositories, one of which is encrypted:
```
StringList *argList = strLstNew(); // Create an empty string list
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO); // Add the --repo-path option
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 2, TEST_PATH "/repo2"); // Add the --repo2-path option
hrnCfgArgKeyRawStrId(argList, cfgOptRepoCipherType, 2, cipherTypeAes256Cbc); // Add the --repo2-cipher-type option
hrnCfgEnvKeyRawZ(cfgOptRepoCipherPass, 2, TEST_CIPHER_PASS); // Set environment variable for the --repo2-cipher-pass option
harnessCfgLoad(cfgCmdInfo, argList); // Load the command and option list into the test harness
HRN_CFG_LOAD(cfgCmdInfo, argList); // Load the command and option list into the test harness
```
#### Storing a file
@ -455,7 +455,7 @@ HARNESS_FORK_BEGIN()
{
sleepMSec(250);
harnessCfgLoad(cfgCmdInfo, argListText);
HRN_CFG_LOAD(cfgCmdInfo, argListText);
TEST_RESULT_STR_Z(
infoRender(),
"stanza: stanza1\n"
@ -531,7 +531,7 @@ There are detailed comment blocks above each section that explain the rules for
The `option:` section is broken into sub-sections by a simple comment divider (e.g. `# Repository options`) under which the options are organized alphabetically by option name. To better explain this section, two hypothetical examples will be discussed. For more details, see [config.yaml](https://github.com/pgbackrest/pgbackrest/blob/master/src/build/config/config.yaml).
#### Example 1: hypothetical command line only option
#### Example 1: hypothetical command line only option
```
set:
type: string

6
doc/xml/contributing.xml
View File

@ -442,7 +442,7 @@ if (testBegin("expireBackup()"))
<section id="test-command">
<title>Setting up the command to be run</title>
<p>The <link url="{[github-url-test-common]}/harnessConfig.h">harnessConfig.h</link> describes a list of functions that should be used when configuration options are required for a command being tested. Options are set in a <code>StringList</code> which must be defined and passed to the function <code>harnessCfgLoad()</code> with the command. For example, the following will set up a test to run <cmd>pgbackrest --repo-path=test/test-0/repo info</cmd> command on multiple repositories, one of which is encrypted:</p>
<p>The <link url="{[github-url-test-common]}/harnessConfig.h">harnessConfig.h</link> describes a list of functions that should be used when configuration options are required for a command being tested. Options are set in a <code>StringList</code> which must be defined and passed to the <code>HRN_CFG_LOAD()</code> macro with the command. For example, the following will set up a test to run <cmd>pgbackrest --repo-path=test/test-0/repo info</cmd> command on multiple repositories, one of which is encrypted:</p>
<code-block>
StringList *argList = strLstNew(); // Create an empty string list
@ -450,7 +450,7 @@ hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO); // Add the -
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 2, TEST_PATH "/repo2"); // Add the --repo2-path option
hrnCfgArgKeyRawStrId(argList, cfgOptRepoCipherType, 2, cipherTypeAes256Cbc); // Add the --repo2-cipher-type option
hrnCfgEnvKeyRawZ(cfgOptRepoCipherPass, 2, TEST_CIPHER_PASS); // Set environment variable for the --repo2-cipher-pass option
harnessCfgLoad(cfgCmdInfo, argList); // Load the command and option list into the test harness
HRN_CFG_LOAD(cfgCmdInfo, argList); // Load the command and option list into the test harness
</code-block>
</section>
@ -514,7 +514,7 @@ HARNESS_FORK_BEGIN()
{
sleepMSec(250);
harnessCfgLoad(cfgCmdInfo, argListText);
HRN_CFG_LOAD(cfgCmdInfo, argListText);
TEST_RESULT_STR_Z(
infoRender(),
"stanza: stanza1\n"

118
test/src/common/harnessConfig.c
View File

@ -7,11 +7,6 @@ Harness for Loading Test Configurations
#include <stdio.h>
#include <stdlib.h>
#include "common/harnessConfig.h"
#include "common/harnessDebug.h"
#include "common/harnessLog.h"
#include "common/harnessTest.h"
#include "common/io/io.h"
#include "config/config.intern.h"
#include "config/load.h"
@ -19,32 +14,63 @@ Harness for Loading Test Configurations
#include "storage/helper.h"
#include "version.h"
#include "common/harnessConfig.h"
#include "common/harnessDebug.h"
#include "common/harnessLog.h"
#include "common/harnessTest.h"
/**********************************************************************************************************************************/
void
harnessCfgLoadRaw(unsigned int argListSize, const char *argList[])
hrnCfgLoad(ConfigCommand commandId, const StringList *argListParam, const HrnCfgLoadParam param)
{
FUNCTION_HARNESS_BEGIN();
FUNCTION_HARNESS_PARAM(UINT, argListSize);
FUNCTION_HARNESS_PARAM(CHARPY, argList);
FUNCTION_HARNESS_PARAM(ENUM, commandId);
FUNCTION_HARNESS_PARAM(STRING_LIST, argListParam);
FUNCTION_HARNESS_PARAM(ENUM, param.role);
FUNCTION_HARNESS_END();
// Make a copy of the arg list that we can modify
StringList *argList = strLstDup(argListParam);
// Add standard options needed in most cases
if (!param.noStd)
{
// Set job retry to 0 if it is valid
if (cfgParseOptionValid(commandId, param.role, cfgOptJobRetry))
strLstInsert(argList, 0, STRDEF("--" CFGOPT_JOB_RETRY "=0"));
// Set log path if valid
if (cfgParseOptionValid(commandId, param.role, cfgOptLogPath))
strLstInsert(argList, 0, strNewFmt("--" CFGOPT_LOG_PATH "=%s", hrnPath()));
// Set lock path if valid
if (cfgParseOptionValid(commandId, param.role, cfgOptLockPath))
strLstInsert(argList, 0, strNewFmt("--" CFGOPT_LOCK_PATH "=%s/lock", hrnPath()));
}
// Insert the command so it does not interfere with parameters
if (commandId != cfgCmdNone)
strLstInsert(argList, 0, cfgCommandRoleNameParam(commandId, param.role, COLON_STR));
// Insert the project exe
strLstInsert(argList, 0, param.exeBogus ? STRDEF("pgbackrest-bogus") : STRDEF(testProjectExe()));
// Log parameters
if (param.log)
{
printf("config load:");
for (unsigned int argIdx = 0; argIdx < strLstSize(argList); argIdx++)
printf(" %s", strZ(strLstGet(argList, argIdx)));
hrnTestResultComment(param.comment);
}
// Free objects in storage helper
storageHelperFree();
// Log parameters
hrnTestLogPrefix(__LINE__);
printf("config load:");
for (unsigned int argIdx = 0; argIdx < argListSize; argIdx++)
printf(" %s", argList[argIdx]);
printf("\n");
fflush(stdout);
// Parse config
configParse(storageLocal(), argListSize, argList, false);
configParse(storageLocal(), strLstSize(argList), strLstPtr(argList), false);
// Set dry-run mode for storage and logging
harnessLogDryRunSet(cfgOptionValid(cfgOptDryRun) && cfgOptionBool(cfgOptDryRun));
@ -65,56 +91,6 @@ harnessCfgLoadRaw(unsigned int argListSize, const char *argList[])
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
void
harnessCfgLoadRole(ConfigCommand commandId, ConfigCommandRole commandRoleId, const StringList *argListParam)
{
FUNCTION_HARNESS_BEGIN();
FUNCTION_HARNESS_PARAM(ENUM, commandId);
FUNCTION_HARNESS_PARAM(ENUM, commandRoleId);
FUNCTION_HARNESS_PARAM(STRING_LIST, argListParam);
FUNCTION_HARNESS_END();
// Make a copy of the arg list that we can modify
StringList *argList = strLstDup(argListParam);
// Set job retry to 0 if it is valid
if (cfgParseOptionValid(commandId, commandRoleId, cfgOptJobRetry))
strLstInsert(argList, 0, STRDEF("--" CFGOPT_JOB_RETRY "=0"));
// Set log path if valid
if (cfgParseOptionValid(commandId, commandRoleId, cfgOptLogPath))
strLstInsert(argList, 0, strNewFmt("--" CFGOPT_LOG_PATH "=%s", hrnPath()));
// Set lock path if valid
if (cfgParseOptionValid(commandId, commandRoleId, cfgOptLockPath))
strLstInsert(argList, 0, strNewFmt("--" CFGOPT_LOCK_PATH "=%s/lock", hrnPath()));
// Insert the command so it does not interfere with parameters
strLstInsert(argList, 0, cfgCommandRoleNameParam(commandId, commandRoleId, COLON_STR));
// Insert the project exe
strLstInsert(argList, 0, STRDEF(testProjectExe()));
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
void
harnessCfgLoad(ConfigCommand commandId, const StringList *argListParam)
{
FUNCTION_HARNESS_BEGIN();
FUNCTION_HARNESS_PARAM(ENUM, commandId);
FUNCTION_HARNESS_PARAM(STRING_LIST, argListParam);
FUNCTION_HARNESS_END();
harnessCfgLoadRole(commandId, cfgCmdRoleMain, argListParam);
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
void
hrnCfgArgRaw(StringList *argList, ConfigOption optionId, const String *value)

40
test/src/common/harnessConfig.h
View File

@ -1,6 +1,9 @@
/***********************************************************************************************************************************
Harness for Loading Test Configurations
***********************************************************************************************************************************/
#ifndef TEST_COMMON_HARNESS_CONFIG_H
#define TEST_COMMON_HARNESS_CONFIG_H
#include "config/config.h"
/***********************************************************************************************************************************
@ -19,17 +22,36 @@ Config option constants
#define TEST_CIPHER_PASS_ARCHIVE "xarchivex"
/***********************************************************************************************************************************
Load a test configuration without any side effects
Load a test configuration
There's no need to open log files, acquire locks, reset log levels, etc.
Automatically adds the exe, command (and role), lock-path, and log-path so executing the binary works locally or in a container.
There is no need to open log files, acquire locks, reset log levels, etc.
HRN_CFG_LOAD() is the preferred macro but if a configuration error is being tested with TEST_ERROR() then use hrnCfgLoadP() instead
since it will not log to the console and clutter the error log message.
***********************************************************************************************************************************/
// Low-level version used when it is important that only the options set explicity by the test are present in the config. The
// additional options set by harnessCfgLoad() can make these tests harder to write. Most tests should use harnessCfgLoad().
void harnessCfgLoadRaw(unsigned int argListSize, const char *argList[]);
typedef struct HrnCfgLoadParam
{
VAR_PARAM_HEADER;
ConfigCommandRole role; // Command role (defaults to main)
bool exeBogus; // Use pgbackrest-bogus as exe parameter
bool noStd; // Do not add standard options, e.g. lock-path
bool log; // Log parameters? (used internally by HRN_CFG_LOAD())
const char *comment; // Comment
} HrnCfgLoadParam;
// Automatically adds the exe, command (and role), lock-path, and log-path so executing the binary works locally or in a container.
void harnessCfgLoad(ConfigCommand commandId, const StringList *argList);
void harnessCfgLoadRole(ConfigCommand commandId, ConfigCommandRole commandRoleId, const StringList *argList);
#define hrnCfgLoadP(commandId, argList, ...) \
hrnCfgLoad(commandId, argList, (HrnCfgLoadParam){VAR_PARAM_INIT, __VA_ARGS__})
#define HRN_CFG_LOAD(commandId, argList, ...) \
do \
{ \
hrnTestLogPrefix(__LINE__); \
hrnCfgLoad(commandId, argList, (HrnCfgLoadParam){.log = true, __VA_ARGS__}); \
} \
while (0)
void hrnCfgLoad(ConfigCommand commandId, const StringList *argList, const HrnCfgLoadParam param);
/***********************************************************************************************************************************
Configuration helper functions
@ -74,3 +96,5 @@ void hrnCfgEnvKeyRawZ(ConfigOption optionId, unsigned optionKey, const char *val
void hrnCfgEnvRemoveRaw(ConfigOption optionId);
void hrnCfgEnvKeyRemoveRaw(ConfigOption optionId, unsigned optionKey);
#endif

6
test/src/common/harnessProtocol.c
View File

@ -66,8 +66,7 @@ protocolLocalExec(
{
// Load configuration
StringList *const paramList = protocolLocalParam(protocolStorageType, hostIdx, processId);
strLstInsert(paramList, 0, cfgExe());
harnessCfgLoadRaw(strLstSize(paramList), strLstPtr(paramList));
hrnCfgLoadP(cfgCmdNone, paramList, .noStd = true);
// Change log process id to aid in debugging
hrnLogProcessIdSet(processId);
@ -163,8 +162,7 @@ protocolRemoteExec(
{
// Load configuration
StringList *const paramList = protocolRemoteParam(protocolStorageType, hostIdx);
strLstInsert(paramList, 0, cfgExe());
harnessCfgLoadRaw(strLstSize(paramList), strLstPtr(paramList));
hrnCfgLoadP(cfgCmdNone, paramList, .noStd = true);
// Change log process id to aid in debugging
hrnLogProcessIdSet(processId);

6
test/src/module/command/archiveCommonTest.c
View File

@ -29,7 +29,7 @@ testRun(void)
strLstAddZ(argList, "--archive-async");
strLstAddZ(argList, "--archive-timeout=1");
strLstAddZ(argList, "--stanza=db");
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
// -------------------------------------------------------------------------------------------------------------------------
const String *segment = STRDEF("000000010000000100000001");
@ -138,7 +138,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=db");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--" CFGOPT_ARCHIVE_ASYNC);
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleAsync);
const String *walSegment = STRDEF("000000010000000100000001");
@ -238,7 +238,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--repo-path=" TEST_PATH);
strLstAddZ(argList, "archive-get");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
TEST_RESULT_STR(walSegmentFind(storageRepo(), STRDEF("9.6-2"), STRDEF("123456781234567812345678"), 0), NULL, "no path");

49
test/src/module/command/archiveGetTest.c
View File

@ -27,7 +27,7 @@ testRun(void)
strLstAddZ(argList, "--archive-async");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/unused");
strLstAddZ(argList, "--spool-path=" TEST_PATH "/spool");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
size_t queueSize = 16 * 1024 * 1024;
size_t walSegmentSize = 16 * 1024 * 1024;
@ -117,7 +117,7 @@ testRun(void)
StringList *argList = strLstDup(argBaseList);
hrnCfgArgRawZ(argList, cfgOptPgHost, BOGUS_STR);
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleAsync);
TEST_ERROR(cmdArchiveGetAsync(), HostInvalidError, "archive-get command must be run on the PostgreSQL host");
@ -130,7 +130,7 @@ testRun(void)
TEST_TITLE("error on no segments");
argList = strLstDup(argBaseList);
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleAsync);
TEST_ERROR(cmdArchiveGetAsync(), ParamInvalidError, "at least one wal segment is required");
@ -155,7 +155,7 @@ testRun(void)
"1={\"db-id\":18072658121562454734,\"db-version\":\"10\"}\n");
strLstAddZ(argList, "000000010000000100000001");
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleAsync);
TEST_RESULT_VOID(cmdArchiveGetAsync(), "get async");
@ -317,7 +317,7 @@ testRun(void)
strLstAddZ(argList, "0000000100000001000000FE");
strLstAddZ(argList, "0000000100000001000000FF");
strLstAddZ(argList, "000000010000000200000000");
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleAsync);
HRN_INFO_PUT(
storageRepoIdxWrite(1), INFO_ARCHIVE_PATH_FILE,
@ -421,7 +421,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "000000010000000200000000");
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleAsync);
TEST_RESULT_VOID(cmdArchiveGetAsync(), "archive async");
@ -454,7 +454,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "000000010000000200000000");
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleAsync);
HRN_INFO_PUT(
storageRepoIdxWrite(2), INFO_ARCHIVE_PATH_FILE,
@ -534,17 +534,15 @@ testRun(void)
hrnProtocolLocalShimUninstall();
argList = strLstNew();
strLstAddZ(argList, "pgbackrest-bogus");
hrnCfgArgRawZ(argList, cfgOptPgPath, TEST_PATH_PG);
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawZ(argList, cfgOptSpoolPath, TEST_PATH_SPOOL);
hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
hrnCfgArgRawZ(argList, cfgOptStanza, "test2");
strLstAddZ(argList, CFGCMD_ARCHIVE_GET ":" CONFIG_COMMAND_ROLE_ASYNC);
strLstAddZ(argList, "0000000100000001000000FE");
strLstAddZ(argList, "0000000100000001000000FF");
strLstAddZ(argList, "000000010000000200000000");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleAsync, .exeBogus = true);
TEST_ERROR(
cmdArchiveGetAsync(), ExecuteError,
@ -569,33 +567,30 @@ testRun(void)
// Arguments that must be included. Use raw config here because we need to keep the
StringList *argBaseList = strLstNew();
strLstAddZ(argBaseList, "pgbackrest-bogus");
hrnCfgArgRawZ(argBaseList, cfgOptPgPath, TEST_PATH_PG);
hrnCfgArgRawZ(argBaseList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawZ(argBaseList, cfgOptStanza, "test1");
hrnCfgArgRawZ(argBaseList, cfgOptArchiveTimeout, "1");
hrnCfgArgRawZ(argBaseList, cfgOptLockPath, HRN_PATH "/lock");
strLstAddZ(argBaseList, CFGCMD_ARCHIVE_GET);
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("command must be run on the pg host");
StringList *argList = strLstDup(argBaseList);
hrnCfgArgRawZ(argList, cfgOptPgHost, BOGUS_STR);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
TEST_ERROR(cmdArchiveGet(), HostInvalidError, "archive-get command must be run on the PostgreSQL host");
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstDup(argBaseList);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
TEST_ERROR(cmdArchiveGet(), ParamRequiredError, "WAL segment to get required");
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstDup(argBaseList);
strLstAddZ(argList, "000000010000000100000001");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
TEST_ERROR(cmdArchiveGet(), ParamRequiredError, "path to copy WAL segment required");
@ -605,7 +600,7 @@ testRun(void)
hrnPgControlToBuffer((PgControl){.version = PG_VERSION_10, .systemId = 0xFACEFACEFACEFACE}));
strLstAddZ(argList, TEST_PATH_PG "/pg_wal/RECOVERYXLOG");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
TEST_ERROR(cmdArchiveGet(), RepoInvalidError, "unable to find a valid repository");
@ -626,7 +621,7 @@ testRun(void)
strLstAddZ(argList, "00000001.history");
strLstAddZ(argList, TEST_PATH_PG "/pg_wal/RECOVERYHISTORY");
strLstAddZ(argList, "--archive-async");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
TEST_ERROR(cmdArchiveGet(), RepoInvalidError, "unable to find a valid repository");
@ -649,7 +644,7 @@ testRun(void)
hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
strLstAddZ(argList, "000000010000000100000001");
strLstAddZ(argList, "pg_wal/RECOVERYXLOG");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
THROW_ON_SYS_ERROR(chdir(strZ(cfgOptionStr(cfgOptPgPath))) != 0, PathMissingError, "unable to chdir()");
@ -684,7 +679,7 @@ testRun(void)
// Write more WAL segments (in this case queue should be full)
// -------------------------------------------------------------------------------------------------------------------------
strLstAddZ(argList, "--archive-get-queue-max=48");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
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");
@ -749,7 +744,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
strLstAddZ(argList, BOGUS_STR);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .exeBogus = true);
TEST_ERROR(cmdArchiveGet(), ParamInvalidError, "extra parameters found");
@ -776,7 +771,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "01ABCDEF01ABCDEF01ABCDEF");
strLstAddZ(argList, TEST_PATH_PG "/pg_wal/RECOVERYXLOG");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
TEST_ERROR(cmdArchiveGet(), RepoInvalidError, "unable to find a valid repository");
@ -896,7 +891,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "000000010000000100000001.partial");
strLstAddZ(argList, TEST_PATH_PG "/pg_wal/RECOVERYXLOG");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
TEST_RESULT_INT(cmdArchiveGet(), 0, "get");
@ -913,7 +908,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "00000001.history");
strLstAddZ(argList, TEST_PATH_PG "/pg_wal/RECOVERYHISTORY");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
TEST_RESULT_INT(cmdArchiveGet(), 1, "get");
@ -962,7 +957,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptStanza, "test1");
strLstAddZ(argList, "01ABCDEF01ABCDEF01ABCDEF");
strLstAddZ(argList, TEST_PATH_PG "/pg_wal/RECOVERYXLOG");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
hrnCfgEnvKeyRemoveRaw(cfgOptRepoCipherPass, 2);
TEST_RESULT_INT(cmdArchiveGet(), 0, "get");
@ -1061,7 +1056,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
hrnCfgEnvKeyRawZ(cfgOptRepoCipherPass, 2, TEST_CIPHER_PASS);
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
hrnCfgEnvKeyRemoveRaw(cfgOptRepoCipherPass, 2);
TEST_RESULT_INT(cmdArchiveGet(), 0, "get");
@ -1081,7 +1076,7 @@ testRun(void)
hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
strLstAddZ(argList, "000000010000000100000001");
strLstAddZ(argList, "pg_wal/RECOVERYXLOG");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
HRN_INFO_PUT(
storageRepoIdxWrite(0), INFO_ARCHIVE_PATH_FILE,

57
test/src/module/command/archivePushTest.c
View File

@ -32,7 +32,7 @@ testRun(void)
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/db");
strLstAddZ(argList, "--spool-path=" TEST_PATH "/spool");
strLstAddZ(argList, "--" CFGOPT_ARCHIVE_ASYNC);
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleAsync);
storagePathCreateP(storagePgWrite(), STRDEF("pg_wal/archive_status"));
storagePathCreateP(storageTest, STRDEF("spool/archive/db/out"));
@ -69,7 +69,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
StringList *argListDrop = strLstDup(argList);
strLstAdd(argListDrop, strNewFmt("--archive-push-queue-max=%zu", (size_t)1024 * 1024 * 1024));
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argListDrop);
HRN_CFG_LOAD(cfgCmdArchivePush, argListDrop, .role = cfgCmdRoleAsync);
// Write the files that we claim are in pg_wal
Buffer *walBuffer = bufNew((size_t)16 * 1024 * 1024);
@ -90,7 +90,7 @@ testRun(void)
// Now set queue max low enough that WAL will be dropped
argListDrop = strLstDup(argList);
strLstAdd(argListDrop, strNewFmt("--archive-push-queue-max=%zu", (size_t)16 * 1024 * 1024 * 2));
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argListDrop);
HRN_CFG_LOAD(cfgCmdArchivePush, argListDrop, .role = cfgCmdRoleAsync);
TEST_RESULT_BOOL(
archivePushDrop(STRDEF("pg_wal"), archivePushProcessList(STRDEF(TEST_PATH "/db/pg_wal"))), true,
@ -104,7 +104,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test");
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/pg");
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
// Check mismatched pg_control and archive.info
// -------------------------------------------------------------------------------------------------------------------------
@ -175,7 +175,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test");
strLstAddZ(argList, "--repo2-path=" TEST_PATH "/repo2");
strLstAddZ(argList, "--repo4-path=" TEST_PATH "/repo4");
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
// repo2 has correct info
storagePutP(
@ -255,21 +255,21 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPgHost, "host");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/pg");
strLstAddZ(argList, "--" CFGOPT_STANZA "=test2");
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleMain, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleMain);
TEST_ERROR(cmdArchivePush(), HostInvalidError, "archive-push command must be run on the PostgreSQL host");
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "--stanza=test");
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
TEST_ERROR(cmdArchivePush(), ParamRequiredError, "WAL segment to push required");
// -------------------------------------------------------------------------------------------------------------------------
StringList *argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, "pg_wal/000000010000000100000001");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
TEST_ERROR(
cmdArchivePush(), OptionRequiredError,
@ -284,7 +284,7 @@ testRun(void)
argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, "pg_wal/000000010000000100000001");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
storagePutP(
storageNewWriteP(storageTest, STRDEF("pg/" PG_PATH_GLOBAL "/" PG_FILE_PGCONTROL)),
@ -332,7 +332,7 @@ testRun(void)
argListTemp = strLstDup(argList);
hrnCfgArgRawNegate(argListTemp, cfgOptArchiveHeaderCheck);
strLstAddZ(argListTemp, "pg_wal/000000010000000100000001");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
TEST_RESULT_VOID(cmdArchivePush(), "push the WAL segment");
TEST_RESULT_LOG("P00 INFO: pushed WAL file '000000010000000100000001' to the archive");
@ -349,7 +349,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, "pg_wal/000000010000000100000001");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
memset(bufPtr(walBuffer1), 0, bufSize(walBuffer1));
hrnPgWalToBuffer((PgWal){.version = PG_VERSION_11, .systemId = 0xFACEFACEFACEFACE}, walBuffer1);
@ -396,7 +396,7 @@ testRun(void)
strLstAddZ(argListTemp, "--" CFGOPT_STANZA "=test");
hrnCfgArgRawZ(argListTemp, cfgOptRepoPath, TEST_PATH "/repo");
strLstAddZ(argListTemp, TEST_PATH "/pg/pg_wal/000000010000000100000002");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
TEST_RESULT_VOID(
storagePutP(storageNewWriteP(storageTest, STRDEF("pg/pg_wal/000000010000000100000002")), walBuffer2), "write WAL");
@ -428,7 +428,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, "pg_wal/00000001.history");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
storagePutP(storageNewWriteP(storagePgWrite(), STRDEF("pg_wal/00000001.history")), BUFSTRDEF("FAKEHISTORY"));
@ -446,7 +446,7 @@ testRun(void)
argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, "--archive-push-queue-max=16m");
strLstAddZ(argListTemp, "pg_wal/000000010000000100000002");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
TEST_RESULT_VOID(cmdArchivePush(), "drop WAL file");
TEST_RESULT_LOG("P00 WARN: dropped WAL file '000000010000000100000002' because archive queue exceeded 16MB");
@ -454,7 +454,7 @@ testRun(void)
argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, "--archive-push-queue-max=1GB");
strLstAddZ(argListTemp, "pg_wal/000000010000000100000002");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
TEST_RESULT_VOID(cmdArchivePush(), "push WAL file again");
TEST_RESULT_LOG(
@ -507,7 +507,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argListTemp, cfgOptRepoPath, 3, TEST_PATH "/repo3");
hrnCfgArgRawNegate(argListTemp, cfgOptCompress);
strLstAddZ(argListTemp, "pg_wal/000000010000000100000002");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
hrnCfgEnvKeyRemoveRaw(cfgOptRepoCipherPass, 2);
TEST_RESULT_VOID(cmdArchivePush(), "push the WAL segment");
@ -642,7 +642,7 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_SPOOL_PATH "=/spool");
strLstAddZ(argList, "--" CFGOPT_STANZA "=test2");
strLstAddZ(argList, "--" CFGOPT_ARCHIVE_ASYNC);
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleAsync);
TEST_ERROR(cmdArchivePush(), HostInvalidError, "archive-push command must be run on the PostgreSQL host");
@ -654,24 +654,21 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_STANZA "=test2");
strLstAddZ(argList, "--" CFGOPT_ARCHIVE_ASYNC);
strLstAddZ(argList, "/000000010000000100000001");
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleAsync);
TEST_ERROR(cmdArchivePush(), OptionRequiredError, "'archive-push' command in async mode requires option 'pg1-path'");
// Call with a bogus exe name so the async process will error out and we can make sure timeouts work
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "pgbackrest-bogus");
strLstAddZ(argList, "--stanza=test");
strLstAddZ(argList, "--archive-async");
strLstAddZ(argList, "--archive-timeout=1");
strLstAddZ(argList, "--lock-path=" TEST_PATH "/lock");
strLstAddZ(argList, "--spool-path=" TEST_PATH " /spool");
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/pg");
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "archive-push");
strLstAddZ(argList, "pg_wal/bogus");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .exeBogus = true);
storagePathCreateP(storageTest, cfgOptionStr(cfgOptPgPath));
THROW_ON_SYS_ERROR(chdir(strZ(cfgOptionStr(cfgOptPgPath))) != 0, PathMissingError, "unable to chdir()");
@ -708,7 +705,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
StringList *argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, TEST_PATH "/pg/pg_xlog/000000010000000100000001");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
storagePathCreateP(storagePgWrite(), STRDEF("pg_xlog/archive_status"));
@ -725,7 +722,7 @@ testRun(void)
argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, TEST_PATH "/pg/pg_xlog/000000010000000100000001");
strLstAddZ(argListTemp, "--archive-timeout=1");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
THROW_ON_SYS_ERROR(chdir(strZ(cfgOptionStr(cfgOptPgPath))) != 0, PathMissingError, "unable to chdir()");
@ -776,7 +773,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, TEST_PATH "/pg/pg_xlog/000000010000000100000001");
harnessCfgLoad(cfgCmdArchivePush, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp);
storagePutP(storageNewWriteP(storagePgWrite(), STRDEF("pg_xlog/archive_status/000000010000000100000001.ready")), NULL);
@ -806,7 +803,7 @@ testRun(void)
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/pg");
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--log-subprocess");
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleAsync);
TEST_ERROR(cmdArchivePushAsync(), ParamRequiredError, "WAL path to push required");
@ -820,7 +817,7 @@ testRun(void)
storagePathCreateP(storagePgWrite(), STRDEF("pg_xlog/archive_status"));
strLstAddZ(argList, TEST_PATH "/pg/pg_xlog");
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleAsync);
TEST_ERROR(cmdArchivePushAsync(), AssertError, "no WAL files to process");
@ -837,7 +834,7 @@ testRun(void)
// Add repo3
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 3, TEST_PATH "/repo3");
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleAsync);
storagePutP(
storageNewWriteP(storageTest, STRDEF("repo3/archive/test/archive.info")),
@ -897,7 +894,7 @@ testRun(void)
argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, "--archive-push-queue-max=1gb");
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp, .role = cfgCmdRoleAsync);
TEST_RESULT_VOID(cmdArchivePushAsync(), "push WAL segments");
TEST_RESULT_LOG(
@ -972,7 +969,7 @@ testRun(void)
argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, "--archive-push-queue-max=16m");
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleAsync, argListTemp);
HRN_CFG_LOAD(cfgCmdArchivePush, argListTemp, .role = cfgCmdRoleAsync);
TEST_RESULT_VOID(cmdArchivePushAsync(), "push WAL segments");
TEST_RESULT_LOG(

64
test/src/module/command/backupTest.c
View File

@ -474,7 +474,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/pg");
strLstAddZ(argList, "--repo1-retention-full=1");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Create the pg path
storagePathCreateP(storagePgWrite(), NULL, .mode = 0700);
@ -748,7 +748,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "--repo1-cipher-type=aes-256-cbc");
setenv("PGBACKREST_REPO1_CIPHER_PASS", "12345678", true);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
unsetenv("PGBACKREST_REPO1_CIPHER_PASS");
// Create the pg path
@ -837,7 +837,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptRepoPath, repoPath);
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
time_t timestamp = 1575401652;
String *backupLabel = backupLabelFormat(backupTypeFull, NULL, timestamp);
@ -918,7 +918,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
strLstAddZ(argList, "--" CFGOPT_BACKUP_STANDBY);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_ERROR(
backupInit(infoBackupNew(PG_VERSION_91, 1000000000000000910, hrnPgCatalogVersion(PG_VERSION_91), NULL)), ConfigError,
@ -939,7 +939,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
strLstAddZ(argList, "--" CFGOPT_BACKUP_STANDBY);
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_RESULT_VOID(
backupInit(infoBackupNew(PG_VERSION_92, 1000000000000000920, hrnPgCatalogVersion(PG_VERSION_92), NULL)),
@ -963,7 +963,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_ERROR(
backupInit(infoBackupNew(PG_VERSION_11, 1000000000000001100, hrnPgCatalogVersion(PG_VERSION_11), NULL)),
@ -991,7 +991,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
strLstAddZ(argList, "--" CFGOPT_START_FAST);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_RESULT_VOID(
backupInit(infoBackupNew(PG_VERSION_83, 1000000000000000830, hrnPgCatalogVersion(PG_VERSION_83), NULL)),
@ -1015,7 +1015,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
strLstAddZ(argList, "--" CFGOPT_STOP_AUTO);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_RESULT_VOID(
backupInit(infoBackupNew(PG_VERSION_84, 1000000000000000840, hrnPgCatalogVersion(PG_VERSION_84), NULL)),
@ -1038,7 +1038,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
strLstAddZ(argList, "--" CFGOPT_CHECKSUM_PAGE);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
harnessPqScriptSet((HarnessPq [])
{
@ -1070,7 +1070,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
strLstAddZ(argList, "--no-" CFGOPT_CHECKSUM_PAGE);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
harnessPqScriptSet((HarnessPq [])
{
@ -1118,7 +1118,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptRepoPath, repoPath);
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Create pg_control
storagePutP(
@ -1165,7 +1165,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
hrnCfgArgRawStrId(argList, cfgOptType, backupTypeFull);
strLstAddZ(argList, "--no-" CFGOPT_COMPRESS);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("cannot resume when manifest and copy are missing");
@ -1367,7 +1367,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptRepoPath, repoPath);
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
cmdStanzaCreate();
TEST_RESULT_LOG("P00 INFO: stanza-create for stanza 'test1' on repo1");
@ -1381,7 +1381,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
storagePutP(storageNewWriteP(storagePgWrite(), PG_FILE_POSTMASTERPID_STR), BUFSTRDEF("PID"));
@ -1403,7 +1403,7 @@ testRun(void)
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
strLstAddZ(argList, "--no-" CFGOPT_COMPRESS);
strLstAddZ(argList, "--" CFGOPT_FORCE);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
storagePutP(storageNewWriteP(storagePgWrite(), STRDEF("postgresql.conf")), BUFSTRDEF("CONFIGSTUFF"));
@ -1437,7 +1437,7 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_COMPRESS);
hrnCfgArgRawBool(argList, cfgOptRepoHardlink, true);
hrnCfgArgRawStrId(argList, cfgOptType, backupTypeDiff);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_ERROR(cmdBackup(), FileMissingError, "no files have changed since the last backup - this seems unlikely");
@ -1458,7 +1458,7 @@ testRun(void)
strLstAddZ(argList, "--no-" CFGOPT_COMPRESS);
strLstAddZ(argList, "--" CFGOPT_CHECKSUM_PAGE);
hrnCfgArgRawStrId(argList, cfgOptType, backupTypeIncr);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
storagePutP(storageNewWriteP(storagePgWrite(), PG_FILE_PGVERSION_STR), BUFSTRDEF("VER"));
@ -1485,7 +1485,7 @@ testRun(void)
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
strLstAddZ(argList, "--no-" CFGOPT_COMPRESS);
hrnCfgArgRawStrId(argList, cfgOptType, backupTypeDiff);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
sleepMSec(MSEC_PER_SEC - (timeMSec() % MSEC_PER_SEC));
storagePutP(storageNewWriteP(storagePgWrite(), PG_FILE_PGVERSION_STR), BUFSTRDEF("VR2"));
@ -1511,7 +1511,7 @@ testRun(void)
hrnCfgEnvKeyRawZ(cfgOptRepoCipherPass, 2, TEST_CIPHER_PASS);
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
cmdStanzaCreate();
TEST_RESULT_LOG("P00 INFO: stanza-create for stanza 'test1' on repo2");
@ -1523,7 +1523,7 @@ testRun(void)
// With repo2 the only repo configured, ensure it is chosen by confirming diff is changed to full due to no prior backups
hrnCfgArgKeyRawZ(argList, cfgOptRepoRetentionFull, 2, "1");
hrnCfgArgRawStrId(argList, cfgOptType, backupTypeDiff);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_RESULT_VOID(cmdBackup(), "backup");
TEST_RESULT_LOG(
@ -1539,7 +1539,7 @@ testRun(void)
// Add repo1 to the configuration
hrnCfgArgKeyRaw(argList, cfgOptRepoPath, 1, repoPath);
hrnCfgArgKeyRawZ(argList, cfgOptRepoRetentionFull, 1, "1");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_RESULT_VOID(cmdBackup(), "backup");
TEST_RESULT_LOG(
@ -1555,7 +1555,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
storagePutP(storageNewWriteP(storagePgWrite(), PG_FILE_PGVERSION_STR), BUFSTRDEF("VER"));
@ -1619,7 +1619,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptRepoPath, repoPath);
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
cmdStanzaCreate();
TEST_RESULT_LOG("P00 INFO: stanza-create for stanza 'test1' on repo1");
@ -1634,7 +1634,7 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_STOP_AUTO);
strLstAddZ(argList, "--no-" CFGOPT_COMPRESS);
strLstAddZ(argList, "--no-" CFGOPT_ARCHIVE_CHECK);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Add files
storagePutP(
@ -1731,7 +1731,7 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_STOP_AUTO);
hrnCfgArgRawBool(argList, cfgOptRepoHardlink, true);
strLstAddZ(argList, "--" CFGOPT_ARCHIVE_COPY);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Create a backup manifest that looks like a halted backup manifest
Manifest *manifestResume = manifestNewBuild(
@ -1922,7 +1922,7 @@ testRun(void)
strLstAddZ(argList, "--no-" CFGOPT_COMPRESS);
strLstAddZ(argList, "--" CFGOPT_STOP_AUTO);
hrnCfgArgRawBool(argList, cfgOptRepoHardlink, true);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Load the previous manifest and null out the checksum-page option to be sure it gets set to false in this backup
const String *manifestPriorFile = STRDEF(STORAGE_REPO_BACKUP "/latest/" BACKUP_MANIFEST_FILE);
@ -2087,7 +2087,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptRepoPath, repoPath);
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
harnessCfgLoad(cfgCmdStanzaUpgrade, argList);
HRN_CFG_LOAD(cfgCmdStanzaUpgrade, argList);
cmdStanzaUpgrade();
TEST_RESULT_LOG("P00 INFO: stanza-upgrade for stanza 'test1' on repo1");
@ -2104,7 +2104,7 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_BACKUP_STANDBY);
strLstAddZ(argList, "--" CFGOPT_START_FAST);
strLstAddZ(argList, "--" CFGOPT_ARCHIVE_COPY);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Create file to copy from the standby. This file will be zero-length on the primary and non-zero-length on the standby
// but no bytes will be copied.
@ -2236,7 +2236,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptRepoPath, repoPath);
hrnCfgArgRaw(argList, cfgOptPgPath, pg1Path);
strLstAddZ(argList, "--no-" CFGOPT_ONLINE);
harnessCfgLoad(cfgCmdStanzaUpgrade, argList);
HRN_CFG_LOAD(cfgCmdStanzaUpgrade, argList);
cmdStanzaUpgrade();
TEST_RESULT_LOG("P00 INFO: stanza-upgrade for stanza 'test1' on repo1");
@ -2251,7 +2251,7 @@ testRun(void)
hrnCfgArgRawBool(argList, cfgOptRepoHardlink, true);
strLstAddZ(argList, "--" CFGOPT_MANIFEST_SAVE_THRESHOLD "=1");
strLstAddZ(argList, "--" CFGOPT_ARCHIVE_COPY);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Move pg1-path and put a link in its place. This tests that backup works when pg1-path is a symlink yet should be
// completely invisible in the manifest and logging.
@ -2441,7 +2441,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "1");
hrnCfgArgRawStrId(argList, cfgOptType, backupTypeIncr);
hrnCfgArgRawBool(argList, cfgOptRepoHardlink, true);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Run backup
testBackupPqScriptP(PG_VERSION_11, backupTimeStart, .errorAfterStart = true);
@ -2480,7 +2480,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptType, backupTypeIncr);
strLstAddZ(argList, "--" CFGOPT_DELTA);
hrnCfgArgRawBool(argList, cfgOptRepoHardlink, true);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Update pg_control timestamp
HRN_STORAGE_TIME(storagePg(), "global/pg_control", backupTimeStart);

28
test/src/module/command/checkTest.c
View File

@ -46,7 +46,7 @@ testRun(void)
strLstAdd(argList, pg1PathOpt);
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--archive-timeout=.5");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
// Set up harness to expect a failure to connect to the database
harnessPqScriptSet((HarnessPq [])
@ -83,7 +83,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--repo2-host=repo.domain.com");
strLstAddZ(argList, "--archive-timeout=.5");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
// Two standbys found but no primary
harnessPqScriptSet((HarnessPq [])
@ -106,7 +106,7 @@ testRun(void)
strLstAdd(argList, pg1PathOpt);
strLstAddZ(argList, "--repo1-host=repo.domain.com");
strLstAddZ(argList, "--archive-timeout=.5");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
harnessPqScriptSet((HarnessPq [])
{
@ -126,7 +126,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--archive-timeout=.5");
strLstAddZ(argList, "--backup-standby");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
// Primary database connection ok
harnessPqScriptSet((HarnessPq [])
@ -155,7 +155,7 @@ testRun(void)
strLstAddZ(argList, "--archive-timeout=.5");
strLstAdd(argList, pg8PathOpt);
strLstAddZ(argList, "--pg8-port=5433");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
// Standby database path doesn't match pg_control
harnessPqScriptSet((HarnessPq [])
@ -231,7 +231,7 @@ testRun(void)
// Multi-repo - add a second repo (repo2)
StringList *argListRepo2 = strLstDup(argList);
strLstAddZ(argListRepo2, "--repo2-path=" TEST_PATH "/repo2");
harnessCfgLoad(cfgCmdCheck, argListRepo2);
HRN_CFG_LOAD(cfgCmdCheck, argListRepo2);
harnessPqScriptSet((HarnessPq [])
{
@ -269,7 +269,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--repo2-path=" TEST_PATH "/repo2");
strLstAddZ(argList, "--archive-timeout=.5");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
// Create stanza files on repo2
storagePutP(storageNewWriteP(storageRepoIdxWrite(1), INFO_ARCHIVE_PATH_FILE_STR), archiveInfoContent);
@ -350,7 +350,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptPgHostCmd, 5, "pgbackrest-bogus");
strLstAddZ(argList, "--pg5-path=/path/to/pg5");
strLstAddZ(argList, "--pg5-host-user=" TEST_USER);
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
// Placeholder test for manifest
TEST_ERROR(
@ -382,7 +382,7 @@ testRun(void)
strLstAdd(argList, pg8PathOpt);
strLstAddZ(argList, "--pg8-port=5433");
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
DbGetResult db = {0};
@ -421,7 +421,7 @@ testRun(void)
// archive-check=false
// -------------------------------------------------------------------------------------------------------------------------
strLstAddZ(argList, "--no-archive-check");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
TEST_RESULT_VOID(checkDbConfig(PG_VERSION_92, db.primaryIdx, db.primary, false), "valid db config --no-archive-check");
@ -433,7 +433,7 @@ testRun(void)
strLstAdd(argList, pg8PathOpt);
strLstAddZ(argList, "--pg8-port=5433");
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
TEST_RESULT_VOID(
checkDbConfig(PG_VERSION_92, db.primaryIdx, db.primary, false), "valid db config, archive-check not valid for command");
@ -447,7 +447,7 @@ testRun(void)
strLstAdd(argList, stanzaOpt);
strLstAdd(argList, pg1PathOpt);
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
harnessPqScriptSet((HarnessPq [])
{
@ -465,7 +465,7 @@ testRun(void)
TEST_TITLE("disable archive_mode=always check");
strLstAddZ(argList, "--no-archive-mode-check");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
TEST_RESULT_VOID(checkDbConfig(PG_VERSION_92, db.primaryIdx, db.primary, false), "check");
TEST_RESULT_VOID(dbFree(db.primary), "free primary");
@ -539,7 +539,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--repo1-cipher-type=aes-256-cbc");
setenv("PGBACKREST_REPO1_CIPHER_PASS", "12345678", true);
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
// Create pg_control
storagePutP(

12
test/src/module/command/commandTest.c
View File

@ -26,14 +26,12 @@ testRun(void)
TEST_TITLE("single parameter");
StringList *argList = strLstNew();
strLstAddZ(argList, PROJECT_BIN);
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
hrnCfgArgRawZ(argList, cfgOptArchiveTimeout, "10");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/pg1");
strLstAddZ(argList, CFGCMD_ARCHIVE_GET);
strLstAddZ(argList, "param1");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .noStd = true);
TEST_RESULT_VOID(cmdBegin(), "command begin with command parameter");
TEST_RESULT_LOG(
@ -44,14 +42,12 @@ testRun(void)
TEST_TITLE("multiple parameters");
argList = strLstNew();
strLstAddZ(argList, PROJECT_BIN);
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgRawBool(argList, cfgOptArchiveAsync, true);
hrnCfgArgRawZ(argList, cfgOptPgPath, "/pg1");
strLstAddZ(argList, CFGCMD_ARCHIVE_GET);
strLstAddZ(argList, "param1");
strLstAddZ(argList, "param 2");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .noStd = true);
TEST_RESULT_VOID(cmdBegin(), "command begin with command parameters");
TEST_RESULT_LOG(
@ -62,7 +58,6 @@ testRun(void)
TEST_TITLE("reset, negate, list, hash options");
argList = strLstNew();
strLstAddZ(argList, PROJECT_BIN);
hrnCfgArgRawNegate(argList, cfgOptConfig);
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 1, "/pg1");
@ -74,9 +69,8 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptDbInclude, "db2");
hrnCfgArgRawZ(argList, cfgOptRecoveryOption, "standby_mode=on");
hrnCfgArgRawZ(argList, cfgOptRecoveryOption, "primary_conninfo=blah");
strLstAddZ(argList, CFGCMD_RESTORE);
hrnCfgEnvRawZ(cfgOptRepoCipherPass, "SECRET-STUFF");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdRestore, argList, .noStd = true);
TEST_RESULT_VOID(cmdBegin(), "command begin");

12
test/src/module/command/controlTest.c
View File

@ -25,7 +25,7 @@ testRun(void)
StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=db");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
TEST_RESULT_STR_Z(lockStopFileName(NULL), HRN_PATH "/lock/all" STOP_FILE_EXT, "stop file for all stanzas");
TEST_RESULT_STR_Z(lockStopFileName(STRDEF("db")), HRN_PATH "/lock/db" STOP_FILE_EXT, "stop file for on stanza");
@ -35,7 +35,7 @@ testRun(void)
if (testBegin("lockStopTest(), cmdStart()"))
{
StringList *argList = strLstNew();
harnessCfgLoad(cfgCmdStart, argList);
HRN_CFG_LOAD(cfgCmdStart, argList);
TEST_RESULT_VOID(lockStopTest(), "no stop files without stanza");
TEST_RESULT_VOID(cmdStart(), " cmdStart - no stanza, no stop files");
@ -48,7 +48,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "--stanza=db");
harnessCfgLoad(cfgCmdStart, argList);
HRN_CFG_LOAD(cfgCmdStart, argList);
TEST_RESULT_VOID(lockStopTest(), "no stop files with stanza");
TEST_RESULT_VOID(cmdStart(), " cmdStart - stanza, no stop files");
@ -70,7 +70,7 @@ testRun(void)
{
const String *lockPath = STRDEF(HRN_PATH "/lock");
StringList *argList = strLstNew();
harnessCfgLoad(cfgCmdStop, argList);
HRN_CFG_LOAD(cfgCmdStop, argList);
TEST_RESULT_VOID(cmdStop(), "no stanza, create stop file");
StorageInfo info = {0};
@ -97,7 +97,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
String *stanzaStopFile = strNewFmt("%s/db" STOP_FILE_EXT, strZ(lockPath));
strLstAddZ(argList, "--stanza=db");
harnessCfgLoad(cfgCmdStop, argList);
HRN_CFG_LOAD(cfgCmdStop, argList);
TEST_RESULT_VOID(cmdStop(), "stanza, create stop file");
TEST_RESULT_BOOL(storageExistsP(hrnStorage, stanzaStopFile), true, " stanza stop file created");
@ -114,7 +114,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
strLstAddZ(argList, "--force");
harnessCfgLoad(cfgCmdStop, argList);
HRN_CFG_LOAD(cfgCmdStop, argList);
TEST_RESULT_VOID(cmdStop(), "stanza, create stop file, force");
TEST_RESULT_VOID(storageRemoveP(hrnStorage, stanzaStopFile), " remove stop file");

110
test/src/module/command/expireTest.c
View File

@ -176,7 +176,7 @@ testRun(void)
// Load Parameters
StringList *argList = strLstDup(argListAvoidWarn);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(
storagePutP(
@ -218,7 +218,7 @@ testRun(void)
// Load Parameters
StringList *argList = strLstDup(argListBase);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_UINT(expireFullBackup(infoBackup, 0), 0, "retention-full not set");
TEST_RESULT_LOG(
@ -231,7 +231,7 @@ testRun(void)
TEST_TITLE("retention-full set - full backup no dependencies expired");
strLstAddZ(argList, "--repo1-retention-full=2");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_UINT(expireFullBackup(infoBackup, 0), 1, "retention-full=2 - one full backup expired");
TEST_RESULT_UINT(infoBackupDataTotal(infoBackup), 5, "current backups reduced by 1 full - no dependencies");
@ -247,7 +247,7 @@ testRun(void)
argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=1");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_UINT(expireFullBackup(infoBackup, 0), 3, "retention-full=1 - one full backup and dependencies expired");
TEST_RESULT_UINT(infoBackupDataTotal(infoBackup), 2, "current backups reduced by 1 full and dependencies");
@ -279,7 +279,7 @@ testRun(void)
// Load Parameters
StringList *argList = strLstDup(argListAvoidWarn);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_UINT(expireDiffBackup(infoBackup, 0), 0, "retention-diff not set - nothing expired");
TEST_RESULT_UINT(infoBackupDataTotal(infoBackup), 6, "current backups not expired");
@ -290,7 +290,7 @@ testRun(void)
// Add retention-diff
StringList *argListTemp = strLstDup(argList);
strLstAddZ(argListTemp, "--repo1-retention-diff=6");
harnessCfgLoad(cfgCmdExpire, argListTemp);
HRN_CFG_LOAD(cfgCmdExpire, argListTemp);
TEST_RESULT_UINT(expireDiffBackup(infoBackup, 0), 0, "retention-diff set - too soon to expire");
TEST_RESULT_UINT(infoBackupDataTotal(infoBackup), 6, "current backups not expired");
@ -299,7 +299,7 @@ testRun(void)
TEST_TITLE("retention-diff set - diff and dependent incr expired");
strLstAddZ(argList, "--repo1-retention-diff=2");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_UINT(expireDiffBackup(infoBackup, 0), 2, "retention-diff=2 - full considered in diff");
TEST_RESULT_UINT(infoBackupDataTotal(infoBackup), 4, "current backups reduced by 1 diff and dependent increment");
@ -316,7 +316,7 @@ testRun(void)
//--------------------------------------------------------------------------------------------------------------------------
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--repo1-retention-diff=1");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_ASSIGN(infoBackup, infoBackupNewLoad(ioBufferReadNew(backupInfoBase)), "get backup.info");
TEST_RESULT_UINT(expireDiffBackup(infoBackup, 0), 2, "retention-diff set to 1 - full considered in diff");
@ -376,7 +376,7 @@ testRun(void)
// Load parameters
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--repo1-retention-diff=1");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_UINT(expireDiffBackup(infoBackup, 0), 1, "retention-diff set - only oldest diff expired");
TEST_RESULT_UINT(infoBackupDataTotal(infoBackup), 2, "current backups reduced by one");
@ -442,7 +442,7 @@ testRun(void)
// Load Parameters
StringList *argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=1");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(removeExpiredBackup(infoBackup, NULL, 0), "remove backups not in backup.info current");
@ -493,7 +493,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=db");
strLstAddZ(argList, "--repo1-retention-full=1"); // avoid warning
strLstAddZ(argList, "--repo1-host=/repo/not/local");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_ERROR(cmdExpire(), HostInvalidError, "expire command must be run on the repository host");
@ -501,7 +501,7 @@ testRun(void)
TEST_TITLE("check stop file");
argList = strLstDup(argListAvoidWarn);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Create the stop file
TEST_RESULT_VOID(
@ -517,7 +517,7 @@ testRun(void)
// Load Parameters
argList = strLstDup(argListBase);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Create backup.info without current backups
const Buffer *backupInfoContent = harnessInfoChecksumZ
@ -553,7 +553,7 @@ testRun(void)
// Set archive retention, archive retention type default but no current backups - code path test
strLstAddZ(argList, "--repo1-retention-archive=4");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(
removeExpiredArchive(infoBackup, false, 0), "archive retention set, retention type default, no current backups");
@ -666,7 +666,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--repo1-retention-archive=3");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(
removeExpiredArchive(infoBackup, false, 0), "archive retention type = full (default), repo1-retention-archive=3");
@ -694,7 +694,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--repo1-retention-archive=2");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(
removeExpiredArchive(infoBackup, false, 0), "archive retention type = full (default), repo1-retention-archive=2");
@ -724,7 +724,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--repo1-retention-archive=1");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(
removeExpiredArchive(infoBackup, false, 0), "archive retention type = full (default), repo1-retention-archive=1");
@ -754,7 +754,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-archive=2");
strLstAddZ(argList, "--repo1-retention-archive-type=diff");
strLstAddZ(argList, "--repo1-retention-diff=2");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(
removeExpiredArchive(infoBackup, false, 0),
@ -792,7 +792,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--repo1-retention-archive=4");
strLstAddZ(argList, "--repo1-retention-archive-type=incr");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Regenerate archive
archiveGenerate(storageTest, archiveStanzaPath, 1, 10, "9.4-1", "0000000200000000");
@ -834,7 +834,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-archive=2");
strLstAddZ(argList, "--repo1-retention-archive-type=diff");
strLstAddZ(argList, "--dry-run");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Write backup.manifest so infoBackup reconstruct produces same results as backup.info on disk
storagePutP(
@ -895,7 +895,7 @@ testRun(void)
StringList *argList2 = strLstDup(argList);
hrnCfgArgRawZ(argList2, cfgOptRepo, "2");
strLstAddZ(argList2, "--pg1-path=" TEST_PATH "/pg");
harnessCfgLoad(cfgCmdBackup, argList2);
HRN_CFG_LOAD(cfgCmdBackup, argList2);
TEST_RESULT_VOID(cmdExpire(), "via backup command: expire last backup in archive sub path and remove sub path");
TEST_RESULT_BOOL(
@ -925,7 +925,7 @@ testRun(void)
// Add to previous list and specify repo
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "expire last backup in archive sub path and remove sub path");
TEST_RESULT_BOOL(
@ -951,7 +951,7 @@ testRun(void)
argList2 = strLstDup(argList);
strLstAddZ(argList2, "--dry-run");
harnessCfgLoad(cfgCmdExpire, argList2);
HRN_CFG_LOAD(cfgCmdExpire, argList2);
harnessLogLevelSet(logLevelDetail);
@ -1090,7 +1090,7 @@ testRun(void)
TEST_TITLE("expire command - multi-repo, archive and backups removed");
// Rerun previous test without dry-run
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "expire backups and remove archive path");
TEST_RESULT_BOOL(
@ -1134,7 +1134,7 @@ testRun(void)
// With multi-repo config from previous test, adhoc expire on backup that doesn't exist
argList2 = strLstDup(argList);
hrnCfgArgRawZ(argList2, cfgOptSet, "20201119-123456F_20201119-234567I");
harnessCfgLoad(cfgCmdExpire, argList2);
HRN_CFG_LOAD(cfgCmdExpire, argList2);
TEST_RESULT_VOID(cmdExpire(), "label format OK but backup does not exist on any repo");
TEST_RESULT_LOG(
@ -1146,7 +1146,7 @@ testRun(void)
// Rerun on single repo
hrnCfgArgRawZ(argList2, cfgOptRepo, "1");
harnessCfgLoad(cfgCmdExpire, argList2);
HRN_CFG_LOAD(cfgCmdExpire, argList2);
TEST_RESULT_VOID(cmdExpire(), "label format OK but backup does not exist on requested repo");
TEST_RESULT_LOG(
@ -1158,7 +1158,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptSet, "20181119-152900F_20181119-152500I");
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
hrnCfgArgRawBool(argList, cfgOptDryRun, true);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Incremental removed but no archives expired because the only remaining full backups must be able to play through PITR
TEST_RESULT_VOID(cmdExpire(), "label format OK and expired on specified repo");
@ -1175,7 +1175,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--set=" BOGUS_STR);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_ERROR(cmdExpire(), OptionInvalidValueError, "'" BOGUS_STR "' is not a valid backup label format");
//--------------------------------------------------------------------------------------------------------------------------
@ -1185,7 +1185,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--repo1-retention-archive=1");
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/pg");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_RESULT_VOID(cmdExpire(), "expire remove archive path");
TEST_RESULT_LOG_FMT(
@ -1243,7 +1243,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--repo1-retention-archive=2");
strLstAddZ(argList, "--repo1-retention-archive-type=full");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(
removeExpiredArchive(infoBackup, false, 0), "backup selected for retention does not have archive-start so do nothing");
@ -1258,7 +1258,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--repo1-retention-archive=1");
strLstAddZ(argList, "--repo1-retention-archive-type=full");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
harnessLogLevelSet(logLevelDetail);
TEST_RESULT_VOID(
@ -1277,7 +1277,7 @@ testRun(void)
argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=2");
strLstAddZ(argList, "--dry-run");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Create backup.info and archives spread over different timelines
storagePutP(storageNewWriteP(storageTest, backupInfoFileName),
@ -1366,7 +1366,7 @@ testRun(void)
// Load Parameters
argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=2");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "expire remove 00000002.history file");
TEST_RESULT_BOOL(
@ -1390,7 +1390,7 @@ testRun(void)
argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=2");
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/pg");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
storagePutP(
storageNewWriteP(storageTest, strNewFmt("%s/10-2/00000002.history", strZ(archiveStanzaPath))), BUFSTRDEF("tmp"));
@ -1442,7 +1442,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "2");
hrnCfgArgRawFmt(argList, cfgOptRepoRetentionHistory, "%u", historyRetentionDays);
hrnCfgArgRawBool(argList, cfgOptDryRun, true);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "expire");
@ -1477,7 +1477,7 @@ testRun(void)
argList = strLstDup(argListBase);
hrnCfgArgRawZ(argList, cfgOptRepoRetentionFull, "2");
hrnCfgArgRawFmt(argList, cfgOptRepoRetentionHistory, "%u", historyRetentionDays);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
HRN_STORAGE_PUT_Z(storageRepoWrite(), STORAGE_REPO_BACKUP "/backup.history/2019/20191119-152138F.manifest.gz", "tmp");
@ -1512,7 +1512,7 @@ testRun(void)
HRN_STORAGE_PUT_Z(storageRepoWrite(), STORAGE_REPO_BACKUP "/backup.history/2017/20171119-152138F.manifest.gz", "tmp");
hrnCfgArgRawZ(argList, cfgOptPgPath, TEST_PATH_PG);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_RESULT_VOID(cmdExpire(), "expire");
@ -1544,7 +1544,7 @@ testRun(void)
// Load Parameters
StringList *argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=2");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
storagePutP(storageNewWriteP(storageTest, backupInfoFileName),
harnessInfoChecksumZ(
@ -1739,7 +1739,7 @@ testRun(void)
argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=1");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Here, although backup 20181119-152138F of 10-1 will be expired, the WAL in 10-1 will not since the archive.info
// does not know about that dir. Again, not really realistic since if it is on disk and reconstructed it would have. So
@ -1949,7 +1949,7 @@ testRun(void)
StringList *argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "--set=20181119-152800F_20181119-152152D");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Set the log level to detail so archive expiration messages are seen
harnessLogLevelSet(logLevelDetail);
@ -1994,7 +1994,7 @@ testRun(void)
argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "--set=20181119-152138F");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "adhoc expire full backup");
TEST_RESULT_BOOL(
@ -2026,7 +2026,7 @@ testRun(void)
argList = strLstDup(argListBase);
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "--set=20181119-152900F");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
String *archiveRemaining = strNew();
strCatFmt(
@ -2069,7 +2069,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--set=20181119-152850F");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_ERROR(
cmdExpire(), CommandError, CFGCMD_EXPIRE " command encountered 1 error(s), check the log file for details");
@ -2082,7 +2082,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--set=20181119-152800F");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "adhoc expire last prior db-id backup");
TEST_RESULT_BOOL(
@ -2105,7 +2105,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--set=20181119-152850F");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_ERROR(
cmdExpire(), CommandError, CFGCMD_EXPIRE " command encountered 1 error(s), check the log file for details");
@ -2153,7 +2153,7 @@ testRun(void)
argList = strLstDup(argListAvoidWarn);
strLstAddZ(argList, "--set=20181119-152850F_20181119-152252D");
strLstAddZ(argList, "--dry-run");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Load the backup info. Do not store a manifest file for the adhoc backup for code coverage
TEST_ASSIGN(infoBackup, infoBackupLoadFile(storageTest, backupInfoFileName, cipherTypeNone, NULL), "get backup.info");
@ -2186,7 +2186,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoRetentionFull, 2, "1");
hrnCfgArgKeyRawStrId(argList, cfgOptRepoCipherType, 2, cipherTypeAes256Cbc);
hrnCfgEnvKeyRawZ(cfgOptRepoCipherPass, 2, TEST_CIPHER_PASS);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Create backup.info
#define TEST_BACKUP_CURRENT \
@ -2440,7 +2440,7 @@ testRun(void)
TEST_TITLE("oldest backup not expired");
StringList *argList = strLstDup(argListTime);
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_ASSIGN(infoBackup, infoBackupNewLoad(ioBufferReadNew(backupInfoBase)), "get backup.info");
TEST_RESULT_VOID(cmdExpire(), "repo-retention-full not set for time-based");
@ -2462,7 +2462,7 @@ testRun(void)
// Add a time period
strLstAddZ(argList, "--repo1-retention-full=35");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "oldest backup older but other backups too young");
TEST_RESULT_STRLST_STR(
@ -2482,7 +2482,7 @@ testRun(void)
argList = strLstDup(argListTime);
strLstAddZ(argList, "--repo1-retention-full=30");
strLstAddZ(argList, "--dry-run");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "only oldest backup expired - dry-run");
TEST_RESULT_LOG(
"P00 INFO: [DRY-RUN] repo1: expire time-based backup 20181119-152138F\n"
@ -2491,7 +2491,7 @@ testRun(void)
"P00 INFO: [DRY-RUN] repo1: 9.4-1 remove archive, start = 000000010000000000000001, stop = 000000010000000000000003");
strLstAddZ(argList, "--repo1-retention-archive=9999999");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "only oldest backup expired - dry-run, retention-archive set to max, no archives expired");
TEST_RESULT_LOG(
"P00 INFO: [DRY-RUN] repo1: expire time-based backup 20181119-152138F\n"
@ -2501,7 +2501,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-full=30");
strLstAddZ(argList, "--repo1-retention-archive=1"); // 1-day: expire all non-essential archive prior to newest full backup
strLstAddZ(argList, "--dry-run");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "only oldest backup expired but retention archive set lower - dry-run");
TEST_RESULT_LOG(
"P00 INFO: [DRY-RUN] repo1: expire time-based backup 20181119-152138F\n"
@ -2525,7 +2525,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-archive-type=diff");
strLstAddZ(argList, "--repo1-retention-archive=1"); // 1-diff: expire all non-essential archive prior to newest diff backup
strLstAddZ(argList, "--dry-run");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "only oldest backup expired, retention archive is DIFF - dry-run");
TEST_RESULT_LOG(
@ -2554,7 +2554,7 @@ testRun(void)
argList = strLstDup(argListTime);
strLstAddZ(argList, "--repo1-retention-full=25");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
// Expire oldest from backup.info only, leaving the backup and archives on disk then save backup.info without oldest backup
TEST_RESULT_UINT(expireTimeBasedBackup(infoBackup, (time_t)(timeNow - (25 * SEC_PER_DAY)), 0), 1, "expire oldest backup");
@ -2573,7 +2573,7 @@ testRun(void)
argList = strLstDup(argListTime);
strLstAddZ(argList, "--repo1-retention-full=1");
harnessCfgLoad(cfgCmdExpire, argList);
HRN_CFG_LOAD(cfgCmdExpire, argList);
TEST_RESULT_VOID(cmdExpire(), "expire all but newest");
TEST_RESULT_LOG(

62
test/src/module/command/helpTest.c
View File

@ -1,13 +1,33 @@
/***********************************************************************************************************************************
Test Help Command
***********************************************************************************************************************************/
#include "config/load.h"
#include "config/parse.h"
#include "storage/helper.h"
#include "storage/posix/storage.h"
#include "storage/storage.h"
#include "version.h"
#include "common/harnessConfig.h"
/***********************************************************************************************************************************
Configuration load with just enough funcionality to test help
***********************************************************************************************************************************/
static void
testCfgLoad(const StringList *const argList)
{
FUNCTION_HARNESS_BEGIN();
FUNCTION_HARNESS_PARAM(STRING_LIST, argList);
FUNCTION_HARNESS_END();
// Parse config
configParse(storageLocal(), strLstSize(argList), strLstPtr(argList), false);
// Apply special option rules
cfgLoadUpdateOption();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
Test Run
***********************************************************************************************************************************/
@ -111,13 +131,13 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "/path/to/pgbackrest");
TEST_RESULT_VOID(harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help from empty command line");
TEST_RESULT_VOID(testCfgLoad(argList), "help from empty command line");
TEST_RESULT_STR_Z(helpRender(), generalHelp, " check text");
argList = strLstNew();
strLstAddZ(argList, "/path/to/pgbackrest");
strLstAddZ(argList, "help");
TEST_RESULT_VOID(harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help from help command");
TEST_RESULT_VOID(testCfgLoad(argList), "help from help command");
TEST_RESULT_STR_Z(helpRender(), generalHelp, " check text");
// -------------------------------------------------------------------------------------------------------------------------
@ -134,7 +154,7 @@ testRun(void)
strLstAddZ(argList, "/path/to/pgbackrest");
strLstAddZ(argList, "help");
strLstAddZ(argList, "version");
TEST_RESULT_VOID(harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for version command");
TEST_RESULT_VOID(testCfgLoad(argList), "help for version command");
TEST_RESULT_STR_Z(helpRender(), commandHelp, " check text");
// This test is broken up into multiple strings because C99 does not require compilers to support const strings > 4095 bytes
@ -291,7 +311,7 @@ testRun(void)
strLstAddZ(argList, "--link-map=/link2=/dest2");
strLstAddZ(argList, "--db-include=db1");
strLstAddZ(argList, "--db-include=db2");
TEST_RESULT_VOID(harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for restore command");
TEST_RESULT_VOID(testCfgLoad(argList), "help for restore command");
unsetenv("PGBACKREST_REPO1_CIPHER_PASS");
TEST_RESULT_STR_Z(helpRender(), commandHelp, " check text");
@ -302,7 +322,7 @@ testRun(void)
strLstAddZ(argList, "archive-push");
strLstAddZ(argList, "buffer-size");
strLstAddZ(argList, "buffer-size");
TEST_RESULT_VOID(harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "parse too many options");
TEST_RESULT_VOID(testCfgLoad(argList), "parse too many options");
TEST_ERROR(helpRender(), ParamInvalidError, "only one option allowed for option help");
argList = strLstNew();
@ -310,7 +330,7 @@ testRun(void)
strLstAddZ(argList, "help");
strLstAddZ(argList, "archive-push");
strLstAddZ(argList, BOGUS_STR);
TEST_RESULT_VOID(harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "parse bogus option");
TEST_RESULT_VOID(testCfgLoad(argList), "parse bogus option");
TEST_ERROR(helpRender(), OptionInvalidError, "option 'BOGUS' is not valid for command 'archive-push'");
argList = strLstNew();
@ -318,7 +338,7 @@ testRun(void)
strLstAddZ(argList, CFGCMD_HELP);
strLstAddZ(argList, CFGCMD_ARCHIVE_PUSH);
strLstAddZ(argList, CFGOPT_PROCESS);
TEST_RESULT_VOID(harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "parse option invalid for command");
TEST_RESULT_VOID(testCfgLoad(argList), "parse option invalid for command");
TEST_ERROR(helpRender(), OptionInvalidError, "option 'process' is not valid for command 'archive-push'");
// -------------------------------------------------------------------------------------------------------------------------
@ -344,13 +364,11 @@ testRun(void)
strLstAddZ(argList, "help");
strLstAddZ(argList, "archive-push");
strLstAddZ(argList, "buffer-size");
TEST_RESULT_VOID(
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for archive-push command, buffer-size option");
TEST_RESULT_VOID(testCfgLoad(argList), "help for archive-push command, buffer-size option");
TEST_RESULT_STR(helpRender(), strNewFmt("%s\ndefault: 1048576\n", optionHelp), " check text");
strLstAddZ(argList, "--buffer-size=32768");
TEST_RESULT_VOID(
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for archive-push command, buffer-size option");
TEST_RESULT_VOID(testCfgLoad(argList), "help for archive-push command, buffer-size option");
TEST_RESULT_STR(helpRender(), strNewFmt("%s\ncurrent: 32768\ndefault: 1048576\n", optionHelp), " check text");
// -------------------------------------------------------------------------------------------------------------------------
@ -376,8 +394,7 @@ testRun(void)
strLstAddZ(argList, "help");
strLstAddZ(argList, "archive-push");
strLstAddZ(argList, "repo1-s3-host");
TEST_RESULT_VOID(
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for archive-push command, repo1-s3-host option");
TEST_RESULT_VOID(testCfgLoad(argList), "help for archive-push command, repo1-s3-host option");
TEST_RESULT_STR_Z(helpRender(), optionHelp, " check text");
optionHelp = strZ(strNewFmt(
@ -389,8 +406,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-type=s3");
strLstAddZ(argList, "--repo1-s3-host=s3-host");
TEST_RESULT_VOID(
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for archive-push command, repo1-s3-host option");
TEST_RESULT_VOID(testCfgLoad(argList), "help for archive-push command, repo1-s3-host option");
TEST_RESULT_STR_Z(helpRender(), optionHelp, " check text");
// -------------------------------------------------------------------------------------------------------------------------
@ -411,8 +427,7 @@ testRun(void)
setenv("PGBACKREST_REPO1_CIPHER_PASS", "supersecret", true);
strLstAddZ(argList, "archive-push");
strLstAddZ(argList, "repo-cipher-pass");
TEST_RESULT_VOID(
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for archive-push command, repo1-s3-host option");
TEST_RESULT_VOID(testCfgLoad(argList), "help for archive-push command, repo1-s3-host option");
unsetenv("PGBACKREST_REPO1_CIPHER_PASS");
TEST_RESULT_STR_Z(helpRender(), optionHelp, " check text");
@ -437,8 +452,7 @@ testRun(void)
strLstAddZ(argList, "help");
strLstAddZ(argList, "backup");
strLstAddZ(argList, "repo-hardlink");
TEST_RESULT_VOID(
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for backup command, repo-hardlink option");
TEST_RESULT_VOID(testCfgLoad(argList), "help for backup command, repo-hardlink option");
TEST_RESULT_STR_Z(helpRender(), optionHelp, " check text");
argList = strLstNew();
@ -446,8 +460,7 @@ testRun(void)
strLstAddZ(argList, "help");
strLstAddZ(argList, "backup");
strLstAddZ(argList, "hardlink");
TEST_RESULT_VOID(
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for backup command, deprecated hardlink option");
TEST_RESULT_VOID(testCfgLoad(argList), "help for backup command, deprecated hardlink option");
TEST_RESULT_STR_Z(helpRender(), optionHelp, " check text");
// Check admonition
@ -482,8 +495,7 @@ testRun(void)
strLstAddZ(argList, "help");
strLstAddZ(argList, "backup");
strLstAddZ(argList, "repo-retention-archive");
TEST_RESULT_VOID(
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "help for backup command, repo-retention-archive option");
TEST_RESULT_VOID(testCfgLoad(argList), "help for backup command, repo-retention-archive option");
TEST_RESULT_STR_Z(helpRender(), optionHelp, " check admonition text");
}
@ -492,7 +504,7 @@ testRun(void)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "/path/to/pgbackrest");
TEST_RESULT_VOID(harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList)), "parse help from empty command line");
TEST_RESULT_VOID(testCfgLoad(argList), "parse help from empty command line");
// Redirect stdout to a file
int stdoutSave = dup(STDOUT_FILENO);

74
test/src/module/command/infoTest.c
View File

@ -36,20 +36,20 @@ testRun(void)
StringList *argListText = strLstDup(argList);
strLstAddZ(argList, "--output=json");
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
// No stanzas have been created
//--------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_STR_Z(infoRender(), "[]", "json - repo but no stanzas");
harnessCfgLoad(cfgCmdInfo, argListText);
HRN_CFG_LOAD(cfgCmdInfo, argListText);
TEST_RESULT_STR_Z(infoRender(), "No stanzas exist in the repository.\n", "text - no stanzas");
// Repo is still empty but stanza option is specified
//--------------------------------------------------------------------------------------------------------------------------
StringList *argListStanzaOpt = strLstDup(argList);
strLstAddZ(argListStanzaOpt, "--stanza=stanza1");
harnessCfgLoad(cfgCmdInfo, argListStanzaOpt);
HRN_CFG_LOAD(cfgCmdInfo, argListStanzaOpt);
TEST_RESULT_STR_Z(
infoRender(),
"["
@ -80,7 +80,7 @@ testRun(void)
StringList *argListTextStanzaOpt = strLstDup(argListText);
strLstAddZ(argListTextStanzaOpt, "--stanza=stanza1");
harnessCfgLoad(cfgCmdInfo, argListTextStanzaOpt);
HRN_CFG_LOAD(cfgCmdInfo, argListTextStanzaOpt);
TEST_RESULT_STR_Z(
infoRender(),
"stanza: stanza1\n"
@ -101,7 +101,7 @@ testRun(void)
" cipher: none\n",
"text - missing stanza data");
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_RESULT_STR_Z(
infoRender(),
"["
@ -190,7 +190,7 @@ testRun(void)
"]", strZ(archiveStanza1Path), strZ(archiveStanza1Path), strZ(archiveStanza1Path), strZ(archiveStanza1Path)),
"json - other error, single repo");
harnessCfgLoad(cfgCmdInfo, argListTextStanzaOpt);
HRN_CFG_LOAD(cfgCmdInfo, argListTextStanzaOpt);
TEST_RESULT_STR(
infoRender(), strNewFmt(
"stanza: stanza1\n"
@ -251,7 +251,7 @@ testRun(void)
{
sleepMSec(250);
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_RESULT_STR_Z(
infoRender(),
"["
@ -303,7 +303,7 @@ testRun(void)
"]",
"json - single stanza, no valid backups, backup/expire lock detected");
harnessCfgLoad(cfgCmdInfo, argListText);
HRN_CFG_LOAD(cfgCmdInfo, argListText);
TEST_RESULT_STR_Z(
infoRender(),
"stanza: stanza1\n"
@ -332,7 +332,7 @@ testRun(void)
strLstAddZ(argList2, "--stanza=stanza1");
hrnCfgArgKeyRawZ(argList2, cfgOptRepoPath, 2, TEST_PATH "/repo2");
hrnCfgArgRawZ(argList2, cfgOptRepo, "1");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
@ -351,7 +351,7 @@ testRun(void)
strLstAddZ(argList2, "--stanza=stanza1");
hrnCfgArgKeyRawZ(argList2, cfgOptRepoPath, 2, TEST_PATH "/repo2");
hrnCfgArgRawZ(argList2, cfgOptRepo, "2");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
@ -388,7 +388,7 @@ testRun(void)
"touch %s",
strZ(strNewFmt("%s/000000010000000000000001-ac61b8f1ec7b1e6c3eaee9345214595eb7daa9a1.gz", strZ(archiveDb2_1))));
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
content = STRDEF
(
"[db]\n"
@ -447,7 +447,7 @@ testRun(void)
{
sleepMSec(250);
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_RESULT_STR_Z(
infoRender(),
"["
@ -584,7 +584,7 @@ testRun(void)
"]",
"json - single stanza, valid backup, no priors, no archives in latest DB, backup/expire lock detected");
harnessCfgLoad(cfgCmdInfo, argListText);
HRN_CFG_LOAD(cfgCmdInfo, argListText);
TEST_RESULT_STR_Z(
infoRender(),
"stanza: stanza1\n"
@ -1101,7 +1101,7 @@ testRun(void)
{
sleepMSec(250);
harnessCfgLoad(cfgCmdInfo, argListMultiRepoJson);
HRN_CFG_LOAD(cfgCmdInfo, argListMultiRepoJson);
TEST_RESULT_STR_Z(
infoRender(),
"["
@ -1519,7 +1519,7 @@ testRun(void)
{
sleepMSec(250);
harnessCfgLoad(cfgCmdInfo, argListMultiRepo);
HRN_CFG_LOAD(cfgCmdInfo, argListMultiRepo);
TEST_RESULT_STR_Z(
infoRender(),
"stanza: stanza1\n"
@ -1611,7 +1611,7 @@ testRun(void)
argList2 = strLstDup(argListMultiRepo);
strLstAddZ(argList2, "--stanza=stanza1");
strLstAddZ(argList2, "--set=bogus");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
@ -1628,7 +1628,7 @@ testRun(void)
strLstAddZ(argList2, "--stanza=stanza1");
strLstAddZ(argList2, "--set=20181119-152138F_20181119-152155I");
strLstAddZ(argList2, "--repo=1");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
@ -1660,7 +1660,7 @@ testRun(void)
argList2 = strLstDup(argListMultiRepo);
strLstAddZ(argList2, "--stanza=stanza1");
strLstAddZ(argList2, "--set=20201116-200000F");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
@ -1690,7 +1690,7 @@ testRun(void)
//--------------------------------------------------------------------------------------------------------------------------
strLstAddZ(argList2, "--output=json");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_ERROR(strZ(infoRender()), ConfigError, "option 'set' is currently only valid for text output");
@ -1700,7 +1700,7 @@ testRun(void)
strLstAddZ(argList2, "--stanza=stanza1");
strLstAddZ(argList2, "--set=20181119-152138F_20181119-152155I");
strLstAddZ(argList2, "--repo=1");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
#define TEST_MANIFEST_TARGET_NO_LINK \
"\n" \
@ -1769,7 +1769,7 @@ testRun(void)
strLstAddZ(argList2, "--stanza=stanza1");
strLstAddZ(argList2, "--set=20181119-152138F_20181119-152155I");
strLstAddZ(argList2, "--repo=1");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
#define TEST_MANIFEST_NO_DB \
"\n" \
@ -1836,7 +1836,7 @@ testRun(void)
//--------------------------------------------------------------------------------------------------------------------------
argList2 = strLstDup(argList);
strLstAddZ(argList2, "--stanza=stanza2");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
"["
@ -1892,7 +1892,7 @@ testRun(void)
argList2 = strLstDup(argListText);
strLstAddZ(argList2, "--stanza=stanza2");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
"stanza: stanza2\n"
@ -1934,7 +1934,7 @@ testRun(void)
argList2 = strLstDup(argListMultiRepo);
hrnCfgArgRawZ(argList2, cfgOptStanza, "stanza1");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
"stanza: stanza1\n"
@ -2048,7 +2048,7 @@ testRun(void)
argList2 = strLstDup(argListMultiRepo);
hrnCfgArgRawZ(argList2, cfgOptStanza, "stanza4");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
@ -2131,7 +2131,7 @@ testRun(void)
argList2 = strLstDup(argListMultiRepo);
hrnCfgArgRawZ(argList2, cfgOptStanza, "stanza3");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
@ -2169,7 +2169,7 @@ testRun(void)
"text - multi-repo, database mismatch, repo2 stanza-upgrade needed");
hrnCfgArgRawZ(argList2, cfgOptOutput, "json");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR_Z(
infoRender(),
@ -2363,7 +2363,7 @@ testRun(void)
argList2 = strLstDup(argListMultiRepo);
strLstAddZ(argList2, "--repo-cipher-type=aes-256-cbc");
strLstAddZ(argList2, "--config=" TEST_PATH "/pgbackrest.conf");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR(
infoRender(), strNewFmt(
@ -2430,7 +2430,7 @@ testRun(void)
hrnCfgArgRawZ(argList2, cfgOptStanza, "stanza3");
hrnCfgArgRawZ(argList2, cfgOptSet, "20201110-100000F");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR(
infoRender(), strNewFmt(
@ -2460,7 +2460,7 @@ testRun(void)
argList2 = strLstDup(argListMultiRepo);
hrnCfgArgRawZ(argList2, cfgOptStanza, "stanza1");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
TEST_RESULT_STR(
infoRender(), strNewFmt(
@ -2610,7 +2610,7 @@ testRun(void)
hrnCfgArgRawZ(argList2, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawZ(argList2, cfgOptStanza, "stanza1");
hrnCfgArgKeyRawZ(argList2, cfgOptRepoPath, 2, TEST_PATH "/repo2");
harnessCfgLoad(cfgCmdInfo, argList2);
HRN_CFG_LOAD(cfgCmdInfo, argList2);
// Note that although the time on the backup in repo2 > repo1, repo1 current db is not the same because of the version so
// the repo1, since read first, will be considered the current PG
@ -2724,7 +2724,7 @@ testRun(void)
{
StringList *argList = strLstNew();
strLstAdd(argList, strNewFmt("--repo-path=%s", strZ(repoPath)));
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
storagePathCreateP(storageLocalWrite(), archivePath);
storagePathCreateP(storageLocalWrite(), backupPath);
@ -2749,7 +2749,7 @@ testRun(void)
//--------------------------------------------------------------------------------------------------------------------------
strLstAddZ(argList, "--set=bogus");
TEST_ERROR(harnessCfgLoad(cfgCmdInfo, argList), OptionInvalidError, "option 'set' not valid without option 'stanza'");
TEST_ERROR(hrnCfgLoadP(cfgCmdInfo, argList), OptionInvalidError, "option 'set' not valid without option 'stanza'");
//--------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("repo-level error");
@ -2760,7 +2760,7 @@ testRun(void)
argList = strLstNew();
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 1, TEST_PATH "/repo2");
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_RESULT_STR_Z(
infoRender(),
@ -2771,7 +2771,7 @@ testRun(void)
"text - invalid stanza");
hrnCfgArgRawZ(argList, cfgOptOutput, "json");
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_RESULT_STR_Z(
infoRender(),
@ -2805,7 +2805,7 @@ testRun(void)
argList = strLstNew();
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 1, TEST_PATH "/repo2");
hrnCfgArgRawZ(argList, cfgOptStanza, "stanza1");
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_RESULT_STR_Z(
infoRender(),
@ -2816,7 +2816,7 @@ testRun(void)
"text - stanza requested");
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 2, TEST_PATH "/repo");
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_RESULT_STR_Z(
infoRender(),

2
test/src/module/command/localTest.c
View File

@ -35,7 +35,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--process=1");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleLocal, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleLocal);
cmdLocal(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
}

14
test/src/module/command/remoteTest.c
View File

@ -35,7 +35,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--process=1");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
harnessCfgLoadRole(cfgCmdInfo, cfgCmdRoleRemote, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList, .role = cfgCmdRoleRemote);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
}
@ -64,14 +64,12 @@ testRun(void)
HARNESS_FORK_CHILD_BEGIN(0, true)
{
StringList *argList = strLstNew();
strLstAddZ(argList, testProjectExe());
strLstAddZ(argList, "--process=0");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
strLstAddZ(argList, "--lock-path=/bogus");
strLstAddZ(argList, "--" CFGOPT_STANZA "=test");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, CFGCMD_ARCHIVE_GET ":" CONFIG_COMMAND_ROLE_REMOTE);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleRemote, .noStd = true);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
}
@ -101,13 +99,11 @@ testRun(void)
HARNESS_FORK_CHILD_BEGIN(0, true)
{
StringList *argList = strLstNew();
strLstAddZ(argList, testProjectExe());
strLstAddZ(argList, "--stanza=test");
strLstAddZ(argList, "--process=0");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
strLstAddZ(argList, "--lock-path=/bogus");
strLstAddZ(argList, CFGCMD_ARCHIVE_PUSH ":" CONFIG_COMMAND_ROLE_REMOTE);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote, .noStd = true);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
}
@ -140,7 +136,7 @@ testRun(void)
strLstAddZ(argList, "--process=0");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleRemote, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
}
@ -178,7 +174,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test");
strLstAddZ(argList, "--process=0");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleRemote, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
}

80
test/src/module/command/repoTest.c
View File

@ -27,7 +27,7 @@ testRun(void)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "--repo-path=" TEST_PATH_REPO);
harnessCfgLoad(cfgCmdRepoCreate, argList);
HRN_CFG_LOAD(cfgCmdRepoCreate, argList);
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("noop on non-S3 storage");
@ -42,7 +42,7 @@ testRun(void)
strLstAddZ(argList, "--repo-path=" TEST_PATH_REPO);
strLstAddZ(argList, "--output=text");
strLstAddZ(argList, "--sort=none");
harnessCfgLoad(cfgCmdRepoLs, argList);
HRN_CFG_LOAD(cfgCmdRepoLs, argList);
// Missing directory
// -------------------------------------------------------------------------------------------------------------------------
@ -158,7 +158,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
StringList *argListTmp = strLstDup(argList);
strLstAddZ(argListTmp, "bbb");
harnessCfgLoad(cfgCmdRepoLs, argListTmp);
HRN_CFG_LOAD(cfgCmdRepoLs, argListTmp);
output = bufNew(0);
cfgOptionSet(cfgOptOutput, cfgSourceParam, VARSTRDEF("text"));
@ -183,7 +183,7 @@ testRun(void)
// Too many paths
// -------------------------------------------------------------------------------------------------------------------------
strLstAddZ(argListTmp, "ccc");
harnessCfgLoad(cfgCmdRepoLs, argListTmp);
HRN_CFG_LOAD(cfgCmdRepoLs, argListTmp);
TEST_ERROR(storageListRender(ioBufferWriteNew(output)), ParamInvalidError, "only one path may be specified");
@ -194,7 +194,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 2, TEST_PATH_REPO "/aaa");
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
strLstAddZ(argList, "--output=json");
harnessCfgLoad(cfgCmdRepoLs, argList);
HRN_CFG_LOAD(cfgCmdRepoLs, argList);
output = bufNew(0);
TEST_RESULT_VOID(storageListRender(ioBufferWriteNew(output)), "file (json)");
@ -298,7 +298,7 @@ testRun(void)
StringList *argList = strLstNew();
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_ERROR(storagePutProcess(ioBufferReadNew(fileBuffer)), ParamRequiredError, "destination file required");
@ -306,7 +306,7 @@ testRun(void)
TEST_TITLE("put a file");
strLstAdd(argList, fileName);
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(fileBuffer)), "put");
@ -318,7 +318,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, "--" CFGOPT_CIPHER_PASS "=custom");
strLstAdd(argList, fileEncCustomName);
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(fileEncCustomBuffer)), "put");
@ -330,7 +330,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, "--raw");
strLstAdd(argList, fileRawName);
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
// Get stdin from a file
int stdinSave = dup(STDIN_FILENO);
@ -351,7 +351,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_ARCHIVE "/test/" INFO_ARCHIVE_FILE);
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(archiveInfoFileBuffer)), "put");
@ -362,7 +362,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_ARCHIVE "/test/" INFO_ARCHIVE_FILE ".copy");
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(archiveInfoFileBuffer)), "put");
@ -373,7 +373,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/" INFO_BACKUP_FILE);
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(backupInfoFileBuffer)), "put");
@ -384,7 +384,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/" INFO_BACKUP_FILE ".copy");
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(backupInfoFileBuffer)), "put");
@ -403,7 +403,7 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_CIPHER_PASS "=custom");
strLstAdd(
argList, STRDEF(STORAGE_PATH_ARCHIVE "/test/12-1/000000010000000100000001-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(archiveFileBuffer)), "put");
@ -418,7 +418,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, "--" CFGOPT_CIPHER_PASS "=custom");
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/latest/" BACKUP_MANIFEST_FILE);
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(manifestFileBuffer)), "put");
@ -430,7 +430,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, "--" CFGOPT_CIPHER_PASS "=custom");
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/latest/" BACKUP_MANIFEST_FILE ".copy");
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(manifestFileBuffer)), "put");
@ -444,7 +444,7 @@ testRun(void)
hrnCfgArgKeyRawStrId(argList, cfgOptRepoCipherType, 2, cipherTypeAes256Cbc);
strLstAddZ(argList, "--" CFGOPT_CIPHER_PASS "=custom");
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/backup.history/2020/label.manifest.gz");
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(manifestFileBuffer)), "put");
@ -456,7 +456,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, "--" CFGOPT_CIPHER_PASS "=custom2");
strLstAdd(argList, STRDEF(STORAGE_PATH_BACKUP "/test/latest/pg_data/backup_label"));
harnessCfgLoad(cfgCmdRepoPut, argList);
HRN_CFG_LOAD(cfgCmdRepoPut, argList);
TEST_RESULT_VOID(storagePutProcess(ioBufferReadNew(backupLabelBuffer)), "put");
@ -465,7 +465,7 @@ testRun(void)
argList = strLstNew();
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
TEST_ERROR(storageGetProcess(ioBufferWriteNew(bufNew(0))), ParamRequiredError, "source file required");
@ -473,7 +473,7 @@ testRun(void)
TEST_TITLE("get a file");
strLstAdd(argList, fileName);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
Buffer *writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -485,7 +485,7 @@ testRun(void)
argList = strLstNew();
hrnCfgArgRawZ(argList, cfgOptRepoPath, "/");
strLstAdd(argList, strNewFmt(TEST_PATH "/repo/%s", strZ(fileName)));
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -499,7 +499,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, "--" CFGOPT_CIPHER_PASS "=custom");
strLstAdd(argList, fileEncCustomName);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -513,7 +513,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, "--raw");
strLstAdd(argList, fileRawName);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
TEST_LOG("get");
@ -539,7 +539,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
strLstAddZ(argList, "--" CFGOPT_IGNORE_MISSING);
strLstAddZ(argList, BOGUS_STR);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(bufNew(0))), 1, "get");
@ -553,7 +553,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, "/somewhere/" INFO_ARCHIVE_FILE);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_ERROR(
@ -567,7 +567,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAdd(argList, fileEncCustomName);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_ERROR(
@ -582,7 +582,7 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_STANZA "=test2");
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_ARCHIVE "/test/" INFO_ARCHIVE_FILE);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_ERROR(storageGetProcess(ioBufferWriteNew(writeBuffer)), OptionInvalidValueError,
@ -595,7 +595,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_ARCHIVE "/test/" INFO_ARCHIVE_FILE);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -609,7 +609,7 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_STANZA "=test");
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_ARCHIVE "/test/" INFO_ARCHIVE_FILE ".copy");
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -622,7 +622,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/" INFO_BACKUP_FILE);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -635,7 +635,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/" INFO_BACKUP_FILE ".copy");
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -655,7 +655,7 @@ testRun(void)
strNewFmt(
"%s/repo/" STORAGE_PATH_ARCHIVE "/test/12-1/000000010000000100000001-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
TEST_PATH));
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -668,7 +668,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/latest/" BACKUP_MANIFEST_FILE);
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -681,7 +681,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/latest/" BACKUP_MANIFEST_FILE ".copy");
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -694,7 +694,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAddZ(argList, STORAGE_PATH_BACKUP "/test/backup.history/2020/label.manifest.gz");
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -707,7 +707,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
hrnCfgArgRawStrId(argList, cfgOptRepoCipherType, cipherTypeAes256Cbc);
strLstAdd(argList, STRDEF(STORAGE_PATH_BACKUP "/test/latest/pg_data/backup_label"));
harnessCfgLoad(cfgCmdRepoGet, argList);
HRN_CFG_LOAD(cfgCmdRepoGet, argList);
writeBuffer = bufNew(0);
TEST_RESULT_INT(storageGetProcess(ioBufferWriteNew(writeBuffer)), 0, "get");
@ -726,7 +726,7 @@ testRun(void)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "--repo-path=" TEST_PATH "/repo");
harnessCfgLoad(cfgCmdRepoRm, argList);
HRN_CFG_LOAD(cfgCmdRepoRm, argList);
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("remove missing path");
@ -737,7 +737,7 @@ testRun(void)
TEST_TITLE("remove empty path");
strLstAddZ(argList, "path");
harnessCfgLoad(cfgCmdRepoRm, argList);
HRN_CFG_LOAD(cfgCmdRepoRm, argList);
TEST_RESULT_VOID(storagePathCreateP(storageRepoWrite(), STRDEF("path")), "add path");
TEST_RESULT_VOID(cmdStorageRemove(), "remove path");
@ -760,7 +760,7 @@ testRun(void)
TEST_TITLE("error on more than one path");
strLstAddZ(argList, "repo2");
harnessCfgLoad(cfgCmdRepoRm, argList);
HRN_CFG_LOAD(cfgCmdRepoRm, argList);
TEST_ERROR(cmdStorageRemove(), ParamInvalidError, "only one path may be specified");
@ -772,7 +772,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 2, TEST_PATH_REPO);
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
strLstAddZ(argList, "path/aaa.txt");
harnessCfgLoad(cfgCmdRepoRm, argList);
HRN_CFG_LOAD(cfgCmdRepoRm, argList);
TEST_RESULT_VOID(
storagePutP(storageNewWriteP(storageRepoWrite(), STRDEF("path/aaa.txt")), BUFSTRDEF("TESTDATA")), "add path/file");

136
test/src/module/command/restoreTest.c
View File

@ -165,7 +165,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/pg");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
// Create the pg path
storagePathCreateP(storagePgWrite(), NULL, .mode = 0700);
@ -337,7 +337,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(restorePathValidate(), PathMissingError, "$PGDATA directory '" TEST_PATH "/pg' does not exist");
@ -365,7 +365,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--delta");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restorePathValidate(), "restore --delta with invalid PGDATA");
TEST_RESULT_BOOL(cfgOptionBool(cfgOptDelta), false, "--delta set to false");
@ -374,7 +374,7 @@ testRun(void)
" confirm that this is a valid $PGDATA directory. --delta and --force have been disabled and if any files"
" exist in the destination directories the restore will be aborted.");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
storagePutP(storageNewWriteP(storagePgWrite(), STRDEF("backup.manifest")), NULL);
TEST_RESULT_VOID(restorePathValidate(), "restore --delta with valid PGDATA");
storageRemoveP(storagePgWrite(), STRDEF("backup.manifest"), .errorOnMissing = true);
@ -384,7 +384,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/pg");
strLstAddZ(argList, "--force");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restorePathValidate(), "restore --force with invalid PGDATA");
TEST_RESULT_BOOL(cfgOptionBool(cfgOptForce), false, "--force set to false");
@ -393,7 +393,7 @@ testRun(void)
" confirm that this is a valid $PGDATA directory. --delta and --force have been disabled and if any files"
" exist in the destination directories the restore will be aborted.");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
storagePutP(storageNewWriteP(storagePgWrite(), STRDEF(PG_FILE_PGVERSION)), NULL);
TEST_RESULT_VOID(restorePathValidate(), "restore --force with valid PGDATA");
storageRemoveP(storagePgWrite(), STRDEF(PG_FILE_PGVERSION), .errorOnMissing = true);
@ -447,7 +447,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("error when no backups are present");
@ -470,7 +470,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--set=BOGUS");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(restoreBackupSet(), BackupSetInvalidError, "backup set BOGUS is not valid");
@ -488,7 +488,7 @@ testRun(void)
strLstAddZ(argList, "--type=time");
strLstAddZ(argList, "--target=2016-12-19 16:28:04-0500");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
// Write out backup.info with no current backups to repo1
HRN_INFO_PUT(storageRepoIdxWrite(0), INFO_BACKUP_PATH_FILE, TEST_RESTORE_BACKUP_INFO_DB);
@ -508,7 +508,7 @@ testRun(void)
strLstAddZ(argList, "--type=time");
strLstAddZ(argList, "--target=2016-12-19 16:28:04-0500");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ASSIGN(backupData, restoreBackupSet(), "get backup set");
TEST_RESULT_STR_Z(backupData.backupSet, "20161219-212741F_20161219-212803D", "backup set found");
@ -525,7 +525,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptType, "time");
hrnCfgArgRawZ(argList, cfgOptTarget, "2016-12-19 16:27:30-0500");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
#define TEST_RESTORE_BACKUP_INFO_NEWEST \
"[backup:current]\n" \
@ -553,7 +553,7 @@ testRun(void)
// Request repo2 - latest from repo2 will be chosen
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ASSIGN(backupData, restoreBackupSet(), "get backup set");
TEST_RESULT_STR_Z(backupData.backupSet, "20201212-201243F", "default to latest backup set");
@ -571,7 +571,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptType, "time");
hrnCfgArgRawZ(argList, cfgOptTarget, "2016-12-19 16:27:30-0500");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ASSIGN(backupData, restoreBackupSet(), "get backup set");
TEST_RESULT_STR_Z(backupData.backupSet, "20201212-201243F", "default to latest backup set");
@ -588,7 +588,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptType, "time");
hrnCfgArgRawZ(argList, cfgOptTarget, "Tue, 15 Nov 1994 12:45:26");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ASSIGN(backupData, restoreBackupSet(), "get backup set");
TEST_RESULT_STR_Z(backupData.backupSet, "20161219-212741F_20161219-212918I", "time invalid format, default latest");
@ -610,7 +610,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptType, "time");
hrnCfgArgRawZ(argList, cfgOptTarget, "2016-12-19 16:27:30-0500");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
// Write out backup.info with no current backups to repo1 and repo2
HRN_INFO_PUT(storageRepoIdxWrite(0), INFO_BACKUP_PATH_FILE, TEST_RESTORE_BACKUP_INFO_DB);
@ -650,7 +650,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreManifestMap(manifest), "base directory is not remapped");
TEST_RESULT_STR(manifestTargetFind(manifest, MANIFEST_TARGET_PGDATA_STR)->path, pgPath, "base directory is not remapped");
@ -662,7 +662,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreManifestMap(manifest), "base directory is remapped");
TEST_RESULT_STR(manifestTargetFind(manifest, MANIFEST_TARGET_PGDATA_STR)->path, pgPath, "base directory is remapped");
@ -676,7 +676,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--tablespace-map=bogus=/bogus");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(restoreManifestMap(manifest), TablespaceMapError, "unable to remap invalid tablespace 'bogus'");
@ -701,7 +701,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--tablespace-map=2=/2");
strLstAddZ(argList, "--tablespace-map=ts2=/ts2");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(
restoreManifestMap(manifest), TablespaceMapError, "tablespace remapped by name 'ts2' and id 2 with different paths");
@ -713,7 +713,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--tablespace-map=1=/1-2");
strLstAddZ(argList, "--tablespace-map=ts2=/2-2");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreManifestMap(manifest), "remap tablespaces");
TEST_RESULT_STR_Z(manifestTargetFind(manifest, STRDEF("pg_tblspc/1"))->path, "/1-2", " check tablespace 1 target");
@ -734,7 +734,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--tablespace-map=2=/2-3");
strLstAddZ(argList, "--tablespace-map-all=/all");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreManifestMap(manifest), "remap tablespaces");
TEST_RESULT_STR_Z(manifestTargetFind(manifest, STRDEF("pg_tblspc/1"))->path, "/all/1", " check tablespace 1 target");
@ -756,7 +756,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--tablespace-map-all=/all2");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreManifestMap(manifest), "remap tablespaces");
TEST_RESULT_STR_Z(manifestTargetFind(manifest, STRDEF("pg_tblspc/1"))->path, "/all2/1", " check tablespace 1 target");
@ -779,7 +779,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--link-map=bogus=bogus");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(restoreManifestMap(manifest), LinkMapError, "unable to remap invalid link 'bogus'");
@ -801,7 +801,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--link-map=pg_hba.conf=bogus");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(
restoreManifestMap(manifest), LinkMapError,
@ -816,7 +816,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--link-map=pg_hba.conf=../conf2/pg_hba2.conf");
strLstAddZ(argList, "--link-map=pg_wal=/wal2");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreManifestMap(manifest), "remap links");
TEST_RESULT_STR_Z(manifestTargetFind(manifest, STRDEF("pg_data/pg_hba.conf"))->path, "../conf2", " check link path");
@ -837,7 +837,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--link-all");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreManifestMap(manifest), "leave links as they are");
TEST_RESULT_STR_Z(manifestTargetFind(manifest, STRDEF("pg_data/pg_hba.conf"))->path, "../conf2", " check link path");
@ -853,7 +853,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreManifestMap(manifest), "remove all links");
TEST_ERROR(
@ -931,7 +931,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--repo1-path=/repo");
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
manifest = testManifestMinimal(STRDEF("20161219-212741F_20161219-21275D"), PG_VERSION_96, pgPath);
userLocalData.userRoot = true;
@ -1020,7 +1020,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
storagePathCreateP(storagePgWrite(), NULL, .mode = 0600);
@ -1108,7 +1108,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--type=preserve");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreCleanBuild(manifest), "restore");
@ -1169,7 +1169,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_VOID(restoreCleanBuild(manifest), "restore");
@ -1195,7 +1195,7 @@ testRun(void)
StringList *argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-include=" UTF8_DB_NAME);
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
Manifest *manifest = NULL;
@ -1243,7 +1243,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-exclude=" UTF8_DB_NAME);
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(restoreSelectiveExpression(manifest), DbMissingError, "database to exclude '" UTF8_DB_NAME "' does not exist");
@ -1261,7 +1261,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-include=" UTF8_DB_NAME);
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR(restoreSelectiveExpression(manifest), NULL, "all databases selected");
@ -1274,7 +1274,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-include=1");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(
restoreSelectiveExpression(manifest), DbInvalidError,
@ -1287,7 +1287,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-include=16385");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(
restoreSelectiveExpression(manifest), DbInvalidError,
@ -1300,7 +1300,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-include=postgres");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(
restoreSelectiveExpression(manifest), DbInvalidError,
@ -1313,7 +1313,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-include=7777777");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(restoreSelectiveExpression(manifest), DbMissingError, "database to include '7777777' does not exist");
@ -1332,7 +1332,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-include=16384");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(restoreSelectiveExpression(manifest), "(^pg_data/base/32768/)", "check expression");
@ -1391,7 +1391,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-exclude=16384");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreSelectiveExpression(manifest),
@ -1407,7 +1407,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-exclude=" UTF8_DB_NAME);
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreSelectiveExpression(manifest),
@ -1423,7 +1423,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-exclude=16385");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreSelectiveExpression(manifest),
@ -1439,7 +1439,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-exclude=7777777");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(restoreSelectiveExpression(manifest), DbMissingError, "database to exclude '7777777' does not exist");
@ -1451,7 +1451,7 @@ testRun(void)
argList = strLstDup(argListClean);
strLstAddZ(argList, "--db-include=test2");
strLstAddZ(argList, "--db-exclude=test2");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(restoreSelectiveExpression(manifest), DbInvalidError, "database to include '32768' is in the exclude list");
@ -1465,7 +1465,7 @@ testRun(void)
strLstAddZ(argList, "--db-exclude=1");
strLstAddZ(argList, "--db-exclude=16385");
strLstAddZ(argList, "--db-exclude=32768"); // user databases excluded will be silently ignored
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreSelectiveExpression(manifest),
@ -1497,7 +1497,7 @@ testRun(void)
StringList *argList = strLstDup(argBaseList);
strLstAddZ(argList, "--recovery-option=a-setting=a");
strLstAddZ(argList, "--recovery-option=b_setting=b");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_94, restoreLabel),
@ -1513,7 +1513,7 @@ testRun(void)
strLstAddZ(argBaseList, "--recovery-option=restore-command=my_restore_command");
argList = strLstDup(argBaseList);
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_94, restoreLabel),
@ -1526,7 +1526,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "--type=immediate");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_94, restoreLabel),
@ -1542,7 +1542,7 @@ testRun(void)
strLstAddZ(argList, "--type=time");
strLstAddZ(argList, "--target=TIME");
strLstAddZ(argList, "--target-timeline=3");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_94, restoreLabel),
@ -1559,7 +1559,7 @@ testRun(void)
strLstAddZ(argList, "--type=time");
strLstAddZ(argList, "--target=TIME");
strLstAddZ(argList, "--target-exclusive");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_94, restoreLabel),
@ -1575,7 +1575,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "--type=name");
strLstAddZ(argList, "--target=NAME");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_94, restoreLabel),
@ -1590,7 +1590,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "--type=immediate");
strLstAddZ(argList, "--target-action=shutdown");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_95, restoreLabel),
@ -1610,7 +1610,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "--type=immediate");
strLstAddZ(argList, "--target-action=promote");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_94, restoreLabel),
@ -1629,7 +1629,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "--type=standby");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_94, restoreLabel),
@ -1644,7 +1644,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "--type=standby");
strLstAddZ(argList, "--target-timeline=current");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_94, restoreLabel),
@ -1659,7 +1659,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "--archive-mode=off");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(
restoreRecoveryConf(PG_VERSION_94, restoreLabel), OptionInvalidError,
@ -1672,7 +1672,7 @@ testRun(void)
argList = strLstDup(argBaseList);
strLstAddZ(argList, "--type=standby");
strLstAddZ(argList, "--archive-mode=off");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_RESULT_STR_Z(
restoreRecoveryConf(PG_VERSION_12, restoreLabel),
@ -1700,7 +1700,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--type=default");
strLstAddZ(argList, "--recovery-option=standby-mode=on");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(
restoreRecoveryWriteAutoConf(PG_VERSION_12, restoreLabel), OptionInvalidError,
@ -1717,7 +1717,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-path=/repo");
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--type=none");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
restoreRecoveryWriteAutoConf(PG_VERSION_12, restoreLabel);
@ -1772,7 +1772,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--recovery-option=restore-command=my_restore_command");
strLstAddZ(argList, "--type=standby");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
restoreRecoveryWriteAutoConf(PG_VERSION_12, restoreLabel);
@ -1805,7 +1805,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-path=/repo");
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--type=preserve");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
restoreRecoveryWrite(manifest);
@ -1828,7 +1828,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--repo1-path=/repo");
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
restoreRecoveryWrite(manifest);
@ -1869,7 +1869,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--repo1-path=%s", strZ(repoPath)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pgPath)));
strLstAddZ(argList, "--pg1-host=pg1");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
TEST_ERROR(cmdRestore(), HostInvalidError, "restore command must be run on the PostgreSQL host");
@ -1884,7 +1884,7 @@ testRun(void)
strLstAddZ(argList, "--set=20161219-212741F");
hrnCfgArgKeyRawStrId(argList, cfgOptRepoCipherType, 2, cipherTypeAes256Cbc);
hrnCfgEnvKeyRawZ(cfgOptRepoCipherPass, 2, TEST_CIPHER_PASS);
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
#define TEST_LABEL "20161219-212741F"
#define TEST_PGDATA MANIFEST_TARGET_PGDATA "/"
@ -2050,7 +2050,7 @@ testRun(void)
strLstAddZ(argList, "--force");
hrnCfgArgKeyRawStrId(argList, cfgOptRepoCipherType, 2, cipherTypeAes256Cbc);
hrnCfgEnvKeyRawZ(cfgOptRepoCipherPass, 2, TEST_CIPHER_PASS);
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
// Store backup.info to repo1 - repo1 will be selected because of the priority order
HRN_INFO_PUT(storageRepoIdxWrite(0), INFO_BACKUP_PATH_FILE, TEST_RESTORE_BACKUP_INFO "\n" TEST_RESTORE_BACKUP_INFO_DB);
@ -2175,7 +2175,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptType, CFGOPTVAL_TYPE_PRESERVE);
strLstAddZ(argList, "--" CFGOPT_SET "=20161219-212741F");
strLstAddZ(argList, "--" CFGOPT_FORCE);
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
cmdRestore();
@ -2229,7 +2229,7 @@ testRun(void)
strLstAddZ(argList, "--link-map=pg_wal=../wal");
strLstAddZ(argList, "--link-map=postgresql.conf=../config/postgresql.conf");
strLstAddZ(argList, "--link-map=pg_hba.conf=../config/pg_hba.conf");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
#define TEST_LABEL "20161219-212741F_20161219-212918I"
#define TEST_PGDATA MANIFEST_TARGET_PGDATA "/"
@ -2599,7 +2599,7 @@ testRun(void)
strLstAddZ(argList, "--link-map=postgresql.conf=../config/postgresql.conf");
strLstAddZ(argList, "--link-map=pg_hba.conf=../config/pg_hba.conf");
strLstAddZ(argList, "--db-include=16384");
harnessCfgLoad(cfgCmdRestore, argList);
HRN_CFG_LOAD(cfgCmdRestore, argList);
// Move pg1-path and put a link in its place. This tests that restore works when pg1-path is a symlink yet should be
// completely invisible in the manifest and logging.

40
test/src/module/command/stanzaTest.c
View File

@ -42,10 +42,10 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
TEST_ERROR(
harnessCfgLoad(cfgCmdStanzaCreate, argList), OptionInvalidError, "option 'repo' not valid for command 'stanza-create'");
hrnCfgLoadP(cfgCmdStanzaCreate, argList), OptionInvalidError, "option 'repo' not valid for command 'stanza-create'");
//--------------------------------------------------------------------------------------------------------------------------
harnessCfgLoad(cfgCmdStanzaCreate, argListBase);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argListBase);
// Create the stop file
TEST_RESULT_VOID(
@ -58,7 +58,7 @@ testRun(void)
//--------------------------------------------------------------------------------------------------------------------------
argList = strLstDup(argListBase);
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
// Create pg_control
storagePutP(
@ -130,7 +130,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 4, TEST_PATH "/repo4");
hrnCfgArgKeyRawStrId(argList, cfgOptRepoCipherType, 4, cipherTypeAes256Cbc);
hrnCfgEnvKeyRawZ(cfgOptRepoCipherPass, 4, "87654321");
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
TEST_RESULT_VOID(cmdStanzaCreate(), "stanza create - files already exist on repo1 and both are valid");
TEST_RESULT_LOG(
@ -250,14 +250,14 @@ testRun(void)
hrnCfgArgKeyRawFmt(argListCmd, cfgOptPgPath, 1, TEST_PATH "/%s", strZ(stanza));
TEST_ERROR(
harnessCfgLoad(cfgCmdStanzaDelete, argListCmd), OptionRequiredError,
hrnCfgLoadP(cfgCmdStanzaDelete, argListCmd), OptionRequiredError,
"stanza-delete command requires option: repo\n"
"HINT: this command requires a specific repository to operate on");
// Add the repo option
StringList *argListDelete = strLstDup(argListCmd);
hrnCfgArgRawZ(argListDelete, cfgOptRepo, "4");
harnessCfgLoad(cfgCmdStanzaDelete, argListDelete);
HRN_CFG_LOAD(cfgCmdStanzaDelete, argListDelete);
TEST_ERROR(
cmdStanzaDelete(), FileMissingError,
@ -282,7 +282,7 @@ testRun(void)
// Stanza with directories only
argListDelete = strLstDup(argListCmd);
hrnCfgArgRawZ(argListDelete, cfgOptRepo, "3");
harnessCfgLoad(cfgCmdStanzaDelete, argListDelete);
HRN_CFG_LOAD(cfgCmdStanzaDelete, argListDelete);
TEST_RESULT_VOID(
storagePathCreateP(storageTest, strNewFmt("repo3/archive/%s/9.6-1/1234567812345678", strZ(stanza))),
@ -307,7 +307,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 2, TEST_PATH "/repo2");
hrnCfgArgKeyRawStrId(argList, cfgOptRepoCipherType, 2, cipherTypeAes256Cbc);
hrnCfgEnvKeyRawZ(cfgOptRepoCipherPass, 2, "12345678");
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
// Backup files removed - archive.info and archive.info.copy exist repo2
TEST_RESULT_VOID(
@ -339,7 +339,7 @@ testRun(void)
// Delete the last repo so only 1 remains
argListDelete = strLstDup(argListCmd);
hrnCfgArgRawZ(argListDelete, cfgOptRepo, "2");
harnessCfgLoad(cfgCmdStanzaDelete, argListDelete);
HRN_CFG_LOAD(cfgCmdStanzaDelete, argListDelete);
// Create the stop file
TEST_RESULT_VOID(
@ -353,7 +353,7 @@ testRun(void)
hrnCfgEnvKeyRemoveRaw(cfgOptRepoCipherPass, 2);
argList = strLstDup(argListBase);
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
// Archive files removed - backup.info exists
TEST_RESULT_VOID(
@ -546,7 +546,7 @@ testRun(void)
// Repeat last test using --force (deprecated)
//--------------------------------------------------------------------------------------------------------------------------
strLstAddZ(argList, "--force");
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
TEST_ERROR(cmdStanzaCreate(), PathNotEmptyError, "archive directory not empty");
TEST_RESULT_LOG(
"P00 WARN: option --force is no longer supported\n"
@ -564,7 +564,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--stanza=%s", strZ(stanza)));
strLstAdd(argList, strNewFmt("--pg1-path=%s", strZ(pg1Path)));
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
// pgControl and database match
//--------------------------------------------------------------------------------------------------------------------------
@ -584,7 +584,7 @@ testRun(void)
TEST_RESULT_BOOL(
storageExistsP(storageTest, strNewFmt("repo/archive/%s/archive.info", strZ(stanza))), true, " stanza created");
harnessCfgLoad(cfgCmdStanzaUpgrade, argList);
HRN_CFG_LOAD(cfgCmdStanzaUpgrade, argList);
harnessPqScriptSet((HarnessPq [])
{
HRNPQ_MACRO_OPEN_GE_92(1, "dbname='postgres' port=5432", PG_VERSION_92, strZ(pg1Path), false, NULL, NULL),
@ -644,7 +644,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--pg2-path=%s", strZ(pg1Path)));
strLstAddZ(argList, "--pg2-port=5434");
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
// Create pg_control for primary
storagePutP(
@ -686,11 +686,11 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
TEST_ERROR(
harnessCfgLoad(cfgCmdStanzaUpgrade, argList), OptionInvalidError,
hrnCfgLoadP(cfgCmdStanzaUpgrade, argList), OptionInvalidError,
"option 'repo' not valid for command 'stanza-upgrade'");
//--------------------------------------------------------------------------------------------------------------------------
harnessCfgLoad(cfgCmdStanzaUpgrade, argListBase);
HRN_CFG_LOAD(cfgCmdStanzaUpgrade, argListBase);
// Create the stop file
TEST_RESULT_VOID(
@ -1007,7 +1007,7 @@ testRun(void)
strLstAdd(argList, strNewFmt("--stanza=%s", strZ(stanzaOther)));
strLstAdd(argList, strNewFmt("--pg1-path=" TEST_PATH "/%s", strZ(stanzaOther)));
strLstAddZ(argList, "--no-online");
harnessCfgLoad(cfgCmdStanzaCreate, argList);
HRN_CFG_LOAD(cfgCmdStanzaCreate, argList);
// Create pg_control for stanza-create
storagePutP(
@ -1020,7 +1020,7 @@ testRun(void)
argList = strLstDup(argListCmd);
strLstAdd(argList, strNewFmt("--stanza=%s", strZ(stanza)));
strLstAdd(argList, strNewFmt("--pg1-path=" TEST_PATH "/%s", strZ(stanza)));
harnessCfgLoad(cfgCmdStanzaDelete, argList);
HRN_CFG_LOAD(cfgCmdStanzaDelete, argList);
// stanza already deleted
//--------------------------------------------------------------------------------------------------------------------------
@ -1132,7 +1132,7 @@ testRun(void)
StringList *argListDel = strLstDup(argList);
hrnCfgArgKeyRawZ(argListDel, cfgOptRepoPath, 2, TEST_PATH "/repo2");
hrnCfgArgRawZ(argListDel, cfgOptRepo, "2");
harnessCfgLoad(cfgCmdStanzaDelete, argListDel);
HRN_CFG_LOAD(cfgCmdStanzaDelete, argListDel);
TEST_RESULT_VOID(
storagePutP(
@ -1151,7 +1151,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 2, TEST_PATH "/repo2");
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
strLstAddZ(argList,"--force");
harnessCfgLoad(cfgCmdStanzaDelete, argList);
HRN_CFG_LOAD(cfgCmdStanzaDelete, argList);
TEST_RESULT_VOID(cmdStanzaDelete(), "stanza delete --force");
TEST_RESULT_BOOL(

16
test/src/module/command/verifyTest.c
View File

@ -242,7 +242,7 @@ testRun(void)
{
// Load Parameters
StringList *argList = strLstDup(argListBase);
harnessCfgLoad(cfgCmdVerify, argList);
HRN_CFG_LOAD(cfgCmdVerify, argList);
const Buffer *contentLoad = harnessInfoChecksumZ
(
@ -773,7 +773,7 @@ testRun(void)
{
// Load Parameters
StringList *argList = strLstDup(argListBase);
harnessCfgLoad(cfgCmdVerify, argList);
HRN_CFG_LOAD(cfgCmdVerify, argList);
//--------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("backup.info invalid checksum, neither backup copy nor archive infos exist");
@ -878,7 +878,7 @@ testRun(void)
{
// Load Parameters
StringList *argList = strLstDup(argListBase);
harnessCfgLoad(cfgCmdVerify, argList);
HRN_CFG_LOAD(cfgCmdVerify, argList);
//--------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("verifyFile()");
@ -917,7 +917,7 @@ testRun(void)
// Load Parameters with multi-repo
StringList *argList = strLstDup(argListBase);
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 4, TEST_PATH "/repo4");
harnessCfgLoad(cfgCmdVerify, argList);
HRN_CFG_LOAD(cfgCmdVerify, argList);
// Store valid archive/backup info files
TEST_RESULT_VOID(
@ -1047,7 +1047,7 @@ testRun(void)
// Load Parameters - single default repo
argList = strLstDup(argListBase);
harnessCfgLoad(cfgCmdVerify, argList);
HRN_CFG_LOAD(cfgCmdVerify, argList);
TEST_RESULT_VOID(
storagePutP(
@ -1089,7 +1089,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 2, TEST_PATH "/repo");
hrnCfgArgRawFmt(argList, cfgOptStanza, "%s", strZ(stanza));
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
harnessCfgLoad(cfgCmdVerify, argList);
HRN_CFG_LOAD(cfgCmdVerify, argList);
TEST_RESULT_VOID(
storagePutP(
@ -1283,7 +1283,7 @@ testRun(void)
{
// Load Parameters
StringList *argList = strLstDup(argListBase);
harnessCfgLoad(cfgCmdVerify, argList);
HRN_CFG_LOAD(cfgCmdVerify, argList);
// Backup labels
const String *backupLabelFull = STRDEF("20181119-152900F");
@ -1415,7 +1415,7 @@ testRun(void)
// Set process max to 1 and add more files to check so first backup completes before second is checked
strLstAddZ(argList, "--process-max=1");
harnessCfgLoad(cfgCmdVerify, argList);
HRN_CFG_LOAD(cfgCmdVerify, argList);
contentLoad = harnessInfoChecksumZ
(

14
test/src/module/common/exitTest.c
View File

@ -29,7 +29,7 @@ testRun(void)
// *****************************************************************************************************************************
if (testBegin("exitInit() and exitOnSignal()"))
{
harnessCfgLoad(cfgCmdHelp, strLstNew());
HRN_CFG_LOAD(cfgCmdHelp, strLstNew());
HARNESS_FORK_BEGIN()
{
@ -46,7 +46,7 @@ testRun(void)
// *****************************************************************************************************************************
if (testBegin("exitSafe()"))
{
harnessCfgLoad(cfgCmdHelp, strLstNew());
HRN_CFG_LOAD(cfgCmdHelp, strLstNew());
cfgCommandSet(cfgCmdNone, cfgCmdRoleMain);
TEST_RESULT_INT(exitSafe(0, false, signalTypeNone), 0, "exit with no command");
@ -55,7 +55,7 @@ testRun(void)
StringList *argList = strLstNew();
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgRawNegate(argList, cfgOptLogTimestamp);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
TEST_RESULT_INT(exitSafe(0, false, signalTypeNone), 0, "exit with no error");
TEST_RESULT_LOG("P00 INFO: archive-push command end: completed successfully");
@ -79,11 +79,9 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, PROJECT_BIN);
strLstAddZ(argList, "--" CFGOPT_STANZA "=test");
strLstAddZ(argList, "--" CFGOPT_PROCESS_MAX "=4");
strLstAddZ(argList, CFGCMD_ARCHIVE_PUSH ":" CONFIG_COMMAND_ROLE_ASYNC);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleAsync, .noStd = true);
harnessLogLevelSet(logLevelDebug);
@ -105,7 +103,7 @@ testRun(void)
" options: --exec-id=1-test --process-max=4 --stanza=test\n"
" \n"
" stack trace:\n"
" " TEST_PGB_PATH "/test/src/module/common/exitTest.c:testRun:92:(void)\n"
" " TEST_PGB_PATH "/test/src/module/common/exitTest.c:testRun:90:(void)\n"
" test.c:main:(argListSize: 1, argList: (char *[]))\n"
" --------------------------------------------------------------------\n"
"P00 INFO: archive-push:async command end: aborted with exception [122]\n"
@ -135,7 +133,7 @@ testRun(void)
" options: --exec-id=1-test --process-max=4 --stanza=test\n"
" \n"
" stack trace:\n"
" " TEST_PGB_PATH "/test/src/module/common/exitTest.c:testRun:123:(void)\n"
" " TEST_PGB_PATH "/test/src/module/common/exitTest.c:testRun:121:(void)\n"
" test.c:main:(argListSize: 1, argList: (char *[]))\n"
" --------------------------------------------------------------------\n"
"P00 INFO: archive-push:async command end: aborted with exception [025]");

8
test/src/module/config/execTest.c
View File

@ -15,7 +15,6 @@ testRun(void)
if (testBegin("cfgExecParam()"))
{
StringList *argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
hrnCfgArgRawZ(argList, cfgOptArchiveTimeout, "5");
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
@ -26,11 +25,10 @@ testRun(void)
strLstAddZ(argList, "--reset-neutral-umask");
strLstAddZ(argList, "--repo-cipher-type=aes-256-cbc");
strLstAddZ(argList, "--" CFGOPT_ARCHIVE_ASYNC);
strLstAddZ(argList, "archive-get");
// Set repo1-cipher-pass to make sure it is not passed on the command line
setenv("PGBACKREST_REPO1_CIPHER_PASS", "1234", true);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .noStd = true);
unsetenv("PGBACKREST_REPO1_CIPHER_PASS");
TEST_RESULT_STRLST_Z(
@ -48,7 +46,6 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/db path");
@ -57,10 +54,9 @@ testRun(void)
strLstAddZ(argList, "--recovery-option=a=b");
strLstAddZ(argList, "--recovery-option=c=d");
hrnCfgArgRawReset(argList, cfgOptLogPath);
strLstAddZ(argList, "restore");
setenv("PGBACKREST_REPO1_HOST", "bogus", true);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdRestore, argList, .noStd = true);
unsetenv("PGBACKREST_REPO1_HOST");
KeyValue *optionReplace = kvNew();

72
test/src/module/config/loadTest.c
View File

@ -21,7 +21,7 @@ testRun(void)
// *****************************************************************************************************************************
if (testBegin("cfgLoadLogSetting()"))
{
harnessCfgLoad(cfgCmdVersion, strLstNew());
HRN_CFG_LOAD(cfgCmdVersion, strLstNew());
TEST_RESULT_VOID(cfgLoadLogSetting(), "load log settings all defaults");
@ -40,7 +40,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/pg1");
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
TEST_ERROR(harnessCfgLoad(cfgCmdCheck, argList), OptionInvalidError, "option 'repo' not valid for command 'check'");
TEST_ERROR(hrnCfgLoadP(cfgCmdCheck, argList), OptionInvalidError, "option 'repo' not valid for command 'check'");
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("error when repo option not set and repo total > 1 or first repo index != 1");
@ -51,19 +51,19 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/pg1");
TEST_ERROR(
harnessCfgLoad(cfgCmdStanzaDelete, argList), OptionRequiredError,
hrnCfgLoadP(cfgCmdStanzaDelete, argList), OptionRequiredError,
"stanza-delete command requires option: repo\n"
"HINT: this command requires a specific repository to operate on");
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdStanzaDelete, argList), "load stanza-delete with repo set");
HRN_CFG_LOAD(cfgCmdStanzaDelete, argList, .comment = "load stanza-delete with repo set");
argList = strLstNew();
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 2, "/repo2");
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/pg1");
TEST_ERROR(
harnessCfgLoad(cfgCmdStanzaDelete, argList), OptionRequiredError,
hrnCfgLoadP(cfgCmdStanzaDelete, argList), OptionRequiredError,
"stanza-delete command requires option: repo\n"
"HINT: this command requires a specific repository to operate on");
@ -71,12 +71,12 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 1, "/repo1");
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/pg1");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdStanzaDelete, argList), "load stanza-delete with single repo, repo option not set");
HRN_CFG_LOAD(cfgCmdStanzaDelete, argList, .comment = "load stanza-delete with single repo, repo option not set");
argList = strLstNew();
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 1, "/repo1");
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 4, "/repo4");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdInfo, argList), "load info config -- option repo not required");
HRN_CFG_LOAD(cfgCmdInfo, argList, .comment = "load info config -- option repo not required");
TEST_RESULT_BOOL(cfgCommand() == cfgCmdInfo, true, " command is info");
// -------------------------------------------------------------------------------------------------------------------------
@ -91,7 +91,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 1, "/repo1");
hrnCfgArgKeyRawZ(argList, cfgOptRepoHost, 2, "host2");
TEST_ERROR(
harnessCfgLoad(cfgCmdRestore, argList), OptionInvalidValueError,
hrnCfgLoadP(cfgCmdRestore, argList), OptionInvalidValueError,
"local repo3 and repo4 paths are both '/repo4' but must be different");
// -------------------------------------------------------------------------------------------------------------------------
@ -103,8 +103,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoPath, 1, "/repo1");
hrnCfgArgKeyRawZ(argList, cfgOptRepoRetentionFull, 1, "1");
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 1, "/pg1");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("local default repo paths for cifs repo type must be different");
@ -114,7 +113,7 @@ testRun(void)
hrnCfgArgKeyRawStrId(argList, cfgOptRepoType, 1, STORAGE_CIFS_TYPE);
hrnCfgArgKeyRawStrId(argList, cfgOptRepoType, 2, STORAGE_CIFS_TYPE);
TEST_ERROR(
harnessCfgLoad(cfgCmdInfo, argList), OptionInvalidValueError,
hrnCfgLoadP(cfgCmdInfo, argList), OptionInvalidValueError,
"local repo1 and repo2 paths are both '/var/lib/pgbackrest' but must be different");
// -------------------------------------------------------------------------------------------------------------------------
@ -130,7 +129,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptRepoS3Endpoint, 3, "endpoint");
hrnCfgEnvKeyRawZ(cfgOptRepoS3Key, 3, "mykey");
hrnCfgEnvKeyRawZ(cfgOptRepoS3KeySecret, 3, "mysecretkey");
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
hrnCfgEnvKeyRemoveRaw(cfgOptRepoS3Key, 3);
hrnCfgEnvKeyRemoveRaw(cfgOptRepoS3KeySecret, 3);
@ -141,7 +140,7 @@ testRun(void)
argList = strLstNew();
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/pg1");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
cfgOptionIdxSet(cfgOptRepoHost, 0, cfgSourceParam, varNewStrZ("repo-host"));
@ -163,7 +162,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 2, "/pg2");
hrnCfgArgKeyRawZ(argList, cfgOptPgHost, 2, "pg2");
hrnCfgArgKeyRawZ(argList, cfgOptPgHostCmd, 2, "pg2-exe");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
TEST_RESULT_STR_Z(cfgOptionIdxStr(cfgOptPgHostCmd, 0), testProjectExe(), " check pg1-host-cmd");
TEST_RESULT_STR_Z(cfgOptionIdxStr(cfgOptPgHostCmd, 1), "pg2-exe", " check pg2-host-cmd");
@ -175,7 +174,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 1, "/pg1");
hrnCfgArgRawZ(argList, cfgOptDbTimeout, "100");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
cfgOptionInvalidate(cfgOptProtocolTimeout);
cfgLoadUpdateOption();
@ -189,7 +188,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 1, "/pg1");
hrnCfgArgRawZ(argList, cfgOptProtocolTimeout, "100");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
cfgOptionInvalidate(cfgOptDbTimeout);
cfgLoadUpdateOption();
@ -203,7 +202,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 1, "/pg1");
hrnCfgArgRawZ(argList, cfgOptDbTimeout, "100000");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
TEST_RESULT_UINT(cfgOptionUInt64(cfgOptProtocolTimeout), 100030000, "check protocol-timeout");
@ -216,7 +215,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptDbTimeout, "100000");
hrnCfgArgRawZ(argList, cfgOptProtocolTimeout, "50.5");
TEST_ERROR(
harnessCfgLoad(cfgCmdCheck, argList), OptionInvalidValueError,
hrnCfgLoadP(cfgCmdCheck, argList), OptionInvalidValueError,
"'50.5' is not valid for 'protocol-timeout' option\n"
"HINT 'protocol-timeout' option (50.5) should be greater than 'db-timeout' option (100000).");
@ -227,7 +226,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptStanza, "test");
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 1, "/pg1");
hrnCfgArgRawZ(argList, cfgOptProtocolTimeout, "11");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
TEST_RESULT_UINT(cfgOptionUInt64(cfgOptProtocolTimeout), 11000, "check protocol-timeout");
TEST_RESULT_UINT(cfgOptionUInt64(cfgOptDbTimeout), 5500, "check db-timeout");
@ -241,7 +240,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 4, "/pg4");
hrnCfgArgKeyRawZ(argList, cfgOptPgHost, 4, "pg4");
hrnCfgArgRawZ(argList, cfgOptRepoHost, "repo1");
TEST_ERROR(harnessCfgLoad(cfgCmdCheck, argList), ConfigError, "pg and repo hosts cannot both be configured as remote");
TEST_ERROR(hrnCfgLoadP(cfgCmdCheck, argList), ConfigError, "pg and repo hosts cannot both be configured as remote");
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("only pg can be remote");
@ -256,7 +255,7 @@ testRun(void)
argList = strLstNew();
hrnCfgArgRawZ(argList, cfgOptRepoHost, "repo1");
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
@ -264,7 +263,7 @@ testRun(void)
strLstAddZ(argList, "process-max");
harnessLogLevelSet(logLevelWarn);
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdHelp, argList), "load help config -- no retention warning");
HRN_CFG_LOAD(cfgCmdHelp, argList, .comment = "load help config -- no retention warning");
TEST_RESULT_BOOL(cfgCommandHelp(), true, " command is help");
argList = strLstNew();
@ -272,7 +271,7 @@ testRun(void)
strLstAddZ(argList, "--no-log-timestamp");
harnessLogLevelSet(logLevelWarn);
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdExpire, argList), "load config for retention warning");
HRN_CFG_LOAD(cfgCmdExpire, argList, .comment = "load config for retention warning");
TEST_RESULT_LOG(
"P00 WARN: option 'repo1-retention-full' is not set for 'repo1-retention-full-type=count', the repository may run out"
" of space\n"
@ -281,8 +280,8 @@ testRun(void)
TEST_RESULT_BOOL(cfgOptionTest(cfgOptRepoRetentionArchive), false, " repo1-retention-archive not set");
strLstAddZ(argList, "--repo1-retention-full=1");
HRN_CFG_LOAD(cfgCmdExpire, argList, .comment = "load config no retention warning");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdExpire, argList), "load config no retention warning");
TEST_RESULT_INT(cfgOptionInt(cfgOptRepoRetentionArchive), 1, " repo1-retention-archive set");
// Munge repo-type for coverage. This will go away when there are multiple repos.
@ -293,8 +292,8 @@ testRun(void)
strLstAddZ(argList, "--stanza=db");
strLstAddZ(argList, "--no-log-timestamp");
strLstAddZ(argList, "--repo1-retention-archive-type=incr");
HRN_CFG_LOAD(cfgCmdExpire, argList, .comment = "load config for retention warning");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdExpire, argList), "load config for retention warning");
TEST_RESULT_LOG(
"P00 WARN: option 'repo1-retention-full' is not set for 'repo1-retention-full-type=count', the repository may run out"
" of space\n"
@ -308,8 +307,8 @@ testRun(void)
strLstAddZ(argList, "--stanza=db");
strLstAddZ(argList, "--no-log-timestamp");
strLstAddZ(argList, "--repo1-retention-archive-type=diff");
HRN_CFG_LOAD(cfgCmdExpire, argList, .comment = "load config for retention warning");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdExpire, argList), "load config for retention warning");
TEST_RESULT_LOG(
"P00 WARN: option 'repo1-retention-full' is not set for 'repo1-retention-full-type=count', the repository may run out"
" of space\n"
@ -320,8 +319,8 @@ testRun(void)
TEST_RESULT_BOOL(cfgOptionTest(cfgOptRepoRetentionArchive), false, " repo1-retention-archive not set");
strLstAddZ(argList, "--repo1-retention-diff=2");
HRN_CFG_LOAD(cfgCmdExpire, argList, .comment = "load config for retention warning");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdExpire, argList), "load config for retention warning");
TEST_RESULT_LOG(
"P00 WARN: option 'repo1-retention-full' is not set for 'repo1-retention-full-type=count', the repository may run out"
" of space\n"
@ -335,8 +334,8 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-archive-type=diff");
strLstAddZ(argList, "--repo1-retention-archive=3");
strLstAddZ(argList, "--repo1-retention-full=1");
HRN_CFG_LOAD(cfgCmdExpire, argList, .comment = "load config for retention warning");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdExpire, argList), "load config for retention warning");
TEST_RESULT_LOG(
"P00 WARN: option 'repo1-retention-diff' is not set for 'repo1-retention-archive-type=diff'\n"
" HINT: to retain differential backups indefinitely (without warning), set option 'repo1-retention-diff'"
@ -349,8 +348,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-archive=3");
strLstAddZ(argList, "--repo1-retention-diff=2");
strLstAddZ(argList, "--repo1-retention-full=1");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdExpire, argList), "load config with success");
HRN_CFG_LOAD(cfgCmdExpire, argList);
argList = strLstNew();
strLstAddZ(argList, "--stanza=db");
@ -358,8 +356,8 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "--repo1-retention-full-type=time");
harnessLogLevelSet(logLevelWarn);
HRN_CFG_LOAD(cfgCmdExpire, argList, .comment = "load config: retention-full-type=time, retention-full is set");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdExpire, argList), "load config: retention-full-type=time, retention-full is set");
TEST_RESULT_BOOL(cfgOptionTest(cfgOptRepoRetentionArchive), false, " repo1-retention-archive not set");
// -------------------------------------------------------------------------------------------------------------------------
@ -377,7 +375,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepo, "2");
TEST_ERROR(
harnessCfgLoad(cfgCmdArchiveGet, argList), OptionInvalidValueError,
hrnCfgLoadP(cfgCmdArchiveGet, argList), OptionInvalidValueError,
"'bogus.bucket' is not valid for option 'repo2-s3-bucket'"
"\nHINT: RFC-2818 forbids dots in wildcard matches."
"\nHINT: TLS/SSL verification cannot proceed with this bucket name."
@ -399,8 +397,8 @@ testRun(void)
strLstAddZ(argList, "--repo1-s3-endpoint=endpoint");
strLstAddZ(argList, "--no-repo1-s3-verify-ssl");
strLstAddZ(argList, "--repo1-path=/repo");
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .comment = "invalid bucket with no verification");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdArchiveGet, argList), "invalid bucket with no verification");
TEST_RESULT_STR_Z(cfgOptionStr(cfgOptRepoS3Bucket), "bogus.bucket", " check bucket value");
// Valid bucket name
@ -412,8 +410,8 @@ testRun(void)
strLstAddZ(argList, "--repo1-s3-region=region");
strLstAddZ(argList, "--repo1-s3-endpoint=endpoint");
strLstAddZ(argList, "--repo1-path=/repo");
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .comment = "valid bucket name");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdArchiveGet, argList), "valid bucket name");
TEST_RESULT_STR_Z(cfgOptionStr(cfgOptRepoS3Bucket), "cool-bucket", " check bucket value");
TEST_RESULT_BOOL(cfgOptionValid(cfgOptCompress), false, " compress is not valid");
@ -426,8 +424,8 @@ testRun(void)
argList = strLstNew();
strLstAddZ(argList, "--" CFGOPT_STANZA "=db");
strLstAddZ(argList, "--no-" CFGOPT_COMPRESS);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdArchivePush, argList), "load config");
TEST_RESULT_STR_Z(cfgOptionStr(cfgOptCompressType), "none", " compress-type=none");
TEST_RESULT_INT(cfgOptionInt(cfgOptCompressLevel), 0, " compress-level=0");
TEST_RESULT_BOOL(cfgOptionValid(cfgOptCompress), false, " compress is not valid");
@ -439,8 +437,8 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_STANZA "=db");
strLstAddZ(argList, "--" CFGOPT_COMPRESS);
strLstAddZ(argList, "--" CFGOPT_COMPRESS_LEVEL "=9");
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdArchivePush, argList), "load config");
TEST_RESULT_STR_Z(cfgOptionStr(cfgOptCompressType), "gz", " compress-type=gz");
TEST_RESULT_INT(cfgOptionInt(cfgOptCompressLevel), 9, " compress-level=9");
TEST_RESULT_BOOL(cfgOptionValid(cfgOptCompress), false, " compress is not valid");
@ -452,8 +450,8 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_STANZA "=db");
strLstAddZ(argList, "--no-" CFGOPT_COMPRESS);
strLstAddZ(argList, "--" CFGOPT_COMPRESS_TYPE "=gz");
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdArchivePush, argList), "load config");
TEST_RESULT_STR_Z(cfgOptionStr(cfgOptCompressType), "gz", " compress-type=gz");
TEST_RESULT_INT(cfgOptionInt(cfgOptCompressLevel), 6, " compress-level=6");
TEST_RESULT_BOOL(cfgOptionValid(cfgOptCompress), false, " compress is not valid");

8
test/src/module/config/parseTest.c
View File

@ -1635,14 +1635,14 @@ testRun(void)
argList = strLstNew();
hrnCfgArgRawZ(argList, cfgOptLogLevelFile, "detail");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdInfo, argList), "info command");
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_RESULT_BOOL(cfgLogFile(), true, " check logging");
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("version command does not do file logging");
TEST_RESULT_VOID(harnessCfgLoad(cfgCmdVersion, strLstNew()), "version command");
HRN_CFG_LOAD(cfgCmdVersion, strLstNew());
TEST_RESULT_BOOL(cfgLogFile(), false, " check logging");
// -------------------------------------------------------------------------------------------------------------------------
@ -1652,7 +1652,7 @@ testRun(void)
// hrnCfgArgRawZ(argList, cfgOptStanza, "test");
// hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 2, "/pg2");
// hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 8, "/pg8");
// TEST_RESULT_VOID(harnessCfgLoad(cfgCmdCheck, argList), "check command");
// HRN_CFG_LOAD(cfgCmdCheck, argList);
//
// TEST_RESULT_STR_Z(cfgOptionIdxStr(cfgOptPgPath, 0), "/pg2", "check pg1-path");
// TEST_RESULT_STR_Z(cfgOptionIdxStr(cfgOptPgPath, cfgOptionKeyToIdx(cfgOptPgPath, 8)), "/pg8", "check pg8-path");
@ -1666,7 +1666,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 8, "/pg8");
hrnCfgArgRawZ(argList, cfgOptPg, "4");
TEST_ERROR(
harnessCfgLoadRole(cfgCmdBackup, cfgCmdRoleLocal, argList), OptionInvalidValueError,
hrnCfgLoadP(cfgCmdBackup, argList, .role = cfgCmdRoleLocal), OptionInvalidValueError,
"key '4' is not valid for 'pg' option");
}

2
test/src/module/config/protocolTest.c
View File

@ -34,7 +34,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--repo1-host=repo-host");
strLstAddZ(argList, "--repo1-host-user=repo-host-user");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
ProtocolServer *server = protocolServerNew(STRDEF("test"), STRDEF("config"), read, write);

12
test/src/module/db/dbTest.c
View File

@ -75,7 +75,7 @@ testRun(void)
strLstAddZ(argList, "--pg1-database=testdb");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypePg);
strLstAddZ(argList, "--process=0");
harnessCfgLoadRole(cfgCmdBackup, cfgCmdRoleRemote, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList, .role = cfgCmdRoleRemote);
// Set script
harnessPqScriptSet((HarnessPq [])
@ -149,7 +149,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "--pg1-path=/pg1");
strLstAddZ(argList, "--pg1-database=backupdb");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("error when unable to select any pg_settings");
@ -365,7 +365,7 @@ testRun(void)
strLstAddZ(argList, "--pg1-path=/pg1");
strLstAddZ(argList, "--pg2-path=/pg2");
strLstAddZ(argList, "--pg2-port=5433");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
harnessPqScriptSet((HarnessPq [])
{
@ -504,7 +504,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "--pg1-path=/path/to/pg");
strLstAddZ(argList, "--pg1-user=bob");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
harnessPqScriptSet((HarnessPq [])
{
@ -581,7 +581,7 @@ testRun(void)
strLstAddZ(argList, "--pg1-path=/path/to/pg1");
strLstAddZ(argList, "--pg8-path=/path/to/pg2");
strLstAddZ(argList, "--pg8-port=5433");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
harnessPqScriptSet((HarnessPq [])
{
@ -646,7 +646,7 @@ testRun(void)
strLstAddZ(argList, "--pg5-path=/path/to/pg5");
strLstAddZ(argList, "--pg8-path=/path/to/pg8");
strLstAddZ(argList, "--pg8-port=5434");
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
harnessPqScriptSet((HarnessPq [])
{

2
test/src/module/info/infoBackupTest.c
View File

@ -451,7 +451,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=db");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--repo-path=" TEST_PATH);
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
// Create manifest for upgrade db (id=2), save to disk
manifestContent = harnessInfoChecksumZ

2
test/src/module/performance/storageTest.c
View File

@ -156,7 +156,7 @@ testRun(void)
strLstAddZ(argList, "--" CFGOPT_STANZA "=test");
strLstAddZ(argList, "--" CFGOPT_PROCESS "=0");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
harnessCfgLoadRole(cfgCmdArchivePush, cfgCmdRoleRemote, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote);
// Create a driver to test remote performance of storageInfoList() and inject it into storageRepo()
StorageTestPerfInfoList driver =

74
test/src/module/protocol/protocolTest.c
View File

@ -155,15 +155,13 @@ testRun(void)
if (testBegin("repoIsLocal() and pgIsLocal()"))
{
StringList *argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--repo1-path=/repo-local");
strLstAddZ(argList, "--repo4-path=/remote-host-new");
strLstAddZ(argList, "--repo4-host=remote-host-new");
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
strLstAddZ(argList, "archive-get");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .noStd = true);
TEST_RESULT_BOOL(repoIsLocal(0), true, "repo is local");
TEST_RESULT_VOID(repoIsLocalVerify(), " local verified");
@ -174,12 +172,10 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--repo1-host=remote-host");
strLstAddZ(argList, "archive-get");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .noStd = true);
TEST_RESULT_BOOL(repoIsLocal(0), false, "repo is remote");
TEST_ERROR(repoIsLocalVerify(), HostInvalidError, "archive-get command must be run on the repository host");
@ -188,12 +184,10 @@ testRun(void)
TEST_TITLE("pg1 is local");
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--pg1-path=/path/to");
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "backup");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdBackup, argList, .noStd = true);
TEST_RESULT_BOOL(pgIsLocal(0), true, "pg is local");
TEST_RESULT_VOID(pgIsLocalVerify(), "verify pg is local");
@ -202,12 +196,10 @@ testRun(void)
TEST_TITLE("pg1 is not local");
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--" CFGOPT_STANZA "=test1");
hrnCfgArgRawZ(argList, cfgOptPgHost, "test1");
strLstAddZ(argList, "--pg1-path=/path/to");
strLstAddZ(argList, "restore");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdRestore, argList, .noStd = true);
TEST_RESULT_BOOL(pgIsLocal(0), false, "pg1 is remote");
TEST_ERROR(pgIsLocalVerify(), HostInvalidError, "restore command must be run on the PostgreSQL host");
@ -216,7 +208,6 @@ testRun(void)
TEST_TITLE("pg7 is not local");
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/bogus");
strLstAddZ(argList, "--pg7-path=/path/to");
@ -224,8 +215,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPg, "7");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypePg);
strLstAddZ(argList, "--process=0");
strLstAddZ(argList, CFGCMD_BACKUP ":" CONFIG_COMMAND_ROLE_LOCAL);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdBackup, argList, .role = cfgCmdRoleLocal, .noStd = true);
TEST_RESULT_BOOL(pgIsLocal(1), false, "pg7 is remote");
}
@ -255,11 +245,9 @@ testRun(void)
if (testBegin("protocolLocalParam()"))
{
StringList *argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "archive-get");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .noStd = true);
TEST_RESULT_STRLST_Z(
protocolLocalParam(protocolStorageTypeRepo, 0, 0),
@ -269,13 +257,11 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--pg1-path=/pg");
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "--log-subprocess");
strLstAddZ(argList, "backup");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdBackup, argList, .noStd = true);
TEST_RESULT_STRLST_Z(
protocolLocalParam(protocolStorageTypePg, 0, 1),
@ -290,7 +276,6 @@ testRun(void)
storagePutP(storageNewWriteP(storageTest, STRDEF("pgbackrest.conf")), bufNew(0));
StringList *argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--repo1-host=repo-host");
@ -299,19 +284,17 @@ testRun(void)
strLstAddZ(argList, "--config=" TEST_PATH "/pgbackrest.conf");
strLstAddZ(argList, "--config-include-path=" TEST_PATH);
strLstAddZ(argList, "--config-path=" TEST_PATH);
strLstAddZ(argList, "archive-get");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .noStd = true);
TEST_RESULT_STRLST_Z(
protocolRemoteParamSsh(protocolStorageTypeRepo, 0),
"-o\nLogLevel=error\n-o\nCompression=no\n-o\nPasswordAuthentication=no\nrepo-host-user@repo-host\n"
"pgbackrest --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
TEST_PROJECT_EXE " --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
" --pg1-path=/path/to/pg --process=0 --remote-type=repo --repo=1 --stanza=test1 archive-get:remote\n",
"remote protocol params");
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--log-subprocess");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/unused"); // Will be passed to remote (required)
@ -322,56 +305,50 @@ testRun(void)
strLstAddZ(argList, "--repo1-host-config-include-path=/path/include");
strLstAddZ(argList, "--repo1-host-config-path=/path/config");
strLstAddZ(argList, "--repo1-host-user=repo-host-user");
strLstAddZ(argList, CFGCMD_CHECK);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdCheck, argList, .noStd = true);
TEST_RESULT_STRLST_Z(
protocolRemoteParamSsh(protocolStorageTypeRepo, 0),
"-o\nLogLevel=error\n-o\nCompression=no\n-o\nPasswordAuthentication=no\n-p\n444\nrepo-host-user@repo-host\n"
"pgbackrest --config=/path/pgbackrest.conf --config-include-path=/path/include --config-path=/path/config"
TEST_PROJECT_EXE " --config=/path/pgbackrest.conf --config-include-path=/path/include --config-path=/path/config"
" --exec-id=1-test --log-level-console=off --log-level-file=info --log-level-stderr=error --log-subprocess"
" --pg1-path=/unused --process=0 --remote-type=repo --repo=1 --stanza=test1 check:remote\n",
"remote protocol params with replacements");
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--process=3");
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
strLstAddZ(argList, "--repo1-host=repo-host");
strLstAddZ(argList, CFGCMD_ARCHIVE_GET ":" CONFIG_COMMAND_ROLE_LOCAL);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleLocal, .noStd = true);
TEST_RESULT_STRLST_Z(
protocolRemoteParamSsh(protocolStorageTypeRepo, 0),
"-o\nLogLevel=error\n-o\nCompression=no\n-o\nPasswordAuthentication=no\npgbackrest@repo-host\n"
"pgbackrest --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
TEST_PROJECT_EXE " --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
" --pg1-path=/path/to/pg --process=3 --remote-type=repo --repo=1 --stanza=test1 archive-get:remote\n",
"remote protocol params for backup local");
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--pg1-path=/path/to/1");
strLstAddZ(argList, "--pg1-host=pg1-host");
strLstAddZ(argList, "--repo1-retention-full=1");
strLstAddZ(argList, "backup");
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdBackup, argList, .noStd = true);
TEST_RESULT_STRLST_Z(
protocolRemoteParamSsh(protocolStorageTypePg, 0),
"-o\nLogLevel=error\n-o\nCompression=no\n-o\nPasswordAuthentication=no\npostgres@pg1-host\n"
"pgbackrest --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
TEST_PROJECT_EXE " --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
" --pg1-path=/path/to/1 --process=0 --remote-type=pg --stanza=test1 backup:remote\n",
"remote protocol params for db backup");
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--process=4");
hrnCfgArgRawZ(argList, cfgOptPg, "2");
@ -381,19 +358,17 @@ testRun(void)
strLstAddZ(argList, "--pg2-path=/path/to/2");
strLstAddZ(argList, "--pg2-host=pg2-host");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypePg);
strLstAddZ(argList, CFGCMD_BACKUP ":" CONFIG_COMMAND_ROLE_LOCAL);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdBackup, argList, .role = cfgCmdRoleLocal, .noStd = true);
TEST_RESULT_STRLST_Z(
protocolRemoteParamSsh(protocolStorageTypePg, 1),
"-o\nLogLevel=error\n-o\nCompression=no\n-o\nPasswordAuthentication=no\npostgres@pg2-host\n"
"pgbackrest --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
TEST_PROJECT_EXE " --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
" --pg1-path=/path/to/2 --process=4 --remote-type=pg --stanza=test1 backup:remote\n",
"remote protocol params for db local");
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "pgbackrest");
strLstAddZ(argList, "--stanza=test1");
strLstAddZ(argList, "--process=4");
hrnCfgArgRawZ(argList, cfgOptPg, "3");
@ -403,13 +378,12 @@ testRun(void)
strLstAddZ(argList, "--pg3-socket-path=/socket3");
strLstAddZ(argList, "--pg3-port=3333");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypePg);
strLstAddZ(argList, CFGCMD_BACKUP ":" CONFIG_COMMAND_ROLE_LOCAL);
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
HRN_CFG_LOAD(cfgCmdBackup, argList, .role = cfgCmdRoleLocal, .noStd = true);
TEST_RESULT_STRLST_Z(
protocolRemoteParamSsh(protocolStorageTypePg, 1),
"-o\nLogLevel=error\n-o\nCompression=no\n-o\nPasswordAuthentication=no\npostgres@pg3-host\n"
"pgbackrest --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
TEST_PROJECT_EXE " --exec-id=1-test --log-level-console=off --log-level-file=off --log-level-stderr=error"
" --pg1-path=/path/to/3 --pg1-port=3333 --pg1-socket-path=/socket3 --process=4 --remote-type=pg --stanza=test1"
" backup:remote\n",
"remote protocol params for db local");
@ -995,7 +969,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-host=localhost");
strLstAddZ(argList, "--repo1-host-user=" TEST_USER);
strLstAddZ(argList, "--repo1-path=" TEST_PATH);
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
ProtocolClient *client = NULL;
@ -1027,7 +1001,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-path=" TEST_PATH);
strLstAddZ(argList, "--process=999");
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypePg);
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleLocal, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleLocal);
TEST_RESULT_STR_Z(cfgOptionStr(cfgOptRepoCipherPass), "acbd", "check cipher pass before");
TEST_ASSIGN(client, protocolRemoteGet(protocolStorageTypeRepo, 0), "get remote protocol");
@ -1059,7 +1033,7 @@ testRun(void)
strLstAddZ(argList, "--repo2-host=localhost");
strLstAddZ(argList, "--repo2-host-user=" TEST_USER);
strLstAddZ(argList, "--repo2-path=" TEST_PATH "2");
harnessCfgLoad(cfgCmdCheck, argList);
HRN_CFG_LOAD(cfgCmdCheck, argList);
TEST_RESULT_PTR(cfgOptionIdxStrNull(cfgOptRepoCipherPass, 0), NULL, "check repo1 cipher pass before");
TEST_ASSIGN(client, protocolRemoteGet(protocolStorageTypeRepo, 0), "get repo1 remote protocol");
@ -1080,7 +1054,7 @@ testRun(void)
strLstAddZ(argList, "--pg1-host=localhost");
strLstAddZ(argList, "--pg1-host-user=" TEST_USER);
strLstAddZ(argList, "--pg1-path=" TEST_PATH);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
TEST_ASSIGN(client, protocolRemoteGet(protocolStorageTypePg, 0), "get remote protocol");
@ -1093,7 +1067,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--protocol-timeout=10");
strLstAddZ(argList, "--process-max=2");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
TEST_ASSIGN(client, protocolLocalGet(protocolStorageTypeRepo, 0, 1), "get local protocol");
TEST_RESULT_PTR(protocolLocalGet(protocolStorageTypeRepo, 0, 1), client, "get local cached protocol");

6
test/src/module/storage/azureTest.c
View File

@ -183,7 +183,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoAzureContainer, TEST_CONTAINER);
hrnCfgEnvRawZ(cfgOptRepoAzureAccount, TEST_ACCOUNT);
hrnCfgEnvRawZ(cfgOptRepoAzureKey, TEST_KEY_SHARED);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
Storage *storage = NULL;
TEST_ASSIGN(storage, storageRepoGet(0, false), "get repo storage");
@ -293,7 +293,7 @@ testRun(void)
hrnCfgArgRawBool(argList, cfgOptRepoStorageVerifyTls, TEST_IN_CONTAINER);
hrnCfgEnvRawZ(cfgOptRepoAzureAccount, TEST_ACCOUNT);
hrnCfgEnvRawZ(cfgOptRepoAzureKey, TEST_KEY_SHARED);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
Storage *storage = NULL;
TEST_ASSIGN(storage, storageRepoGet(0, true), "get repo storage");
@ -731,7 +731,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRepoAzureKeyType, storageAzureKeyTypeSas);
hrnCfgEnvRawZ(cfgOptRepoAzureKey, TEST_KEY_SAS);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
TEST_ASSIGN(storage, storageRepoGet(0, true), "get repo storage");

2
test/src/module/storage/cifsTest.c
View File

@ -20,7 +20,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--repo1-type=cifs");
strLstAddZ(argList, "--repo1-path=" TEST_PATH);
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
const Storage *storage = NULL;
TEST_ASSIGN(storage, storageRepoGet(0, true), "get cifs repo storage");

8
test/src/module/storage/gcsTest.c
View File

@ -205,7 +205,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoGcsBucket, TEST_BUCKET);
hrnCfgArgRawStrId(argList, cfgOptRepoGcsKeyType, storageGcsKeyTypeToken);
hrnCfgEnvRawZ(cfgOptRepoGcsKey, TEST_TOKEN);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
Storage *storage = NULL;
TEST_ASSIGN(storage, storageRepoGet(0, false), "get repo storage");
@ -329,7 +329,7 @@ testRun(void)
hrnCfgArgRawFmt(argList, cfgOptRepoGcsEndpoint, "%s:%u", strZ(hrnServerHost()), testPort);
hrnCfgArgRawBool(argList, cfgOptRepoStorageVerifyTls, TEST_IN_CONTAINER);
hrnCfgEnvRawZ(cfgOptRepoGcsKey, TEST_KEY_FILE);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
hrnCfgEnvRemoveRaw(cfgOptRepoGcsKey);
Storage *storage = NULL;
@ -425,7 +425,7 @@ testRun(void)
StringList *argListAuto = strLstDup(argList);
hrnCfgArgRawStrId(argListAuto, cfgOptRepoGcsKeyType, storageGcsKeyTypeAuto);
harnessCfgLoad(cfgCmdArchivePush, argListAuto);
HRN_CFG_LOAD(cfgCmdArchivePush, argListAuto);
TEST_ASSIGN(storage, storageRepoGet(0, true), "get repo storage");
@ -885,7 +885,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoGcsKeyType, "token");
hrnCfgEnvRawZ(cfgOptRepoGcsKey, TEST_TOKEN);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
TEST_ASSIGN(storage, storageRepoGet(0, true), "get repo storage");

8
test/src/module/storage/posixTest.c
View File

@ -1149,7 +1149,7 @@ testRun(void)
strLstAddZ(argList, "--stanza=db");
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
strLstAddZ(argList, "--repo-path=" TEST_PATH);
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
const Storage *storage = NULL;
@ -1184,7 +1184,7 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
argList = strLstNew();
strLstAddZ(argList, "--repo-path=" TEST_PATH);
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_ASSIGN(storage, storageRepo(), "new repo storage no stanza");
TEST_RESULT_STR(storageHelper.stanza, NULL, "stanza NULL");
@ -1220,7 +1220,7 @@ testRun(void)
strLstAddZ(argList, "--spool-path=" TEST_PATH);
strLstAddZ(argList, "--pg1-path=" TEST_PATH "/db");
strLstAddZ(argList, "--pg2-path=" TEST_PATH "/db2");
harnessCfgLoad(cfgCmdArchiveGet, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
TEST_RESULT_PTR(storageHelper.storageSpool, NULL, "storage not cached");
TEST_ASSIGN(storage, storageSpool(), "new storage");
@ -1288,7 +1288,7 @@ testRun(void)
argList = strLstNew();
strLstAddZ(argList, "--repo-path=" TEST_PATH);
harnessCfgLoad(cfgCmdInfo, argList);
HRN_CFG_LOAD(cfgCmdInfo, argList);
TEST_ERROR(storageSpool(), AssertError, "stanza cannot be NULL for this storage object");
TEST_ERROR(storageSpoolWrite(), AssertError, "stanza cannot be NULL for this storage object");

4
test/src/module/storage/remoteTest.c
View File

@ -42,7 +42,7 @@ testRun(void)
strLstAddZ(argList, "--repo1-host-user=" TEST_USER);
strLstAddZ(argList, "--repo1-path=" TEST_PATH "/repo");
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
harnessCfgLoadRole(cfgCmdArchiveGet, cfgCmdRoleLocal, argList);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleLocal);
const Storage *const storageRepoWrite = storageRepoGet(0, true);
const Storage *const storageRepo = storageRepoGet(0, false);
@ -57,7 +57,7 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptPgHostUser, 2, TEST_USER);
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 2, TEST_PATH_PG "2");
hrnCfgArgRawZ(argList, cfgOptRepoPath, TEST_PATH_REPO);
harnessCfgLoad(cfgCmdBackup, argList);
HRN_CFG_LOAD(cfgCmdBackup, argList);
const Storage *const storagePgWrite = storagePgGet(1, true);

10
test/src/module/storage/s3Test.c
View File

@ -250,7 +250,7 @@ testRun(void)
TEST_TITLE("config without token");
StringList *argList = strLstDup(commonArgList);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
StorageS3 *driver = (StorageS3 *)storageDriver(storageRepoGet(0, false));
@ -321,7 +321,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepoStorageCaPath, "/path/to/cert");
hrnCfgArgRawZ(argList, cfgOptRepoStorageCaFile, HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX ".crt");
hrnCfgEnvRaw(cfgOptRepoS3Token, securityToken);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
driver = (StorageS3 *)storageDriver(storageRepoGet(0, false));
@ -385,7 +385,7 @@ testRun(void)
StringList *argList = strLstDup(commonArgList);
hrnCfgArgRawFmt(argList, cfgOptRepoStorageHost, "%s:%u", strZ(host), port);
hrnCfgEnvRaw(cfgOptRepoS3Token, securityToken);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
Storage *s3 = storageRepoGet(0, true);
StorageS3 *driver = (StorageS3 *)storageDriver(s3);
@ -443,7 +443,7 @@ testRun(void)
hrnCfgArgRawFmt(argList, cfgOptRepoStorageHost, "%s:%u", strZ(host), port);
hrnCfgArgRaw(argList, cfgOptRepoS3Role, credRole);
hrnCfgArgRawStrId(argList, cfgOptRepoS3KeyType, storageS3KeyTypeAuto);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
s3 = storageRepoGet(0, true);
driver = (StorageS3 *)storageDriver(s3);
@ -1017,7 +1017,7 @@ testRun(void)
hrnCfgArgRaw(argList, cfgOptRepoStorageHost, host);
hrnCfgArgRawFmt(argList, cfgOptRepoStoragePort, "%u", port);
hrnCfgEnvRemoveRaw(cfgOptRepoS3Token);
harnessCfgLoad(cfgCmdArchivePush, argList);
HRN_CFG_LOAD(cfgCmdArchivePush, argList);
s3 = storageRepoGet(0, true);
driver = (StorageS3 *)storageDriver(s3);