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

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()

tests/unit/server/test_utils.py

@@ -1,362 +0,0 @@
-"""Unit tests for aixtools.server.utils module."""
-
-import asyncio
-import unittest
-from unittest.mock import AsyncMock, Mock, patch
-
-from aixtools.server.utils import (
-    get_session_id_from_request,
-    get_session_id_str,
-    get_session_id_tuple,
-    get_user_id_from_request,
-    run_in_thread,
-)
-
-
-class TestGetSessionIdFromRequest(unittest.TestCase):
-    """Test cases for get_session_id_from_request function."""
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_session_id_with_context_none(self, mock_dependencies):
-        """Test getting session ID when context is None."""
-        mock_request = Mock()
-        mock_request.headers.get.return_value = "test-session-123"
-        mock_dependencies.get_http_request.return_value = mock_request
-        
-        result = get_session_id_from_request(None)
-        
-        self.assertEqual(result, "test-session-123")
-        mock_dependencies.get_http_request.assert_called_once()
-        mock_request.headers.get.assert_called_once_with("session-id")
-
-    def test_get_session_id_with_context_provided(self):
-        """Test getting session ID when context is provided."""
-        mock_ctx = Mock()
-        mock_request = Mock()
-        mock_request.headers.get.return_value = "ctx-session-456"
-        mock_ctx.get_http_request.return_value = mock_request
-        
-        result = get_session_id_from_request(mock_ctx)
-        
-        self.assertEqual(result, "ctx-session-456")
-        mock_ctx.get_http_request.assert_called_once()
-        mock_request.headers.get.assert_called_once_with("session-id")
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_session_id_header_not_found(self, mock_dependencies):
-        """Test getting session ID when header is not found."""
-        mock_request = Mock()
-        mock_request.headers.get.return_value = None
-        mock_dependencies.get_http_request.return_value = mock_request
-        
-        result = get_session_id_from_request(None)
-        
-        self.assertIsNone(result)
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_session_id_value_error(self, mock_dependencies):
-        """Test getting session ID when ValueError is raised."""
-        mock_dependencies.get_http_request.side_effect = ValueError("Request error")
-        
-        result = get_session_id_from_request(None)
-        
-        self.assertIsNone(result)
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_session_id_runtime_error(self, mock_dependencies):
-        """Test getting session ID when RuntimeError is raised."""
-        mock_dependencies.get_http_request.side_effect = RuntimeError("Runtime error")
-        
-        result = get_session_id_from_request(None)
-        
-        self.assertIsNone(result)
-
-
-class TestGetUserIdFromRequest(unittest.TestCase):
-    """Test cases for get_user_id_from_request function."""
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_user_id_with_context_none(self, mock_dependencies):
-        """Test getting user ID when context is None."""
-        mock_request = Mock()
-        mock_request.headers.get.return_value = "TEST-USER-123"
-        mock_dependencies.get_http_request.return_value = mock_request
-        
-        result = get_user_id_from_request(None)
-        
-        self.assertEqual(result, "test-user-123")  # Should be lowercase
-        mock_dependencies.get_http_request.assert_called_once()
-        mock_request.headers.get.assert_called_once_with("user-id")
-
-    def test_get_user_id_with_context_provided(self):
-        """Test getting user ID when context is provided."""
-        mock_ctx = Mock()
-        mock_request = Mock()
-        mock_request.headers.get.return_value = "CTX-USER-456"
-        mock_ctx.get_http_request.return_value = mock_request
-        
-        result = get_user_id_from_request(mock_ctx)
-        
-        self.assertEqual(result, "ctx-user-456")  # Should be lowercase
-        mock_ctx.get_http_request.assert_called_once()
-        mock_request.headers.get.assert_called_once_with("user-id")
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_user_id_header_not_found(self, mock_dependencies):
-        """Test getting user ID when header is not found."""
-        mock_request = Mock()
-        mock_request.headers.get.return_value = None
-        mock_dependencies.get_http_request.return_value = mock_request
-        
-        result = get_user_id_from_request(None)
-        
-        self.assertIsNone(result)
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_user_id_empty_string(self, mock_dependencies):
-        """Test getting user ID when header is empty string."""
-        mock_request = Mock()
-        mock_request.headers.get.return_value = ""
-        mock_dependencies.get_http_request.return_value = mock_request
-        
-        result = get_user_id_from_request(None)
-        
-        self.assertIsNone(result)
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_user_id_value_error(self, mock_dependencies):
-        """Test getting user ID when ValueError is raised."""
-        mock_dependencies.get_http_request.side_effect = ValueError("Request error")
-        
-        result = get_user_id_from_request(None)
-        
-        self.assertIsNone(result)
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_user_id_runtime_error(self, mock_dependencies):
-        """Test getting user ID when RuntimeError is raised."""
-        mock_dependencies.get_http_request.side_effect = RuntimeError("Runtime error")
-        
-        result = get_user_id_from_request(None)
-        
-        self.assertIsNone(result)
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_user_id_attribute_error(self, mock_dependencies):
-        """Test getting user ID when AttributeError is raised."""
-        mock_dependencies.get_http_request.side_effect = AttributeError("Attribute error")
-        
-        result = get_user_id_from_request(None)
-        
-        self.assertIsNone(result)
-
-    @patch('aixtools.server.utils.dependencies')
-    def test_get_user_id_case_variations(self, mock_dependencies):
-        """Test that user ID is always returned in lowercase."""
-        test_cases = [
-            ("UPPERCASE", "uppercase"),
-            ("MixedCase", "mixedcase"),
-            ("lowercase", "lowercase"),
-            ("CamelCase", "camelcase"),
-        ]
-        
-        for input_user_id, expected_output in test_cases:
-            with self.subTest(input_user_id=input_user_id):
-                mock_request = Mock()
-                mock_request.headers.get.return_value = input_user_id
-                mock_dependencies.get_http_request.return_value = mock_request
-                
-                result = get_user_id_from_request(None)
-                
-                self.assertEqual(result, expected_output)
-
-
-class TestGetSessionIdTuple(unittest.TestCase):
-    """Test cases for get_session_id_tuple function."""
-
-    @patch('aixtools.server.utils.get_session_id_from_request')
-    @patch('aixtools.server.utils.get_user_id_from_request')
-    @patch('aixtools.server.utils.session_id_var')
-    @patch('aixtools.server.utils.user_id_var')
-    def test_get_session_id_tuple_with_headers(self, mock_user_var, mock_session_var, 
-                                               mock_get_user, mock_get_session):
-        """Test getting session ID tuple when headers are available."""
-        mock_get_user.return_value = "header-user"
-        mock_get_session.return_value = "header-session"
-        
-        result = get_session_id_tuple(None)
-        
-        self.assertEqual(result, ("header-user", "header-session"))
-        mock_get_user.assert_called_once_with(None)
-        mock_get_session.assert_called_once_with(None)
-
-    @patch('aixtools.server.utils.get_session_id_from_request')
-    @patch('aixtools.server.utils.get_user_id_from_request')
-    @patch('aixtools.server.utils.session_id_var')
-    @patch('aixtools.server.utils.user_id_var')
-    def test_get_session_id_tuple_with_fallback(self, mock_user_var, mock_session_var,
-                                                mock_get_user, mock_get_session):
-        """Test getting session ID tuple with fallback to context variables."""
-        mock_get_user.return_value = None
-        mock_get_session.return_value = None
-        mock_user_var.get.return_value = "context-user"
-        mock_session_var.get.return_value = "context-session"
-        
-        result = get_session_id_tuple(None)
-        
-        self.assertEqual(result, ("context-user", "context-session"))
-        mock_user_var.get.assert_called_once_with("default_user")
-        mock_session_var.get.assert_called_once_with("default_session")
-
-    @patch('aixtools.server.utils.get_session_id_from_request')
-    @patch('aixtools.server.utils.get_user_id_from_request')
-    @patch('aixtools.server.utils.session_id_var')
-    @patch('aixtools.server.utils.user_id_var')
-    def test_get_session_id_tuple_mixed_sources(self, mock_user_var, mock_session_var,
-                                                mock_get_user, mock_get_session):
-        """Test getting session ID tuple with mixed sources."""
-        mock_get_user.return_value = "header-user"
-        mock_get_session.return_value = None
-        mock_session_var.get.return_value = "context-session"
-        
-        result = get_session_id_tuple(None)
-        
-        self.assertEqual(result, ("header-user", "context-session"))
-
-    def test_get_session_id_tuple_with_context(self):
-        """Test getting session ID tuple with provided context."""
-        mock_ctx = Mock()
-        
-        with patch('aixtools.server.utils.get_user_id_from_request') as mock_get_user, \
-             patch('aixtools.server.utils.get_session_id_from_request') as mock_get_session:
-            
-            mock_get_user.return_value = "ctx-user"
-            mock_get_session.return_value = "ctx-session"
-            
-            result = get_session_id_tuple(mock_ctx)
-            
-            self.assertEqual(result, ("ctx-user", "ctx-session"))
-            mock_get_user.assert_called_once_with(mock_ctx)
-            mock_get_session.assert_called_once_with(mock_ctx)
-
-
-class TestGetSessionIdStr(unittest.TestCase):
-    """Test cases for get_session_id_str function."""
-
-    @patch('aixtools.server.utils.get_session_id_tuple')
-    def test_get_session_id_str(self, mock_get_tuple):
-        """Test getting session ID string."""
-        mock_get_tuple.return_value = ("test-user", "test-session")
-        
-        result = get_session_id_str(None)
-        
-        self.assertEqual(result, "test-user:test-session")
-        mock_get_tuple.assert_called_once_with(None)
-
-    @patch('aixtools.server.utils.get_session_id_tuple')
-    def test_get_session_id_str_with_context(self, mock_get_tuple):
-        """Test getting session ID string with context."""
-        mock_ctx = Mock()
-        mock_get_tuple.return_value = ("ctx-user", "ctx-session")
-        
-        result = get_session_id_str(mock_ctx)
-        
-        self.assertEqual(result, "ctx-user:ctx-session")
-        mock_get_tuple.assert_called_once_with(mock_ctx)
-
-    @patch('aixtools.server.utils.get_session_id_tuple')
-    def test_get_session_id_str_special_characters(self, mock_get_tuple):
-        """Test getting session ID string with special characters."""
-        mock_get_tuple.return_value = ("user@domain.com", "session-123-abc")
-        
-        result = get_session_id_str(None)
-        
-        self.assertEqual(result, "user@domain.com:session-123-abc")
-
-
-class TestRunInThread(unittest.IsolatedAsyncioTestCase):
-    """Test cases for run_in_thread decorator."""
-
-    async def test_run_in_thread_basic_function(self):
-        """Test run_in_thread decorator with basic function."""
-        @run_in_thread
-        def sync_function(x, y):
-            return x + y
-        
-        result = await sync_function(5, 3)  # type: ignore
-        
-        self.assertEqual(result, 8)
-
-    async def test_run_in_thread_with_kwargs(self):
-        """Test run_in_thread decorator with keyword arguments."""
-        @run_in_thread
-        def sync_function(x, y, multiplier=1):
-            return (x + y) * multiplier
-        
-        result = await sync_function(5, 3, multiplier=2)  # type: ignore
-        
-        self.assertEqual(result, 16)
-
-    async def test_run_in_thread_with_exception(self):
-        """Test run_in_thread decorator when function raises exception."""
-        @run_in_thread
-        def failing_function():
-            raise ValueError("Test error")
-        
-        with self.assertRaises(ValueError) as context:
-            await failing_function()  # type: ignore
-        
-        self.assertEqual(str(context.exception), "Test error")
-
-    async def test_run_in_thread_preserves_function_metadata(self):
-        """Test that run_in_thread preserves function metadata."""
-        @run_in_thread
-        def documented_function(x):
-            """This is a test function."""
-            return x * 2
-        
-        self.assertEqual(documented_function.__name__, "documented_function")
-        self.assertEqual(documented_function.__doc__, "This is a test function.")
-
-    async def test_run_in_thread_with_no_args(self):
-        """Test run_in_thread decorator with function that takes no arguments."""
-        @run_in_thread
-        def no_args_function():
-            return "success"
-        
-        result = await no_args_function()  # type: ignore
-        
-        self.assertEqual(result, "success")
-
-    async def test_run_in_thread_with_complex_return_type(self):
-        """Test run_in_thread decorator with complex return type."""
-        @run_in_thread
-        def complex_function():
-            return {"key": "value", "list": [1, 2, 3], "nested": {"inner": True}}
-        
-        result = await complex_function()  # type: ignore
-        
-        expected = {"key": "value", "list": [1, 2, 3], "nested": {"inner": True}}
-        self.assertEqual(result, expected)
-
-    @patch('asyncio.to_thread')
-    async def test_run_in_thread_calls_asyncio_to_thread(self, mock_to_thread):
-        """Test that run_in_thread actually calls asyncio.to_thread."""
-        mock_to_thread.return_value = "mocked_result"
-        
-        @run_in_thread
-        def test_function(arg1, arg2, kwarg1=None):
-            return f"{arg1}-{arg2}-{kwarg1}"
-        
-        result = await test_function("a", "b", kwarg1="c")  # type: ignore
-        
-        self.assertEqual(result, "mocked_result")
-        mock_to_thread.assert_called_once()
-        # Verify the original function and arguments were passed
-        args, kwargs = mock_to_thread.call_args
-        self.assertEqual(args[1:], ("a", "b"))  # Skip the function itself
-        self.assertEqual(kwargs, {"kwarg1": "c"})
-
-
-if __name__ == '__main__':
-    unittest.main()