def test_failures(self, mock_check_sbd, mock_get_nodes):
def ret_val(communicator, node, empty_str):
self.assertEqual(communicator, self.mock_com)
self.assertEqual(empty_str, "")
if node.label == "node0":
return """{
"not_sbd": {
"installed": true,
"enabled": true,
"running": false
}
}"""
elif node.label == "node1":
raise NodeConnectionException(node.label, "command", "reason")
elif node.label == "node2":
return "invalid_json"
else:
raise AssertionError(
"Unexpected call: node={node}, node.label={label}".format(
node=str(node), label=node.label))
mock_check_sbd.side_effect = ret_val
self.mock_env.is_cman_cluster = False
mock_get_nodes.return_value = self.node_list
all_none = {"installed": None, "enabled": None, "running": None}
expected = [{
"node": self.node_list.find_by_label("node0"),
"status": all_none
}, {
"node": self.node_list.find_by_label("node1"),
"status": all_none
}, {
"node": self.node_list.find_by_label("node2"),
"status": all_none
}]
_assert_equal_list_of_dictionaries_without_order(
expected, cmd_sbd.get_cluster_sbd_status(self.mock_env))
mock_get_nodes.assert_called_once_with(self.mock_env)
self.assertEqual(3, mock_check_sbd.call_count)
assert_report_item_list_equal(
self.mock_rep.report_item_list,
[(Severities.WARNING, report_codes.UNABLE_TO_GET_SBD_STATUS, {
"node": "node0"
}),
(Severities.WARNING,
report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT, {
"node": "node1",
"reason": "reason",
"command": "command",
}),
(Severities.WARNING, report_codes.UNABLE_TO_GET_SBD_STATUS, {
"node": "node1"
}),
(Severities.WARNING, report_codes.UNABLE_TO_GET_SBD_STATUS, {
"node": "node2"
})])
def test_cman_cluster(self, mock_check_sbd, mock_get_nodes):
self.mock_env.is_cman_cluster = True
assert_raise_library_error(
lambda: cmd_sbd.get_cluster_sbd_status(self.mock_env),
(
Severities.ERROR,
report_codes.CMAN_UNSUPPORTED_COMMAND,
{}
)
)
def test_all_node_names_missing(self):
self.config.corosync_conf.load(filename="corosync-no-node-names.conf")
self.env_assist.assert_raise_library_error(
lambda: get_cluster_sbd_status(self.env_assist.get_env()))
self.env_assist.assert_reports([
fixture.warn(
report_codes.COROSYNC_CONFIG_MISSING_NAMES_OF_NODES,
fatal=False,
),
fixture.error(report_codes.COROSYNC_CONFIG_NO_NODES_DEFINED, ),
])
def test_some_node_names_missing(self):
(
self.config.env.set_known_nodes(["rh7-2"])
.corosync_conf.load(filename="corosync-some-node-names.conf")
.http.add_communication(
"check_sbd",
[
dict(
label="rh7-2",
output=json.dumps(
{
"sbd": {
"installed": True,
"enabled": False,
"running": False,
},
"watchdog": {"path": "", "exist": False},
"device_list": [],
}
),
response_code=200,
),
],
action="remote/check_sbd",
param_list=[("watchdog", ""), ("device_list", "[]")],
)
)
result = get_cluster_sbd_status(self.env_assist.get_env())
self.assertEqual(
result,
[
{
"node": "rh7-2",
"status": {
"running": False,
"enabled": False,
"installed": True,
},
},
],
)
self.env_assist.assert_reports(
[
fixture.warn(
report_codes.COROSYNC_CONFIG_MISSING_NAMES_OF_NODES,
fatal=False,
),
]
)
def test_some_node_names_missing(self):
(self.config
.env.set_known_nodes(["rh7-2"])
.corosync_conf.load(filename="corosync-some-node-names.conf")
.http.add_communication(
"check_sbd",
[
dict(
label="rh7-2",
output=json.dumps({
"sbd":{
"installed": True,
"enabled": False,
"running":False
},
"watchdog":{
"path":"",
"exist":False
},
"device_list":[]
}),
response_code=200,
),
],
action="remote/check_sbd",
param_list=[("watchdog", ""), ("device_list", "[]")],
)
)
result = get_cluster_sbd_status(self.env_assist.get_env())
self.assertEqual(
result,
[
{
"node": "rh7-2",
"status": {
"running": False,
"enabled": False,
"installed": True,
}
},
]
)
self.env_assist.assert_reports([
fixture.warn(
report_codes.COROSYNC_CONFIG_MISSING_NAMES_OF_NODES,
fatal=False,
),
])
def test_all_node_names_missing(self):
self.config.corosync_conf.load(filename="corosync-no-node-names.conf")
self.env_assist.assert_raise_library_error(
lambda: get_cluster_sbd_status(self.env_assist.get_env()),
[
fixture.error(
report_codes.COROSYNC_CONFIG_NO_NODES_DEFINED,
),
]
)
self.env_assist.assert_reports([
fixture.warn(
report_codes.COROSYNC_CONFIG_MISSING_NAMES_OF_NODES,
fatal=False,
),
])
def test_failures(self, mock_check_sbd, mock_get_nodes):
def ret_val(communicator, node, empty_str):
self.assertEqual(communicator, self.mock_com)
self.assertEqual(empty_str, "")
if node.label == "node0":
return """{
"not_sbd": {
"installed": true,
"enabled": true,
"running": false
}
}"""
elif node.label == "node1":
raise NodeConnectionException(node.label, "command", "reason")
elif node.label == "node2":
return "invalid_json"
else:
raise AssertionError(
"Unexpected call: node={node}, node.label={label}".format(
node=str(node), label=node.label
)
)
mock_check_sbd.side_effect = ret_val
self.mock_env.is_cman_cluster = False
mock_get_nodes.return_value = self.node_list
all_none = {
"installed": None,
"enabled": None,
"running": None
}
expected = [
{
"node": self.node_list.find_by_label("node0"),
"status": all_none
},
{
"node": self.node_list.find_by_label("node1"),
"status": all_none
},
{
"node": self.node_list.find_by_label("node2"),
"status": all_none
}
]
self.assertEqual(
expected, cmd_sbd.get_cluster_sbd_status(self.mock_env)
)
mock_get_nodes.assert_called_once_with(self.mock_env)
self.assertEqual(3, mock_check_sbd.call_count)
assert_report_item_list_equal(
self.mock_rep.report_item_list,
[
(
Severities.WARNING,
report_codes.UNABLE_TO_GET_SBD_STATUS,
{"node": "node0"}
),
(
Severities.WARNING,
report_codes.UNABLE_TO_GET_SBD_STATUS,
{"node": "node1"}
),
(
Severities.WARNING,
report_codes.UNABLE_TO_GET_SBD_STATUS,
{"node": "node2"}
)
]
)
def test_success(self, mock_check_sbd, mock_get_nodes):
def ret_val(communicator, node, empty_str):
self.assertEqual(communicator, self.mock_com)
self.assertEqual(empty_str, "")
if node.label == "node0":
return """{
"sbd": {
"installed": true,
"enabled": true,
"running": false
}
}"""
elif node.label == "node1":
return """{
"sbd": {
"installed": false,
"enabled": false,
"running": false
}
}"""
elif node.label == "node2":
return """{
"sbd": {
"installed": true,
"enabled": false,
"running": false
}
}"""
else:
raise AssertionError(
"Unexpected call: node={node}, node.label={label}".format(
node=str(node), label=node.label
)
)
mock_check_sbd.side_effect = ret_val
self.mock_env.is_cman_cluster = False
mock_get_nodes.return_value = self.node_list
expected = [
{
"node": self.node_list.find_by_label("node0"),
"status": {
"installed": True,
"enabled": True,
"running": False
}
},
{
"node": self.node_list.find_by_label("node1"),
"status": {
"installed": False,
"enabled": False,
"running": False
}
},
{
"node": self.node_list.find_by_label("node2"),
"status": {
"installed": True,
"enabled": False,
"running": False
}
}
]
self.assertEqual(
expected, cmd_sbd.get_cluster_sbd_status(self.mock_env)
)
mock_get_nodes.assert_called_once_with(self.mock_env)
self.assertEqual(3, mock_check_sbd.call_count)
self.assertEqual(self.mock_log.warning.call_count, 0)
def test_success(self, mock_check_sbd, mock_get_nodes):
def ret_val(communicator, node, empty_str):
self.assertEqual(communicator, self.mock_com)
self.assertEqual(empty_str, "")
if node.label == "node0":
return """{
"sbd": {
"installed": true,
"enabled": true,
"running": false
}
}"""
elif node.label == "node1":
return """{
"sbd": {
"installed": false,
"enabled": false,
"running": false
}
}"""
elif node.label == "node2":
return """{
"sbd": {
"installed": true,
"enabled": false,
"running": false
}
}"""
else:
raise AssertionError(
"Unexpected call: node={node}, node.label={label}".format(
node=str(node), label=node.label
)
)
mock_check_sbd.side_effect = ret_val
self.mock_env.is_cman_cluster = False
mock_get_nodes.return_value = self.node_list
expected = [
{
"node": self.node_list.find_by_label("node0"),
"status": {
"installed": True,
"enabled": True,
"running": False
}
},
{
"node": self.node_list.find_by_label("node1"),
"status": {
"installed": False,
"enabled": False,
"running": False
}
},
{
"node": self.node_list.find_by_label("node2"),
"status": {
"installed": True,
"enabled": False,
"running": False
}
}
]
_assert_equal_list_of_dictionaries_without_order(
expected, cmd_sbd.get_cluster_sbd_status(self.mock_env)
)
mock_get_nodes.assert_called_once_with(self.mock_env)
self.assertEqual(3, mock_check_sbd.call_count)
self.assertEqual(self.mock_log.warning.call_count, 0)
def test_default_different_results_on_different_nodes(self):
node_name_list = ["node-1", "node-2", "node-3", "node-4", "node-5"]
(self.config
.env.set_known_nodes(node_name_list)
.corosync_conf.load(node_name_list=node_name_list)
.http.add_communication(
"check_sbd",
[
dict(
label="node-1",
output='{"notauthorized":"true"}',
response_code=401,
),
dict(
label="node-2",
was_connected=False,
errno=6,
error_msg="Could not resolve host: node-2;"
" Name or service not known"
,
),
dict(
label="node-3",
output=json.dumps({
"sbd":{
"installed": True,
"enabled": False,
"running":False
},
"watchdog":{
"path":"",
"exist":False
},
"device_list":[]
}),
response_code=200,
),
dict(
label="node-4",
output=json.dumps({
"watchdog":{
"path":"",
"exist":False
},
"device_list":[]
}),
response_code=200,
),
dict(
label="node-5",
output="invalid json",
response_code=200,
),
],
action="remote/check_sbd",
param_list=[("watchdog", ""), ("device_list", "[]")],
)
)
default_status = {
'running': None,
'enabled': None,
'installed': None,
}
self.assertEqual(
get_cluster_sbd_status(self.env_assist.get_env()),
[
{
'node': 'node-3',
'status': {
'running': False,
'enabled': False,
'installed': True,
}
},
{
'node': 'node-1',
'status': default_status
},
{
'node': 'node-2',
'status': default_status
},
{
'node': 'node-4',
'status': default_status
},
{
'node': 'node-5',
'status': default_status
},
]
)
self.env_assist.assert_reports([
fixture.warn(
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
node="node-1",
reason="HTTP error: 401",
command="remote/check_sbd",
),
warn_unable_to_get_sbd_status(node="node-1", reason=""),
fixture.warn(
report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT,
node="node-2",
reason=
"Could not resolve host: node-2; Name or service not known"
,
command="remote/check_sbd",
),
warn_unable_to_get_sbd_status(node="node-2", reason=""),
warn_unable_to_get_sbd_status(node="node-4", reason="'sbd'"),
warn_unable_to_get_sbd_status(
node="node-5",
#the reason differs in python3
#reason="No JSON object could be decoded",
),
])
def test_cman_cluster(self, mock_check_sbd, mock_get_nodes):
self.mock_env.is_cman_cluster = True
assert_raise_library_error(
lambda: cmd_sbd.get_cluster_sbd_status(self.mock_env),
(Severities.ERROR, report_codes.CMAN_UNSUPPORTED_COMMAND, {}))
