@ngocsangairvds/vsaf 3.2.14 → 3.2.15

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

@@ -1,467 +0,0 @@
-"""Unit tests for diagram_extractor (TSK-194a)."""
-
-from __future__ import annotations
-
-import base64
-import json
-import sqlite3
-import urllib.parse
-import xml.etree.ElementTree as ET
-import zlib
-from pathlib import Path
-
-import pytest
-from vds_audit_orchestrator.collectors.diagram_extractor import DiagramExtractionError, DiagramExtractor
-
-# Test fixtures path
-FIXTURES_DIR = Path(__file__).parent.parent.parent / "fixtures" / "diagrams"
-
-
-class TestDiagramExtractor:
-    """Test DiagramExtractor functionality."""
-
-    def test_is_supported_drawio(self) -> None:
-        """Test .drawio file type is supported."""
-        extractor = DiagramExtractor()
-        assert extractor.is_supported(Path("test.drawio"))
-        assert extractor.is_supported(Path("test.xml"))
-
-    def test_is_supported_bmpr(self) -> None:
-        """Test .bmpr file type is supported."""
-        extractor = DiagramExtractor()
-        assert extractor.is_supported(Path("test.bmpr"))
-
-    def test_is_supported_unsupported(self) -> None:
-        """Test unsupported file types."""
-        extractor = DiagramExtractor()
-        assert not extractor.is_supported(Path("test.pdf"))
-        assert not extractor.is_supported(Path("test.txt"))
-
-    def test_extract_drawio_simple(self) -> None:
-        """Test extraction from uncompressed .drawio file."""
-        file_path = FIXTURES_DIR / "simple.drawio"
-        extractor = DiagramExtractor()
-
-        result = extractor.extract_text(file_path)
-
-        # Check provenance header
-        assert "<!-- Extracted from: simple.drawio" in result
-        assert "Converter: diagram_extractor v1.0" in result
-
-        # Check extracted labels
-        assert "API Gateway" in result
-        assert "Auth Service" in result
-        assert "Database" in result
-        assert "User Request" in result
-
-        # Check markdown format
-        assert "# Diagram Labels" in result
-        assert "- API Gateway" in result
-        assert "- Auth Service" in result
-
-    def test_extract_drawio_compressed(self) -> None:
-        """Test extraction from compressed .drawio file."""
-        file_path = FIXTURES_DIR / "compressed.drawio"
-        extractor = DiagramExtractor()
-
-        result = extractor.extract_text(file_path)
-
-        # Check provenance header
-        assert "<!-- Extracted from: compressed.drawio" in result
-
-        # Check extracted labels from compressed content
-        assert "Login Service" in result
-        assert "Payment Gateway" in result
-        assert "Notification System" in result
-
-    def test_extract_bmpr(self) -> None:
-        """Test extraction from Balsamiq .bmpr file."""
-        file_path = FIXTURES_DIR / "mockup.bmpr"
-        extractor = DiagramExtractor()
-
-        result = extractor.extract_text(file_path)
-
-        # Check provenance header
-        assert "<!-- Extracted from: mockup.bmpr" in result
-
-        # Check extracted labels
-        assert "Welcome Screen" in result
-        assert "Login Button" in result
-        assert "Username Field" in result
-        assert "Dashboard Title" in result
-
-    def test_extract_drawio_empty(self, tmp_path: Path) -> None:
-        """Test extraction from empty .drawio file returns empty string."""
-        file_path = tmp_path / "empty.drawio"
-        file_path.write_text(
-            '<?xml version="1.0"?><mxfile><diagram><mxGraphModel><root><mxCell id="0"/></root></mxGraphModel></diagram></mxfile>',
-            encoding="utf-8",
-        )
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Empty diagram should return empty string (no labels found)
-        assert result == ""
-
-    def test_extract_bmpr_empty(self, tmp_path: Path) -> None:
-        """Test extraction from empty .bmpr file returns empty string."""
-        file_path = tmp_path / "empty.bmpr"
-
-        # Create empty SQLite database
-        conn = sqlite3.connect(file_path)
-        cursor = conn.cursor()
-        cursor.execute("CREATE TABLE RESOURCES (ID INTEGER PRIMARY KEY, ATTRIBUTES TEXT)")
-        conn.commit()
-        conn.close()
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Empty database should return empty string
-        assert result == ""
-
-    def test_extract_file_not_found(self, tmp_path: Path) -> None:
-        """Test extraction from non-existent file raises error."""
-        file_path = tmp_path / "nonexistent.drawio"
-        extractor = DiagramExtractor()
-
-        with pytest.raises(DiagramExtractionError, match="File not found"):
-            extractor.extract_text(file_path)
-
-    def test_extract_unsupported_type(self, tmp_path: Path) -> None:
-        """Test extraction from unsupported file type raises error."""
-        file_path = tmp_path / "test.pdf"
-        file_path.write_bytes(b"%PDF-1.4\n")
-
-        extractor = DiagramExtractor()
-
-        with pytest.raises(DiagramExtractionError, match="Unsupported diagram type"):
-            extractor.extract_text(file_path)
-
-    def test_extract_drawio_malformed_xml(self, tmp_path: Path) -> None:
-        """Test extraction from malformed XML raises error."""
-        file_path = tmp_path / "malformed.drawio"
-        file_path.write_text("<mxfile><unclosed>", encoding="utf-8")
-
-        extractor = DiagramExtractor()
-
-        with pytest.raises(DiagramExtractionError, match="Failed to parse DrawIO XML"):
-            extractor.extract_text(file_path)
-
-    def test_extract_bmpr_not_sqlite(self, tmp_path: Path) -> None:
-        """Test extraction from non-SQLite .bmpr file raises error."""
-        file_path = tmp_path / "invalid.bmpr"
-        file_path.write_bytes(b"not a sqlite file")
-
-        extractor = DiagramExtractor()
-
-        with pytest.raises(DiagramExtractionError, match="Failed to read Balsamiq SQLite"):
-            extractor.extract_text(file_path)
-
-    def test_extract_drawio_with_html_labels(self, tmp_path: Path) -> None:
-        """Test that HTML labels are skipped."""
-        file_path = tmp_path / "html_labels.drawio"
-        xml_content = """<?xml version="1.0"?>
-<mxfile>
-  <diagram>
-    <mxGraphModel>
-      <root>
-        <mxCell id="0"/>
-        <mxCell id="1" parent="0"/>
-        <mxCell id="2" value="Plain Text Label" vertex="1" parent="1"/>
-        <mxCell id="3" value="&lt;b&gt;HTML Label&lt;/b&gt;" vertex="1" parent="1"/>
-        <mxCell id="4" value="Another Plain Label" vertex="1" parent="1"/>
-      </root>
-    </mxGraphModel>
-  </diagram>
-</mxfile>"""
-        file_path.write_text(xml_content, encoding="utf-8")
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Plain labels should be included
-        assert "Plain Text Label" in result
-        assert "Another Plain Label" in result
-
-        # HTML labels should be skipped
-        assert "<b>HTML Label</b>" not in result
-
-    def test_extract_drawio_with_url_encoding(self, tmp_path: Path) -> None:
-        """Test URL-encoded labels are properly decoded."""
-        file_path = tmp_path / "url_encoded.drawio"
-        xml_content = """<?xml version="1.0"?>
-<mxfile>
-  <diagram>
-    <mxGraphModel>
-      <root>
-        <mxCell id="0"/>
-        <mxCell id="1" parent="0"/>
-        <mxCell id="2" value="Hello%20World" vertex="1" parent="1"/>
-        <mxCell id="3" value="Test%2FPath" vertex="1" parent="1"/>
-      </root>
-    </mxGraphModel>
-  </diagram>
-</mxfile>"""
-        file_path.write_text(xml_content, encoding="utf-8")
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # URL-encoded labels should be decoded
-        assert "Hello World" in result
-        assert "Test/Path" in result
-
-    def test_extract_drawio_deduplication(self, tmp_path: Path) -> None:
-        """Test duplicate labels are removed."""
-        file_path = tmp_path / "duplicates.drawio"
-        xml_content = """<?xml version="1.0"?>
-<mxfile>
-  <diagram>
-    <mxGraphModel>
-      <root>
-        <mxCell id="0"/>
-        <mxCell id="1" parent="0"/>
-        <mxCell id="2" value="API Service" vertex="1" parent="1"/>
-        <mxCell id="3" value="Database" vertex="1" parent="1"/>
-        <mxCell id="4" value="API Service" vertex="1" parent="1"/>
-        <mxCell id="5" value="Cache" vertex="1" parent="1"/>
-        <mxCell id="6" value="Database" vertex="1" parent="1"/>
-      </root>
-    </mxGraphModel>
-  </diagram>
-</mxfile>"""
-        file_path.write_text(xml_content, encoding="utf-8")
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Each label should appear only once
-        assert result.count("- API Service") == 1
-        assert result.count("- Database") == 1
-        assert result.count("- Cache") == 1
-
-    def test_extract_bmpr_nested_text(self, tmp_path: Path) -> None:
-        """Test extraction of deeply nested text in Balsamiq JSON."""
-        file_path = tmp_path / "nested.bmpr"
-
-        conn = sqlite3.connect(file_path)
-        cursor = conn.cursor()
-        cursor.execute("CREATE TABLE RESOURCES (ID INTEGER PRIMARY KEY, ATTRIBUTES TEXT)")
-
-        # Create deeply nested JSON structure
-        mockup_data = {
-            "controls": {
-                "control": [
-                    {
-                        "typeID": "Canvas",
-                        "children": {
-                            "controls": {
-                                "control": [{"typeID": "Label", "properties": {"text": "Nested Label", "size": "14"}}]
-                            }
-                        },
-                    },
-                    {"typeID": "Button", "properties": {"text": "Submit"}},
-                ]
-            },
-            "mockupH": "800",
-            "mockupW": "1200",
-        }
-
-        attributes = {"kind": "mockup", "data": json.dumps(mockup_data)}
-
-        cursor.execute("INSERT INTO RESOURCES (ID, ATTRIBUTES) VALUES (?, ?)", (1, json.dumps(attributes)))
-        conn.commit()
-        conn.close()
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Both nested and top-level text should be extracted
-        assert "Nested Label" in result
-        assert "Submit" in result
-
-    def test_extract_bmpr_malformed_json(self, tmp_path: Path) -> None:
-        """Test graceful handling of malformed JSON in BMPR."""
-        file_path = tmp_path / "malformed.bmpr"
-
-        conn = sqlite3.connect(file_path)
-        cursor = conn.cursor()
-        cursor.execute("CREATE TABLE RESOURCES (ID INTEGER PRIMARY KEY, ATTRIBUTES TEXT)")
-
-        # Insert malformed JSON
-        cursor.execute("INSERT INTO RESOURCES (ID, ATTRIBUTES) VALUES (?, ?)", (1, "not valid json"))
-
-        # Insert valid JSON
-        valid_data = {
-            "data": json.dumps({"controls": {"control": [{"typeID": "Label", "properties": {"text": "Valid Label"}}]}})
-        }
-        cursor.execute("INSERT INTO RESOURCES (ID, ATTRIBUTES) VALUES (?, ?)", (2, json.dumps(valid_data)))
-
-        conn.commit()
-        conn.close()
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Should extract from valid JSON, skip malformed
-        assert "Valid Label" in result
-
-    def test_extract_drawio_empty_values(self, tmp_path: Path) -> None:
-        """Test that empty or whitespace-only values are skipped."""
-        file_path = tmp_path / "empty_values.drawio"
-        xml_content = """<?xml version="1.0"?>
-<mxfile>
-  <diagram>
-    <mxGraphModel>
-      <root>
-        <mxCell id="0"/>
-        <mxCell id="1" parent="0"/>
-        <mxCell id="2" value="" vertex="1" parent="1"/>
-        <mxCell id="3" value="   " vertex="1" parent="1"/>
-        <mxCell id="4" value="Valid Label" vertex="1" parent="1"/>
-      </root>
-    </mxGraphModel>
-  </diagram>
-</mxfile>"""
-        file_path.write_text(xml_content, encoding="utf-8")
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Only valid label should be extracted
-        assert "Valid Label" in result
-        # Check that only one label bullet point exists (not counting dashes in header)
-        lines = [line for line in result.split("\n") if line.strip().startswith("- ")]
-        assert len(lines) == 1
-
-    def test_extract_drawio_mixed_compressed_uncompressed(self, tmp_path: Path) -> None:
-        """Test file with both compressed and uncompressed content."""
-        file_path = tmp_path / "mixed.drawio"
-
-        # Create compressed content
-        inner_xml = """<mxGraphModel>
-  <root>
-    <mxCell id="0"/>
-    <mxCell id="1" parent="0"/>
-    <mxCell id="2" value="Compressed Label" vertex="1" parent="1"/>
-  </root>
-</mxGraphModel>"""
-        compressed = zlib.compress(inner_xml.encode("utf-8"))[2:-4]
-        encoded = base64.b64encode(compressed).decode("ascii")
-
-        # Create XML with both compressed diagram and uncompressed cells
-        root = ET.Element("mxfile")
-        diagram = ET.SubElement(root, "diagram")
-        diagram.text = encoded
-
-        # Add uncompressed content at root level
-        model = ET.SubElement(root, "mxGraphModel")
-        root_elem = ET.SubElement(model, "root")
-        ET.SubElement(root_elem, "mxCell", {"id": "0"})
-        ET.SubElement(root_elem, "mxCell", {"id": "1", "parent": "0"})
-        ET.SubElement(root_elem, "mxCell", {"id": "3", "value": "Uncompressed Label", "vertex": "1", "parent": "1"})
-
-        tree = ET.ElementTree(root)
-        tree.write(file_path, encoding="utf-8", xml_declaration=True)
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Both compressed and uncompressed labels should be extracted
-        assert "Compressed Label" in result
-        assert "Uncompressed Label" in result
-
-    def test_extract_drawio_url_encoded_compressed(self, tmp_path: Path) -> None:
-        """Test extraction from URL-encoded + base64 + deflate compressed .drawio file.
-
-        This format is used by Confluence-exported drawio files where:
-        1. The inner mxGraphModel XML is URL-encoded
-        2. Then deflate compressed
-        3. Then base64 encoded
-
-        TSK-201: Fix for uncompressed mxfile XML format.
-        """
-        file_path = tmp_path / "confluence_export.drawio"
-
-        # Create inner XML content (similar to real Confluence export)
-        inner_xml = """<mxGraphModel dx="1000" dy="800" grid="1" gridSize="10">
-  <root>
-    <mxCell id="0"/>
-    <mxCell id="1" parent="0"/>
-    <mxCell id="2" value="Đăng ký dịch vụ" vertex="1" parent="1">
-      <mxGeometry x="100" y="100" width="120" height="60" as="geometry"/>
-    </mxCell>
-    <mxCell id="3" value="Merchant profile" vertex="1" parent="1">
-      <mxGeometry x="250" y="100" width="120" height="60" as="geometry"/>
-    </mxCell>
-    <mxCell id="4" value="Phê duyệt yêu cầu" vertex="1" parent="1">
-      <mxGeometry x="400" y="100" width="120" height="60" as="geometry"/>
-    </mxCell>
-  </root>
-</mxGraphModel>"""
-
-        # Encode: URL encode -> deflate compress -> base64 encode
-        url_encoded = urllib.parse.quote(inner_xml, safe="")
-        compressed = zlib.compress(url_encoded.encode("utf-8"))[2:-4]  # Remove zlib header/trailer for raw deflate
-        encoded = base64.b64encode(compressed).decode("ascii")
-
-        # Create mxfile wrapper (like Confluence exports)
-        xml_content = f"""<mxfile host="confluence.example.com" modified="2025-07-10T09:29:43.657Z" type="atlas">
-  <diagram id="test-diagram" name="Page-1">{encoded}</diagram>
-</mxfile>"""
-
-        file_path.write_text(xml_content, encoding="utf-8")
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Check provenance header
-        assert "<!-- Extracted from: confluence_export.drawio" in result
-
-        # Check Vietnamese labels are extracted
-        assert "Đăng ký dịch vụ" in result
-        assert "Merchant profile" in result
-        assert "Phê duyệt yêu cầu" in result
-
-    def test_extract_drawio_html_in_value(self, tmp_path: Path) -> None:
-        """Test extraction of text from HTML-containing mxCell values.
-
-        DrawIO sometimes uses HTML in value attributes for rich formatting.
-        The extractor should extract the text content from HTML.
-
-        TSK-201: Enhanced HTML handling.
-        """
-        file_path = tmp_path / "html_values.drawio"
-        xml_content = """<?xml version="1.0"?>
-<mxfile>
-  <diagram>
-    <mxGraphModel>
-      <root>
-        <mxCell id="0"/>
-        <mxCell id="1" parent="0"/>
-        <mxCell id="2" value="&lt;b&gt;Bold Label&lt;/b&gt;" vertex="1" parent="1"/>
-        <mxCell id="3" value="&lt;div&gt;Container&lt;br/&gt;with line break&lt;/div&gt;" vertex="1" parent="1"/>
-        <mxCell id="4" value="Plain Text" vertex="1" parent="1"/>
-        <mxCell id="5" value="Text with&amp;nbsp;HTML entity" vertex="1" parent="1"/>
-      </root>
-    </mxGraphModel>
-  </diagram>
-</mxfile>"""
-        file_path.write_text(xml_content, encoding="utf-8")
-
-        extractor = DiagramExtractor()
-        result = extractor.extract_text(file_path)
-
-        # Plain text should be extracted
-        assert "Plain Text" in result
-
-        # HTML content should have text extracted (tags removed)
-        assert "Bold Label" in result
-        assert "Container" in result
-        assert "with line break" in result
-
-        # HTML entities should be decoded
-        assert "Text with HTML entity" in result
-        assert "&nbsp;" not in result  # Entity should be decoded

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

