@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/unit/agents/test_utils.py

@@ -1,1007 +0,0 @@
-"""Test utilities for PydanticAI agents (TSK-090).
-
-This module provides deterministic test harness utilities for testing PydanticAI
-agents without making actual LLM calls. It includes:
-
-- TestModel configuration for deterministic testing
-- FunctionModel helpers for custom response logic
-- Mock AuditDeps factory
-- Assertion helpers for validating agent outputs
-- Example tests demonstrating usage
-
-Reference: PydanticAI testing documentation
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Any, TypeVar
-
-import pytest
-from pydantic import BaseModel
-from vds_audit_orchestrator.agents.base import AgentResult
-from vds_audit_orchestrator.agents.pydantic_base import (
-    AuditDeps,
-    CodeFindings,
-    CodeIssue,
-    CodePattern,
-    DocFindings,
-    SecurityFindings,
-    SynthesisResult,
-    Vulnerability,
-)
-from vds_audit_orchestrator.models.evidence import (
-    Evidence,
-    EvidenceBundle,
-    EvidenceStatus,
-    compute_content_hash,
-)
-
-# Type variable for generic model creation
-T = TypeVar("T", bound=BaseModel)
-
-
-# =============================================================================
-# TestModel Configuration
-# =============================================================================
-
-
-def create_test_model(
-    responses: list[str] | None = None,
-    *,
-    call_count: int = 0,
-    seed: int | None = None,
-) -> Any:
-    """Create a TestModel with predefined responses for deterministic testing.
-
-    The TestModel from pydantic_ai.models.test provides a way to test agents
-    without making actual LLM calls. It returns predictable responses based
-    on the configuration.
-
-    Args:
-        responses: List of response strings to return in sequence.
-            If None, returns a default test response.
-        call_count: Initial call count for tracking invocations.
-        seed: Random seed for reproducibility (used if responses are None).
-
-    Returns:
-        A configured TestModel instance.
-
-    Example:
-        >>> model = create_test_model(["Response 1", "Response 2"])
-        >>> # First call returns "Response 1", second returns "Response 2"
-    """
-    try:
-        from pydantic_ai.models.test import TestModel
-    except ImportError:
-        # Fallback for older pydantic_ai versions
-        return _create_mock_test_model(responses, call_count)
-
-    if responses is None:
-        responses = ["Test response from deterministic TestModel"]
-
-    return TestModel(
-        custom_result_text=responses[0] if len(responses) == 1 else None,
-        custom_result_args=None,
-        call_tools=None,
-        seed=seed,
-    )
-
-
-def _create_mock_test_model(
-    responses: list[str] | None = None,
-    call_count: int = 0,
-) -> Any:
-    """Fallback mock test model when pydantic_ai TestModel is unavailable."""
-
-    @dataclass
-    class MockTestModel:
-        """Mock test model for testing without pydantic_ai.models.test."""
-
-        responses: list[str] = field(default_factory=lambda: ["Mock test response"])
-        call_index: int = 0
-
-        def __call__(self, *args: Any, **kwargs: Any) -> str:
-            """Return next response in sequence."""
-            if self.call_index >= len(self.responses):
-                return self.responses[-1]
-            response = self.responses[self.call_index]
-            self.call_index += 1
-            return response
-
-    return MockTestModel(responses=responses or ["Mock test response"], call_index=call_count)
-
-
-# =============================================================================
-# FunctionModel Helpers
-# =============================================================================
-
-
-def create_function_model(
-    response_fn: Callable[[list[Any]], str],
-    *,
-    name: str = "test_function_model",
-) -> Any:
-    """Create a FunctionModel with custom response logic for flexible testing.
-
-    FunctionModel allows defining custom logic for generating responses based
-    on the input messages. This is useful for testing complex scenarios where
-    responses depend on the input.
-
-    Args:
-        response_fn: Function that takes a list of messages and returns a response string.
-            The function signature is: (messages: list[Message]) -> str
-        name: Optional name for the function model.
-
-    Returns:
-        A configured FunctionModel instance.
-
-    Example:
-        >>> def custom_response(messages):
-        ...     if "security" in str(messages[-1]):
-        ...         return '{"risk_level": "HIGH", "findings": []}'
-        ...     return '{"risk_level": "LOW", "findings": []}'
-        >>> model = create_function_model(custom_response)
-    """
-    try:
-        from pydantic_ai.models.function import FunctionModel
-    except ImportError:
-        # Fallback for older pydantic_ai versions
-        return _create_mock_function_model(response_fn, name)
-
-    # Newer PydanticAI versions don't accept 'name' parameter
-    return FunctionModel(response_fn)
-
-
-def _create_mock_function_model(
-    response_fn: Callable[[list[Any]], str],
-    name: str = "mock_function_model",
-) -> Any:
-    """Fallback mock function model."""
-
-    @dataclass
-    class MockFunctionModel:
-        """Mock function model for testing."""
-
-        fn: Callable[[list[Any]], str]
-        model_name: str = "mock_function_model"
-
-        def __call__(self, messages: list[Any]) -> str:
-            return self.fn(messages)
-
-    return MockFunctionModel(fn=response_fn, model_name=name)
-
-
-def create_structured_response_model[T: BaseModel](
-    response_type: type[T],
-    response_data: dict[str, Any],
-) -> Any:
-    """Create a model that returns a structured Pydantic response.
-
-    This is useful for testing agents that expect structured output types.
-
-    Args:
-        response_type: The Pydantic model type to return.
-        response_data: Dictionary data to construct the response.
-
-    Returns:
-        A model configured to return the structured response.
-
-    Example:
-        >>> model = create_structured_response_model(
-        ...     CodeAnalysisOutput,
-        ...     {"findings": [], "summary": {...}}
-        ... )
-    """
-
-    def structured_response_fn(messages: list[Any]) -> str:
-        instance = response_type.model_validate(response_data)
-        return instance.model_dump_json()
-
-    return create_function_model(structured_response_fn, name=f"structured_{response_type.__name__}")
-
-
-# =============================================================================
-# Mock AuditDeps Factory
-# =============================================================================
-
-
-def create_mock_deps(
-    profile: dict[str, Any] | None = None,
-    evidence: EvidenceBundle | None = None,
-    settings: Any | None = None,
-) -> AuditDeps:
-    """Create mock AuditDeps for testing agents.
-
-    Provides a factory for creating AuditDeps with sensible defaults for testing.
-
-    Args:
-        profile: Optional project profile dictionary.
-        evidence: Optional EvidenceBundle. If None, creates a minimal bundle.
-        settings: Optional LLMConfig settings.
-
-    Returns:
-        AuditDeps instance configured for testing.
-
-    Example:
-        >>> deps = create_mock_deps(
-        ...     profile={"repo_name": "test-repo", "criticality": "HIGH"},
-        ...     evidence=my_evidence_bundle,
-        ... )
-    """
-    if evidence is None:
-        evidence = create_minimal_evidence_bundle()
-
-    if profile is None:
-        profile = {
-            "repo_name": "test-repository",
-            "project_key": "TEST",
-            "domain": "insurance",
-            "service_type": "backend",
-            "criticality": "medium",
-        }
-
-    return AuditDeps(
-        evidence=evidence,
-        profile=profile,
-        settings=settings,
-    )
-
-
-def create_minimal_evidence_bundle(
-    repository: str = "test-repo",
-    git_files: list[tuple[str, str, str]] | None = None,
-) -> EvidenceBundle:
-    """Create a minimal EvidenceBundle for testing.
-
-    Args:
-        repository: Repository name.
-        git_files: Optional list of (source_id, title, content) tuples.
-
-    Returns:
-        A minimal EvidenceBundle with the specified files.
-
-    Example:
-        >>> bundle = create_minimal_evidence_bundle(
-        ...     repository="my-service",
-        ...     git_files=[("README.md", "README", "# My Service")]
-        ... )
-    """
-    if git_files is None:
-        git_files = [
-            ("README.md", "README", "# Test Repository\n\nA test repository."),
-            ("src/main.py", "Main Module", "def main():\n    pass"),
-        ]
-
-    git_evidence = [
-        Evidence(
-            source="git_file",
-            source_id=source_id,
-            title=title,
-            content=content,
-            content_hash=compute_content_hash(content),
-            status=EvidenceStatus.FOUND,
-            collected_at=datetime.now(),
-        )
-        for source_id, title, content in git_files
-    ]
-
-    return EvidenceBundle(
-        repository=repository,
-        git_evidence=git_evidence,
-    )
-
-
-def create_evidence_with_issues(
-    repository: str = "test-repo",
-    include_todos: bool = True,
-    include_fixmes: bool = True,
-    include_bare_except: bool = True,
-    include_security_issues: bool = False,
-) -> EvidenceBundle:
-    """Create an EvidenceBundle with known issues for testing detection.
-
-    Args:
-        repository: Repository name.
-        include_todos: Include TODO comments.
-        include_fixmes: Include FIXME comments.
-        include_bare_except: Include bare except clauses.
-        include_security_issues: Include potential security issues.
-
-    Returns:
-        EvidenceBundle with specified issues.
-
-    Example:
-        >>> bundle = create_evidence_with_issues(
-        ...     include_todos=True,
-        ...     include_security_issues=True
-        ... )
-    """
-    files: list[tuple[str, str, str]] = []
-
-    if include_todos:
-        files.append(
-            (
-                "src/todo_file.py",
-                "File with TODO",
-                "def incomplete():\n    # TODO: Implement this function\n    pass",
-            )
-        )
-
-    if include_fixmes:
-        files.append(
-            (
-                "src/fixme_file.py",
-                "File with FIXME",
-                "def buggy():\n    # FIXME: This has a bug\n    return None",
-            )
-        )
-
-    if include_bare_except:
-        files.append(
-            (
-                "src/bad_error_handling.py",
-                "Bad Error Handling",
-                "def risky():\n    try:\n        do_something()\n    except:\n        pass",
-            )
-        )
-
-    if include_security_issues:
-        files.append(
-            (
-                "src/security_issue.py",
-                "Security Issue",
-                'password = "hardcoded123"\napi_key = "sk-secret-key"',
-            )
-        )
-
-    return create_minimal_evidence_bundle(repository=repository, git_files=files)
-
-
-# =============================================================================
-# Assertion Helpers
-# =============================================================================
-
-
-def assert_valid_code_findings(result: CodeFindings) -> None:
-    """Assert that CodeFindings is valid and well-formed.
-
-    Validates:
-    - All issues have required fields
-    - Severity values are valid
-    - Category values are valid
-    - Score is within valid range
-
-    Args:
-        result: CodeFindings to validate.
-
-    Raises:
-        AssertionError: If validation fails.
-
-    Example:
-        >>> output = agent.run(...)
-        >>> assert_valid_code_findings(output)
-    """
-    assert isinstance(result, CodeFindings), f"Expected CodeFindings, got {type(result)}"
-
-    # Validate score
-    assert 0.0 <= result.score <= 10.0, f"Invalid score: {result.score}"
-
-    # Validate issues
-    valid_categories = {"security", "quality", "maintainability"}
-    valid_severities = {"critical", "high", "medium", "low"}
-
-    for issue in result.issues:
-        assert isinstance(issue, CodeIssue), f"Invalid issue type: {type(issue)}"
-        assert issue.category in valid_categories, f"Invalid category: {issue.category}"
-        assert issue.severity in valid_severities, f"Invalid severity: {issue.severity}"
-        assert issue.description, "Issue must have a description"
-
-    # Validate confidence
-    assert 0.0 <= result.confidence <= 1.0, f"Invalid confidence: {result.confidence}"
-
-
-def assert_valid_doc_findings(result: DocFindings) -> None:
-    """Assert that DocFindings is valid and well-formed.
-
-    Validates:
-    - All scores are within 0.0-10.0 range
-    - Overall score is within range
-    - Confidence is valid
-
-    Args:
-        result: DocFindings to validate.
-
-    Raises:
-        AssertionError: If validation fails.
-
-    Example:
-        >>> output = doc_agent.run(...)
-        >>> assert_valid_doc_findings(output)
-    """
-    assert isinstance(result, DocFindings), f"Expected DocFindings, got {type(result)}"
-
-    # Validate scores
-    assert 0.0 <= result.readme_score <= 10.0, f"Invalid readme_score: {result.readme_score}"
-    assert 0.0 <= result.confluence_score <= 10.0, f"Invalid confluence_score: {result.confluence_score}"
-    assert 0.0 <= result.api_docs_score <= 10.0, f"Invalid api_docs_score: {result.api_docs_score}"
-
-    # Validate overall score (computed property)
-    assert 0.0 <= result.overall_score <= 10.0, f"Invalid overall_score: {result.overall_score}"
-
-    # Validate confidence
-    assert 0.0 <= result.confidence <= 1.0, f"Invalid confidence: {result.confidence}"
-
-    # Validate lists
-    assert isinstance(result.notes, list), "notes must be a list"
-    assert isinstance(result.recommendations, list), "recommendations must be a list"
-
-
-def assert_valid_security_findings(result: SecurityFindings) -> None:
-    """Assert that SecurityFindings is valid and well-formed.
-
-    Validates:
-    - Posture score is valid
-    - All vulnerabilities have required fields
-    - Confidence is valid
-
-    Args:
-        result: SecurityFindings to validate.
-
-    Raises:
-        AssertionError: If validation fails.
-
-    Example:
-        >>> output = security_agent.run(...)
-        >>> assert_valid_security_findings(output)
-    """
-    assert isinstance(result, SecurityFindings), f"Expected SecurityFindings, got {type(result)}"
-
-    # Validate posture score
-    assert 0.0 <= result.posture_score <= 10.0, f"Invalid posture_score: {result.posture_score}"
-
-    # Validate vulnerabilities
-    valid_severities = {"critical", "high", "medium", "low"}
-    valid_categories = {"dependency", "code", "configuration"}
-
-    for vuln in result.vulnerabilities:
-        assert isinstance(vuln, Vulnerability), f"Invalid vulnerability type: {type(vuln)}"
-        assert vuln.severity.lower() in valid_severities, f"Invalid severity: {vuln.severity}"
-        assert vuln.category in valid_categories, f"Invalid category: {vuln.category}"
-        assert vuln.title, "Vulnerability must have a title"
-        assert vuln.description, "Vulnerability must have a description"
-
-    # Validate confidence
-    assert 0.0 <= result.confidence <= 1.0, f"Invalid confidence: {result.confidence}"
-
-
-def assert_valid_synthesis_result(result: SynthesisResult) -> None:
-    """Assert that SynthesisResult is valid and well-formed.
-
-    Validates:
-    - Overall score is within 0-100 range
-    - Maturity level is valid
-    - Required fields are present
-
-    Args:
-        result: SynthesisResult to validate.
-
-    Raises:
-        AssertionError: If validation fails.
-
-    Example:
-        >>> synthesis = synthesis_agent.synthesize(...)
-        >>> assert_valid_synthesis_result(synthesis)
-    """
-    assert isinstance(result, SynthesisResult), f"Expected SynthesisResult, got {type(result)}"
-
-    # Validate overall score
-    assert 0.0 <= result.overall_score <= 100.0, f"Invalid overall_score: {result.overall_score}"
-
-    # Validate maturity level
-    valid_levels = {"Critical", "Developing", "Established", "Optimizing", "Leading"}
-    assert result.maturity_level in valid_levels, f"Invalid maturity_level: {result.maturity_level}"
-
-    # Validate lists
-    assert isinstance(result.critical_gaps, list), "critical_gaps must be a list"
-    assert isinstance(result.aligned_practices, list), "aligned_practices must be a list"
-    assert isinstance(result.recommendations, list), "recommendations must be a list"
-
-    # Validate agent scores
-    assert isinstance(result.agent_scores, dict), "agent_scores must be a dict"
-    for agent, score in result.agent_scores.items():
-        assert isinstance(agent, str), f"Agent name must be string: {agent}"
-        assert 0.0 <= score <= 100.0, f"Invalid agent score for {agent}: {score}"
-
-
-def assert_agent_result_success(result: AgentResult) -> None:
-    """Assert that an AgentResult indicates success.
-
-    Args:
-        result: AgentResult to validate.
-
-    Raises:
-        AssertionError: If result indicates failure.
-    """
-    assert isinstance(result, AgentResult), f"Expected AgentResult, got {type(result)}"
-    assert result.success is True, f"Agent failed: {result.error}"
-    assert result.error is None, f"Unexpected error: {result.error}"
-
-
-def assert_agent_result_failure(result: AgentResult, expected_error: str | None = None) -> None:
-    """Assert that an AgentResult indicates failure.
-
-    Args:
-        result: AgentResult to validate.
-        expected_error: Optional substring that should be in the error message.
-
-    Raises:
-        AssertionError: If result indicates success or error doesn't match.
-    """
-    assert isinstance(result, AgentResult), f"Expected AgentResult, got {type(result)}"
-    assert result.success is False, "Expected agent to fail"
-    assert result.error is not None, "Expected error message"
-
-    if expected_error:
-        assert expected_error in result.error, f"Expected '{expected_error}' in error: {result.error}"
-
-
-def assert_findings_contain_type(
-    findings: list[dict[str, Any]],
-    finding_type: str,
-    min_count: int = 1,
-) -> None:
-    """Assert that findings contain a specific type.
-
-    Args:
-        findings: List of finding dictionaries.
-        finding_type: Type of finding to search for.
-        min_count: Minimum number of findings expected.
-
-    Raises:
-        AssertionError: If findings don't contain expected type.
-    """
-    matching = [f for f in findings if f.get("type") == finding_type]
-    assert len(matching) >= min_count, (
-        f"Expected at least {min_count} findings of type '{finding_type}', found {len(matching)}"
-    )
-
-
-def assert_findings_contain_severity(
-    findings: list[dict[str, Any]],
-    severity: str,
-    min_count: int = 1,
-) -> None:
-    """Assert that findings contain a specific severity level.
-
-    Args:
-        findings: List of finding dictionaries.
-        severity: Severity level to search for.
-        min_count: Minimum number of findings expected.
-
-    Raises:
-        AssertionError: If findings don't contain expected severity.
-    """
-    matching = [f for f in findings if f.get("severity", "").lower() == severity.lower()]
-    assert len(matching) >= min_count, (
-        f"Expected at least {min_count} findings with severity '{severity}', found {len(matching)}"
-    )
-
-
-# =============================================================================
-# Mock Response Factories
-# =============================================================================
-
-
-def create_mock_code_analysis_output(
-    score: float = 8.0,
-    issues: list[dict[str, Any]] | None = None,
-    patterns: list[dict[str, Any]] | None = None,
-    confidence: float = 0.8,
-    reasoning: str = "Code analysis completed successfully.",
-    files_analyzed: int = 10,
-    tech_stack: list[str] | None = None,
-) -> CodeFindings:
-    """Create a mock CodeFindings for testing.
-
-    Args:
-        score: Overall code quality score (0-10).
-        issues: Optional list of issue dictionaries.
-        patterns: Optional list of pattern dictionaries.
-        confidence: Confidence level (0-1).
-        reasoning: Explanation of the analysis.
-        files_analyzed: Number of files analyzed.
-        tech_stack: Detected technology stack.
-
-    Returns:
-        CodeFindings instance.
-    """
-    if issues is None:
-        issues = []
-
-    if patterns is None:
-        patterns = []
-
-    if tech_stack is None:
-        tech_stack = ["python"]
-
-    parsed_issues = [
-        CodeIssue(
-            file_path=i.get("file_path", "src/example.py"),
-            line_number=i.get("line_number"),
-            severity=i.get("severity", "low"),
-            category=i.get("category", "quality"),
-            description=i.get("description", "Test issue"),
-            recommendation=i.get("recommendation", ""),
-        )
-        for i in issues
-    ]
-
-    parsed_patterns = [
-        CodePattern(
-            name=p.get("name", "test_pattern"),
-            occurrences=p.get("occurrences", 1),
-            is_positive=p.get("is_positive", True),
-            description=p.get("description", ""),
-            examples=p.get("examples", []),
-        )
-        for p in patterns
-    ]
-
-    return CodeFindings(
-        score=score,
-        issues=parsed_issues,
-        patterns=parsed_patterns,
-        confidence=confidence,
-        reasoning=reasoning,
-        files_analyzed=files_analyzed,
-        tech_stack=tech_stack,
-    )
-
-
-def create_mock_doc_quality_output(
-    readme_score: float = 8.0,
-    confluence_score: float = 7.0,
-    api_docs_score: float = 6.0,
-    confidence: float = 0.8,
-    notes: list[str] | None = None,
-    missing_sections: list[str] | None = None,
-    strengths: list[str] | None = None,
-    recommendations: list[str] | None = None,
-) -> DocFindings:
-    """Create a mock DocFindings for testing.
-
-    Args:
-        readme_score: README quality score (0-10).
-        confluence_score: Confluence documentation score (0-10).
-        api_docs_score: API documentation score (0-10).
-        confidence: Confidence level (0-1).
-        notes: Observations about documentation quality.
-        missing_sections: Required sections that are missing.
-        strengths: Documentation strengths identified.
-        recommendations: Recommendations for improvement.
-
-    Returns:
-        DocFindings instance.
-    """
-    return DocFindings(
-        readme_score=readme_score,
-        confluence_score=confluence_score,
-        api_docs_score=api_docs_score,
-        confidence=confidence,
-        notes=notes or ["Documentation is well-structured."],
-        missing_sections=missing_sections or [],
-        strengths=strengths or ["Clear README"],
-        recommendations=recommendations or [],
-    )
-
-
-def create_mock_security_output(
-    posture_score: float = 8.0,
-    vulnerabilities: list[dict[str, Any]] | None = None,
-    recommendations: list[str] | None = None,
-    confidence: float = 0.8,
-    sonarqube_issues: int = 0,
-    dependency_vulnerabilities: int = 0,
-    security_controls: list[str] | None = None,
-) -> SecurityFindings:
-    """Create a mock SecurityFindings for testing.
-
-    Args:
-        posture_score: Overall security posture score (0-10).
-        vulnerabilities: Optional list of vulnerability dictionaries.
-        recommendations: Security recommendations.
-        confidence: Confidence level (0-1).
-        sonarqube_issues: Number of SonarQube security issues.
-        dependency_vulnerabilities: Number of dependency vulnerabilities.
-        security_controls: Security controls detected.
-
-    Returns:
-        SecurityFindings instance.
-    """
-    if vulnerabilities is None:
-        vulnerabilities = []
-
-    parsed_vulnerabilities = [
-        Vulnerability(
-            id=v.get("id", "VULN-001"),
-            severity=v.get("severity", "low"),
-            category=v.get("category", "configuration"),
-            title=v.get("title", "Test vulnerability"),
-            description=v.get("description", "Test security finding"),
-            affected_component=v.get("affected_component", ""),
-            remediation=v.get("remediation", ""),
-            cvss_score=v.get("cvss_score"),
-        )
-        for v in vulnerabilities
-    ]
-
-    return SecurityFindings(
-        posture_score=posture_score,
-        vulnerabilities=parsed_vulnerabilities,
-        recommendations=recommendations or ["No critical security issues found."],
-        confidence=confidence,
-        sonarqube_issues=sonarqube_issues,
-        dependency_vulnerabilities=dependency_vulnerabilities,
-        security_controls=security_controls or [],
-    )
-
-
-def create_mock_synthesis_result(
-    overall_score: float = 75.0,
-    maturity_level: str = "Established",
-    critical_gaps: list[dict[str, Any]] | None = None,
-    aligned_practices: list[dict[str, Any]] | None = None,
-    recommendations: list[dict[str, Any]] | None = None,
-    executive_summary: str = "Repository demonstrates established practices.",
-) -> SynthesisResult:
-    """Create a mock SynthesisResult for testing.
-
-    Args:
-        overall_score: Overall maturity score (0-100).
-        maturity_level: Maturity level string.
-        critical_gaps: List of critical gap dictionaries.
-        aligned_practices: List of aligned practice dictionaries.
-        recommendations: List of recommendation dictionaries.
-        executive_summary: Executive summary text.
-
-    Returns:
-        SynthesisResult instance.
-    """
-    return SynthesisResult(
-        overall_score=overall_score,
-        maturity_level=maturity_level,
-        critical_gaps=critical_gaps or [],
-        aligned_practices=aligned_practices or [],
-        recommendations=recommendations or [],
-        executive_summary=executive_summary,
-        agent_scores={
-            "CodeAnalysisAgent": 80.0,
-            "DocumentationAgent": 75.0,
-            "SecurityAgent": 70.0,
-        },
-        cross_cutting_concerns=[],
-    )
-
-
-# =============================================================================
-# Pytest Fixtures
-# =============================================================================
-
-
-@pytest.fixture
-def test_model() -> Any:
-    """Pytest fixture for a basic TestModel."""
-    return create_test_model()
-
-
-@pytest.fixture
-def mock_audit_deps() -> AuditDeps:
-    """Pytest fixture for mock AuditDeps."""
-    return create_mock_deps()
-
-
-@pytest.fixture
-def evidence_with_issues() -> EvidenceBundle:
-    """Pytest fixture for evidence bundle with known issues."""
-    return create_evidence_with_issues(
-        include_todos=True,
-        include_fixmes=True,
-        include_bare_except=True,
-    )
-
-
-@pytest.fixture
-def clean_evidence() -> EvidenceBundle:
-    """Pytest fixture for clean evidence bundle without issues."""
-    return create_minimal_evidence_bundle(
-        git_files=[
-            ("README.md", "README", "# Clean Project\n\nWell-documented project."),
-            (
-                "src/main.py",
-                "Main",
-                '"""Main module with proper docstrings."""\n\ndef main() -> None:\n    """Entry point."""\n    print("Hello")',
-            ),
-        ]
-    )
-
-
-@pytest.fixture
-def mock_code_output() -> CodeFindings:
-    """Pytest fixture for mock CodeFindings."""
-    return create_mock_code_analysis_output()
-
-
-@pytest.fixture
-def mock_doc_output() -> DocFindings:
-    """Pytest fixture for mock DocFindings."""
-    return create_mock_doc_quality_output()
-
-
-@pytest.fixture
-def mock_security_output() -> SecurityFindings:
-    """Pytest fixture for mock SecurityFindings."""
-    return create_mock_security_output()
-
-
-# =============================================================================
-# Example Tests Demonstrating Usage
-# =============================================================================
-
-
-class TestExampleUsage:
-    """Example tests demonstrating how to use the test utilities."""
-
-    @pytest.mark.asyncio
-    async def test_code_agent_with_test_model(self, evidence_with_issues: EvidenceBundle) -> None:
-        """Example of testing CodeAgent with TestModel.
-
-        This test demonstrates how to:
-        1. Create a deterministic test model
-        2. Configure an agent with the test model
-        3. Run analysis without making LLM calls
-        4. Validate the output using assertion helpers
-        """
-        from unittest.mock import AsyncMock, patch
-
-        from vds_audit_orchestrator.agents.code_agent import CodeAnalysisAgent
-        from vds_audit_orchestrator.llm.provider import LLMSettings
-
-        # Create mock settings with LLM enabled
-        settings = LLMSettings()
-        settings.enabled = True
-
-        # Create expected LLM output
-        mock_output = create_mock_code_analysis_output(
-            score=6.0,
-            issues=[
-                {
-                    "category": "maintainability",
-                    "severity": "medium",
-                    "description": "TODO comment found",
-                    "file_path": "src/todo_file.py",
-                }
-            ],
-        )
-
-        # Create agent and mock the LLM call
-        agent = CodeAnalysisAgent(settings=settings)
-
-        with (
-            patch.object(agent, "_scan_security_patterns", AsyncMock(return_value=[])),
-            patch.object(agent, "_run_pydantic_ai_analysis", AsyncMock(return_value=mock_output)),
-        ):
-            result = await agent.analyze(evidence_with_issues)
-
-        # Validate result using assertion helpers
-        assert_agent_result_success(result)
-        assert result.metadata.get("files_analyzed", 0) >= 0
-
-        # Validate LLM output was processed correctly (pydantic_ai_analysis source)
-        llm_findings = [f for f in result.findings if f.get("source") == "pydantic_ai_analysis"]
-        assert len(llm_findings) >= 1
-
-    @pytest.mark.asyncio
-    async def test_code_agent_pattern_matching_only(self, evidence_with_issues: EvidenceBundle) -> None:
-        """Example of testing CodeAgent pattern matching without LLM.
-
-        This test demonstrates testing the deterministic pattern matching
-        functionality independently of LLM analysis.
-        """
-        from unittest.mock import AsyncMock, patch
-
-        from vds_audit_orchestrator.agents.code_agent import CodeAnalysisAgent
-        from vds_audit_orchestrator.llm.provider import LLMSettings
-
-        # Disable LLM to test pattern matching only
-        settings = LLMSettings()
-        settings.enabled = False
-
-        agent = CodeAnalysisAgent(settings=settings)
-
-        with patch.object(agent, "_scan_security_patterns", AsyncMock(return_value=[])):
-            result = await agent.analyze(evidence_with_issues)
-
-        # Validate result
-        assert_agent_result_success(result)
-
-        # Check pattern matching found expected issues
-        pattern_findings = [f for f in result.findings if f.get("source") == "pattern_scan"]
-        assert len(pattern_findings) > 0
-
-        # Verify TODO was detected
-        todo_findings = [f for f in pattern_findings if "TODO" in f.get("description", "")]
-        assert len(todo_findings) >= 1
-
-    def test_assertion_helpers_valid_code_output(self, mock_code_output: CodeFindings) -> None:
-        """Example of using assertion helpers for CodeFindings validation."""
-        # This should not raise
-        assert_valid_code_findings(mock_code_output)
-
-    def test_assertion_helpers_valid_doc_output(self, mock_doc_output: DocFindings) -> None:
-        """Example of using assertion helpers for DocFindings validation."""
-        # This should not raise
-        assert_valid_doc_findings(mock_doc_output)
-
-    def test_assertion_helpers_valid_security_output(self, mock_security_output: SecurityFindings) -> None:
-        """Example of using assertion helpers for SecurityFindings validation."""
-        # This should not raise
-        assert_valid_security_findings(mock_security_output)
-
-    def test_mock_deps_creation(self) -> None:
-        """Example of creating mock AuditDeps with custom configuration."""
-        custom_evidence = create_evidence_with_issues(include_security_issues=True)
-
-        deps = create_mock_deps(
-            profile={
-                "repo_name": "security-critical-service",
-                "criticality": "critical",
-                "has_pii": True,
-            },
-            evidence=custom_evidence,
-        )
-
-        assert deps.profile is not None
-        assert deps.profile["repo_name"] == "security-critical-service"
-        assert deps.evidence is not None
-        assert len(deps.evidence.git_evidence) > 0
-
-    def test_structured_response_model(self) -> None:
-        """Example of creating a structured response model."""
-        response_data = {
-            "score": 8.0,
-            "issues": [
-                {
-                    "file_path": "src/example.py",
-                    "severity": "low",
-                    "category": "quality",
-                    "description": "Good structure",
-                }
-            ],
-            "patterns": [],
-            "confidence": 0.8,
-            "reasoning": "Analysis complete",
-            "files_analyzed": 5,
-            "tech_stack": ["python"],
-        }
-
-        model = create_structured_response_model(CodeFindings, response_data)
-        assert model is not None
-
-    def test_findings_assertion_helpers(self) -> None:
-        """Example of using findings assertion helpers."""
-        findings = [
-            {"type": "technical_debt", "severity": "low", "description": "TODO found"},
-            {"type": "technical_debt", "severity": "medium", "description": "FIXME found"},
-            {"type": "error_handling", "severity": "high", "description": "Bare except"},
-        ]
-
-        # These should not raise
-        assert_findings_contain_type(findings, "technical_debt", min_count=2)
-        assert_findings_contain_severity(findings, "high", min_count=1)
-
-        # This should raise
-        with pytest.raises(AssertionError):
-            assert_findings_contain_type(findings, "security", min_count=1)