@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/unit/engine/test_provider_failure_classifier.py

@@ -1,195 +0,0 @@
-from __future__ import annotations
-
-from datetime import UTC, datetime, timedelta
-
-import httpx
-from vds_audit_orchestrator.engine.provider_failure_classifier import (
-    ProviderFailureClass,
-    ProviderFailureClassifier,
-    ProviderHealthMemory,
-    ProviderQuotaStatus,
-    RateLimitState,
-    RowFailoverContext,
-    parse_rate_limit_headers,
-    parse_retry_after,
-    truncate_failover_profiles_considered,
-    truncate_row_failover_context,
-)
-
-
-def test_parse_retry_after_supports_seconds() -> None:
-    assert parse_retry_after({"Retry-After": "7"}) == 7.0
-
-
-def test_parse_retry_after_supports_http_date() -> None:
-    future = datetime.now(UTC) + timedelta(seconds=12)
-    parsed = parse_retry_after({"Retry-After": future.strftime("%a, %d %b %Y %H:%M:%S GMT")})
-    assert parsed is not None
-    assert 0.0 <= parsed <= 12.5
-
-
-def test_classifier_marks_401_as_terminal_auth() -> None:
-    request = httpx.Request("GET", "https://example.com")
-    response = httpx.Response(401, request=request)
-    exc = httpx.HTTPStatusError("401 Unauthorized", request=request, response=response)
-
-    classification = ProviderFailureClassifier.classify(exc)
-
-    assert classification.failure_class == ProviderFailureClass.TERMINAL_AUTH
-    assert classification.is_failoverable is False
-    assert classification.raw_status_code == 401
-
-
-def test_classifier_marks_503_as_retryable_transient() -> None:
-    request = httpx.Request("GET", "https://example.com")
-    response = httpx.Response(503, request=request, headers={"Retry-After": "9"})
-    exc = httpx.HTTPStatusError("503 Service Unavailable", request=request, response=response)
-
-    classification = ProviderFailureClassifier.classify(exc)
-
-    assert classification.failure_class == ProviderFailureClass.RETRYABLE_TRANSIENT
-    assert classification.is_failoverable is True
-    assert classification.retry_after_seconds == 9.0
-
-
-def test_classifier_marks_tool_validation_shape_as_non_provider_bug() -> None:
-    try:
-        try:
-            raise ValueError(
-                "1 validation error for search_evidence\nquery\n  Field required [type=missing, input_value={}, input_type=dict]"
-            )
-        except ValueError as inner:
-            raise RuntimeError("Tool 'search_evidence' exceeded max retries count of 1") from inner
-    except RuntimeError as exc:
-        classification = ProviderFailureClassifier.classify(exc)
-
-    assert classification.failure_class == ProviderFailureClass.NON_PROVIDER_BUG
-    assert classification.is_failoverable is False
-
-
-def test_truncate_row_failover_context_bounds_lists_and_mappings() -> None:
-    context = RowFailoverContext(
-        row_id="row-1",
-        check_id="CL-001",
-        evidence_refs=[{"ref": f"ref-{idx}"} for idx in range(20)],
-        route_state={f"route-{idx}": idx for idx in range(30)},
-        partial_progress={f"progress-{idx}": idx for idx in range(30)},
-        original_provider="primary-openai",
-        failover_count=4,
-        failover_chain=["primary-openai", "fallback-a", "fallback-b", "fallback-c"],
-        timeout_telemetry_snapshot={f"timeout-{idx}": idx for idx in range(30)},
-    )
-
-    trimmed = truncate_row_failover_context(context, max_provider_hops=2)
-
-    assert len(trimmed.evidence_refs) == 12
-    assert len(trimmed.route_state) == 20
-    assert len(trimmed.partial_progress) == 20
-    assert len(trimmed.timeout_telemetry_snapshot) == 20
-    assert trimmed.failover_chain == ["primary-openai", "fallback-a", "fallback-b"]
-
-
-def test_truncate_failover_profiles_considered_caps_list_to_hop_budget() -> None:
-    trimmed = truncate_failover_profiles_considered(
-        ["primary-openai", "fallback-a", "fallback-b", "fallback-c"],
-        max_provider_hops=1,
-    )
-
-    assert trimmed == ["primary-openai", "fallback-a", "fallback-b"]
-
-
-def test_parse_rate_limit_headers_supports_openai_duration_resets() -> None:
-    state = parse_rate_limit_headers(
-        {
-            "x-ratelimit-remaining-requests": "0",
-            "x-ratelimit-remaining-tokens": "12",
-            "x-ratelimit-reset-requests": "6m0s",
-            "x-ratelimit-reset-tokens": "1s",
-            "Retry-After": "4",
-        },
-        protocol="openai",
-    )
-
-    assert state.remaining_requests == 0
-    assert state.remaining_tokens == 12
-    assert state.request_capacity_known_empty() is True
-    assert state.retry_after_seconds == 4.0
-    assert state.reset_requests_at is not None
-    assert state.reset_tokens_at is not None
-
-
-def test_provider_health_memory_tracks_preflight_cooldown_and_success() -> None:
-    import asyncio
-
-    memory = ProviderHealthMemory()
-    asyncio.run(
-        memory.apply_preflight_probe(
-            "provider-a",
-            {
-                "quota_readiness": "cooldown",
-                "reason_code": "provider_rate_limited",
-                "cooldown_seconds": 5,
-                "rate_limit_state": {
-                    "retry_after_seconds": 5.0,
-                    "raw_headers_present": True,
-                },
-            },
-        )
-    )
-
-    assert memory.is_in_cooldown("provider-a") is True
-    assert memory.should_skip_provider("provider-a") is True
-
-    asyncio.run(
-        memory.record_success(
-            "provider-a",
-            rate_limit_state=RateLimitState(remaining_requests=10, raw_headers_present=True),
-        )
-    )
-
-    state = memory.get_state("provider-a")
-    assert state.quota_status == ProviderQuotaStatus.READY
-    assert memory.is_in_cooldown("provider-a") is False
-
-
-def test_classifier_marks_route_credential_gap_as_failoverable() -> None:
-    # Production shape: router returns 400 with "No credentials for provider: anthropic"
-    # This must NOT be classified as TERMINAL_AUTH — it's recoverable via cross-profile failover.
-    request = httpx.Request("POST", "https://proxy.internal/v1/chat/completions")
-    response = httpx.Response(400, request=request)
-    exc = httpx.HTTPStatusError(
-        "400 Bad Request: No credentials for provider: anthropic",
-        request=request,
-        response=response,
-    )
-
-    classification = ProviderFailureClassifier.classify(exc)
-
-    assert classification.failure_class == ProviderFailureClass.ROUTE_PROVIDER_UNAVAILABLE
-    assert classification.is_failoverable is True
-    assert classification.classification_reason == "route_provider_credential_gap"
-    assert classification.raw_status_code == 400
-
-
-def test_classifier_marks_403_as_terminal_auth() -> None:
-    # Production shape: 403 Forbidden — permanent key/permission rejection, not failoverable.
-    request = httpx.Request("POST", "https://api.openai.com/v1/chat/completions")
-    response = httpx.Response(403, request=request)
-    exc = httpx.HTTPStatusError("403 Forbidden", request=request, response=response)
-
-    classification = ProviderFailureClassifier.classify(exc)
-
-    assert classification.failure_class == ProviderFailureClass.TERMINAL_AUTH
-    assert classification.is_failoverable is False
-    assert classification.raw_status_code == 403
-
-
-def test_classifier_marks_transport_connect_error_as_retryable_transient() -> None:
-    # Production shape: network-level connect failure — transient, failover to another profile.
-    exc = httpx.ConnectError("All connection attempts failed")
-
-    classification = ProviderFailureClassifier.classify(exc)
-
-    assert classification.failure_class == ProviderFailureClass.RETRYABLE_TRANSIENT
-    assert classification.is_failoverable is True
-    assert classification.raw_status_code is None

