def setUp(self):
self.cluster_state = "state"
patcher_primitives = mock.patch(
"pcs.lib.pacemaker.state._get_primitives_for_state_check")
self.addCleanup(patcher_primitives.stop)
self.get_primitives_for_state_check = patcher_primitives.start()
patcher_roles = mock.patch(
"pcs.lib.pacemaker.state._get_primitive_roles_with_nodes")
self.addCleanup(patcher_roles.stop)
self.get_primitive_roles_with_nodes = patcher_roles.start()
def test_success_read_content_from_file(self):
mock_open = mock.mock_open()
with mock.patch("pcs.lib.env_file.open", mock_open, create=True):
mock_open().read.return_value = "test booth\nconfig"
self.assertEqual(
"test booth\nconfig",
RealFile("some role", "/path/to.file").read()
)
def test_sucessfully_care_about_local_file(self, mock_is_file):
#setup, fixtures
def next_in_line(env):
env.booth["modified_env"] = {
"config_file": {
"content": "file content",
"no_existing_file_expected": False,
},
"key_file": {
"content": "key file content",
"no_existing_file_expected": False,
}
}
return "call result"
mock_is_file.return_value = True
mock_env = mock.MagicMock()
mock_open = mock.mock_open()
with mock.patch(
"pcs.cli.booth.env.open",
mock_open,
create=True
):
#run tested code
booth_conf_middleware = middleware_config(
"booth-name",
"/local/file/path.conf",
"/local/file/path.key",
)
self.assertEqual(
"call result",
booth_conf_middleware(next_in_line, mock_env)
)
#assertions
self.assertEqual(mock_is_file.mock_calls,[
mock.call("/local/file/path.conf"),
mock.call("/local/file/path.key"),
])
self.assertEqual(mock_env.booth["name"], "booth-name")
self.assertEqual(mock_env.booth["config_file"], {"content": ""})
self.assertEqual(mock_env.booth["key_file"], {"content": ""})
self.assertEqual(mock_open.mock_calls, [
mock.call(u'/local/file/path.conf'),
mock.call().read(),
mock.call(u'/local/file/path.key'),
mock.call().read(),
mock.call(u'/local/file/path.key', u'w'),
mock.call().write(u'key file content'),
mock.call().close(),
mock.call(u'/local/file/path.conf', u'w'),
mock.call().write(u'file content'),
mock.call().close(),
])
def test_success_write_content_to_path(self):
mock_open = mock.mock_open()
mock_file_operation = mock.Mock()
with mock.patch("pcs.lib.env_file.open", mock_open, create=True):
RealFile("some role", "/etc/booth/some-name.conf").write(
"config content", file_operation=mock_file_operation)
mock_open.assert_called_once_with("/etc/booth/some-name.conf", "w")
mock_open().write.assert_called_once_with("config content")
mock_file_operation.assert_called_once_with(
"/etc/booth/some-name.conf")
def setUp(self):
tmpfile_patcher = mock.patch("pcs.lib.pacemaker.live.write_tmpfile")
self.addCleanup(tmpfile_patcher.stop)
self.mock_write_tmpfile = tmpfile_patcher.start()
self.tmpfile_old = mock_tmpfile("old.cib")
self.tmpfile_new = mock_tmpfile("new.cib")
self.mock_write_tmpfile.side_effect = [
self.tmpfile_old, self.tmpfile_new
]
self.env_assist, self.config = get_env_tools(test_case=self)
def setUp(self):
self.report_processor = MockLibraryReportProcessor(
raise_on_errors=False
)
self.cluster_state = "state"
patcher = mock.patch(
"pcs.lib.pacemaker.state.get_resource_roles_with_nodes"
)
self.addCleanup(patcher.stop)
self.get_resource_roles_with_nodes = patcher.start()
def test_sucessfully_care_about_local_file(self, mock_is_file):
#setup, fixtures
def next_in_line(env):
env.booth["modified_env"] = {
"config_file": {
"content": "file content",
"no_existing_file_expected": False,
},
"key_file": {
"content": "key file content",
"no_existing_file_expected": False,
}
}
return "call result"
mock_is_file.return_value = True
mock_env = mock.MagicMock()
mock_open = mock.mock_open()
with mock.patch("pcs.cli.booth.env.open", mock_open, create=True):
#run tested code
booth_conf_middleware = middleware_config(
"booth-name",
"/local/file/path.conf",
"/local/file/path.key",
)
self.assertEqual("call result",
booth_conf_middleware(next_in_line, mock_env))
#assertions
self.assertEqual(mock_is_file.mock_calls, [
mock.call("/local/file/path.conf"),
mock.call("/local/file/path.key"),
])
self.assertEqual(mock_env.booth["name"], "booth-name")
self.assertEqual(mock_env.booth["config_file"], {"content": ""})
self.assertEqual(mock_env.booth["key_file"], {"content": ""})
self.assertEqual(mock_open.mock_calls, [
mock.call(u'/local/file/path.conf'),
mock.call().read(),
mock.call(u'/local/file/path.key'),
mock.call().read(),
mock.call(u'/local/file/path.key', u'w'),
mock.call().write(u'key file content'),
mock.call().close(),
mock.call(u'/local/file/path.conf', u'w'),
mock.call().write(u'file content'),
mock.call().close(),
])
def test_success_write_content_to_path(self):
mock_open = mock.mock_open()
mock_file_operation = mock.Mock()
with mock.patch("pcs.lib.env_file.open", mock_open, create=True):
RealFile("some role", "/etc/booth/some-name.conf").write(
"config content",
file_operation=mock_file_operation
)
mock_open.assert_called_once_with("/etc/booth/some-name.conf", "w")
mock_open().write.assert_called_once_with("config content")
mock_file_operation.assert_called_once_with(
"/etc/booth/some-name.conf"
)
def test_success_binary(self):
mock_open = mock.mock_open()
mock_file_operation = mock.Mock()
with mock.patch("pcs.lib.env_file.open", mock_open, create=True):
RealFile("some role", "/etc/booth/some-name.conf").write(
"config content".encode("utf-8"),
file_operation=mock_file_operation,
is_binary=True)
mock_open.assert_called_once_with("/etc/booth/some-name.conf",
"wb")
mock_open().write.assert_called_once_with(
"config content".encode("utf-8"))
mock_file_operation.assert_called_once_with(
"/etc/booth/some-name.conf")
def test_success_binary(self):
mock_open = mock.mock_open()
mock_file_operation = mock.Mock()
with mock.patch("pcs.lib.env_file.open", mock_open, create=True):
RealFile("some role", "/etc/booth/some-name.conf").write(
"config content".encode("utf-8"),
file_operation=mock_file_operation,
is_binary=True
)
mock_open.assert_called_once_with("/etc/booth/some-name.conf", "wb")
mock_open().write.assert_called_once_with(
"config content".encode("utf-8")
)
mock_file_operation.assert_called_once_with(
"/etc/booth/some-name.conf"
)
def patch_env(call_queue, config, init_env):
#It is mandatory to patch some env objects/methods. It is ok when command
#does not use this objects/methods and specify no call for it. But it would
#be a problem when the test succeded because the live call respond correctly
#by accident. Such test would fails on different machine (with another live
#environment)
patcher_list = [
patch_lib_env(
"cmd_runner", lambda env: spy.Runner(init_env.cmd_runner())
if config.spy else Runner(call_queue,
env_vars={}
if not config.env.cib_tempfile else {
"CIB_file": config.env.cib_tempfile,
})),
mock.patch(
"pcs.lib.env.get_local_corosync_conf",
get_get_local_corosync_conf(call_queue)
if not config.spy else spy.get_local_corosync_conf),
patch_lib_env(
"get_node_communicator", lambda env: NodeCommunicator(call_queue)
if not config.spy else spy.NodeCommunicator(
init_env.get_node_communicator()))
]
#It is not always desirable to patch the method push_cib. Some tests can
#patch only the internals (runner...). So push_cib is patched only when it
#is explicitly configured
if is_push_cib_call_in(call_queue):
patcher_list.append(patch_lib_env("push_cib",
get_push_cib(call_queue)))
for patcher in patcher_list:
patcher.start()
def unpatch():
for patcher in patcher_list:
patcher.stop()
return unpatch
def patch(target, *args, **kwargs):
return mock.patch("{0}.{1}".format(prefix, target), *args, **kwargs)
def patch_env(call_queue, config, init_env):
#It is mandatory to patch some env objects/methods. It is ok when command
#does not use this objects/methods and specify no call for it. But it would
#be a problem when the test succeded because the live call respond correctly
#by accident. Such test would fails on different machine (with another live
#environment)
get_cmd_runner = init_env.cmd_runner
get_node_communicator = init_env.get_node_communicator
patcher_list = [
patch_lib_env(
"cmd_runner", lambda env: spy.Runner(get_cmd_runner())
if config.spy else Runner(call_queue,
env_vars={}
if not config.env.cib_tempfile else {
"CIB_file": config.env.cib_tempfile,
})),
mock.patch(
"pcs.lib.env.get_local_corosync_conf",
get_get_local_corosync_conf(call_queue)
if not config.spy else spy.get_local_corosync_conf),
patch_lib_env(
"get_node_communicator", lambda env: NodeCommunicator(call_queue)
if not config.spy else spy.NodeCommunicator(get_node_communicator(
)))
]
if is_fs_call_in(call_queue):
fs_mock = get_fs_mock(call_queue)
builtin = (
("__builtin__" if sys.version_info[0] == 2 else "builtins") +
".{0}").format
patcher_list.extend([
mock.patch(builtin("open"), fs_mock("open", open)),
mock.patch("os.path.exists",
fs_mock("os.path.exists", os.path.exists)),
mock.patch("os.chmod", fs_mock("os.chmod", os.chmod)),
mock.patch("os.chown", fs_mock("os.chown", os.chown)),
])
# It is not always desirable to patch these methods. Some tests may patch
# only the internals (runner etc.). So these methods are only patched when
# it is explicitly configured.
if is_push_cib_call_in(call_queue):
patcher_list.append(patch_lib_env("push_cib",
get_push_cib(call_queue)))
if is_push_corosync_conf_call_in(call_queue):
patcher_list.append(
patch_lib_env("push_corosync_conf",
get_push_corosync_conf(call_queue)))
for patcher in patcher_list:
patcher.start()
def unpatch():
for patcher in patcher_list:
patcher.stop()
return unpatch
def patch(target, *args, **kwargs):
return mock.patch("{0}.{1}".format(target_prefix, target), *args, **kwargs)
def test_success_read_content_from_file(self):
mock_open = mock.mock_open()
with mock.patch("pcs.lib.env_file.open", mock_open, create=True):
mock_open().read.return_value = "test booth\nconfig"
self.assertEqual("test booth\nconfig",
RealFile("some role", "/path/to.file").read())