def _fixture_get_env(self, cib_data=None, corosync_conf_data=None):
return LibraryEnvironment(
self.mock_logger,
self.mock_reporter,
cib_data=cib_data,
corosync_conf_data=corosync_conf_data,
)
def setUp(self):
self.mock_logger = mock.MagicMock(logging.Logger)
self.mock_reporter = MockLibraryReportProcessor()
self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
self.metadata = """
<resource-agent>
<shortdesc>short desc</shortdesc>
<longdesc>long desc</longdesc>
<parameters>
</parameters>
<actions>
</actions>
</resource-agent>
"""
self.description = {
"name":
"fence_dummy",
"shortdesc":
"short desc",
"longdesc":
"long desc",
"parameters": [],
"actions": [],
"default_actions": [{
"name": "monitor",
"interval": "60s",
"OCF_CHECK_LEVEL": None,
"automatic": None,
"depth": None,
"on_target": None,
"role": None,
"start-delay": None,
"timeout": None,
}],
}
def setUp(self):
self.mock_logger = mock.MagicMock(logging.Logger)
self.mock_reporter = MockLibraryReportProcessor()
mock.patch("pcs.lib.env.get_service_manager",
spec=ServiceManagerInterface).start()
self.addCleanup(mock.patch.stopall)
self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
def get_env(self, is_systemd=True):
self.__call_queue = CallQueue(self.__config.calls)
# pylint: disable=attribute-defined-outside-init
self._env = LibraryEnvironment(
mock.MagicMock(logging.Logger),
MockLibraryReportProcessor(),
cib_data=self.__config.env.cib_data,
corosync_conf_data=self.__config.env.corosync_conf_data,
known_hosts_getter=((lambda: self.__config.spy.known_hosts)
if self.__config.spy else
self.__config.env.known_hosts_getter),
booth_files_data=self.__config.env.booth,
)
self.__unpatch = patch_env(
self.__call_queue,
self.__config,
self._env,
is_systemd=is_systemd,
)
# If pushing corosync.conf has not been patched in the
# LibraryEnvironment, store any corosync.conf passed to the
# LibraryEnvironment for check for changes in cleanup.
if not is_push_corosync_conf_call_in(self.__call_queue):
self.__original_mocked_corosync_conf = (
self.__config.env.corosync_conf_data)
return self._env
def test_corosync_conf_not_set_need_offline_success(
self, mock_get_corosync, mock_distribute, mock_is_running,
mock_reload, mock_check_offline, mock_qdevice_reload):
corosync_data = open(rc("corosync.conf")).read()
new_corosync_data = corosync_data.replace("version: 2", "version: 3")
mock_get_corosync.return_value = corosync_data
mock_is_running.return_value = False
env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
self.assertTrue(env.is_corosync_conf_live)
self.assertEqual(corosync_data, env.get_corosync_conf_data())
self.assertEqual(corosync_data,
env.get_corosync_conf().config.export())
self.assertEqual(2, mock_get_corosync.call_count)
conf_facade = CorosyncConfigFacade.from_string(new_corosync_data)
conf_facade._need_stopped_cluster = True
env.push_corosync_conf(conf_facade)
mock_check_offline.assert_called_once_with("mock node communicator",
self.mock_reporter,
"mock node list", False)
mock_distribute.assert_called_once_with("mock node communicator",
self.mock_reporter,
"mock node list",
new_corosync_data, False)
mock_reload.assert_not_called()
mock_qdevice_reload.assert_not_called()
def setUp(self):
self.mock_log = mock.MagicMock(spec_set=logging.Logger)
self.mock_run = mock.MagicMock(spec_set=CommandRunner)
self.mock_rep = MockLibraryReportProcessor()
self.mock_env = LibraryEnvironment(self.mock_log,
self.mock_rep,
cib_data="<cib/>")
def test_corosync_conf_set(self, mock_get_corosync, mock_distribute,
mock_reload, mock_check_offline,
mock_qdevice_reload):
corosync_data = "totem {\n version: 2\n}\n"
new_corosync_data = "totem {\n version: 3\n}\n"
env = LibraryEnvironment(self.mock_logger,
self.mock_reporter,
corosync_conf_data=corosync_data)
self.assertFalse(env.is_corosync_conf_live)
self.assertEqual(corosync_data, env.get_corosync_conf_data())
self.assertEqual(corosync_data,
env.get_corosync_conf().config.export())
self.assertEqual(0, mock_get_corosync.call_count)
env.push_corosync_conf(
CorosyncConfigFacade.from_string(new_corosync_data))
self.assertEqual(0, mock_distribute.call_count)
self.assertEqual(new_corosync_data, env.get_corosync_conf_data())
self.assertEqual(0, mock_get_corosync.call_count)
mock_check_offline.assert_not_called()
mock_reload.assert_not_called()
mock_qdevice_reload.assert_not_called()
def test_get_cluster_conf_live(self, mock_get_local_cluster_conf):
env = LibraryEnvironment(
self.mock_logger, self.mock_reporter, cluster_conf_data=None
)
mock_get_local_cluster_conf.return_value = "cluster.conf data"
self.assertEqual("cluster.conf data", env.get_cluster_conf_data())
mock_get_local_cluster_conf.assert_called_once_with()
def test_get_cluster_conf(self):
env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
facade_obj = env.get_cluster_conf()
self.assertTrue(isinstance(facade_obj, ClusterConfFacade))
assert_xml_equal(
'<cluster/>', etree.tostring(facade_obj._config).decode()
)
def setUp(self):
self.mock_logger = mock.MagicMock(logging.Logger)
self.mock_reporter = MockLibraryReportProcessor()
self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
self.metadata = """
<resource-agent>
<shortdesc>short desc</shortdesc>
<longdesc>long desc</longdesc>
<parameters>
</parameters>
<actions>
</actions>
</resource-agent>
"""
self.description = {
"name": "ocf:test:Dummy",
"shortdesc": "short desc",
"longdesc": "long desc",
"parameters": [],
"actions": [],
"default_actions": [{
"interval": "60s",
"name": "monitor"
}],
}
def test_usergroups_set(self):
groups = ["some", "group"]
env = LibraryEnvironment(
self.mock_logger,
self.mock_reporter,
user_groups=groups
)
self.assertEqual(groups, env.user_groups)
def test_node_communicator_no_options(self, mock_comm):
expected_comm = mock.MagicMock()
mock_comm.return_value = expected_comm
env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
comm = env.node_communicator()
self.assertEqual(expected_comm, comm)
mock_comm.assert_called_once_with(self.mock_logger, self.mock_reporter,
{}, None, [])
def test_cmd_runner_no_options(self, mock_runner):
expected_runner = mock.MagicMock()
mock_runner.return_value = expected_runner
env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
runner = env.cmd_runner()
self.assertEqual(expected_runner, runner)
mock_runner.assert_called_once_with(self.mock_logger,
self.mock_reporter, {})
def test_get_cib_no_version_live(self, mock_get_cib_xml,
mock_ensure_cib_version):
mock_get_cib_xml.return_value = '<cib/>'
env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
assert_xml_equal('<cib/>', etree.tostring(env.get_cib()).decode())
self.assertEqual(1, mock_get_cib_xml.call_count)
self.assertEqual(0, mock_ensure_cib_version.call_count)
self.assertFalse(env.cib_upgraded)
def test_user_set(self):
user = "******"
env = LibraryEnvironment(
self.mock_logger,
self.mock_reporter,
user_login=user
)
self.assertEqual(user, env.user_login)
def test_push_cib_upgraded_live(self, mock_replace_cib):
env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
env._cib_upgraded = True
env.push_cib(etree.XML('<cib/>'))
mock_replace_cib.assert_called_once_with("mock cmd runner", '<cib/>',
True)
assert_report_item_list_equal(
env.report_processor.report_item_list,
[(severity.INFO, report_codes.CIB_UPGRADE_SUCCESSFUL, {})])
def test_get_cib_upgrade_live(self, mock_get_cib_xml,
mock_ensure_cib_version):
mock_get_cib_xml.return_value = '<cib/>'
mock_ensure_cib_version.return_value = etree.XML('<new_cib/>')
env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
assert_xml_equal('<new_cib/>',
etree.tostring(env.get_cib((1, 2, 3))).decode())
self.assertEqual(1, mock_get_cib_xml.call_count)
self.assertEqual(1, mock_ensure_cib_version.call_count)
self.assertTrue(env.cib_upgraded)
def cli_env_to_lib_env(cli_env):
return LibraryEnvironment(
logging.getLogger("old_cli"),
LibraryReportProcessorToConsole(cli_env.debug),
cli_env.user,
cli_env.groups,
cli_env.cib_data,
cli_env.corosync_conf_data,
booth=cli_env.booth,
auth_tokens_getter=cli_env.auth_tokens_getter,
cluster_conf_data=cli_env.cluster_conf_data,
)
def test_cmd_runner_all_options(self, mock_runner):
expected_runner = mock.MagicMock()
mock_runner.return_value = expected_runner
user = "******"
env = LibraryEnvironment(self.mock_logger,
self.mock_reporter,
user_login=user)
runner = env.cmd_runner()
self.assertEqual(expected_runner, runner)
mock_runner.assert_called_once_with(self.mock_logger,
self.mock_reporter,
{"CIB_user": user})
def cli_env_to_lib_env(cli_env):
return LibraryEnvironment(
logging.getLogger("pcs"),
cli_env.report_processor,
cli_env.user,
cli_env.groups,
cli_env.cib_data,
cli_env.corosync_conf_data,
booth_files_data=cli_env.booth,
known_hosts_getter=cli_env.known_hosts_getter,
request_timeout=cli_env.request_timeout,
)
def test_get_cib_upgrade_live(self, mock_get_cib_xml,
mock_ensure_cib_version):
mock_get_cib_xml.return_value = '<cib/>'
mock_ensure_cib_version.return_value = etree.XML('<new_cib/>')
env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
assert_xml_equal('<new_cib/>',
etree.tostring(env.get_cib((1, 2, 3))).decode())
self.assertEqual(1, mock_get_cib_xml.call_count)
self.assertEqual(1, mock_ensure_cib_version.call_count)
assert_report_item_list_equal(
env.report_processor.report_item_list,
[(severity.INFO, report_codes.CIB_UPGRADE_SUCCESSFUL, {})])
self.assertTrue(env.cib_upgraded)
def cli_env_to_lib_env(cli_env):
return LibraryEnvironment(
logging.getLogger("old_cli"),
LibraryReportProcessorToConsole(cli_env.debug),
cli_env.user,
cli_env.groups,
cli_env.cib_data,
cli_env.corosync_conf_data,
booth=cli_env.booth,
token_file_data_getter=cli_env.token_file_data_getter,
cluster_conf_data=cli_env.cluster_conf_data,
request_timeout=cli_env.request_timeout,
)
def test_cib_not_set(self, mock_get_cib, mock_push_cib):
cib_data = "test cib data"
new_cib_data = "new test cib data"
mock_get_cib.return_value = cib_data
env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
self.assertTrue(env.is_cib_live)
self.assertEqual(cib_data, env._get_cib_xml())
self.assertEqual(1, mock_get_cib.call_count)
env._push_cib_xml(new_cib_data)
self.assertEqual(1, mock_push_cib.call_count)
def get_env(self):
self.__call_queue = CallQueue(self.__config.calls)
#pylint: disable=attribute-defined-outside-init
self._env = LibraryEnvironment(
mock.MagicMock(logging.Logger),
MockLibraryReportProcessor(),
cib_data=self.__config.env.cib_data,
corosync_conf_data=self.__config.env.corosync_conf_data,
token_file_data_getter=((lambda: {
"tokens": self.__config.spy.auth_tokens,
"ports": self.__config.spy.ports or {},
}) if self.__config.spy else None))
self.__unpatch = patch_env(self.__call_queue, self.__config, self._env)
return self._env
def test_node_communicator_all_options(self, mock_comm):
expected_comm = mock.MagicMock()
mock_comm.return_value = expected_comm
user = "******"
groups = ["some", "group"]
tokens = {"node": "token"}
env = LibraryEnvironment(self.mock_logger,
self.mock_reporter,
user_login=user,
user_groups=groups,
auth_tokens_getter=lambda: tokens)
comm = env.node_communicator()
self.assertEqual(expected_comm, comm)
mock_comm.assert_called_once_with(self.mock_logger, self.mock_reporter,
tokens, user, groups)
def test_cib_set(self, mock_get_cib, mock_push_cib):
cib_data = "test cib data"
new_cib_data = "new test cib data"
env = LibraryEnvironment(self.mock_logger,
self.mock_reporter,
cib_data=cib_data)
self.assertFalse(env.is_cib_live)
self.assertEqual(cib_data, env._get_cib_xml())
self.assertEqual(0, mock_get_cib.call_count)
env._push_cib_xml(new_cib_data)
self.assertEqual(0, mock_push_cib.call_count)
self.assertEqual(new_cib_data, env._get_cib_xml())
self.assertEqual(0, mock_get_cib.call_count)
def test_dump_cib_file(self, mock_tmpfile, mock_runner):
expected_runner = mock.MagicMock()
mock_runner.return_value = expected_runner
mock_instance = mock.MagicMock()
mock_instance.name = rc("file.tmp")
mock_tmpfile.return_value = mock_instance
env = LibraryEnvironment(
self.mock_logger, self.mock_reporter, cib_data="<cib />"
)
runner = env.cmd_runner()
self.assertEqual(expected_runner, runner)
mock_runner.assert_called_once_with(
self.mock_logger,
self.mock_reporter,
{"LC_ALL": "C", "CIB_file": rc("file.tmp"),},
)
mock_tmpfile.assert_called_once_with("<cib />")
def setUp(self):
self.mock_log = mock.MagicMock(spec_set=logging.Logger)
self.mock_run = mock.MagicMock(spec_set=CommandRunner)
self.mock_rep = MockLibraryReportProcessor()
cib = """
<cib validate-with="pacemaker-2.5">
<configuration>
<alerts>
<alert id="alert" path="path"/>
<alert id="alert-1" path="/path"/>
</alerts>
</configuration>
</cib>
"""
self.mock_env = LibraryEnvironment(self.mock_log,
self.mock_rep,
cib_data=cib)
def setUp(self):
self.mock_log = mock.MagicMock(spec_set=logging.Logger)
self.mock_run = mock.MagicMock(spec_set=CommandRunner)
self.mock_rep = MockLibraryReportProcessor()
cib = """
<cib validate-with="pacemaker-2.5">
<configuration>
<alerts>
<alert id="alert" path="path">
<recipient id="alert-recipient" value="value1"/>
<recipient id="alert-recipient-1" value="value" description="d">
<meta_attributes
id="alert-recipient-1-meta_attributes"
>
<nvpair
id="alert-recipient-1-meta_attributes-attr1"
name="attr1"
value="val1"
/>
<nvpair
id="alert-recipient-1-meta_attributes-attr2"
name="attr2"
value="val2"
/>
</meta_attributes>
<instance_attributes
id="alert-recipient-1-instance_attributes"
>
<nvpair
id="alert-recipient-1-instance_attributes-attr1"
name="attr1"
value="val1"
/>
</instance_attributes>
</recipient>
</alert>
</alerts>
</configuration>
</cib>
"""
self.mock_env = LibraryEnvironment(self.mock_log,
self.mock_rep,
cib_data=cib)
def get_env(self):
self.__call_queue = CallQueue(self.__config.calls)
#pylint: disable=attribute-defined-outside-init
self._env = LibraryEnvironment(
mock.MagicMock(logging.Logger),
MockLibraryReportProcessor(),
cib_data=self.__config.env.cib_data,
corosync_conf_data=self.__config.env.corosync_conf_data,
token_file_data_getter=((lambda: {
"tokens": self.__config.spy.auth_tokens,
"ports": self.__config.spy.ports or {},
}) if self.__config.spy else None),
booth=self.__config.env.booth,
)
self.__unpatch = patch_env(self.__call_queue, self.__config, self._env)
# If pushing corosync.conf has not been patched in the
# LibraryEnvironment, store any corosync.conf passed to the
# LibraryEnvironment for check for changes in cleanup.
if not is_push_corosync_conf_call_in(self.__call_queue):
self.__original_mocked_corosync_conf = (
self.__config.env.corosync_conf_data)
return self._env
