aixtools 0.1.10__py3-none-any.whl → 0.2.0__py3-none-any.whl

tests/unit/mcp/test_client.py

@@ -1,242 +0,0 @@
-"""Unit tests for aixtools.mcp.client module."""
-
-import asyncio
-import unittest
-from unittest.mock import Mock, patch
-
-from mcp import types as mcp_types
-from pydantic_ai import exceptions
-
-from aixtools.mcp.client import (
-    CACHE_KEY,
-    DEFAULT_MCP_CONNECTION_TIMEOUT,
-    CachedMCPServerStreamableHTTP,
-    get_configured_mcp_servers,
-    get_mcp_headers,
-)
-
-
-class TestGetMcpHeaders(unittest.TestCase):
-    """Test cases for get_mcp_headers function."""
-
-    def test_get_mcp_headers_with_both_ids(self):
-        """Test get_mcp_headers with both user_id and session_id."""
-        session_id_tuple = ("user123", "session456")
-        result = get_mcp_headers(session_id_tuple)
-        
-        expected = {
-            "user-id": "user123",
-            "session-id": "session456"
-        }
-        self.assertEqual(result, expected)
-
-    def test_get_mcp_headers_with_user_id_only(self):
-        """Test get_mcp_headers with only user_id."""
-        session_id_tuple = ("user123", None)  # type: ignore
-        result = get_mcp_headers(session_id_tuple)
-        
-        expected = {
-            "user-id": "user123"
-        }
-        self.assertEqual(result, expected)
-
-    def test_get_mcp_headers_with_session_id_only(self):
-        """Test get_mcp_headers with only session_id."""
-        session_id_tuple = (None, "session456")  # type: ignore
-        result = get_mcp_headers(session_id_tuple)
-        
-        expected = {
-            "session-id": "session456"
-        }
-        self.assertEqual(result, expected)
-
-    def test_get_mcp_headers_with_empty_strings(self):
-        """Test get_mcp_headers with empty strings."""
-        session_id_tuple = ("", "")
-        result = get_mcp_headers(session_id_tuple)
-        
-        self.assertIsNone(result)
-
-    def test_get_mcp_headers_with_none_values(self):
-        """Test get_mcp_headers with None values."""
-        session_id_tuple = (None, None)  # type: ignore
-        result = get_mcp_headers(session_id_tuple)
-        
-        self.assertIsNone(result)
-
-    def test_get_mcp_headers_with_mixed_empty_and_none(self):
-        """Test get_mcp_headers with mixed empty and None values."""
-        session_id_tuple = ("", None)  # type: ignore
-        result = get_mcp_headers(session_id_tuple)
-        
-        self.assertIsNone(result)
-
-
-class TestGetConfiguredMcpServers(unittest.TestCase):
-    """Test cases for get_configured_mcp_servers function."""
-
-    @patch('aixtools.mcp.client.CachedMCPServerStreamableHTTP')
-    def test_get_configured_mcp_servers_basic(self, mock_cached_server):
-        """Test get_configured_mcp_servers with basic parameters."""
-        session_id_tuple = ("user123", "session456")
-        mcp_urls = ["http://server1.com", "http://server2.com"]
-        
-        mock_server_instances = [Mock(), Mock()]
-        mock_cached_server.side_effect = mock_server_instances
-        
-        result = get_configured_mcp_servers(session_id_tuple, mcp_urls)
-        
-        self.assertEqual(len(result), 2)
-        self.assertEqual(result, mock_server_instances)
-        
-        # Verify that CachedMCPServerStreamableHTTP was called correctly
-        expected_headers = {"user-id": "user123", "session-id": "session456"}
-        mock_cached_server.assert_any_call(
-            url="http://server1.com", 
-            headers=expected_headers, 
-            timeout=DEFAULT_MCP_CONNECTION_TIMEOUT
-        )
-        mock_cached_server.assert_any_call(
-            url="http://server2.com", 
-            headers=expected_headers, 
-            timeout=DEFAULT_MCP_CONNECTION_TIMEOUT
-        )
-
-    @patch('aixtools.mcp.client.CachedMCPServerStreamableHTTP')
-    def test_get_configured_mcp_servers_custom_timeout(self, mock_cached_server):
-        """Test get_configured_mcp_servers with custom timeout."""
-        session_id_tuple = ("user123", "session456")
-        mcp_urls = ["http://server1.com"]
-        custom_timeout = 60
-        
-        mock_server_instance = Mock()
-        mock_cached_server.return_value = mock_server_instance
-        
-        result = get_configured_mcp_servers(session_id_tuple, mcp_urls, custom_timeout)
-        
-        self.assertEqual(len(result), 1)
-        mock_cached_server.assert_called_once_with(
-            url="http://server1.com",
-            headers={"user-id": "user123", "session-id": "session456"},
-            timeout=custom_timeout
-        )
-
-    @patch('aixtools.mcp.client.CachedMCPServerStreamableHTTP')
-    def test_get_configured_mcp_servers_no_headers(self, mock_cached_server):
-        """Test get_configured_mcp_servers when no headers are generated."""
-        session_id_tuple = (None, None)  # type: ignore
-        mcp_urls = ["http://server1.com"]
-        
-        mock_server_instance = Mock()
-        mock_cached_server.return_value = mock_server_instance
-        
-        result = get_configured_mcp_servers(session_id_tuple, mcp_urls)
-        
-        self.assertEqual(len(result), 1)
-        mock_cached_server.assert_called_once_with(
-            url="http://server1.com",
-            headers=None,
-            timeout=DEFAULT_MCP_CONNECTION_TIMEOUT
-        )
-
-    @patch('aixtools.mcp.client.CachedMCPServerStreamableHTTP')
-    def test_get_configured_mcp_servers_empty_urls(self, mock_cached_server):
-        """Test get_configured_mcp_servers with empty URL list."""
-        session_id_tuple = ("user123", "session456")
-        mcp_urls = []
-        
-        result = get_configured_mcp_servers(session_id_tuple, mcp_urls)
-        
-        self.assertEqual(len(result), 0)
-        mock_cached_server.assert_not_called()
-
-
-class TestCachedMCPServerStreamableHTTP(unittest.IsolatedAsyncioTestCase):
-    """Test cases for CachedMCPServerStreamableHTTP class."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.server = CachedMCPServerStreamableHTTP(url="http://test.com")
-        self.server._client = Mock()
-
-    def test_init(self):
-        """Test CachedMCPServerStreamableHTTP initialization."""
-        server = CachedMCPServerStreamableHTTP(url="http://test.com")
-        
-        self.assertIsNotNone(server._tools_cache)
-        self.assertIsNone(server._tools_list)
-        self.assertIsNotNone(server._isolation_lock)
-
-    async def test_run_direct_or_isolated_success(self):
-        """Test _run_direct_or_isolated with successful execution."""
-        async def test_func():
-            return "success"
-        
-        def fallback(exc):
-            return "fallback"
-        
-        result = await self.server._run_direct_or_isolated(test_func, fallback, None)
-        self.assertEqual(result, "success")
-
-    async def test_run_direct_or_isolated_timeout(self):
-        """Test _run_direct_or_isolated with timeout."""
-        async def test_func():
-            await asyncio.sleep(2)
-            return "success"
-        
-        def fallback(exc):
-            return "fallback"
-        
-        result = await self.server._run_direct_or_isolated(test_func, fallback, 0.1)
-        self.assertEqual(result, "fallback")
-
-    async def test_run_direct_or_isolated_exception(self):
-        """Test _run_direct_or_isolated with exception."""
-        async def test_func():
-            raise ValueError("test error")
-        
-        def fallback(exc):
-            return f"fallback: {exc}"
-        
-        result = await self.server._run_direct_or_isolated(test_func, fallback, None)
-        self.assertEqual(result, "fallback: test error")
-
-    async def test_run_direct_or_isolated_model_retry(self):
-        """Test _run_direct_or_isolated with ModelRetry exception."""
-        async def test_func():
-            raise exceptions.ModelRetry("retry error")
-        
-        def fallback(exc):
-            return "fallback"
-        
-        with self.assertRaises(exceptions.ModelRetry):
-            await self.server._run_direct_or_isolated(test_func, fallback, None)
-
-    async def test_list_tools_uninitialized_client(self):
-        """Test list_tools with uninitialized client."""
-        self.server._client = None  # type: ignore
-        
-        result = await self.server.list_tools()
-        
-        self.assertEqual(result, [])
-
-    async def test_list_tools_cached(self):
-        """Test list_tools with cached result."""
-        cached_tools = [Mock(spec=mcp_types.Tool)]
-        self.server._tools_cache[CACHE_KEY] = cached_tools
-        
-        result = await self.server.list_tools()
-        
-        self.assertEqual(result, cached_tools)
-
-    async def test_call_tool_uninitialized_client(self):
-        """Test call_tool with uninitialized client."""
-        self.server._client = None  # type: ignore
-        
-        result = await self.server.call_tool("test_tool", {}, Mock(), Mock())
-        
-        self.assertIn("MCP connection is uninitialized", str(result))
-
-
-if __name__ == '__main__':
-    unittest.main()

tests/unit/server/test_path.py

@@ -1,225 +0,0 @@
-"""Unit tests for aixtools.server.path module."""
-
-import unittest
-from pathlib import Path, PurePath, PurePosixPath
-from unittest.mock import Mock, patch
-
-from aixtools.server.path import (
-    CONTAINER_WORKSPACE_PATH,
-    WORKSPACES_ROOT_DIR,
-    container_to_host_path,
-    get_workspace_path,
-    host_to_container_path,
-)
-
-
-class TestGetWorkspacePath(unittest.TestCase):
-    """Test cases for get_workspace_path function."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.mock_ctx = ("test_user", "test_session")
-
-    def test_sandbox_path_without_service_name(self):
-        """Test getting sandbox path without service name."""
-        result = get_workspace_path(in_sandbox=True)
-        
-        self.assertEqual(result, CONTAINER_WORKSPACE_PATH)
-        self.assertIsInstance(result, PurePath)
-
-    def test_sandbox_path_with_service_name(self):
-        """Test getting sandbox path with service name."""
-        result = get_workspace_path("mcp_server", in_sandbox=True)
-        
-        expected = CONTAINER_WORKSPACE_PATH / "mcp_server"
-        self.assertEqual(result, expected)
-
-    @patch('aixtools.server.path.get_session_id_tuple')
-    def test_host_path_without_service_name(self, mock_get_session):
-        """Test getting host path without service name."""
-        mock_get_session.return_value = ("test_user", "test_session")
-        
-        result = get_workspace_path(in_sandbox=False)
-        
-        expected = WORKSPACES_ROOT_DIR / "test_user" / "test_session"
-        self.assertEqual(result, expected)
-
-    @patch('aixtools.server.path.get_session_id_tuple')
-    def test_host_path_with_service_name(self, mock_get_session):
-        """Test getting host path with service name."""
-        mock_get_session.return_value = ("test_user", "test_session")
-        
-        result = get_workspace_path("mcp_server", in_sandbox=False)
-        
-        expected = WORKSPACES_ROOT_DIR / "test_user" / "test_session" / "mcp_server"
-        self.assertEqual(result, expected)
-
-    def test_host_path_with_tuple_context(self):
-        """Test getting host path with tuple context."""
-        result = get_workspace_path("service", in_sandbox=False, ctx=self.mock_ctx)
-        
-        expected = WORKSPACES_ROOT_DIR / "test_user" / "test_session" / "service"
-        self.assertEqual(result, expected)
-
-    @patch('aixtools.server.path.get_session_id_tuple')
-    def test_host_path_with_context_object(self, mock_get_session):
-        """Test getting host path with context object."""
-        mock_ctx = Mock()
-        mock_get_session.return_value = ("ctx_user", "ctx_session")
-        
-        result = get_workspace_path("service", in_sandbox=False, ctx=mock_ctx)
-        
-        expected = WORKSPACES_ROOT_DIR / "ctx_user" / "ctx_session" / "service"
-        self.assertEqual(result, expected)
-        mock_get_session.assert_called_once_with(mock_ctx)
-
-    def test_default_parameters(self):
-        """Test function with default parameters."""
-        with patch('aixtools.server.path.get_session_id_tuple') as mock_get_session:
-            mock_get_session.return_value = ("default_user", "default_session")
-            
-            result = get_workspace_path()
-            
-            expected = WORKSPACES_ROOT_DIR / "default_user" / "default_session"
-            self.assertEqual(result, expected)
-
-
-class TestContainerToHostPath(unittest.TestCase):
-    """Test cases for container_to_host_path function."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.mock_ctx = ("test_user", "test_session")
-
-    @patch('aixtools.server.path.get_workspace_path')
-    def test_valid_container_path_conversion(self, mock_get_workspace):
-        """Test valid container path conversion."""
-        mock_get_workspace.return_value = Path("/data/workspaces/user/session")
-        
-        container_path = PurePosixPath("/workspace/file.txt")
-        result = container_to_host_path(container_path, ctx=self.mock_ctx)
-        
-        expected = Path("/data/workspaces/user/session/file.txt")
-        self.assertEqual(result, expected)
-
-    @patch('aixtools.server.path.get_workspace_path')
-    def test_container_root_path_conversion(self, mock_get_workspace):
-        """Test container root path conversion."""
-        mock_get_workspace.return_value = Path("/data/workspaces/user/session")
-        
-        container_path = PurePosixPath("/workspace")
-        result = container_to_host_path(container_path, ctx=self.mock_ctx)
-        
-        expected = Path("/data/workspaces/user/session")
-        self.assertEqual(result, expected)
-
-    @patch('aixtools.server.path.get_workspace_path')
-    def test_nested_container_path_conversion(self, mock_get_workspace):
-        """Test nested container path conversion."""
-        mock_get_workspace.return_value = Path("/data/workspaces/user/session")
-        
-        container_path = PurePosixPath("/workspace/subdir/nested/file.txt")
-        result = container_to_host_path(container_path, ctx=self.mock_ctx)
-        
-        expected = Path("/data/workspaces/user/session/subdir/nested/file.txt")
-        self.assertEqual(result, expected)
-
-    def test_invalid_container_path_raises_error(self):
-        """Test that invalid container paths raise ValueError."""
-        invalid_paths = [
-            PurePosixPath("/tmp/file.txt"),
-            PurePosixPath("/home/user/file.txt"),
-            PurePosixPath("/workspace_other/file.txt"),
-        ]
-        
-        for invalid_path in invalid_paths:
-            with self.subTest(path=invalid_path):
-                with self.assertRaises(ValueError) as context:
-                    container_to_host_path(invalid_path, ctx=self.mock_ctx)
-                
-                self.assertIn("Container path must be a subdir", str(context.exception))
-                self.assertIn(str(invalid_path), str(context.exception))
-
-    @patch('aixtools.server.path.get_workspace_path')
-    def test_context_passed_to_get_workspace_path(self, mock_get_workspace):
-        """Test that context is properly passed to get_workspace_path."""
-        mock_get_workspace.return_value = Path("/data/workspaces/user/session")
-        
-        container_path = PurePosixPath("/workspace/file.txt")
-        container_to_host_path(container_path, ctx=self.mock_ctx)
-        
-        mock_get_workspace.assert_called_once_with(ctx=self.mock_ctx)
-
-
-class TestHostToContainerPath(unittest.TestCase):
-    """Test cases for host_to_container_path function."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.mock_ctx = ("test_user", "test_session")
-
-    @patch('aixtools.server.path.get_workspace_path')
-    def test_valid_host_path_conversion(self, mock_get_workspace):
-        """Test valid host path conversion."""
-        mock_get_workspace.return_value = Path("/data/workspaces/user/session")
-        
-        host_path = Path("/data/workspaces/user/session/file.txt")
-        result = host_to_container_path(host_path, ctx=self.mock_ctx)
-        
-        expected = PurePosixPath("/workspace/file.txt")
-        self.assertEqual(result, expected)
-
-    @patch('aixtools.server.path.get_workspace_path')
-    def test_host_root_path_conversion(self, mock_get_workspace):
-        """Test host root path conversion."""
-        mock_get_workspace.return_value = Path("/data/workspaces/user/session")
-        
-        host_path = Path("/data/workspaces/user/session")
-        result = host_to_container_path(host_path, ctx=self.mock_ctx)
-        
-        expected = PurePosixPath("/workspace")
-        self.assertEqual(result, expected)
-
-    @patch('aixtools.server.path.get_workspace_path')
-    def test_nested_host_path_conversion(self, mock_get_workspace):
-        """Test nested host path conversion."""
-        mock_get_workspace.return_value = Path("/data/workspaces/user/session")
-        
-        host_path = Path("/data/workspaces/user/session/subdir/nested/file.txt")
-        result = host_to_container_path(host_path, ctx=self.mock_ctx)
-        
-        expected = PurePosixPath("/workspace/subdir/nested/file.txt")
-        self.assertEqual(result, expected)
-
-    @patch('aixtools.server.path.get_workspace_path')
-    def test_invalid_host_path_raises_error(self, mock_get_workspace):
-        """Test that invalid host paths raise ValueError."""
-        mock_get_workspace.return_value = Path("/data/workspaces/user/session")
-        
-        invalid_paths = [
-            Path("/tmp/file.txt"),
-            Path("/home/user/file.txt"),
-            Path("/data/other/file.txt"),
-        ]
-        
-        for invalid_path in invalid_paths:
-            with self.subTest(path=invalid_path):
-                with self.assertRaises(ValueError) as context:
-                    host_to_container_path(invalid_path, ctx=self.mock_ctx)
-                
-                self.assertIn("Host path must be a subdir", str(context.exception))
-                self.assertIn(str(invalid_path), str(context.exception))
-
-    @patch('aixtools.server.path.get_workspace_path')
-    def test_context_passed_to_get_workspace_path(self, mock_get_workspace):
-        """Test that context is properly passed to get_workspace_path."""
-        mock_get_workspace.return_value = Path("/data/workspaces/user/session")
-        
-        host_path = Path("/data/workspaces/user/session/file.txt")
-        host_to_container_path(host_path, ctx=self.mock_ctx)
-        
-        mock_get_workspace.assert_called_once_with(ctx=self.mock_ctx)
-
-
-if __name__ == '__main__':
-    unittest.main()