def _test_check_winperf_phydisk(item, section_1, section_2, check_func):
# fist call: initialize value store
with pytest.raises(IgnoreResultsError):
list(check_func(
item,
type_defs.Parameters({}),
section_1,
))
# second call: get values
check_results = list(
check_func(
item,
type_defs.Parameters({}),
section_2,
))
exp_metrics = set(
'disk_' + k for k in DISK
if not k.endswith('_base') and k not in ('timestamp', 'frequency'))
for res in check_results:
if isinstance(res, Metric):
exp_metrics.remove(res.name)
assert res.value > 0
assert not exp_metrics
def test_cluster_check_diskstat_summary(value_store):
with pytest.raises(IgnoreResultsError):
list(
diskstat.cluster_check_diskstat(
'SUMMARY',
type_defs.Parameters({}),
{
'node1': {
'disk1': DISK_HALF,
},
'node2': {
'disk2': DISK_HALF,
},
},
{
'node1': None,
'node2': None,
},
))
results_cluster = list(
diskstat.cluster_check_diskstat(
'SUMMARY',
type_defs.Parameters({}),
{
'node1': {
'disk1': DISK,
},
'node2': {
'disk2': DISK,
},
},
{
'node1': None,
'node2': None,
},
))
with pytest.raises(IgnoreResultsError):
list(
diskstat.check_diskstat(
'SUMMARY',
type_defs.Parameters({}),
{
'disk1': DISK_HALF,
'disk2': DISK_HALF,
},
None,
))
results_non_cluster = list(
diskstat.check_diskstat(
'SUMMARY',
type_defs.Parameters({}),
{
'disk1': DISK,
'disk2': DISK,
},
None,
))
assert results_cluster == results_non_cluster
def test_cluster_check_diskstat_single_item(value_store):
with pytest.raises(IgnoreResultsError):
list(
diskstat.cluster_check_diskstat(
'disk1',
type_defs.Parameters({}),
{
'node1': {
'disk1': DISK_HALF,
},
},
{
'node1': None,
},
))
results_cluster = list(
diskstat.cluster_check_diskstat(
'disk1',
type_defs.Parameters({}),
{
'node_overwritten': {
'disk1': DISK_HALF,
},
'node1': {
'disk1': DISK,
},
},
{
'node_overwritten': None,
'node1': None,
},
))
with pytest.raises(IgnoreResultsError):
list(
diskstat.check_diskstat(
'disk1',
type_defs.Parameters({}),
{
'disk1': DISK_HALF,
},
None,
))
results_non_cluster = list(
diskstat.check_diskstat(
'disk1',
type_defs.Parameters({}),
{
'disk1': DISK,
},
None,
))
assert results_cluster == results_non_cluster
def test_discovery_grouped_hierarchy():
assert list(
interfaces.discover_interfaces(
[
type_defs.Parameters({
'matching_conditions': (
False,
{
'portstates': ['1', '2'],
},
),
"grouping": (
True,
[{
'group_name': 'group',
'member_appearance': 'alias',
}],
),
}),
type_defs.Parameters({
'matching_conditions': (True, {}),
"grouping": (
True,
[{
'group_name': 'group',
'member_appearance': 'index',
}],
),
}),
DEFAULT_DISCOVERY_PARAMS,
],
_create_interfaces(0),
)) == SINGLE_SERVICES + [
Service(
item='group',
parameters={
'aggregate': {
'member_appearance': 'alias',
'inclusion_condition': {
'portstates': ['1', '2']
},
'exclusion_conditions': [],
},
'discovered_state': ['1'],
'discovered_speed': 20000000,
},
labels=[],
),
]
def test_cluster_check_bluecat_none_ok():
assert list(
bluecat_dns.cluster_check_bluecat_dns(
type_defs.Parameters({
"oper_states": {
"warning": [1],
"critical": [2, 3],
},
},),
{
'node1': {
'oper_state': 1,
},
'node2': {
'oper_state': 3,
},
},
)) == [
Result(
state=state.WARN,
details='[node1]: DNS is running normally(!)',
),
Result(
state=state.CRIT,
details='[node2]: DNS is currently starting(!!)',
),
Result(
state=state.CRIT,
summary='No node with OK DNS state',
),
]
def test_cluster_check_pulse_secure_users():
assert list(
pulse_secure_users.cluster_check_pulse_secure_users(
type_defs.Parameters({}),
{
'node1': {
'n_users': 20
},
'node2': {
'n_users': 30
}
},
)) == [
Result(
state=state.OK,
details='[node1]: Pulse Secure users: 20',
),
Result(
state=state.OK,
details='[node2]: Pulse Secure users: 30',
),
Result(
state=state.OK,
summary='Pulse Secure users across cluster: 50',
details='Pulse Secure users across cluster: 50',
),
Metric(
'current_users',
50.0,
levels=(None, None),
boundaries=(None, None),
),
]
def test_discovery_grouped_by_agent_and_in_rules():
ifaces = _create_interfaces(0)
ifaces[0].group = 'group'
ifaces[1].group = 'group'
assert list(
interfaces.discover_interfaces(
[
type_defs.Parameters({
'matching_conditions': (True, {}),
"grouping": (
True,
[{
'group_name': 'group',
'member_appearance': 'index',
}],
),
}),
DEFAULT_DISCOVERY_PARAMS,
],
ifaces,
)) == SINGLE_SERVICES + [
Service(
item='group',
parameters={
'aggregate': {
'member_appearance': 'index',
'inclusion_condition': {},
'exclusion_conditions': [],
},
'discovered_state': ['1'],
'discovered_speed': 20000000.0,
},
labels=[],
),
]
def test_cluster_check_bluecat_one_ok():
assert list(
bluecat_dns.cluster_check_bluecat_dns(
type_defs.Parameters({
"oper_states": {
"warning": [4],
"critical": [],
},
},),
{
'node1': {
'oper_state': 1,
},
'node2': {
'oper_state': 4,
},
},
)) == [
Result(
state=state.OK,
details='[node1]: DNS is running normally',
),
Result(
state=state.OK,
details='[node2]: DNS is currently stopping(!)',
),
Result(
state=state.OK,
summary='DNS is running normally on node1',
),
]
def check_bluecat_dhcp_one_lease():
assert list(
bluecat_dhcp.check_bluecat_dhcp(
type_defs.Parameters(
{
"oper_states": {
"warning": [],
"critical": [],
},
}, ),
{
'oper_state': 1,
'leases': 1,
},
)) == [
Result(
state=state.OK,
summary="DHCP is running normally",
),
Result(
state=state.OK,
summary="1 lease per second",
),
Metric(
'leases',
1,
),
]
def check_bluecat_dhcp_crit():
assert list(
bluecat_dhcp.check_bluecat_dhcp(
type_defs.Parameters(
{
"oper_states": {
"warning": [],
"critical": [5],
},
}, ),
{
'oper_state': 5,
'leases': 10,
},
)) == [
Result(
state=state.CRIT,
summary="DHCP is fault",
),
Result(
state=state.OK,
summary="1 lease per second",
),
Metric(
'leases',
1,
),
]
def _test_check_aix_diskiod(item, section_1, section_2, check_func):
# fist call: initialize value store
list(check_func(
item,
type_defs.Parameters({}),
section_1,
))
# second call: get values
check_results = list(
check_func(
item,
type_defs.Parameters({}),
section_2,
))
for res in check_results:
if isinstance(res, Metric):
assert res.value > 0
def test_check_disk(value_store):
with pytest.raises(IgnoreResultsError):
list(aix_diskiod._check_disk(type_defs.Parameters({}), DISK))
assert list(aix_diskiod._check_disk(type_defs.Parameters({}), DISK)) == [
Result(state=state.OK,
summary='Read throughput: 0.00 B/s',
details='Read throughput: 0.00 B/s'),
Metric('disk_read_throughput',
0.0,
levels=(None, None),
boundaries=(None, None)),
Result(state=state.OK,
summary='Write throughput: 0.00 B/s',
details='Write throughput: 0.00 B/s'),
Metric('disk_write_throughput',
0.0,
levels=(None, None),
boundaries=(None, None)),
]
def test_discovery_ungrouped_off():
assert list(
interfaces.discover_interfaces(
[
type_defs.Parameters({
'matching_conditions': (True, {}),
'discovery_single': (False, {}),
}),
DEFAULT_DISCOVERY_PARAMS,
],
_create_interfaces(0),
)) == []
def test_discovery_legacy_parameters():
assert list(
interfaces.discover_interfaces(
[
type_defs.Parameters(
{
'pad_portnumbers': False,
'item_appearance': 'alias',
'match_desc': ['enxe4b97ab99f99', 'vboxnet0', 'lo'],
'portstates': ['1', '2', '3'],
'porttypes': ['6'],
'match_alias': ['enxe4b97ab99f99', 'vboxnet0', 'lo'],
}),
type_defs.Parameters({
'matching_conditions': (True, {}),
'discovery_single': (False, {}),
}),
DEFAULT_DISCOVERY_PARAMS,
],
_create_interfaces(0),
)) == [
Service(
item='enxe4b97ab99f99',
parameters={
'discovered_state': ['2'],
'discovered_speed': 10000000,
},
labels=[],
),
Service(
item='vboxnet0',
parameters={
'discovered_state': ['1'],
'discovered_speed': 10000000,
},
labels=[],
),
]
def test__check_disk():
with value_store.context(CheckPluginName('_check_disk'), 'item'):
check_disk_1 = list(
aix_diskiod._check_disk(type_defs.Parameters({}), DISK))
assert len(check_disk_1)
assert isinstance(check_disk_1[0], IgnoreResults)
assert list(aix_diskiod._check_disk(type_defs.Parameters(
{}), DISK)) == [
Result(state=state.OK,
summary='Read: 0.00 B/s',
details='Read: 0.00 B/s'),
Metric('disk_read_throughput',
0.0,
levels=(None, None),
boundaries=(None, None)),
Result(state=state.OK,
summary='Write: 0.00 B/s',
details='Write: 0.00 B/s'),
Metric('disk_write_throughput',
0.0,
levels=(None, None),
boundaries=(None, None)),
]
def test_lnx_if_regression(
monkeypatch,
string_table,
discovery_results,
items_params_results,
):
section = lnx_if.parse_lnx_if(string_table)
assert list(
lnx_if.discover_lnx_if(
[type_defs.Parameters(interfaces.DISCOVERY_DEFAULT_PARAMETERS)],
section,
)) == discovery_results
monkeypatch.setattr(interfaces, 'get_value_store', lambda: {})
for item, par, res in items_params_results:
assert list(
lnx_if.check_lnx_if(
item,
type_defs.Parameters(par),
section,
)) == res
node_name = 'node'
for item, par, res in items_params_results:
assert list(
lnx_if.cluster_check_lnx_if(
item,
type_defs.Parameters(par),
{node_name: section},
)) == [
Result(
state=res[0].state,
summary=res[0].summary.replace(' ', ' on %s: ' % node_name,
1),
)
] + res[1:]
def test_check_diskstat_dict(params, disk, exp_res):
with value_store.context('plugin', 'item'): # type: ignore
# we use {**disk} here because check_diskstat_dict pops items
assert list(diskstat.check_diskstat_dict(params, {**disk}, get_value_store())) == exp_res
if exp_res:
exp_res[0] = Result(
state=exp_res[0].state,
summary="5 minutes 0 seconds average: " + exp_res[0].summary,
)
assert list(
diskstat.check_diskstat_dict(type_defs.Parameters({
**params, 'average': 300
},), disk, get_value_store()),) == exp_res
def test_discovery_ungrouped_one():
assert list(
interfaces.discover_interfaces(
[
type_defs.Parameters({
'matching_conditions': (
False,
{
'match_index': ['5'],
},
),
'discovery_single': (False, {}),
}),
DEFAULT_DISCOVERY_PARAMS,
],
_create_interfaces(0),
)) == SINGLE_SERVICES[1:]
def test_check_diskstat_dict(params, disk, exp_res):
value_store: type_defs.ValueStore = {}
assert list(diskstat.check_diskstat_dict(params, disk,
value_store)) == exp_res
if exp_res:
exp_res[0] = Result(
state=exp_res[0].state,
summary="5 minutes 0 seconds average: " + exp_res[0].summary,
)
assert list(
diskstat.check_diskstat_dict(
type_defs.Parameters({
**params, 'average': 300
}, ), disk, value_store), ) == exp_res
def test_cluster_check_bluecat_one_ok():
assert list(
bluecat_dhcp.cluster_check_bluecat_dhcp(
type_defs.Parameters(
{
"oper_states": {
"warning": [4],
"critical": [],
},
}, ),
{
'node1': {
'oper_state': 1,
'leases': 13,
},
'node2': {
'oper_state': 4,
'leases': 11,
},
},
)
) == [
Result(
state=state.OK,
details=
'[node1]: DHCP is running normally\n[node1]: 13 leases per second',
),
Result(
state=state.OK,
details=
'[node2]: DHCP is currently stopping(!)\n[node2]: 11 leases per second',
),
Result(
state=state.OK,
summary='DHCP is running normally on node1',
),
Result(
state=state.OK,
summary='13 leases per second on node1',
),
Metric(
'leases',
13,
),
]
def test_check_pulse_secure_users():
assert list(
pulse_secure_users.check_pulse_secure_users(
type_defs.Parameters({}),
{'n_users': 172},
)) == [
Result(
state=state.OK,
summary='Pulse Secure users: 172',
details='Pulse Secure users: 172',
),
Metric(
'current_users',
172.0,
levels=(None, None),
boundaries=(None, None),
),
]
def check_bluecat_dns_ok():
assert list(
bluecat_dns.check_bluecat_dns(
type_defs.Parameters({
"oper_states": {
"warning": [],
"critical": [],
},
},),
{
'oper_state': 1,
},
)) == [
Result(
state=state.OK,
summary="DNS is running normally",
),
]
def check_bluecat_dns_crit():
assert list(
bluecat_dns.check_bluecat_dns(
type_defs.Parameters({
"oper_states": {
"warning": [],
"critical": [5],
},
},),
{
'oper_state': 5,
},
)) == [
Result(
state=state.CRIT,
summary="DNS is fault",
),
]
def test_check_single_interface_averaging(value_store, item, params, result):
with pytest.raises(IgnoreResultsError):
list(
interfaces.check_single_interface(
item,
params,
_create_interfaces(0)[int(item) - 1],
timestamp=0,
))
assert list(
interfaces.check_single_interface(
item,
type_defs.Parameters({
**params,
'average': 5,
}),
_create_interfaces(4000000)[int(item) - 1],
timestamp=5,
)) == result
def test_discovery_grouped_empty():
assert list(
interfaces.discover_interfaces(
[
type_defs.Parameters({
'matching_conditions': (
False,
{
'match_desc': ['non_existing'],
},
),
"grouping": (
True,
[{
'group_name': 'group',
'member_appearance': 'index',
}],
),
}),
DEFAULT_DISCOVERY_PARAMS,
],
_create_interfaces(0),
)) == SINGLE_SERVICES
def test_cluster_check_bluecat_none_ok():
assert list(
bluecat_dhcp.cluster_check_bluecat_dhcp(
type_defs.Parameters(
{
"oper_states": {
"warning": [1],
"critical": [2, 3],
},
}, ),
{
'node1': {
'oper_state': 1,
'leases': 0,
},
'node2': {
'oper_state': 3,
'leases': 1,
},
},
)
) == [
Result(
state=state.WARN,
details=
'[node1]: DHCP is running normally(!)\n[node1]: 0 leases per second',
),
Result(
state=state.CRIT,
details=
'[node2]: DHCP is currently starting(!!)\n[node2]: 1 lease per second',
),
Result(
state=state.CRIT,
summary='No node with OK DHCP state',
),
]
),
])
def test_veritas_vcs_boil_down_states_in_cluster(states, exp_res):
assert veritas_vcs.veritas_vcs_boil_down_states_in_cluster(
states) == exp_res
PARAMS = type_defs.Parameters(
{
'map_frozen': {
'frozen': 2,
'tfrozen': 1
},
'map_states': {
'FAULTED': 2,
'RUNNING': 0,
'OK': 0,
'ONLINE': 0,
'default': 1,
'PARTIAL': 1,
'OFFLINE': 1,
'UNKNOWN': 3,
'EXITED': 1,
},
}, )
def test_check_veritas_vcs():
assert list(veritas_vcs.check_veritas_vcs('minions', PARAMS, SECTION)) == [
Result(
state=state.OK,
summary='running',
Metric,
Result,
Service,
state,
type_defs,
)
from cmk.base.plugins.agent_based.utils import diskstat
@pytest.mark.parametrize(
"params,exp_res",
[
(
[
type_defs.Parameters({
'summary': True,
},),
],
[
Service(item='SUMMARY'),
],
),
(
[
type_defs.Parameters({
'summary': True,
'physical': True,
},),
],
[
Service(item='SUMMARY'),
def test_check_multiple_interfaces_group_simple(value_store):
params = type_defs.Parameters({
'errors': (0.01, 0.1),
'traffic': [('both', ('upper', ('perc', (5.0, 20.0))))],
'aggregate': {
'member_appearance': 'index',
'inclusion_condition': {},
'exclusion_conditions': [],
},
'discovered_state': ['1'],
'discovered_speed':
20000000,
'state': ['8'],
'speed':
123456,
})
with pytest.raises(IgnoreResultsError):
list(
interfaces.check_multiple_interfaces(
'group',
params,
_create_interfaces(0),
timestamp=0,
))
assert list(
interfaces.check_multiple_interfaces(
'group',
params,
_create_interfaces(4000000),
timestamp=5,
)
) == [
Result(state=state.OK, summary='Group Status (degraded)'),
Result(
state=state.OK,
summary=
'Members: [1 (up), 2 (down), 3 (down), 4 (down), 5 (up), 6 (up)]'),
Result(state=state.WARN,
summary='10 MBit/s (wrong speed, expected: 123 kBit/s)'),
Metric('in',
800000.0,
levels=(62500.0, 250000.0),
boundaries=(0.0, 1250000.0)),
Metric('inmcast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('inbcast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('inucast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('innucast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('indisc', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('inerr', 0.0, levels=(0.01, 0.1), boundaries=(None, None)),
Metric('out',
3200000.0,
levels=(62500.0, 250000.0),
boundaries=(0.0, 1250000.0)),
Metric('outmcast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outbcast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outucast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outnucast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outdisc', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outerr', 0.0, levels=(0.01, 0.1), boundaries=(None, None)),
Metric('outqlen', 0.0, levels=(None, None), boundaries=(None, None)),
Result(
state=state.CRIT,
summary='In: 800 kB/s (warn/crit at 62.5 kB/s/250 kB/s) (64.0%)'),
Result(
state=state.CRIT,
summary='Out: 3.20 MB/s (warn/crit at 62.5 kB/s/250 kB/s) (256.0%)'
),
]
def test_check_multiple_interfaces_group_by_agent(value_store):
params = type_defs.Parameters({
'errors': (0.01, 0.1),
'traffic': [('both', ('upper', ('perc', (5.0, 20.0))))],
'aggregate': {
'member_appearance': 'index',
},
'discovered_state': ['1'],
'discovered_speed':
20000000
})
with pytest.raises(IgnoreResultsError):
ifaces = _create_interfaces(0)
ifaces[3].group = 'group'
ifaces[5].group = 'group'
list(
interfaces.check_multiple_interfaces(
'group',
params,
ifaces,
timestamp=0,
))
ifaces = _create_interfaces(4000000)
ifaces[3].group = 'group'
ifaces[5].group = 'group'
assert list(
interfaces.check_multiple_interfaces(
'group',
params,
ifaces,
timestamp=5,
)
) == [
Result(state=state.CRIT,
summary='Group Status (degraded)',
details='Group Status (degraded)'),
Result(state=state.OK,
summary='Members: [4 (down), 6 (up)]',
details='Members: [4 (down), 6 (up)]'),
Result(state=state.OK,
summary='assuming 20 MBit/s',
details='assuming 20 MBit/s'),
Metric('in',
800000.0,
levels=(
125000.0, 500000.0),
boundaries=(0.0, 2500000.0)),
Metric('inmcast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('inbcast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('inucast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('innucast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('indisc', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('inerr', 0.0, levels=(0.01, 0.1), boundaries=(None, None)),
Metric('out',
3200000.0,
levels=(
125000.0, 500000.0),
boundaries=(0.0, 2500000.0)),
Metric('outmcast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outbcast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outucast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outnucast', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outdisc', 0.0, levels=(None, None), boundaries=(None, None)),
Metric('outerr', 0.0, levels=(0.01, 0.1), boundaries=(None, None)),
Metric('outqlen', 0.0, levels=(None, None), boundaries=(None, None)),
Result(
state=state.CRIT,
summary='In: 800 kB/s (warn/crit at 125 kB/s/500 kB/s) (32.0%)',
details='In: 800 kB/s (warn/crit at 125 kB/s/500 kB/s) (32.0%)'),
Result(
state=state.CRIT,
summary='Out: 3.20 MB/s (warn/crit at 125 kB/s/500 kB/s) (128.0%)',
details='Out: 3.20 MB/s (warn/crit at 125 kB/s/500 kB/s) (128.0%)'
),
]
