@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/test_engine/test_checklist_generator.py

@@ -1,1252 +0,0 @@
-"""Tests for ChecklistGenerator (TSK-180).
-
-Comprehensive test coverage for template-row checklist generation,
-ensuring strict 1:1 mapping and proper Vietnamese output.
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import pytest
-from openpyxl import load_workbook
-from vds_audit_orchestrator.engine.checklist_generator import (
-    ChecklistGenerator,
-    _compute_hash,
-    _compute_template_hash,
-    generate_checklist_from_result,
-    write_checklist_artifacts,
-)
-from vds_audit_orchestrator.engine.checklist_projection import (
-    base_locked_columns,
-    canonical_excel_columns,
-)
-from vds_audit_orchestrator.models.checklist import (
-    VERIFICATION_REASON_EXTRACTED_FROM_FINDING_EVIDENCE,
-    VERIFICATION_REASON_EXTRACTED_FROM_FINDING_EVIDENCE_DATA,
-    VERIFICATION_REASON_EXTRACTED_FROM_FINDING_EVIDENCE_REF,
-    AuditChecklist,
-    ChecklistExportConfig,
-    RowStatus,
-)
-from vds_audit_orchestrator.models.enums import (
-    CheckStatus,
-    Severity,
-)
-from vds_audit_orchestrator.models.findings import CheckFinding, RepositoryAuditResult, SectionResult
-from vds_audit_orchestrator.models.template import AuditCheck, AuditSection, AuditTemplate
-
-# =============================================================================
-# Fixtures
-# =============================================================================
-
-
-@pytest.fixture
-def sample_template() -> AuditTemplate:
-    """Create a sample audit template with multiple sections."""
-    return AuditTemplate(
-        name="Test Audit Template",
-        version="1.0.0",
-        sections=[
-            AuditSection(
-                id="security",
-                name="Security",
-                weight=60.0,
-                checks=[
-                    AuditCheck(
-                        id="SEC-001",
-                        description="Verify branch protection is enabled",
-                        max_points=100,
-                        weight=50.0,
-                        check_type="bitbucket_branch_permission",
-                        severity=Severity.HIGH,
-                    ),
-                    AuditCheck(
-                        id="SEC-002",
-                        description="Verify security scanning is configured",
-                        max_points=100,
-                        weight=50.0,
-                        check_type="git_file_exists",
-                        check_config={"path": ".github/workflows/security.yml"},
-                        severity=Severity.CRITICAL,
-                    ),
-                ],
-            ),
-            AuditSection(
-                id="documentation",
-                name="Documentation",
-                weight=40.0,
-                checks=[
-                    AuditCheck(
-                        id="DOC-001",
-                        description="Verify README exists and is complete",
-                        max_points=100,
-                        weight=60.0,
-                        check_type="llm_content_evaluation",
-                        severity=Severity.MEDIUM,
-                    ),
-                    AuditCheck(
-                        id="DOC-002",
-                        description="Verify API documentation exists",
-                        max_points=100,
-                        weight=40.0,
-                        check_type="git_file_exists",
-                        check_config={"path": "docs/api.md"},
-                        severity=Severity.LOW,
-                    ),
-                ],
-            ),
-        ],
-    )
-
-
-@pytest.fixture
-def sample_findings() -> list[CheckFinding]:
-    """Create sample findings matching the template checks."""
-    return [
-        CheckFinding(
-            check_id="SEC-001",
-            check_name="Branch Protection",
-            status=CheckStatus.PASSED,
-            severity=Severity.HIGH,
-            score_percentage=100.0,
-            points_awarded=100.0,
-            max_points=100,
-            execution_time_ms=0,
-            message="Branch protection is properly configured.",
-            evidence=["bitbucket://project/repo/settings/branch-permissions"],
-        ),
-        CheckFinding(
-            check_id="SEC-002",
-            check_name="Security Scanning",
-            status=CheckStatus.FAILED,
-            severity=Severity.CRITICAL,
-            score_percentage=0.0,
-            points_awarded=0.0,
-            max_points=100,
-            execution_time_ms=0,
-            message="Security scanning configuration file not found.",
-            recommendation="Add .github/workflows/security.yml with security scanning workflow.",
-        ),
-        CheckFinding(
-            check_id="DOC-001",
-            check_name="README Completeness",
-            status=CheckStatus.PARTIAL,
-            severity=Severity.MEDIUM,
-            score_percentage=60.0,
-            points_awarded=60.0,
-            max_points=100,
-            execution_time_ms=0,
-            message="README exists but is missing installation section.",
-            evidence=["README.md"],
-            confidence=0.85,
-        ),
-        CheckFinding(
-            check_id="DOC-002",
-            check_name="API Documentation",
-            status=CheckStatus.PASSED,
-            severity=Severity.LOW,
-            score_percentage=100.0,
-            points_awarded=100.0,
-            max_points=100,
-            execution_time_ms=0,
-            message="API documentation found at docs/api.md.",
-            evidence=["docs/api.md"],
-        ),
-    ]
-
-
-@pytest.fixture
-def sample_section_results(sample_findings: list[CheckFinding]) -> list[SectionResult]:
-    """Create section results from findings."""
-    security_findings = [f for f in sample_findings if f.check_id.startswith("SEC")]
-    doc_findings = [f for f in sample_findings if f.check_id.startswith("DOC")]
-
-    return [
-        SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=50.0,
-            weighted_contribution=30.0,
-            total_checks=2,
-            passed_checks=1,
-            failed_checks=1,
-            findings=security_findings,
-        ),
-        SectionResult(
-            section_id="documentation",
-            section_name="Documentation",
-            score_percentage=80.0,
-            weighted_contribution=32.0,
-            total_checks=2,
-            passed_checks=1,
-            findings=doc_findings,
-        ),
-    ]
-
-
-@pytest.fixture
-def sample_audit_result(sample_section_results: list[SectionResult]) -> RepositoryAuditResult:
-    """Create a complete audit result."""
-    return RepositoryAuditResult(
-        repo_name="test-repository",
-        project_key="TEST",
-        repo_url="https://bitbucket.org/vds/test-repository",
-        total_score=62.0,
-        grade="D",
-        sections=sample_section_results,
-        total_checks=4,
-        passed_checks=2,
-        failed_checks=2,
-        template_name="Test Audit Template",
-        template_version="1.0.0",
-        audit_metadata={"git_ref": "abc123"},
-    )
-
-
-@pytest.fixture
-def generator(sample_template: AuditTemplate) -> ChecklistGenerator:
-    """Create a checklist generator."""
-    return ChecklistGenerator(
-        template=sample_template,
-        row_llm_mode="selective",
-        protocol="anthropic",
-        model="claude-sonnet-4-20250514",
-    )
-
-
-# =============================================================================
-# Unit Tests: Hash Functions
-# =============================================================================
-
-
-class TestHashFunctions:
-    """Tests for hash computation functions."""
-
-    def test_compute_hash_string(self) -> None:
-        """Test hash computation for string input."""
-        hash1 = _compute_hash("test content")
-        hash2 = _compute_hash("test content")
-        hash3 = _compute_hash("different content")
-
-        assert len(hash1) == 16
-        assert hash1 == hash2
-        assert hash1 != hash3
-
-    def test_compute_hash_bytes(self) -> None:
-        """Test hash computation for bytes input."""
-        hash1 = _compute_hash(b"test content")
-        hash2 = _compute_hash("test content")
-
-        assert hash1 == hash2
-
-    def test_compute_template_hash(self, sample_template: AuditTemplate) -> None:
-        """Test template hash computation is deterministic."""
-        hash1 = _compute_template_hash(sample_template)
-        hash2 = _compute_template_hash(sample_template)
-
-        assert len(hash1) == 16
-        assert hash1 == hash2
-
-    def test_template_hash_changes_with_content(self, sample_template: AuditTemplate) -> None:
-        """Test that template hash changes when content changes."""
-        hash1 = _compute_template_hash(sample_template)
-
-        # Modify template
-        modified = AuditTemplate(
-            name=sample_template.name,
-            version="2.0.0",  # Changed version
-            sections=sample_template.sections,
-        )
-        hash2 = _compute_template_hash(modified)
-
-        assert hash1 != hash2
-
-
-# =============================================================================
-# Unit Tests: ChecklistGenerator Initialization
-# =============================================================================
-
-
-class TestChecklistGeneratorInit:
-    """Tests for ChecklistGenerator initialization."""
-
-    def test_init_with_template(self, sample_template: AuditTemplate) -> None:
-        """Test generator initialization with template."""
-        gen = ChecklistGenerator(sample_template)
-
-        assert gen.template == sample_template
-        assert gen.template_hash is not None
-        assert gen.row_llm_mode == "selective"
-        assert gen._template_row_count == 4
-
-    def test_init_with_custom_hash(self, sample_template: AuditTemplate) -> None:
-        """Test generator initialization with custom hash."""
-        custom_hash = "abcd1234abcd1234"
-        gen = ChecklistGenerator(sample_template, template_hash=custom_hash)
-
-        assert gen.template_hash == custom_hash
-
-    def test_init_with_llm_config(self, sample_template: AuditTemplate) -> None:
-        """Test generator initialization with LLM configuration."""
-        gen = ChecklistGenerator(
-            sample_template,
-            row_llm_mode="per-row",
-            protocol="openai",
-            model="gpt-4o",
-        )
-
-        assert gen.row_llm_mode == "per-row"
-        assert gen.protocol == "openai"
-        assert gen.model == "gpt-4o"
-
-    def test_check_lookup_built(self, generator: ChecklistGenerator) -> None:
-        """Test that check lookup is properly built."""
-        assert "SEC-001" in generator._check_lookup
-        assert "SEC-002" in generator._check_lookup
-        assert "DOC-001" in generator._check_lookup
-        assert "DOC-002" in generator._check_lookup
-
-        check, section_id = generator._check_lookup["SEC-001"]
-        assert check.id == "SEC-001"
-        assert section_id == "security"
-
-
-# =============================================================================
-# Unit Tests: Checklist Generation
-# =============================================================================
-
-
-class TestChecklistGeneration:
-    """Tests for checklist generation from audit results."""
-
-    def test_generate_creates_checklist(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test that generate_from_audit_result creates a checklist."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        assert isinstance(checklist, AuditChecklist)
-        assert checklist.repository == "test-repository"
-        assert checklist.template_name == "Test Audit Template"
-
-    def test_row_count_matches_template(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test strict 1:1 row mapping."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        # Should have exactly 4 rows (matching template)
-        assert checklist.total_rows == 4
-        assert checklist.template_row_count == 4
-        assert checklist.validate_row_count()
-
-    def test_row_order_preserved(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test that row order matches template order."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        # Check IDs should be in template order
-        check_ids = [row.check_id for row in checklist.rows]
-        assert check_ids == ["SEC-001", "SEC-002", "DOC-001", "DOC-002"]
-
-    def test_status_mapping(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test status mapping from findings."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        # SEC-001: PASSED -> PASS
-        assert checklist.rows[0].status == RowStatus.PASS
-        # SEC-002: FAILED -> FAIL
-        assert checklist.rows[1].status == RowStatus.FAIL
-        # DOC-001: PARTIAL -> PARTIAL (score 60)
-        assert checklist.rows[2].status == RowStatus.PARTIAL
-        # DOC-002: PASSED -> PASS
-        assert checklist.rows[3].status == RowStatus.PASS
-
-    def test_score_breakdown_computed(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test score breakdown is computed correctly."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        # Check SEC-001 score breakdown
-        row = checklist.rows[0]
-        assert row.score_breakdown.raw_score == 100.0
-        assert row.score_breakdown.final_score == 100.0
-        assert row.score_percent == 100.0
-
-        # Check DOC-001 score breakdown (confidence 0.85)
-        row = checklist.rows[2]
-        assert row.score_breakdown.raw_score == 60.0
-        assert row.score_breakdown.confidence_factor == 0.85
-        # final_score = 60.0 * 1.0 * 0.85 = 51.0
-        assert row.score_breakdown.final_score == pytest.approx(51.0, rel=0.01)
-
-    def test_vietnamese_status(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test Vietnamese status translation."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        assert checklist.rows[0].status_vietnamese == "ĐẠT"
-        assert checklist.rows[1].status_vietnamese == "KHÔNG ĐẠT"
-        assert checklist.rows[2].status_vietnamese == "MỘT PHẦN"
-
-    def test_score_1_5_computed(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test 1-5 score computation."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        # 100% -> 5
-        assert checklist.rows[0].score_1_5 == 5
-        # 0% -> 1
-        assert checklist.rows[1].score_1_5 == 1
-        # ~51% -> 3
-        assert checklist.rows[2].score_1_5 == 3
-        # 100% -> 5
-        assert checklist.rows[3].score_1_5 == 5
-
-    def test_provenance_recorded(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test provenance metadata is recorded."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        row = checklist.rows[0]
-        assert row.provenance.row_llm_mode == "selective"
-        assert row.provenance.protocol == "anthropic"
-        assert row.provenance.model == "claude-sonnet-4-20250514"
-        assert row.provenance.template_hash == generator.template_hash
-        assert row.provenance.evidence_hash is not None
-
-    def test_missing_finding_creates_error_row(
-        self,
-        sample_template: AuditTemplate,
-    ) -> None:
-        """Test that missing findings create ERROR rows."""
-        generator = ChecklistGenerator(sample_template)
-
-        # Create result with only some findings
-        result = RepositoryAuditResult(
-            repo_name="test-repo",
-            total_score=50.0,
-            grade="F",
-            sections=[
-                SectionResult(
-                    section_id="security",
-                    section_name="Security",
-                    score_percentage=50.0,
-                    weighted_contribution=30.0,
-                    total_checks=1,
-                    passed_checks=1,
-                    findings=[
-                        CheckFinding(
-                            check_id="SEC-001",
-                            check_name="Test",
-                            status=CheckStatus.PASSED,
-                            score_percentage=100.0,
-                            points_awarded=100.0,
-                            max_points=100,
-                            execution_time_ms=0,
-                        )
-                    ],
-                )
-            ],
-        )
-
-        checklist = generator.generate_from_audit_result(result)
-
-        # SEC-001 should be PASS
-        assert checklist.rows[0].status == RowStatus.PASS
-        # SEC-002, DOC-001, DOC-002 should be ERROR (no findings)
-        assert checklist.rows[1].status == RowStatus.ERROR
-        assert checklist.rows[2].status == RowStatus.ERROR
-        assert checklist.rows[3].status == RowStatus.ERROR
-
-
-# =============================================================================
-# Unit Tests: Summary Statistics
-# =============================================================================
-
-
-class TestChecklistSummary:
-    """Tests for checklist summary statistics."""
-
-    def test_status_counts(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test status count computation."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        assert checklist.pass_count == 2
-        assert checklist.partial_count == 1
-        assert checklist.fail_count == 1
-        assert checklist.na_count == 0
-        assert checklist.error_count == 0
-
-    def test_overall_score(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test overall score computation."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        # Overall score is weighted average of applicable rows
-        assert checklist.overall_score >= 0
-        assert checklist.overall_score <= 100
-
-    def test_overall_score_1_5(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test overall score on 1-5 scale."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        assert checklist.overall_score_1_5 >= 1.0
-        assert checklist.overall_score_1_5 <= 5.0
-
-    def test_get_failed_rows(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test get_failed_rows method."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        failed = checklist.get_failed_rows()
-        assert len(failed) == 2  # FAIL + PARTIAL
-
-        statuses = {row.status for row in failed}
-        assert RowStatus.FAIL in statuses
-        assert RowStatus.PARTIAL in statuses
-
-    def test_get_top_findings(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test get_top_findings method."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        top = checklist.get_top_findings(limit=5)
-        assert len(top) == 2  # Only 2 failed/partial rows
-
-        # FAIL should come before PARTIAL
-        assert top[0].status == RowStatus.FAIL
-
-    def test_get_section_summary(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test section summary generation."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        summary = checklist.get_section_summary()
-
-        assert "security" in summary
-        assert "documentation" in summary
-
-        security = summary["security"]
-        assert security["total_rows"] == 2
-        assert security["pass_count"] == 1
-        assert security["fail_count"] == 1
-
-
-# =============================================================================
-# Unit Tests: Evidence Anchoring
-# =============================================================================
-
-
-class TestEvidenceAnchoring:
-    """Tests for evidence anchor extraction."""
-
-    def test_evidence_from_finding(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test evidence extraction from finding.evidence list."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        # SEC-001 has evidence
-        row = checklist.rows[0]
-        assert len(row.evidence_refs) > 0
-
-    def test_evidence_from_finding_is_unverified_without_concrete_read(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Extracted finding evidence should not claim verified=true by default."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        row = checklist.rows[0]
-        assert row.evidence_refs
-        anchor = row.evidence_refs[0]
-        assert anchor.verified is False
-        assert anchor.verification_reason == VERIFICATION_REASON_EXTRACTED_FROM_FINDING_EVIDENCE
-
-    def test_evidence_ref_and_evidence_data_are_unverified_without_validation(
-        self,
-        generator: ChecklistGenerator,
-    ) -> None:
-        finding = CheckFinding(
-            check_id="SEC-099",
-            check_name="Synthetic finding",
-            status=CheckStatus.FAILED,
-            severity=Severity.HIGH,
-            score_percentage=0.0,
-            points_awarded=0.0,
-            max_points=100,
-            execution_time_ms=0,
-            message="Missing controls",
-            evidence=[],
-            evidence_ref="docs/runbook.md",
-            evidence_data={
-                "file_path": "src/main.py",
-                "confluence_url": "https://confluence.example.com/pages/123",
-                "excerpt": "Expected control excerpt",
-            },
-        )
-
-        anchors = generator._extract_evidence_anchors(
-            finding=finding,
-            evidence_bundle=None,
-            config=ChecklistExportConfig(max_evidence_refs=5),
-        )
-        reason_by_ref = {anchor.ref_value: anchor.verification_reason for anchor in anchors}
-
-        assert anchors
-        assert all(anchor.verified is False for anchor in anchors)
-        assert reason_by_ref["docs/runbook.md"] == VERIFICATION_REASON_EXTRACTED_FROM_FINDING_EVIDENCE_REF
-        assert reason_by_ref["src/main.py"] == VERIFICATION_REASON_EXTRACTED_FROM_FINDING_EVIDENCE_DATA
-        assert (
-            reason_by_ref["https://confluence.example.com/pages/123"]
-            == VERIFICATION_REASON_EXTRACTED_FROM_FINDING_EVIDENCE_DATA
-        )
-
-    def test_evidence_ref_type_inference(
-        self,
-        generator: ChecklistGenerator,
-    ) -> None:
-        """Test evidence reference type inference."""
-        assert generator._infer_ref_type("https://confluence.example.com/page") == "confluence_url"
-        assert generator._infer_ref_type("https://bitbucket.org/repo") == "bitbucket_url"
-        assert generator._infer_ref_type("https://jira.example.com/browse/TEST-1") == "jira_url"
-        assert generator._infer_ref_type("https://example.com/page") == "url"
-        assert generator._infer_ref_type("src/main.py") == "code_path"
-        assert generator._infer_ref_type("JIRA-123") == "jira_key"
-        assert generator._infer_ref_type("README.md") == "doc_path"
-
-    def test_evidence_refs_str_formatting(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test evidence_refs_str computed field."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-
-        row = checklist.rows[0]
-        refs_str = row.evidence_refs_str
-
-        # Should be newline-separated
-        assert isinstance(refs_str, str)
-
-
-# =============================================================================
-# Integration Tests: JSON Export
-# =============================================================================
-
-
-class TestJsonExport:
-    """Tests for JSON export functionality."""
-
-    def test_export_json_creates_file(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test JSON export creates file."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.json"
-
-        result_path = generator.export_json(checklist, output_path)
-
-        assert result_path.exists()
-        assert result_path == output_path
-
-    def test_export_json_valid_structure(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test JSON export has valid structure."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.json"
-
-        generator.export_json(checklist, output_path)
-
-        data = json.loads(output_path.read_text(encoding="utf-8"))
-
-        assert "checklist_version" in data
-        assert "template_name" in data
-        assert "repository" in data
-        assert "rows" in data
-        assert len(data["rows"]) == 4
-
-    def test_export_json_row_structure(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test JSON export row structure."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.json"
-
-        generator.export_json(checklist, output_path)
-
-        data = json.loads(output_path.read_text(encoding="utf-8"))
-        row = data["rows"][0]
-
-        # Required fields
-        assert "row_id" in row
-        assert "check_id" in row
-        assert "status" in row
-        assert "score_breakdown" in row
-        assert "reason" in row
-        assert "finding" in row
-        assert "provenance" in row
-
-
-# =============================================================================
-# Integration Tests: Excel Export
-# =============================================================================
-
-
-class TestExcelExport:
-    """Tests for Excel export functionality."""
-
-    def test_export_excel_creates_file(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test Excel export creates file."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.xlsx"
-
-        result_path = generator.export_excel(checklist, output_path)
-
-        assert result_path.exists()
-        assert result_path == output_path
-
-    def test_export_excel_has_sheets(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test Excel export has required sheets."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.xlsx"
-
-        generator.export_excel(checklist, output_path)
-
-        wb = load_workbook(output_path)
-        assert "Summary" in wb.sheetnames
-        assert "Checklist" in wb.sheetnames
-
-    def test_export_excel_row_count(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test Excel export has correct row count."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.xlsx"
-
-        generator.export_excel(checklist, output_path)
-
-        wb = load_workbook(output_path)
-        ws = wb["Checklist"]
-
-        # Header + 4 data rows
-        assert ws.max_row == 5
-
-    def test_export_excel_vietnamese_headers(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test Excel export has Vietnamese headers."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.xlsx"
-
-        generator.export_excel(checklist, output_path)
-
-        wb = load_workbook(output_path)
-        ws = wb["Checklist"]
-
-        headers = [cell.value for cell in ws[1]]
-        assert "Trạng thái" in headers
-        assert "Điểm (%)" in headers
-        assert "Lý do" in headers
-        assert "Phát hiện" in headers
-        assert "Minh chứng" in headers
-
-    def test_export_excel_base_five_columns_are_locked(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Base 5 columns must be immutable and ordered."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.xlsx"
-
-        generator.export_excel(checklist, output_path)
-
-        wb = load_workbook(output_path)
-        ws = wb["Checklist"]
-        headers = [cell.value for cell in ws[1]]
-        expected = [column.header for column in base_locked_columns()]
-        assert headers[:5] == expected
-
-    def test_export_excel_extended_columns_match_deterministic_profile(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Extended columns should match projection profile exactly."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.xlsx"
-
-        generator.export_excel(checklist, output_path)
-
-        wb = load_workbook(output_path)
-        ws = wb["Checklist"]
-        headers = [cell.value for cell in ws[1]]
-        expected = [column.header for column in canonical_excel_columns()]
-        assert headers == expected
-
-
-# =============================================================================
-# Integration Tests: Markdown Export
-# =============================================================================
-
-
-class TestMarkdownExport:
-    """Tests for Markdown export functionality."""
-
-    def test_export_markdown_creates_file(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test Markdown export creates file."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.md"
-
-        result_path = generator.export_markdown(checklist, output_path)
-
-        assert result_path.exists()
-        assert result_path == output_path
-
-    def test_export_markdown_has_sections(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test Markdown export has required sections."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.md"
-
-        generator.export_markdown(checklist, output_path)
-
-        content = output_path.read_text(encoding="utf-8")
-
-        assert "# Audit Checklist:" in content
-        assert "## Summary" in content
-        assert "## Top Findings" in content
-        assert "## Detailed Results" in content
-        assert "## Provenance" in content
-
-    def test_export_markdown_has_table(
-        self,
-        generator: ChecklistGenerator,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test Markdown export has results table."""
-        checklist = generator.generate_from_audit_result(sample_audit_result)
-        output_path = tmp_path / "audit-checklist.md"
-
-        generator.export_markdown(checklist, output_path)
-
-        content = output_path.read_text(encoding="utf-8")
-
-        # Table headers
-        assert "| # |" in content
-        assert "| Status |" in content
-        assert "| Check ID |" in content
-
-
-# =============================================================================
-# Integration Tests: Convenience Functions
-# =============================================================================
-
-
-class TestConvenienceFunctions:
-    """Tests for convenience functions."""
-
-    def test_generate_checklist_from_result(
-        self,
-        sample_template: AuditTemplate,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Test generate_checklist_from_result function."""
-        checklist = generate_checklist_from_result(
-            sample_template,
-            sample_audit_result,
-            row_llm_mode="off",
-        )
-
-        assert isinstance(checklist, AuditChecklist)
-        assert checklist.total_rows == 4
-        assert checklist.row_llm_mode == "off"
-
-    def test_generate_checklist_from_result_applies_profile_multipliers(
-        self,
-        sample_template: AuditTemplate,
-        sample_audit_result: RepositoryAuditResult,
-    ) -> None:
-        """Profile multipliers from result.profile_info should be applied."""
-        result_with_profile = sample_audit_result.model_copy(
-            update={
-                "profile_info": {
-                    "weight_overrides": {
-                        "check_multipliers": {
-                            "SEC-001": 2.0,
-                        }
-                    }
-                }
-            }
-        )
-
-        checklist = generate_checklist_from_result(sample_template, result_with_profile)
-
-        row = next(item for item in checklist.rows if item.check_id == "SEC-001")
-        assert row.weight_raw == 50.0
-        assert row.weight_adjusted == 100.0
-        assert row.weight_adjustment_reason == "profile_multiplier:check_id=SEC-001"
-
-    def test_write_checklist_artifacts(
-        self,
-        sample_template: AuditTemplate,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test write_checklist_artifacts function."""
-        checklist = generate_checklist_from_result(sample_template, sample_audit_result)
-
-        written = write_checklist_artifacts(
-            checklist,
-            tmp_path,
-            template=sample_template,
-            include_markdown=True,
-        )
-
-        assert "json" in written
-        assert "xlsx" in written
-        assert "md" in written
-        assert "meta" in written
-
-        assert written["json"].exists()
-        assert written["xlsx"].exists()
-        assert written["md"].exists()
-        assert written["meta"].exists()
-
-        payload = json.loads(written["meta"].read_text(encoding="utf-8"))
-        assert payload["projection_profile_version"]
-        assert payload["base_locked_columns"] == [{"header": c.header, "key": c.key} for c in base_locked_columns()]
-
-    def test_write_checklist_artifacts_without_markdown(
-        self,
-        sample_template: AuditTemplate,
-        sample_audit_result: RepositoryAuditResult,
-        tmp_path: Path,
-    ) -> None:
-        """Test write_checklist_artifacts without Markdown."""
-        checklist = generate_checklist_from_result(sample_template, sample_audit_result)
-
-        written = write_checklist_artifacts(
-            checklist,
-            tmp_path,
-            template=sample_template,
-            include_markdown=False,
-        )
-
-        assert "json" in written
-        assert "xlsx" in written
-        assert "meta" in written
-        assert "md" not in written
-
-
-# =============================================================================
-# Edge Case Tests
-# =============================================================================
-
-
-class TestEdgeCases:
-    """Tests for edge cases."""
-
-    def test_empty_template(self) -> None:
-        """Test generator with empty template."""
-        template = AuditTemplate(
-            name="Empty Template",
-            version="1.0.0",
-            sections=[],
-        )
-        generator = ChecklistGenerator(template)
-
-        result = RepositoryAuditResult(
-            repo_name="test",
-            total_score=0.0,
-            grade="F",
-            sections=[],
-        )
-
-        checklist = generator.generate_from_audit_result(result)
-
-        assert checklist.total_rows == 0
-        assert checklist.validate_row_count()
-
-    def test_na_status_handling(
-        self,
-        sample_template: AuditTemplate,
-    ) -> None:
-        """Test N/A status handling."""
-        generator = ChecklistGenerator(sample_template)
-
-        result = RepositoryAuditResult(
-            repo_name="test",
-            total_score=100.0,
-            grade="A",
-            sections=[
-                SectionResult(
-                    section_id="security",
-                    section_name="Security",
-                    score_percentage=100.0,
-                    weighted_contribution=60.0,
-                    total_checks=2,
-                    na_checks=1,
-                    passed_checks=1,
-                    findings=[
-                        CheckFinding(
-                            check_id="SEC-001",
-                            check_name="Test",
-                            status=CheckStatus.PASSED,
-                            score_percentage=100.0,
-                            points_awarded=100.0,
-                            max_points=100,
-                            execution_time_ms=0,
-                        ),
-                        CheckFinding(
-                            check_id="SEC-002",
-                            check_name="Test",
-                            status=CheckStatus.NOT_APPLICABLE,
-                            score_percentage=0.0,
-                            points_awarded=0.0,
-                            max_points=100,
-                            execution_time_ms=0,
-                        ),
-                    ],
-                )
-            ],
-        )
-
-        checklist = generator.generate_from_audit_result(result)
-
-        # Find NA row
-        na_rows = checklist.get_rows_by_status(RowStatus.NA)
-        assert len(na_rows) == 1
-        assert na_rows[0].status_vietnamese == "KHÔNG ÁP DỤNG"
-
-    def test_error_status_handling(
-        self,
-        sample_template: AuditTemplate,
-    ) -> None:
-        """Test ERROR status handling."""
-        generator = ChecklistGenerator(sample_template)
-
-        result = RepositoryAuditResult(
-            repo_name="test",
-            total_score=50.0,
-            grade="F",
-            sections=[
-                SectionResult(
-                    section_id="security",
-                    section_name="Security",
-                    score_percentage=50.0,
-                    weighted_contribution=30.0,
-                    total_checks=2,
-                    error_checks=1,
-                    passed_checks=1,
-                    findings=[
-                        CheckFinding(
-                            check_id="SEC-001",
-                            check_name="Test",
-                            status=CheckStatus.PASSED,
-                            score_percentage=100.0,
-                            points_awarded=100.0,
-                            max_points=100,
-                            execution_time_ms=0,
-                        ),
-                        CheckFinding(
-                            check_id="SEC-002",
-                            check_name="Test",
-                            status=CheckStatus.ERROR,
-                            score_percentage=0.0,
-                            points_awarded=0.0,
-                            max_points=100,
-                            execution_time_ms=0,
-                            error_message="Connection timeout",
-                        ),
-                    ],
-                )
-            ],
-        )
-
-        checklist = generator.generate_from_audit_result(result)
-
-        # Find ERROR row
-        error_rows = checklist.get_rows_by_status(RowStatus.ERROR)
-        assert len(error_rows) >= 1  # At least the one with ERROR status
-        assert error_rows[0].status_vietnamese == "LỖI"
-
-    def test_special_characters_in_text(
-        self,
-        generator: ChecklistGenerator,
-        tmp_path: Path,
-    ) -> None:
-        """Test handling of special characters in text fields."""
-        # Create finding with special characters
-        finding = CheckFinding(
-            check_id="SEC-001",
-            check_name="Test Check",
-            status=CheckStatus.PASSED,
-            score_percentage=100.0,
-            points_awarded=100.0,
-            max_points=100,
-            execution_time_ms=0,
-            message="Test with special chars: <>&\"'",
-            evidence=["path/with spaces/file.txt"],
-        )
-
-        result = RepositoryAuditResult(
-            repo_name="test-repo",
-            total_score=100.0,
-            grade="A",
-            sections=[
-                SectionResult(
-                    section_id="security",
-                    section_name="Security",
-                    score_percentage=100.0,
-                    weighted_contribution=60.0,
-                    total_checks=1,
-                    passed_checks=1,
-                    findings=[finding],
-                )
-            ],
-        )
-
-        checklist = generator.generate_from_audit_result(result)
-
-        # Export to all formats - should not raise
-        generator.export_json(checklist, tmp_path / "checklist.json")
-        generator.export_excel(checklist, tmp_path / "checklist.xlsx")
-        generator.export_markdown(checklist, tmp_path / "checklist.md")
-
-        # Verify files exist
-        assert (tmp_path / "checklist.json").exists()
-        assert (tmp_path / "checklist.xlsx").exists()
-        assert (tmp_path / "checklist.md").exists()
-
-    def test_long_text_truncation(
-        self,
-        sample_template: AuditTemplate,
-        tmp_path: Path,
-    ) -> None:
-        """Test handling of very long text in exports."""
-        generator = ChecklistGenerator(sample_template)
-
-        long_text = "A" * 5000  # Very long text
-
-        finding = CheckFinding(
-            check_id="SEC-001",
-            check_name="Test",
-            status=CheckStatus.PARTIAL,
-            score_percentage=60.0,
-            message=long_text,
-            recommendation=long_text,
-        )
-
-        result = RepositoryAuditResult(
-            repo_name="test",
-            total_score=60.0,
-            grade="D",
-            sections=[
-                SectionResult(
-                    section_id="security",
-                    section_name="Security",
-                    score_percentage=60.0,
-                    weighted_contribution=36.0,
-                    total_checks=1,
-                    findings=[finding],
-                )
-            ],
-        )
-
-        checklist = generator.generate_from_audit_result(result)
-
-        # Markdown should truncate in table
-        md_path = tmp_path / "checklist.md"
-        generator.export_markdown(checklist, md_path)
-
-        content = md_path.read_text(encoding="utf-8")
-        # Tables should have truncated content
-        assert "..." in content