package/tools/vds-scripts/audit_orchestrator/tests/unit/engine/test_readiness_extractor.py

@@ -1,496 +0,0 @@
-"""Unit tests for ReadinessDataExtractor (Phase 85 TSK-850.7)."""
-
-from __future__ import annotations
-
-from typing import Any
-
-import pytest
-from vds_audit_orchestrator.engine.readiness_extractor import (
-    ReadinessDataExtractor,
-)
-from vds_audit_orchestrator.models.checklist import (
-    AuditChecklist,
-    EvidenceAnchor,
-    RowEvaluation,
-    RowProvenance,
-    RowStatus,
-    ScoreBreakdown,
-)
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _provenance(**overrides) -> RowProvenance:
-    defaults: dict[str, Any] = {
-        "row_llm_mode": "off",
-        "template_hash": "abcdef1234567890",
-        "evidence_hash": "1234567890abcdef",
-    }
-    defaults.update(overrides)
-    return RowProvenance(**defaults)
-
-
-def _score_breakdown(raw: float = 80.0, final: float | None = None) -> ScoreBreakdown:
-    f = final if final is not None else raw
-    return ScoreBreakdown(raw_score=raw, final_score=f)
-
-
-def _row(
-    *,
-    row_id: str = "R-001",
-    row_index: int = 0,
-    status: RowStatus = RowStatus.PASS,
-    raw_score: float = 80.0,
-    final_score: float | None = None,
-    weight: float = 5.0,
-    category: str = "Security",
-    requirement: str = "Requirement text",
-    finding: str = "Finding text",
-    reason: str = "Reason text",
-    reasoning: str = "",
-    recommendation: str | None = None,
-    score_1_5: int | None = None,
-    evidence_refs: list[EvidenceAnchor] | None = None,
-) -> RowEvaluation:
-    f = final_score if final_score is not None else raw_score
-    return RowEvaluation(
-        row_id=row_id,
-        row_index=row_index,
-        requirement_text=requirement,
-        requirement_category=category,
-        weight_raw=weight,
-        weight_adjusted=weight,
-        status=status,
-        score_breakdown=_score_breakdown(raw_score, f),
-        reason=reason,
-        reasoning=reasoning,
-        finding=finding,
-        recommendation=recommendation,
-        provenance=_provenance(),
-        score_1_5=score_1_5,
-        evidence_refs=evidence_refs or [],
-    )
-
-
-def _checklist(rows: list[RowEvaluation] | None = None) -> AuditChecklist:
-    r = rows if rows is not None else []
-    return AuditChecklist(
-        template_name="Test Template",
-        template_version="1.0.0",
-        template_hash="aaaa111122223333",
-        template_row_count=len(r),
-        repository="test-repo",
-        row_llm_mode="off",
-        evidence_hash="bbbb444455556666",
-        rows=r,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Extractor instance
-# ---------------------------------------------------------------------------
-
-
-@pytest.fixture
-def extractor() -> ReadinessDataExtractor:
-    return ReadinessDataExtractor()
-
-
-# ---------------------------------------------------------------------------
-# Empty checklist
-# ---------------------------------------------------------------------------
-
-
-class TestEmptyChecklist:
-    def test_empty_rows(self, extractor: ReadinessDataExtractor):
-        ctx = extractor.extract(_checklist([]), "prod", "1.0")
-        assert ctx["total_rows"] == 0
-        assert ctx["weighted_score_pct"] == 0.0
-        assert ctx["severity_candidates"] == []
-        assert ctx["category_heatmap"] == []
-        assert ctx["low_confidence_rows"] == []
-        assert ctx["conflicting_rows"] == []
-        assert ctx["rows"] == []
-
-    def test_metadata_propagated(self, extractor: ReadinessDataExtractor):
-        ctx = extractor.extract(_checklist([]), "my-product", "2.0")
-        assert ctx["repo_name"] == "my-product"
-        assert ctx["template_name"] == "Test Template"
-        assert ctx["template_version"] == "1.0.0"
-
-
-# ---------------------------------------------------------------------------
-# Weighted score computation
-# ---------------------------------------------------------------------------
-
-
-class TestWeightedScore:
-    def test_single_row(self, extractor: ReadinessDataExtractor):
-        rows = [_row(raw_score=60.0, weight=10.0)]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["weighted_score_pct"] == 60.0
-
-    def test_two_rows_equal_weight(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=80.0, weight=5.0),
-            _row(row_id="R2", row_index=1, raw_score=40.0, weight=5.0, status=RowStatus.FAIL),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["weighted_score_pct"] == 60.0
-
-    def test_two_rows_unequal_weight(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=100.0, weight=3.0),
-            _row(row_id="R2", row_index=1, raw_score=0.0, weight=1.0, status=RowStatus.FAIL),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        # (100*3 + 0*1) / (3+1) = 75.0
-        assert ctx["weighted_score_pct"] == 75.0
-
-    def test_na_rows_excluded_from_weight(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=50.0, weight=10.0, status=RowStatus.PARTIAL),
-            _row(row_id="R2", row_index=1, raw_score=0.0, weight=10.0, status=RowStatus.NA),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["weighted_score_pct"] == 50.0
-
-    def test_error_rows_excluded_from_weight(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=90.0, weight=5.0),
-            _row(row_id="R2", row_index=1, raw_score=10.0, weight=5.0, status=RowStatus.ERROR),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["weighted_score_pct"] == 90.0
-
-    def test_zero_weight_rows(self, extractor: ReadinessDataExtractor):
-        rows = [_row(raw_score=50.0, weight=0.0, status=RowStatus.PARTIAL)]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["weighted_score_pct"] == 0.0
-
-
-# ---------------------------------------------------------------------------
-# Status distribution
-# ---------------------------------------------------------------------------
-
-
-class TestStatusDistribution:
-    def test_mixed_statuses(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, status=RowStatus.PASS),
-            _row(row_id="R2", row_index=1, status=RowStatus.FAIL, raw_score=10.0),
-            _row(row_id="R3", row_index=2, status=RowStatus.PARTIAL, raw_score=50.0),
-            _row(row_id="R4", row_index=3, status=RowStatus.NA),
-            _row(row_id="R5", row_index=4, status=RowStatus.ERROR),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        dist = ctx["status_distribution"]
-        assert dist["PASS"] == 1
-        assert dist["FAIL"] == 1
-        assert dist["PARTIAL"] == 1
-        assert dist["N/A"] == 1
-        assert dist["ERROR"] == 1
-
-    def test_all_pass(self, extractor: ReadinessDataExtractor):
-        rows = [_row(row_id=f"R{i}", row_index=i, status=RowStatus.PASS) for i in range(3)]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["status_distribution"]["PASS"] == 3
-        assert ctx["status_distribution"]["FAIL"] == 0
-
-
-# ---------------------------------------------------------------------------
-# Severity candidates
-# ---------------------------------------------------------------------------
-
-
-class TestSeverityCandidates:
-    def test_all_pass_no_candidates(self, extractor: ReadinessDataExtractor):
-        rows = [_row(row_id=f"R{i}", row_index=i, raw_score=95.0, weight=5.0) for i in range(4)]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["severity_candidates"] == []
-
-    def test_low_score_high_weight_is_candidate(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=10.0, weight=5.0, status=RowStatus.FAIL, score_1_5=1),
-            _row(row_id="R2", row_index=1, raw_score=90.0, weight=5.0),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["severity_candidates"]) == 1
-        assert ctx["severity_candidates"][0]["row_id"] == "R1"
-
-    def test_low_score_low_weight_excluded(self, extractor: ReadinessDataExtractor):
-        # Weight is tiny relative to total, below 3% threshold
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=10.0, weight=0.1, status=RowStatus.FAIL, score_1_5=1),
-            _row(row_id="R2", row_index=1, raw_score=90.0, weight=100.0),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["severity_candidates"]) == 0
-
-    def test_na_rows_excluded_from_candidates(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=10.0, weight=10.0, status=RowStatus.NA, score_1_5=1),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["severity_candidates"] == []
-
-    def test_all_fail_many_candidates(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id=f"R{i}", row_index=i, raw_score=5.0, weight=5.0, status=RowStatus.FAIL, score_1_5=1)
-            for i in range(5)
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        # All rows have equal weight (20% each > 3%), all score_1_5=1
-        assert len(ctx["severity_candidates"]) == 5
-
-
-# ---------------------------------------------------------------------------
-# Category heatmap
-# ---------------------------------------------------------------------------
-
-
-class TestCategoryHeatmap:
-    def test_single_category(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=60.0, category="Security"),
-            _row(row_id="R2", row_index=1, raw_score=80.0, category="Security"),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        heatmap = ctx["category_heatmap"]
-        assert len(heatmap) == 1
-        assert heatmap[0]["category"] == "Security"
-        assert heatmap[0]["avg_score"] == 70.0
-        assert heatmap[0]["row_count"] == 2
-        assert heatmap[0]["worst_row_id"] == "R1"
-        assert heatmap[0]["worst_score"] == 60.0
-
-    def test_multiple_categories(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=90.0, category="Security"),
-            _row(row_id="R2", row_index=1, raw_score=40.0, category="Documentation", status=RowStatus.PARTIAL),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        heatmap = ctx["category_heatmap"]
-        assert len(heatmap) == 2
-        cats = {e["category"] for e in heatmap}
-        assert "Security" in cats
-        assert "Documentation" in cats
-
-    def test_na_excluded_from_heatmap(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, raw_score=50.0, category="A", status=RowStatus.PARTIAL),
-            _row(row_id="R2", row_index=1, raw_score=0.0, category="A", status=RowStatus.NA),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["category_heatmap"]) == 1
-        assert ctx["category_heatmap"][0]["row_count"] == 1
-
-    def test_uncategorized_fallback(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, category=None),  # type: ignore[arg-type]
-        ]
-        # requirement_category=None should fall back to "uncategorized"
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["category_heatmap"][0]["category"] == "uncategorized"
-
-
-# ---------------------------------------------------------------------------
-# Data gap detection
-# ---------------------------------------------------------------------------
-
-
-class TestDataGaps:
-    def test_no_evidence_detected(self, extractor: ReadinessDataExtractor):
-        rows = [_row(row_id="R1", row_index=0, evidence_refs=[])]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["low_confidence_rows"]) == 1
-        assert ctx["low_confidence_rows"][0]["issue"] == "no_evidence"
-
-    def test_short_evidence_detected(self, extractor: ReadinessDataExtractor):
-        short_ref = EvidenceAnchor(ref_type="code_path", ref_value="a.py")
-        rows = [_row(row_id="R1", row_index=0, evidence_refs=[short_ref])]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["low_confidence_rows"]) == 1
-        assert "short_evidence" in ctx["low_confidence_rows"][0]["issue"]
-
-    def test_sufficient_evidence_not_flagged(self, extractor: ReadinessDataExtractor):
-        ref = EvidenceAnchor(ref_type="code_path", ref_value="a" * 30)
-        rows = [_row(row_id="R1", row_index=0, evidence_refs=[ref])]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["low_confidence_rows"]) == 0
-
-    def test_na_rows_excluded_from_gaps(self, extractor: ReadinessDataExtractor):
-        rows = [_row(row_id="R1", row_index=0, status=RowStatus.NA, evidence_refs=[])]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["low_confidence_rows"]) == 0
-
-
-# ---------------------------------------------------------------------------
-# Conflicting evidence detection
-# ---------------------------------------------------------------------------
-
-
-class TestConflictingEvidence:
-    def test_pass_with_low_score(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, status=RowStatus.PASS, raw_score=10.0, score_1_5=1),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["conflicting_rows"]) == 1
-        assert ctx["conflicting_rows"][0]["conflict_type"] == "pass_with_low_score"
-
-    def test_fail_with_high_score(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, status=RowStatus.FAIL, raw_score=90.0, score_1_5=5),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["conflicting_rows"]) == 1
-        assert ctx["conflicting_rows"][0]["conflict_type"] == "fail_with_high_score"
-
-    def test_vietnamese_contradiction_keyword(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(
-                row_id="R1",
-                row_index=0,
-                status=RowStatus.PARTIAL,
-                raw_score=50.0,
-                reasoning="Kết quả tốt, tuy nhiên thiếu minh chứng cụ thể",
-            ),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["conflicting_rows"]) == 1
-        assert ctx["conflicting_rows"][0]["conflict_type"] == "contradiction_keyword:tuy nhiên"
-
-    def test_no_conflict_normal_pass(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, status=RowStatus.PASS, raw_score=95.0, score_1_5=5),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["conflicting_rows"]) == 0
-
-    def test_no_conflict_normal_fail(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, status=RowStatus.FAIL, raw_score=10.0, score_1_5=1),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["conflicting_rows"]) == 0
-
-    def test_na_excluded_from_conflicts(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(row_id="R1", row_index=0, status=RowStatus.NA, raw_score=10.0, score_1_5=1),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["conflicting_rows"] == []
-
-    def test_multiple_vietnamese_keywords(self, extractor: ReadinessDataExtractor):
-        rows = [
-            _row(
-                row_id="R1",
-                row_index=0,
-                status=RowStatus.PARTIAL,
-                raw_score=60.0,
-                reasoning="Mặc dù có một số minh chứng nhưng chưa đầy đủ",
-            ),
-        ]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        # Should detect first matching keyword in tuple order ("nhưng" before "mặc dù")
-        assert len(ctx["conflicting_rows"]) == 1
-        assert "nhưng" in ctx["conflicting_rows"][0]["conflict_type"]
-
-
-# ---------------------------------------------------------------------------
-# Row serialization
-# ---------------------------------------------------------------------------
-
-
-class TestRowSerialization:
-    def test_rows_serialized(self, extractor: ReadinessDataExtractor):
-        rows = [_row(row_id="R1", row_index=0, raw_score=70.0)]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert len(ctx["rows"]) == 1
-        r = ctx["rows"][0]
-        assert r["row_id"] == "R1"
-        assert r["score_percent"] == 70.0
-        assert r["status"] == "PASS"
-        assert "evidence_refs_count" in r
-
-    def test_computed_score_1_5_when_none(self, extractor: ReadinessDataExtractor):
-        rows = [_row(row_id="R1", row_index=0, raw_score=95.0, score_1_5=None)]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["rows"][0]["score_1_5"] == 5  # 95% -> 5
-
-    def test_explicit_score_1_5_preserved(self, extractor: ReadinessDataExtractor):
-        rows = [_row(row_id="R1", row_index=0, raw_score=95.0, score_1_5=4)]
-        ctx = extractor.extract(_checklist(rows), "p", "1")
-        assert ctx["rows"][0]["score_1_5"] == 4
-
-
-# ---------------------------------------------------------------------------
-# Integration: mixed realistic checklist
-# ---------------------------------------------------------------------------
-
-
-class TestMixedChecklist:
-    def test_realistic_mixed_checklist(self, extractor: ReadinessDataExtractor):
-        ref_long = EvidenceAnchor(ref_type="code_path", ref_value="src/main/java/com/vds/SecurityConfig.java")
-        rows = [
-            _row(
-                row_id="SEC-001",
-                row_index=0,
-                raw_score=95.0,
-                weight=10.0,
-                category="Security",
-                status=RowStatus.PASS,
-                evidence_refs=[ref_long],
-            ),
-            _row(
-                row_id="SEC-002",
-                row_index=1,
-                raw_score=15.0,
-                weight=8.0,
-                category="Security",
-                status=RowStatus.FAIL,
-                score_1_5=1,
-                finding="No SAST",
-            ),
-            _row(
-                row_id="DOC-001",
-                row_index=2,
-                raw_score=50.0,
-                weight=5.0,
-                category="Documentation",
-                status=RowStatus.PARTIAL,
-            ),
-            _row(row_id="OPS-001", row_index=3, raw_score=0.0, weight=3.0, category="Operations", status=RowStatus.NA),
-            _row(
-                row_id="OPS-002", row_index=4, raw_score=0.0, weight=2.0, category="Operations", status=RowStatus.ERROR
-            ),
-        ]
-        ctx = extractor.extract(_checklist(rows), "insurance-api", "3.0")
-
-        assert ctx["repo_name"] == "insurance-api"
-        assert ctx["total_rows"] == 5
-
-        # Weighted score: only SEC-001 (95*10), SEC-002 (15*8), DOC-001 (50*5) apply
-        # = (950 + 120 + 250) / (10 + 8 + 5) = 1320 / 23 = 57.39...
-        assert 57.0 < ctx["weighted_score_pct"] < 58.0
-
-        # Status distribution
-        dist = ctx["status_distribution"]
-        assert dist["PASS"] == 1
-        assert dist["FAIL"] == 1
-        assert dist["PARTIAL"] == 1
-        assert dist["N/A"] == 1
-        assert dist["ERROR"] == 1
-
-        # Severity candidates: SEC-002 has score_1_5=1 and weight_pct=8/23*100 ~ 34.8% > 3%
-        assert len(ctx["severity_candidates"]) >= 1
-        candidate_ids = {c["row_id"] for c in ctx["severity_candidates"]}
-        assert "SEC-002" in candidate_ids
-
-        # Heatmap should have Security and Documentation (Operations has NA and ERROR)
-        cats = {e["category"] for e in ctx["category_heatmap"]}
-        assert "Security" in cats
-        assert "Documentation" in cats