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_winperf_if_inventory_teaming(check_manager, monkeypatch, settings, info, expected_discovery): check = check_manager.get_check("winperf_if") monkeypatch.setitem(check.context, "host_extra_conf", lambda _, __: settings) monkeypatch.setitem(check.context, "_prepare_if_group_patterns_from_conf", lambda: {}) parsed = check.run_parse(info) actual_discovery = check.run_discovery(parsed) assertDiscoveryResultsEqual(check, DiscoveryResult(sorted(expected_discovery)), DiscoveryResult(sorted(actual_discovery)))
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), )
def test_jolokia_generic_discovery(check_manager, check, info, expected_result): parsed = check_manager.get_check('jolokia_generic').run_parse(info) check = check_manager.get_check(check) discovered = check.run_discovery(parsed) assertDiscoveryResultsEqual( check, DiscoveryResult(discovered), DiscoveryResult(expected_result), )
def test_logwatch_ec_inventory_single(check_manager, info, fwd_rule, expected_result): parsed = check_manager.get_check('logwatch').run_parse(info) check = check_manager.get_check('logwatch.ec_single') def mock_cfg(_hostname, _ruleset): return fwd_rule with MockHostExtraConf(check, mock_cfg): actual_result = DiscoveryResult(check.run_discovery(parsed)) assertDiscoveryResultsEqual(check, actual_result, DiscoveryResult(expected_result))
def test_logwatch_inventory_group(check_manager, info, fwd_rule, inventory_groups, expected_result): parsed = check_manager.get_check('logwatch').run_parse(info) check = check_manager.get_check('logwatch.groups') mock_cfgs = [fwd_rule, inventory_groups] def mock_cfg(_hostname, _ruleset): return mock_cfgs.pop(0) with MockHostExtraConf(check, mock_cfg): actual_result = DiscoveryResult(check.run_discovery(parsed)) assertDiscoveryResultsEqual(check, actual_result, DiscoveryResult(expected_result))
def test_hr_ps_discovery(info, discovery_params, expected_discovery_result): '''Test that the hr_ps check returns the correct discovery results given different discovery parameters. ''' check = Check('hr_ps') with MockHostExtraConf(check, discovery_params, 'host_extra_conf'): actual_discovery_result = check.run_discovery(check.run_parse(info)) assertDiscoveryResultsEqual( check, DiscoveryResult(actual_discovery_result), DiscoveryResult(expected_discovery_result), )
def test_df_discovery_with_parse(check_manager, info, expected_result, inventory_df_rules): check = check_manager.get_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 used in mock of host_extra_conf") with MockHostExtraConf(check, mocked_host_extra_conf_merged, "host_extra_conf_merged"): raw_discovery_result = check.run_discovery(check.run_parse(info)) discovery_result = DiscoveryResult(raw_discovery_result) expected_result = DiscoveryResult(expected_result) assertDiscoveryResultsEqual(check, discovery_result, expected_result)
def get_discovery_actual(check, info_arg, immu): """Validate and return actual DiscoveryResult""" print("discovery: %r" % (check.name,)) disco_func = check.info.get("inventory_function") if not disco_func: return DiscoveryResult() d_result_raw = check.run_discovery(info_arg) immu.test(' after discovery (%s): ' % disco_func.__name__) d_result = DiscoveryResult(d_result_raw) for entry in d_result.entries: params = get_merged_parameters(check, entry.default_params) validate_discovered_params(check, params) return d_result
def test_winperf_if_inventory_group_patterns(check_manager, monkeypatch, settings, group_patterns, info, expected_discovery, expected_check_results): check = check_manager.get_check("winperf_if") monkeypatch.setitem(check.context, "host_name", lambda: "test-host") monkeypatch.setitem(check.context, "host_extra_conf", lambda _, __: settings) monkeypatch.setitem(check.context, "_prepare_if_group_patterns_from_conf", lambda: group_patterns) parsed = check.run_parse(info) actual_discovery = check.run_discovery(parsed) assertDiscoveryResultsEqual(check, DiscoveryResult(sorted(expected_discovery)), DiscoveryResult(sorted(actual_discovery))) # check if grouped interfaces return the "Teaming Status" and "Members" of the group for (item, params), expected_result in zip(expected_discovery, expected_check_results): actual_result = CheckResult(check.run_check(item, params, parsed)) assertCheckResultsEqual(actual_result, expected_result)
def test_nfsmounts(check_manager, info, discovery_expected, check_expected): check_nfs = check_manager.get_check("nfsmounts") check_cifs = check_manager.get_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 discovery(check, subcheck, dataset, info_arg, immu): """Test discovery funciton, return discovery result""" print("discovery: %r" % check.name) discov_expected = getattr(dataset, 'discovery', {}) disco_func = check.info.get("inventory_function") if discov_expected.get(subcheck): # we *must* have a discovery function in this case! assert disco_func, "%r has no discovery function!" \ % check.name if not disco_func: return [] d_result_raw = check.run_discovery(info_arg) immu.test(' after discovery (%s): ' % disco_func.__name__) d_result = DiscoveryResult(d_result_raw) if subcheck in discov_expected: d_result_expected = DiscoveryResult(discov_expected[subcheck]) assertDiscoveryResultsEqual(check, d_result, d_result_expected) return d_result
def test_discovery_mbg_lantime_ng_refclock(check_manager, info, expected): check = check_manager.get_check("mbg_lantime_ng_refclock") discovery = DiscoveryResult(check.run_discovery(info)) assertDiscoveryResultsEqual(check, discovery, expected)
def test_docker_container_diskstat_discovery(info, discovery_expected): check = Check('docker_container_diskstat') parsed = check.run_parse(info) discovery_actual = DiscoveryResult(check.run_discovery(parsed)) assertDiscoveryResultsEqual(check, discovery_actual, discovery_expected)
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 MockItemState((0, 0)): # raise MKCounterWrapped anyway, because counters are missing in info with pytest.raises(MKCounterWrapped): check.run_check("SUMMARY", {}, parsed) @pytest.mark.parametrize("info, discovery_expected", [ (INFO_MISSING_COUNTERS, DiscoveryResult([("SUMMARY", {})])), ]) def test_docker_container_diskstat_discovery(info, discovery_expected): check = Check('docker_container_diskstat') parsed = check.run_parse(info) discovery_actual = DiscoveryResult(check.run_discovery(parsed)) assertDiscoveryResultsEqual(check, discovery_actual, discovery_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)]),
def get_discovery_expected(subcheck, dataset): """Return expected DiscoveryResult""" discovery_dict = getattr(dataset, 'discovery', {}) discovery_raw = discovery_dict.get(subcheck, []) return DiscoveryResult(discovery_raw)
def test_parse_and_discovery_function(check_manager, info, result): check = check_manager.get_check("lnx_thermal") parsed = check.run_parse(info) discovery = DiscoveryResult(check.run_discovery(parsed)) assertDiscoveryResultsEqual(check, discovery, DiscoveryResult(result))
def test_zfsget_discovery(info, expected_discovery_result): check_zfsget = Check("zfsget") discovery_result = DiscoveryResult( check_zfsget.run_discovery(check_zfsget.run_parse(info))) assertDiscoveryResultsEqual("zfsget", discovery_result, DiscoveryResult(expected_discovery_result))
def test_discovery_mbg_lantime_ng_refclock_gps(info, expected): check = Check("mbg_lantime_ng_refclock.gps") discovery = DiscoveryResult(check.run_discovery(info)) assertDiscoveryResultsEqual(check, discovery, expected)
u'1', u'28', u'3', u'1', u'52', u'62', u'100', u'101', u'127', u'0', u'0' ]] meinberg_lantime_5 = [[ u'1', u'14', u'3', u'1', u'150', u'6', u'8', u'0', u'0', u'1', u'not announced' ]] meinberg_lantime_6 = [[ u'1', u'30', u'3', u'1', u'155', u'0', u'8', u'0', u'0', u'0', u'2016-12-31' ]] @pytest.mark.parametrize( "info,expected", [ (meinberg_lantime_1, DiscoveryResult( [])), # GPS clocks are not covered here (meinberg_lantime_2, DiscoveryResult([('1', None)])), ]) def test_discovery_mbg_lantime_ng_refclock(info, expected): check = Check("mbg_lantime_ng_refclock") discovery = DiscoveryResult(check.run_discovery(info)) assertDiscoveryResultsEqual(check, discovery, expected) @pytest.mark.parametrize("info,item,params,expected", [ (meinberg_lantime_2, '1', (3, 3), CheckResult([ BasicCheckResult( 0, 'Type: pzf600, Usage: primary, State: synchronized (LW sync)', None), BasicCheckResult(0, 'Field strength: 80%',
def test_wmi_cpu_load_discovery(check_name, info, expected): check = Check(check_name) discovery_result = DiscoveryResult( check.run_discovery(check.run_parse(info))) discovery_expected = DiscoveryResult(expected) assertDiscoveryResultsEqual(check, discovery_result, discovery_expected)