@@ -1,59 +0,0 @@
-"""Unit tests for enrichment_extractor mention normalization."""
-
-from __future__ import annotations
-
-from vds_audit_orchestrator.collectors.enrichment_extractor import MentionExtractor
-from vds_audit_orchestrator.models.enrichment import MentionType
-
-
-class TestMentionExtractor:
-    """Test mention extraction and URL normalization behavior."""
-
-    def test_extract_normalizes_malformed_bitbucket_urls(self) -> None:
-        extractor = MentionExtractor()
-        html = """
-        <p>
-          <a href="http://bitbucket.digital.vn/projects/MAP/repos/app-center-be/browse">app-center-be</a>
-        </p>
-        <p>
-          http://bitbucket.digital.vn/projects/WEBAPPV2/repos/miniapp-ui/browse\\n[Miniapp UI]
-        </p>
-        <p>
-          http://bitbucket.digital.vn/projects/SUPERAPP<
-        </p>
-        """
-
-        mentions = extractor.extract(html, page_id="88718882")
-        bitbucket_urls = {mention.url for mention in mentions if mention.type == MentionType.BITBUCKET}
-
-        assert "http://bitbucket.digital.vn/projects/MAP/repos/app-center-be/browse" in bitbucket_urls
-        assert "http://bitbucket.digital.vn/projects/WEBAPPV2/repos/miniapp-ui/browse" in bitbucket_urls
-        assert "http://bitbucket.digital.vn/projects/SUPERAPP" in bitbucket_urls
-        assert all(url is not None for url in bitbucket_urls)
-        assert all("\\n" not in str(url) for url in bitbucket_urls)
-        assert all("[" not in str(url) for url in bitbucket_urls)
-        assert all("<" not in str(url) for url in bitbucket_urls)
-
-    def test_extract_deduplicates_bitbucket_mentions(self) -> None:
-        extractor = MentionExtractor()
-        html = """
-        <p><a href="http://bitbucket.digital.vn/projects/MAP/repos/app-center-be/browse">A</a></p>
-        <p>Duplicate: http://bitbucket.digital.vn/projects/MAP/repos/app-center-be/browse</p>
-        """
-
-        mentions = extractor.extract(html, page_id="88718882")
-        bitbucket_mentions = [mention for mention in mentions if mention.type == MentionType.BITBUCKET]
-
-        assert len(bitbucket_mentions) == 1
-        assert bitbucket_mentions[0].url == "http://bitbucket.digital.vn/projects/MAP/repos/app-center-be/browse"
-
-    def test_extract_preserves_jira_mentions(self) -> None:
-        extractor = MentionExtractor()
-        text = "Please validate TDOV-123 before release."
-
-        mentions = extractor.extract(text, page_id="88718882")
-        jira_mentions = [mention for mention in mentions if mention.type == MentionType.JIRA]
-
-        assert len(jira_mentions) == 1
-        assert jira_mentions[0].key == "TDOV-123"
-        assert jira_mentions[0].context_surrounding is not None

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

