def test_check(self, remote_mock, capsys):
"""
Test management of check_postgres view output
:param remote_mock: mock get_remote_status function
:param capsys: retrieve output from consolle
"""
# Create a backup_manager
backup_manager = build_backup_manager()
# Set up mock responses
streaming = backup_manager.server.streaming
streaming.server_txt_version = "9.5"
# Instantiate a StreamingWalArchiver obj
archiver = StreamingWalArchiver(backup_manager)
# Prepare the output check strategy
strategy = CheckOutputStrategy()
# Case: correct configuration
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_path": "fake/path",
}
# Expect out: all parameters: OK
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert out == "\tpg_receivexlog: OK\n" "\tpg_receivexlog compatible: OK\n"
# Case: pg_receivexlog is not compatible
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": False,
"pg_receivexlog_path": "fake/path",
"pg_receivexlog_version": "9.2",
}
# Expect out: some parameters: FAILED
strategy = CheckOutputStrategy()
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert (
out == "\tpg_receivexlog: OK\n"
"\tpg_receivexlog compatible: FAILED "
"(PostgreSQL version: 9.5, pg_receivexlog version: 9.2)\n"
)
# Case: pg_receivexlog returned error
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": None,
"pg_receivexlog_path": "fake/path",
"pg_receivexlog_version": None,
}
# Expect out: all parameters: OK
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert (
out == "\tpg_receivexlog: OK\n"
"\tpg_receivexlog compatible: FAILED "
"(PostgreSQL version: 9.5, pg_receivexlog version: None)\n"
)
def test_check(self, remote_mock, capsys):
"""
Test management of check_postgres view output
:param remote_mock: mock get_remote_status function
:param capsys: retrieve output from consolle
"""
# Create a backup_manager
backup_manager = build_backup_manager()
# Set up mock responses
streaming = backup_manager.server.streaming
streaming.server_txt_version = "9.5"
# Instantiate a StreamingWalArchiver obj
archiver = StreamingWalArchiver(backup_manager)
# Prepare the output check strategy
strategy = CheckOutputStrategy()
# Case: correct configuration
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_path": "fake/path",
"incoming_wals_count": 0,
}
# Expect out: all parameters: OK
backup_manager.server.process_manager.list.return_value = []
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert (
out == "\tpg_receivexlog: OK\n"
"\tpg_receivexlog compatible: OK\n"
"\treceive-wal running: FAILED "
"(See the Barman log file for more details)\n"
)
# Case: pg_receivexlog is not compatible
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": False,
"pg_receivexlog_path": "fake/path",
"pg_receivexlog_version": "9.2",
"incoming_wals_count": 0,
}
# Expect out: some parameters: FAILED
strategy = CheckOutputStrategy()
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert (
out == "\tpg_receivexlog: OK\n"
"\tpg_receivexlog compatible: FAILED "
"(PostgreSQL version: 9.5, pg_receivexlog version: 9.2)\n"
"\treceive-wal running: FAILED "
"(See the Barman log file for more details)\n"
)
# Case: pg_receivexlog returned error
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": None,
"pg_receivexlog_path": "fake/path",
"pg_receivexlog_version": None,
"incoming_wals_count": 0,
}
# Expect out: all parameters: OK
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert (
out == "\tpg_receivexlog: OK\n"
"\tpg_receivexlog compatible: FAILED "
"(PostgreSQL version: 9.5, pg_receivexlog version: None)\n"
"\treceive-wal running: FAILED "
"(See the Barman log file for more details)\n"
)
# Case: receive-wal running
backup_manager.server.process_manager.list.return_value = [
ProcessInfo(
pid=1, server_name=backup_manager.config.name, task="receive-wal"
)
]
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert (
out == "\tpg_receivexlog: OK\n"
"\tpg_receivexlog compatible: FAILED "
"(PostgreSQL version: 9.5, pg_receivexlog version: None)\n"
"\treceive-wal running: OK\n"
)
# Case: streaming connection not configured
backup_manager.server.streaming = None
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert (
out == "\tpg_receivexlog: OK\n"
"\tpg_receivexlog compatible: FAILED "
"(PostgreSQL version: Unknown, pg_receivexlog version: None)\n"
"\treceive-wal running: OK\n"
)
# Case: too many wal files in the incoming queue
archiver.config.max_incoming_wals_queue = 10
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": None,
"pg_receivexlog_path": "fake/path",
"pg_receivexlog_version": None,
"incoming_wals_count": 20,
}
# Expect out: the wals incoming queue is too big
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert (
out == "\tpg_receivexlog: OK\n"
"\tpg_receivexlog compatible: FAILED "
"(PostgreSQL version: Unknown, pg_receivexlog version: None)\n"
"\treceive-wal running: OK\n"
)
def test_check(self, remote_mock, capsys):
"""
Test management of check_postgres view output
:param remote_mock: mock get_remote_status function
:param capsys: retrieve output from consolle
"""
# Create a backup_manager
backup_manager = build_backup_manager()
# Set up mock responses
streaming = backup_manager.server.streaming
streaming.server_txt_version = '9.5'
# Instantiate a StreamingWalArchiver obj
archiver = StreamingWalArchiver(backup_manager)
# Prepare the output check strategy
strategy = CheckOutputStrategy()
# Case: correct configuration
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_path': 'fake/path',
}
# Expect out: all parameters: OK
backup_manager.server.process_manager.list.return_value = []
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert out == \
"\tpg_receivexlog: OK\n" \
"\tpg_receivexlog compatible: OK\n" \
"\treceive-wal running: FAILED " \
"(See the Barman log file for more details)\n"
# Case: pg_receivexlog is not compatible
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': False,
'pg_receivexlog_path': 'fake/path',
'pg_receivexlog_version': '9.2',
}
# Expect out: some parameters: FAILED
strategy = CheckOutputStrategy()
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert out == \
"\tpg_receivexlog: OK\n" \
"\tpg_receivexlog compatible: FAILED " \
"(PostgreSQL version: 9.5, pg_receivexlog version: 9.2)\n" \
"\treceive-wal running: FAILED " \
"(See the Barman log file for more details)\n"
# Case: pg_receivexlog returned error
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': None,
'pg_receivexlog_path': 'fake/path',
'pg_receivexlog_version': None,
}
# Expect out: all parameters: OK
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert out == \
"\tpg_receivexlog: OK\n" \
"\tpg_receivexlog compatible: FAILED " \
"(PostgreSQL version: 9.5, pg_receivexlog version: None)\n" \
"\treceive-wal running: FAILED " \
"(See the Barman log file for more details)\n"
# Case: receive-wal running
backup_manager.server.process_manager.list.return_value = [
ProcessInfo(pid=1,
server_name=backup_manager.config.name,
task="receive-wal")
]
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert out == \
"\tpg_receivexlog: OK\n" \
"\tpg_receivexlog compatible: FAILED " \
"(PostgreSQL version: 9.5, pg_receivexlog version: None)\n" \
"\treceive-wal running: OK\n"
def test_check(self, remote_mock, capsys):
"""
Test management of check_postgres view output
:param remote_mock: mock get_remote_status function
:param capsys: retrieve output from consolle
"""
# Create a backup_manager
backup_manager = build_backup_manager()
# Set up mock responses
streaming = backup_manager.server.streaming
streaming.server_txt_version = '9.5'
# Instantiate a StreamingWalArchiver obj
archiver = StreamingWalArchiver(backup_manager)
# Prepare the output check strategy
strategy = CheckOutputStrategy()
# Case: correct configuration
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_path': 'fake/path',
}
# Expect out: all parameters: OK
backup_manager.server.process_manager.list.return_value = []
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert out == \
"\tpg_receivexlog: OK\n" \
"\tpg_receivexlog compatible: OK\n" \
"\treceive-wal running: FAILED " \
"(See the Barman log file for more details)\n"
# Case: pg_receivexlog is not compatible
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': False,
'pg_receivexlog_path': 'fake/path',
'pg_receivexlog_version': '9.2',
}
# Expect out: some parameters: FAILED
strategy = CheckOutputStrategy()
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert out == \
"\tpg_receivexlog: OK\n" \
"\tpg_receivexlog compatible: FAILED " \
"(PostgreSQL version: 9.5, pg_receivexlog version: 9.2)\n" \
"\treceive-wal running: FAILED " \
"(See the Barman log file for more details)\n"
# Case: pg_receivexlog returned error
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': None,
'pg_receivexlog_path': 'fake/path',
'pg_receivexlog_version': None,
}
# Expect out: all parameters: OK
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert out == \
"\tpg_receivexlog: OK\n" \
"\tpg_receivexlog compatible: FAILED " \
"(PostgreSQL version: 9.5, pg_receivexlog version: None)\n" \
"\treceive-wal running: FAILED " \
"(See the Barman log file for more details)\n"
# Case: receive-wal running
backup_manager.server.process_manager.list.return_value = [
ProcessInfo(pid=1,
server_name=backup_manager.config.name,
task="receive-wal")
]
archiver.check(strategy)
(out, err) = capsys.readouterr()
assert out == \
"\tpg_receivexlog: OK\n" \
"\tpg_receivexlog compatible: FAILED " \
"(PostgreSQL version: 9.5, pg_receivexlog version: None)\n" \
"\treceive-wal running: OK\n"
