def run_test_on_checks(check, subcheck, dataset, info_arg, immu, write): """Run check for test case listed in dataset""" test_cases = getattr(dataset, 'checks', {}).get(subcheck, []) check_func = check.info.get("check_function") check_plugin_name = CheckPluginName(maincheckify(check.name)) for item, params, results_expected_raw in test_cases: print("Dataset item %r in check %r" % (item, check.name)) immu.register(params, 'params') with current_service( Service( item=item, check_plugin_name=check_plugin_name, description="unit test description", parameters={}, )): result = CheckResult(check.run_check(item, params, info_arg)) immu.test(' after check (%s): ' % check_func.__name__) result_expected = CheckResult(results_expected_raw) if write: new_entry = (item, params, result.raw_repr()) dataset.update_check_result(subcheck, new_entry) else: assertCheckResultsEqual(result, result_expected)
def test_check_memory(check_manager, params, meminfo, expected): check_memory = check_manager.get_check("mem.used").context["check_memory"] copy_info = meminfo.copy() result = check_memory(params, meminfo) assertCheckResultsEqual(CheckResult(result), CheckResult(expected)) assert copy_info == meminfo
def test_io_check(check_manager): item_1st = 'VMFS_01' params = {'flex_levels': 'irrelevant'} check = check_manager.get_check("hp_msa_volume.io") parsed = { u'VMFS_01': { u'durable-id': u'V3', u'data-read-numeric': u'23719999539712', u'data-written-numeric': u'18093374647808', u'virtual-disk-name': u'A', u'raidtype': u'RAID0', }, u'VMFS_02': { u'durable-id': u'V4', u'data-read-numeric': u'49943891507200', u'data-written-numeric': u'7384656100352', u'virtual-disk-name': u'A', u'raidtype': u'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_df_check_with_parse(check_manager, item, params, info, expected_result): check = check_manager.get_check("df") actual = CheckResult(check.run_check(item, params, check.run_parse(info))) expected = CheckResult(expected_result) assertCheckResultsEqual(actual, expected)
def test_df_check(check_manager): item_1st = 'VMFS_01' params = {'flex_levels': 'irrelevant'} check = check_manager.get_check("hp_msa_volume.df") parsed = { u'VMFS_01': { u'durable-id': u'V3', u'virtual-disk-name': u'A', u'total-size-numeric': u'4296482816', u'allocated-size-numeric': u'2484011008', u'raidtype': u'RAID0', }, u'VMFS_02': { u'durable-id': u'V4', u'virtual-disk-name': u'A', u'total-size-numeric': u'4296286208', u'allocated-size-numeric': u'3925712896', u'raidtype': u'RAID0', } } expected_result = (0, '57.81% used (1.16 of 2.00 TB), trend: 0.00 B / 24 hours', [ ('fs_used', 1212896, 1678313.6, 1888102.8, 0, 2097892), ('fs_size', 2097892), ('fs_used_percent', 57.81498761614039), ('growth', 0.0), ('trend', 0, None, None, 0, 87412.16666666667), ]) _, trend_result = check.run_check(item_1st, params, parsed) assertCheckResultsEqual(CheckResult(trend_result), CheckResult(expected_result))
def test_df_check(): item_1st = 'VMFS_01' params = {'flex_levels': 'irrelevant'} check = Check("hp_msa_volume.df") parsed = { u'VMFS_01': { u'durable-id': u'V3', u'virtual-disk-name': u'A', u'total-size-numeric': u'4296482816', u'allocated-size-numeric': u'2484011008', u'raidtype': u'RAID0', }, u'VMFS_02': { u'durable-id': u'V4', u'virtual-disk-name': u'A', u'total-size-numeric': u'4296286208', u'allocated-size-numeric': u'3925712896', u'raidtype': u'RAID0', } } expected_result = (0, '57.81% used (1.16 of 2.00 TB), trend: +2.43 TB / 24 hours', [ ('fs_used', 1212896, 1678313.6, 1888102.8, 0, 2097892), ('fs_size', 2097892), ('fs_used_percent', 57.81498761614039), ('growth', 1329829.766497462), ('trend', 2551581.1594836353, None, None, 0, 87412.16666666667), ]) with freezegun.freeze_time("2020-07-31 07:00:00"), MockItemState((1596100000, 42)): _, trend_result = check.run_check(item_1st, params, parsed) assertCheckResultsEqual(CheckResult(trend_result), CheckResult(expected_result))
def test_check_single_queue(raw_queue, levels_length, expected_result): check_single_queue = _get_from_context("_check_single_queue") queue = _get_from_context("Queue") assertCheckResultsEqual( CheckResult(check_single_queue(queue(*raw_queue), levels_length)), CheckResult(expected_result), )
def test_check_temperature_called(test_case): check = Check('acme_temp') check_temperature = check.context['check_temperature'] time = dt.datetime(2014, 1, 1, 0, 0, 0) state = { 'temp.foo.delta': (unix_ts(time), test_case.reading), 'temp.foo.trend': (0, 0) } with MockItemState(state): with freezegun.freeze_time(time + dt.timedelta(seconds=test_case.seconds_elapsed)): # Assuming atmospheric pressure... result = check_temperature( test_case.reading + test_case.growth, { 'device_level_handling': 'dev', 'trend_compute': test_case.wato_dict, }, 'foo', dev_unit='c', dev_levels=(100, 100), # don't boil dev_levels_lower=(0, 0), # don't freeze over ) assertCheckResultsEqual(CheckResult(result), CheckResult(test_case.expected))
def test_df_check_groups_with_parse(add_params, expected_result): check = Check('df') params = 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_diskstat_dict_warns_and_crits_about_read_and_write_ios( check_manager, item, params, disks, expected, monkeypatch): check = check_manager.get_check("diskstat") check_diskstat_dict = check.context["check_diskstat_dict"] with monkeypatch.context() as m: m.setattr('time.time', lambda: 0.0) actual_result = CheckResult(check_diskstat_dict(item, params, disks)) expected_result = CheckResult(expected) assertCheckResultsEqual(actual_result, expected_result)
def test_k8s_replicas(check_manager, info, expected): check = check_manager.get_check("k8s_replicas") parsed = check.run_parse(info) actual = check.run_check(None, {}, parsed) assertCheckResultsEqual( CheckResult(actual), CheckResult(expected), )
def test_uptime_solaris_inputs(check_manager, info, reference): check = check_manager.get_check("uptime") parsed = check.run_parse(info) # This time freeze has no correlation with the uptime of the test. It # is needed for the check output to always return the same infotext. # The true test happens on state and perfdata with on_time('2018-04-15 16:50', 'CET'): result = CheckResult(check.run_check(None, {}, parsed)) assertCheckResultsEqual(result, CheckResult(reference))
def test_check_nullmailer_mailq(raw_queues, expected_result): dummy_item = "" params = _get_from_context("nullmailer_mailq_default_levels") check_nullmailer_mailq = _get_from_context("check_nullmailer_mailq") queue = _get_from_context("Queue") assertCheckResultsEqual( CheckResult( check_nullmailer_mailq( dummy_item, params, [queue(*raw_queue) for raw_queue in raw_queues])), CheckResult(expected_result), )
def test_if_check(check_manager, monkeypatch, item, params, result): check = check_manager.get_check('lnx_if') assert check.run_discovery(parsed_change(0)) == DISCOVERY monkeypatch.setattr('time.time', lambda: 0) with pytest.raises(MKCounterWrapped): CheckResult(check.run_check(item, params, parsed_change(0))) monkeypatch.setattr('time.time', lambda: 5) output = check.run_check(item, params, parsed_change(4000000)) assertCheckResultsEqual(CheckResult(output), CheckResult(result))
def check_listed_result(check, list_entry, info_arg, immu): """Run check for all results listed in dataset""" item, params, results_expected_raw = list_entry print("Dataset item %r in check %r" % (item, check.name)) immu.register(params, 'params') result_raw = check.run_check(item, params, info_arg) check_func = check.info.get("check_function") immu.test(' after check (%s): ' % check_func.__name__) result = CheckResult(result_raw) result_expected = CheckResult(results_expected_raw) assertCheckResultsEqual(result, result_expected)
def test_local_check(check_manager, monkeypatch, item, info): monkeypatch.setattr('time.time', lambda: 1556005721) check = check_manager.get_check('local') parsed = check.run_parse(info) assert parsed[item][0].cached == (420.0, 140.0, 300.0) result = CheckResult(check.run_check(item, {}, parsed)) expected = CheckResult([ (0, "Cache generated 7 m ago, cache interval: 5 m, elapsed cache lifespan: 140%" ), (0, "On node node_1: This Check is outdated", [("V", 1.0)]), ]) assertCheckResultsEqual(result, expected)
def test_crashreport(check_manager, crashdata): try: generictests.run(check_manager, crashdata) check = check_manager.get_check(crashdata.full_checkname) #FIXME #if crashdata.is_discovery: # if crashdata.parsed: # raw_result = check.run_discovery(crashdata.parsed) # else: # raw_result = check.run_discovery(crashdata.info) # print(DiscoveryResult(raw_result)) # return 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: pprint.pprint(crashdata.__dict__) crashdata.write() raise
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_subset_patterns(check_manager): check = check_manager.get_check("ps") check.set_check_api_utils_globals() # needed for host name parsed = check.context['parse_ps']( splitter("""(user,0,0,0.5) main (user,0,0,0.4) main_dev (user,0,0,0.1) main_dev (user,0,0,0.5) main_test"""))[1] # Boundary in match is necessary otherwise main instance accumulates all wato_rule = [({ 'default_params': { 'cpu_rescale_max': True, 'levels': (1, 1, 99999, 99999) }, 'match': '~(main.*)\\b', 'descr': '%s' }, [], ["@all"], {})] discovered = [ ('main', { 'cpu_rescale_max': True, 'levels': (1, 1, 99999, 99999), 'process': '~(main.*)\\b', 'match_groups': ('main',), 'user': None, 'cgroup': (None, False), }), ('main_dev', { 'cpu_rescale_max': True, 'levels': (1, 1, 99999, 99999), 'process': '~(main.*)\\b', 'match_groups': ('main_dev',), 'user': None, 'cgroup': (None, False), }), ('main_test', { 'cpu_rescale_max': True, 'levels': (1, 1, 99999, 99999), 'process': '~(main.*)\\b', 'match_groups': ('main_test',), 'user': None, 'cgroup': (None, False), }), ] assert check.context["inventory_ps_common"](wato_rule, parsed) == discovered def counted_reference(count): return CheckResult([ (0, "%s process%s" % (count, '' if count == 1 else 'es'), [("count", count, 100000, 100000, 0, None)]), (0, "0.5% CPU", [("pcpu", 0.5, None, None, None, None)]), ]) for (item, params), count in zip(discovered, [1, 2, 1]): output = CheckResult(check.context["check_ps_common"](item, params, parsed, cpu_cores=1)) assertCheckResultsEqual(output, counted_reference(count))
def test_check_diskstat_line(monkeypatch, args, expected_result): monkeypatch.setattr(cmk.base.check_legacy_includes.diskstat, 'get_rate', get_rate) monkeypatch.setattr(cmk.base.check_legacy_includes.diskstat, 'get_average', get_average) actual_result = CheckResult(check_diskstat_line(*args)) # type: ignore[name-defined] # pylint: disable=undefined-variable assertCheckResultsEqual(actual_result, expected_result)
def test_check_ps_common_cpu(check_manager, monkeypatch, data): check = check_manager.get_check("ps") def time_info(agent_info, check_time, cputime, cpu_cores): with on_time(datetime.datetime.utcfromtimestamp(check_time), "CET"): parsed = check.context['parse_ps'](splitter(agent_info.format(cputime)))[1] return CheckResult(check.context["check_ps_common"]( inv_item[0], inv_item[1], parsed, cpu_cores=cpu_cores)) inv_item = ( "test", { "process": "~test", "user": None, "levels": (1, 1, 99999, 99999) # from factory defaults }) if data.cpu_rescale_max is not None: inv_item[1].update({"cpu_rescale_max": data.cpu_rescale_max}) # Initialize counters time_info(data.agent_info, 0, 0, data.cpu_cores) # Check_cpu_utilization output = time_info(data.agent_info, 60, data.cputime, data.cpu_cores) reference = CheckResult([ (0, "1 process", [("count", 1, 100000, 100000, 0)]), (0, "105.00 kB virtual", [("vsz", 105, None, None, None, None)]), (0, "30.00 kB physical", [("rss", 30, None, None, None, None)]), check.context["cpu_check"](data.exp_load, inv_item[0], inv_item[1]), (0, "running for 239 m", []), ]) assertCheckResultsEqual(output, reference)
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_with_parse(check_manager, item, params, info, expected_result): check = check_manager.get_check("df") if params == "default": params = check.default_parameters() result = CheckResult(check.run_check(item, params, check.run_parse(info)))
def test_check_diskstat_generic_summary_clutster(monkeypatch, info, expected_result): monkeypatch.setattr(cmk.base.check_legacy_includes.diskstat, 'get_rate', get_rate) monkeypatch.setattr(cmk.base.check_legacy_includes.diskstat, 'get_average', get_average) actual_result = CheckResult(check_diskstat_generic("SUMMARY", {}, 0, info)) # type: ignore[name-defined] # pylint: disable=undefined-variable assertCheckResultsEqual(actual_result, expected_result)
def check_discovered_result(check, discovery_result, info_arg, immu): """Run the check on all discovered items with the default parameters. We cannot validate the results, but at least make sure we don't crash. """ print("Check %r in check %r" % (discovery_result, check.name)) item = discovery_result.item params = get_merged_parameters(check, discovery_result.default_params) immu.register(params, 'params') raw_checkresult = check.run_check(item, params, info_arg) check_func = check.info.get("check_function") immu.test(' after check (%s): ' % check_func.__name__) cr = CheckResult(raw_checkresult) return (item, params, cr.raw_repr())
def test_local_check(check_manager, monkeypatch, item, info): monkeypatch.setattr('time.time', lambda: 1556005721) check = check_manager.get_check('local') parsed = check.run_parse(info) assert parsed[item][0].expired == 120. with pytest.raises(MKCounterWrapped): CheckResult(check.run_check(item, {}, parsed))
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_cpu_util_single_process_levels(check_manager, monkeypatch, cpu_cores): """Test CPU utilization per single process. - Check that Number of cores weight is active - Check that single process CPU utilization is present only on warn/crit states""" check = check_manager.get_check("ps") params: Dict[str, Any] = { 'process': '~.*firefox', 'process_info': "text", 'cpu_rescale_max': True, 'levels': (1, 1, 99999, 99999), 'single_cpulevels': (45.0, 80.0), } def run_check_ps_common_with_elapsed_time(check_time, cputime): with on_time(check_time, "CET"): agent_info = """(on,2275004,434008,00:00:49/26:58,25576) firefox (on,1869920,359836,00:01:23/6:57,25664) firefox (on,7962644,229660,00:00:10/26:56,25758) firefox (on,1523536,83064,00:{:02}:00/26:55,25898) firefox""" parsed = check.context['parse_ps'](splitter(agent_info.format(cputime)))[1] return CheckResult(check.context["check_ps_common"]( 'firefox', params, parsed, cpu_cores=cpu_cores)) # CPU utilization is a counter, initialize it run_check_ps_common_with_elapsed_time(0, 0) # CPU utilization is a counter, after 60s time, one process consumes 2 min of CPU output = run_check_ps_common_with_elapsed_time(60, 2) cpu_util = 200.0 / cpu_cores cpu_util_s = check.context['get_percent_human_readable'](cpu_util) single_msg = 'firefox with PID 25898 CPU: %s (warn/crit at 45.0%%/80.0%%)' % cpu_util_s reference = [ (0, "Processes: 4", [("count", 4, 100000, 100000, 0)]), (0, "virtual: 13.00 GB", [("vsz", 13631104, None, None, None, None)]), (0, "physical: 1.06 GB", [("rss", 1106568, None, None, None, None)]), (0, "CPU: %s" % cpu_util_s, [('pcpu', cpu_util, None, None, None, None)]), (0, 'youngest running for: 6 m', []), (0, 'oldest running for: 26 m', []), (0, "\r\n".join([ '\nname firefox, user on, virtual size 2275004kB, resident size 434008kB, creation time 1970-01-01 00:34:02, pid 25576, cpu usage 0.0%', 'name firefox, user on, virtual size 1869920kB, resident size 359836kB, creation time 1970-01-01 00:54:03, pid 25664, cpu usage 0.0%', 'name firefox, user on, virtual size 7962644kB, resident size 229660kB, creation time 1970-01-01 00:34:04, pid 25758, cpu usage 0.0%', 'name firefox, user on, virtual size 1523536kB, resident size 83064kB, creation time 1970-01-01 00:34:05, pid 25898, cpu usage %.1f%%\r\n' % cpu_util, ])) ] if cpu_util > params['single_cpulevels'][1]: reference.insert(4, (2, single_msg, [])) elif cpu_util > params['single_cpulevels'][0]: reference.insert(4, (1, single_msg, [])) assertCheckResultsEqual(output, CheckResult(reference))
def run_check_ps_common_with_elapsed_time(check_time, cputime): with on_time(check_time, "CET"): agent_info = """(on,2275004,434008,00:00:49/26:58,25576) firefox (on,1869920,359836,00:01:23/6:57,25664) firefox (on,7962644,229660,00:00:10/26:56,25758) firefox (on,1523536,83064,00:{:02}:00/26:55,25898) firefox""" parsed = check.context['parse_ps'](splitter(agent_info.format(cputime)))[1] return CheckResult(check.context["check_ps_common"]( 'firefox', params, parsed, cpu_cores=cpu_cores))