atlas-chat 0.1.0__py3-none-any.whl

atlas/tests/modules/mcp_tools/test_client_auth.py

@@ -0,0 +1,226 @@
+from unittest.mock import ANY, AsyncMock, Mock, patch
+
+import pytest
+
+from atlas.modules.mcp_tools.client import MCPToolManager
+
+
+class TestMCPClientAuthentication:
+    """Test MCP client initialization with authentication."""
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    async def test_http_client_with_env_var_token(self, mock_client_class, monkeypatch):
+        """Should resolve env var and pass token to HTTP client."""
+        monkeypatch.setenv("MCP_AUTH_TOKEN", "secret-token-123")
+
+        server_config = {
+            "url": "http://localhost:8000/mcp",
+            "transport": "http",
+            "auth_token": "${MCP_AUTH_TOKEN}"
+        }
+
+        # Create a dummy MCPToolManager instance to call _initialize_single_client
+        # We need to mock the config_manager.mcp_config.servers to return our server_config
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            # Manually set servers_config for the manager
+            manager.servers_config = {"test-server": server_config}
+
+            await manager._initialize_single_client("test-server", server_config)
+
+        mock_client_class.assert_called_once_with(
+            "http://localhost:8000/mcp",
+            auth="secret-token-123",
+            log_handler=ANY,
+            elicitation_handler=ANY,
+            sampling_handler=ANY,
+        )
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    async def test_http_client_with_literal_token(self, mock_client_class):
+        """Should pass literal token string to HTTP client."""
+        mock_client = AsyncMock()
+        mock_client_class.return_value = mock_client
+
+        server_config = {
+            "url": "http://localhost:8000/mcp",
+            "transport": "http",
+            "auth_token": "direct-token-456"
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            manager.servers_config = {"test-server": server_config}
+
+            await manager._initialize_single_client("test-server", server_config)
+
+        mock_client_class.assert_called_once_with(
+            "http://localhost:8000/mcp",
+            auth="direct-token-456",
+            log_handler=ANY,
+            elicitation_handler=ANY,
+            sampling_handler=ANY,
+        )
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    async def test_http_client_without_token(self, mock_client_class):
+        """Should pass None when no auth_token specified."""
+        mock_client = AsyncMock()
+        mock_client_class.return_value = mock_client
+
+        server_config = {
+            "url": "http://localhost:8000/mcp",
+            "transport": "http"
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            manager.servers_config = {"test-server": server_config}
+
+            await manager._initialize_single_client("test-server", server_config)
+
+        mock_client_class.assert_called_once_with(
+            "http://localhost:8000/mcp",
+            auth=None,
+            log_handler=ANY,
+            elicitation_handler=ANY,
+            sampling_handler=ANY,
+        )
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    async def test_sse_client_with_token(self, mock_client_class):
+        """Should pass auth token to SSE client."""
+        mock_client = AsyncMock()
+        mock_client_class.return_value = mock_client
+
+        server_config = {
+            "url": "http://localhost:8000/sse",
+            "transport": "sse",
+            "auth_token": "sse-token-789"
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            manager.servers_config = {"test-server": server_config}
+
+            await manager._initialize_single_client("test-server", server_config)
+
+        mock_client_class.assert_called_once_with(
+            "http://localhost:8000/sse",
+            auth="sse-token-789",
+            log_handler=ANY,
+            elicitation_handler=ANY,
+            sampling_handler=ANY,
+        )
+
+    @pytest.mark.asyncio
+    async def test_missing_env_var_raises_error(self, caplog):
+        """Should fail gracefully and log error when env var is missing."""
+        server_config = {
+            "url": "http://localhost:8000/mcp",
+            "transport": "http",
+            "auth_token": "${MISSING_TOKEN_VAR}"
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            manager.servers_config = {"test-server": server_config}
+
+            # Client initialization should return None when env var is missing
+            result = await manager._initialize_single_client("test-server", server_config)
+            assert result is None
+            # Should log the error about missing environment variable
+            assert "Environment variable 'MISSING_TOKEN_VAR' is not set" in caplog.text
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    @patch('fastmcp.client.transports.StdioTransport')
+    async def test_stdio_client_ignores_token(self, mock_transport_class, mock_client_class):
+        """stdio clients should ignore auth_token (no auth mechanism)."""
+        server_config = {
+            "command": ["python", "server.py"],
+            "auth_token": "ignored-token"
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            manager.servers_config = {"test-server": server_config}
+
+            await manager._initialize_single_client("test-server", server_config)
+
+        # For stdio, the Client is called with StdioTransport, not URL and auth
+        # The auth_token should be ignored for stdio transports
+        assert mock_transport_class.called
+        assert mock_client_class.called
+
+    @pytest.mark.asyncio
+    async def test_malformed_env_var_pattern(self, caplog):
+        """Should handle malformed env var patterns gracefully."""
+        server_config = {
+            "url": "http://localhost:8000/mcp",
+            "transport": "http",
+            "auth_token": "${MISSING_CLOSING_BRACE"
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            manager.servers_config = {"test-server": server_config}
+
+            # Should succeed and pass the malformed pattern as literal string
+            result = await manager._initialize_single_client("test-server", server_config)
+            assert result is not None  # Client should be created with malformed string as auth token
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    async def test_empty_auth_token_string(self, mock_client_class):
+        """Should pass empty string as auth token."""
+        mock_client = AsyncMock()
+        mock_client_class.return_value = mock_client
+
+        server_config = {
+            "url": "http://localhost:8000/mcp",
+            "transport": "http",
+            "auth_token": ""
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            manager.servers_config = {"test-server": server_config}
+
+            await manager._initialize_single_client("test-server", server_config)
+
+        mock_client_class.assert_called_once_with(
+            "http://localhost:8000/mcp",
+            auth="",
+            log_handler=ANY,
+            elicitation_handler=ANY,
+            sampling_handler=ANY,
+        )

atlas/tests/modules/mcp_tools/test_client_env.py

@@ -0,0 +1,191 @@
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from atlas.modules.mcp_tools.client import MCPToolManager
+
+
+class TestMCPClientEnvironmentVariables:
+    """Test MCP client initialization with environment variables."""
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    @patch('fastmcp.client.transports.StdioTransport')
+    async def test_stdio_client_with_env_vars(self, mock_transport_class, mock_client_class, monkeypatch):
+        """Should pass environment variables to StdioTransport."""
+        # Set up environment variables for resolution
+        monkeypatch.setenv("MY_ENV_VAR", "resolved-value")
+
+        server_config = {
+            "command": ["python", "server.py"],
+            "cwd": "backend",
+            "env": {
+                "VAR1": "literal-value",
+                "VAR2": "another-literal"
+            }
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            # Mock os.path.exists to return True for cwd
+            with patch('os.path.exists', return_value=True):
+                manager = MCPToolManager()
+                manager.servers_config = {"test-server": server_config}
+
+                await manager._initialize_single_client("test-server", server_config)
+
+        # Verify StdioTransport was called with env dict
+        assert mock_transport_class.called
+        call_kwargs = mock_transport_class.call_args[1]
+        assert "env" in call_kwargs
+        assert call_kwargs["env"] == {
+            "VAR1": "literal-value",
+            "VAR2": "another-literal"
+        }
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    @patch('fastmcp.client.transports.StdioTransport')
+    async def test_stdio_client_with_env_var_resolution(self, mock_transport_class, mock_client_class, monkeypatch):
+        """Should resolve ${ENV_VAR} patterns in env values."""
+        # Set up environment variables
+        monkeypatch.setenv("CLOUD_PROFILE", "my-profile-9")
+        monkeypatch.setenv("CLOUD_REGION", "us-east-7")
+
+        server_config = {
+            "command": ["python", "server.py"],
+            "cwd": "backend",
+            "env": {
+                "PROFILE": "${CLOUD_PROFILE}",
+                "REGION": "${CLOUD_REGION}",
+                "LITERAL": "not-a-var"
+            }
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            # Mock os.path.exists to return True for cwd
+            with patch('os.path.exists', return_value=True):
+                manager = MCPToolManager()
+                manager.servers_config = {"test-server": server_config}
+
+                await manager._initialize_single_client("test-server", server_config)
+
+        # Verify env vars were resolved
+        assert mock_transport_class.called
+        call_kwargs = mock_transport_class.call_args[1]
+        assert call_kwargs["env"] == {
+            "PROFILE": "my-profile-9",
+            "REGION": "us-east-7",
+            "LITERAL": "not-a-var"
+        }
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    @patch('fastmcp.client.transports.StdioTransport')
+    async def test_stdio_client_without_env(self, mock_transport_class, mock_client_class):
+        """Should pass None when no env specified."""
+        server_config = {
+            "command": ["python", "server.py"],
+            "cwd": "backend"
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            # Mock os.path.exists to return True for cwd
+            with patch('os.path.exists', return_value=True):
+                manager = MCPToolManager()
+                manager.servers_config = {"test-server": server_config}
+
+                await manager._initialize_single_client("test-server", server_config)
+
+        # Verify env is None
+        assert mock_transport_class.called
+        call_kwargs = mock_transport_class.call_args[1]
+        assert call_kwargs["env"] is None
+
+    @pytest.mark.asyncio
+    async def test_stdio_client_missing_env_var_fails(self, caplog):
+        """Should fail when env var resolution fails."""
+        server_config = {
+            "command": ["python", "server.py"],
+            "cwd": "backend",
+            "env": {
+                "PROFILE": "${MISSING_VAR}"
+            }
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            # Mock os.path.exists to return True for cwd
+            with patch('os.path.exists', return_value=True):
+                manager = MCPToolManager()
+                manager.servers_config = {"test-server": server_config}
+
+                result = await manager._initialize_single_client("test-server", server_config)
+
+        # Should return None and log error
+        assert result is None
+        assert "Failed to resolve env var" in caplog.text
+        assert "MISSING_VAR" in caplog.text
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    @patch('fastmcp.client.transports.StdioTransport')
+    async def test_stdio_client_with_env_no_cwd(self, mock_transport_class, mock_client_class, monkeypatch):
+        """Should pass env vars even when no cwd specified."""
+        monkeypatch.setenv("MY_VAR", "my-value")
+
+        server_config = {
+            "command": ["python", "server.py"],
+            "env": {
+                "TEST_VAR": "${MY_VAR}"
+            }
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            manager.servers_config = {"test-server": server_config}
+
+            await manager._initialize_single_client("test-server", server_config)
+
+        # Verify env was passed
+        assert mock_transport_class.called
+        call_kwargs = mock_transport_class.call_args[1]
+        assert call_kwargs["env"] == {"TEST_VAR": "my-value"}
+
+    @pytest.mark.asyncio
+    @patch('atlas.modules.mcp_tools.client.Client')
+    @patch('fastmcp.client.transports.StdioTransport')
+    async def test_stdio_client_empty_env_dict(self, mock_transport_class, mock_client_class):
+        """Should handle empty env dict."""
+        server_config = {
+            "command": ["python", "server.py"],
+            "env": {}
+        }
+
+        with patch('atlas.modules.mcp_tools.client.config_manager') as mock_config_manager:
+            mock_config_manager.mcp_config.servers = {"test-server": Mock()}
+            mock_config_manager.mcp_config.servers["test-server"].model_dump.return_value = server_config
+
+            manager = MCPToolManager()
+            manager.servers_config = {"test-server": server_config}
+
+            await manager._initialize_single_client("test-server", server_config)
+
+        # Empty dict should become empty dict (not None)
+        assert mock_transport_class.called
+        call_kwargs = mock_transport_class.call_args[1]
+        assert call_kwargs["env"] == {}

atlas/tests/test_admin_mcp_server_management_routes.py

@@ -0,0 +1,141 @@
+import json
+from pathlib import Path
+
+from main import app
+from starlette.testclient import TestClient
+
+from atlas.infrastructure.app_factory import app_factory
+from atlas.modules.config import config_manager
+
+
+def _configure_test_overrides(tmp_path: Path, monkeypatch):
+    # Keep config changes isolated per test
+    monkeypatch.setattr(config_manager.app_settings, "app_config_overrides", str(tmp_path))
+    monkeypatch.setattr(config_manager.app_settings, "mcp_config_file", "mcp.json")
+
+    # Avoid any side effects from attempting to reload MCP servers during add/remove.
+    monkeypatch.setattr(app_factory, "get_mcp_manager", lambda: None)
+
+
+def test_admin_mcp_available_servers_returns_inventory(monkeypatch, tmp_path):
+    _configure_test_overrides(tmp_path, monkeypatch)
+
+    client = TestClient(app)
+    response = client.get(
+        "/admin/mcp/available-servers",
+        headers={"X-User-Email": "admin@example.com"},
+    )
+    assert response.status_code == 200
+
+    data = response.json()
+    assert "available_servers" in data
+    assert isinstance(data["available_servers"], dict)
+
+    # Repo should ship at least one example server.
+    assert len(data["available_servers"]) > 0
+
+    # Spot-check expected shape.
+    first_name = next(iter(data["available_servers"]))
+    first = data["available_servers"][first_name]
+    assert "config" in first
+    assert "source_file" in first
+
+
+def test_admin_mcp_active_servers_empty_when_no_override_file(monkeypatch, tmp_path):
+    _configure_test_overrides(tmp_path, monkeypatch)
+
+    # Ensure there is no mcp.json in overrides
+    assert not (tmp_path / "mcp.json").exists()
+
+    client = TestClient(app)
+    response = client.get(
+        "/admin/mcp/active-servers",
+        headers={"X-User-Email": "admin@example.com"},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data == {"active_servers": {}}
+
+
+def test_admin_mcp_add_server_persists_to_overrides(monkeypatch, tmp_path):
+    _configure_test_overrides(tmp_path, monkeypatch)
+
+    client = TestClient(app)
+
+    available = client.get(
+        "/admin/mcp/available-servers",
+        headers={"X-User-Email": "admin@example.com"},
+    ).json()["available_servers"]
+
+    server_name = next(iter(available.keys()))
+
+    add_response = client.post(
+        "/admin/mcp/add-server",
+        headers={"X-User-Email": "admin@example.com"},
+        json={"server_name": server_name},
+    )
+    assert add_response.status_code == 200
+    add_data = add_response.json()
+    assert add_data["server_name"] == server_name
+
+    # Active endpoint should reflect the new server.
+    active = client.get(
+        "/admin/mcp/active-servers",
+        headers={"X-User-Email": "admin@example.com"},
+    ).json()["active_servers"]
+    assert server_name in active
+
+    # And it should be persisted in overrides/mcp.json.
+    persisted_path = tmp_path / "mcp.json"
+    assert persisted_path.exists()
+    persisted = json.loads(persisted_path.read_text(encoding="utf-8"))
+    assert server_name in persisted
+
+    # Re-adding returns the already_active response.
+    add_again = client.post(
+        "/admin/mcp/add-server",
+        headers={"X-User-Email": "admin@example.com"},
+        json={"server_name": server_name},
+    )
+    assert add_again.status_code == 200
+    assert add_again.json().get("already_active") is True
+
+
+def test_admin_mcp_remove_server_updates_overrides(monkeypatch, tmp_path):
+    _configure_test_overrides(tmp_path, monkeypatch)
+
+    client = TestClient(app)
+
+    available = client.get(
+        "/admin/mcp/available-servers",
+        headers={"X-User-Email": "admin@example.com"},
+    ).json()["available_servers"]
+
+    server_name = next(iter(available.keys()))
+
+    # Add then remove.
+    add_response = client.post(
+        "/admin/mcp/add-server",
+        headers={"X-User-Email": "admin@example.com"},
+        json={"server_name": server_name},
+    )
+    assert add_response.status_code == 200
+
+    remove_response = client.post(
+        "/admin/mcp/remove-server",
+        headers={"X-User-Email": "admin@example.com"},
+        json={"server_name": server_name},
+    )
+    assert remove_response.status_code == 200
+    remove_data = remove_response.json()
+    assert remove_data["server_name"] == server_name
+    assert "removed_config" in remove_data
+
+    active = client.get(
+        "/admin/mcp/active-servers",
+        headers={"X-User-Email": "admin@example.com"},
+    ).json()["active_servers"]
+    assert server_name not in active
+
+    persisted = json.loads((tmp_path / "mcp.json").read_text(encoding="utf-8"))
+    assert server_name not in persisted