@@ -1,158 +0,0 @@
-"""Tests for GraphifyEvidenceCollector."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-from vds_audit_orchestrator.collectors.graphify_collector import GraphifyEvidenceCollector
-from vds_audit_orchestrator.models.evidence import Evidence, EvidenceRequirement, EvidenceStatus
-
-FIXTURE_PIPELINE_OUTPUT = {
-    "node_count": 42,
-    "edge_count": 67,
-    "community_count": 5,
-    "gods": [
-        {"label": "AuthService", "degree": 15, "source_file": "src/auth.py", "source_location": "L10"},
-        {"label": "DatabasePool", "degree": 12, "source_file": "src/db.py", "source_location": "L5"},
-    ],
-    "surprises": [
-        {
-            "source": "AuthService",
-            "target": "README.md",
-            "relation": "semantically_similar_to",
-            "confidence": "INFERRED",
-            "reasons": ["cross-type"],
-        },
-    ],
-    "communities": {"0": ["AuthService", "TokenValidator"], "1": ["DatabasePool", "QueryBuilder"]},
-    "cohesion": {"0": 0.85, "1": 0.72},
-    "confidence_breakdown": {"EXTRACTED": 40, "INFERRED": 22, "AMBIGUOUS": 5},
-    "doc_nodes": ["README.md", "CONTRIBUTING.md"],
-    "orphan_nodes": ["legacy_util"],
-    "import_edges": [
-        {"source": "auth", "target": "db", "relation": "imports"},
-        {"source": "db", "target": "auth", "relation": "imports"},
-    ],
-}
-
-
-@pytest.fixture()
-def graphify_req():
-    """Single graphify_graph requirement that triggers all 3 probes."""
-    return [
-        EvidenceRequirement(
-            source="graphify_graph",
-            path_pattern="**/*.py",
-            required_sections=[],
-            required_keywords=[],
-            min_content_length=0,
-            weight=1.0,
-        ),
-    ]
-
-
-@pytest.fixture()
-def collector():
-    return GraphifyEvidenceCollector(repo_path=Path("/tmp/test-repo"))
-
-
-@pytest.fixture()
-def mock_pipeline(collector):
-    with patch.object(collector, "_run_pipeline", return_value=FIXTURE_PIPELINE_OUTPUT):
-        yield
-
-
-class TestGraphifyCollectReturnsEvidence:
-    @pytest.mark.asyncio()
-    async def test_returns_list_of_evidence(self, collector, mock_pipeline, graphify_req):
-        result = await collector.collect(graphify_req)
-        assert isinstance(result, list)
-        assert all(isinstance(e, Evidence) for e in result)
-
-    @pytest.mark.asyncio()
-    async def test_produces_three_probes(self, collector, mock_pipeline, graphify_req):
-        result = await collector.collect(graphify_req)
-        sources = {e.source for e in result}
-        assert "graphify_architecture" in sources
-        assert "graphify_documentation" in sources
-        assert "graphify_dependency" in sources
-
-    @pytest.mark.asyncio()
-    async def test_evidence_has_content_hash(self, collector, mock_pipeline, graphify_req):
-        result = await collector.collect(graphify_req)
-        for e in result:
-            assert e.content_hash
-            assert len(e.content_hash) == 64
-
-
-class TestArchitectureProbe:
-    @pytest.mark.asyncio()
-    async def test_has_god_nodes(self, collector, mock_pipeline, graphify_req):
-        result = await collector.collect(graphify_req)
-        arch = next(e for e in result if e.source == "graphify_architecture")
-        content = json.loads(arch.content)
-        assert "god_nodes" in content
-        assert len(content["god_nodes"]) == 2
-        assert content["god_nodes"][0]["label"] == "AuthService"
-
-    @pytest.mark.asyncio()
-    async def test_has_communities(self, collector, mock_pipeline, graphify_req):
-        result = await collector.collect(graphify_req)
-        arch = next(e for e in result if e.source == "graphify_architecture")
-        content = json.loads(arch.content)
-        assert content["community_count"] == 5
-        assert "confidence_breakdown" in content
-
-
-class TestDependencyProbe:
-    @pytest.mark.asyncio()
-    async def test_detects_cycle_candidates(self, collector, mock_pipeline, graphify_req):
-        result = await collector.collect(graphify_req)
-        dep = next(e for e in result if e.source == "graphify_dependency")
-        content = json.loads(dep.content)
-        assert "cycle_candidates" in content
-        assert content["cycle_count"] == 1
-        assert content["cycle_candidates"][0] == {"a": "auth", "b": "db"}
-
-
-class TestDocumentationProbe:
-    @pytest.mark.asyncio()
-    async def test_has_doc_coverage(self, collector, mock_pipeline, graphify_req):
-        result = await collector.collect(graphify_req)
-        doc = next(e for e in result if e.source == "graphify_documentation")
-        content = json.loads(doc.content)
-        assert content["doc_node_count"] == 2
-        assert "doc_coverage_ratio" in content
-
-
-class TestEdgeCases:
-    @pytest.mark.asyncio()
-    async def test_skips_non_graphify_requirements(self, collector, mock_pipeline):
-        reqs = [
-            EvidenceRequirement(
-                source="git_file",
-                path_pattern="*.py",
-                required_sections=[],
-                required_keywords=[],
-                min_content_length=0,
-                weight=1.0,
-            ),
-        ]
-        result = await collector.collect(reqs)
-        assert result == []
-
-    @pytest.mark.asyncio()
-    async def test_returns_missing_on_pipeline_failure(self, collector, graphify_req):
-        with patch.object(collector, "_run_pipeline", return_value=None):
-            result = await collector.collect(graphify_req)
-        assert all(e.status == EvidenceStatus.MISSING for e in result)
-        assert all(e.completeness_score == 0.0 for e in result)
-
-    @pytest.mark.asyncio()
-    async def test_found_status_on_success(self, collector, mock_pipeline, graphify_req):
-        result = await collector.collect(graphify_req)
-        assert all(e.status == EvidenceStatus.FOUND for e in result)
-        assert all(e.completeness_score == 1.0 for e in result)