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_error_3(self): node_id = "id_1" node_name = "name_1" node_status = self.fixture_get_node_status(node_name, node_id) self.fixture_add_node_status(node_status) mock_runner = mock.MagicMock(spec_set=CommandRunner) call_list = [ mock.call(self.crm_mon_cmd()), mock.call([self.path("crm_node"), "--cluster-id"]), mock.call( [self.path("crm_node"), "--name-for-id={0}".format(node_id)] ), ] return_value_list = [ (str(self.status), "", 0), (node_id, "", 0), ("(null)", "", 0), ] mock_runner.run.side_effect = return_value_list assert_raise_library_error( lambda: lib.get_local_node_status(mock_runner), ( Severity.ERROR, report_codes.PACEMAKER_LOCAL_NODE_NAME_NOT_FOUND, {"reason": "node name is null"} ) ) 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_cleanup(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"), "--cleanup"]), ] 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_cleanup(mock_runner), ( Severity.ERROR, report_codes.RESOURCE_CLEANUP_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_scope_error(self): expected_stdout = "some info" expected_stderr = "some error" expected_retval = 6 scope = "test_scope" mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( 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_error(self): xml = "<xml/>" expected_stdout = "expected output" expected_stderr = "expected stderr" expected_retval = 1 mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( 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_error_one_node(self): expected_stdout = "some info" expected_stderr = "some error" expected_retval = 1 mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( expected_stdout, expected_stderr, expected_retval ) assert_raise_library_error( lambda: lib.nodes_unstandby(mock_runner), ( Severity.ERROR, report_codes.COMMON_ERROR, { "text": expected_stderr + "\n" + expected_stdout, } ) ) mock_runner.run.assert_called_once_with( [self.path("crm_standby"), "-D"] )
def assert_wait_fail(self, command, cib_resources_xml): wait_error_message = outdent( """\ Pending actions: Action 39: stonith-vm-rhel72-1-reboot on vm-rhel72-1 Error performing operation: Timer expired """ ) runner.set_runs(fixture_pre_timeout_calls(cib_resources_xml) + [ Call( "crm_resource --wait --timeout=10", stderr=wait_error_message, returncode=62, ), ]) assert_raise_library_error( command, ( severities.ERROR, report_codes.WAIT_FOR_IDLE_TIMED_OUT, { "reason": wait_error_message.strip(), }, None ) ) runner.assert_everything_launched()
def test_wait_error_timeout(self): expected_stdout = "some info" expected_stderr = "some error" expected_retval = 62 mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( expected_stdout, expected_stderr, expected_retval ) assert_raise_library_error( lambda: lib.wait_for_resources(mock_runner), ( Severity.ERROR, report_codes.RESOURCE_WAIT_TIMED_OUT, { "reason": expected_stderr + "\n" + expected_stdout, } ) ) mock_runner.run.assert_called_once_with( [self.path("crm_resource"), "--wait"] )
def test_refuse_bad_permission_and_bad_scope_type(self): role_id = 'role1' self.fixture_add_role(role_id) assert_raise_library_error( lambda: lib.add_permissions_to_role( self.cib.tree, role_id, [('readX', 'xpathX', '/whatever')] ), ( severities.ERROR, report_codes.INVALID_OPTION_VALUE, { "option_name": "permission", "option_value": "readX", "allowed_values": ["read", "write", "deny"], } ), ( severities.ERROR, report_codes.INVALID_OPTION_VALUE, { "option_name": "scope type", "option_value": "xpathX", "allowed_values": ["xpath", "id"], } ), )
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_node_down(self): nodes = ["node1", "node2"] node_addrs_list = NodeAddressesList([NodeAddresses(addr) for addr in nodes]) def side_effect(node, request, data): if node.ring0 == nodes[1]: raise NodeAuthenticationException(nodes[1], "command", "HTTP error: 401") return '{"corosync": false}' self.mock_communicator.call_node.side_effect = side_effect assert_raise_library_error( lambda: lib.check_corosync_offline_on_nodes(self.mock_communicator, self.mock_reporter, node_addrs_list), ( severity.ERROR, report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {"node": nodes[1], "command": "command", "reason": "HTTP error: 401"}, report_codes.SKIP_OFFLINE_NODES, ), ( severity.ERROR, report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR, {"node": nodes[1]}, report_codes.SKIP_OFFLINE_NODES, ), )
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_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", "id_description": "group", "context_type": "resources", "context_id": "", }, ), ) assert_raise_library_error( lambda: find_group( tree.find('.//resources'), "a", id_description="resource group" ), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "a", "id_description": "resource group", }, ), )
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", "id_description": "id", } ), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "last", "id_description": "id", } ) )
def test_two_agents_exception(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = ( self.mock_runner_side_effect + [ ("<resource-agent />", "", 0), ("<resource-agent />", "", 0), ] ) assert_raise_library_error( lambda: lib_ra.guess_exactly_one_resource_agent_full_name( mock_runner, "dummy" ), ( severity.ERROR, report_codes.AGENT_NAME_GUESS_FOUND_MORE_THAN_ONE, { "agent": "dummy", "possible_agents": [ "ocf:heartbeat:Dummy", "ocf:pacemaker:Dummy" ], } ), )
def test_watchdog_does_not_exist_and_sbd_not_installed( self, mock_check_sbd ): mock_check_sbd.return_value = json.dumps({ "sbd": { "installed": False }, "watchdog": { "exist": False } }) assert_raise_library_error( lambda: lib_sbd.check_sbd_on_node( self.mock_rep, self.mock_com, self.node, "watchdog" ), ( Severities.ERROR, report_codes.WATCHDOG_NOT_FOUND, {"node": self.node.label} ), ( Severities.ERROR, report_codes.SBD_NOT_INSTALLED, {"node": self.node.label} ) ) mock_check_sbd.assert_called_once_with( self.mock_com, self.node, "watchdog" ) self.assertEqual(0, len(self.mock_rep.report_item_list))
def test_unable_to_parse_upgraded_cib(self, mock_named_file): mock_file = mock.MagicMock() mock_file.name = "mock_file_name" mock_file.read.return_value = "not xml" mock_named_file.return_value = mock_file self.mock_runner.run.return_value = ("", "", 0) assert_raise_library_error( lambda: lib.upgrade_cib(etree.XML("<old_cib/>"), self.mock_runner), ( severities.ERROR, report_codes.CIB_UPGRADE_FAILED, { "reason": "Start tag expected, '<' not found, line 1, column 1", } ) ) mock_named_file.assert_called_once_with("w+", suffix=".pcs") mock_file.write.assert_called_once_with("<old_cib/>") mock_file.flush.assert_called_once_with() self.mock_runner.run.assert_called_once_with( [ join(settings.pacemaker_binaries, "cibadmin"), "--upgrade", "--force" ], env_extend={"CIB_file": "mock_file_name"} ) mock_file.seek.assert_called_once_with(0) mock_file.read.assert_called_once_with()
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_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_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_transform_error(self, mock_tmp_store, mock_get_cert): mock_tmp_store.return_value = self.mock_tmpfile self.mock_runner.run.return_value = ("tool output error", 1) assert_raise_library_error( lambda: lib.client_cert_request_to_pk12( self.mock_runner, "certificate request" ), ( severity.ERROR, report_codes.QDEVICE_CERTIFICATE_IMPORT_ERROR, { "reason": "tool output error", } ) ) mock_tmp_store.assert_called_once_with( "certificate request", reports.qdevice_certificate_import_error ) self.mock_runner.run.assert_called_once_with([ _client_cert_tool, "-M", "-c", self.mock_tmpfile.name ]) mock_get_cert.assert_not_called()
def test_import_error(self, mock_tmp_store): mock_tmp_store.return_value = self.mock_tmpfile self.mock_runner.run.return_value = ("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", } ) ) 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_sign_error(self, mock_tmp_store, mock_get_cert): mock_tmp_store.return_value = self.mock_tmpfile self.mock_runner.run.return_value = ("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", } ) ) 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_raises_when_booth_config_in_use(self): env = mock.MagicMock() env.booth.name = "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_upgrade_failed(self, mock_named_file): mock_file = mock.MagicMock() mock_file.name = "mock_file_name" mock_named_file.return_value = mock_file self.mock_runner.run.return_value = ("some info", "some error", 1) assert_raise_library_error( lambda: lib.upgrade_cib(etree.XML("<old_cib/>"), self.mock_runner), ( severities.ERROR, report_codes.CIB_UPGRADE_FAILED, { "reason": "some error\nsome info", } ) ) mock_named_file.assert_called_once_with("w+", suffix=".pcs") mock_file.write.assert_called_once_with("<old_cib/>") mock_file.flush.assert_called_once_with() self.mock_runner.run.assert_called_once_with( [ join(settings.pacemaker_binaries, "cibadmin"), "--upgrade", "--force" ], env_extend={"CIB_file": "mock_file_name"} )
def test_invalid_input(self, mock_pull): mock_pull.return_value = {} assert_raise_library_error( lambda: commands.pull_config(self.mock_env, "node", "name"), ( Severities.ERROR, report_codes.INVALID_RESPONSE_FORMAT, {"node": "node"} ) ) mock_pull.assert_called_once_with( self.mock_com, NodeAddresses("node"), "name" ) self.assertEqual(0, self.mock_env.booth.create_config.call_count) self.assertEqual(0, self.mock_env.booth.set_key_path.call_count) self.assertEqual(0, self.mock_env.booth.create_key.call_count) assert_report_item_list_equal( self.mock_rep.report_item_list, [( Severities.INFO, report_codes.BOOTH_FETCHING_CONFIG_FROM_NODE, { "node": "node", "config": "name" } )] )
def test_init_error(self, mock_destroy): self.mock_runner.run.return_value = ("tool output error", 1) assert_raise_library_error( lambda: lib.client_setup( self.mock_runner, "certificate data".encode("utf-8") ), ( severity.ERROR, report_codes.QDEVICE_INITIALIZATION_ERROR, { "model": "net", "reason": "tool output error", } ) ) self.assertEqual( "certificate data".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_json_error(self): nodes = ["node1", "node2"] node_addrs_list = NodeAddressesList( [NodeAddresses(addr) for addr in nodes] ) self.mock_communicator.call_node.side_effect = [ '{}', # missing key '{', # not valid json ] assert_raise_library_error( lambda: lib.check_corosync_offline_on_nodes( self.mock_communicator, self.mock_reporter, node_addrs_list ), ( severity.ERROR, report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR, { "node": nodes[0], }, report_codes.SKIP_OFFLINE_NODES ), ( severity.ERROR, report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR, { "node": nodes[1], }, report_codes.SKIP_OFFLINE_NODES ) )
def test_error(self): expected_stdout = "some info" expected_stderr = "some error" expected_retval = 1 mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( 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_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_invalid_version(self): assert_raise_library_error( lambda: lib.get_cib_crm_feature_set( etree.XML('<cib crm_feature_set="3" />') ), fixture.error( report_codes.CIB_LOAD_ERROR_BAD_FORMAT, reason=( "the attribute 'crm_feature_set' of the element 'cib' has " "an invalid value: '3'" ) ) )
def test_missing_attribute(self): assert_raise_library_error( lambda: lib.get_cib_crm_feature_set( etree.XML("<cib />") ), fixture.error( report_codes.CIB_LOAD_ERROR_BAD_FORMAT, reason=( "the attribute 'crm_feature_set' of the element 'cib' is " "missing" ) ) )
def test_raise_if_missing(self): for section in self.cib.tree.findall(".//configuration/resources"): section.getparent().remove(section) assert_raise_library_error( lambda: lib.get_resources(self.cib.tree), ( severities.ERROR, report_codes.CIB_CANNOT_FIND_MANDATORY_SECTION, { "section": "configuration/resources", } ), )
def test_id_not_exists(self): assert_raise_library_error( lambda: lib.remove_role(self.tree.find(".//acls"), "id-of-role"), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "context_type": "acls", "context_id": "", "id": "id-of-role", }, ), )
def test_failure(self): self.mock_run.run.return_value = ("out", "error", 1) assert_raise_library_error( lambda: lib.get_daemon_status(self.mock_run), ( Severities.ERROR, report_codes.BOOTH_DAEMON_STATUS_ERROR, {"reason": "error\nout"} ) ) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "status"] )
def test_recipient_not_found(self): report_list = [(Severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "recipient" }), (Severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "alert2-recipient1" })] assert_raise_library_error( lambda: cmd_alert.remove_recipient(self.mock_env, [ "recipient", "alert-recipient1", "alert2-recipient1" ]), *report_list) assert_report_item_list_equal(self.mock_rep.report_item_list, report_list)
def test_failure(self): report_list = [(Severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, { "alert": "unknown" }), (Severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, { "alert": "unknown2" })] assert_raise_library_error( lambda: cmd_alert.remove_alert( self.mock_env, ["unknown", "alert1", "unknown2", "alert2"]), *report_list) assert_report_item_list_equal(self.mock_rep.report_item_list, report_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._upgrade_cib(mock_runner), (Severity.ERROR, report_codes.CIB_UPGRADE_FAILED, { "reason": expected_stderr + "\n" + expected_stdout, })) mock_runner.run.assert_called_once_with( ["/usr/sbin/cibadmin", "--upgrade", "--force"])
def test_refuse_when_name_starts_with_slash(self, mock_path_exists): mock_path_exists.return_value = True assert_raise_library_error( lambda: env.get_config_file_name("/booth"), ( severities.ERROR, report_codes.BOOTH_INVALID_NAME, { "name": "/booth", "reason": "contains illegal character '/'", } ), )
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", "id_description": "id", }), (severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "last", "id_description": "id", }))
def test_refuse_empty_ticket(self, _): assert_raise_library_error( lambda: self.prepare({ "loss-policy": "stop", "id": "id", "ticket": " " }), ( severities.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, {"option_names": ["ticket"]} ) )
def test_refuse_missing_resource_id(self, _): assert_raise_library_error( lambda: self.prepare( {"id": "id", "rsc-role": "master"}, "ticket_key", "" ), ( severities.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, { "option_names": ["rsc"], } ), )
def test_init_tool_fail(self, mock_is_dir_nonempty): mock_is_dir_nonempty.return_value = False self.mock_runner.run.return_value = ("stdout", "test error", 1) assert_raise_library_error( lambda: lib.qdevice_setup(self.mock_runner), (severity.ERROR, report_codes.QDEVICE_INITIALIZATION_ERROR, { "model": "net", "reason": "test error\nstdout", })) mock_is_dir_nonempty.assert_called_once_with(_qnetd_cert_dir) self.mock_runner.run.assert_called_once_with([_qnetd_cert_tool, "-i"])
def test_refuse_unknown_lost_policy(self, _): assert_raise_library_error( lambda: self.prepare({ "loss-policy": "unknown", "ticket": "T", "id": "id", }), (severities.ERROR, report_codes.INVALID_OPTION_VALUE, { 'allowed_values': ('fence', 'stop', 'freeze', 'demote'), 'option_value': 'unknown', 'option_name': 'loss-policy', }), )
def test_tool_error(self, mock_get_cert): self.mock_runner.run.return_value = ("stdout", "tool output error", 1) assert_raise_library_error( lambda: lib.client_generate_certificate_request( self.mock_runner, "clusterName"), (severity.ERROR, report_codes.QDEVICE_INITIALIZATION_ERROR, { "model": "net", "reason": "tool output error\nstdout", })) self.mock_runner.run.assert_called_once_with( [_client_cert_tool, "-r", "-n", "clusterName"]) mock_get_cert.assert_not_called()
def test_refuse_for_nonexisting_resource(self): env = get_mocked_env(cib_data=str(self.create_cib())) assert_raise_library_error( lambda: ticket_command.create(env, "ticketA", "resourceA", "master", {"loss-policy": "fence"}), ( severities.ERROR, report_codes.RESOURCE_DOES_NOT_EXIST, { "resource_id": "resourceA" }, ), )
def test_refuse_unknown_symmetrical(self, _): assert_raise_library_error( lambda: self.prepare({ "symmetrical": "unknown", "kind": "Optional", "id": "id", }), (severities.ERROR, report_codes.INVALID_OPTION_VALUE, { 'allowed_values': ('true', 'false'), 'option_value': 'unknown', 'option_name': 'symmetrical', }), )
def test_raises_when_config_exists_and_overwrite_not_allowed( self, mock_ex): assert_raise_library_error( lambda: self.check(MockLibraryReportProcessor()), ( severities.ERROR, report_codes.FILE_ALREADY_EXISTS, { "file_path": CONF_PATH }, report_codes.FORCE_FILE_OVERWRITE, ), )
def test_failed(self, mock_disable, mock_is_systemctl): mock_disable.side_effect = DisableServiceError("booth", "msg", self.name) assert_raise_library_error( lambda: commands.disable_booth(self.mock_env), (Severities.ERROR, report_codes.SERVICE_DISABLE_ERROR, { "service": "booth", "reason": "msg", "node": None, "instance": self.name, })) mock_disable.assert_called_once_with(self.mock_run, "booth", self.name) mock_is_systemctl.assert_called_once_with()
def test_invalid_message_type(self): assert_raise_library_error( lambda: cmd_sbd.set_message(self.env, "device", "node1", "message"), ( Severities.ERROR, report_codes.INVALID_OPTION_VALUE, { "option_name": "message", "option_value": "message", "allowed_values": settings.sbd_message_types, } ) )
def test_refuse_unknown_kind(self, _): assert_raise_library_error( lambda: self.prepare({ "symmetrical": "true", "kind": "unknown", "id": "id", }), (severities.ERROR, report_codes.INVALID_OPTION_VALUE, { 'allowed_values': ('Optional', 'Mandatory', 'Serialize'), 'option_value': 'unknown', 'option_name': 'kind', }), )
def test_failuer(self): runner.set_runs( self.fixture_call_sbd_message("device", "node", "test", "error", 1)) assert_raise_library_error( lambda: cmd_sbd.set_message(self.env, "device", "node", "test"), (Severities.ERROR, report_codes.SBD_DEVICE_MESSAGE_ERROR, { "device": "device", "node": "node", "message": "test", "reason": "error", })) runner.assert_everything_launched()
def test_wait_ok_run_fail(self): self.runner.set_runs(fixture.call_dummy_metadata( ) + fixture.call_wait_supported() + fixture.calls_cib( self.fixture_resources_pre, self.fixture_resources_post_simple, cib_base_file=self.upgraded_cib, ) + fixture.call_wait(10) + fixture.call_status( fixture.state_complete(self.fixture_status_primitive_not_running))) assert_raise_library_error( lambda: self.simplest_create(10), fixture.report_resource_not_running("A", severities.ERROR), ) self.runner.assert_everything_launched()
def test_raises_when_multiple_booth_resource_found(self): assert_raise_library_error( lambda: commands._find_resource_elements_for_operation( mock.MagicMock(), "somename", allow_multiple=False), ( Severities.ERROR, report_codes.BOOTH_MULTIPLE_TIMES_IN_CIB, { 'name': 'somename', }, report_codes.FORCE_BOOTH_REMOVE_FROM_CIB, ), )
def test_cib_parse_error(self, mock_upgrade_file, mock_upgrade, mock_get_cib): mock_upgrade_file.return_value = "not xml" assert_raise_library_error( lambda: lib.ensure_cib_version(self.mock_runner, self.cib, (2, 3, 5), False), (severities.ERROR, report_codes.CIB_UPGRADE_FAILED, { "reason": "Start tag expected, '<' not found, line 1, column 1", })) mock_upgrade_file.assert_called_once_with(self.cib, self.mock_runner) mock_upgrade.assert_not_called() mock_get_cib.assert_not_called()
def test_failed(self): output = "out" device = "device" self.mock_runner.run.return_value = output, "", 1 assert_raise_library_error( lambda: lib_sbd.get_device_sbd_header_dump(self.mock_runner, device ), (Severities.ERROR, report_codes.SBD_DEVICE_DUMP_ERROR, { "device": device, "reason": output, })) self.mock_runner.run.assert_called_once_with( [settings.sbd_binary, "-d", device, "dump"])
def base_test(self, func): assert_raise_library_error( func, ( severity.ERROR, report_codes.INVALID_OPTION_VALUE, { "option_name": "model", "option_value": "bad model", "allowed_values": ["net"], } ) )
def test_raises_whne_id_exists(self, does_id_exists): does_id_exists.return_value = True assert_raise_library_error( lambda: lib.validate_id_does_not_exist("tree", "some-id"), ( severities.ERROR, report_codes.ID_ALREADY_EXISTS, { "id": "some-id" }, ), ) does_id_exists.assert_called_once_with("tree", "some-id")
def test_file_error(self, mock_config): self.mock_env.is_cman_cluster = False 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_standby_unknown_node(self): self.fixture_add_node_status( self.fixture_get_node_status("node_1", "id_1")) mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = (str(self.status), "", 0) assert_raise_library_error( lambda: lib.nodes_standby(mock_runner, ["node_2"]), (Severity.ERROR, report_codes.NODE_NOT_FOUND, { "node": "node_2" })) mock_runner.run.assert_called_once_with(self.crm_mon_cmd())