def test_refuse_problem_combination(self): assert_raise_library_error( lambda: config_structure.validate_peers( site_list=["1.1.1.1"], arbitrator_list=["1.1.1.1"] ), ( severities.ERROR, report_codes.BOOTH_LACK_OF_SITES, { "sites": ["1.1.1.1"], } ), ( severities.ERROR, report_codes.BOOTH_EVEN_PEERS_NUM, { "number": 2, } ), ( severities.ERROR, report_codes.BOOTH_ADDRESS_DUPLICATION, { "addresses": set(["1.1.1.1"]), } ), )
def test_error_refresh(self): expected_stdout = "some info" expected_stderr = "some error" expected_retval = 1 mock_runner = mock.MagicMock(spec_set=CommandRunner) call_list = [ mock.call(self.crm_mon_cmd()), mock.call([self.path("crm_resource"), "--refresh"]), ] return_value_list = [ (self.fixture_status_xml(1, 1), "", 0), (expected_stdout, expected_stderr, expected_retval), ] mock_runner.run.side_effect = return_value_list assert_raise_library_error( lambda: lib.resource_refresh(mock_runner), ( Severity.ERROR, report_codes.RESOURCE_REFRESH_ERROR, { "reason": expected_stderr + "\n" + expected_stdout, } ) ) self.assertEqual(len(return_value_list), len(call_list)) self.assertEqual(len(return_value_list), mock_runner.run.call_count) mock_runner.run.assert_has_calls(call_list)
def test_raises_when_booth_config_in_use(self): env = _env_fixture("somename") assert_raise_library_error( lambda: commands.config_destroy(env), ( Severities.ERROR, report_codes.BOOTH_CONFIG_IS_USED, { "name": "somename", "detail": "in cluster resource", } ), ( Severities.ERROR, report_codes.BOOTH_CONFIG_IS_USED, { "name": "somename", "detail": "(enabled in systemd)", } ), ( Severities.ERROR, report_codes.BOOTH_CONFIG_IS_USED, { "name": "somename", "detail": "(running in systemd)", } ) )
def test_error(self): xml = "<xml/>" expected_stdout = "expected output" expected_stderr = "expected stderr" expected_retval = 1 mock_runner = get_runner( expected_stdout, expected_stderr, expected_retval ) assert_raise_library_error( lambda: lib.replace_cib_configuration( mock_runner, XmlManipulation.from_str(xml).tree ) , ( Severity.ERROR, report_codes.CIB_PUSH_ERROR, { "reason": expected_stderr, "pushed_cib": expected_stdout, } ) ) mock_runner.run.assert_called_once_with( [ self.path("cibadmin"), "--replace", "--verbose", "--xml-pipe", "--scope", "configuration" ], stdin_string=xml )
def test_unknown_permission(self): permissions = [ ("read", "id", "test-id"), ("unknown", "id", "another-id"), ("write", "xpath", "my xpath"), ("allow", "xpath", "xpath") ] assert_raise_library_error( lambda: lib.validate_permissions(self.tree, permissions), ( severities.ERROR, report_codes.INVALID_OPTION_VALUE, { "option_value": "unknown", "option_name": "permission", "allowed_values": self.allowed_permissions, }, None ), ( severities.ERROR, report_codes.INVALID_OPTION_VALUE, { "option_value": "allow", "option_name": "permission", "allowed_values": self.allowed_permissions, }, None ) )
def test_failed(self): device_list = ["/dev/sdb", "/dev/vda"] option_dict = { "watchdog-timeout": "10", # -1 "loop-timeout": "1", # -3 } error_msg = "error" self.mock_runner.run.return_value = "", error_msg, 1 assert_raise_library_error( lambda: lib_sbd.initialize_block_devices( self.mock_rep, self.mock_runner, device_list, option_dict ), ( Severities.ERROR, report_codes.SBD_DEVICE_INITIALIZATION_ERROR, { "device_list": device_list, "reason": error_msg, } ) ) cmd = [ settings.sbd_binary, "-d", "/dev/sdb", "-d", "/dev/vda", "-3", "1", "-1", "10", "create" ] self.mock_runner.run.assert_called_once_with(cmd) assert_report_item_list_equal( self.mock_rep.report_item_list, [( Severities.INFO, report_codes.SBD_DEVICE_INITIALIZATION_STARTED, {"device_list": device_list} )] )
def test_raises_when_is_under_another_context(self): tree = etree.fromstring(""" <cib> <resources> <group id="g1"><primitive id="a"/></group> <group id="g2"><primitive id="b"/></group> </resources> </cib> """) assert_raise_library_error( lambda: lib.find_element_by_tag_and_id( "primitive", tree.find('.//resources/group[@id="g2"]'), "a" ), ( severities.ERROR, report_codes.OBJECT_WITH_ID_IN_UNEXPECTED_CONTEXT, { "type": "primitive", "id": "a", "expected_context_type": "group", "expected_context_id": "g2", }, ), )
def test_unknown_scope(self): permissions = [ ("read", "id", "test-id"), ("write", "not_id", "test-id"), ("deny", "not_xpath", "some xpath"), ("read", "xpath", "xpath") ] assert_raise_library_error( lambda: lib.validate_permissions(self.tree, permissions), ( severities.ERROR, report_codes.INVALID_OPTION_VALUE, { "option_value": "not_id", "option_name": "scope type", "allowed_values": self.allowed_scopes, }, None ), ( severities.ERROR, report_codes.INVALID_OPTION_VALUE, { "option_value": "not_xpath", "option_name": "scope type", "allowed_values": self.allowed_scopes, }, None ) )
def test_sign_error(self, mock_tmp_store, mock_get_cert): mock_tmp_store.return_value = self.mock_tmpfile self.mock_runner.run.return_value = ("stdout", "tool output error", 1) assert_raise_library_error( lambda: lib.qdevice_sign_certificate_request( self.mock_runner, "certificate request", "clusterName" ), ( severity.ERROR, report_codes.QDEVICE_CERTIFICATE_SIGN_ERROR, { "reason": "tool output error\nstdout", } ) ) mock_tmp_store.assert_called_once_with( "certificate request", reports.qdevice_certificate_sign_error ) self.mock_runner.run.assert_called_once_with([ _qnetd_cert_tool, "-s", "-c", self.mock_tmpfile.name, "-n", "clusterName" ]) mock_get_cert.assert_not_called()
def test_enable_failed( self, mock_net_setup, mock_net_enable, mock_net_start ): mock_net_enable.side_effect = EnableServiceError( "test service", "test error" ) assert_raise_library_error( lambda: lib.qdevice_setup(self.lib_env, "net", True, True), ( severity.ERROR, report_codes.SERVICE_ENABLE_ERROR, { "service": "test service", "reason": "test error", } ) ) mock_net_setup.assert_called_once_with("mock_runner") mock_net_enable.assert_called_once_with("mock_runner", "corosync-qnetd") mock_net_start.assert_not_called() assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( severity.INFO, report_codes.QDEVICE_INITIALIZATION_SUCCESS, { "model": "net", } ) ] )
def test_failed(self, mock_net_stop, mock_status): mock_status.return_value = "" mock_net_stop.side_effect = StopServiceError( "test service", "test error" ) assert_raise_library_error( lambda: lib.qdevice_stop(self.lib_env, "net"), ( severity.ERROR, report_codes.SERVICE_STOP_ERROR, { "service": "test service", "reason": "test error", } ) ) mock_net_stop.assert_called_once_with("mock_runner", "corosync-qnetd") assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( severity.INFO, report_codes.SERVICE_STOP_STARTED, { "service": "quorum device", } ) ] )
def test_scope_error(self): expected_stdout = "some info" # yes, the numbers do not match, tested and verified with # pacemaker-2.0.0-1.fc29.1.x86_64 expected_stderr = ( "Call cib_query failed (-6): No such device or address" ) expected_retval = 105 scope = "test_scope" mock_runner = get_runner( expected_stdout, expected_stderr, expected_retval ) assert_raise_library_error( lambda: lib.get_cib_xml(mock_runner, scope=scope), ( Severity.ERROR, report_codes.CIB_LOAD_ERROR_SCOPE_MISSING, { "scope": scope, "reason": expected_stderr + "\n" + expected_stdout, } ) ) mock_runner.run.assert_called_once_with( [ self.path("cibadmin"), "--local", "--query", "--scope={0}".format(scope) ] )
def test_init_error(self, mock_destroy): self.mock_runner.run.return_value = ("stdout", "tool output error", 1) assert_raise_library_error( lambda: lib.client_setup( self.mock_runner, "qnetd CA certificate".encode("utf-8") ), ( severity.ERROR, report_codes.QDEVICE_INITIALIZATION_ERROR, { "model": "net", "reason": "tool output error\nstdout", } ) ) self.assertEqual( "qnetd CA certificate".encode("utf-8"), open(self.ca_file_path, "rb").read() ) self.mock_runner.run.assert_called_once_with([ _client_cert_tool, "-i", "-c", self.ca_file_path ]) mock_destroy.assert_called_once_with()
def test_invalid_target(self): assert_raise_library_error( lambda: lib.remove_levels_by_params( self.reporter, self.tree, target_type="bad_target", target_value="nodeA" ), ( severity.ERROR, report_codes.INVALID_OPTION_TYPE, { "option_name": "target", "allowed_types": [ "node", "regular expression", "attribute_name=value" ] }, None ), ) self.assertEqual( self.get_remaining_ids(), [ "fl1", "fl2", "fl3", "fl4", "fl5", "fl6", "fl7", "fl8", "fl9", "fl10" ] )
def test_raises_when_id_does_not_exists(self): tree = etree.fromstring('<cib><resources/></cib>') assert_raise_library_error( lambda: find_group(tree.find('.//resources'), "a"), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "a", "expected_types": ["group"], "context_type": "resources", "context_id": "", }, None ), ) assert_raise_library_error( lambda: find_group( tree.find('.//resources'), "a", id_types=["resource group"] ), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "a", "expected_types": ["resource group"], "context_type": "resources", "context_id": "", }, None ), )
def test_not_existing_id(self): permissions = [ ("read", "id", "test-id"), ("write", "id", "id"), ("deny", "id", "last"), ("write", "xpath", "maybe xpath") ] assert_raise_library_error( lambda: lib.validate_permissions(self.tree, permissions), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "id", "expected_types": ["id"], "context_type": "", "context_id": "", }, None ), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "last", "expected_types": ["id"], "context_type": "", "context_id": "", }, None ) )
def test_import_error(self, mock_tmp_store): mock_tmp_store.return_value = self.mock_tmpfile self.mock_runner.run.return_value = ("stdout", "tool output error", 1) assert_raise_library_error( lambda: lib.client_import_certificate_and_key( self.mock_runner, "pk12 certificate" ), ( severity.ERROR, report_codes.QDEVICE_CERTIFICATE_IMPORT_ERROR, { "reason": "tool output error\nstdout", } ) ) mock_tmp_store.assert_called_once_with( "pk12 certificate", reports.qdevice_certificate_import_error ) mock_tmp_store.assert_called_once_with( "pk12 certificate", reports.qdevice_certificate_import_error ) self.mock_runner.run.assert_called_once_with([ _client_cert_tool, "-m", "-c", self.mock_tmpfile.name ])
def test_cannot_read_file(self): cert_tool_output = dedent( """ some line Certificate request stored in {0}.bad some other line """.format(self.file_path) ) report_func = reports.qdevice_certificate_import_error assert_raise_library_error( lambda: lib._get_output_certificate( cert_tool_output, report_func ), ( severity.ERROR, report_codes.QDEVICE_CERTIFICATE_IMPORT_ERROR, { "reason": "{0}.bad: No such file or directory".format( self.file_path ), } ) )
def test_error_on_no_device(self): config = open(rc("corosync-3nodes.conf")).read() facade = lib.ConfigFacade.from_string(config) assert_raise_library_error( facade.remove_quorum_device_heuristics, fixture.error(report_codes.QDEVICE_NOT_DEFINED) ) self.assertFalse(facade.need_stopped_cluster) self.assertFalse(facade.need_qdevice_reload)
def test_error_on_empty_config(self): config = "" facade = lib.ConfigFacade.from_string(config) assert_raise_library_error( facade.remove_quorum_device_heuristics, fixture.error(report_codes.QDEVICE_NOT_DEFINED) ) self.assertFalse(facade.need_stopped_cluster) self.assertFalse(facade.need_qdevice_reload)
def test_refuse_invalid_id(self): assert_raise_library_error( lambda: lib.create_role(self.cib.tree, '#invalid'), ( severities.ERROR, report_codes.INVALID_ID, {'id': '#invalid'}, ), )
def test_existing_id(self): assert_raise_library_error( lambda: lib.create_group(self.acls, "group2"), ( severities.ERROR, report_codes.ID_ALREADY_EXISTS, {"id": "group2"} ) )
def test_target_id_is_not_unique_target_id(self): assert_raise_library_error( lambda: lib.create_target(self.acls, "target2"), ( severities.ERROR, report_codes.CIB_ACL_TARGET_ALREADY_EXISTS, {"target_id":"target2"} ) )
def test_refuse_missing_ticket(self, _): assert_raise_library_error( lambda: self.prepare({"loss-policy": "stop", "id": "id"}), ( severities.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, {"option_names": ["ticket"]} ) )
def test_id_exists(self): assert_raise_library_error( lambda: alert.create_alert(self.tree, "alert", "/path"), ( severities.ERROR, report_codes.ID_ALREADY_EXISTS, {"id": "alert"} ) )
def test_not_systemd(self, mock_is_systemctl): mock_is_systemctl.return_value = False assert_raise_library_error( lib.ensure_is_systemd, ( severity.ERROR, report_codes.UNSUPPORTED_OPERATION_ON_NON_SYSTEMD_SYSTEMS, {} ) )
def test_parse_error_missing_brace(): config = "section {" assert_raise_library_error( lambda: lib.ConfigFacade.from_string(config), ( severity.ERROR, report_codes.PARSE_ERROR_COROSYNC_CONF_MISSING_CLOSING_BRACE, {} ) )
def test_parse_error_unexpected_brace(): config = "}" assert_raise_library_error( lambda: lib.ConfigFacade.from_string(config), ( severity.ERROR, report_codes.PARSE_ERROR_COROSYNC_CONF_UNEXPECTED_CLOSING_BRACE, {} ) )
def test_ensure_support_error(self, mock_obj): mock_obj.return_value = False assert_raise_library_error( lambda: lib.ensure_wait_for_idle_support(mock.Mock()), ( Severity.ERROR, report_codes.WAIT_FOR_IDLE_NOT_SUPPORTED, {} ) )
def assert_result_causes_invalid_format(self, result): assert_raise_library_error( lambda: node_communication_format.response_to_result( result, self.main_key, self.expected_keys, self.node_label, ), fixture_invalid_response_format(self.node_label) )
def test_refuse_unknown_attributes(self, _): assert_raise_library_error( lambda: self.prepare({ "score": "1", "unknown": "value", "id": "id", }), ( severities.ERROR, report_codes.INVALID_OPTIONS, { "option_names": ["unknown"], "option_type": None, "allowed": [ "id", "score", "score-attribute", "score-attribute-mangle", ], "allowed_patterns": [], }, ), )
def test_init_error(self, mock_destroy): self.mock_runner.run.return_value = ("stdout", "tool output error", 1) assert_raise_library_error( lambda: lib.client_setup( self.mock_runner, "qnetd CA certificate".encode("utf-8") ), ( severity.ERROR, report_codes.QDEVICE_INITIALIZATION_ERROR, { "model": "net", "reason": "tool output error\nstdout", }, ), ) with open(self.ca_file_path, "rb") as a_file: file_content = a_file.read() self.assertEqual("qnetd CA certificate".encode("utf-8"), file_content) self.mock_runner.run.assert_called_once_with( [_client_cert_tool, "-i", "-c", self.ca_file_path] ) mock_destroy.assert_called_once_with()
def test_error_refresh(self): expected_stdout = "some info" expected_stderr = "some error" expected_retval = 1 mock_runner = mock.MagicMock(spec_set=CommandRunner) call_list = [ mock.call(self.crm_mon_cmd()), mock.call([self.path("crm_resource"), "--refresh"]), ] return_value_list = [ (self.fixture_status_xml(1, 1), "", 0), (expected_stdout, expected_stderr, expected_retval), ] mock_runner.run.side_effect = return_value_list assert_raise_library_error( lambda: lib.resource_refresh(mock_runner), (Severity.ERROR, report_codes.RESOURCE_REFRESH_ERROR, { "reason": expected_stderr + "\n" + expected_stdout, })) self.assertEqual(len(return_value_list), len(call_list)) self.assertEqual(len(return_value_list), mock_runner.run.call_count) mock_runner.run.assert_has_calls(call_list)
def test_error(self): expected_stdout = "some info" expected_stderr = "some error" expected_retval = 1 mock_runner = get_runner( expected_stdout, expected_stderr, expected_retval ) assert_raise_library_error( lambda: lib.get_cib_xml(mock_runner), ( Severity.ERROR, report_codes.CIB_LOAD_ERROR, { "reason": expected_stderr + "\n" + expected_stdout, } ) ) mock_runner.run.assert_called_once_with( [self.path("cibadmin"), "--local", "--query"] )
def test_error_running_simulate(self, mock_write_tmpfile): tmpfile_new_cib = mock.MagicMock() tmpfile_new_cib.name = rc("new_cib.tmp") tmpfile_transitions = mock.MagicMock() tmpfile_transitions.name = rc("transitions.tmp") mock_write_tmpfile.side_effect = [tmpfile_new_cib, tmpfile_transitions] expected_stdout = "some stdout" expected_stderr = "some error" expected_retval = 1 mock_runner = get_runner( expected_stdout, expected_stderr, expected_retval ) assert_raise_library_error( lambda: lib.simulate_cib_xml(mock_runner, "<cib />"), fixture.error( report_codes.CIB_SIMULATE_ERROR, reason="some error", cib="<cib />", ), )
def test_wait_error_timeout(self): expected_stdout = "some info" expected_stderr = "some error" expected_retval = 124 mock_runner = get_runner( expected_stdout, expected_stderr, expected_retval ) assert_raise_library_error( lambda: lib.wait_for_idle(mock_runner), ( Severity.ERROR, report_codes.WAIT_FOR_IDLE_TIMED_OUT, { "reason": expected_stderr + "\n" + expected_stdout, } ) ) mock_runner.run.assert_called_once_with( [self.path("crm_resource"), "--wait"] )
def test_stop_failed(self, mock_net_destroy, mock_net_disable, mock_net_stop, mock_status): mock_status.return_value = "" mock_net_stop.side_effect = StopServiceError("test service", "test error") assert_raise_library_error( lambda: lib.qdevice_destroy(self.lib_env, "net"), ( severity.ERROR, reports.codes.SERVICE_ACTION_FAILED, { "action": reports.const.SERVICE_ACTION_STOP, "service": "test service", "reason": "test error", "node": "", "instance": "", }, ), ) mock_net_stop.assert_called_once_with("mock_runner", "corosync-qnetd") mock_net_disable.assert_not_called() mock_net_destroy.assert_not_called() assert_report_item_list_equal( self.mock_reporter.report_item_list, [( severity.INFO, reports.codes.SERVICE_ACTION_STARTED, { "action": reports.const.SERVICE_ACTION_STOP, "service": "quorum device", "instance": "", }, )], )
def test_unknown_options_are_forceable(self): report_processor = MockLibraryReportProcessor() expected_errors = [ ( severities.ERROR, report_codes.INVALID_OPTIONS, { "option_names": ["site"], "option_type": "booth ticket", "allowed": list(config_structure.TICKET_KEYS), "allowed_patterns": [], }, ), ] 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_OPTIONS, { "option_names": ["unknown"], "option_type": "booth ticket", "allowed": list(config_structure.TICKET_KEYS), "allowed_patterns": [], }, ), ])
def test_empty_options(self): assert_raise_library_error( lambda: cmd_sbd.set_message(self.env, "", "", "")) assert_report_item_list_equal( self.env.report_processor.report_item_list, [ ( Severities.ERROR, reports.codes.REQUIRED_OPTIONS_ARE_MISSING, { "option_names": ["device", "node"], "option_type": None, }, ), fixture.error( reports.codes.INVALID_OPTION_VALUE, option_name="message", option_value="", allowed_values=settings.sbd_message_types, cannot_be_empty=False, forbidden_characters=None, ), ], )
def test_refuse_unknown_lost_policy(self, mock_check_new_id_applicable): # pylint: disable=unused-argument assert_raise_library_error( lambda: self.prepare( { "loss-policy": "unknown", "ticket": "T", "id": "id" }, "ticket_key", "resourceA", ), ( severities.ERROR, report_codes.INVALID_OPTION_VALUE, { "allowed_values": ("fence", "stop", "freeze", "demote"), "option_value": "unknown", "option_name": "loss-policy", "cannot_be_empty": False, "forbidden_characters": None, }, ), )
def test_refuse_unknown_attributes(self, _): assert_raise_library_error( lambda: self.prepare( {"unknown": "nonsense", "rsc-role": "master"}, "ticket_key", "resourceA", ), ( severities.ERROR, report_codes.INVALID_OPTIONS, { "option_names": ["unknown"], "option_type": None, "allowed": [ "id", "loss-policy", "rsc", "rsc-role", "ticket", ], "allowed_patterns": [], }, ), )
def test_used_not_forced(self, mock_net_destroy, mock_status): mock_status.return_value = 'Cluster "a_cluster":\n' assert_raise_library_error( lambda: lib.qdevice_destroy(self.lib_env, "net")) assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( severity.ERROR, report_codes.QDEVICE_USED_BY_CLUSTERS, { "clusters": ["a_cluster"], }, report_codes.FORCE, ), ], ) self.assertEqual( self.lib_env.service_manager.method_calls, [], ) mock_net_destroy.assert_not_called()
def test_failed(self, mock_qdevice_initialized): self.lib_env.service_manager.start.side_effect = StartServiceError( "test service", "test error") mock_qdevice_initialized.return_value = True assert_raise_library_error( lambda: lib.qdevice_start(self.lib_env, "net"), ( severity.ERROR, reports.codes.SERVICE_ACTION_FAILED, { "action": reports.const.SERVICE_ACTION_START, "service": "test service", "reason": "test error", "node": "", "instance": "", }, ), ) self.assertEqual( self.lib_env.service_manager.method_calls, [mock.call.start("corosync-qnetd")], ) mock_qdevice_initialized.assert_called_once_with() assert_report_item_list_equal( self.mock_reporter.report_item_list, [( severity.INFO, reports.codes.SERVICE_ACTION_STARTED, { "action": reports.const.SERVICE_ACTION_START, "service": "quorum device", "instance": "", }, )], )
def test_invalid_character(self): desc = "test id" info = { "id": "", "id_description": desc, "invalid_character": "", "is_first_char": False, } report = (severity.ERROR, report_codes.INVALID_ID, info) info["id"] = "dum:my" info["invalid_character"] = ":" assert_raise_library_error( lambda: lib.validate_id("dum:my", desc), report ) info["id"] = "dummy:" info["invalid_character"] = ":" assert_raise_library_error( lambda: lib.validate_id("dummy:", desc), report ) info["id"] = "dum?my" info["invalid_character"] = "?" assert_raise_library_error( lambda: lib.validate_id("dum?my", desc), report ) info["id"] = "dummy?" info["invalid_character"] = "?" assert_raise_library_error( lambda: lib.validate_id("dummy?", desc), report )
def test_invalid_first_character(self): desc = "test id" info = { "id": "", "id_description": desc, "invalid_character": "", "is_first_char": True, } report = (severity.ERROR, report_codes.INVALID_ID_BAD_CHAR, info) info["id"] = "0" info["invalid_character"] = "0" assert_raise_library_error(lambda: lib.validate_id("0", desc), report) info["id"] = "-" info["invalid_character"] = "-" assert_raise_library_error(lambda: lib.validate_id("-", desc), report) info["id"] = "." info["invalid_character"] = "." assert_raise_library_error(lambda: lib.validate_id(".", desc), report) info["id"] = ":" info["invalid_character"] = ":" assert_raise_library_error(lambda: lib.validate_id(":", desc), report) info["id"] = "0dummy" info["invalid_character"] = "0" assert_raise_library_error(lambda: lib.validate_id("0dummy", desc), report) info["id"] = "-dummy" info["invalid_character"] = "-" assert_raise_library_error(lambda: lib.validate_id("-dummy", desc), report) info["id"] = ".dummy" info["invalid_character"] = "." assert_raise_library_error(lambda: lib.validate_id(".dummy", desc), report) info["id"] = ":dummy" info["invalid_character"] = ":" assert_raise_library_error(lambda: lib.validate_id(":dummy", desc), report)
def test_invalid_xml(self): xml = "<invalid><xml />" assert_raise_library_error( lambda: lib.get_cib(xml), (Severity.ERROR, report_codes.CIB_LOAD_ERROR_BAD_FORMAT, {}))
def test_ensure_support_error(self, mock_obj): mock_obj.return_value = False assert_raise_library_error( lambda: lib.ensure_wait_for_idle_support(mock.Mock()), (Severity.ERROR, report_codes.WAIT_FOR_IDLE_NOT_SUPPORTED, {}))
def test_not_systemd(self, mock_is_systemctl): mock_is_systemctl.return_value = False assert_raise_library_error( lib.ensure_is_systemd, (severity.ERROR, report_codes.UNSUPPORTED_OPERATION_ON_NON_SYSTEMD_SYSTEMS, {}))
def test_file_error(self, mock_config): mock_config.side_effect = LibraryError( ReportItem.error(report_codes.UNABLE_TO_GET_SBD_CONFIG, )) assert_raise_library_error( lambda: cmd_sbd.get_local_sbd_config(self.mock_env), (Severities.ERROR, report_codes.UNABLE_TO_GET_SBD_CONFIG, {}))
def test_target_id_is_not_unique_target_id(self): assert_raise_library_error( lambda: lib.create_target(self.acls, "target2"), (severities.ERROR, report_codes.CIB_ACL_TARGET_ALREADY_EXISTS, { "target_id": "target2" }))
def test_existing_id(self): assert_raise_library_error( lambda: lib.create_group(self.acls, "group2"), (severities.ERROR, report_codes.ID_ALREADY_EXISTS, { "id": "group2" }))
def test_raises_when_is_not_live(self): env = self.env_fake assert_raise_library_error( lambda: env.ensure_wait_satisfiable(10), (severity.ERROR, report_codes.WAIT_FOR_IDLE_NOT_LIVE_CLUSTER, {}, None))
def test_invalid_empty(self): assert_raise_library_error(lambda: lib.validate_id("", "test id"), (severity.ERROR, report_codes.EMPTY_ID, { "id": "", "id_description": "test id", }))
def test_parse_error_missing_brace(): config = "section {" assert_raise_library_error( lambda: lib.ConfigFacade.from_string(config), (severity.ERROR, report_codes.PARSE_ERROR_COROSYNC_CONF_MISSING_CLOSING_BRACE, {}))
def test_refuse_invalid_xml(self): assert_raise_library_error( lambda: ClusterState('invalid xml'), (severities.ERROR, report_codes.BAD_CLUSTER_STATE_FORMAT, {}))
def test_id_exists(self): assert_raise_library_error( lambda: alert.create_alert(self.tree, "alert", "/path"), (severities.ERROR, report_codes.ID_ALREADY_EXISTS, {"id": "alert"}), )