def test_ended_preemtively():
lines = """\
QMNAME(THE.ENDED.ONE) STATUS(ENDED PREEMPTIVELY) DEFAULT(NO) STANDBY(NOT APPLICABLE) INSTNAME(Installation1) INSTPATH(/opt/mqm) INSTVER(7.5.0.2)
"""
section = parse_info(lines, chr(10))
check = Check(CHECK_NAME)
parsed = parse_ibm_mq_managers(section)
params: Dict[str, Any] = {}
actual = list(check.run_check("THE.ENDED.ONE", params, parsed))
expected = [
(1, "Status: ENDED PREEMPTIVELY"),
(0, "Version: 7.5.0.2"),
(0, "Installation: /opt/mqm (Installation1), Default: NO"),
]
assert expected == actual
lines = """\
QMNAME(THE.ENDED.ONE) STATUS(ENDED PRE-EMPTIVELY) DEFAULT(NO) STANDBY(NOT APPLICABLE) INSTNAME(Installation1) INSTPATH(/opt/mqm) INSTVER(8.0.0.1)
"""
section = parse_info(lines, chr(10))
check = Check(CHECK_NAME)
parsed = parse_ibm_mq_managers(section)
actual = list(check.run_check("THE.ENDED.ONE", params, parsed))
expected = [
(1, "Status: ENDED PRE-EMPTIVELY"),
(0, "Version: 8.0.0.1"),
(0, "Installation: /opt/mqm (Installation1), Default: NO"),
]
assert expected == actual
def test_status_wato_override():
check = Check(CHECK_NAME)
parsed = {
"QM1": {
"STATUS": "RUNNING"
},
"QM1:CHAN1": {
"CHLTYPE": "SVRCONN",
"STATUS": "STOPPED"
},
}
# Factory defaults
params: Dict[str, Any] = {}
actual = list(check.run_check("QM1:CHAN1", params, parsed))
expected: List[Tuple[int, str, List[Any]]] = [
(2, "Status: STOPPED, Type: SVRCONN", [])
]
assert actual == expected
# Override factory defaults
params = {"mapped_states": [("stopped", 1)]}
actual = list(check.run_check("QM1:CHAN1", params, parsed))
expected = [(1, "Status: STOPPED, Type: SVRCONN", [])]
assert actual == expected
# Override-does-not-match configuration
params = {
"mapped_states": [("retrying", 1)],
"mapped_states_default": 3,
}
actual = list(check.run_check("QM1:CHAN1", params, parsed))
expected = [(3, "Status: STOPPED, Type: SVRCONN", [])]
assert actual == expected
def test_check():
check = Check(CHECK_NAME)
params: Dict[str, Any] = {}
parsed = {
"QM1": {
"STATUS": "RUNNING"
},
"QM1:CHAN1": {
"CHLTYPE": "SDR",
"STATUS": "RETRYING",
"XMITQ": "MY.XMIT.Q"
},
"QM1:CHAN2": {
"CHLTYPE": "RCVR",
"STATUS": "STOPPED"
},
"QM1:CHAN3": {
"CHLTYPE": "SVRCONN"
},
}
actual = list(check.run_check("QM1:CHAN1", params, parsed))
expected: List[Tuple[int, str, List[Any]]] = [
(1, "Status: RETRYING, Type: SDR, Xmitq: MY.XMIT.Q", [])
]
assert actual == expected
actual = list(check.run_check("QM1:CHAN2", params, parsed))
expected = [(2, "Status: STOPPED, Type: RCVR", [])]
assert actual == expected
actual = list(check.run_check("QM1:CHAN3", params, parsed))
expected = [(0, "Status: INACTIVE, Type: SVRCONN", [])]
assert actual == expected
def test_nimble_latency_write_params(params, data, result):
"""Test that latency write levels are applied to write types only."""
read_check = Check("nimble_latency")
write_check = Check("nimble_latency.write")
read_results = list(read_check.run_check("itemxyz", params, data))
write_results = list(write_check.run_check("itemxyz", params, data))
assert result == write_results[0]
assert not read_results
def test_docker_container_diskstat_wrapped():
check = Check('docker_container_diskstat')
parsed = check.run_parse(INFO_MISSING_COUNTERS)
with pytest.raises(MKCounterWrapped):
check.run_check("SUMMARY", {}, parsed)
with mock_item_state((0, 0)):
# raise MKCounterWrapped anyway, because counters are missing in info
with pytest.raises(MKCounterWrapped):
check.run_check("SUMMARY", {}, parsed)
def test_fortigate_sslvpn_old_params():
check = Check("fortigate_sslvpn")
parsed = {
"domain": {
"state": "1",
"users": 0,
"web_sessions": 0,
"tunnels": 0,
"tunnels_max": 0,
},
}
check.run_check("no-item", None, parsed)
def test_cluster_mode_check_function(monkeypatch, params, first_result_change,
second_result_change):
check = Check("netapp_api_cpu")
monkeypatch.setattr("time.time", lambda: 0)
try:
check.run_check("clu1-01", params, result_parsed_over_time[0])
except MKCounterWrapped:
pass
monkeypatch.setattr("time.time", lambda: 60)
result = check.run_check("clu1-01", params, result_parsed_over_time[1])
assert result == first_result_change
monkeypatch.setattr("time.time", lambda: 180)
result = check.run_check("clu1-01", params, result_parsed_over_time[2])
assert result == second_result_change
def test_stale_service_for_not_running_qmgr():
check = Check(CHECK_NAME)
params: Dict[str, Any] = {}
parsed = {"QM1": {"STATUS": "ENDED NORMALLY"}}
with pytest.raises(MKCounterWrapped,
match=r"Stale because queue manager ENDED NORMALLY"):
list(check.run_check("QM1:CHAN2", params, parsed))
def test_check_function(
info,
state_expected,
info_expected,
perf_expected_key,
perf_expected_value,
state_expected_perc,
info_expected_perc,
):
"""
Checks funny connections values
"""
check = Check("mongodb_connections")
check_result = CheckResult(
check.run_check(None, {"levels_perc": (80.0, 90.0)}, info))
if len(check_result.subresults) == 0:
assert state_expected == 3
elif len(check_result.subresults) == 3:
check_used_connection(
check_result.subresults[0],
state_expected,
info_expected,
perf_expected_key,
perf_expected_value,
)
check_used_percentage(check_result.subresults[1], state_expected_perc,
info_expected_perc)
# check_used_rate(check_result.subresults[2].... we are not testing the get_rate function here assuming it works
else:
raise AssertionError()
def test_nfsmounts(info, discovery_expected, check_expected):
check_nfs = Check("nfsmounts")
check_cifs = Check("cifsmounts")
# assure that the code of both checks is identical
assert (
check_nfs.info["parse_function"].__code__.co_code
== check_cifs.info["parse_function"].__code__.co_code
)
assert (
check_nfs.info["inventory_function"].__code__.co_code
== check_cifs.info["inventory_function"].__code__.co_code
)
assert (
check_nfs.info["check_function"].__code__.co_code
== check_cifs.info["check_function"].__code__.co_code
)
parsed = check_nfs.run_parse(info)
assertDiscoveryResultsEqual(
check_nfs,
DiscoveryResult(check_nfs.run_discovery(parsed)), #
DiscoveryResult(discovery_expected),
)
for item, params, result_expected in check_expected:
result = CheckResult(check_nfs.run_check(item, params, parsed))
assertCheckResultsEqual(result, CheckResult([result_expected]))
def test_check_function(
info,
state_expected,
info_expected,
perf_expected,
state_expected_flush,
info_expected_flush,
perf_expected_flush_key,
perf_expected_flush_value,
):
"""
Only checks for missing flushing data
"""
check = Check("mongodb_flushing")
check_result = CheckResult(
check.run_check(None, {
"average_time": (1, 4, 60),
"last_time": (0.1, 0.2)
}, info))
if len(check_result.subresults) == 1:
check_result_3(check_result.subresults[0], state_expected,
info_expected)
elif len(check_result.subresults) == 4:
check_result_average(check_result.subresults[0], state_expected,
info_expected)
check_result_flush_time(
check_result.subresults[1],
state_expected_flush,
info_expected_flush,
perf_expected_flush_key,
perf_expected_flush_value,
)
def test_no_xmit_queue_defined():
"""
Happened on queue manager MQZZZPPPP and channel FOO.TO.RESA. It
is a misconfiguration on the queue manager, but the monitoring should
not choke on this.
"""
check = Check(CHECK_NAME)
params: Dict[str, Any] = {}
parsed = {
"QM1": {
"STATUS": "RUNNING"
},
"QM1:CHAN1": {
"CHLTYPE": "SDR",
"STATUS": "RETRYING",
"XMITQ": "MY.XMIT.Q"
},
"QM1:CHAN2": {
"CHLTYPE": "RCVR",
"STATUS": "STOPPED"
},
"QM1:CHAN3": {
"CHLTYPE": "SVRCONN"
},
"MQZZZPPPP:FOO.TO.RESA": {
"CHLTYPE": "SDR"
},
}
actual = list(check.run_check("MQZZZPPPP:FOO.TO.RESA", params, parsed))
expected: List[Tuple[int, str,
List[Any]]] = [(0, "Status: INACTIVE, Type: SDR", [])]
assert actual == expected
def test_check_win_license(params, expected_status, expected_levels_info):
check = Check("msoffice_serviceplans")
item = "bundle"
output = check.run_check(
item,
params,
[
[item, "plan-success-1", "Success"],
[item, "plan-suc", "cess-2", "Success"],
[item, "plan-pending-1", "PendingActivation"],
[item, "plan-pen", "ding-2", "PendingActivation"],
],
)
result = [
BasicCheckResult(expected_status,
"Success: 2, Pending: 2%s" % expected_levels_info),
BasicCheckResult(0,
"Pending Services: plan-pending-1, plan-pen ding-2"),
]
assertCheckResultsEqual(
CheckResult(output),
CheckResult(result),
)
def test_crashreport(fix_plugin_legacy, crashdata):
try:
run(fix_plugin_legacy.check_info, crashdata)
check = Check(crashdata.full_checkname)
if "item" in crashdata.vars:
item = crashdata.vars["item"]
params = crashdata.vars.get("params", {})
if crashdata.parsed:
raw_result = check.run_check(item, params, crashdata.parsed)
else:
raw_result = check.run_check(item, params, crashdata.info)
print(CheckResult(raw_result))
except Exception:
pprint.pprint(crashdata.__dict__)
crashdata.write("/tmp")
raise
def test_io_check():
item_1st = "VMFS_01"
params = {"flex_levels": "irrelevant"}
check = Check("hp_msa_volume.io")
parsed = {
"VMFS_01": {
"durable-id": "V3",
"data-read-numeric": "23719999539712",
"data-written-numeric": "18093374647808",
"virtual-disk-name": "A",
"raidtype": "RAID0",
},
"VMFS_02": {
"durable-id": "V4",
"data-read-numeric": "49943891507200",
"data-written-numeric": "7384656100352",
"virtual-disk-name": "A",
"raidtype": "RAID0",
},
}
_, read, written = check.run_check(item_1st, params, parsed)
assertCheckResultsEqual(
CheckResult(read),
CheckResult((0, "Read: 0.00 B/s", [("disk_read_throughput", 0.0, None,
None)])),
)
assertCheckResultsEqual(
CheckResult(written),
CheckResult((0, "Write: 0.00 B/s", [("disk_write_throughput", 0.0,
None, None)])),
)
def test_check():
check = Check(CHECK_NAME)
params = {"curdepth": (1500, 2000), "ipprocs": {"upper": (4, 8)}}
parsed = {
"QM1": {
"STATUS": "RUNNING"
},
"QM1:MY.QUEUE": {
"CURDEPTH": "1400",
"MAXDEPTH": "200000",
"MSGAGE": "2201",
"IPPROCS": "5",
"OPPROCS": "0",
"QTIME": ",",
},
}
actual = list(check.run_check("QM1:MY.QUEUE", params, parsed))
expected = [
(0, "Queue depth: 1400 (0.7%)", [("curdepth", 1400, 1500, 2000, 0,
200000)]),
(0, "Oldest message: 36 m", [("msgage", 2201, None, None)]),
(1, "Open input handles: 5 (warn/crit at 4/8)", [("ipprocs", 5, 4, 8)
]),
(0, "Open output handles: 0", [("opprocs", 0, None, None)]),
(0, "Qtime short: n/a", [("qtime_short", 0, None, None)]),
(0, "Qtime long: n/a", [("qtime_long", 0, None, None)]),
]
assert actual == expected
def test_check_win_license(capture, result):
check = Check("win_license")
output = check.run_check(
None, result.parameters or check.default_parameters(), check.run_parse(splitter(capture))
)
assertCheckResultsEqual(CheckResult(output), result.check_output)
def test_statgrab_cpu_check(info, mockstate, expected_result):
check = Check("statgrab_cpu")
# set up mocking of `get_item_state`
with mock_item_state(mockstate):
result = CheckResult(check.run_check(None, {}, info))
assertCheckResultsEqual(result, expected_result)
def test_ra32e_power_check_battery():
check = Check(RA32E_POWER)
result = check.run_check(None, {}, [["0"]])
assert len(result) == 2
status, infotext = result
assert status == 1
assert "battery" in infotext
def test_nimble_latency_ranges(params, data, result):
"""The user can specify a parameter range_reference, which serves as a starting
point from which values should start to be stacked and checked against levels.
Test whether the stacking is correct."""
check = Check("nimble_latency")
actual_results = list(check.run_check("itemxyz", params, data))
assert result == actual_results[0]
def test_df_check_groups_with_parse(add_params, expected_result):
check = Check("df")
params = make_test_df_params()
params.update(add_params)
actual = CheckResult(check.run_check("my-group", params, parse_df(info_df_groups)))
expected = CheckResult(expected_result)
assertCheckResultsEqual(actual, expected)
def test_k8s_replicas(info, expected):
check = Check("k8s_replicas")
parsed = parse_json(info)
actual = check.run_check(None, {}, parsed)
assertCheckResultsEqual(
CheckResult(actual),
CheckResult(expected),
)
def test_check_docker_node_disk_usage():
check = Check("docker_node_disk_usage")
result = list(check.run_check("volumes", {}, check.run_parse(AGENT_OUTPUT)))
assert result == [
(0, "Size: 229.67 kB", [("size", 235177, None, None)]),
(0, "Reclaimable: 93.00 B", [("reclaimable", 93, None, None)]),
(0, "Count: 7", [("count", 7, None, None)]),
(0, "Active: 5", [("active", 5, None, None)]),
]
def test_vanished_service_for_running_qmgr():
check = Check(CHECK_NAME)
params: Dict[str, Any] = {}
parsed = {
"QM1": {"STATUS": "RUNNING"},
"QM1:CHAN1": {"CHLTYPE": "SVRCONN"},
}
actual = list(check.run_check("QM1:VANISHED", params, parsed))
assert len(actual) == 0
def test_docker_container_diskstat_check(mocker, monkeypatch):
mocker.patch("cmk.base.item_state._get_counter", return_value=[None, 2.22])
check = Check('docker_container_diskstat')
result = check.run_check('dm-1', {}, check.run_parse(INFO))
assert list(result) == [
(0, 'Read: 2.22 B/s', [('disk_read_throughput', 2.22, None, None)]),
(0, 'Write: 2.22 B/s', [('disk_write_throughput', 2.22, None, None)]),
(0, 'Read operations: 2.22 1/s', [('disk_read_ios', 2.22, None, None)]),
(0, 'Write operations: 2.22 1/s', [('disk_write_ios', 2.22, None, None)]),
]
def test_check_function(parameters, info, state_expected, infotext_expected, perfdata_expected):
"""
Verifies if check function asserts warn and crit CPU levels.
"""
check = Check(CHECK_NAME)
item = None
state, infotext, perfdata = check.run_check(item, parameters, info)
assert state == state_expected
assert infotext == infotext_expected
assert perfdata == perfdata_expected
def test_statgrab_cpu_check_error(info, mockstate):
check = Check("statgrab_cpu")
with mock_item_state(mockstate):
# the mock values are designed to raise an exception.
# to make sure it is raised, use this:
with assertMKCounterWrapped(
"Too short time difference since last check"):
CheckResult(check.run_check(None, {}, info))
def test_check_function(
parameters, item, info, state_expected, infotext_expected, perfdata_expected
):
"""
Verifies if check function asserts warn and crit Board and CPU temperature levels.
"""
check = Check("alcatel_temp")
state, infotext, perfdata = check.run_check(item, parameters, info)
assert state == state_expected
assert infotext_expected in infotext
assert perfdata == perfdata_expected
def test_status_wato_override():
lines = """\
QMNAME(THE.ENDED.ONE) STATUS(ENDED PRE-EMPTIVELY) DEFAULT(NO) STANDBY(NOT APPLICABLE) INSTNAME(Installation1) INSTPATH(/opt/mqm) INSTVER(7.5.0.2)
"""
section = parse_info(lines, chr(10))
check = Check(CHECK_NAME)
parsed = parse_ibm_mq_managers(section)
# Factory defaults
params: Dict[str, Any] = {}
actual = list(check.run_check("THE.ENDED.ONE", params, parsed))
expected = [
(1, "Status: ENDED PRE-EMPTIVELY"),
(0, "Version: 7.5.0.2"),
(0, "Installation: /opt/mqm (Installation1), Default: NO"),
]
assert expected == actual
# Override factory defaults
params = {"mapped_states": [("ended_pre_emptively", 2)]}
actual = list(check.run_check("THE.ENDED.ONE", params, parsed))
expected = [
(2, "Status: ENDED PRE-EMPTIVELY"),
(0, "Version: 7.5.0.2"),
(0, "Installation: /opt/mqm (Installation1), Default: NO"),
]
assert expected == actual
# Override-does-not-match configuration
params = {
"mapped_states": [("running_as_standby", 2)],
"mapped_states_default": 3,
}
actual = list(check.run_check("THE.ENDED.ONE", params, parsed))
expected = [
(3, "Status: ENDED PRE-EMPTIVELY"),
(0, "Version: 7.5.0.2"),
(0, "Installation: /opt/mqm (Installation1), Default: NO"),
]
assert expected == actual
def test_wmi_msexch_isclienttype_wato_params(check_name, expected):
check = Check(check_name)
result = list(
check.run_check(
item="_total",
params={
"store_latency": (41.0, 51.0),
"clienttype_latency": (40.0, 50.0),
"clienttype_requests": (60, 70),
},
info=check.run_parse(info_msx_info_store_1),
))
assert result == expected