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