File size: 5,853 Bytes
f3b0a91 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 | """Grader static layer: YAML safety, CRD extraction, tamper rules, label/annotation checks, preservation."""
import pytest
from alertforge.grader import loader, static
from alertforge.grader.amcheck import inhibited, jaccard, parse_matchers, Unsupported
def refs(doc_text: str):
return loader.index_rules([loader.parse_rule_file("rules/x.yml", doc_text)])
def test_alias_bomb_is_rejected():
bomb = "a: &a [x, x]\n" + "".join(f"{c}: &{c} [*{p}, *{p}]\n" for p, c in zip("abcdefghijklmnopqrstuvwxyz", "bcdefghijklmnopqrstuvwxyz"))
with pytest.raises(loader.YamlError):
loader.safe_yaml(bomb)
def test_prometheusrule_manifest_is_unwrapped():
text = ("apiVersion: monitoring.coreos.com/v1\nkind: PrometheusRule\nmetadata: {name: x}\n"
"spec:\n groups:\n - name: g\n rules:\n - alert: A\n expr: up == 0\n")
f = loader.parse_rule_file("rules/x.yml", text)
assert f.groups and f.groups[0]["rules"][0]["alert"] == "A"
def test_unparsable_file_is_reported_not_raised():
f = loader.parse_rule_file("rules/x.yml", "groups:\n- name: g\n rules:\n - alert: A\n expr: up == 0\n")
assert f.groups is None and f.error
@pytest.mark.parametrize("rule,needle", [
("- record: ALERTS\n expr: vector(1)", "reserved"),
("- record: http_requests_total\n expr: vector(1)", "input series"),
("- record: x:y\n expr: vector(1)\n labels: {alertname: Foo}", "reserved label"),
('- record: x:y\n expr: label_replace(vector(1), "alertname", "Foo", "", "")', "label_replace"),
])
def test_series_injection_is_tamper(rule, needle):
_, _, every = refs(f"groups:\n- name: g\n rules:\n {rule}\n")
reasons = static.rule_tamper(every, {"http_requests_total"})
assert any(needle in r for r in reasons), reasons
def test_group_interval_offset_limit_are_tamper():
_, _, every = refs("groups:\n- name: g\n interval: 30s\n limit: 5\n rules:\n - alert: A\n expr: up == 0\n")
reasons = static.rule_tamper(every, set())
assert any("interval" in r for r in reasons) and any("limit" in r for r in reasons)
def test_default_interval_is_not_tamper():
_, _, every = refs("groups:\n- name: g\n interval: 1m\n rules:\n - alert: A\n expr: up == 0\n")
assert static.rule_tamper(every, set()) == []
def test_mute_time_intervals_are_tamper():
am = {"route": {"receiver": "x", "routes": [{"receiver": "y", "mute_time_intervals": ["nights"]}]},
"time_intervals": [{"name": "nights"}]}
assert len(static.am_tamper(am)) == 2
def test_labels_must_match_exactly():
req = {"severity": "page", "team": "t"}
assert static.labels_ok({"labels": {"severity": "page", "team": "t"}}, req)
assert not static.labels_ok({"labels": {"severity": "page", "team": "t", "extra": "1"}}, req)
assert not static.labels_ok({"labels": {"severity": "warning", "team": "t"}}, req)
def test_summary_and_template_labels():
rule = {"annotations": {"summary": "{{ $labels.service }} on {{ $labels.instance }}",
"description": '{{ index $labels "pod" }} {{ .Labels.namespace }}'}}
assert static.summary_ok(rule)
assert static.template_labels(rule) == {"service", "instance", "pod", "namespace"}
assert not static.summary_ok({"annotations": {"summary": "errors are high"}})
def test_canon_ignores_formatting_but_not_group_knobs():
a = {"alert": "A", "expr": "up ==\n 0", "for": "5m", "labels": {"severity": "page"}}
b = {"alert": "A", "expr": "up == 0", "for": "300s", "labels": {"severity": "page"}}
assert loader.canon(a, {"name": "g"}) == loader.canon(b, {"name": "other", "interval": "1m"})
assert loader.canon(a, {"name": "g"}) != loader.canon(a, {"name": "g", "query_offset": "1m"})
def test_preservation_duplicate_untouched_name_is_not_preserved():
alerts, _, every = refs("groups:\n- name: g\n rules:\n - alert: A\n expr: up == 0\n - alert: A\n expr: up == 0\n")
h = loader.canon(every[0].rule, every[0].group)
p, items = static.preservation(every, alerts, {"rules": [{"kind": "alert", "name": "A", "hash": h}]}, None, [], [])
assert p == 0.0
# ---------------------------------------------------------------------------- inhibition simulator
RULE = {"source_matchers": ['alertname="SvcDown"'], "target_matchers": ['alertname=~"Burn|Err"'], "equal": ["service"]}
def alert(name, svc):
return {"alertname": name, "service": svc}
def test_inhibit_equal_service():
am = {"inhibit_rules": [RULE]}
assert inhibited(am, alert("SvcDown", "a"), alert("Burn", "a")) is True
assert inhibited(am, alert("SvcDown", "a"), alert("Burn", "b")) is False
assert inhibited(am, alert("Burn", "a"), alert("SvcDown", "a")) is False
assert inhibited(am, None, alert("Burn", "a")) is False
def test_inhibit_without_equal_overinhibits():
am = {"inhibit_rules": [{k: v for k, v in RULE.items() if k != "equal"}]}
assert inhibited(am, alert("SvcDown", "a"), alert("Burn", "b")) is True
def test_inhibit_legacy_match_and_regex_anchoring():
am = {"inhibit_rules": [{"source_match": {"alertname": "SvcDown"}, "target_match_re": {"alertname": "Bur"}}]}
assert inhibited(am, alert("SvcDown", "a"), alert("Burn", "a")) is False # regex is fully anchored
def test_inhibit_unsupported_constructs_fail_closed():
assert inhibited({"inhibit_rules": [{**RULE, "foo": 1}]}, alert("SvcDown", "a"), alert("Burn", "a")) is None
assert inhibited({"inhibit_rules": [{"source_matchers": ['{alertname="x"}'], "target_matchers": []}]},
alert("x", "a"), alert("y", "a")) is None
with pytest.raises(Unsupported):
parse_matchers({"source_matchers": ['alertname=~"("']}, "source")
def test_jaccard():
assert jaccard({"a", "b"}, {"a"}) == 0.5
assert jaccard(set(), set()) == 1.0
|