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