| """End-to-end grading of built tasks with the real promtool/amtool (§12.1 behaviors).""" |
|
|
| import copy |
| import hashlib |
| import json |
| import os |
| import random |
| import subprocess |
| import sys |
|
|
| from alertforge import render, solutions |
| from alertforge.grader.grade import KEYS, Grader |
|
|
| from conftest import needs_tools |
|
|
|
|
| def grade(m, state, grader=None): |
| files, am, extra = state |
| return render.grade_state(m["world"], m["spec"], m["hidden_dir"], m["static"], files, am, grader, extra) |
|
|
|
|
| def req_of(m, kind): |
| return next(r for r in m["world"].reqs if r.kind == kind) |
|
|
|
|
| @needs_tools |
| def test_oracle_null_partial(easy_task): |
| ko, _ = grade(easy_task, solutions.oracle(easy_task["world"])) |
| kn, _ = grade(easy_task, solutions.null(easy_task["world"])) |
| kp, _ = grade(easy_task, solutions.partial(easy_task["world"])) |
| assert set(ko) == set(KEYS) |
| assert ko["reward"] == 1.0 and ko["solved"] == 1.0 and ko["preservation"] == 1.0 |
| assert kn["reward"] == 0.0 and kn["progress"] == 0.0 and kn["preservation"] == 1.0 |
| assert kp["outcome"] == 0.0 and 0.05 < kp["reward"] < 0.4 |
|
|
|
|
| @needs_tools |
| def test_hard_task_oracle_is_one(hard_task): |
| ko, det = grade(hard_task, solutions.oracle(hard_task["world"])) |
| assert ko["reward"] == 1.0, det["requirements"] |
|
|
|
|
| @needs_tools |
| def test_duplicate_definition_costs_twenty_percent_not_everything(easy_task): |
| """S4: a duplicate (fixed copy next to the broken one) keeps most of the credit.""" |
| w = easy_task["world"] |
| files, am, _ = solutions.oracle(w) |
| a = req_of(easy_task, "new_alert").alert |
| rule = copy.deepcopy(next(x for _, x in solutions._alert_rules(files, a.name))) |
| files["scratch"] = [{"name": "scratch", "rules": [rule]}] |
| k, det = grade(easy_task, (files, am, {})) |
| q = det["requirements"][a.req_id]["q"] |
| assert 0.75 <= q < 1.0 and k["outcome"] == 0.0 |
|
|
|
|
| @needs_tools |
| def test_missing_continue_gets_jaccard_credit(easy_task): |
| """S6: a route that reaches PagerDuty but not Slack earns partial credit, not zero.""" |
| w = easy_task["world"] |
| files, am, _ = solutions.oracle(w) |
| team = req_of(easy_task, "route").route["team"] |
| for rt in am["route"]["routes"]: |
| if rt.get("matchers") == [f'team="{team}"']: |
| rt["routes"][0].pop("continue") |
| _, det = grade(easy_task, (files, am, {})) |
| s = det["requirements"][req_of(easy_task, "route").id]["s"] |
| assert 0.2 < s < 1.0 |
|
|
|
|
| @needs_tools |
| def test_stray_files_are_ignored_and_yaml_error_costs_at_most_half(easy_task): |
| """S5: scratch files never zero the reward; one unparsable file keeps >= half of progress.""" |
| w = easy_task["world"] |
| files, am, _ = solutions.oracle(w) |
| k, _ = grade(easy_task, (files, am, {"notes/todo.md": "x", "scratch.yml": "groups: [["})) |
| assert k["reward"] == 1.0 |
| stem = "fleet" |
| k2, det = grade(easy_task, (files, am, {f"rules/{stem}.yml": solutions.break_indent})) |
| assert k2["syntax_ok"] == 0.0 and k2["outcome"] == 0.0 and k2["tamper"] == 0.0 |
| assert k2["progress"] > 0.4 |
|
|
|
|
| @needs_tools |
| def test_label_error_costs_label_family_only(easy_task): |
| """S3b: a wrong severity keeps Fire/Silent credit (probes select only alertname/alertstate/service).""" |
| w = easy_task["world"] |
| files, am, _ = solutions.oracle(w) |
| a = req_of(easy_task, "new_alert").alert |
| for _, x in solutions._alert_rules(files, a.name): |
| x["labels"]["severity"] = "warning" |
| _, det = grade(easy_task, (files, am, {})) |
| fams = det["requirements"][a.req_id]["families"]["integrated"] |
| assert fams["fire"] == 1.0 and fams["silent"] == 1.0 and fams["label_annot"] < 1.0 |
| assert 0.7 <= det["requirements"][a.req_id]["q"] < 1.0 |
|
|
|
|
| @needs_tools |
| def test_decoupled_pass_gives_half_credit_when_sli_is_broken(easy_task): |
| """S3a: a correct burn alert on top of broken SLI recording rules keeps about half its credit.""" |
| w = easy_task["world"] |
| files, am, _ = solutions.oracle(w) |
| for g in files["slo-recording"]: |
| for x in g["rules"]: |
| x["expr"] = x["expr"].replace("sum by (service) ", "sum ") |
| _, det = grade(easy_task, (files, am, {})) |
| a = req_of(easy_task, "new_alert").alert |
| assert det["requirements"][a.req_id]["families"]["decoupled"]["fire"] == 1.0 |
| assert 0.4 <= det["requirements"][a.req_id]["q"] <= 0.6 |
|
|
|
|
| @needs_tools |
| def test_tamper_adversaries_zero_everything(easy_task): |
| w = easy_task["world"] |
| for name in ("A-alerts-inject", "A-shadow-series", "A-group-interval"): |
| k, _ = grade(easy_task, solutions.adversary(w, name)) |
| assert k["tamper"] == 1.0 and k["reward"] == 0.0, name |
|
|
|
|
| @needs_tools |
| def test_always_fire_and_rename_score_zero_on_alert_requirements(easy_task): |
| w = easy_task["world"] |
| for name in ("A-fire", "A-silent"): |
| k, _ = grade(easy_task, solutions.adversary(w, name)) |
| assert k["req_alerts"] <= 0.05 and k["req_repairs"] <= 0.05 and k["outcome"] == 0.0, name |
|
|
|
|
| @needs_tools |
| def test_receiver_null_and_over_inhibit_block_outcome(easy_task): |
| w = easy_task["world"] |
| k, _ = grade(easy_task, solutions.adversary(w, "A-receiver-null")) |
| assert k["outcome"] == 0.0 and k["preservation"] < 1.0 |
| k, _ = grade(easy_task, solutions.adversary(w, "A-inhibit-all")) |
| assert k["req_inhibit"] <= 0.05 |
|
|
|
|
| @needs_tools |
| def test_pmut_is_interior(easy_task): |
| rng = random.Random(3) |
| g = Grader(easy_task["spec"], easy_task["hidden_dir"]) |
| xs = [grade(easy_task, solutions.pmut(easy_task["world"], rng)[0], g)[0]["reward"] for _ in range(6)] |
| assert all(0.0 <= x <= 1.0 for x in xs) and max(xs) > 0.05 |
|
|
|
|
| @needs_tools |
| def test_grader_cli_writes_all_keys(easy_task, tmp_path): |
| """tests/grade.py (the copied grader) produces the same keys as the library.""" |
| task_dir = os.path.dirname(os.path.dirname(easy_task["hidden_dir"])) |
| ws = os.path.join(task_dir, "environment", "workspace", "monitoring") |
| out = tmp_path / "reward.json" |
| subprocess.run([sys.executable, "-I", os.path.join(task_dir, "tests", "grade.py"), "--workspace", ws, |
| "--spec", os.path.join(task_dir, "tests", "spec.json"), "--hidden", |
| os.path.join(task_dir, "tests", "hidden"), "--out", str(out)], check=True, |
| env={**os.environ}, capture_output=True) |
| keys = json.loads(out.read_text()) |
| assert set(keys) == set(KEYS) and keys["reward"] == 0.0 |
|
|
|
|
| def _tree_hash(root): |
| h = hashlib.sha256() |
| for dp, _, fns in sorted(os.walk(root)): |
| for fn in sorted(fns): |
| p = os.path.join(dp, fn) |
| h.update(os.path.relpath(p, root).encode()) |
| with open(p, "rb") as fh: |
| h.update(fh.read()) |
| return h.hexdigest() |
|
|
|
|
| @needs_tools |
| def test_build_is_deterministic(tmp_path): |
| a = render.build_task("alert-storm-cleanup", "medium", 2, str(tmp_path / "a"), "t", 7) |
| b = render.build_task("alert-storm-cleanup", "medium", 2, str(tmp_path / "b"), "t", 7) |
| assert _tree_hash(os.path.join(tmp_path, "a", "t")) == _tree_hash(os.path.join(tmp_path, "b", "t")) |
| assert a["n_checks"] == b["n_checks"] |
|
|
|
|
| @needs_tools |
| def test_checksums_and_solution_scripts(easy_task): |
| task_dir = os.path.dirname(os.path.dirname(easy_task["hidden_dir"])) |
| r = subprocess.run(["shasum", "-a", "256", "-c", "checksums.sha256"], cwd=os.path.join(task_dir, "tests"), |
| capture_output=True, text=True) |
| assert r.returncode == 0, r.stdout + r.stderr |
| solve = open(os.path.join(task_dir, "solution", "solve.sh")).read() |
| assert solve.startswith("#!/bin/bash") and "AF_EOF" in solve |
|
|
|
|
| @needs_tools |
| def test_grading_is_deterministic_across_fresh_graders(hard_task): |
| """M10: promtool group order is pinned (group_eval_order), so repeated grades are bit-identical.""" |
| st = solutions.partial(hard_task["world"]) |
| vals = {grade(hard_task, st)[0]["reward"] for _ in range(3)} |
| assert len(vals) == 1 |
|
|
