Update test_grader.py

test_grader.py

@@ -0,0 +1,227 @@
+"""
+test_grader.py – Unit tests for grader.py
+==========================================
+
+Run with:  pytest test_grader.py -v
+
+These tests cover every branch of grade_action() and the edge-cases of
+calculate_overall_score().  They also act as a regression guard — any
+change to a reward constant will immediately fail the assertion that was
+relying on it, forcing an intentional review.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from grader import (
+    HEALTH_DRAIN_THRESHOLD,
+    PASS_THRESHOLD,
+    R_BREACH,
+    R_DISRUPTION,
+    R_MALWARE_QUARANTINE,
+    R_PARTIAL,
+    R_PERFECT,
+    R_PHISH_BEC_QUARANTINE,
+    R_SPAM_BLOCK,
+    R_SPAM_QUARANTINE,
+    R_WRONG_PROCEDURE,
+    calculate_overall_score,
+    grade_action,
+)
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# CONSTANT SANITY CHECKS
+# ═════════════════════════════════════════════════════════════════════════════
+
+class TestRewardConstants:
+    def test_all_rewards_in_open_interval(self):
+        for r in [R_PERFECT, R_MALWARE_QUARANTINE, R_PHISH_BEC_QUARANTINE,
+                  R_SPAM_BLOCK, R_SPAM_QUARANTINE, R_WRONG_PROCEDURE,
+                  R_DISRUPTION, R_BREACH]:
+            assert 0.0 < r < 1.0, f"Reward {r} violates open-interval contract"
+
+    def test_reward_ordering(self):
+        assert R_BREACH < R_DISRUPTION < R_WRONG_PROCEDURE
+        assert R_WRONG_PROCEDURE < HEALTH_DRAIN_THRESHOLD
+        assert HEALTH_DRAIN_THRESHOLD < R_SPAM_QUARANTINE
+        assert R_SPAM_QUARANTINE < R_SPAM_BLOCK
+        assert R_SPAM_BLOCK < R_PHISH_BEC_QUARANTINE
+        assert R_PHISH_BEC_QUARANTINE < R_MALWARE_QUARANTINE
+        assert R_MALWARE_QUARANTINE < R_PERFECT
+
+    def test_partial_alias(self):
+        assert R_PARTIAL == R_MALWARE_QUARANTINE
+
+    def test_health_drain_covers_breach_disruption_wrong(self):
+        assert R_BREACH < HEALTH_DRAIN_THRESHOLD
+        assert R_DISRUPTION < HEALTH_DRAIN_THRESHOLD
+        assert R_WRONG_PROCEDURE < HEALTH_DRAIN_THRESHOLD
+
+    def test_cautious_scores_never_drain_health(self):
+        assert R_SPAM_QUARANTINE >= HEALTH_DRAIN_THRESHOLD
+        assert R_SPAM_BLOCK >= HEALTH_DRAIN_THRESHOLD
+        assert R_PHISH_BEC_QUARANTINE >= HEALTH_DRAIN_THRESHOLD
+        assert R_MALWARE_QUARANTINE >= HEALTH_DRAIN_THRESHOLD
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# GRADE_ACTION — PERFECT MATCH
+# ═════════════════════════════════════════════════════════════════════════════
+
+class TestPerfectTriage:
+    @pytest.mark.parametrize("action,etype", [
+        ("MOVE_TO_SPAM",  "SPAM"),
+        ("BLOCK_DOMAIN",  "PHISH"),
+        ("MARK_SAFE",     "SAFE"),
+        ("QUARANTINE",    "MALWARE"),
+        ("QUARANTINE",    "BEC"),
+        ("BLOCK_DOMAIN",  "BEC"),
+        ("QUARANTINE",    "PHISH"),
+    ])
+    def test_perfect_match(self, action, etype):
+        reward, msg = grade_action(action, action, etype)
+        assert reward == R_PERFECT
+        assert "PERFECT_TRIAGE" in msg
+
+    def test_case_insensitive_action(self):
+        reward, _ = grade_action("move_to_spam", "MOVE_TO_SPAM", "SPAM")
+        assert reward == R_PERFECT
+
+    def test_case_insensitive_type(self):
+        reward, _ = grade_action("MARK_SAFE", "MARK_SAFE", "safe")
+        assert reward == R_PERFECT
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# GRADE_ACTION — SECURITY BREACH
+# ═════════════════════════════════════════════════════════════════════════════
+
+class TestSecurityBreach:
+    @pytest.mark.parametrize("etype", ["PHISH", "BEC", "MALWARE", "SPAM"])
+    def test_mark_safe_on_any_threat_is_breach(self, etype):
+        """BUG FIX coverage: SPAM + MARK_SAFE must return R_BREACH (not R_WRONG_PROCEDURE)."""
+        reward, msg = grade_action("MARK_SAFE", "BLOCK_DOMAIN", etype)
+        assert reward == R_BREACH
+        assert "SECURITY_BREACH" in msg
+
+    def test_spam_mark_safe_is_breach_not_wrong_procedure(self):
+        """Regression: the original code excluded SPAM from _THREAT_TYPES."""
+        reward, _ = grade_action("MARK_SAFE", "MOVE_TO_SPAM", "SPAM")
+        assert reward == R_BREACH, (
+            "SPAM + MARK_SAFE must be R_BREACH — SPAM was excluded from "
+            "_THREAT_TYPES in the v1.0.2 bug"
+        )
+        assert reward < HEALTH_DRAIN_THRESHOLD  # must drain health
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# GRADE_ACTION — BUSINESS DISRUPTION
+# ═════════════════════════════════════════════════════════════════════════════
+
+class TestBusinessDisruption:
+    @pytest.mark.parametrize("blocking_action", ["BLOCK_DOMAIN", "QUARANTINE", "MOVE_TO_SPAM"])
+    def test_blocking_safe_email_is_disruption(self, blocking_action):
+        reward, msg = grade_action(blocking_action, "MARK_SAFE", "SAFE")
+        assert reward == R_DISRUPTION
+        assert "BUSINESS_DISRUPTION" in msg
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# GRADE_ACTION — PARTIAL CREDIT
+# ═════════════════════════════════════════════════════════════════════════════
+
+class TestPartialCredit:
+    def test_malware_quarantine(self):
+        reward, msg = grade_action("QUARANTINE", "BLOCK_DOMAIN", "MALWARE")
+        assert reward == R_MALWARE_QUARANTINE
+        assert "CAUTIOUS" in msg
+
+    def test_phish_quarantine(self):
+        reward, msg = grade_action("QUARANTINE", "BLOCK_DOMAIN", "PHISH")
+        assert reward == R_PHISH_BEC_QUARANTINE
+        assert "UNDER_RESPONSE" in msg
+
+    def test_bec_quarantine(self):
+        reward, msg = grade_action("QUARANTINE", "BLOCK_DOMAIN", "BEC")
+        assert reward == R_PHISH_BEC_QUARANTINE
+
+    def test_spam_block_domain(self):
+        reward, msg = grade_action("BLOCK_DOMAIN", "MOVE_TO_SPAM", "SPAM")
+        assert reward == R_SPAM_BLOCK
+        assert "OVER_ESCALATION" in msg
+
+    def test_spam_quarantine(self):
+        reward, msg = grade_action("QUARANTINE", "MOVE_TO_SPAM", "SPAM")
+        assert reward == R_SPAM_QUARANTINE
+        assert "OVER_ESCALATION" in msg
+
+    @pytest.mark.parametrize("action", ["QUARANTINE", "BLOCK_DOMAIN", "MOVE_TO_SPAM"])
+    def test_partial_credits_never_drain_health(self, action):
+        reward, _ = grade_action(action, "MOVE_TO_SPAM", "SPAM")
+        assert reward >= HEALTH_DRAIN_THRESHOLD
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# GRADE_ACTION — WRONG PROCEDURE / INVALID
+# ═════════════════════════════════════════════════════════════════════════════
+
+class TestWrongProcedure:
+    def test_malware_block_domain_is_wrong_procedure(self):
+        """lv4 / lv8: expected QUARANTINE, agent picks BLOCK_DOMAIN."""
+        reward, msg = grade_action("BLOCK_DOMAIN", "QUARANTINE", "MALWARE")
+        assert reward == R_WRONG_PROCEDURE
+        assert "INCORRECT_PROCEDURE" in msg
+
+    def test_invalid_action_token(self):
+        reward, msg = grade_action("DELETE", "QUARANTINE", "MALWARE")
+        assert reward == R_WRONG_PROCEDURE
+        assert "INVALID_ACTION" in msg
+
+    def test_invalid_action_drains_health(self):
+        reward, _ = grade_action("NONSENSE", "QUARANTINE", "PHISH")
+        assert reward < HEALTH_DRAIN_THRESHOLD
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# CALCULATE_OVERALL_SCORE
+# ═════════════════════════════════════════════════════════════════════════════
+
+class TestCalculateOverallScore:
+    def test_empty_list_returns_r_breach(self):
+        assert calculate_overall_score([]) == R_BREACH
+
+    def test_all_perfect_returns_r_perfect(self):
+        assert calculate_overall_score([R_PERFECT, R_PERFECT, R_PERFECT]) == R_PERFECT
+
+    def test_result_never_exceeds_r_perfect(self):
+        assert calculate_overall_score([1.0, 1.0]) == R_PERFECT
+
+    def test_result_never_below_r_breach(self):
+        assert calculate_overall_score([0.0, 0.0]) == R_BREACH
+
+    def test_easy_all_perfect(self):
+        scores = [R_PERFECT] * 3
+        assert calculate_overall_score(scores) == R_PERFECT
+
+    def test_medium_mixed(self):
+        scores = [R_PERFECT, R_BREACH, R_PERFECT, R_PHISH_BEC_QUARANTINE]
+        result = calculate_overall_score(scores)
+        expected = round((R_PERFECT + R_BREACH + R_PERFECT + R_PHISH_BEC_QUARANTINE) / 4, 4)
+        assert result == expected
+
+    def test_hard_mostly_bad(self):
+        scores = [R_BREACH, R_DISRUPTION, R_PERFECT]
+        result = calculate_overall_score(scores)
+        assert result < PASS_THRESHOLD
+
+    def test_returns_four_decimal_places(self):
+        result = calculate_overall_score([R_PERFECT, R_BREACH])
+        assert result == round(result, 4)
+
+    def test_single_perfect_step(self):
+        assert calculate_overall_score([R_PERFECT]) == R_PERFECT
+
+    def test_single_breach_step(self):
+        assert calculate_overall_score([R_BREACH]) == R_BREACH