db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-12-01 22:30:09 +02:00
Code Issues Releases Activity

Config parsing no longer implemented in Perl.

Browse Source 
Options are passed to Perl as JSON from the C process.
This commit is contained in:
David Steele
2018-01-28 21:37:09 -05:00
parent f0ef1dee05
commit a91a648019
28 changed files with 639 additions and 1596 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
test/lib/pgBackRestTest/Common/DefineTest.pm
View File

@@ -470,18 +470,6 @@ my $oTestDef =
'config/load' => TESTDEF_COVERAGE_FULL,
},
},
{
&TESTDEF_NAME => 'unit',
&TESTDEF_TOTAL => 1,
},
{
&TESTDEF_NAME => 'option',
&TESTDEF_TOTAL => 34,
},
{
&TESTDEF_NAME => 'config-perl',
&TESTDEF_TOTAL => 25,
}
]
},
# Storage tests

4
test/lib/pgBackRestTest/Common/JobTest.pm
View File

@@ -153,7 +153,7 @@ sub run
# Create gcov directory
my $bGCovExists = true;
if (!$self->{oStorageTest}->pathExists($self->{strGCovPath}))
if ($self->{oTest}->{&TEST_C} && !$self->{oStorageTest}->pathExists($self->{strGCovPath}))
{
$self->{oStorageTest}->pathCreate($self->{strGCovPath}, {strMode => '0770'});
$bGCovExists = false;
@@ -165,7 +165,7 @@ sub run
'docker run -itd -h ' . $self->{oTest}->{&TEST_VM} . "-test --name=${strImage}" .
" -v $self->{strCoveragePath}:$self->{strCoveragePath} " .
" -v ${strHostTestPath}:${strVmTestPath}" .
" -v $self->{strGCovPath}:$self->{strGCovPath}" .
($self->{oTest}->{&TEST_C} ? " -v $self->{strGCovPath}:$self->{strGCovPath}" : '') .
" -v $self->{strBackRestBase}:$self->{strBackRestBase} " .
containerRepo() . ':' . $self->{oTest}->{&TEST_VM} .
"-test",

340
test/lib/pgBackRestTest/Env/ConfigEnvTest.pm
View File

@@ -12,10 +12,12 @@ use warnings FATAL => qw(all);
use Carp qw(confess);
use English '-no_match_vars';
use Getopt::Long qw(GetOptions);
use pgBackRest::Common::Exception;
use pgBackRest::Common::Log;
use pgBackRest::Config::Config;
use pgBackRestBuild::Config::Data;
use pgBackRest::Version;
use constant CONFIGENVTEST => 'ConfigEnvTest';
@@ -101,13 +103,347 @@ sub commandTestWrite
return @szyParam;
}
####################################################################################################################################
# testOptionValidate
#
# Make sure the command-line options are valid based on the command.
####################################################################################################################################
sub testOptionValidate
{
my $iCommandId = shift;
# Build hash with all valid command-line options
my @stryOptionAllow;
for (my $iOptionId = 0; $iOptionId < cfgOptionTotal(); $iOptionId++)
{
my $strOption = cfgOptionName($iOptionId);
if (cfgDefOptionType($iOptionId) == CFGDEF_TYPE_HASH || cfgDefOptionType($iOptionId) == CFGDEF_TYPE_LIST)
{
$strOption .= '=s@';
}
elsif (cfgDefOptionType($iOptionId) != CFGDEF_TYPE_BOOLEAN)
{
$strOption .= '=s';
}
push(@stryOptionAllow, $strOption);
# Check if the option can be negated
if (cfgDefOptionNegate($iOptionId))
{
push(@stryOptionAllow, 'no-' . cfgOptionName($iOptionId));
}
}
# Get command-line options
my $oOptionTest = {};
# Parse command line options
if (!GetOptions($oOptionTest, @stryOptionAllow))
{
confess &log(ASSERT, "error parsing command line");
}
# Store results of validation
my $rhOption = {};
# Keep track of unresolved dependencies
my $bDependUnresolved = true;
my %oOptionResolved;
# Loop through all possible options
while ($bDependUnresolved)
{
# Assume that all dependencies will be resolved in this loop
$bDependUnresolved = false;
for (my $iOptionId = 0; $iOptionId < cfgOptionTotal(); $iOptionId++)
{
my $strOption = cfgOptionName($iOptionId);
# Skip the option if it has been resolved in a prior loop
if (defined($oOptionResolved{$strOption}))
{
next;
}
# Determine if an option is valid for a command
$rhOption->{$strOption}{valid} = cfgDefOptionValid($iCommandId, $iOptionId);
if (!$rhOption->{$strOption}{valid})
{
$oOptionResolved{$strOption} = true;
next;
}
# Store the option value
my $strValue = $oOptionTest->{$strOption};
# Check to see if an option can be negated. Make sure that it is not set and negated at the same time.
$rhOption->{$strOption}{negate} = false;
if (cfgDefOptionNegate($iOptionId))
{
$rhOption->{$strOption}{negate} = defined($$oOptionTest{'no-' . $strOption});
if ($rhOption->{$strOption}{negate} && defined($strValue))
{
confess &log(ERROR, "option '${strOption}' cannot be both set and negated", ERROR_OPTION_NEGATE);
}
if ($rhOption->{$strOption}{negate} && cfgDefOptionType($iOptionId) eq CFGDEF_TYPE_BOOLEAN)
{
$strValue = false;
}
}
# Check dependency for the command then for the option
my $bDependResolved = true;
my $strDependOption;
my $strDependValue;
my $strDependType;
if (cfgDefOptionDepend($iCommandId, $iOptionId))
{
# Check if the depend option has a value
my $iDependOptionId = cfgDefOptionDependOption($iCommandId, $iOptionId);
$strDependOption = cfgOptionName($iDependOptionId);
$strDependValue = $rhOption->{$strDependOption}{value};
# Make sure the depend option has been resolved, otherwise skip this option for now
if (!defined($oOptionResolved{$strDependOption}))
{
$bDependUnresolved = true;
next;
}
if (!defined($strDependValue))
{
$bDependResolved = false;
$strDependType = 'source';
}
# If a depend value exists, make sure the option value matches
if ($bDependResolved && cfgDefOptionDependValueTotal($iCommandId, $iOptionId) == 1 &&
cfgDefOptionDependValue($iCommandId, $iOptionId, 0) ne $strDependValue)
{
$bDependResolved = false;
$strDependType = 'value';
}
# If a depend list exists, make sure the value is in the list
if ($bDependResolved && cfgDefOptionDependValueTotal($iCommandId, $iOptionId) > 1 &&
!cfgDefOptionDependValueValid($iCommandId, $iOptionId, $strDependValue))
{
$bDependResolved = false;
$strDependType = 'list';
}
}
if (cfgDefOptionDepend($iCommandId, $iOptionId) && !$bDependResolved && defined($strValue))
{
my $strError = "option '${strOption}' not valid without option ";
my $iDependOptionId = cfgOptionId($strDependOption);
if ($strDependType eq 'source')
{
confess &log(ERROR, "${strError}'${strDependOption}'", ERROR_OPTION_INVALID);
}
# If a depend value exists, make sure the option value matches
if ($strDependType eq 'value')
{
if (cfgDefOptionType($iDependOptionId) eq CFGDEF_TYPE_BOOLEAN)
{
$strError .=
"'" . (cfgDefOptionDependValue($iCommandId, $iOptionId, 0) ? '' : 'no-') . "${strDependOption}'";
}
else
{
$strError .= "'${strDependOption}' = '" . cfgDefOptionDependValue($iCommandId, $iOptionId, 0) . "'";
}
confess &log(ERROR, $strError, ERROR_OPTION_INVALID);
}
$strError .= "'${strDependOption}'";
# If a depend list exists, make sure the value is in the list
if ($strDependType eq 'list')
{
my @oyValue;
for (my $iValueId = 0; $iValueId < cfgDefOptionDependValueTotal($iCommandId, $iOptionId); $iValueId++)
{
push(@oyValue, "'" . cfgDefOptionDependValue($iCommandId, $iOptionId, $iValueId) . "'");
}
$strError .= @oyValue == 1 ? " = $oyValue[0]" : " in (" . join(", ", @oyValue) . ")";
confess &log(ERROR, $strError, ERROR_OPTION_INVALID);
}
}
# Is the option defined?
if (defined($strValue))
{
# Check that floats and integers are valid
if (cfgDefOptionType($iOptionId) eq CFGDEF_TYPE_INTEGER ||
cfgDefOptionType($iOptionId) eq CFGDEF_TYPE_FLOAT)
{
# Test that the string is a valid float or integer by adding 1 to it. It's pretty hokey but it works and it
# beats requiring Scalar::Util::Numeric to do it properly.
my $bError = false;
eval
{
my $strTest = $strValue + 1;
return true;
}
or do
{
$bError = true;
};
# Check that integers are really integers
if (!$bError && cfgDefOptionType($iOptionId) eq CFGDEF_TYPE_INTEGER &&
(int($strValue) . 'S') ne ($strValue . 'S'))
{
$bError = true;
}
# Error if the value did not pass tests
!$bError
or confess &log(ERROR, "'${strValue}' is not valid for '${strOption}' option", ERROR_OPTION_INVALID_VALUE);
}
# Process an allow list for the command then for the option
if (cfgDefOptionAllowList($iCommandId, $iOptionId) &&
!cfgDefOptionAllowListValueValid($iCommandId, $iOptionId, $strValue))
{
confess &log(ERROR, "'${strValue}' is not valid for '${strOption}' option", ERROR_OPTION_INVALID_VALUE);
}
# Process an allow range for the command then for the option
if (cfgDefOptionAllowRange($iCommandId, $iOptionId) &&
($strValue < cfgDefOptionAllowRangeMin($iCommandId, $iOptionId) ||
$strValue > cfgDefOptionAllowRangeMax($iCommandId, $iOptionId)))
{
confess &log(ERROR, "'${strValue}' is not valid for '${strOption}' option", ERROR_OPTION_INVALID_RANGE);
}
# Set option value
if (ref($strValue) eq 'ARRAY' &&
(cfgDefOptionType($iOptionId) eq CFGDEF_TYPE_HASH || cfgDefOptionType($iOptionId) eq CFGDEF_TYPE_LIST))
{
foreach my $strItem (@{$strValue})
{
my $strKey;
my $strValue;
# If the keys are expected to have values
if (cfgDefOptionType($iOptionId) eq CFGDEF_TYPE_HASH)
{
# Check for = and make sure there is a least one character on each side
my $iEqualPos = index($strItem, '=');
if ($iEqualPos < 1 || length($strItem) <= $iEqualPos + 1)
{
confess &log(ERROR, "'${strItem}' not valid key/value for '${strOption}' option",
ERROR_OPTION_INVALID_PAIR);
}
$strKey = substr($strItem, 0, $iEqualPos);
$strValue = substr($strItem, $iEqualPos + 1);
}
# Else no values are expected so set value to true
else
{
$strKey = $strItem;
$strValue = true;
}
# Check that the key has not already been set
if (defined($rhOption->{$strOption}{$strKey}{value}))
{
confess &log(ERROR, "'${$strItem}' already defined for '${strOption}' option",
ERROR_OPTION_DUPLICATE_KEY);
}
# Set key/value
$rhOption->{$strOption}{value}{$strKey} = $strValue;
}
}
else
{
$rhOption->{$strOption}{value} = $strValue;
}
# If not config sourced then it must be a param
if (!defined($rhOption->{$strOption}{source}))
{
$rhOption->{$strOption}{source} = CFGDEF_SOURCE_PARAM;
}
}
# Else try to set a default
elsif ($bDependResolved)
{
# Source is default for this option
$rhOption->{$strOption}{source} = CFGDEF_SOURCE_DEFAULT;
# Check for default in command then option
my $strDefault = cfgDefOptionDefault($iCommandId, $iOptionId);
# If default is defined
if (defined($strDefault))
{
# Only set default if dependency is resolved
$rhOption->{$strOption}{value} = $strDefault if !$rhOption->{$strOption}{negate};
}
# Else check required
elsif (cfgDefOptionRequired($iCommandId, $iOptionId))
{
confess &log(ERROR,
cfgCommandName($iCommandId) . " command requires option: ${strOption}" .
ERROR_OPTION_REQUIRED);
}
}
$oOptionResolved{$strOption} = true;
}
}
# Make sure all options specified on the command line are valid
foreach my $strOption (sort(keys(%{$oOptionTest})))
{
# Strip "no-" off the option
$strOption = $strOption =~ /^no\-/ ? substr($strOption, 3) : $strOption;
if (!$rhOption->{$strOption}{valid})
{
confess &log(
ERROR, "option '${strOption}' not valid for command '" . cfgCommandName($iCommandId) . "'", ERROR_OPTION_COMMAND);
}
}
return $rhOption;
}
####################################################################################################################################
# Load the configuration
####################################################################################################################################
sub configTestLoad
{
my $self = shift;
my $iCommandId = shift;
@ARGV = $self->commandTestWrite(cfgCommandName($iCommandId), $self->{&CONFIGENVTEST});
$self->testResult(sub {configLoad(false)}, true, 'config load: ' . join(" ", @ARGV));
$self->testResult(
sub {configLoad(
false, backrestBin(), cfgCommandName($iCommandId),
(JSON::PP->new()->allow_nonref())->encode(testOptionValidate($iCommandId)))},
true, 'config load: ' . join(" ", @ARGV));
}
####################################################################################################################################

