@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/unit/models/test_evidence.py

@@ -1,515 +0,0 @@
-"""Unit tests for evidence models.
-
-Tests for EvidenceStatus, Evidence, EvidenceRequirement, EvidenceBundle,
-and the compute_content_hash utility function.
-
-Reference: TSK-027
-"""
-
-from __future__ import annotations
-
-from datetime import datetime, timedelta
-
-import pytest
-from vds_audit_orchestrator.models.evidence import (
-    Evidence,
-    EvidenceBundle,
-    EvidenceRequirement,
-    EvidenceStatus,
-    compute_content_hash,
-)
-
-
-class TestEvidenceStatus:
-    """Tests for EvidenceStatus enum."""
-
-    def test_all_status_values_exist(self) -> None:
-        """Verify all required status values are defined."""
-        assert EvidenceStatus.FOUND.value == "Found"
-        assert EvidenceStatus.PARTIAL.value == "Partial"
-        assert EvidenceStatus.MISSING.value == "Missing"
-        assert EvidenceStatus.OUTDATED.value == "Outdated"
-        assert EvidenceStatus.FAULTY.value == "Faulty"
-        assert EvidenceStatus.NOT_APPLICABLE.value == "Not Applicable"
-
-    def test_status_is_string_enum(self) -> None:
-        """Verify EvidenceStatus inherits from str."""
-        assert isinstance(EvidenceStatus.FOUND, str)
-        assert EvidenceStatus.FOUND == "Found"
-
-    def test_status_count(self) -> None:
-        """Verify correct number of status values."""
-        assert len(EvidenceStatus) == 6
-
-
-class TestComputeContentHash:
-    """Tests for compute_content_hash function."""
-
-    def test_hash_basic_content(self) -> None:
-        """Test hashing basic content."""
-        content = "Hello, World!"
-        result = compute_content_hash(content)
-        assert isinstance(result, str)
-        assert len(result) == 64  # SHA-256 hex digest length
-
-    def test_hash_is_deterministic(self) -> None:
-        """Test that same content produces same hash."""
-        content = "Test content for hashing"
-        hash1 = compute_content_hash(content)
-        hash2 = compute_content_hash(content)
-        assert hash1 == hash2
-
-    def test_different_content_different_hash(self) -> None:
-        """Test that different content produces different hash."""
-        hash1 = compute_content_hash("Content A")
-        hash2 = compute_content_hash("Content B")
-        assert hash1 != hash2
-
-    def test_hash_empty_string(self) -> None:
-        """Test hashing empty string."""
-        result = compute_content_hash("")
-        assert isinstance(result, str)
-        assert len(result) == 64
-
-    def test_hash_unicode_content(self) -> None:
-        """Test hashing unicode content."""
-        content = "Unicode: 中文, 日本語, emoji"
-        result = compute_content_hash(content)
-        assert isinstance(result, str)
-        assert len(result) == 64
-
-    def test_known_hash_value(self) -> None:
-        """Test against known SHA-256 hash value."""
-        # SHA-256 of "Hello, World!" is well-known
-        result = compute_content_hash("Hello, World!")
-        assert result == "dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f"
-
-
-class TestEvidence:
-    """Tests for Evidence model."""
-
-    @pytest.fixture
-    def sample_evidence(self) -> Evidence:
-        """Create sample evidence for testing."""
-        content = "# README\n\nThis is a test project."
-        return Evidence(
-            source="git_file",
-            source_id="README.md",
-            source_url="https://bitbucket.org/project/repo/src/main/README.md",
-            title="Project README",
-            content=content,
-            content_hash=compute_content_hash(content),
-            status=EvidenceStatus.FOUND,
-            completeness_score=0.85,
-            author="developer@example.com",
-            metadata={"branch": "main", "commit": "abc123"},
-        )
-
-    def test_create_evidence_with_required_fields(self) -> None:
-        """Test creating evidence with only required fields."""
-        evidence = Evidence(
-            source="git_file",
-            source_id="test.py",
-            title="Test File",
-            content="print('hello')",
-            content_hash="abc123",
-            status=EvidenceStatus.FOUND,
-        )
-        assert evidence.source == "git_file"
-        assert evidence.source_id == "test.py"
-        assert evidence.status == EvidenceStatus.FOUND
-
-    def test_evidence_defaults(self) -> None:
-        """Test default values for optional fields."""
-        evidence = Evidence(
-            source="git_file",
-            source_id="test.py",
-            title="Test",
-            content="content",
-            content_hash="hash",
-            status=EvidenceStatus.FOUND,
-        )
-        assert evidence.source_url is None
-        assert evidence.last_modified is None
-        assert evidence.author is None
-        assert evidence.completeness_score == 0.0
-        assert evidence.metadata == {}
-        assert isinstance(evidence.collected_at, datetime)
-
-    def test_evidence_source_normalization(self) -> None:
-        """Test that source is normalized to lowercase."""
-        evidence = Evidence(
-            source="GIT_FILE",
-            source_id="test.py",
-            title="Test",
-            content="content",
-            content_hash="hash",
-            status=EvidenceStatus.FOUND,
-        )
-        assert evidence.source == "git_file"
-
-    def test_evidence_completeness_score_bounds(self) -> None:
-        """Test completeness_score is bounded between 0.0 and 1.0."""
-        # Test valid lower bound
-        evidence = Evidence(
-            source="git_file",
-            source_id="test.py",
-            title="Test",
-            content="content",
-            content_hash="hash",
-            status=EvidenceStatus.FOUND,
-            completeness_score=0.0,
-        )
-        assert evidence.completeness_score == 0.0
-
-        # Test valid upper bound
-        evidence2 = Evidence(
-            source="git_file",
-            source_id="test.py",
-            title="Test",
-            content="content",
-            content_hash="hash",
-            status=EvidenceStatus.FOUND,
-            completeness_score=1.0,
-        )
-        assert evidence2.completeness_score == 1.0
-
-        # Test mid-range value
-        evidence3 = Evidence(
-            source="git_file",
-            source_id="test.py",
-            title="Test",
-            content="content",
-            content_hash="hash",
-            status=EvidenceStatus.FOUND,
-            completeness_score=0.75,
-        )
-        assert evidence3.completeness_score == 0.75
-
-    def test_evidence_all_sources(self) -> None:
-        """Test evidence creation with all valid source types."""
-        sources = ["git_file", "confluence_page", "jira_issue", "sonarqube_metric"]
-        for source in sources:
-            evidence = Evidence(
-                source=source,
-                source_id="id",
-                title="Title",
-                content="content",
-                content_hash="hash",
-                status=EvidenceStatus.FOUND,
-            )
-            assert evidence.source == source
-
-    def test_evidence_serialization(self, sample_evidence: Evidence) -> None:
-        """Test evidence can be serialized to dict."""
-        data = sample_evidence.model_dump()
-        assert data["source"] == "git_file"
-        assert data["source_id"] == "README.md"
-        assert data["status"] == "Found"
-        assert data["completeness_score"] == 0.85
-
-
-class TestEvidenceRequirement:
-    """Tests for EvidenceRequirement model."""
-
-    def test_create_minimal_requirement(self) -> None:
-        """Test creating requirement with minimal fields."""
-        req = EvidenceRequirement(source="git_file")
-        assert req.source == "git_file"
-        assert req.path_pattern is None
-        assert req.required_sections == []
-        assert req.weight == 1.0
-        assert req.critical is False
-
-    def test_create_full_requirement(self) -> None:
-        """Test creating requirement with all fields."""
-        req = EvidenceRequirement(
-            source="git_file",
-            path_pattern="**/README.md",
-            page_title_pattern=None,
-            issue_jql=None,
-            required_sections=["Installation", "Usage"],
-            required_keywords=["docker", "kubernetes"],
-            min_content_length=500,
-            max_age_days=30,
-            weight=2.0,
-            critical=True,
-        )
-        assert req.path_pattern == "**/README.md"
-        assert req.required_sections == ["Installation", "Usage"]
-        assert req.required_keywords == ["docker", "kubernetes"]
-        assert req.min_content_length == 500
-        assert req.max_age_days == 30
-        assert req.weight == 2.0
-        assert req.critical is True
-
-    def test_requirement_source_normalization(self) -> None:
-        """Test source is normalized to lowercase."""
-        req = EvidenceRequirement(source="CONFLUENCE_PAGE")
-        assert req.source == "confluence_page"
-
-    def test_requirement_list_normalization_from_string(self) -> None:
-        """Test single string is converted to list."""
-        req = EvidenceRequirement(
-            source="git_file",
-            required_sections="Installation",  # type: ignore[arg-type]
-            required_keywords="docker",  # type: ignore[arg-type]
-        )
-        assert req.required_sections == ["Installation"]
-        assert req.required_keywords == ["docker"]
-
-    def test_requirement_list_normalization_from_none(self) -> None:
-        """Test None is converted to empty list."""
-        req = EvidenceRequirement(
-            source="git_file",
-            required_sections=None,  # type: ignore[arg-type]
-        )
-        assert req.required_sections == []
-
-    def test_confluence_requirement(self) -> None:
-        """Test Confluence-specific requirement."""
-        req = EvidenceRequirement(
-            source="confluence_page",
-            page_title_pattern="Architecture*",
-            required_sections=["Overview", "Components"],
-        )
-        assert req.source == "confluence_page"
-        assert req.page_title_pattern == "Architecture*"
-
-    def test_jira_requirement(self) -> None:
-        """Test Jira-specific requirement."""
-        req = EvidenceRequirement(
-            source="jira_issue",
-            issue_jql="project = AUDIT AND type = Story",
-            max_age_days=90,
-        )
-        assert req.source == "jira_issue"
-        assert req.issue_jql == "project = AUDIT AND type = Story"
-
-
-class TestEvidenceBundle:
-    """Tests for EvidenceBundle model."""
-
-    @pytest.fixture
-    def sample_git_evidence(self) -> list[Evidence]:
-        """Create sample git evidence."""
-        return [
-            Evidence(
-                source="git_file",
-                source_id="README.md",
-                title="README",
-                content="content",
-                content_hash="hash1",
-                status=EvidenceStatus.FOUND,
-            ),
-            Evidence(
-                source="git_file",
-                source_id="CHANGELOG.md",
-                title="CHANGELOG",
-                content="content",
-                content_hash="hash2",
-                status=EvidenceStatus.PARTIAL,
-            ),
-        ]
-
-    @pytest.fixture
-    def sample_confluence_evidence(self) -> list[Evidence]:
-        """Create sample Confluence evidence."""
-        return [
-            Evidence(
-                source="confluence_page",
-                source_id="12345",
-                title="Architecture",
-                content="content",
-                content_hash="hash3",
-                status=EvidenceStatus.FOUND,
-            ),
-        ]
-
-    @pytest.fixture
-    def sample_missing_evidence(self) -> list[Evidence]:
-        """Create sample missing evidence."""
-        return [
-            Evidence(
-                source="git_file",
-                source_id="SECURITY.md",
-                title="Security Policy",
-                content="",
-                content_hash="empty",
-                status=EvidenceStatus.MISSING,
-            ),
-        ]
-
-    def test_create_empty_bundle(self) -> None:
-        """Test creating empty bundle."""
-        bundle = EvidenceBundle(repository="my-repo")
-        assert bundle.repository == "my-repo"
-        assert bundle.git_evidence == []
-        assert bundle.confluence_evidence == []
-        assert bundle.jira_evidence == []
-        assert bundle.sonarqube_evidence == []
-        assert bundle.total_evidence == 0
-        assert bundle.profile == {}
-
-    def test_bundle_total_evidence(
-        self,
-        sample_git_evidence: list[Evidence],
-        sample_confluence_evidence: list[Evidence],
-    ) -> None:
-        """Test total_evidence computed property."""
-        bundle = EvidenceBundle(
-            repository="my-repo",
-            git_evidence=sample_git_evidence,
-            confluence_evidence=sample_confluence_evidence,
-        )
-        assert bundle.total_evidence == 3
-
-    def test_bundle_found_count(
-        self,
-        sample_git_evidence: list[Evidence],
-        sample_confluence_evidence: list[Evidence],
-    ) -> None:
-        """Test found_count computed property."""
-        bundle = EvidenceBundle(
-            repository="my-repo",
-            git_evidence=sample_git_evidence,
-            confluence_evidence=sample_confluence_evidence,
-        )
-        # 1 FOUND in git + 1 FOUND in confluence = 2
-        assert bundle.found_count == 2
-
-    def test_bundle_partial_count(self, sample_git_evidence: list[Evidence]) -> None:
-        """Test partial_count computed property."""
-        bundle = EvidenceBundle(
-            repository="my-repo",
-            git_evidence=sample_git_evidence,
-        )
-        assert bundle.partial_count == 1
-
-    def test_bundle_missing_count(self, sample_missing_evidence: list[Evidence]) -> None:
-        """Test missing_count computed property."""
-        bundle = EvidenceBundle(
-            repository="my-repo",
-            git_evidence=sample_missing_evidence,
-        )
-        assert bundle.missing_count == 1
-
-    def test_bundle_all_evidence(
-        self,
-        sample_git_evidence: list[Evidence],
-        sample_confluence_evidence: list[Evidence],
-    ) -> None:
-        """Test all_evidence property."""
-        bundle = EvidenceBundle(
-            repository="my-repo",
-            git_evidence=sample_git_evidence,
-            confluence_evidence=sample_confluence_evidence,
-        )
-        all_evidence = bundle.all_evidence
-        assert len(all_evidence) == 3
-        assert all(isinstance(e, Evidence) for e in all_evidence)
-
-    def test_bundle_get_evidence_by_source(
-        self,
-        sample_git_evidence: list[Evidence],
-        sample_confluence_evidence: list[Evidence],
-    ) -> None:
-        """Test get_evidence_by_source method."""
-        bundle = EvidenceBundle(
-            repository="my-repo",
-            git_evidence=sample_git_evidence,
-            confluence_evidence=sample_confluence_evidence,
-        )
-        git = bundle.get_evidence_by_source("git_file")
-        assert len(git) == 2
-        confluence = bundle.get_evidence_by_source("confluence_page")
-        assert len(confluence) == 1
-        jira = bundle.get_evidence_by_source("jira_issue")
-        assert len(jira) == 0
-
-    def test_bundle_collected_at_default(self) -> None:
-        """Test collected_at has default value."""
-        bundle = EvidenceBundle(repository="my-repo")
-        assert isinstance(bundle.collected_at, datetime)
-        # Should be recent (within last minute)
-        assert datetime.now() - bundle.collected_at < timedelta(minutes=1)
-
-    def test_bundle_serialization(self, sample_git_evidence: list[Evidence]) -> None:
-        """Test bundle can be serialized."""
-        bundle = EvidenceBundle(
-            repository="my-repo",
-            git_evidence=sample_git_evidence,
-        )
-        data = bundle.model_dump()
-        assert data["repository"] == "my-repo"
-        assert len(data["git_evidence"]) == 2
-        assert data["total_evidence"] == 2
-        assert data["found_count"] == 1
-        assert data["partial_count"] == 1
-
-    def test_bundle_outdated_count(self) -> None:
-        """Test outdated_count property."""
-        evidence = Evidence(
-            source="git_file",
-            source_id="old.md",
-            title="Old Doc",
-            content="old content",
-            content_hash="hash",
-            status=EvidenceStatus.OUTDATED,
-        )
-        bundle = EvidenceBundle(repository="my-repo", git_evidence=[evidence])
-        assert bundle.outdated_count == 1
-
-    def test_bundle_faulty_count(self) -> None:
-        """Test faulty_count property."""
-        evidence = Evidence(
-            source="git_file",
-            source_id="bad.md",
-            title="Bad Doc",
-            content="corrupted",
-            content_hash="hash",
-            status=EvidenceStatus.FAULTY,
-        )
-        bundle = EvidenceBundle(repository="my-repo", git_evidence=[evidence])
-        assert bundle.faulty_count == 1
-
-
-class TestEvidenceIntegration:
-    """Integration tests for evidence models."""
-
-    def test_full_workflow(self) -> None:
-        """Test complete evidence collection workflow."""
-        # 1. Define requirements
-        readme_req = EvidenceRequirement(
-            source="git_file",
-            path_pattern="**/README.md",
-            required_sections=["Installation", "Usage"],
-            min_content_length=50,
-            critical=True,
-        )
-
-        # 2. Collect evidence
-        readme_content = "# Project\n\n## Installation\nRun npm install\n\n## Usage\nRun npm start"
-        readme_evidence = Evidence(
-            source="git_file",
-            source_id="README.md",
-            source_url="https://bitbucket.org/project/repo/README.md",
-            title="README",
-            content=readme_content,
-            content_hash=compute_content_hash(readme_content),
-            status=EvidenceStatus.FOUND,
-            completeness_score=0.9,
-        )
-
-        # 3. Bundle evidence
-        bundle = EvidenceBundle(
-            repository="my-service",
-            git_evidence=[readme_evidence],
-        )
-
-        # 4. Verify
-        assert bundle.total_evidence == 1
-        assert bundle.found_count == 1
-        assert bundle.missing_count == 0
-        assert readme_req.critical is True
-        assert len(readme_evidence.content) > readme_req.min_content_length