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

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

tests/unit/utils/test_files.py

@@ -1,146 +0,0 @@
-"""Unit tests for aixtools.utils.files module."""
-
-import unittest
-
-from aixtools.utils.files import is_text_content
-
-
-class TestIsTextContent(unittest.TestCase):
-    """Test cases for is_text_content function."""
-
-    def test_text_mime_types_return_true(self):
-        """Test that text mime types return True."""
-        text_mime_types = [
-            "text/plain",
-            "text/html",
-            "text/css",
-            "text/javascript",
-            "text/csv",
-            "text/xml",
-            "text/markdown",
-        ]
-        
-        for mime_type in text_mime_types:
-            with self.subTest(mime_type=mime_type):
-                result = is_text_content(b"some content", mime_type)
-                self.assertTrue(result, f"MIME type {mime_type} should be detected as text")
-
-    def test_application_text_mime_types_return_true(self):
-        """Test that application text-like mime types return True."""
-        app_text_mime_types = [
-            "application/json",
-            "application/xml",
-            "application/javascript",
-        ]
-        
-        for mime_type in app_text_mime_types:
-            with self.subTest(mime_type=mime_type):
-                result = is_text_content(b"some content", mime_type)
-                self.assertTrue(result, f"MIME type {mime_type} should be detected as text")
-
-    def test_binary_mime_types_with_valid_utf8_return_true(self):
-        """Test that binary mime types with valid UTF-8 content return True."""
-        binary_mime_types = [
-            "application/octet-stream",
-            "image/png",
-            "video/mp4",
-            "application/pdf",
-        ]
-        
-        utf8_content = "Hello, world! 🌍".encode("utf-8")
-        
-        for mime_type in binary_mime_types:
-            with self.subTest(mime_type=mime_type):
-                result = is_text_content(utf8_content, mime_type)
-                self.assertTrue(result, f"Valid UTF-8 content should be detected as text even with {mime_type}")
-
-    def test_binary_mime_types_with_invalid_utf8_return_false(self):
-        """Test that binary mime types with invalid UTF-8 content return False."""
-        binary_mime_types = [
-            "application/octet-stream",
-            "image/png",
-            "video/mp4",
-            "application/pdf",
-        ]
-        
-        # Create invalid UTF-8 bytes
-        invalid_utf8_content = b'\x80\x81\x82\x83'
-        
-        for mime_type in binary_mime_types:
-            with self.subTest(mime_type=mime_type):
-                result = is_text_content(invalid_utf8_content, mime_type)
-                self.assertFalse(result, f"Invalid UTF-8 content should not be detected as text with {mime_type}")
-
-    def test_empty_mime_type_with_valid_utf8_return_true(self):
-        """Test that empty mime type with valid UTF-8 content returns True."""
-        utf8_content = "Hello, world!".encode("utf-8")
-        
-        result = is_text_content(utf8_content, "")
-        self.assertTrue(result)
-
-    def test_empty_mime_type_with_invalid_utf8_return_false(self):
-        """Test that empty mime type with invalid UTF-8 content returns False."""
-        invalid_utf8_content = b'\x80\x81\x82\x83'
-        
-        result = is_text_content(invalid_utf8_content, "")
-        self.assertFalse(result)
-
-    def test_none_mime_type_with_valid_utf8_return_true(self):
-        """Test that None mime type with valid UTF-8 content returns True."""
-        utf8_content = "Hello, world!".encode("utf-8")
-        
-        result = is_text_content(utf8_content, None)  # type: ignore
-        self.assertTrue(result)
-
-    def test_none_mime_type_with_invalid_utf8_return_false(self):
-        """Test that None mime type with invalid UTF-8 content returns False."""
-        invalid_utf8_content = b'\x80\x81\x82\x83'
-        
-        result = is_text_content(invalid_utf8_content, None)  # type: ignore
-        self.assertFalse(result)
-
-    def test_empty_content_with_text_mime_type_return_true(self):
-        """Test that empty content with text mime type returns True."""
-        result = is_text_content(b"", "text/plain")
-        self.assertTrue(result)
-
-    def test_empty_content_with_binary_mime_type_return_true(self):
-        """Test that empty content with binary mime type returns True (empty is valid UTF-8)."""
-        result = is_text_content(b"", "application/octet-stream")
-        self.assertTrue(result)
-
-    def test_unicode_content_return_true(self):
-        """Test that Unicode content is properly detected as text."""
-        unicode_strings = [
-            "Hello, 世界!",
-            "Café ☕",
-            "🚀 Rocket",
-            "Здравствуй мир",
-            "مرحبا بالعالم",
-        ]
-        
-        for unicode_str in unicode_strings:
-            with self.subTest(content=unicode_str):
-                utf8_content = unicode_str.encode("utf-8")
-                result = is_text_content(utf8_content, "application/octet-stream")
-                self.assertTrue(result, f"Unicode string '{unicode_str}' should be detected as text")
-
-    def test_binary_image_data_return_false(self):
-        """Test that actual binary image data returns False."""
-        # PNG file header
-        png_header = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR'
-        
-        result = is_text_content(png_header, "image/png")
-        self.assertFalse(result)
-
-    def test_binary_executable_data_return_false(self):
-        """Test that binary executable data returns False."""
-        # Binary data with invalid UTF-8 sequences
-        binary_data = b'\x7f\x80\x81\x82\x83\x84\x85\x86'
-        
-        result = is_text_content(binary_data, "application/octet-stream")
-        self.assertFalse(result)
-
-
-if __name__ == '__main__':
-    unittest.main()