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_parse_empty_address():
check = Check("arista_bgp")
data = [
[
[],
[0, 0, 0, 0],
"65007",
[0, 0, 0, 0],
"2",
"1",
"",
"1.1.4.192.168.1.2",
]
]
assert check.run_parse([data]) == {
"192.168.1.2": {
"Admin state": "running",
"BGP version": 4,
"Last received error": "",
"Local address": "empty()",
"Local identifier": "0.0.0.0",
"Peer state": "idle",
"Remote AS number": 65007,
"Remote identifier": "0.0.0.0",
},
}
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_discovery_qmgr_not_included():
check = Check(CHECK_NAME)
parsed = {
"QM1": {
"STATUS": "RUNNING"
},
"QM2": {
"STATUS": "RUNNING"
},
"QM1:QUEUE1": {
"CURDEPTH": "0"
},
"QM1:QUEUE2": {
"CURDEPTH": "1400"
},
"QM2:QUEUE3": {
"CURDEPTH": "530"
},
"QM2:QUEUE4": {
"CURDEPTH": "10"
},
}
discovery = list(check.run_discovery(parsed))
assert len(discovery) == 4
assert ("QM1:QUEUE2", {}) in discovery
assert ("QM2:QUEUE3", {}) in discovery
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_parse_simple():
check = Check("arista_bgp")
data = [
[
[192, 168, 1, 1],
[10, 10, 10, 10],
"65000",
[192, 168, 2, 0],
"2",
"6",
"Cease/other configuration change",
"1.1.4.192.168.1.2",
]
]
assert check.run_parse([data]) == {
"192.168.1.2": {
"Admin state": "running",
"BGP version": 4,
"Last received error": "Cease/other configuration change",
"Local address": "192.168.1.1",
"Local identifier": "10.10.10.10",
"Peer state": "established",
"Remote AS number": 65000,
"Remote identifier": "192.168.2.0",
}
}
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_parse_svrconn_with_multiple_instances():
lines = """\
QMNAME(MY.TEST) STATUS(RUNNING) NOW(2020-04-03T17:27:02+0200)
5724-H72 (C) Copyright IBM Corp. 1994, 2015.
Starting MQSC for queue manager MY.TEST.
AMQ8417: Display Channel Status details.
CHANNEL(XXXXXX.IIB.SVRCONN) CHLTYPE(SVRCONN)
CONNAME(10.25.19.182) CURRENT
STATUS(RUNNING) SUBSTATE(RECEIVE)
AMQ8417: Display Channel Status details.
CHANNEL(XXXXXX.IIB.SVRCONN) CHLTYPE(SVRCONN)
CONNAME(10.25.19.183) CURRENT
STATUS(RUNNING) SUBSTATE(RECEIVE)
One MQSC commands read.
No commands have a syntax error.
All valid MQSC commands were processed.
"""
section = parse_info(lines, chr(10))
check = Check(CHECK_NAME)
parsed = check.run_parse(section)
attrs = parsed["MY.TEST:XXXXXX.IIB.SVRCONN"]
assert attrs["CHLTYPE"] == "SVRCONN"
assert attrs["STATUS"] == "RUNNING"
# Last entry of the instances defines the values
assert attrs["CONNAME"] == "10.25.19.183"
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_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_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_parse():
lines = """\
QMNAME(THE.LOCAL.ONE) STATUS(RUNNING) DEFAULT(NO) STANDBY(NOT PERMITTED) INSTNAME(Installation1) INSTPATH(/opt/mqm) INSTVER(8.0.0.6) HA() DRROLE()
INSTANCE(sb112233) MODE(ACTIVE)
QMNAME(THE.MULTI.INSTANCE.ONE) STATUS(RUNNING) DEFAULT(NO) STANDBY(PERMITTED) INSTNAME(Installation1) INSTPATH(/opt/mqm) INSTVER(8.0.0.6) HA() DRROLE()
INSTANCE(sb112233) MODE(ACTIVE)
INSTANCE(sb112255) MODE(STANDBY)
QMNAME(THE.RDQM.ONE) STATUS(RUNNING) DEFAULT(NO) STANDBY(NOT PERMITTED) INSTNAME(Installation1) INSTPATH(/opt/mqm) INSTVER(9.1.0.4) HA(REPLICATED) DRROLE()
INSTANCE(sb008877) MODE(ACTIVE)
QMNAME(THE.SLEEPING.ONE) STATUS(ENDED NORMALLY) DEFAULT(NO) STANDBY(NOT APPLICABLE) INSTNAME(Installation1) INSTPATH(/opt/mqm) INSTVER(7.5.0.1) HA() DRROLE()
QMNAME(THE.CRASHED.ONE) STATUS(ENDED UNEXPECTEDLY) DEFAULT(NO) STANDBY(NOT APPLICABLE) INSTNAME(Installation2) INSTPATH(/opt/mqm9) INSTVER(9.0.0.6) HA() DRROLE()
"""
section = parse_info(lines, chr(10))
check = Check(CHECK_NAME)
parsed = check.run_parse(section)
assert len(parsed) == 5
attrs = parsed["THE.LOCAL.ONE"]
assert attrs["STATUS"] == "RUNNING"
assert [("sb112233", "ACTIVE")] == attrs["INSTANCES"]
attrs = parsed["THE.MULTI.INSTANCE.ONE"]
assert [("sb112233", "ACTIVE"),
("sb112255", "STANDBY")] == attrs["INSTANCES"]
attrs = parsed["THE.CRASHED.ONE"]
assert attrs["QMNAME"] == "THE.CRASHED.ONE"
assert attrs["STATUS"] == "ENDED UNEXPECTEDLY"
assert attrs["STANDBY"] == "NOT APPLICABLE"
assert "INSTANCES" not in attrs
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_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_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_df_discovery_groups_with_parse(inventory_df_rules, filesystem_groups,
expected_result):
check = Check("df")
def mocked_host_extra_conf_merged(_hostname, ruleset):
if ruleset is check.context.get("inventory_df_rules"):
return inventory_df_rules
raise AssertionError(
"Unknown/unhandled ruleset 'inventory_df_rules' used in mock of host_extra_conf_merged"
)
def mocked_host_extra_conf(_hostname, ruleset):
if ruleset is check.context.get("filesystem_groups"):
return filesystem_groups
raise AssertionError(
"Unknown/unhandled ruleset 'filesystem_groups' used in mock of host_extra_conf"
)
with MockHostExtraConf(check, mocked_host_extra_conf_merged,
"host_extra_conf_merged"):
with MockHostExtraConf(check, mocked_host_extra_conf,
"host_extra_conf"):
raw_discovery_result = check.run_discovery(
parse_df(info_df_groups))
discovery_result = DiscoveryResult(raw_discovery_result)
expected_result = DiscoveryResult(expected_result)
assertDiscoveryResultsEqual(check, discovery_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_f5_bigip_mem_tmm_discovery(info, result):
parsed = Check("f5_bigip_mem").run_parse(info)
check = Check("f5_bigip_mem.tmm")
assert list(check.run_discovery(parsed)) == result
if result:
assert parsed["TMM"] == (1024.0, 0.0)
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_inventory_function(info, item_expected, data_expected):
"""
Verifies if the item is detected corresponding to info content.
"""
check = Check("alcatel_temp")
result = list(check.run_discovery(info))
assert result[0][0] == item_expected
assert result[0][1] == data_expected
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_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_parse():
lines = """\
QMNAME(MY.TEST) STATUS(RUNNING) NOW(2020-04-03T17:27:02+0200)
5724-H72 (C) Copyright IBM Corp. 1994, 2015.
Starting MQSC for queue manager MY.TEST.
AMQ8414: Display Channel details.
CHANNEL(HERE.TO.THERE.ONE) CHLTYPE(SDR)
XMITQ(HERE.TO.THERE.ONE.XMIT)
AMQ8414: Display Channel details.
CHANNEL(HERE.TO.THERE.TWO) CHLTYPE(SDR)
XMITQ(HERE.TO.THERE.TWO.XMIT)
AMQ8414: Display Channel details.
CHANNEL(SYSTEM.DEF.SENDER) CHLTYPE(SDR)
XMITQ( )
AMQ8417: Display Channel Status details.
CHANNEL(HERE.TO.THERE.TWO) CHLTYPE(SDR)
COMPRATE(0,0) COMPTIME(0,0)
CONNAME(55.888.222.333(1414),22,333.444.555(1414))
EXITTIME(0,0) MONCHL(OFF)
CURRENT RQMNAME( )
STATUS(RETRYING) SUBSTATE( )
XBATCHSZ(0,0) XMITQ(HERE.TO.THERE.TWO.XMIT)
XQTIME(0,1)
AMQ8417: Display Channel Status details.
CHANNEL(HERE.TO.THERE.ONE) CHLTYPE(SDR)
COMPRATE(0,0) COMPTIME(0,0)
CONNAME(62.240.197.243(1414),62.240.197.244(1414))
EXITTIME(0,0) MONCHL(OFF)
CURRENT RQMNAME( )
STATUS(RETRYING) SUBSTATE(MQGET)
XBATCHSZ(0,0) XMITQ(HERE.TO.THERE.TWO.XMIT)
XQTIME(0,1)
5 MQSC commands read.
No commands have a syntax error.
All valid MQSC commands were processed.
"""
section = parse_info(lines, chr(10))
check = Check(CHECK_NAME)
parsed = check.run_parse(section)
assert 2 + 1 == len(parsed)
attrs = parsed["MY.TEST"]
assert attrs["STATUS"] == "RUNNING"
assert attrs["NOW"] is not None
attrs = parsed["MY.TEST:HERE.TO.THERE.TWO"]
assert attrs["CHLTYPE"] == "SDR"
assert attrs["STATUS"] == "RETRYING"
assert attrs["CONNAME"] == "55.888.222.333(1414),22,333.444.555(1414)"
assert attrs["MONCHL"] == "OFF"
attrs = parsed["MY.TEST:HERE.TO.THERE.TWO"]
assert attrs["CHLTYPE"] == "SDR"
assert attrs["STATUS"] == "RETRYING"
assert attrs["CONNAME"] == "55.888.222.333(1414),22,333.444.555(1414)"
assert attrs["MONCHL"] == "OFF"
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_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_f5_bigip_mem_discovery(info, result):
mem_total, mem_used, items = result
check = Check("f5_bigip_mem")
parsed = check.run_parse(info)
assert list(check.run_discovery(parsed)) == items
if items:
assert parsed["total"] == (mem_total, mem_used)
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_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_jolokia_generic_discovery(check, lines, expected_result):
parsed = Check("jolokia_generic").run_parse(lines)
check = Check(check)
discovered = check.run_discovery(parsed)
assertDiscoveryResultsEqual(
check,
DiscoveryResult(discovered),
DiscoveryResult(expected_result),
)
