def test_kill(self, pm_mock, capsys):
server = build_real_server()
# Empty process list, the process is not running
task_name = 'test_task'
process_list = []
pm_mock.return_value.list.return_value = process_list
pm_mock.return_value.kill.return_value = True
server.kill(task_name)
out, err = capsys.readouterr()
assert ('Termination of %s failed: no such process for server %s' % (
task_name,
server.config.name)) in err
# Successful kill
pid = 1234
process_list.append(ProcessInfo(pid, server.config.name, task_name))
pm_mock.return_value.list.return_value = process_list
pm_mock.return_value.kill.return_value = True
server.kill('test_task')
out, err = capsys.readouterr()
assert ('Stopped process %s(%s)' %
(task_name, pid)) in out
# The process don't terminate
pm_mock.return_value.kill.return_value = False
server.kill('test_task')
out, err = capsys.readouterr()
assert ('ERROR: Cannot terminate process %s(%s)' %
(task_name, pid)) in err
def test_init(self):
"""
Test the init method
"""
pi = ProcessInfo(pid=12345,
server_name='test_server',
task='test_task')
assert pi.pid == 12345
assert pi.server_name == 'test_server'
assert pi.task == 'test_task'
def test_init(self):
"""
Test the init method
"""
pi = ProcessInfo(pid=12345,
server_name="test_server",
task="test_task")
assert pi.pid == 12345
assert pi.server_name == "test_server"
assert pi.task == "test_task"
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"