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"}),
)
