Initial commit

tests/unit/coverage/test_status_classifier.py

@@ -0,0 +1,338 @@
+"""Unit tests for evidence status classification."""
+
+# FILE: tests/unit/coverage/test_status_classifier.py
+
+from datetime import datetime
+
+import pytest
+
+from libs.coverage.evaluator import CoverageEvaluator
+from libs.schemas import (
+    CompiledCoveragePolicy,
+    CoveragePolicy,
+    Defaults,
+    FoundEvidence,
+    Status,
+    StatusClassifier,
+    StatusClassifierConfig,
+    TaxYearBoundary,
+)
+from libs.schemas.coverage.core import ConflictRules, Privacy, QuestionTemplates
+
+# pylint: disable=wrong-import-position,import-error,too-few-public-methods,global-statement
+# pylint: disable=raise-missing-from,unused-argument,too-many-arguments,too-many-positional-arguments
+# pylint: disable=too-many-locals,import-outside-toplevel
+# mypy: disable-error-code=union-attr
+# mypy: disable-error-code=no-untyped-def
+
+
+class TestStatusClassifier:
+    """Test evidence status classification logic"""
+
+    @pytest.fixture
+    def mock_policy(self):
+        """Create mock compiled policy for testing"""
+        policy = CoveragePolicy(
+            version="1.0",
+            jurisdiction="UK",
+            tax_year="2024-25",
+            tax_year_boundary=TaxYearBoundary(start="2024-04-06", end="2025-04-05"),
+            defaults=Defaults(
+                confidence_thresholds={"ocr": 0.82, "extract": 0.85},
+                date_tolerance_days=30,
+            ),
+            document_kinds=["P60"],
+            status_classifier=StatusClassifierConfig(
+                present_verified=StatusClassifier(
+                    min_ocr=0.82,
+                    min_extract=0.85,
+                    date_in_year=True,
+                ),
+                present_unverified=StatusClassifier(
+                    min_ocr=0.60,
+                    min_extract=0.70,
+                    date_in_year_or_tolerance=True,
+                ),
+                conflicting=StatusClassifier(
+                    conflict_rules=["Same doc kind, different totals"]
+                ),
+                missing=StatusClassifier(),
+            ),
+            conflict_resolution=ConflictRules(precedence=["P60"]),
+            question_templates=QuestionTemplates(
+                default={"text": "test", "why": "test"}
+            ),
+            privacy=Privacy(vector_pii_free=True, redact_patterns=[]),
+        )
+
+        return CompiledCoveragePolicy(
+            policy=policy,
+            compiled_predicates={},
+            compiled_at=datetime.utcnow(),
+            hash="test-hash",
+            source_files=["test.yaml"],
+        )
+
+    @pytest.fixture
+    def evaluator(self):
+        """Create coverage evaluator for testing"""
+        return CoverageEvaluator()
+
+    def test_classify_missing_evidence(self, evaluator, mock_policy):
+        """Test classification when no evidence found"""
+        found = []
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        assert status == Status.MISSING
+
+    def test_classify_verified_evidence(self, evaluator, mock_policy):
+        """Test classification of verified evidence"""
+        found = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.85,
+                extract_confidence=0.90,
+                date="2024-05-15T10:00:00Z",
+            )
+        ]
+
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        assert status == Status.PRESENT_VERIFIED
+
+    def test_classify_unverified_evidence(self, evaluator, mock_policy):
+        """Test classification of unverified evidence"""
+        found = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.70,  # Below verified threshold
+                extract_confidence=0.75,  # Below verified threshold
+                date="2024-05-15T10:00:00Z",
+            )
+        ]
+
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        assert status == Status.PRESENT_UNVERIFIED
+
+    def test_classify_low_confidence_evidence(self, evaluator, mock_policy):
+        """Test classification of very low confidence evidence"""
+        found = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.50,  # Below unverified threshold
+                extract_confidence=0.55,  # Below unverified threshold
+                date="2024-05-15T10:00:00Z",
+            )
+        ]
+
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        assert status == Status.MISSING
+
+    def test_classify_conflicting_evidence(self, evaluator, mock_policy):
+        """Test classification when multiple conflicting documents found"""
+        found = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.85,
+                extract_confidence=0.90,
+                date="2024-05-15T10:00:00Z",
+            ),
+            FoundEvidence(
+                doc_id="DOC-002",
+                kind="P60",
+                ocr_confidence=0.85,
+                extract_confidence=0.90,
+                date="2024-05-20T10:00:00Z",
+            ),
+        ]
+
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        assert status == Status.CONFLICTING
+
+    def test_classify_evidence_outside_tax_year(self, evaluator, mock_policy):
+        """Test classification of evidence outside tax year"""
+        found = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.85,
+                extract_confidence=0.90,
+                date="2023-03-15T10:00:00Z",  # Outside tax year
+            )
+        ]
+
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        # Evidence outside tax year should be unverified even with high confidence
+        # This is correct business logic - date validation is part of verification
+        assert status == Status.PRESENT_UNVERIFIED
+
+    def test_classify_evidence_no_date(self, evaluator, mock_policy):
+        """Test classification of evidence without date"""
+        found = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.85,
+                extract_confidence=0.90,
+                date=None,
+            )
+        ]
+
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        # Evidence without date cannot be fully verified, even with high confidence
+        # This is correct business logic - date validation is required for verification
+        assert status == Status.PRESENT_UNVERIFIED
+
+    def test_parse_tax_year_bounds(self, evaluator):
+        """Test parsing of tax year boundary strings"""
+        start_str = "2024-04-06"
+        end_str = "2025-04-05"
+
+        start, end = evaluator._parse_tax_year_bounds(start_str, end_str)
+
+        assert isinstance(start, datetime)
+        assert isinstance(end, datetime)
+        assert start.year == 2024
+        assert start.month == 4
+        assert start.day == 6
+        assert end.year == 2025
+        assert end.month == 4
+        assert end.day == 5
+
+    def test_evidence_within_tax_year(self, evaluator, mock_policy):
+        """Test evidence date validation within tax year"""
+        # Evidence within tax year
+        found = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.85,
+                extract_confidence=0.90,
+                date="2024-06-15T10:00:00Z",  # Within 2024-25 tax year
+            )
+        ]
+
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        assert status == Status.PRESENT_VERIFIED
+
+    def test_evidence_boundary_dates(self, evaluator, mock_policy):
+        """Test evidence on tax year boundary dates"""
+        # Test start boundary
+        found_start = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.85,
+                extract_confidence=0.90,
+                date="2024-04-06T00:00:00Z",  # Exact start date
+            )
+        ]
+
+        status = evaluator.classify_status(found_start, mock_policy, "2024-25")
+        assert status == Status.PRESENT_VERIFIED
+
+        # Test end boundary
+        found_end = [
+            FoundEvidence(
+                doc_id="DOC-002",
+                kind="P60",
+                ocr_confidence=0.85,
+                extract_confidence=0.90,
+                date="2025-04-05T23:59:59Z",  # Exact end date
+            )
+        ]
+
+        status = evaluator.classify_status(found_end, mock_policy, "2024-25")
+        assert status == Status.PRESENT_VERIFIED
+
+    def test_threshold_edge_cases(self, evaluator, mock_policy):
+        """Test classification at threshold boundaries"""
+        # Exactly at verified threshold
+        found_exact = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.82,  # Exactly at threshold
+                extract_confidence=0.85,  # Exactly at threshold
+                date="2024-06-15T10:00:00Z",
+            )
+        ]
+
+        status = evaluator.classify_status(found_exact, mock_policy, "2024-25")
+        assert status == Status.PRESENT_VERIFIED
+
+        # Just below verified threshold
+        found_below = [
+            FoundEvidence(
+                doc_id="DOC-002",
+                kind="P60",
+                ocr_confidence=0.81,  # Just below threshold
+                extract_confidence=0.84,  # Just below threshold
+                date="2024-06-15T10:00:00Z",
+            )
+        ]
+
+        status = evaluator.classify_status(found_below, mock_policy, "2024-25")
+        assert status == Status.PRESENT_UNVERIFIED
+
+    def test_mixed_confidence_levels(self, evaluator, mock_policy):
+        """Test classification with mixed OCR and extract confidence"""
+        # High OCR, low extract
+        found_mixed1 = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.90,  # High
+                extract_confidence=0.70,  # Low
+                date="2024-06-15T10:00:00Z",
+            )
+        ]
+
+        status = evaluator.classify_status(found_mixed1, mock_policy, "2024-25")
+        assert status == Status.PRESENT_UNVERIFIED  # Both must meet threshold
+
+        # Low OCR, high extract
+        found_mixed2 = [
+            FoundEvidence(
+                doc_id="DOC-002",
+                kind="P60",
+                ocr_confidence=0.70,  # Low
+                extract_confidence=0.90,  # High
+                date="2024-06-15T10:00:00Z",
+            )
+        ]
+
+        status = evaluator.classify_status(found_mixed2, mock_policy, "2024-25")
+        assert status == Status.PRESENT_UNVERIFIED  # Both must meet threshold
+
+    def test_zero_confidence_evidence(self, evaluator, mock_policy):
+        """Test classification of zero confidence evidence"""
+        found = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=0.0,
+                extract_confidence=0.0,
+                date="2024-06-15T10:00:00Z",
+            )
+        ]
+
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        assert status == Status.MISSING
+
+    def test_perfect_confidence_evidence(self, evaluator, mock_policy):
+        """Test classification of perfect confidence evidence"""
+        found = [
+            FoundEvidence(
+                doc_id="DOC-001",
+                kind="P60",
+                ocr_confidence=1.0,
+                extract_confidence=1.0,
+                date="2024-06-15T10:00:00Z",
+            )
+        ]
+
+        status = evaluator.classify_status(found, mock_policy, "2024-25")
+        assert status == Status.PRESENT_VERIFIED