@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/integration/test_mcp_integration.py

@@ -1,741 +0,0 @@
-"""MCP Tool Integration Tests for Audit Orchestrator (TSK-095).
-
-Tests MCP toolset configuration and tool invocation patterns using
-PydanticAI's capture_run_messages pattern. These tests verify that
-agents correctly use MCP tools without requiring live MCP servers.
-
-Reference: TSK-095 - Verify MCP Tool Usage with integration tests
-"""
-
-from __future__ import annotations
-
-import json
-from typing import Any
-from unittest.mock import MagicMock, patch
-
-import pytest
-from vds_audit_orchestrator.agents.toolsets.mcp_toolset import (
-    AuditMCPToolset,
-    MCPServerConfig,
-    MCPToolsetConfig,
-    MCPToolsetError,
-    create_mcp_toolset,
-    get_default_vds_mcp_config,
-)
-from vds_audit_orchestrator.agents.toolsets.skills_toolset import (
-    SkillExecutionResult,
-    SkillInfo,
-    SkillsToolsetConfig,
-    create_skills_toolset_from_config,
-)
-from vds_audit_orchestrator.models.evidence import Evidence, EvidenceBundle, EvidenceStatus
-
-# =============================================================================
-# Test Fixtures
-# =============================================================================
-
-
-@pytest.fixture
-def mock_mcp_config() -> dict[str, Any]:
-    """Mock MCP configuration for testing."""
-    return {
-        "mcpServers": {
-            "git": {
-                "command": "npx",
-                "args": ["-y", "@anthropic/mcp-git"],
-                "env": {},
-            },
-            "confluence": {
-                "command": "npx",
-                "args": ["-y", "@anthropic/mcp-confluence"],
-                "env": {
-                    "CONFLUENCE_BASE_URL": "https://confluence.example.com",
-                    "CONFLUENCE_TOKEN": "test-token",
-                },
-            },
-            "sonarqube": {
-                "command": "npx",
-                "args": ["-y", "@vds/mcp-sonarqube"],
-                "env": {
-                    "SONARQUBE_BASE_URL": "https://sonar.example.com",
-                    "SONARQUBE_TOKEN": "test-token",
-                },
-            },
-            "filesystem": {
-                "command": "npx",
-                "args": ["-y", "@anthropic/mcp-filesystem", "/tmp"],
-                "env": {},
-            },
-        }
-    }
-
-
-@pytest.fixture
-def mock_mcp_toolset_config() -> MCPToolsetConfig:
-    """Create a mock MCPToolsetConfig for testing."""
-    return MCPToolsetConfig(
-        mcpServers={
-            "git": MCPServerConfig(
-                command="npx",
-                args=["-y", "@anthropic/mcp-git"],
-                enabled=True,
-            ),
-            "confluence": MCPServerConfig(
-                command="npx",
-                args=["-y", "@anthropic/mcp-confluence"],
-                env={
-                    "CONFLUENCE_BASE_URL": "https://confluence.example.com",
-                    "CONFLUENCE_TOKEN": "test-token",
-                },
-                enabled=True,
-            ),
-            "sonarqube": MCPServerConfig(
-                command="npx",
-                args=["-y", "@vds/mcp-sonarqube"],
-                env={
-                    "SONARQUBE_BASE_URL": "https://sonar.example.com",
-                    "SONARQUBE_TOKEN": "test-token",
-                },
-                enabled=True,
-            ),
-        }
-    )
-
-
-@pytest.fixture
-def mock_skills_config() -> SkillsToolsetConfig:
-    """Create a mock SkillsToolsetConfig for testing."""
-    return SkillsToolsetConfig(
-        directories=["/tmp/skills"],
-        validate_skills=True,
-        script_timeout=60,
-        allowlist=["grepai", "vds-cli"],
-    )
-
-
-@pytest.fixture
-def mock_evidence_bundle() -> EvidenceBundle:
-    """Create a mock evidence bundle for agent testing."""
-    return EvidenceBundle(
-        repository="test-repo",
-        git_evidence=[
-            Evidence(
-                source="git_file",
-                source_id="src/main.py",
-                title="Main App",
-                content="def main():\n    # TODO: Implement feature\n    pass",
-                content_hash="hash1",
-                status=EvidenceStatus.FOUND,
-            ),
-            Evidence(
-                source="git_file",
-                source_id="README.md",
-                title="README",
-                content="# Test Project\n\nA test project for MCP integration.",
-                content_hash="hash2",
-                status=EvidenceStatus.FOUND,
-            ),
-        ],
-        sonarqube_evidence=[
-            Evidence(
-                source="sonarqube_metric",
-                source_id="test-repo",
-                title="Quality Gate",
-                content=json.dumps(
-                    {
-                        "issues": [
-                            {
-                                "key": "issue-1",
-                                "severity": "MAJOR",
-                                "message": "Security issue detected",
-                                "component": "src/auth.py",
-                                "rule": "security:S123",
-                            }
-                        ]
-                    }
-                ),
-                content_hash="hash3",
-                status=EvidenceStatus.FOUND,
-            )
-        ],
-        confluence_evidence=[
-            Evidence(
-                source="confluence_page",
-                source_id="12345",
-                title="Architecture",
-                content="<h1>Architecture</h1><p>System architecture documentation.</p>",
-                content_hash="hash4",
-                status=EvidenceStatus.FOUND,
-                source_url="https://confluence.example.com/12345",
-            )
-        ],
-    )
-
-
-# =============================================================================
-# MCP Toolset Initialization Tests
-# =============================================================================
-
-
-class TestMCPToolsetInitialization:
-    """Tests for MCP toolset configuration and initialization."""
-
-    def test_mcp_server_config_creation(self):
-        """Test MCPServerConfig can be created with all fields."""
-        config = MCPServerConfig(
-            command="npx",
-            args=["-y", "@anthropic/mcp-git"],
-            env={"GIT_TOKEN": "secret"},
-            url=None,
-            enabled=True,
-        )
-        assert config.command == "npx"
-        assert config.args == ["-y", "@anthropic/mcp-git"]
-        assert config.env == {"GIT_TOKEN": "secret"}
-        assert config.enabled is True
-
-    def test_mcp_toolset_config_to_fastmcp(self, mock_mcp_toolset_config: MCPToolsetConfig):
-        """Test MCPToolsetConfig converts to FastMCPToolset format."""
-        result = mock_mcp_toolset_config.to_fastmcp_config()
-
-        assert "mcpServers" in result
-        assert "git" in result["mcpServers"]
-        assert "confluence" in result["mcpServers"]
-        assert "sonarqube" in result["mcpServers"]
-
-        # Verify git server config
-        git_config = result["mcpServers"]["git"]
-        assert git_config["command"] == "npx"
-        assert git_config["args"] == ["-y", "@anthropic/mcp-git"]
-
-    def test_mcp_toolset_config_disabled_servers_excluded(self):
-        """Test that disabled servers are excluded from FastMCPToolset config."""
-        config = MCPToolsetConfig(
-            mcpServers={
-                "git": MCPServerConfig(
-                    command="npx",
-                    args=["-y", "@anthropic/mcp-git"],
-                    enabled=True,
-                ),
-                "disabled_server": MCPServerConfig(
-                    command="npx",
-                    args=["-y", "@some/mcp-disabled"],
-                    enabled=False,
-                ),
-            }
-        )
-
-        result = config.to_fastmcp_config()
-        assert "git" in result["mcpServers"]
-        assert "disabled_server" not in result["mcpServers"]
-
-    def test_audit_mcp_toolset_from_dict(self, mock_mcp_config: dict[str, Any]):
-        """Test AuditMCPToolset initialization from dict config."""
-        toolset = AuditMCPToolset(config=mock_mcp_config)
-
-        server_names = toolset.get_server_names()
-        assert "git" in server_names
-        assert "confluence" in server_names
-        assert "sonarqube" in server_names
-        assert "filesystem" in server_names
-
-    def test_audit_mcp_toolset_with_enabled_servers_filter(self, mock_mcp_config: dict[str, Any]):
-        """Test AuditMCPToolset filters to enabled servers only."""
-        toolset = AuditMCPToolset(
-            config=mock_mcp_config,
-            enabled_servers=["git", "sonarqube"],
-        )
-
-        server_names = toolset.get_server_names()
-        assert "git" in server_names
-        assert "sonarqube" in server_names
-        assert "confluence" not in server_names
-        assert "filesystem" not in server_names
-
-    def test_audit_mcp_toolset_with_mcp_toolset_config(self, mock_mcp_toolset_config: MCPToolsetConfig):
-        """Test AuditMCPToolset initialization from MCPToolsetConfig."""
-        toolset = AuditMCPToolset(config=mock_mcp_toolset_config)
-
-        server_names = toolset.get_server_names()
-        assert "git" in server_names
-        assert "confluence" in server_names
-        assert "sonarqube" in server_names
-
-    def test_create_mcp_toolset_factory(self, monkeypatch):
-        """Test create_mcp_toolset factory function."""
-        # Clear any existing environment config
-        monkeypatch.delenv("VDS_AUDIT_MCP_CONFIG_PATH", raising=False)
-
-        toolset = create_mcp_toolset(enabled_servers=["git"])
-
-        # Should use defaults with only git enabled
-        server_names = toolset.get_server_names()
-        assert "git" in server_names
-
-    def test_create_mcp_toolset_from_env(self, monkeypatch, tmp_path):
-        """Test create_mcp_toolset reads from environment variable."""
-        config_file = tmp_path / "mcp_config.json"
-        config_data = {
-            "mcpServers": {
-                "test_server": {
-                    "command": "test-cmd",
-                    "args": ["--test"],
-                }
-            }
-        }
-        config_file.write_text(json.dumps(config_data))
-
-        monkeypatch.setenv("VDS_AUDIT_MCP_CONFIG_PATH", str(config_file))
-
-        toolset = create_mcp_toolset()
-        server_names = toolset.get_server_names()
-        assert "test_server" in server_names
-
-    def test_get_default_vds_mcp_config(self, monkeypatch):
-        """Test get_default_vds_mcp_config returns expected servers."""
-        # Clear any credentials to test base config
-        monkeypatch.delenv("CONFLUENCE_BASE_URL", raising=False)
-        monkeypatch.delenv("CONFLUENCE_TOKEN", raising=False)
-        monkeypatch.delenv("JIRA_BASE_URL", raising=False)
-        monkeypatch.delenv("JIRA_TOKEN", raising=False)
-        monkeypatch.delenv("SONARQUBE_BASE_URL", raising=False)
-        monkeypatch.delenv("SONARQUBE_TOKEN", raising=False)
-
-        config = get_default_vds_mcp_config()
-
-        # Git and filesystem should always be available
-        assert "git" in config.mcpServers
-        assert "filesystem" in config.mcpServers
-        assert config.mcpServers["git"].enabled is True
-        assert config.mcpServers["filesystem"].enabled is True
-
-    def test_mcp_toolset_error_on_invalid_path(self):
-        """Test MCPToolsetError raised for non-existent config path."""
-        toolset = AuditMCPToolset(config="/nonexistent/path/config.json")
-
-        with pytest.raises(MCPToolsetError) as exc_info:
-            toolset.get_server_names()
-
-        assert "not found" in str(exc_info.value).lower()
-
-
-# =============================================================================
-# Skills Toolset Tests
-# =============================================================================
-
-
-class TestSkillsToolsetExecution:
-    """Tests for skills toolset configuration and execution."""
-
-    def test_skills_toolset_config_creation(self):
-        """Test SkillsToolsetConfig creation with all fields."""
-        config = SkillsToolsetConfig(
-            directories=["/path/to/skills", "/another/skills"],
-            validate_skills=True,
-            script_timeout=120,
-            allowlist=["skill1", "skill2"],
-        )
-
-        assert config.directories == ["/path/to/skills", "/another/skills"]
-        assert config.validate_skills is True
-        assert config.script_timeout == 120
-        assert config.allowlist == ["skill1", "skill2"]
-
-    def test_skills_toolset_config_defaults(self):
-        """Test SkillsToolsetConfig default values."""
-        config = SkillsToolsetConfig()
-
-        assert config.directories == []
-        assert config.validate_skills is True
-        assert config.script_timeout == 60
-        assert config.allowlist == []
-
-    def test_skill_info_dataclass(self):
-        """Test SkillInfo dataclass creation."""
-        skill = SkillInfo(
-            name="grepai",
-            description="Semantic code search",
-            path="/skills/grepai",
-        )
-
-        assert skill.name == "grepai"
-        assert skill.description == "Semantic code search"
-        assert skill.path == "/skills/grepai"
-
-    def test_skill_execution_result_success(self):
-        """Test SkillExecutionResult for successful execution."""
-        result = SkillExecutionResult(
-            success=True,
-            output={"findings": ["item1", "item2"]},
-            error=None,
-        )
-
-        assert result.success is True
-        assert result.output == {"findings": ["item1", "item2"]}
-        assert result.error is None
-
-    def test_skill_execution_result_failure(self):
-        """Test SkillExecutionResult for failed execution."""
-        result = SkillExecutionResult(
-            success=False,
-            output=None,
-            error="Skill execution timed out",
-        )
-
-        assert result.success is False
-        assert result.output is None
-        assert result.error == "Skill execution timed out"
-
-    @patch("pydantic_ai_skills.SkillsToolset")
-    def test_create_skills_toolset_from_config(
-        self, mock_skills_toolset_class, mock_skills_config: SkillsToolsetConfig
-    ):
-        """Test create_skills_toolset_from_config creates toolset correctly."""
-        mock_toolset_instance = MagicMock()
-        mock_skills_toolset_class.return_value = mock_toolset_instance
-
-        # Note: This will raise RuntimeError in real execution if pydantic-ai-skills
-        # is not installed. We mock to test the flow.
-        try:
-            _ = create_skills_toolset_from_config(mock_skills_config)
-            # If it succeeds, verify mock was called
-            mock_skills_toolset_class.assert_called_once()
-        except RuntimeError as e:
-            # Expected if pydantic-ai-skills is not installed
-            assert "pydantic-ai-skills is required" in str(e)
-
-
-# =============================================================================
-# Agent MCP Tool Usage Tests
-# =============================================================================
-
-
-class TestCodeAgentMCPToolUsage:
-    """Tests for CodeAnalysisAgent MCP tool invocation.
-
-    Note: Phase 23 (FR-1) removed grepai from the audit workflow.
-    CodeAnalysisAgent now uses SecurityPatternScanner for scoped security scanning.
-    """
-
-    @pytest.mark.asyncio
-    async def test_code_agent_uses_pattern_scanner(self, mock_evidence_bundle: EvidenceBundle):
-        """Test that CodeAnalysisAgent uses SecurityPatternScanner for security scanning.
-
-        Phase 23 (FR-1): grepai has been replaced with SecurityPatternScanner
-        for scoped security scanning.
-        """
-        from vds_audit_orchestrator.agents.code_agent import CodeAnalysisAgent
-
-        agent = CodeAnalysisAgent(settings=MagicMock(enabled=False))
-        result = await agent.analyze(mock_evidence_bundle)
-
-        assert result.success is True
-        assert result.metadata["files_analyzed"] == 2
-        # Pattern matching layer should be present
-        assert "pattern_matching" in result.metadata["analysis_layers"]
-
-    @pytest.mark.asyncio
-    async def test_code_agent_pattern_scanner_scoped(self, mock_evidence_bundle: EvidenceBundle):
-        """Test CodeAnalysisAgent uses scoped pattern scanning (not grepai).
-
-        Phase 23 (FR-1): Security scanning is now scoped to the target repository
-        using SecurityPatternScanner instead of grepai.
-        """
-        from vds_audit_orchestrator.agents.code_agent import CodeAnalysisAgent
-
-        agent = CodeAnalysisAgent(settings=MagicMock(enabled=False))
-        result = await agent.analyze(mock_evidence_bundle)
-
-        # Verify pattern matching was used (not grepai)
-        assert result.success is True
-        # Pattern scanner is skipped when repo_path is not available
-        # but pattern_matching layer should still work
-        assert "pattern_matching" in result.metadata["analysis_layers"]
-
-
-class TestSecurityAgentMCPToolUsage:
-    """Tests for SecurityAgent MCP tool invocation."""
-
-    @pytest.mark.asyncio
-    @pytest.mark.asyncio
-    async def test_security_agent_uses_sonarqube_tools(self, mock_evidence_bundle: EvidenceBundle):
-        """Test that SecurityAgent can use SonarQube-related tools."""
-        from vds_audit_orchestrator.agents.security_agent import SecurityAgent
-
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-
-        agent = SecurityAgent(settings=mock_settings)
-        result = await agent.analyze(mock_evidence_bundle)
-
-        assert result.success is True
-
-        # Verify SonarQube evidence was parsed
-        assert result.metadata["sonarqube_issues_parsed"] == 1
-
-        # Verify findings include SonarQube data
-        sq_findings = [f for f in result.findings if f.get("source") == "sonarqube"]
-        assert len(sq_findings) >= 1
-
-    @pytest.mark.asyncio
-    @patch("vds_audit_orchestrator.agents.security_agent.SecurityPatternScanner")
-    async def test_security_agent_uses_pattern_scanner(self, mock_scanner_class, mock_evidence_bundle: EvidenceBundle):
-        """Test SecurityAgent uses SecurityPatternScanner for security scanning.
-
-        Phase 23 (FR-1): grepai has been replaced with SecurityPatternScanner
-        for scoped security scanning.
-        """
-        from vds_audit_orchestrator.agents.security_agent import SecurityAgent
-
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-
-        # Mock the scanner to return some findings
-        mock_scanner = MagicMock()
-        mock_scanner.scan.return_value = []
-        mock_scanner_class.return_value = mock_scanner
-
-        agent = SecurityAgent(settings=mock_settings)
-        result = await agent.analyze(mock_evidence_bundle)
-
-        assert result.success is True
-        # SonarQube evidence should still be parsed
-        assert result.metadata["sonarqube_issues_parsed"] == 1
-
-
-class TestDocsAgentMCPToolUsage:
-    """Tests for DocumentationAgent MCP tool invocation."""
-
-    @pytest.mark.asyncio
-    async def test_docs_agent_uses_confluence_tools(self, mock_evidence_bundle: EvidenceBundle):
-        """Test that DocumentationAgent can use Confluence-related tools."""
-        from vds_audit_orchestrator.agents.docs_agent import DocumentationAgent
-
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-
-        agent = DocumentationAgent(settings=mock_settings)
-        result = await agent.analyze(mock_evidence_bundle)
-
-        assert result.success is True
-
-        # Verify Confluence evidence was processed
-        assert result.metadata["confluence_count"] == 1
-
-    @pytest.mark.asyncio
-    async def test_docs_agent_analyzes_readme_from_git(self, mock_evidence_bundle: EvidenceBundle):
-        """Test DocumentationAgent analyzes README from git evidence."""
-        from vds_audit_orchestrator.agents.docs_agent import DocumentationAgent
-
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-
-        agent = DocumentationAgent(settings=mock_settings)
-        result = await agent.analyze(mock_evidence_bundle)
-
-        assert result.success is True
-        assert result.metadata["readme_count"] == 1
-
-
-# =============================================================================
-# MCP Tool Message Capture Tests (PydanticAI Pattern)
-# =============================================================================
-
-
-class TestMCPToolMessageCapture:
-    """Tests using PydanticAI's capture_run_messages pattern for tool verification."""
-
-    @pytest.mark.asyncio
-    async def test_capture_tool_calls_pattern(self):
-        """Demonstrate the capture_run_messages pattern for MCP tool verification.
-
-        This test shows how to use PydanticAI's capture_run_messages to verify
-        that agents correctly invoke MCP tools during execution.
-        """
-        # Note: This is a demonstration of the pattern. In practice, you would
-        # use the actual agent with a TestModel.
-        try:
-            from pydantic_ai import Agent, capture_run_messages
-            from pydantic_ai.models.test import TestModel
-
-            # Create a simple test agent
-            agent = Agent(
-                model=TestModel(),
-                instructions="Analyze the provided code.",
-                output_type=str,
-            )
-
-            # Capture messages during run
-            with capture_run_messages() as messages:
-                _ = await agent.run("Analyze this code: def foo(): pass")
-
-            # In a real test, you would verify tool_name in message parts
-            assert len(messages) > 0
-
-        except ImportError:
-            # Skip if pydantic-ai not fully installed
-            pytest.skip("pydantic-ai with TestModel not available")
-
-    @pytest.mark.asyncio
-    async def test_mock_mcp_server_fixture(self, mock_mcp_config: dict[str, Any]):
-        """Test that mock MCP server fixtures provide correct structure."""
-        # Verify fixture structure matches expected MCP config format
-        assert "mcpServers" in mock_mcp_config
-
-        for _server_name, server_config in mock_mcp_config["mcpServers"].items():
-            assert "command" in server_config
-            assert "args" in server_config
-            assert isinstance(server_config["args"], list)
-
-    @pytest.mark.asyncio
-    async def test_tool_invocation_logging(self, mock_evidence_bundle: EvidenceBundle):
-        """Test that tool invocations are logged for verification."""
-        from vds_audit_orchestrator.agents.code_agent import CodeAnalysisAgent
-
-        agent = CodeAnalysisAgent(settings=MagicMock(enabled=False))
-        result = await agent.analyze(mock_evidence_bundle)
-
-        # Verify analysis layers are tracked (indicates tool usage)
-        assert "analysis_layers" in result.metadata
-        assert "pattern_matching" in result.metadata["analysis_layers"]
-
-
-# =============================================================================
-# Error Handling Tests
-# =============================================================================
-
-
-class TestMCPToolErrorHandling:
-    """Tests for MCP tool error handling and graceful degradation."""
-
-    @pytest.mark.asyncio
-    async def test_code_agent_handles_mcp_tool_timeout(self, mock_evidence_bundle: EvidenceBundle):
-        """Test CodeAnalysisAgent handles MCP tool timeout gracefully."""
-        from vds_audit_orchestrator.agents.code_agent import CodeAnalysisAgent
-
-        agent = CodeAnalysisAgent(settings=MagicMock(enabled=False))
-        result = await agent.analyze(mock_evidence_bundle)
-
-        # Should succeed - CodeAnalysisAgent no longer uses grepai
-        assert result.success is True
-
-        # Should still have pattern findings (local analysis)
-        pattern_findings = [f for f in result.findings if f.get("source") == "pattern_scan"]
-        assert len(pattern_findings) > 0
-
-    @pytest.mark.asyncio
-    async def test_security_agent_handles_mcp_tool_unavailable(self, mock_evidence_bundle: EvidenceBundle):
-        """Test SecurityAgent handles MCP tool unavailability gracefully."""
-        from vds_audit_orchestrator.agents.security_agent import SecurityAgent
-
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-
-        agent = SecurityAgent(settings=mock_settings)
-        result = await agent.analyze(mock_evidence_bundle)
-
-        # Should succeed - SecurityAgent no longer uses grepai
-        assert result.success is True
-
-        # SonarQube findings should still be present
-        sq_findings = [f for f in result.findings if f.get("source") == "sonarqube"]
-        assert len(sq_findings) >= 1
-
-    def test_mcp_toolset_handles_invalid_config_gracefully(self):
-        """Test AuditMCPToolset handles invalid configuration gracefully."""
-        invalid_config = {"invalid": "config"}
-
-        toolset = AuditMCPToolset(config=invalid_config)
-        server_names = toolset.get_server_names()
-
-        # Should return empty list for invalid config
-        assert server_names == []
-
-
-# =============================================================================
-# Integration Smoke Tests
-# =============================================================================
-
-
-class TestMCPIntegrationSmoke:
-    """Smoke tests for MCP integration without live servers."""
-
-    def test_all_mcp_components_importable(self):
-        """Test that all MCP-related components can be imported."""
-        from vds_audit_orchestrator.agents.toolsets.mcp_toolset import (
-            AuditMCPToolset,
-            MCPServerConfig,
-            MCPToolsetConfig,
-            MCPToolsetError,
-            create_mcp_toolset,
-            get_default_vds_mcp_config,
-        )
-        from vds_audit_orchestrator.agents.toolsets.skills_toolset import (
-            SkillExecutionResult,
-            SkillInfo,
-            SkillsToolsetConfig,
-        )
-
-        # Verify all components are accessible
-        assert AuditMCPToolset is not None
-        assert MCPServerConfig is not None
-        assert MCPToolsetConfig is not None
-        assert MCPToolsetError is not None
-        assert create_mcp_toolset is not None
-        assert get_default_vds_mcp_config is not None
-        assert SkillExecutionResult is not None
-        assert SkillInfo is not None
-        assert SkillsToolsetConfig is not None
-
-    def test_default_mcp_config_structure(self, monkeypatch):
-        """Test default MCP config has expected structure."""
-        # Clear credentials to test base structure
-        for var in [
-            "CONFLUENCE_BASE_URL",
-            "CONFLUENCE_TOKEN",
-            "JIRA_BASE_URL",
-            "JIRA_TOKEN",
-            "SONARQUBE_BASE_URL",
-            "SONARQUBE_TOKEN",
-        ]:
-            monkeypatch.delenv(var, raising=False)
-
-        config = get_default_vds_mcp_config()
-        fastmcp_config = config.to_fastmcp_config()
-
-        # Verify structure
-        assert "mcpServers" in fastmcp_config
-        assert isinstance(fastmcp_config["mcpServers"], dict)
-
-        # Git should always be present
-        assert "git" in fastmcp_config["mcpServers"]
-        git_config = fastmcp_config["mcpServers"]["git"]
-        assert "command" in git_config
-        assert git_config["command"] == "npx"
-
-    @pytest.mark.asyncio
-    async def test_agents_work_without_mcp_servers(self, mock_evidence_bundle: EvidenceBundle):
-        """Test that agents work without live MCP servers."""
-        from vds_audit_orchestrator.agents.code_agent import CodeAnalysisAgent
-        from vds_audit_orchestrator.agents.docs_agent import DocumentationAgent
-        from vds_audit_orchestrator.agents.security_agent import SecurityAgent
-
-        # CodeAnalysisAgent no longer uses grepai
-        code_agent = CodeAnalysisAgent(settings=MagicMock(enabled=False))
-        code_result = await code_agent.analyze(mock_evidence_bundle)
-        assert code_result.success is True
-
-        # SecurityAgent no longer uses grepai
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-
-        security_agent = SecurityAgent(settings=mock_settings)
-        security_result = await security_agent.analyze(mock_evidence_bundle)
-        assert security_result.success is True
-
-        mock_doc_settings = MagicMock()
-        mock_doc_settings.enabled = False
-
-        docs_agent = DocumentationAgent(settings=mock_doc_settings)
-        docs_result = await docs_agent.analyze(mock_evidence_bundle)
-        assert docs_result.success is True