def test_check_archive(self, tmpdir):
"""
Test the check_archive method
"""
# Setup temp dir and server
server = build_real_server(
global_conf={
"barman_lock_directory": tmpdir.mkdir('lock').strpath
},
main_conf={"wals_directory": tmpdir.mkdir('wals').strpath})
strategy = CheckStrategy()
# Call the check on an empty xlog file. expect it to contain errors.
server.check_archive(strategy)
assert strategy.has_error is True
assert strategy.check_result[0].check == 'WAL archive'
assert strategy.check_result[0].status is False
# Write something in the xlog db file and check for the results
with server.xlogdb('w') as fxlogdb:
fxlogdb.write("00000000000000000000")
# The check strategy should contain no errors.
strategy = CheckStrategy()
server.check_archive(strategy)
assert strategy.has_error is False
assert len(strategy.check_result) == 0
def test_check_strategy_log(self, caplog):
"""
Test correct log
:type caplog: pytest_capturelog.CaptureLogFuncArg
"""
strategy = CheckStrategy()
# Expected result OK
strategy.result('test_server_one', 'wal_level', True)
assert len(caplog.records()) == 1
record = caplog.records().pop()
assert record.msg == \
"Check 'wal_level' succeeded for server 'test_server_one'"
assert record.levelname == 'DEBUG'
# Expected result FAILED
strategy.result('test_server_one', 'wal_level', False)
assert len(caplog.records()) == 1
record = caplog.records().pop()
assert record.levelname == 'ERROR'
assert record.msg == \
"Check 'wal_level' failed for server 'test_server_one'"
def test_check_strategy_log(self, caplog):
"""
Test correct log
:type caplog: pytest_capturelog.CaptureLogFuncArg
"""
strategy = CheckStrategy()
# Expected result OK
strategy.result("test_server_one", "wal_level", True)
records = list(caplog.records)
assert len(records) == 1
record = records.pop()
assert record.msg == "Check 'wal_level' succeeded for server 'test_server_one'"
assert record.levelname == "DEBUG"
# Expected result FAILED
strategy.result("test_server_one", "wal_level", False)
records = list(caplog.records)
assert len(records) == 2
record = records.pop()
assert record.levelname == "ERROR"
assert record.msg == "Check 'wal_level' failed for server 'test_server_one'"
def test_check_strategy(self, capsys):
"""
Test correct values result
:type capsys: pytest
"""
strategy = CheckStrategy()
# Expected no errors
strategy.result('test_server_one', 'wal_level', True)
strategy.result('test_server_one', 'archive mode', True)
assert ('', '') == capsys.readouterr()
assert strategy.has_error is False
assert strategy.check_result
assert len(strategy.check_result) == 2
# Expected two errors
strategy.result('test_server_one', 'wal_level', False)
strategy.result('test_server_one', 'archive mode', False)
assert ('', '') == capsys.readouterr()
assert strategy.has_error is True
assert strategy.check_result
assert len(strategy.check_result) == 4
assert len([result
for result in strategy.check_result
if not result.status]) == 2
def test_check_strategy_log(self, caplog):
"""
Test correct log
:type caplog: pytest_capturelog.CaptureLogFuncArg
"""
strategy = CheckStrategy()
# Expected result OK
strategy.result('test_server_one', 'wal_level', True)
records = list(caplog.records)
assert len(records) == 1
record = records.pop()
assert record.msg == \
"Check 'wal_level' succeeded for server 'test_server_one'"
assert record.levelname == 'DEBUG'
# Expected result FAILED
strategy.result('test_server_one', 'wal_level', False)
records = list(caplog.records)
assert len(records) == 2
record = records.pop()
assert record.levelname == 'ERROR'
assert record.msg == \
"Check 'wal_level' failed for server 'test_server_one'"
def test_check_strategy(self, capsys):
"""
Test correct values result
:type capsys: pytest
"""
strategy = CheckStrategy()
# Expected no errors
strategy.result('test_server_one', 'wal_level', True)
strategy.result('test_server_one', 'archive mode', True)
assert ('', '') == capsys.readouterr()
assert strategy.has_error is False
assert strategy.check_result
assert len(strategy.check_result) == 2
# Expected two errors
strategy = CheckStrategy()
strategy.result('test_server_one', 'wal_level', False)
strategy.result('test_server_one', 'archive mode', False)
assert ('', '') == capsys.readouterr()
assert strategy.has_error is True
assert strategy.check_result
assert len(strategy.check_result) == 2
assert len([result
for result in strategy.check_result
if not result.status]) == 2
# Test Non blocking error behaviour (one non blocking error)
strategy = CheckStrategy()
strategy.result('test_server_one', 'backup maximum age', False)
strategy.result('test_server_one', 'archive mode', True)
assert ('', '') == capsys.readouterr()
assert strategy.has_error is False
assert strategy.check_result
assert len(strategy.check_result) == 2
assert len([result
for result in strategy.check_result
if not result.status]) == 1
# Test Non blocking error behaviour (2 errors one is non blocking)
strategy = CheckStrategy()
strategy.result('test_server_one', 'backup maximum age', False)
strategy.result('test_server_one', 'archive mode', False)
assert ('', '') == capsys.readouterr()
assert strategy.has_error is True
assert strategy.check_result
assert len(strategy.check_result) == 2
assert len([result
for result in strategy.check_result
if not result.status]) == 2
def test_check(self, remote_status_mock):
"""
Very simple and basic test for the check method
:param remote_status_mock: mock for the get_remote_status method
"""
remote_status_mock.return_value = {
'pg_basebackup_compatible': True,
'pg_basebackup_installed': True,
'pg_basebackup_path': '/fake/path',
'pg_basebackup_bwlimit': True,
'pg_basebackup_version': '9.5',
'pg_basebackup_tbls_mapping': True,
}
check_strat = CheckStrategy()
backup_manager = build_backup_manager(
global_conf={'backup_method': 'postgres'})
backup_manager.server.postgres.server_txt_version = '9.5'
backup_manager.executor.check(check_strategy=check_strat)
# No errors detected
assert check_strat.has_error is not True
remote_status_mock.reset_mock()
remote_status_mock.return_value = {
'pg_basebackup_compatible': False,
'pg_basebackup_installed': True,
'pg_basebackup_path': True,
'pg_basebackup_bwlimit': True,
'pg_basebackup_version': '9.5',
'pg_basebackup_tbls_mapping': True,
}
check_strat = CheckStrategy()
backup_manager.executor.check(check_strategy=check_strat)
# Error present because of the 'pg_basebackup_compatible': False
assert check_strat.has_error is True
# Even if pg_backup has no tbls_mapping option the check
# succeeds if the server doesn't have any tablespaces
remote_status_mock.reset_mock()
remote_status_mock.return_value = {
'pg_basebackup_compatible': True,
'pg_basebackup_installed': True,
'pg_basebackup_path': True,
'pg_basebackup_bwlimit': True,
'pg_basebackup_version': '9.3',
'pg_basebackup_tbls_mapping': False,
}
check_strat = CheckStrategy()
backup_manager.server.postgres.get_tablespaces.return_value = []
backup_manager.executor.check(check_strategy=check_strat)
assert check_strat.has_error is False
# This check fails because the server contains tablespaces and
# pg_basebackup doesn't support the tbls_mapping option
remote_status_mock.reset_mock()
remote_status_mock.return_value = {
'pg_basebackup_compatible': True,
'pg_basebackup_installed': True,
'pg_basebackup_path': True,
'pg_basebackup_bwlimit': True,
'pg_basebackup_version': '9.3',
'pg_basebackup_tbls_mapping': False,
}
check_strat = CheckStrategy()
backup_manager.server.postgres.get_tablespaces.return_value = [True]
backup_manager.executor.check(check_strategy=check_strat)
assert check_strat.has_error is True
