def setUp(self): self.known_hosts = { "host{}".format(i): PcsKnownHost("host{}".format(i), "token{}".format(i), [ Destination("addr{}{}".format(i, j), "port{}{}".format(i, j)) for j in range(2) ]) for i in range(2) } self.report_processor = MockLibraryReportProcessor() self.factory = lib.NodeTargetLibFactory(self.known_hosts, self.report_processor)
def setUp(self): self.name = "booth_name" self.mock_env = _env_fixture(self.name) self.mock_rep = MockLibraryReportProcessor() self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_env.cmd_runner.return_value = self.mock_run self.mock_env.report_processor = self.mock_rep
def setUp(self): self.mock_reporter = MockLibraryReportProcessor() self.alert = etree.Element("alert", id="alert-1") self.recipient = etree.SubElement(self.alert, "recipient", id="rec-1", value="value1")
def test_failures(self): resources = etree.fromstring("<resources />") reporter = MockLibraryReportProcessor() lib.verify(reporter, self.get_cib(), resources, []) report = [ ( severity.ERROR, report_codes.STONITH_RESOURCES_DO_NOT_EXIST, { "stonith_ids": [ "d1", "d2", "d3", "d4", "d5", "dR", "dR-special" ], }, None ), ( severity.ERROR, report_codes.NODE_NOT_FOUND, { "node": "nodeA", }, None ), ( severity.ERROR, report_codes.NODE_NOT_FOUND, { "node": "nodeB", }, None ), ] assert_report_item_list_equal(reporter.report_item_list, report)
def fixture_env(cib): env = mock.MagicMock() env.get_cib = mock.Mock() env.get_cib.return_value = cib env.push_cib = mock.Mock() env.report_processor = MockLibraryReportProcessor() return env
def wrap_element_by_master(cib_file, resource_id, master_id=None): cib_tree = etree.parse(cib_file, etree.XMLParser(huge_tree=True)).getroot() element = cib_tree.find(f'.//*[@id="{resource_id}"]') final_master_id = (master_id if master_id is not None else f"{resource_id}-master") master_element = _xml_to_element(f""" <master id="{final_master_id}"> </master> """) element.getparent().append(master_element) master_element.append(element) final_xml = etree_to_str(cib_tree) environ = dict(os.environ) environ["CIB_file"] = cib_file runner = CommandRunner(mock.MagicMock(logging.Logger), MockLibraryReportProcessor(), environ) stdout, stderr, retval = runner.run([ "cibadmin", "--replace", "--scope", "resources", "--xml-pipe", ], stdin_string=final_xml) assert retval == 0, ("Error running wrap_element_by_master:\n" + stderr + "\n" + stdout)
def test_unknown_options_are_forceable(self): report_processor = MockLibraryReportProcessor() expected_errors = [ ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "site", "option_type": "booth ticket", "allowed": list(config_structure.TICKET_KEYS), }, ), ] assert_raise_library_error( lambda: config_structure.validate_ticket_options( report_processor, { "site": "a", "unknown": "c", }, allow_unknown_options=True, ), *expected_errors) assert_report_item_list_equal( report_processor.report_item_list, expected_errors + [ ( severities.WARNING, report_codes.INVALID_OPTION, { "option_name": "unknown", "option_type": "booth ticket", "allowed": list(config_structure.TICKET_KEYS), }, ), ])
def test_report_when_duplication_allowed(self, export_with_set): export_with_set.return_value = "exported_duplicate_element" element = mock.MagicMock() element.tag = "constraint_type" report_processor = MockLibraryReportProcessor() constraint.check_is_without_duplication( report_processor, fixture_constraint_section(["duplicate_element"]), element, are_duplicate=lambda e1, e2: True, export_element=constraint.export_with_set, duplication_alowed=True, ) assert_report_item_list_equal( report_processor.report_item_list, [ ( severities.WARNING, report_codes.DUPLICATE_CONSTRAINTS_EXIST, { 'constraint_info_list': ['exported_duplicate_element'], 'constraint_type': 'constraint_type' }, ) ] )
def test_success(self, mock_func): mock_com = mock.MagicMock(spec_set=NodeCommunicator) mock_rep = MockLibraryReportProcessor() watchdog_dict = dict([ (NodeAddresses("node" + str(i)), "/dev/watchdog" + str(i)) for i in range(5) ]) device_dict = dict([ (NodeAddresses("node" + str(i)), ["/dev/sdb" + str(i)]) for i in range(5) ]) node_list = list(watchdog_dict.keys()) config = { "opt1": "val1", "opt2": "val2" } lib_sbd.set_sbd_config_on_all_nodes( mock_rep, mock_com, node_list, config, watchdog_dict, device_dict ) mock_func.assert_called_once_with( lib_sbd.set_sbd_config_on_node, [ ( [ mock_rep, mock_com, node, config, watchdog_dict[node], device_dict[node] ], {} ) for node in node_list ] )
def test_success(self, mock_func): mock_com = mock.MagicMock(spec_set=NodeCommunicator) mock_rep = MockLibraryReportProcessor() node_list = [NodeAddresses("node" + str(i)) for i in range(2)] data = { node_list[0]: { "watchdog": "/dev/watchdog1", "device_list": ["/dev/sdb", "/dev/vda1"], }, node_list[1]: { "watchdog": "/dev/watchdog2", "device_list": ["/dev/sda2"], } } lib_sbd.check_sbd_on_all_nodes(mock_rep, mock_com, data) items = sorted(data.items()) mock_func.assert_called_once_with( lib_sbd.check_sbd_on_node, [ ( [ mock_rep, mock_com, node, data["watchdog"], data["device_list"] ], {} ) for node, data in items ] )
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 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_success_on_valid_options(self): report_processor = MockLibraryReportProcessor() config_structure.validate_ticket_options( report_processor, {"timeout": "10"}, allow_unknown_options=False, ) assert_report_item_list_equal(report_processor.report_item_list, [])
def test_empty(self): reporter = MockLibraryReportProcessor() lib._validate_devices(reporter, self.resources_el, []) report = [(severity.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, { "option_type": None, "option_names": ["stonith devices"], }, None)] assert_report_item_list_equal(reporter.report_item_list, report)
def test_success(self, mock_func): mock_com = mock.MagicMock(spec_set=NodeCommunicator) mock_rep = MockLibraryReportProcessor() node_list = [NodeAddresses("node" + str(i)) for i in range(5)] lib_sbd.disable_sbd_service_on_all_nodes(mock_rep, mock_com, node_list) mock_func.assert_called_once_with(lib_sbd.disable_sbd_service_on_node, [([mock_rep, mock_com, node], {}) for node in node_list])
def test_invalid(self): reporter = MockLibraryReportProcessor() lib._validate_devices(reporter, self.resources_el, ["dummy", "fenceX"]) report = [(severity.ERROR, report_codes.STONITH_RESOURCES_DO_NOT_EXIST, { "stonith_ids": ["dummy", "fenceX"], }, report_codes.FORCE_STONITH_RESOURCE_DOES_NOT_EXIST)] assert_report_item_list_equal(reporter.report_item_list, report)
def test_node_invalid(self): reporter = MockLibraryReportProcessor() lib._validate_target_valuewise(reporter, self.state, TARGET_TYPE_NODE, "rh7-x") report = [(severity.ERROR, report_codes.NODE_NOT_FOUND, { "node": "rh7-x", }, report_codes.FORCE_NODE_DOES_NOT_EXIST)] assert_report_item_list_equal(reporter.report_item_list, report)
def test_success(self): reporter = MockLibraryReportProcessor() lib._validate_level(reporter, 1) lib._validate_level(reporter, "1") lib._validate_level(reporter, 9) lib._validate_level(reporter, "9") lib._validate_level(reporter, "05") assert_report_item_list_equal(reporter.report_item_list, [])
def test_empty(self): resources = etree.fromstring("<resources />") topology = etree.fromstring("<fencing-topology />") reporter = MockLibraryReportProcessor() lib.verify(reporter, topology, resources, self.get_status()) assert_report_item_list_equal(reporter.report_item_list, [])
def test_remove_config_even_if_cannot_get_its_content_when_forced(self): env = _env_fixture("somename") env.report_processor = MockLibraryReportProcessor() commands.config_destroy(env, ignore_config_load_problems=True) env.booth.remove_config.assert_called_once_with() assert_report_item_list_equal( env.report_processor.report_item_list, [(Severities.WARNING, report_codes.BOOTH_CANNOT_IDENTIFY_KEYFILE, {})])
def test_success(self): resources = etree.fromstring("<resources />") for name in ["d1", "d2", "d3", "d4", "d5", "dR", "dR-special"]: self.fixture_resource(resources, name) reporter = MockLibraryReportProcessor() lib.verify(reporter, self.get_cib(), resources, self.get_status()) assert_report_item_list_equal(reporter.report_item_list, [])
def fixture_to_cib(cib_file, xml): environ = dict(os.environ) environ["CIB_file"] = cib_file runner = CommandRunner(mock.MagicMock(logging.Logger), MockLibraryReportProcessor(), environ) stdout, stderr, retval = runner.run( ["cibadmin", "--create", "--scope", "resources", "--xml-text", xml]) assert retval == 0, ("Error running fixture_to_cib:\n" + stderr + "\n" + stdout)
def test_success(self): reporter = MockLibraryReportProcessor() lib._validate_devices( reporter, self.resources_el, ["stonith1"] ) lib._validate_devices( reporter, self.resources_el, ["stonith1", "stonith2"] ) assert_report_item_list_equal(reporter.report_item_list, [])
def setUp(self): self.cib = "cib" self.report_processor = MockLibraryReportProcessor() self.find = partial( constraint.find_valid_resource_id, self.report_processor, self.cib, in_clone_allowed=False, )
def test_invalid(self): reporter = MockLibraryReportProcessor() lib._validate_target_typewise(reporter, "bad_target") report = [(severity.ERROR, report_codes.INVALID_OPTION_TYPE, { "option_name": "target", "allowed_types": ["node", "regular expression", "attribute_name=value"], }, None)] assert_report_item_list_equal(reporter.report_item_list, report)
def test_warn_when_config_exists_and_overwrite_allowed(self, mock_exists): report_processor = MockLibraryReportProcessor() self.check(report_processor, can_overwrite_existing=True) assert_report_item_list_equal(report_processor.report_item_list, [( severities.WARNING, report_codes.FILE_ALREADY_EXISTS, { "file_path": CONF_PATH }, )])
def test_node_invalid_not_forceable(self): reporter = MockLibraryReportProcessor() lib._validate_devices(reporter, self.resources_el, ["dummy", "fenceX"], allow_force=False) report = [(severity.ERROR, report_codes.STONITH_RESOURCES_DO_NOT_EXIST, { "stonith_ids": ["dummy", "fenceX"], }, None)] assert_report_item_list_equal(reporter.report_item_list, report)
def test_invalid_forced(self): reporter = MockLibraryReportProcessor() lib._validate_devices(reporter, self.resources_el, ["dummy", "fenceX"], force_device=True) report = [(severity.WARNING, report_codes.STONITH_RESOURCES_DO_NOT_EXIST, { "stonith_ids": ["dummy", "fenceX"], }, None)] assert_report_item_list_equal(reporter.report_item_list, report)
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_success(self, mock_find): mock_find.return_value = [] reporter = MockLibraryReportProcessor() lib._validate_level_target_devices_does_not_exist( reporter, "tree", "level", "target_type", "target_value", "devices") mock_find.assert_called_once_with("tree", "level", "target_type", "target_value", "devices") assert_report_item_list_equal(reporter.report_item_list, [])
def test_node_invalid_not_forceable(self): reporter = MockLibraryReportProcessor() lib._validate_target_valuewise(reporter, self.state, TARGET_TYPE_NODE, "rh7-x", allow_force=False) report = [(severity.ERROR, report_codes.NODE_NOT_FOUND, { "node": "rh7-x", }, None)] assert_report_item_list_equal(reporter.report_item_list, report)
class EnsureResourceState(TestCase): resource_id = "R" 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 fixture_running_state_info(self): return { "Started": ["node1"], "Master": ["node2"], "Slave": ["node3", "node4"], } def fixture_running_report(self, severity): return (severity, report_codes.RESOURCE_RUNNING_ON_NODES, { "resource_id": self.resource_id, "roles_with_nodes": self.fixture_running_state_info(), }) def fixture_not_running_report(self, severity): return (severity, report_codes.RESOURCE_DOES_NOT_RUN, { "resource_id": self.resource_id }) def assert_running_info_transform(self, run_info, report, expected_running): self.get_resource_roles_with_nodes.return_value = run_info state.ensure_resource_state( expected_running, self.report_processor, self.cluster_state, self.resource_id ) self.report_processor.assert_reports([report]) self.get_resource_roles_with_nodes.assert_called_once_with( self.cluster_state, self.resource_id ) def test_report_info_running(self): self.assert_running_info_transform( self.fixture_running_state_info(), self.fixture_running_report(severities.INFO), expected_running=True, ) def test_report_error_running(self): self.assert_running_info_transform( self.fixture_running_state_info(), self.fixture_running_report(severities.ERROR), expected_running=False, ) def test_report_error_not_running(self): self.assert_running_info_transform( [], self.fixture_not_running_report(severities.ERROR), expected_running=True, ) def test_report_info_not_running(self): self.assert_running_info_transform( [], self.fixture_not_running_report(severities.INFO), expected_running=False, )