def test_basic_host_ruleset_get_merged_dict_values(monkeypatch):
ts = Scenario().add_host("abc")
ts.add_host("abc")
ts.add_host("xyz")
ts.add_host("host1")
ts.add_host("host2")
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert matcher.get_host_ruleset_merged_dict(RulesetMatchObject(
host_name="abc", service_description=None),
ruleset=dict_ruleset) == {}
assert matcher.get_host_ruleset_merged_dict(RulesetMatchObject(
host_name="xyz", service_description=None),
ruleset=dict_ruleset) == {}
assert matcher.get_host_ruleset_merged_dict(RulesetMatchObject(
host_name="host1", service_description=None),
ruleset=dict_ruleset) == {
"hu": "BLA",
"ho": "BLA",
"he": "BLUB",
}
assert matcher.get_host_ruleset_merged_dict(RulesetMatchObject(
host_name="host2", service_description=None),
ruleset=dict_ruleset) == {
"hu": "BLUB",
"ho": "BLA",
"he": "BLUB",
}
def test_basic_get_host_ruleset_values(monkeypatch):
ts = Scenario().add_host("abc")
ts.add_host("xyz")
ts.add_host("host1")
ts.add_host("host2")
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert list(
matcher.get_host_ruleset_values(RulesetMatchObject(
host_name="abc", service_description=None),
ruleset=ruleset,
is_binary=False)) == []
assert list(
matcher.get_host_ruleset_values(RulesetMatchObject(
host_name="xyz", service_description=None),
ruleset=ruleset,
is_binary=False)) == []
assert list(
matcher.get_host_ruleset_values(RulesetMatchObject(
host_name="host1", service_description=None),
ruleset=ruleset,
is_binary=False)) == ["BLA", "BLUB"]
assert list(
matcher.get_host_ruleset_values(RulesetMatchObject(
host_name="host2", service_description=None),
ruleset=ruleset,
is_binary=False)) == ["BLUB"]
def test_basic_get_host_ruleset_values_subfolders(monkeypatch):
ts = Scenario().add_host("abc")
ts.add_host("xyz")
ts.add_host("lvl1", host_path="/lvl1/hosts.mk")
ts.add_host("lvl2", host_path="/lvl1/lvl2/hosts.mk")
ts.add_host("lvl1a", host_path="/lvl1_a/hosts.mk")
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert list(
matcher.get_host_ruleset_values(RulesetMatchObject(
host_name="xyz", service_description=None),
ruleset=ruleset,
is_binary=False)) == []
assert list(
matcher.get_host_ruleset_values(RulesetMatchObject(
host_name="lvl1", service_description=None),
ruleset=ruleset,
is_binary=False)) == ["LEVEL1"]
assert list(
matcher.get_host_ruleset_values(
RulesetMatchObject(host_name="lvl2", service_description=None),
ruleset=ruleset,
is_binary=False)) == ["LEVEL1", "LEVEL2"]
assert list(
matcher.get_host_ruleset_values(RulesetMatchObject(
host_name="lvl1a", service_description=None),
ruleset=ruleset,
is_binary=False)) == []
def test_basic_host_ruleset_is_matching_host_ruleset(
monkeypatch: MonkeyPatch) -> None:
ts = Scenario()
ts.add_host(HostName("abc"))
ts.add_host(HostName("abc"))
ts.add_host(HostName("xyz"))
ts.add_host(HostName("host1"))
ts.add_host(HostName("host2"))
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert (matcher.is_matching_host_ruleset(
RulesetMatchObject(host_name=HostName("abc"),
service_description=None),
ruleset=binary_ruleset,
) is False)
assert (matcher.is_matching_host_ruleset(
RulesetMatchObject(host_name=HostName("xyz"),
service_description=None),
ruleset=binary_ruleset,
) is False)
assert (matcher.is_matching_host_ruleset(
RulesetMatchObject(host_name=HostName("host1"),
service_description=None),
ruleset=binary_ruleset,
) is True)
assert (matcher.is_matching_host_ruleset(
RulesetMatchObject(host_name=HostName("host2"),
service_description=None),
ruleset=binary_ruleset,
) is False)
def test_ruleset_match_object_service_cache_id():
obj1 = RulesetMatchObject(host_name="host",
service_description="svc",
service_labels={u"a": u"v1"})
obj2 = RulesetMatchObject(host_name="host",
service_description="svc",
service_labels={u"a": u"v2"})
assert obj1.service_cache_id != obj2.service_cache_id
def test_ruleset_match_object_service_cache_id() -> None:
obj1 = RulesetMatchObject(
host_name=HostName("host"),
service_description="svc",
service_labels={"a": "v1"},
)
obj2 = RulesetMatchObject(
host_name=HostName("host"),
service_description="svc",
service_labels={"a": "v2"},
)
assert obj1.service_cache_id != obj2.service_cache_id
def test_basic_get_host_ruleset_values(monkeypatch: MonkeyPatch) -> None:
ts = Scenario()
ts.add_host(HostName("abc"))
ts.add_host(HostName("xyz"))
ts.add_host(HostName("host1"))
ts.add_host(HostName("host2"))
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert (
list(
matcher.get_host_ruleset_values(
RulesetMatchObject(host_name=HostName("abc"), service_description=None),
ruleset=ruleset,
is_binary=False,
)
)
== []
)
assert (
list(
matcher.get_host_ruleset_values(
RulesetMatchObject(host_name=HostName("xyz"), service_description=None),
ruleset=ruleset,
is_binary=False,
)
)
== []
)
assert (
list(
matcher.get_host_ruleset_values(
RulesetMatchObject(host_name=HostName("host1"), service_description=None),
ruleset=ruleset,
is_binary=False,
)
)
== ["BLA", "BLUB"]
)
assert (
list(
matcher.get_host_ruleset_values(
RulesetMatchObject(host_name=HostName("host2"), service_description=None),
ruleset=ruleset,
is_binary=False,
)
)
== ["BLUB"]
)
def _ruleset_labels_of_service(self, ruleset_matcher, hostname,
service_desc):
# type: (RulesetMatcher, str, Text) -> Dict
match_object = RulesetMatchObject(hostname,
service_description=service_desc)
return ruleset_matcher.get_service_ruleset_merged_dict(
match_object, self._service_label_rules)
def test_ruleset_matcher_get_host_ruleset_values_tags(monkeypatch, hostname,
expected_result):
ts = Scenario()
ts.add_host("host1",
tags={
"criticality": "prod",
"agent": "cmk-agent",
"networking": "lan",
})
ts.add_host("host2", tags={
"criticality": "test",
"networking": "wan",
})
ts.add_host("host3", tags={
"criticality": "test",
"networking": "dmz",
})
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert list(
matcher.get_host_ruleset_values(RulesetMatchObject(
host_name=hostname, service_description=None),
ruleset=tag_ruleset,
is_binary=False)) == expected_result
def _ruleset_labels_of_service(self, ruleset_matcher: RulesetMatcher,
hostname: HostName,
service_desc: ServiceName) -> Labels:
match_object = RulesetMatchObject(hostname,
service_description=service_desc)
return ruleset_matcher.get_service_ruleset_merged_dict(
match_object, self._service_label_rules)
def test_ruleset_matcher_get_host_ruleset_values_tags_duplicate_ids(
monkeypatch: MonkeyPatch,
rule_spec: RuleConditionsSpec,
expected_result: Sequence[RuleValue],
) -> None:
ts = Scenario()
add_tag_config = TagConfig.from_config(
{
"aux_tags": [],
"tag_groups": [
{
"id": "grp1",
"tags": [
{
"aux_tags": [],
"id": "v1",
"title": "Value1",
},
],
"title": "Group 1",
},
{
"id": "grp2",
"tags": [
{
"aux_tags": [],
"id": "v1",
"title": "Value1",
},
],
"title": "Group 2",
},
],
}
)
ts.tags += add_tag_config
ts.add_host(
"host",
tags={
"grp1": "v1",
},
)
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert (
list(
matcher.get_host_ruleset_values(
RulesetMatchObject(
host_name=HostName("host"),
service_description=None,
),
ruleset=[rule_spec],
is_binary=False,
)
)
== expected_result
)
def test_basic_host_ruleset_is_matching_host_ruleset(monkeypatch):
ts = Scenario().add_host("abc")
ts.add_host("abc")
ts.add_host("xyz")
ts.add_host("host1")
ts.add_host("host2")
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert matcher.is_matching_host_ruleset(RulesetMatchObject(
host_name="abc", service_description=None),
ruleset=binary_ruleset) is False
assert matcher.is_matching_host_ruleset(RulesetMatchObject(
host_name="xyz", service_description=None),
ruleset=binary_ruleset) is False
assert matcher.is_matching_host_ruleset(RulesetMatchObject(
host_name="host1", service_description=None),
ruleset=binary_ruleset) is True
assert matcher.is_matching_host_ruleset(RulesetMatchObject(
host_name="host2", service_description=None),
ruleset=binary_ruleset) is False
def test_ruleset_matcher_get_host_ruleset_values_labels(monkeypatch, hostname, expected_result):
ts = Scenario()
ts.add_host("host1", labels={"os": "linux", "abc": "xä", "hu": "ha"})
ts.add_host("host2")
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert list(
matcher.get_host_ruleset_values(RulesetMatchObject(host_name=hostname,
service_description=None),
ruleset=host_label_ruleset,
is_binary=False)) == expected_result
def test_ruleset_matcher_get_host_ruleset_values_tags_duplicate_ids(
monkeypatch: MonkeyPatch,
rule_spec: RuleSpec,
expected_result: Sequence[RuleValue],
) -> None:
ts = Scenario()
add_tag_config = TagConfig()
add_tag_config.parse_config({
'aux_tags': [],
'tag_groups': [
{
'id': 'grp1',
'tags': [
{
'aux_tags': [],
'id': 'v1',
'title': 'Value1',
},
],
'title': 'Group 1'
},
{
'id': 'grp2',
'tags': [
{
'aux_tags': [],
'id': 'v1',
'title': 'Value1',
},
],
'title': 'Group 2'
},
],
})
ts.tags += add_tag_config
ts.add_host(
"host",
tags={
"grp1": "v1",
},
)
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert list(
matcher.get_host_ruleset_values(
RulesetMatchObject(
host_name="host",
service_description=None,
),
ruleset=[rule_spec],
is_binary=False,
)) == expected_result
def test_basic_host_ruleset_get_merged_dict_values(monkeypatch: MonkeyPatch) -> None:
ts = Scenario()
ts.add_host(HostName("abc"))
ts.add_host(HostName("abc"))
ts.add_host(HostName("xyz"))
ts.add_host(HostName("host1"))
ts.add_host(HostName("host2"))
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert (
matcher.get_host_ruleset_merged_dict(
RulesetMatchObject(host_name=HostName("abc"), service_description=None),
ruleset=dict_ruleset,
)
== {}
)
assert (
matcher.get_host_ruleset_merged_dict(
RulesetMatchObject(host_name=HostName("xyz"), service_description=None),
ruleset=dict_ruleset,
)
== {}
)
assert matcher.get_host_ruleset_merged_dict(
RulesetMatchObject(host_name=HostName("host1"), service_description=None),
ruleset=dict_ruleset,
) == {
"hu": "BLA",
"ho": "BLA",
"he": "BLUB",
}
assert matcher.get_host_ruleset_merged_dict(
RulesetMatchObject(host_name=HostName("host2"), service_description=None),
ruleset=dict_ruleset,
) == {
"hu": "BLUB",
"ho": "BLA",
"he": "BLUB",
}
def test_ruleset_matcher_get_host_ruleset_values_labels(
monkeypatch: MonkeyPatch, hostname_str: str, expected_result: Sequence[str]
) -> None:
ts = Scenario()
ts.add_host(HostName("host1"), labels={"os": "linux", "abc": "xä", "hu": "ha"})
ts.add_host(HostName("host2"))
config_cache = ts.apply(monkeypatch)
matcher = config_cache.ruleset_matcher
assert (
list(
matcher.get_host_ruleset_values(
RulesetMatchObject(host_name=HostName(hostname_str), service_description=None),
ruleset=host_label_ruleset,
is_binary=False,
)
)
== expected_result
)
def test_ruleset_match_object_service_cache_id_no_labels() -> None:
obj = RulesetMatchObject(host_name=HostName("host"),
service_description="svc")
assert obj.service_cache_id == ("svc", hash(None))
def test_ruleset_match_object_set_invalid_attribute():
x = RulesetMatchObject(host_name=None, service_description=None)
with pytest.raises(AttributeError, match="object has no attribute"):
x.xyz = 123 # pylint: disable=assigning-non-slot
def test_ruleset_match_object_invalid_attribute_in_init():
with pytest.raises(TypeError, match="unexpected keyword"):
RulesetMatchObject(x=1) # pylint: disable=unexpected-keyword-arg
def test_ruleset_match_object_service_description():
obj = RulesetMatchObject(host_name=None, service_description=u"Ümlaut")
assert obj.service_description == u"Ümlaut"
def _ruleset_labels_of_host(self, ruleset_matcher, hostname):
# type: (RulesetMatcher, str) -> Dict
match_object = RulesetMatchObject(hostname, service_description=None)
return ruleset_matcher.get_host_ruleset_merged_dict(match_object, self._host_label_rules)
def test_ruleset_match_object_host_name():
obj = RulesetMatchObject(host_name="abc", service_description=None)
assert obj.host_name == "abc"
def test_ruleset_match_object_no_conditions():
x = RulesetMatchObject(host_name=None, service_description=None)
assert x.host_name is None
assert x.service_description is None