@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/unit/cli/test_workflow_cli.py

@@ -1,123 +0,0 @@
-"""Phase 172 P172-E — tests for _parse_evidence_overrides (TSK-172.28/172.29)."""
-
-from __future__ import annotations
-
-import pytest
-import typer
-from vds_audit_orchestrator.workflow_cmds import _parse_evidence_overrides
-
-
-class TestParseEvidenceOverrides:
-    """TSK-172.29: _parse_evidence_overrides parses override strings into threshold dicts."""
-
-    def test_single_valid_entry_returns_correct_dict(self) -> None:
-        result = _parse_evidence_overrides(["1. decoupling:7:4"])
-        assert result == {"1. decoupling": {"min_evidence_refs": 7, "min_search_patterns": 4}}
-
-    def test_multiple_entries_all_parsed(self) -> None:
-        result = _parse_evidence_overrides(
-            [
-                "1. decoupling:7:4",
-                "2. dependency management:5:3",
-            ]
-        )
-        assert result == {
-            "1. decoupling": {"min_evidence_refs": 7, "min_search_patterns": 4},
-            "2. dependency management": {"min_evidence_refs": 5, "min_search_patterns": 3},
-        }
-
-    def test_empty_list_returns_empty_dict(self) -> None:
-        assert _parse_evidence_overrides([]) == {}
-
-    def test_key_is_lowercased(self) -> None:
-        result = _parse_evidence_overrides(["1. Decoupling:5:3"])
-        assert "1. decoupling" in result
-
-    def test_key_is_stripped(self) -> None:
-        result = _parse_evidence_overrides(["  1. decoupling  :5:3"])
-        assert "1. decoupling" in result
-
-    def test_raises_on_too_few_parts(self) -> None:
-        with pytest.raises(typer.BadParameter, match="expected"):
-            _parse_evidence_overrides(["1. decoupling:7"])
-
-    def test_raises_on_non_integer_threshold(self) -> None:
-        with pytest.raises(typer.BadParameter, match="integers"):
-            _parse_evidence_overrides(["1. decoupling:seven:4"])
-
-    def test_raises_on_zero_threshold(self) -> None:
-        with pytest.raises(typer.BadParameter, match="≥ 1"):
-            _parse_evidence_overrides(["1. decoupling:0:4"])
-
-    def test_raises_on_empty_objective(self) -> None:
-        with pytest.raises(typer.BadParameter, match="empty"):
-            _parse_evidence_overrides([":5:3"])
-
-
-# ---------------------------------------------------------------------------
-# TSK-172.30 — override threading: RowEvaluatorConfig → AgentLoopConfig → context
-# ---------------------------------------------------------------------------
-
-
-class TestEvidenceOverrideThreading:
-    """TSK-172.30: evidence_overrides flows from RowEvaluatorConfig through to lookup_evidence_requirements."""
-
-    def test_lookup_merges_overrides_for_matching_objective(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        """lookup_evidence_requirements merges override values on top of built-in table."""
-        monkeypatch.setenv("VDS_AUDIT_EVIDENCE_GATE_P172", "1")
-        from vds_audit_orchestrator.engine.tool_first_planner import lookup_evidence_requirements
-
-        overrides = {"1. decoupling": {"min_evidence_refs": 7, "min_search_patterns": 4}}
-        result = lookup_evidence_requirements("1. Decoupling", overrides=overrides)
-        assert result["min_evidence_refs"] == 7
-        assert result["min_search_patterns"] == 4
-
-    def test_lookup_ignores_overrides_for_nonmatching_objective(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        """Overrides for a different objective do not affect other objectives."""
-        monkeypatch.setenv("VDS_AUDIT_EVIDENCE_GATE_P172", "1")
-        from vds_audit_orchestrator.engine.tool_first_planner import (
-            DEFAULT_EVIDENCE_REQUIREMENTS,
-            lookup_evidence_requirements,
-        )
-
-        overrides = {"3. performance": {"min_evidence_refs": 10, "min_search_patterns": 5}}
-        result = lookup_evidence_requirements("1. Decoupling", overrides=overrides)
-        # Should use built-in table, not the unrelated override
-        assert result is not DEFAULT_EVIDENCE_REQUIREMENTS
-        assert result["min_evidence_refs"] == 5  # built-in for decoupling
-
-    def test_agent_loop_injects_overrides_into_context(self) -> None:
-        """AgentLoopConfig.evidence_overrides is injected into context as _evidence_overrides."""
-        from unittest.mock import MagicMock
-
-        from vds_agent_core.agents.loop import AgentLoopConfig, BoundedAgentLoop
-
-        overrides = {"1. decoupling": {"min_evidence_refs": 7, "min_search_patterns": 4}}
-        cfg = AgentLoopConfig(
-            max_steps=1,
-            timeout_seconds=5.0,
-            budget_units=10,
-            tool_calls_limit=5,
-            evidence_overrides=overrides,
-        )
-        captured_context: dict = {}
-
-        def _planner(step_number: int, context: dict, trace: list) -> None:  # type: ignore[return]
-            captured_context.update(context)
-
-        registry = MagicMock()  # bare mock — planner returns None so registry never called
-        loop = BoundedAgentLoop(registry=registry, config=cfg, planner=_planner)
-        loop.run(initial_context={"row_id": "CL-001:row_1"})
-
-        assert captured_context.get("_evidence_overrides") == overrides
-
-    def test_row_evaluator_config_has_evidence_overrides_field(self) -> None:
-        """RowEvaluatorConfig accepts evidence_overrides and defaults to empty dict."""
-        from vds_audit_orchestrator.engine.row_evaluator_types import RowEvaluatorConfig
-
-        default = RowEvaluatorConfig()
-        assert default.evidence_overrides == {}
-
-        overrides = {"1. decoupling": {"min_evidence_refs": 7, "min_search_patterns": 4}}
-        cfg = RowEvaluatorConfig(evidence_overrides=overrides)
-        assert cfg.evidence_overrides == overrides

package/tools/vds-scripts/audit_orchestrator/tests/unit/collectors/test_cache_guard.py

@@ -1,479 +0,0 @@
-"""Unit tests for Cache Guard optimization (Phase 126, Package D).
-
-Tests for:
-- TSK-126.12: BitbucketMaterialDownloader freshness integration
-- TSK-126.13: Confluence materialization flow freshness integration
-- TSK-126.14: Cache diagnostics fetch_reason tagging
-
-Reference: .kiro/specs/audit-orchestrator/requirements.md FR-126.1
-"""
-
-from __future__ import annotations
-
-from datetime import UTC, datetime, timedelta
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from vds_audit_orchestrator.collectors.bitbucket_downloader import BitbucketMaterialDownloader
-from vds_audit_orchestrator.collectors.material_cache import MaterialCache
-
-# ---------------------------------------------------------------------------
-# TSK-126.12: BitbucketMaterialDownloader freshness integration
-# ---------------------------------------------------------------------------
-
-
-class TestBitbucketFreshnessIntegration:
-    """Tests for BitbucketMaterialDownloader freshness checking (TSK-126.12)."""
-
-    @pytest.fixture
-    def mock_client(self):
-        """Create a mock BitbucketCliClient."""
-        client = MagicMock()
-        client.get_commits = AsyncMock()
-        client.get_default_branch = AsyncMock()
-        client.get_file_content = AsyncMock()
-        return client
-
-    @pytest.fixture
-    def downloader(self, mock_client):
-        """Create a BitbucketMaterialDownloader with mock client."""
-        return BitbucketMaterialDownloader(mock_client)
-
-    @pytest.mark.asyncio
-    async def test_check_freshness_skips_download_when_unchanged(self, downloader, mock_client, tmp_path):
-        """Should skip download and return cached entry when remote unchanged."""
-        project = "PAR"
-        repo = "merchant-report"
-        cached_commit_sha = "abc123def456"
-        current_commit_sha = "abc123def456"  # Same = unchanged
-
-        # Mock the freshness check to return unchanged
-        mock_client.get_commits.return_value = [{"id": current_commit_sha, "author": {"displayName": "Test User"}}]
-        mock_client.get_default_branch.return_value = {"id": "refs/heads/main"}
-
-        # Create cached entry
-        cached_file = tmp_path / "README.md"
-        cached_file.write_text("# Cached README", encoding="utf-8")
-        cached_sha256 = downloader._file_sha256(cached_file)
-
-        cached_entry = {
-            "project": project,
-            "repo": repo,
-            "file": "README.md",
-            "path": str(cached_file),
-            "sha256": cached_sha256,
-            "default_branch": "main",
-            "default_branch_ref": "refs/heads/main",
-            "last_commit": {"id": cached_commit_sha},
-            "status": "found",
-        }
-
-        # Call _download_readme with cached entry
-        result = await downloader._download_readme(
-            project, repo, tmp_path, cached=cached_entry, sync_policy="if-changed"
-        )
-
-        # Should return cached with fetch_reason indicating cache hit
-        assert result["cached"] is True
-        assert result["fetch_reason"] == "cache_hit_remote_unchanged"
-        assert result["status"] == "not_modified"
-        assert "freshness" in result
-        assert "hours_since_commit" in result
-
-    @pytest.mark.asyncio
-    async def test_check_freshness_proceeds_when_changed(self, downloader, mock_client, tmp_path):
-        """Should proceed with download when remote commit changed."""
-        project = "PAR"
-        repo = "merchant-report"
-        cached_commit_sha = "abc123def456"
-        current_commit_sha = "xyz789new123"  # Different = changed
-
-        # Mock the API calls
-        mock_client.get_commits.return_value = [{"id": current_commit_sha, "author": {"displayName": "Test User"}}]
-        mock_client.get_default_branch.return_value = {"id": "refs/heads/main"}
-        mock_client.get_file_content.return_value = "# Updated README\n"
-
-        # Create cached entry
-        cached_file = tmp_path / "README.md"
-        cached_file.write_text("# Old README", encoding="utf-8")
-        cached_sha256 = downloader._file_sha256(cached_file)
-
-        cached_entry = {
-            "project": project,
-            "repo": repo,
-            "file": "README.md",
-            "path": str(cached_file),
-            "sha256": cached_sha256,
-            "default_branch": "main",
-            "default_branch_ref": "refs/heads/main",
-            "last_commit": {"id": cached_commit_sha},
-            "status": "found",
-        }
-
-        # Call _download_readme with cached entry
-        result = await downloader._download_readme(
-            project, repo, tmp_path, cached=cached_entry, sync_policy="if-changed"
-        )
-
-        # Should download fresh content
-        assert result["status"] == "found"
-        assert result["fetch_reason"] == "signal_refresh_bitbucket_commit_changed"
-
-    def test_determine_fetch_reason_signal_refresh(self, downloader):
-        """Should return signal_refresh when token changed."""
-        reason = downloader._determine_fetch_reason(
-            policy="if-changed",
-            token_before="main:abc123",
-            token_after="main:xyz789",
-            fresh_check_result={"changed": True},
-            status="found",
-        )
-        assert reason == "signal_refresh_bitbucket_commit_changed"
-
-    def test_determine_fetch_reason_fresh_download(self, downloader):
-        """Should return fresh_download when no cache."""
-        reason = downloader._determine_fetch_reason(
-            policy="if-changed",
-            token_before=None,
-            token_after=None,
-            fresh_check_result=None,
-            status="found",
-        )
-        assert reason == "fresh_download_no_cache"
-
-    def test_determine_fetch_reason_force_refresh(self, downloader):
-        """Should return force_refresh reason."""
-        reason = downloader._determine_fetch_reason(
-            policy="force-refresh",
-            token_before="main:abc123",
-            token_after="main:xyz789",
-            fresh_check_result=None,
-            status="found",
-        )
-        assert reason == "fresh_download_force_refresh"
-
-
-# ---------------------------------------------------------------------------
-# TSK-126.13: Confluence materialization flow freshness integration
-# ---------------------------------------------------------------------------
-
-
-class TestConfluenceFreshnessIntegration:
-    """Tests for Confluence materialization freshness (TSK-126.13)."""
-
-    def test_determine_page_fetch_reason_signal_refresh(self):
-        """Should return signal_refresh when version probe indicates change."""
-        from vds_audit_orchestrator.collectors.material_downloader import MaterialDownloader
-
-        # Create a minimal downloader (no actual client needed for this test)
-        downloader = MaterialDownloader(
-            client=MagicMock(),
-            converter=MagicMock(),
-        )
-
-        reason = downloader._determine_page_fetch_reason(
-            policy="if-changed",
-            probe_available=True,
-            cached_token="5",
-            probe_token="6",  # Changed
-            status="found",
-        )
-        assert reason == "signal_refresh_confluence_version_changed"
-
-    def test_determine_page_fetch_reason_cache_hit(self):
-        """Should return downloaded when versions match (no change)."""
-        from vds_audit_orchestrator.collectors.material_downloader import MaterialDownloader
-
-        downloader = MaterialDownloader(
-            client=MagicMock(),
-            converter=MagicMock(),
-        )
-
-        reason = downloader._determine_page_fetch_reason(
-            policy="if-changed",
-            probe_available=True,
-            cached_token="5",
-            probe_token="5",  # Same
-            status="found",
-        )
-        assert reason == "confluence_page_downloaded"
-
-    def test_determine_attachment_fetch_reason_signal_refresh(self):
-        """Should return signal_refresh for attachments when version changed."""
-        from vds_audit_orchestrator.collectors.material_downloader import MaterialDownloader
-
-        downloader = MaterialDownloader(
-            client=MagicMock(),
-            converter=MagicMock(),
-        )
-
-        reason = downloader._determine_attachment_fetch_reason(
-            policy="if-changed",
-            cached_token="3:1024",
-            probe_token="4:2048",  # Changed
-            status="found",
-        )
-        assert reason == "signal_refresh_attachment_version_changed"
-
-
-# ---------------------------------------------------------------------------
-# TSK-126.14: Cache diagnostics fetch_reason tagging
-# ---------------------------------------------------------------------------
-
-
-class TestMaterialCacheFetchReasonDiagnostics:
-    """Tests for fetch_reason tracking in cache diagnostics (TSK-126.14)."""
-
-    def test_empty_diagnostics_includes_fetch_reason_counters(self, tmp_path):
-        """Empty diagnostics should include new fetch reason counters."""
-        cache = MaterialCache(cache_dir=tmp_path)
-        diags = cache.get_diagnostics()
-
-        assert "fetch_cache_hit" in diags
-        assert "fetch_signal_refresh" in diags
-        assert "fetch_fresh_download" in diags
-        assert diags["fetch_cache_hit"] == 0
-        assert diags["fetch_signal_refresh"] == 0
-        assert diags["fetch_fresh_download"] == 0
-
-    def test_track_fetch_reason_cache_hit(self, tmp_path):
-        """Should increment cache_hit counter when tracking cache_hit."""
-        cache = MaterialCache(cache_dir=tmp_path)
-
-        cache._track_fetch_reason("cache_hit")
-        diags = cache.get_diagnostics()
-
-        assert diags["fetch_cache_hit"] == 1
-        assert diags["fetch_signal_refresh"] == 0
-        assert diags["fetch_fresh_download"] == 0
-
-    def test_track_fetch_reason_signal_refresh(self, tmp_path):
-        """Should increment signal_refresh counter when tracking signal_refresh."""
-        cache = MaterialCache(cache_dir=tmp_path)
-
-        cache._track_fetch_reason("signal_refresh")
-        diags = cache.get_diagnostics()
-
-        assert diags["fetch_cache_hit"] == 0
-        assert diags["fetch_signal_refresh"] == 1
-        assert diags["fetch_fresh_download"] == 0
-
-    def test_track_fetch_reason_fresh_download(self, tmp_path):
-        """Should increment fresh_download counter when tracking fresh_download."""
-        cache = MaterialCache(cache_dir=tmp_path)
-
-        cache._track_fetch_reason("fresh_download")
-        diags = cache.get_diagnostics()
-
-        assert diags["fetch_cache_hit"] == 0
-        assert diags["fetch_signal_refresh"] == 0
-        assert diags["fetch_fresh_download"] == 1
-
-    def test_infer_fetch_reason_from_not_modified_entry(self, tmp_path):
-        """Should infer cache_hit from not_modified status."""
-        cache = MaterialCache(cache_dir=tmp_path)
-
-        entry = {
-            "status": "not_modified",
-            "cached_at": datetime.now(UTC).isoformat(),
-        }
-
-        reason = cache._infer_fetch_reason_from_entry(entry)
-        assert reason == "cache_hit"
-
-    def test_infer_fetch_reason_from_version_match(self, tmp_path):
-        """Should infer cache_hit from version_match fetch_reason."""
-        cache = MaterialCache(cache_dir=tmp_path)
-
-        entry = {
-            "status": "found",
-            "fetch_reason": "confluence_page_version_match",
-            "cached_at": datetime.now(UTC).isoformat(),
-        }
-
-        reason = cache._infer_fetch_reason_from_entry(entry)
-        assert reason == "cache_hit"
-
-    def test_infer_fetch_reason_from_changed(self, tmp_path):
-        """Should infer signal_refresh from changed fetch_reason."""
-        cache = MaterialCache(cache_dir=tmp_path)
-
-        entry = {
-            "status": "found",
-            "fetch_reason": "confluence_page_version_changed",
-            "cached_at": datetime.now(UTC).isoformat(),
-        }
-
-        reason = cache._infer_fetch_reason_from_entry(entry)
-        assert reason == "signal_refresh"
-
-    def test_infer_fetch_reason_from_age_fresh(self, tmp_path):
-        """Should infer cache_hit for fresh entries (within TTL)."""
-        cache = MaterialCache(cache_dir=tmp_path, ttl_hours=24)
-
-        entry = {
-            "status": "found",
-            "cached_at": (datetime.now(UTC) - timedelta(hours=2)).isoformat(),
-        }
-
-        reason = cache._infer_fetch_reason_from_entry(entry)
-        assert reason == "cache_hit"
-
-    def test_infer_fetch_reason_from_age_stale(self, tmp_path):
-        """Should infer signal_refresh for stale entries (past TTL)."""
-        cache = MaterialCache(cache_dir=tmp_path, ttl_hours=24)
-
-        entry = {
-            "status": "found",
-            "cached_at": (datetime.now(UTC) - timedelta(hours=30)).isoformat(),
-        }
-
-        reason = cache._infer_fetch_reason_from_entry(entry)
-        assert reason == "signal_refresh"
-
-    def test_materialize_page_includes_fetch_reason(self, tmp_path):
-        """materialize_page() should include fetch_reason in output."""
-        cache = MaterialCache(cache_dir=tmp_path, ttl_hours=24)
-        output_dir = tmp_path / "output"
-        output_dir.mkdir(exist_ok=True)
-
-        # Setup: create a valid cached page entry with actual file
-        page_id = "12345"
-        project_key = "CEP"
-        now = datetime.now(UTC)
-
-        html_content = b"<html><body>Test</body></html>"
-        # Use the cache_dir for the cached file
-        html_cache_path = tmp_path / "pages" / "CEP" / page_id / "page.html"
-        html_cache_path.parent.mkdir(parents=True, exist_ok=True)
-        html_cache_path.write_bytes(html_content)
-        html_sha256 = cache._file_sha256(html_cache_path)
-
-        cache._manifest.setdefault("pages", {})
-        cache._manifest["pages"][cache._page_cache_key(page_id, project_key)] = {
-            "page_id": page_id,
-            "title": "Test Page",
-            "status": "found",
-            "cached_at": now.isoformat(),
-            "cache_paths": {
-                "html": f"pages/CEP/{page_id}/page.html",
-            },
-            "hashes": {
-                "html_sha256": html_sha256,
-            },
-            "sizes": {
-                "html_size_bytes": len(html_content),
-            },
-            "namespace": {
-                "kind": "confluence",
-                "project_key": project_key,
-            },
-        }
-
-        result = cache.materialize_page(page_id, output_dir, project_key=project_key)
-
-        # Verify fetch_reason is present
-        assert result is not None
-        assert "fetch_reason" in result
-        assert result["fetch_reason"] in ("cache_hit", "signal_refresh")
-
-    def test_materialize_bitbucket_includes_fetch_reason(self, tmp_path):
-        """materialize_bitbucket() should include fetch_reason in output."""
-        cache = MaterialCache(cache_dir=tmp_path, ttl_hours=24)
-        output_dir = tmp_path / "output"
-        output_dir.mkdir(exist_ok=True)
-
-        # Setup: create a valid cached bitbucket entry with actual file
-        project_key = "PAR"
-        repo = "merchant-report"
-        now = datetime.now(UTC)
-
-        readme_content = b"# README"
-        # Use the cache_dir for the cached file
-        readme_cache_path = tmp_path / "bitbucket" / project_key / repo / "README.md"
-        readme_cache_path.parent.mkdir(parents=True, exist_ok=True)
-        readme_cache_path.write_bytes(readme_content)
-        readme_sha256 = cache._file_sha256(readme_cache_path)
-
-        cache._manifest.setdefault("bitbucket", {})
-        cache._manifest["bitbucket"][f"{project_key}/{repo}/README.md"] = {
-            "project": project_key,
-            "repo": repo,
-            "file": "README.md",
-            "status": "found",
-            "cached_at": now.isoformat(),
-            "cache_paths": {
-                "file": f"bitbucket/{project_key}/{repo}/README.md",
-            },
-            "hashes": {
-                "file_sha256": readme_sha256,
-            },
-            "default_branch": "main",
-        }
-
-        results = cache.materialize_bitbucket(project_key, output_dir)
-
-        # Should have one result
-        assert len(results) > 0
-        result = results[0]
-
-        # Verify fetch_reason is present
-        assert "fetch_reason" in result
-        assert result["fetch_reason"] in ("cache_hit", "signal_refresh")
-
-
-# ---------------------------------------------------------------------------
-# Integration tests
-# ---------------------------------------------------------------------------
-
-
-class TestCacheGuardIntegration:
-    """Integration tests for cache guard optimization."""
-
-    def test_full_fetch_reason_tracking_flow(self, tmp_path):
-        """Test complete flow from cache hit to signal refresh to fresh download."""
-        cache = MaterialCache(cache_dir=tmp_path, ttl_hours=24)
-
-        # Start with empty diagnostics
-        assert cache.get_diagnostics()["fetch_cache_hit"] == 0
-        assert cache.get_diagnostics()["fetch_signal_refresh"] == 0
-        assert cache.get_diagnostics()["fetch_fresh_download"] == 0
-
-        # Simulate cache hit
-        cache._track_fetch_reason("cache_hit")
-        assert cache.get_diagnostics()["fetch_cache_hit"] == 1
-
-        # Simulate signal refresh
-        cache._track_fetch_reason("signal_refresh")
-        assert cache.get_diagnostics()["fetch_signal_refresh"] == 1
-
-        # Simulate fresh download
-        cache._track_fetch_reason("fresh_download")
-        assert cache.get_diagnostics()["fetch_fresh_download"] == 1
-
-        # Verify total counts
-        total_fetches = (
-            cache.get_diagnostics()["fetch_cache_hit"]
-            + cache.get_diagnostics()["fetch_signal_refresh"]
-            + cache.get_diagnostics()["fetch_fresh_download"]
-        )
-        assert total_fetches == 3
-
-    def test_diagnostics_reset(self, tmp_path):
-        """reset_diagnostics() should clear all counters including fetch_reason."""
-        cache = MaterialCache(cache_dir=tmp_path)
-
-        # Increment some counters
-        cache._track_fetch_reason("cache_hit")
-        cache._track_fetch_reason("signal_refresh")
-        cache._diag_inc("page_hits")
-
-        # Reset
-        cache.reset_diagnostics()
-
-        # All counters should be zero
-        diags = cache.get_diagnostics()
-        assert diags["fetch_cache_hit"] == 0
-        assert diags["fetch_signal_refresh"] == 0
-        assert diags["fetch_fresh_download"] == 0
-        assert diags["page_hits"] == 0

package/tools/vds-scripts/audit_orchestrator/tests/unit/collectors/test_checklist_parser_phase120.py

@@ -1,55 +0,0 @@
-from __future__ import annotations
-
-from vds_audit_orchestrator.collectors.checklist_parser import ChecklistParser
-
-
-class _UnusedClient:
-    pass
-
-
-def test_phase120_checklist_parser_handles_widened_columns_and_forward_fill() -> None:
-    parser = ChecklistParser(_UnusedClient())  # type: ignore[arg-type]
-    html = """
-    <table>
-      <thead>
-        <tr>
-          <th>Quy tắc</th>
-          <th>Tiêu chí chính</th>
-          <th>Tiêu chí con kỹ thuật</th>
-          <th>Check = Manual</th>
-          <th>Hướng dẫn chi tiết</th>
-          <th>Trọng số</th>
-        </tr>
-      </thead>
-      <tbody>
-        <tr>
-          <td>1. Decoupling</td>
-          <td>Service boundary</td>
-          <td>Controller does not call repository directly</td>
-          <td></td>
-          <td>Inspect controller and service packages</td>
-          <td>10</td>
-        </tr>
-        <tr>
-          <td></td>
-          <td></td>
-          <td>Deployment runbook exists</td>
-          <td>Manual</td>
-          <td>Check Confluence or repo docs for runbook</td>
-          <td>5</td>
-        </tr>
-      </tbody>
-    </table>
-    """
-
-    template = parser._parse_html_table(html, "Backend Checklist")
-
-    assert len(template.sections) == 1
-    section = template.sections[0]
-    assert section.name == "1. Decoupling"
-    assert len(section.checks) == 2
-    assert section.checks[0].requirement_category == "Service boundary"
-    assert section.checks[0].check_config["detailed_guidance"] == "Inspect controller and service packages"
-    assert section.checks[1].requirement_category == "Service boundary"
-    assert section.checks[1].check_config["check_manual"] == "Manual"
-    assert section.checks[1].check_config["detailed_guidance"] == "Check Confluence or repo docs for runbook"