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 run_test_on_discovery(check, subcheck, dataset, info_arg, immu, write):
d_result_act = get_discovery_actual(check, info_arg, immu)
if write:
update_dataset_attrs_with_discovery(dataset, check, subcheck, d_result_act)
else:
d_result_exp = get_discovery_expected(subcheck, dataset)
assertDiscoveryResultsEqual(check, d_result_act, d_result_exp)
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_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_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_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 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_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_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_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)
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_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)
