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())