362
test/lib/pgBackRestTest/Module/Config/ConfigConfigPerlTest.pm
View File

@@ -1,362 +0,0 @@
####################################################################################################################################
# ConfigConfigTest.pm - Tests for mixed command line and config file options in Config.pm
####################################################################################################################################
package pgBackRestTest::Module::Config::ConfigConfigPerlTest;
use parent 'pgBackRestTest::Env::ConfigEnvTest';
####################################################################################################################################
# Perl includes
####################################################################################################################################
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use pgBackRest::Common::Exception;
use pgBackRest::Common::Ini;
use pgBackRest::Common::Log;
use pgBackRest::Config::Config;
use pgBackRestTest::Common::RunTest;
####################################################################################################################################
# run
####################################################################################################################################
sub run
{
my $self = shift;
my $oConfig = {};
my $strConfigFile = $self->testPath() . '/pgbackrest.conf';
if ($self->begin('set and negate option ' . cfgOptionName(CFGOPT_CONFIG)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, '/dude/dude.conf');
$self->optionTestSetBool(CFGOPT_CONFIG, false);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_NEGATE, cfgOptionName(CFGOPT_CONFIG));
}
if ($self->begin('option ' . cfgOptionName(CFGOPT_CONFIG)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSetBool(CFGOPT_CONFIG, false);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_CONFIG);
}
if ($self->begin('default option ' . cfgOptionName(CFGOPT_CONFIG)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_CONFIG, cfgDefOptionDefault(CFGCMD_BACKUP, CFGOPT_CONFIG));
}
if ($self->begin('config file is a path'))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $self->testPath());
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP), ERROR_FILE_INVALID, $self->testPath());
}
if ($self->begin('load from config stanza command section - option ' . cfgOptionName(CFGOPT_PROCESS_MAX)))
{
$oConfig = {};
$$oConfig{$self->stanza() . ':' . cfgCommandName(CFGCMD_BACKUP)}{cfgOptionName(CFGOPT_PROCESS_MAX)} = 2;
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_PROCESS_MAX, 2);
}
if ($self->begin('load from config stanza section - option ' . cfgOptionName(CFGOPT_PROCESS_MAX)))
{
$oConfig = {};
$$oConfig{$self->stanza()}{cfgOptionName(CFGOPT_PROCESS_MAX)} = 3;
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_PROCESS_MAX, 3);
}
if ($self->begin('load from config global command section - option thread-max'))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL . ':' . cfgCommandName(CFGCMD_BACKUP)}{'thread-max'} = 2;
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_PROCESS_MAX, 2);
}
if ($self->begin('load from config global section - option ' . cfgOptionName(CFGOPT_PROCESS_MAX)))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{cfgOptionName(CFGOPT_PROCESS_MAX)} = 5;
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_PROCESS_MAX, 5);
}
if ($self->begin('default - option ' . cfgOptionName(CFGOPT_PROCESS_MAX)))
{
$oConfig = {};
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_PROCESS_MAX, 1);
}
if ($self->begin('command-line override - option ' . cfgOptionName(CFGOPT_PROCESS_MAX)))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{cfgOptionName(CFGOPT_PROCESS_MAX)} = 9;
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_PROCESS_MAX, 7);
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_PROCESS_MAX, 7);
}
if ($self->begin('invalid boolean - option ' . cfgOptionName(CFGOPT_HARDLINK)))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL . ':' . cfgCommandName(CFGCMD_BACKUP)}{cfgOptionName(CFGOPT_HARDLINK)} = 'Y';
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID_VALUE, 'Y', cfgOptionName(CFGOPT_HARDLINK));
}
if ($self->begin('invalid value - option ' . cfgOptionName(CFGOPT_LOG_LEVEL_CONSOLE)))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{cfgOptionName(CFGOPT_LOG_LEVEL_CONSOLE)} = BOGUS;
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID_VALUE, BOGUS, cfgOptionName(CFGOPT_LOG_LEVEL_CONSOLE));
}
if ($self->begin('valid value - option ' . cfgOptionName(CFGOPT_LOG_LEVEL_CONSOLE)))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{cfgOptionName(CFGOPT_LOG_LEVEL_CONSOLE)} = lc(INFO);
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_RESTORE));
}
if ($self->begin('archive-push - option ' . cfgOptionName(CFGOPT_LOG_LEVEL_CONSOLE)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_ARCHIVE_PUSH));
}
if ($self->begin(cfgCommandName(CFGCMD_EXPIRE) . ' ' . cfgOptionName(CFGOPT_RETENTION_FULL)))
{
$oConfig = {};
$$oConfig{$self->stanza() . ':' . cfgCommandName(CFGCMD_EXPIRE)}{cfgOptionName(CFGOPT_RETENTION_FULL)} = 2;
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_EXPIRE));
$self->optionTestExpect(CFGOPT_RETENTION_FULL, 2);
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' option ' . cfgOptionName(CFGOPT_COMPRESS)))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL . ':' . cfgCommandName(CFGCMD_BACKUP)}{cfgOptionName(CFGOPT_COMPRESS)} = 'n';
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_COMPRESS, false);
}
if ($self->begin(cfgCommandName(CFGCMD_RESTORE) . ' global option ' . cfgOptionName(CFGOPT_RECOVERY_OPTION) . ' error'))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL . ':' . cfgCommandName(CFGCMD_RESTORE)}{cfgOptionName(CFGOPT_RECOVERY_OPTION)} = 'bogus=';
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_RESTORE), ERROR_OPTION_INVALID_VALUE, 'bogus=', cfgOptionName(CFGOPT_RECOVERY_OPTION));
}
if ($self->begin(cfgCommandName(CFGCMD_RESTORE) . ' global option ' . cfgOptionName(CFGOPT_RECOVERY_OPTION) . ' error'))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL . ':' . cfgCommandName(CFGCMD_RESTORE)}{cfgOptionName(CFGOPT_RECOVERY_OPTION)} = '=bogus';
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_RESTORE), ERROR_OPTION_INVALID_VALUE, '=bogus', cfgOptionName(CFGOPT_RECOVERY_OPTION));
}
if ($self->begin(cfgCommandName(CFGCMD_RESTORE) . ' global option ' . cfgOptionName(CFGOPT_RECOVERY_OPTION)))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL . ':' . cfgCommandName(CFGCMD_RESTORE)}{cfgOptionName(CFGOPT_RECOVERY_OPTION)} =
'archive-command=/path/to/pgbackrest';
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_RESTORE));
$self->optionTestExpect(CFGOPT_RECOVERY_OPTION, '/path/to/pgbackrest', 'archive-command');
}
if ($self->begin(cfgCommandName(CFGCMD_RESTORE) . ' stanza option ' . cfgOptionName(CFGOPT_RECOVERY_OPTION)))
{
$oConfig = {};
$$oConfig{$self->stanza()}{cfgOptionName(CFGOPT_RECOVERY_OPTION)} = ['standby-mode=on', 'a=b'];
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_RESTORE));
$self->optionTestExpect(CFGOPT_RECOVERY_OPTION, 'b', 'a');
$self->optionTestExpect(CFGOPT_RECOVERY_OPTION, 'on', 'standby-mode');
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' option ' . cfgOptionName(CFGOPT_DB_PATH)))
{
$oConfig = {};
$$oConfig{$self->stanza()}{cfgOptionName(CFGOPT_DB_PATH)} = '/path/to/db';
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_DB_PATH, '/path/to/db');
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' option ' . cfgOptionName(CFGOPT_ARCHIVE_CHECK)))
{
$oConfig = {};
$$oConfig{$self->stanza()}{cfgOptionName(CFGOPT_DB_PATH)} = '/path/to/db';
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->optionTestSetBool(CFGOPT_ARCHIVE_CHECK, false);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_ONLINE, true);
$self->optionTestExpect(CFGOPT_ARCHIVE_CHECK, false);
}
if ($self->begin(cfgCommandName(CFGCMD_ARCHIVE_PUSH) . ' option ' . cfgOptionName(CFGOPT_DB_PATH)))
{
$oConfig = {};
$$oConfig{$self->stanza()}{cfgOptionName(CFGOPT_DB_PATH)} = '/path/to/db';
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_ARCHIVE_PUSH));
$self->optionTestExpect(CFGOPT_DB_PATH, '/path/to/db');
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' option ' . cfgOptionName(CFGOPT_REPO_PATH)))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{cfgOptionName(CFGOPT_REPO_PATH)} = '/repo';
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_REPO_PATH, '/repo');
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' option ' . cfgOptionName(CFGOPT_REPO_PATH) . ' multiple times'))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{cfgOptionName(CFGOPT_REPO_PATH)} = ['/repo', '/repo2'];
storageTest()->put($strConfigFile, iniRender($oConfig, true));
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_CONFIG, $strConfigFile);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_MULTIPLE_VALUE, cfgOptionName(CFGOPT_REPO_PATH));
}
}
####################################################################################################################################
# Getters
####################################################################################################################################
# Change this from the default so the same stanza is not used in all tests.
sub stanza {return 'main'};
1;

