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

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

tests/unit/vault/test_vault.py

@@ -1,246 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-from hvac.exceptions import InvalidPath
-
-from aixtools.vault.vault import VaultAuthError, VaultClient
-
-
-@pytest.fixture
-def patched_vault_client():
-    with patch("aixtools.vault.vault.hvac.Client") as mock_hvac_client_cls:
-        fake_hvac_client = MagicMock()
-        fake_hvac_client.is_authenticated.return_value = True
-        mock_hvac_client_cls.return_value = fake_hvac_client
-
-        client = VaultClient()
-        return client
-
-
-@pytest.fixture
-def valid_params():
-    return {
-        "vault_mount_point": "secret",
-        "path_prefix": "path",
-        "env": "dev",
-        "user_id": "test-user",
-        "service_name": "test-service",
-        "user_api_key": "test-api-key",
-    }
-
-
-def test_store_user_service_api_key_success(patched_vault_client, valid_params):
-    patched_vault_client.client.secrets.kv.v2.create_or_update_secret.return_value = {}
-
-    patched_vault_client.store_user_service_api_key(
-        user_id=valid_params["user_id"],
-        service_name=valid_params["service_name"],
-        user_api_key=valid_params["user_api_key"],
-    )
-
-    secret_path = (
-        f"{valid_params['path_prefix']}/{valid_params['env']}/{valid_params['user_id']}/{valid_params['service_name']}"
-    )
-
-    patched_vault_client.client.secrets.kv.v2.create_or_update_secret.assert_called_once_with(
-        secret_path,
-        secret={"user-api-key": valid_params["user_api_key"]},
-        mount_point=valid_params["vault_mount_point"],
-    )
-
-
-def test_store_user_service_api_key_invalid_path(patched_vault_client, valid_params):
-    patched_vault_client.client.secrets.kv.v2.create_or_update_secret.side_effect = Exception("Invalid Path")
-
-    with pytest.raises(VaultAuthError, match="Invalid Path"):
-        patched_vault_client.store_user_service_api_key(
-            user_id=valid_params["user_id"],
-            service_name=valid_params["service_name"],
-            user_api_key=valid_params["user_api_key"],
-        )
-        patched_vault_client.client.assert_not_called()
-
-
-def test_read_user_service_api_key_success(patched_vault_client):
-    """Test successful read of user service API key."""
-    mock_response = {"data": {"data": {"user-api-key": "test-api-key"}}}
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.return_value = mock_response
-
-    result = patched_vault_client.read_user_service_api_key(user_id="test-user", service_name="test-service")
-
-    assert result == "test-api-key"
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.assert_called_once_with(
-        "path/dev/test-user/test-service", mount_point="secret", raise_on_deleted_version=True
-    )
-
-
-def test_read_user_service_api_key_secret_not_found(patched_vault_client):
-    """Test read_user_service_api_key when the secret path does not exist."""
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.side_effect = InvalidPath
-
-    result = patched_vault_client.read_user_service_api_key(user_id="test-user", service_name="test-service")
-
-    assert result is None
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.assert_called_once_with(
-        "path/dev/test-user/test-service", mount_point="secret", raise_on_deleted_version=True
-    )
-
-
-def test_read_user_service_api_key_unexpected_error(patched_vault_client):
-    """Test read_user_service_api_key when an unexpected exception occurs."""
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.side_effect = Exception("Unexpected error")
-
-    with pytest.raises(VaultAuthError, match="Unexpected error"):
-        patched_vault_client.read_user_service_api_key(user_id="test-user", service_name="test-service")
-
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.assert_called_once_with(
-        "path/dev/test-user/test-service", mount_point="secret", raise_on_deleted_version=True
-    )
-
-
-def test_store_user_service_secret_success(patched_vault_client, valid_params):
-    """Test successful storage of complete user service secret."""
-    secret_data = {"api_key": "test-api-key", "token": "test-token", "endpoint": "https://api.example.com"}
-    patched_vault_client.client.secrets.kv.v2.create_or_update_secret.return_value = {}
-
-    patched_vault_client.store_user_service_secret(
-        user_id=valid_params["user_id"],
-        service_name=valid_params["service_name"],
-        secret_data=secret_data,
-    )
-
-    secret_path = (
-        f"{valid_params['path_prefix']}/{valid_params['env']}/{valid_params['user_id']}/{valid_params['service_name']}"
-    )
-
-    patched_vault_client.client.secrets.kv.v2.create_or_update_secret.assert_called_once_with(
-        secret_path,
-        secret=secret_data,
-        mount_point=valid_params["vault_mount_point"],
-    )
-
-
-def test_store_user_service_secret_error(patched_vault_client, valid_params):
-    """Test store_user_service_secret when an error occurs."""
-    secret_data = {"api_key": "test-api-key", "token": "test-token"}
-    patched_vault_client.client.secrets.kv.v2.create_or_update_secret.side_effect = Exception("Storage error")
-
-    with pytest.raises(VaultAuthError, match="Storage error"):
-        patched_vault_client.store_user_service_secret(
-            user_id=valid_params["user_id"],
-            service_name=valid_params["service_name"],
-            secret_data=secret_data,
-        )
-
-
-def test_read_user_service_secret_success(patched_vault_client):
-    """Test successful read of complete user service secret."""
-    secret_data = {"api_key": "test-api-key", "token": "test-token", "endpoint": "https://api.example.com"}
-    mock_response = {"data": {"data": secret_data}}
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.return_value = mock_response
-
-    result = patched_vault_client.read_user_service_secret(user_id="test-user", service_name="test-service")
-
-    assert result == secret_data
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.assert_called_once_with(
-        "path/dev/test-user/test-service", mount_point="secret", raise_on_deleted_version=True
-    )
-
-
-def test_read_user_service_secret_not_found(patched_vault_client):
-    """Test read_user_service_secret when the secret path does not exist."""
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.side_effect = InvalidPath
-
-    result = patched_vault_client.read_user_service_secret(user_id="test-user", service_name="test-service")
-
-    assert result is None
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.assert_called_once_with(
-        "path/dev/test-user/test-service", mount_point="secret", raise_on_deleted_version=True
-    )
-
-
-def test_list_user_secret_keys_success(patched_vault_client):
-    """Test successful listing of all user secret keys."""
-    mock_response = {"data": {"keys": ["service1/", "service2/", "service3"]}}
-    patched_vault_client.client.secrets.kv.v2.list_secrets.return_value = mock_response
-
-    result = patched_vault_client.list_user_secret_keys(user_id="test-user")
-
-    assert result == ["service1", "service2", "service3"]
-    patched_vault_client.client.secrets.kv.v2.list_secrets.assert_called_once_with(
-        path="path/dev/test-user", mount_point="secret"
-    )
-
-
-def test_list_user_secret_keys_no_secrets(patched_vault_client):
-    """Test listing user secret keys when no secrets exist."""
-    mock_response = {"data": {"keys": []}}
-    patched_vault_client.client.secrets.kv.v2.list_secrets.return_value = mock_response
-
-    result = patched_vault_client.list_user_secret_keys(user_id="test-user")
-
-    assert result == []
-    patched_vault_client.client.secrets.kv.v2.list_secrets.assert_called_once_with(
-        path="path/dev/test-user", mount_point="secret"
-    )
-
-
-def test_list_user_secret_keys_empty_response(patched_vault_client):
-    """Test listing user secret keys when response is empty."""
-    patched_vault_client.client.secrets.kv.v2.list_secrets.return_value = {}
-
-    result = patched_vault_client.list_user_secret_keys(user_id="test-user")
-
-    assert result == []
-    patched_vault_client.client.secrets.kv.v2.list_secrets.assert_called_once_with(
-        path="path/dev/test-user", mount_point="secret"
-    )
-
-
-def test_list_user_secret_keys_invalid_path(patched_vault_client):
-    """Test listing user secret keys when user path does not exist."""
-    patched_vault_client.client.secrets.kv.v2.list_secrets.side_effect = InvalidPath
-
-    result = patched_vault_client.list_user_secret_keys(user_id="test-user")
-
-    assert result == []
-    patched_vault_client.client.secrets.kv.v2.list_secrets.assert_called_once_with(
-        path="path/dev/test-user", mount_point="secret"
-    )
-
-
-def test_list_user_secret_keys_unexpected_error(patched_vault_client):
-    """Test listing user secret keys when an unexpected exception occurs."""
-    patched_vault_client.client.secrets.kv.v2.list_secrets.side_effect = Exception("List error")
-
-    with pytest.raises(VaultAuthError, match="List error"):
-        patched_vault_client.list_user_secret_keys(user_id="test-user")
-
-    patched_vault_client.client.secrets.kv.v2.list_secrets.assert_called_once_with(
-        path="path/dev/test-user", mount_point="secret"
-    )
-
-
-def test_list_user_secret_keys_strips_trailing_slashes(patched_vault_client):
-    """Test that trailing slashes are properly stripped from directory names."""
-    mock_response = {"data": {"keys": ["service1/", "service2/", "service3", "service4/"]}}
-    patched_vault_client.client.secrets.kv.v2.list_secrets.return_value = mock_response
-
-    result = patched_vault_client.list_user_secret_keys(user_id="test-user")
-
-    assert result == ["service1", "service2", "service3", "service4"]
-    patched_vault_client.client.secrets.kv.v2.list_secrets.assert_called_once_with(
-        path="path/dev/test-user", mount_point="secret"
-    )
-
-
-def test_read_user_service_secret_error(patched_vault_client):
-    """Test read_user_service_secret when an unexpected exception occurs."""
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.side_effect = Exception("Read error")
-
-    with pytest.raises(VaultAuthError, match="Read error"):
-        patched_vault_client.read_user_service_secret(user_id="test-user", service_name="test-service")
-
-    patched_vault_client.client.secrets.kv.v2.read_secret_version.assert_called_once_with(
-        "path/dev/test-user/test-service", mount_point="secret", raise_on_deleted_version=True
-    )