condition["reason"], condition["message"]), ) continue time_difference = current_timestamp - condition["last_transition_time"] check_result = list( check_levels( time_difference, levels_upper=condition_levels(params=params, condition=name), render_func=render.timespan, )) result = check_result[0] yield Result( state=result.state, summary= f"{condition_detailed_description(condition_name, condition['status'], condition['reason'], condition['message'])} for {result.summary}", ) register.check_plugin( name="kube_deployment_conditions", service_name="Condition", discovery_function=discovery, check_function=check, check_default_parameters=dict( available="no_levels", progressing="no_levels", replicafailure="no_levels", ), check_ruleset_name="kube_deployment_conditions",
), ]), ]) def test_discover_smart_stats(section, discovered): assert list(smart.discover_smart_stats(section)) == discovered @pytest.mark.parametrize("item, params, section, result", [ ("/dev/sda", { 'Current_Pending_Sector': 0, 'End-to-End_Error': 0, 'Reallocated_Sector_Ct': 0, 'Reported_Uncorrect': 0, 'UDMA_CRC_Error_Count': 0, }, SECTION_SD, [ Result(state=State.OK, summary='Powered on: 67 days 1 hour'), Metric('Power_On_Hours', 1609), Result(state=State.OK, summary='Power cycles: 9'), Metric('Power_Cycle_Count', 9), Result(state=State.OK, summary='Uncorrectable errors: 0'), Metric('Reported_Uncorrect', 0), Result(state=State.OK, summary='Reallocated sectors: 0'), Metric('Reallocated_Sector_Ct', 0), Result(state=State.OK, summary='Pending sectors: 0'), Metric('Current_Pending_Sector', 0), Result(state=State.OK, summary='End-to-End errors: 0'), Metric('End-to-End_Error', 0), Result(state=State.OK, summary='UDMA CRC errors: 0'), Metric('UDMA_CRC_Error_Count', 0), ]), ("/dev/nvme0n1", {'Critical_Warning': 0}, SECTION_NVME, [
info = list(itertools.chain.from_iterable(generate_inputs())) assert sorted({s.item: s for s in ps_utils.discover_ps( # type: ignore[attr-defined] PS_DISCOVERY_WATO_RULES, # type: ignore[arg-type] ps_section.parse_ps(info), None, None, )}.values(), key=lambda s: s.item or "") == sorted(PS_DISCOVERED_ITEMS, key=lambda s: s.item or "") # type: ignore[attr-defined] CheckResult = tuple check_results = [ [ Result( state=state.OK, summary="Processes: 1", ), Metric("count", 1, levels=(100000, 100000), boundaries=(0, None)), Result( state=state.WARN, notice="virtual: 1.00 GiB (warn/crit at 1.00 GiB/2.00 GiB)", ), Metric("vsz", 1050360, levels=(1073741824, 2147483648)), Result( state=state.OK, notice="physical: 296 MiB", ), Metric("rss", 303252, levels=(1073741824, 2147483648)), Result( state=state.WARN, notice="Percentage of total RAM: 28.92% (warn/crit at 25.00%/50.00%)",
]], { 'pages_total': 118722, 'pages_color': 55876, 'pages_bw': 62846 }, ), ]) def test_parse_printer_pages_ricoh(string_table, expected_parsed_data): assert parse_printer_pages_ricoh(string_table) == expected_parsed_data @pytest.mark.parametrize("section,expected_results", [ ({ 'pages_color': 21693, 'pages_bw': 54198 }, [ Result(state=state.OK, summary='total prints: 75891'), Metric('pages_total', 75891.0), Result(state=state.OK, summary='b/w: 54198'), Metric('pages_bw', 54198.0), Result(state=state.OK, summary='color: 21693'), Metric('pages_color', 21693.0), ]), ]) def test_check_printer_pages_types(section, expected_results): assert list(check_printer_pages_types(section)) == expected_results _ = __name__ == "__main__" and pytest.main(["-svv", "-T=unit", __file__])
{ "state_mapping": { "Alert": State.CRIT, "Ignored": State.UNKNOWN, "No Data": State.UNKNOWN, "OK": State.OK, "Skipped": State.UNKNOWN, "Unknown": State.UNKNOWN, "Warn": State.WARN, }, "tags_to_show": [], }, [ Result( state=State.CRIT, summary="Overall state: Alert", details="Devices in env {{env.name}} receive article updates delayed!", ), Result( state=State.OK, summary="Datadog thresholds: critical: 180.0", ), ], id="standard case", ), pytest.param( "staging | IDM Gateway Service | Import Error Rate", { "state_mapping": { "Alert": State.CRIT, "Ignored": State.UNKNOWN,
def test_check(): yielded_results = list( livestatus_status._generate_livestatus_results( "heute", Parameters(livestatus_status.livestatus_status_default_levels), PARSED_STATUS, PARSED_SSL, { "host_checks": [1, 2], "service_checks": [1, 2], "forks": [1, 2], "connections": [1, 2], "requests": [1, 2], "log_messages": [1, 2], }, 581785200, )) assert yielded_results == [ Result(state=state.OK, summary='Livestatus version: 2019.05.31'), Result(state=state.OK, summary='Host checks: 0.0/s'), Metric('host_checks', 7.615869237677187e-05), Result(state=state.OK, summary='Service checks: 0.0/s'), Metric('service_checks', 0.0002685888198403617), Result(state=state.OK, notice='Process creations: -0.0/s'), Metric('forks', -3.4376948802370615e-09), Result(state=state.OK, notice='Livestatus connects: 0.0/s'), Metric('connections', 6.261761224351807e-06), Result(state=state.OK, notice='Livestatus requests: 0.0/s'), Metric('requests', 8.090614900637924e-06), Result(state=state.OK, notice='Log messages: 0.0/s'), Metric('log_messages', 1.5985281193102335e-06), Result(state=state.OK, notice='Average check latency: 0.000s'), Metric('average_latency_generic', 2.23711e-06, levels=(30.0, 60.0)), Result(state=state.OK, notice='Average Checkmk latency: 0.000s'), Metric('average_latency_cmk', 2.01088e-05, levels=(30.0, 60.0)), Result(state=state.OK, notice='Average fetcher latency: 0.000s'), Metric('average_latency_fetcher', 2.01088e-05, levels=(30.0, 60.0)), Result(state=state.OK, notice='Check helper usage: 1.4%'), Metric('helper_usage_generic', 1.42967, levels=(60.0, 90.0)), Result(state=state.OK, notice='Checkmk helper usage: 0.044%'), Metric('helper_usage_cmk', 0.043827200000000004, levels=(60.0, 90.0)), Result(state=state.OK, notice='Fetcher helper usage: 0.044%'), Metric('helper_usage_fetcher', 0.043827200000000004, levels=(40.0, 80.0)), Result(state=state.OK, notice='Checker helper usage: 0.044%'), Metric('helper_usage_checker', 0.043827200000000004, levels=(40.0, 80.0)), Result(state=state.OK, notice='Livestatus usage: 0.000000000000%'), Metric('livestatus_usage', 3.46e-321, levels=(80.0, 90.0)), Result(state=state.OK, notice='Livestatus overflow rate: 0.0/s'), Metric('livestatus_overflows_rate', 0.0, levels=(0.01, 0.02)), Result(state=state.OK, notice='Hosts: 2.00'), Metric('monitored_hosts', 2.0), Result(state=state.OK, notice='Services: 513.00'), Metric('monitored_services', 513.0), Result(state=state.OK, notice='Core version: Checkmk 2019.05.31'), Result( state=state.OK, notice='Site certificate valid until Oct 01 3017', ), Result( state=state.OK, notice='Expiring in: 1029 years 363 days', ), Metric('site_cert_days', 375948.7452314815), ]
from cmk.base.api.agent_based import value_store import pytest # type: ignore[import] KILO = 1024 MEGA = KILO**2 @pytest.mark.parametrize( "label,used,total,levels,kwargs,expected", [ # all variants of "no levels" ("Longterm", 23 * MEGA, 42 * MEGA, None, {}, [ Result( state=state.OK, summary="Longterm: 54.8% - 23.0 MiB of 42.0 MiB", ), ]), ("Longterm", 23 * MEGA, 42 * MEGA, "ignore", {}, [ Result( state=state.OK, summary="Longterm: 54.8% - 23.0 MiB of 42.0 MiB", ), ]), ("Longterm", 23 * MEGA, 42 * MEGA, ("ignore", None), {}, [ Result( state=state.OK, summary="Longterm: 54.8% - 23.0 MiB of 42.0 MiB", ), ]), ("Longterm", 23 * MEGA, 42 * MEGA, ("ignore", (None, None)), {}, [
def test_winperf_if_group_patterns(value_store): expected_services = [ Service(item='Broadcom ABC123 NetXtreme 123 GigE [Client1] 138', parameters={ 'discovered_oper_status': ['1'], 'discovered_speed': 1410065408 }), Service(item='Broadcom ABC456 NetXtreme 456 GigE [Client2] 137', parameters={ 'discovered_oper_status': ['1'], 'discovered_speed': 1410065408 }), Service( item='Broadcom', parameters={ 'aggregate': { 'member_appearance': 'descr', 'inclusion_condition': { 'match_desc': [ 'Broadcom ABC123 NetXtreme 123 GigE \\[Client1\\] 138', 'Broadcom ABC456 NetXtreme 456 GigE \\[Client2\\] 137' ] }, 'exclusion_conditions': [] }, 'discovered_oper_status': ['1'], 'discovered_speed': 2820130816.0 }), Service( item='isatap', parameters={ 'aggregate': { 'member_appearance': 'descr', 'inclusion_condition': { 'match_desc': [ 'isatap.{A1A1A1A1-A1A1-A1A1-A1A1-A1A1A1A1A1A1}', 'isatap.{B1B1B1B1-B1B1-B1B1-B1B1-B1B1B1B1B1B1}', 'isatap.{C1C1C1C1-C1C1-C1C1-C1C1-C1C1C1C1C1C1}', 'isatap.{D1D1D1D1-D1D1-D1D1-D1D1-D1D1D1D1D1D1}', 'isatap.{E1E1E1E1-E1E1-E1E1-E1E1-E1E1E1E1E1E1}', 'isatap.{F1F1F1F1-F1F1-F1F1-F1F1-F1F1F1F1F1F1}' ] }, 'exclusion_conditions': [] }, 'discovered_oper_status': ['1'], 'discovered_speed': 600000.0 }), ] section = winperf_if.parse_winperf_if(IF_SECTION) assert list( winperf_if.discover_winperf_if( [ type_defs.Parameters({ 'discovery_single': ( False, {}, ), 'grouping': ( True, { 'group_items': [ { 'group_name': 'isatap', 'member_appearance': 'descr', }, ], }, ), 'matching_conditions': ( False, { 'match_desc': [ 'isatap.{A1A1A1A1-A1A1-A1A1-A1A1-A1A1A1A1A1A1}', 'isatap.{B1B1B1B1-B1B1-B1B1-B1B1-B1B1B1B1B1B1}', 'isatap.{C1C1C1C1-C1C1-C1C1-C1C1-C1C1C1C1C1C1}', 'isatap.{D1D1D1D1-D1D1-D1D1-D1D1-D1D1D1D1D1D1}', 'isatap.{E1E1E1E1-E1E1-E1E1-E1E1-E1E1E1E1E1E1}', 'isatap.{F1F1F1F1-F1F1-F1F1-F1F1-F1F1F1F1F1F1}', ], }, ), }), type_defs.Parameters({ 'grouping': ( True, { 'group_items': [ { 'group_name': 'Broadcom', 'member_appearance': 'descr', }, ], }, ), 'matching_conditions': ( False, { 'match_desc': [ 'Broadcom ABC123 NetXtreme 123 GigE \\[Client1\\] 138', 'Broadcom ABC456 NetXtreme 456 GigE \\[Client2\\] 137', ], }, ), }), type_defs.Parameters({ **interfaces.DISCOVERY_DEFAULT_PARAMETERS, 'discovery_single': ( True, { 'item_appearance': 'descr', 'pad_portnumbers': True, }, ), }), ], section, )) == expected_services assert [ result for service in expected_services for result in winperf_if.check_winperf_if( service.item or "", # or "" to make mypy happy type_defs.Parameters(service.parameters), section, ) if not isinstance(result, IgnoreResults) ] == [ Result(state=state.OK, summary='[1]'), Result(state=state.OK, summary='(Connected)', details='Operational state: Connected'), Result(state=state.OK, summary='Speed: 1.41 GBit/s'), Result(state=state.OK, summary='[2]'), Result(state=state.OK, summary='(Connected)', details='Operational state: Connected'), Result(state=state.OK, summary='Speed: 1.41 GBit/s'), Result(state=state.OK, summary='Teaming'), Result(state=state.OK, summary='(up)', details='Operational state: up'), Result( state=state.OK, summary= ('Members: [Broadcom ABC123 NetXtreme 123 GigE [Client1] 138 (Connected),' ' Broadcom ABC456 NetXtreme 456 GigE [Client2] 137 (Connected)]'), ), Result(state=state.OK, summary='Speed: 2.82 GBit/s'), Result(state=state.OK, summary='Teaming'), Result(state=state.OK, summary='(up)', details='Operational state: up'), Result( state=state.OK, summary= ('Members: [isatap.{A1A1A1A1-A1A1-A1A1-A1A1-A1A1A1A1A1A1} (Connected),' ' isatap.{B1B1B1B1-B1B1-B1B1-B1B1-B1B1B1B1B1B1} (Connected),' ' isatap.{C1C1C1C1-C1C1-C1C1-C1C1-C1C1C1C1C1C1} (Connected),' ' isatap.{D1D1D1D1-D1D1-D1D1-D1D1-D1D1D1D1D1D1} (Connected),' ' isatap.{E1E1E1E1-E1E1-E1E1-E1E1-E1E1E1E1E1E1} (Connected),' ' isatap.{F1F1F1F1-F1F1-F1F1-F1F1-F1F1F1F1F1F1} (Connected)]'), ), Result(state=state.OK, summary='Speed: 600 kBit/s'), ]
@pytest.mark.parametrize("item, params, expected_results", [ ("H62 10 - DATA 20", df.FILESYSTEM_DEFAULT_LEVELS, [ Metric( 'fs_used', 84.703125, levels=(256.0, 288.0), boundaries=(0.0, 320.0), ), Metric('fs_size', 320.0, boundaries=(0.0, None)), Metric( 'fs_used_percent', 26.4697265625, levels=(80.0, 90.0), boundaries=(0.0, 100.0), ), Result(state=state.OK, summary='26.47% used (84.7 of 320 MiB)'), Metric('growth', -4470.553049074118), Result(state=state.OK, summary='trend per 1 day 0 hours: +621 TiB'), Result(state=state.OK, summary='trend per 1 day 0 hours: +203357489.65%'), Metric( 'trend', 650743966.868858, boundaries=(0.0, 13.333333333333334), ), Result(state=state.OK, summary='Time left until disk full: 31 milliseconds'), Result(state=state.OK, summary='Service: scriptserver'), Result(state=state.OK, summary='Path: /hana/data/H62/mnt00007/hdb00020/datavolume_0000.dat'), ]), ("H62 10 - DATA 20", LEVELS_CRIT, [ Metric(
[u'22731'], [u'[uptime_solaris_start]'], [ u'SunOS', u'unknown', u'5.10', u'Generic_147148-26', u'i86pc', u'i386', u'i86pc' ], [u'global'], [ u'4:58pm', u'up', u'6:19,', u'2', u'users,', u'load', u'average:', u'0.18,', u'0.06,', u'0.03' ], [u'unix:0:system_misc:snaptime', u'22737.886916295'], [u'[uptime_solaris_end]'], ], [ Result(state=State.OK, summary='Up since Apr 15 2018 12:31:09'), Result(state=State.OK, summary='Uptime: 6 hours 18 minutes'), Metric('uptime', 22731), ], ), ( [ [u'1122'], [u'[uptime_solaris_start]'], [ u'SunOS', u'unknown', u'5.10', u'Generic_147148-26', u'i86pc', u'i386', u'i86pc' ], [u'global'], [ u'4:23pm', u'up', u'19', u'min(s),', u'2', u'users,', u'load',
group='DAG-NET', ), ], {}, ) @pytest.mark.parametrize("item, params, results", [ ( '3', { 'discovered_oper_status': ['1'], 'discovered_speed': 10000000000 }, [ Result(state=state.OK, summary='[SLOT 6 Port 1 DAG]'), Result(state=state.OK, summary='(Connected)', details='Operational state: Connected'), Result(state=state.OK, summary='MAC: A0:36:9F:B0:A3:60'), Result(state=state.OK, summary='Speed: 10 GBit/s'), Metric('in', 0.0, boundaries=(0.0, 1250000000.0)), Metric('inmcast', 0.0), Metric('inbcast', 0.0), Metric('inucast', 0.0), Metric('innucast', 0.0), Metric('indisc', 0.0), Metric('inerr', 0.0), Metric('out', 1073741824.0, boundaries=(0.0, 1250000000.0)), Metric('outmcast', 0.0), Metric('outbcast', 0.0),
assert list(winperf_processor.discover_winperf_processor_util(SECTION)) == [ Service(), ] @pytest.mark.parametrize( "value_store, params, result", [ ( {}, {}, [ IgnoreResults("Initialized: 'util'"), IgnoreResults("Initialized: 'user'"), IgnoreResults("Initialized: 'privileged'"), Result(state=State.OK, notice="Number of processors: 4"), Metric("cpus", 4), ], ), ( VALUE_STORE, {}, [ Result(state=State.OK, summary="Total CPU: 100.00%"), Metric("util", 99.99983122362869, boundaries=(0, 4)), # boundaries: 4 as in 4 CPUs Result(state=State.OK, notice="User: <0.01%"), Metric("user", 0.0005063291139240507), Result(state=State.OK, notice="Privileged: <0.01%"), Metric("privileged", 1.687763713080169e-05), Result(state=State.OK, notice="Number of processors: 4"), Metric("cpus", 4),
def test_check_item_not_in_section(section: Section, item: str, summary: str): results = list(check(item=item, section=section)) assert results == [Result(state=State.CRIT, summary=summary)]
("ora.cssd", "Clusterware not running"), ("ora.crsd", "Cluster resource service daemon not running"), ], ) def test_check_item_not_in_section(section: Section, item: str, summary: str): results = list(check(item=item, section=section)) assert results == [Result(state=State.CRIT, summary=summary)] def test_check_item_not_in_section_and_cluster_down(section: Section): with pytest.raises(IgnoreResultsError): list(check(item="foo", section=section)) @pytest.mark.parametrize( "item, results", [ ( "ora.DG_CLUSTER.dg", [ Result(state=State.OK, summary="online"), Result(state=State.OK, summary="on host2: online"), Result(state=State.CRIT, summary="on oracle_host: off, target state online"), ], ), ("ora.cluster_interconnect.haip", [Result(state=State.OK, summary="local: online")]), ], ) def test_check_item_in_section(section: Section, item: str, results: Sequence[Result]): assert results == list(check(item=item, section=section))
def test_storcli_cache_vault_check_ok(section: mcv.Section) -> None: assert list(mcv.check_storcli_cache_vault("/c0", section)) == [ Result(state=State.OK, summary="Optimal"), Result(state=State.OK, summary="Capacitance: 111.00%"), ]
PARSED_SSL, { "host_checks": [1, 2], "service_checks": [1, 2], "forks": [1, 2], "connections": [1, 2], "requests": [1, 2], "log_messages": [1, 2], }, 581785200, )) assert all(x in yielded_results for x in fetcher_checker_counters) _RESULTS = [ Result(state=state.OK, summary='Livestatus version: 2019.05.31'), Result(state=state.OK, summary='Host checks: 0.0/s'), Metric('host_checks', 7.615869237677187e-05, boundaries=(0.0, None)), Result(state=state.OK, summary='Service checks: 0.0/s'), Metric('service_checks', 0.0002685888198403617, boundaries=(0.0, None)), Result(state=state.OK, notice='Process creations: -0.0/s'), Metric('forks', -3.4376948802370615e-09, boundaries=(0.0, None)), Result(state=state.OK, notice='Livestatus connects: 0.0/s'), Metric('connections', 6.261761224351807e-06, boundaries=(0.0, None)), Result(state=state.OK, notice='Livestatus requests: 0.0/s'), Metric('requests', 8.090614900637924e-06, boundaries=(0.0, None)), Result(state=state.OK, notice='Log messages: 0.0/s'), Metric('log_messages', 1.5985281193102335e-06, boundaries=(0.0, None)), Result(state=state.OK, notice='Average check latency: 0.000s'), Metric('average_latency_generic', 2.23711e-06, levels=(30.0, 60.0), boundaries=(0.0, None)), Result(state=state.OK, notice='Average Checkmk latency: 0.000s'),
pytest.param( { 'failover_state': 1, 'primary': 'active', 'secondary': 'standby', }, Section( local_role='primary', local_status='9', local_status_detail='Active unit', failover_link_status='2', remote_status='10', ), [ Result( state=State.OK, summary='Device (primary) is the Active unit', ), ], id='Check: local unit == Primary unit == Active unit', ), pytest.param( { 'failover_state': 1, 'primary': 'active', 'secondary': 'standby', }, Section( local_role='primary', local_status='10', local_status_detail='Standby unit', failover_link_status='2',
@pytest.mark.parametrize( "string_table,expected_parsed_data", [ ([[["4"]]], 4), ], ) def test_parse_f5_bigip_cluster_status(string_table, expected_parsed_data): assert parse_f5_bigip_cluster_status(string_table) == expected_parsed_data @pytest.mark.parametrize( "arg,result", [ ((def_params, 3), [Result(state=state.OK, summary="Node is active")]), ((def_params, 2), [Result(state=state.OK, summary="Node is active 2") ]), ((def_params, 1), [Result(state=state.OK, summary="Node is active 1") ]), ((def_params, 0), [Result(state=state.OK, summary="Node is standby")]), ], ) def test_check_f5_bigip_cluster_status(arg, result): assert list(check_f5_bigip_cluster_status(arg[0], arg[1])) == result @pytest.mark.parametrize( "arg,result", [ ((def_params, 4), [Result(state=state.OK, summary="Node is active")]),
], ) def test_parse_kaspersky_av_client(string_table, now, expected_section): assert kaspersky_av_client._parse_kaspersky_av_client( string_table, now=now) == expected_section @pytest.mark.parametrize( "section,results", [ ( dict(fullscan_age=2, signature_age=2), [ Result( state=State.WARN, summary= "Last update of signatures: 2 seconds ago (warn/crit at 2 seconds ago/3 seconds ago)", ), Result( state=State.WARN, summary= "Last fullscan: 2 seconds ago (warn/crit at 2 seconds ago/3 seconds ago)", ), ], ), ( dict(fullscan_age=3, signature_age=3), [ Result( state=State.CRIT, summary=
@pytest.mark.parametrize( "section_kube_memory_resources,section_kube_performance_memory,expected_result", [ pytest.param( Resources( request=0.0, limit=28120704.0, count_unspecified_limits=0, count_zeroed_limits=0, count_unspecified_requests=0, count_total=2, ), None, ( Result(state=State.OK, summary="Requests: 0 B (2/2 containers with requests)"), Metric("kube_memory_request", 0.0, boundaries=(0.0, None)), Result( state=State.OK, summary="Limits: 26.8 MiB (2/2 containers with limits)"), Metric("kube_memory_limit", 28120704.0, boundaries=(0.0, None)), Result(state=State.OK, summary="Allocatable: 34.3 MiB"), Metric("kube_memory_allocatable", 35917989.0, boundaries=(0.0, None)), ), id="No performance data", ), pytest.param( Resources(
]) def test_regression_discovery(monkeypatch, discovery_params, discovery_results): patch_discovery_params_retrieval(monkeypatch, discovery_params) assert list(ipmi.discover_ipmi( SECTION_IPMI, SECTION_IPMI_DISCRETE, )) == discovery_results @pytest.mark.parametrize('item, check_results', [ ('Summary', [ Metric('ambient_temp', 18.5), Result( state=state.CRIT, summary= '146 sensors - 105 OK - 1 CRIT: PS1_Status (ok (Presence detected, Failure detected <= NOT OK !!)) - 40 skipped', details= '146 sensors - 105 OK - 1 CRIT: PS1_Status (ok (Presence detected, Failure detected <= NOT OK !!)) - 40 skipped' ) ]), ('CMOS_Battery', [Result(state=state.OK, summary='Status: ok', details='Status: ok')]), ('ROMB_Battery', [Result(state=state.OK, summary='Status: ok', details='Status: ok')]), ('VCORE', [ Result(state=state.OK, summary='Status: ok (State Deasserted)', details='Status: ok (State Deasserted)') ]), ('1.2V_VDDR', [ Result(state=state.OK, summary='Status: ok (State Deasserted)', details='Status: ok (State Deasserted)')
"1072 mount_id3.trend": [LAST_TIME_EPOCH, LAST_TIME_EPOCH, 8989], } monkeypatch.setattr(hitachi_hnas_volume, "get_value_store", lambda: value_store_patched) yield value_store_patched @pytest.mark.parametrize( "item,params,section,expected", [ ( "1024 mount_id1", {}, common_section, ( Result(state=State.OK, summary="no filesystem size information"), Result(state=State.OK, summary="Status: mounted"), Result(state=State.OK, summary="assigned to EVS 1"), ), ), ( "1071 mount_id2", {}, common_section, ( Result(state=State.OK, summary="no filesystem size information"), Result(state=State.WARN, summary="Status: unformatted"), Result(state=State.OK, summary="assigned to EVS 1"), ), ),
@pytest.mark.parametrize( "section_kube_memory_resources,section_kube_performance_memory,expected_result", [ pytest.param( Resources( request=0.0, limit=28120704.0, count_unspecified_limits=0, count_zeroed_limits=0, count_unspecified_requests=0, count_total=2, ), None, ( Result(state=State.OK, summary="Request: 0 B (2/2 containers with requests)"), Metric("kube_memory_request", 0.0, boundaries=(0.0, None)), Result(state=State.OK, summary="Limit: 26.8 MiB (2/2 containers with limits)"), Metric("kube_memory_limit", 28120704.0, boundaries=(0.0, None)), ), id="No performance data", ), pytest.param( Resources( request=0.0, limit=0.0, count_unspecified_limits=0, count_zeroed_limits=2, count_unspecified_requests=0, count_total=2, ),
yield value_store_patched @pytest.mark.parametrize( "item, info, expected_result", [ ( "HXE 90 HXE - Log", [ ["[[HXE 90 HXE]]"], ["Data", "OK", "Size 64.3 GB, Used 10.1 GB, Free 85 %"], ["Log", "OK", "Size 64.3 GB, Used 10.1 GB, Free 85 %"], ["Trace", "OK", "Size 64.3 GB, Used 10.1 GB, Free 85 %"], ], [ Result(state=State.OK, summary="Status: OK"), Metric( "fs_used", 10342.400000000001, levels=(52674.56, 59258.88), boundaries=(0.0, 65843.2), ), Metric("fs_size", 65843.2, boundaries=(0.0, None)), Metric( "fs_used_percent", 15.707620528771386, levels=(80.0, 90.0), boundaries=(0.0, 100.0), ), Result(state=State.OK, summary="15.71% used (10.1 of 64.3 GiB)"),
def test_discover_oracle_performance(fix_register, string_table, expected_result): check_plugin = fix_register.check_plugins[CheckPluginName( "oracle_performance")] section = parse_oracle_performance(string_table) assert sorted(check_plugin.discovery_function(section)) == expected_result @pytest.mark.parametrize( "string_table, item, expected_result", [ ( _AGENT_OUTPUT_1, "TWH", [ Result(state=State.OK, summary="DB Time: 0.00 1/s"), Metric("oracle_db_time", 0.0), Result(state=State.OK, summary="DB CPU: 0.00 1/s"), Metric("oracle_db_cpu", 0.0), Result(state=State.OK, summary="DB Non-Idle Wait: 0.00 1/s"), Metric("oracle_db_wait_time", 0.0), Result(state=State.OK, summary="Buffer hit ratio: 98.1%"), Metric("oracle_buffer_hit_ratio", 98.096392315184), Result(state=State.OK, summary="Library cache hit ratio: 99.3%"), Metric("oracle_library_cache_hit_ratio", 99.32706545096245), Metric("oracle_buffer_busy_wait", 0.0), Metric("oracle_consistent_gets", 0.0), Metric("oracle_db_block_change", 0.0), Metric("oracle_db_block_gets", 0.0), Metric("oracle_free_buffer_wait", 0.0),
def check_waiting(params: Mapping[str, int], state: ContainerWaitingState) -> CheckResult: summary = f"Status: Waiting ({state.reason}: {state.detail})" yield Result(state=State.OK, summary=summary)
if item not in section_gcp_service_cloud_sql: return metrics = { "up": gcp.MetricSpec("cloudsql.googleapis.com/database/up", str, dtype="int"), } timeseries = section_gcp_service_cloud_sql[item].rows yield from gcp.generic_check(metrics, timeseries, {}) metric_type = "cloudsql.googleapis.com/database/state" if (metric := next((r for r in timeseries if r.ts.metric.type == metric_type), None)) is None: yield Result(state=State.UNKNOWN, summary="No data available") return gcp_state = metric.ts.points[0].value.string_value state = State(params[gcp_state]) summary = f"State: {gcp_state}" yield Result(state=state, summary=summary) register.check_plugin( name="gcp_sql_status", sections=["gcp_service_cloud_sql", "gcp_assets"], service_name="GCP Cloud SQL: %s", check_ruleset_name="gcp_sql_status", discovery_function=discover, check_function=check_gcp_sql_status, check_default_parameters={ "RUNNING": int(State.OK), "SUSPEND": int(State.WARN), "RUNNABLE": int(State.OK), "PENDING_CREATE": int(State.UNKNOWN), "MAINTENANCE": int(State.UNKNOWN),
def check_running(params: Mapping[str, int], state: ContainerRunningState) -> CheckResult: start_time_timestamp = state.start_time time_delta = time() - start_time_timestamp summary = f"Status: Running for {render.timespan(time_delta)}" yield Result(state=State.OK, summary=summary)
def test_subset_patterns(): section_ps = ps_section.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""")) # Boundary in match is necessary otherwise main instance accumulates all inv_params: List[Dict] = [{ 'default_params': { 'cpu_rescale_max': True, 'levels': (1, 1, 99999, 99999) }, 'match': '~(main.*)\\b', 'descr': '%s', }, {}] discovered = [ Service( item='main', parameters={ 'cpu_rescale_max': True, 'levels': (1, 1, 99999, 99999), 'process': '~(main.*)\\b', 'match_groups': ('main',), 'user': None, 'cgroup': (None, False), }, ), Service( item='main_dev', parameters={ 'cpu_rescale_max': True, 'levels': (1, 1, 99999, 99999), 'process': '~(main.*)\\b', 'match_groups': ('main_dev',), 'user': None, 'cgroup': (None, False), }, ), Service( item='main_test', parameters={ 'cpu_rescale_max': True, 'levels': (1, 1, 99999, 99999), 'process': '~(main.*)\\b', 'match_groups': ('main_test',), 'user': None, 'cgroup': (None, False), }, ), ] test_discovered = ps_utils.discover_ps(inv_params, section_ps, None, None) # type: ignore[arg-type] assert {s.item: s for s in test_discovered} == {s.item: s for s in discovered} # type: ignore[attr-defined] for service, count in zip(discovered, [1, 2, 1]): assert isinstance(service.item, str) with value_store.context(CheckPluginName("ps"), "unit-test"): output = list(ps_utils.check_ps_common( label="Processes", item=service.item, params=service.parameters, # type: ignore[arg-type] process_lines=[ (None, psi, cmd_line) for (psi, cmd_line) in section_ps[1]], cpu_cores=1, total_ram=None, )) assert output[0] == Result(state=state.OK, summary="Processes: %s" % count)
) def test_discovery_wlan_controller(section: Dict[str, WlanController], expected_result: List[Service]): services = discovery_wlan_controller(section) assert list(services) == expected_result @pytest.mark.parametrize( "item, section, expected_result", [ ( "wism21", WLAN_CONTROLLERS_SECTION, [ Result(state=State.OK, notice="Name: wism21"), Result(state=State.OK, summary="Type: Cisco WiSM2 Controller"), Result(state=State.OK, summary="Software version: 8.0.152.12"), Result(state=State.OK, notice="IP address: 10.5.1.11"), Result(state=State.OK, summary="Location: secgate 1:1"), Result(state=State.OK, summary="Group name: mobile-01"), Result(state=State.OK, summary="Mobility group name: mobile-01"), ], ), ("wism23", WLAN_CONTROLLERS_SECTION, []), ], ) def test_check_wlan_controller_metadata(item: str, section: Dict[str, WlanController], expected_result: List[CheckResult]):