404
test/lib/pgBackRestTest/Module/Config/ConfigOptionTest.pm
View File

@@ -1,404 +0,0 @@
####################################################################################################################################
# ConfigOptionTest.pm - Tests for command line options in Config.pm
####################################################################################################################################
package pgBackRestTest::Module::Config::ConfigOptionTest;
use parent 'pgBackRestTest::Env::ConfigEnvTest';
####################################################################################################################################
# Perl includes
####################################################################################################################################
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use English '-no_match_vars';
use Cwd qw(abs_path);
use pgBackRest::Common::Exception;
use pgBackRest::Common::Log;
use pgBackRest::Config::Config;
use pgBackRest::Version;
use pgBackRestTest::Common::RunTest;
####################################################################################################################################
# run
####################################################################################################################################
sub run
{
my $self = shift;
my @oyArray;
if ($self->begin('backup with no stanza'))
{
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_REQUIRED, cfgOptionName(CFGOPT_STANZA));
}
if ($self->begin('backup with boolean stanza'))
{
$self->optionTestSetBool(CFGOPT_STANZA);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP), ERROR_COMMAND_REQUIRED);
}
if ($self->begin('backup type defaults to ' . CFGOPTVAL_BACKUP_TYPE_INCR))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_TYPE, CFGOPTVAL_BACKUP_TYPE_INCR);
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' invalid option ' . cfgOptionName(CFGOPT_ARCHIVE_ASYNC)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSetBool(CFGOPT_ARCHIVE_ASYNC);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_COMMAND, cfgOptionName(CFGOPT_ARCHIVE_ASYNC),
cfgCommandName(CFGCMD_BACKUP));
}
if ($self->begin('backup type set to ' . CFGOPTVAL_BACKUP_TYPE_FULL))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_TYPE, CFGOPTVAL_BACKUP_TYPE_FULL);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_TYPE, CFGOPTVAL_BACKUP_TYPE_FULL);
}
if ($self->begin('backup type invalid'))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_TYPE, BOGUS);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID_VALUE, BOGUS, cfgOptionName(CFGOPT_TYPE));
}
if ($self->begin('backup invalid force'))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSetBool(CFGOPT_FORCE);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID, cfgOptionName(CFGOPT_FORCE), 'no-' . cfgOptionName(CFGOPT_ONLINE));
}
if ($self->begin('backup valid force'))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSetBool(CFGOPT_ONLINE, false);
$self->optionTestSetBool(CFGOPT_FORCE);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_ONLINE, false);
$self->optionTestExpect(CFGOPT_FORCE, true);
}
if ($self->begin('backup invalid value for ' . cfgOptionName(CFGOPT_TEST_DELAY)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSetBool(CFGOPT_TEST);
$self->optionTestSet(CFGOPT_TEST_DELAY, BOGUS);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID_VALUE, BOGUS, cfgOptionName(CFGOPT_TEST_DELAY));
}
if ($self->begin('backup invalid ' . cfgOptionName(CFGOPT_TEST_DELAY)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_TEST_DELAY, 5);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID, cfgOptionName(CFGOPT_TEST_DELAY), cfgOptionName(CFGOPT_TEST));
}
if ($self->begin('backup check ' . cfgOptionName(CFGOPT_TEST_DELAY) . ' undef'))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_TEST_DELAY);
}
if ($self->begin('restore invalid ' . cfgOptionName(CFGOPT_TARGET)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_TYPE, cfgDefOptionDefault(CFGCMD_RESTORE, CFGOPT_TYPE));
$self->optionTestSet(CFGOPT_TARGET, BOGUS);
@oyArray = (CFGOPTVAL_RESTORE_TYPE_NAME, CFGOPTVAL_RESTORE_TYPE_TIME, CFGOPTVAL_RESTORE_TYPE_XID);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_RESTORE), ERROR_OPTION_INVALID, cfgOptionName(CFGOPT_TARGET),
cfgOptionName(CFGOPT_TYPE), \@oyArray);
}
if ($self->begin('restore ' . cfgOptionName(CFGOPT_TARGET)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_TYPE, CFGOPTVAL_RESTORE_TYPE_NAME);
$self->optionTestSet(CFGOPT_TARGET, BOGUS);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_RESTORE));
$self->optionTestExpect(CFGOPT_TYPE, CFGOPTVAL_RESTORE_TYPE_NAME);
$self->optionTestExpect(CFGOPT_TARGET, BOGUS);
$self->optionTestExpect(CFGOPT_TARGET_TIMELINE);
}
if ($self->begin('invalid string ' . cfgOptionName(CFGOPT_PROCESS_MAX)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_PROCESS_MAX, BOGUS);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID_VALUE, BOGUS, cfgOptionName(CFGOPT_PROCESS_MAX));
}
if ($self->begin('invalid float ' . cfgOptionName(CFGOPT_PROCESS_MAX)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_PROCESS_MAX, '0.0');
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID_VALUE, '0.0', cfgOptionName(CFGOPT_PROCESS_MAX));
}
if ($self->begin('valid ' . cfgOptionName(CFGOPT_PROCESS_MAX)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_PROCESS_MAX, '2');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
}
if ($self->begin('valid thread-max'))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSetByName('thread-max', '2');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_PROCESS_MAX, 2);
}
if ($self->begin('valid float ' . cfgOptionName(CFGOPT_TEST_DELAY)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSetBool(CFGOPT_TEST);
$self->optionTestSet(CFGOPT_TEST_DELAY, '0.25');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
}
if ($self->begin('valid int ' . cfgOptionName(CFGOPT_TEST_DELAY)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSetBool(CFGOPT_TEST);
$self->optionTestSet(CFGOPT_TEST_DELAY, 3);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
}
if ($self->begin('restore valid ' . cfgOptionName(CFGOPT_TARGET_TIMELINE)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_TARGET_TIMELINE, 2);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_RESTORE));
}
if ($self->begin('invalid ' . cfgOptionName(CFGOPT_COMPRESS_LEVEL)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_COMPRESS_LEVEL, '12');
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_RESTORE), ERROR_OPTION_INVALID_RANGE, '12', cfgOptionName(CFGOPT_COMPRESS_LEVEL));
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' invalid value ' . cfgOptionName(CFGOPT_RETENTION_ARCHIVE_TYPE)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_RETENTION_ARCHIVE_TYPE, BOGUS);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID_VALUE, BOGUS, cfgOptionName(CFGOPT_RETENTION_ARCHIVE_TYPE));
}
if ($self->begin(
cfgCommandName(CFGCMD_BACKUP) . ' default value ' . cfgDefOptionDefault(CFGCMD_BACKUP, CFGOPT_RETENTION_ARCHIVE_TYPE) .
' for ' . cfgOptionName(CFGOPT_RETENTION_ARCHIVE_TYPE) . ' with valid ' . cfgOptionName(CFGOPT_RETENTION_FULL)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_RETENTION_FULL, 1);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_RETENTION_ARCHIVE, 1);
$self->optionTestExpect(CFGOPT_RETENTION_FULL, 1);
$self->optionTestExpect(CFGOPT_RETENTION_DIFF, undef);
# Default is FULL so this test will fail if the default is changed, alerting to the need to update configLoad.
$self->optionTestExpect(CFGOPT_RETENTION_ARCHIVE_TYPE, CFGOPTVAL_BACKUP_TYPE_FULL);
}
if ($self->begin(
cfgCommandName(CFGCMD_BACKUP) . ' valid value ' . cfgOptionName(CFGOPT_RETENTION_ARCHIVE) . ' for ' .
cfgOptionName(CFGOPT_RETENTION_ARCHIVE_TYPE) . ' ' . CFGOPTVAL_BACKUP_TYPE_DIFF))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_RETENTION_DIFF, 1);
$self->optionTestSet(CFGOPT_RETENTION_ARCHIVE_TYPE, CFGOPTVAL_BACKUP_TYPE_DIFF);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_RETENTION_ARCHIVE, 1);
$self->optionTestExpect(CFGOPT_RETENTION_DIFF, 1);
$self->optionTestExpect(CFGOPT_RETENTION_FULL, undef);
$self->optionTestExpect(CFGOPT_RETENTION_ARCHIVE_TYPE, CFGOPTVAL_BACKUP_TYPE_DIFF);
}
if ($self->begin(
cfgCommandName(CFGCMD_BACKUP) . ' warn no valid value ' . cfgOptionName(CFGOPT_RETENTION_ARCHIVE) . ' for ' .
cfgOptionName(CFGOPT_RETENTION_ARCHIVE_TYPE) . ' ' . CFGOPTVAL_BACKUP_TYPE_INCR))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_RETENTION_FULL, 2);
$self->optionTestSet(CFGOPT_RETENTION_DIFF, 1);
$self->optionTestSet(CFGOPT_RETENTION_ARCHIVE_TYPE, CFGOPTVAL_BACKUP_TYPE_INCR);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_RETENTION_ARCHIVE, undef);
$self->optionTestExpect(CFGOPT_RETENTION_ARCHIVE_TYPE, CFGOPTVAL_BACKUP_TYPE_INCR);
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' invalid value ' . cfgOptionName(CFGOPT_PROTOCOL_TIMEOUT)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_DB_TIMEOUT, 5);
$self->optionTestSet(CFGOPT_PROTOCOL_TIMEOUT, 4);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_INVALID_VALUE, 4, cfgOptionName(CFGOPT_PROTOCOL_TIMEOUT),
"'protocol-timeout' option (4) should be greater than 'db-timeout' option (5)");
}
if ($self->begin(cfgCommandName(CFGCMD_RESTORE) . ' invalid value ' . cfgOptionName(CFGOPT_RECOVERY_OPTION)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_RECOVERY_OPTION, '=');
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_RESTORE), ERROR_OPTION_INVALID_PAIR, '=', cfgOptionName(CFGOPT_RECOVERY_OPTION));
}
if ($self->begin(cfgCommandName(CFGCMD_RESTORE) . ' invalid value ' . cfgOptionName(CFGOPT_RECOVERY_OPTION)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_RECOVERY_OPTION, '=' . BOGUS);
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_RESTORE), ERROR_OPTION_INVALID_PAIR, '=' . BOGUS, cfgOptionName(CFGOPT_RECOVERY_OPTION));
}
if ($self->begin(cfgCommandName(CFGCMD_RESTORE) . ' invalid value ' . cfgOptionName(CFGOPT_RECOVERY_OPTION)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_RECOVERY_OPTION, BOGUS . '=');
$self->configTestLoadExpect(
cfgCommandName(CFGCMD_RESTORE), ERROR_OPTION_INVALID_PAIR, BOGUS . '=', cfgOptionName(CFGOPT_RECOVERY_OPTION));
}
if ($self->begin(cfgCommandName(CFGCMD_RESTORE) . ' valid value ' . cfgOptionName(CFGOPT_RECOVERY_OPTION)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_RECOVERY_OPTION, 'primary-conn-info=db.domain.net');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_RESTORE));
$self->optionTestExpect(&CFGOPT_RECOVERY_OPTION, 'db.domain.net', 'primary-conn-info');
}
if ($self->begin(cfgCommandName(CFGCMD_RESTORE) . ' values passed to ' . cfgCommandName(CFGCMD_ARCHIVE_GET)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db path/main');
$self->optionTestSet(CFGOPT_REPO_PATH, '/repo');
$self->optionTestSet(CFGOPT_BACKUP_HOST, 'db.mydomain.com');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_RESTORE));
my $strCommand = cfgCommandWrite(CFGCMD_ARCHIVE_GET);
my $strExpectedCommand =
backrestBin() . " --backup-host=db.mydomain.com \"--db1-path=/db path/main\" --repo-path=/repo --stanza=app " .
cfgCommandName(CFGCMD_ARCHIVE_GET);
if ($strCommand ne $strExpectedCommand)
{
confess "expected command '${strExpectedCommand}' but got '${strCommand}'";
}
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' default value ' . cfgOptionName(CFGOPT_DB_CMD)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_HOST, 'db');
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_DB_CMD, backrestBin());
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' missing option ' . cfgOptionName(CFGOPT_DB_PATH)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP), ERROR_OPTION_REQUIRED, 'db1-path', 'does this stanza exist?');
}
if ($self->begin(cfgCommandName(CFGCMD_BACKUP) . ' automatically increase ' . cfgOptionName(CFGOPT_PROTOCOL_TIMEOUT)))
{
$self->optionTestSet(CFGOPT_STANZA, $self->stanza());
$self->optionTestSet(CFGOPT_DB_PATH, '/db');
$self->optionTestSet(CFGOPT_DB_TIMEOUT, cfgDefOptionDefault(CFGCMD_BACKUP, CFGOPT_PROTOCOL_TIMEOUT) + 30);
$self->configTestLoadExpect(cfgCommandName(CFGCMD_BACKUP));
$self->optionTestExpect(CFGOPT_PROTOCOL_TIMEOUT, cfgDefOptionDefault(CFGCMD_BACKUP, CFGOPT_PROTOCOL_TIMEOUT) + 60);
}
}
####################################################################################################################################
# Getters
####################################################################################################################################
# Change this from the default so the same stanza is not used in all tests.
sub stanza {return 'app'};
1;

113
test/lib/pgBackRestTest/Module/Config/ConfigUnitTest.pm
View File

@@ -1,113 +0,0 @@
####################################################################################################################################
# ConfigUnitTest.pm - Tests code paths
####################################################################################################################################
package pgBackRestTest::Module::Config::ConfigUnitTest;
use parent 'pgBackRestTest::Env::ConfigEnvTest';
####################################################################################################################################
# Perl includes
####################################################################################################################################
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use pgBackRest::Common::Exception;
use pgBackRest::Common::Ini;
use pgBackRest::Common::Log;
use pgBackRest::Config::Config;
use pgBackRestTest::Common::RunTest;
####################################################################################################################################
# run
####################################################################################################################################
sub run
{
my $self = shift;
my $oConfig = {};
my $strConfigFile = $self->testPath() . '/pgbackrest.conf';
cfgCommandSet(CFGCMD_ARCHIVE_GET);
cfgOptionSet(CFGOPT_CONFIG, $strConfigFile, true);
if ($self->begin('Config::configFileValidate()'))
{
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{cfgOptionName(CFGOPT_DB_PORT)} = 1234;
$self->testResult(sub {pgBackRest::Config::Config::configFileValidate($oConfig)}, false,
'valid option ' . cfgOptionName(CFGOPT_DB_PORT) . ' under invalid section',
{strLogExpect =>
"WARN: $strConfigFile valid option '" . cfgOptionName(CFGOPT_DB_PORT) . "' is a stanza section option and is not" .
" valid in section " . CFGDEF_SECTION_GLOBAL . "\n" .
"HINT: global options can be specified in global or stanza sections but not visa-versa"});
#---------------------------------------------------------------------------------------------------------------------------
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL . ':' . cfgCommandName(CFGCMD_BACKUP)}{cfgOptionName(CFGOPT_DB_PORT)} = 1234;
$self->testResult(sub {pgBackRest::Config::Config::configFileValidate($oConfig)}, false,
'valid option ' . cfgOptionName(CFGOPT_DB_PORT) . ' for command ' . cfgCommandName(CFGCMD_BACKUP) .
' under invalid global section',
{strLogExpect =>
"WARN: $strConfigFile valid option '" . cfgOptionName(CFGOPT_DB_PORT) . "' is a stanza section option and is not" .
" valid in section " . CFGDEF_SECTION_GLOBAL . "\n" .
"HINT: global options can be specified in global or stanza sections but not visa-versa"});
#---------------------------------------------------------------------------------------------------------------------------
$oConfig = {};
$$oConfig{$self->stanza() . ':' . cfgCommandName(CFGCMD_ARCHIVE_PUSH)}{cfgOptionName(CFGOPT_DB_PORT)} = 1234;
$self->testResult(sub {pgBackRest::Config::Config::configFileValidate($oConfig)}, false,
'valid option ' . cfgOptionName(CFGOPT_DB_PORT) . ' under invalid stanza section command',
{strLogExpect =>
"WARN: $strConfigFile valid option '" . cfgOptionName(CFGOPT_DB_PORT) . "' is not valid for command '" .
cfgCommandName(CFGCMD_ARCHIVE_PUSH) ."'"});
#---------------------------------------------------------------------------------------------------------------------------
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{&BOGUS} = BOGUS;
$self->testResult(
sub {pgBackRest::Config::Config::configFileValidate($oConfig)}, false,
'invalid option ' . $$oConfig{&CFGDEF_SECTION_GLOBAL}{&BOGUS},
{strLogExpect => "WARN: $strConfigFile file contains invalid option '" . BOGUS . "'"});
#---------------------------------------------------------------------------------------------------------------------------
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{'thread-max'} = 3;
$self->testResult(sub {pgBackRest::Config::Config::configFileValidate($oConfig)}, true, 'valid alt name found');
#---------------------------------------------------------------------------------------------------------------------------
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{cfgOptionName(CFGOPT_LOG_LEVEL_STDERR)} =
cfgDefOptionDefault(CFGCMD_ARCHIVE_PUSH, CFGOPT_LOG_LEVEL_STDERR);
$$oConfig{$self->stanza()}{cfgOptionName(CFGOPT_DB_PATH)} = '/db';
$$oConfig{&CFGDEF_SECTION_GLOBAL . ':' . cfgCommandName(CFGCMD_ARCHIVE_PUSH)}{cfgOptionName(CFGOPT_PROCESS_MAX)} = 2;
$self->testResult(sub {pgBackRest::Config::Config::configFileValidate($oConfig)}, true, 'valid config file');
#---------------------------------------------------------------------------------------------------------------------------
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{cfgOptionName(CFGOPT_LOG_LEVEL_STDERR)} =
cfgDefOptionDefault(CFGCMD_ARCHIVE_PUSH, CFGOPT_LOG_LEVEL_STDERR);
$$oConfig{&CFGDEF_SECTION_GLOBAL . ':' . cfgCommandName(CFGCMD_ARCHIVE_PUSH)}{cfgOptionName(CFGOPT_PROCESS_MAX)} = 2;
$$oConfig{'unusual-section^name!:' . cfgCommandName(CFGCMD_CHECK)}{cfgOptionName(CFGOPT_DB_PATH)} = '/db';
$self->testResult(sub {pgBackRest::Config::Config::configFileValidate($oConfig)}, true, 'valid unusual section name');
#---------------------------------------------------------------------------------------------------------------------------
$oConfig = {};
$$oConfig{&CFGDEF_SECTION_GLOBAL}{&BOGUS} = BOGUS;
# Change command to indicate remote
cfgCommandSet(CFGCMD_REMOTE);
$self->testResult(
sub {pgBackRest::Config::Config::configFileValidate($oConfig)}, true,
'invalid option but config file not validated on remote');
}
}
1;