microsoft-agents-storage-cosmos 0.4.0.dev4__tar.gz → 0.4.0.dev7__tar.gz

{microsoft_agents_storage_cosmos-0.4.0.dev4 → microsoft_agents_storage_cosmos-0.4.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-storage-cosmos
-Version: 0.4.0.dev4
+Version: 0.4.0.dev7
 Summary: A Cosmos DB storage library for Microsoft Agents
 Author: Microsoft Corporation
 Project-URL: Homepage, https://github.com/microsoft/Agents
@@ -8,7 +8,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
-Requires-Dist: microsoft-agents-hosting-core==0.4.0.dev4
+Requires-Dist: microsoft-agents-hosting-core==0.4.0.dev7
 Requires-Dist: azure-core
 Requires-Dist: azure-cosmos
 Dynamic: requires-dist

{microsoft_agents_storage_cosmos-0.4.0.dev4 → microsoft_agents_storage_cosmos-0.4.0.dev7}/microsoft_agents_storage_cosmos.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-storage-cosmos
-Version: 0.4.0.dev4
+Version: 0.4.0.dev7
 Summary: A Cosmos DB storage library for Microsoft Agents
 Author: Microsoft Corporation
 Project-URL: Homepage, https://github.com/microsoft/Agents
@@ -8,7 +8,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
-Requires-Dist: microsoft-agents-hosting-core==0.4.0.dev4
+Requires-Dist: microsoft-agents-hosting-core==0.4.0.dev7
 Requires-Dist: azure-core
 Requires-Dist: azure-cosmos
 Dynamic: requires-dist

{microsoft_agents_storage_cosmos-0.4.0.dev4 → microsoft_agents_storage_cosmos-0.4.0.dev7}/microsoft_agents_storage_cosmos.egg-info/SOURCES.txt

@@ -8,7 +8,4 @@ microsoft_agents_storage_cosmos.egg-info/PKG-INFO
 microsoft_agents_storage_cosmos.egg-info/SOURCES.txt
 microsoft_agents_storage_cosmos.egg-info/dependency_links.txt
 microsoft_agents_storage_cosmos.egg-info/requires.txt
-microsoft_agents_storage_cosmos.egg-info/top_level.txt
-tests/test_cosmos_db_config.py
-tests/test_cosmos_db_storage.py
-tests/test_key_ops.py
+microsoft_agents_storage_cosmos.egg-info/top_level.txt

microsoft_agents_storage_cosmos-0.4.0.dev7/microsoft_agents_storage_cosmos.egg-info/requires.txt

@@ -0,0 +1,3 @@
+microsoft-agents-hosting-core==0.4.0.dev7
+azure-core
+azure-cosmos

microsoft_agents_storage_cosmos-0.4.0.dev4/microsoft_agents_storage_cosmos.egg-info/requires.txt

@@ -1,3 +0,0 @@
-microsoft-agents-hosting-core==0.4.0.dev4
-azure-core
-azure-cosmos

microsoft_agents_storage_cosmos-0.4.0.dev4/tests/test_cosmos_db_config.py

@@ -1,245 +0,0 @@
-import json
-import pytest
-
-from microsoft_agents.storage.cosmos import CosmosDBStorageConfig
-
-# thank you AI, again
-
-
-@pytest.fixture()
-def valid_config():
-    """Fixture providing a valid CosmosDBStorageConfig for tests"""
-    return CosmosDBStorageConfig(
-        cosmos_db_endpoint="https://localhost:8081",
-        auth_key=(
-            "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGG"
-            "yPMbIZnqyMsEcaGQy67XIw/Jw=="
-        ),
-        database_id="test-db",
-        container_id="bot-storage",
-    )
-
-
-@pytest.fixture()
-def minimal_config():
-    """Fixture providing a minimal CosmosDBStorageConfig for tests"""
-    return CosmosDBStorageConfig()
-
-
-@pytest.fixture()
-def config_with_options():
-    """Fixture providing a CosmosDBStorageConfig with all options for tests"""
-    return CosmosDBStorageConfig(
-        cosmos_db_endpoint="https://test.documents.azure.com:443/",
-        auth_key="test_key",
-        database_id="test_db",
-        container_id="test_container",
-        cosmos_client_options={"connection_policy": "test"},
-        container_throughput=800,
-        key_suffix="_test",
-        compatibility_mode=False,
-    )
-
-
-class TestCosmosDBStorageConfig:
-
-    def test_constructor_with_parameters(self):
-        """Test creating config with direct parameters"""
-        config = CosmosDBStorageConfig(
-            cosmos_db_endpoint="https://test.documents.azure.com:443/",
-            auth_key="test_key",
-            database_id="test_db",
-            container_id="test_container",
-            container_throughput=800,
-            key_suffix="_test",
-            compatibility_mode=False,
-        )
-
-        assert config.cosmos_db_endpoint == "https://test.documents.azure.com:443/"
-        assert config.auth_key == "test_key"
-        assert config.database_id == "test_db"
-        assert config.container_id == "test_container"
-        assert config.container_throughput == 800
-        assert config.key_suffix == "_test"
-        assert config.compatibility_mode is False
-        assert config.cosmos_client_options == {}
-        assert config.credential is None
-
-    def test_constructor_with_defaults(self):
-        """Test creating config with default values"""
-        config = CosmosDBStorageConfig()
-
-        assert config.cosmos_db_endpoint == ""
-        assert config.auth_key == ""
-        assert config.database_id == ""
-        assert config.container_id == ""
-        assert config.container_throughput == 400  # Default value
-        assert config.key_suffix == ""
-        assert config.compatibility_mode is False
-        assert config.cosmos_client_options == {}
-        assert config.credential is None
-
-    def test_from_file(self, tmp_path):
-        """Test creating config from JSON file"""
-        config_file_path = tmp_path / "cosmos_config.json"
-
-        config_data = {
-            "cosmos_db_endpoint": "https://localhost:8081",
-            "auth_key": "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==",
-            "database_id": "test-db",
-            "container_id": "bot-storage",
-            "container_throughput": 600,
-            "key_suffix": "_file",
-            "compatibility_mode": True,
-            "cosmos_client_options": {"connection_policy": "test"},
-        }
-
-        with open(config_file_path, "w") as f:
-            json.dump(config_data, f)
-
-        config = CosmosDBStorageConfig(filename=str(config_file_path))
-
-        assert config.cosmos_db_endpoint == "https://localhost:8081"
-        assert (
-            config.auth_key
-            == "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
-        )
-        assert config.database_id == "test-db"
-        assert config.container_id == "bot-storage"
-        assert config.container_throughput == 600
-        assert config.key_suffix == "_file"
-        assert config.compatibility_mode is True
-        assert config.cosmos_client_options == {"connection_policy": "test"}
-
-    def test_parameter_override_file(self, tmp_path):
-        """Test that constructor parameters override file values"""
-        config_file_path = tmp_path / "cosmos_config.json"
-
-        with open(config_file_path, "w") as f:
-            json.dump(
-                {
-                    "cosmos_db_endpoint": "https://file-endpoint.com",
-                    "auth_key": "file_key",
-                    "database_id": "file_db",
-                },
-                f,
-            )
-
-        config = CosmosDBStorageConfig(
-            cosmos_db_endpoint="https://param-endpoint.com",
-            auth_key="param_key",
-            filename=str(config_file_path),
-        )
-
-        # Parameters should override file values
-        assert config.cosmos_db_endpoint == "https://param-endpoint.com"
-        assert config.auth_key == "param_key"
-        # File value should be used when parameter not provided
-        assert config.database_id == "file_db"
-
-    def test_validation_success(self):
-        """Test successful validation with all required fields"""
-        config = CosmosDBStorageConfig(
-            cosmos_db_endpoint="https://test.documents.azure.com:443/",
-            auth_key="test_key",
-            database_id="test_db",
-            container_id="test_container",
-        )
-
-        # Should not raise any exception
-        CosmosDBStorageConfig.validate_cosmos_db_config(config)
-
-    def test_validation_missing_config(self):
-        """Test validation with None config"""
-        with pytest.raises(ValueError):
-            CosmosDBStorageConfig.validate_cosmos_db_config(None)
-
-    def test_validation_missing_endpoint(self):
-        """Test validation with missing cosmos_db_endpoint"""
-        config = CosmosDBStorageConfig(
-            auth_key="test_key", database_id="test_db", container_id="test_container"
-        )
-        with pytest.raises(ValueError):
-            CosmosDBStorageConfig.validate_cosmos_db_config(config)
-
-    def test_validation_missing_auth_key(self):
-        """Test validation with missing auth_key"""
-        config = CosmosDBStorageConfig(
-            cosmos_db_endpoint="https://test.documents.azure.com:443/",
-            database_id="test_db",
-            container_id="test_container",
-        )
-        with pytest.raises(ValueError):
-            CosmosDBStorageConfig.validate_cosmos_db_config(config)
-
-    def test_validation_missing_database_id(self):
-        """Test validation with missing database_id"""
-        config = CosmosDBStorageConfig(
-            cosmos_db_endpoint="https://test.documents.azure.com:443/",
-            auth_key="test_key",
-            container_id="test_container",
-        )
-        with pytest.raises(ValueError):
-            CosmosDBStorageConfig.validate_cosmos_db_config(config)
-
-    def test_validation_missing_container_id(self):
-        """Test validation with missing container_id"""
-        config = CosmosDBStorageConfig(
-            cosmos_db_endpoint="https://test.documents.azure.com:443/",
-            auth_key="test_key",
-            database_id="test_db",
-        )
-        with pytest.raises(ValueError):
-            CosmosDBStorageConfig.validate_cosmos_db_config(config)
-
-    def test_validation_suffix_with_compatibility_mode(self):
-        """Test validation fails when using suffix with compatibility mode"""
-        config = CosmosDBStorageConfig(
-            cosmos_db_endpoint="https://test.documents.azure.com:443/",
-            auth_key="test_key",
-            database_id="test_db",
-            container_id="test_container",
-            key_suffix="_test",
-            compatibility_mode=True,
-        )
-        with pytest.raises(ValueError):
-            CosmosDBStorageConfig.validate_cosmos_db_config(config)
-
-    def test_validation_invalid_suffix_characters(self):
-        """Test validation fails with invalid characters in suffix"""
-        config = CosmosDBStorageConfig(
-            cosmos_db_endpoint="https://test.documents.azure.com:443/",
-            auth_key="test_key",
-            database_id="test_db",
-            container_id="test_container",
-            key_suffix="invalid/suffix\\with?bad#chars",
-            compatibility_mode=False,
-        )
-        with pytest.raises(ValueError, match="Cannot use invalid Row Key characters"):
-            CosmosDBStorageConfig.validate_cosmos_db_config(config)
-
-    def test_validation_valid_suffix(self):
-        """Test validation succeeds with valid suffix"""
-        config = CosmosDBStorageConfig(
-            cosmos_db_endpoint="https://test.documents.azure.com:443/",
-            auth_key="test_key",
-            database_id="test_db",
-            container_id="test_container",
-            key_suffix="valid_suffix_123",
-            compatibility_mode=False,
-        )
-        # Should not raise any exception
-        CosmosDBStorageConfig.validate_cosmos_db_config(config)
-
-    def test_cosmos_client_options(self):
-        """Test cosmos_client_options handling"""
-        options = {"connection_policy": "test", "consistency_level": "strong"}
-        config = CosmosDBStorageConfig(cosmos_client_options=options)
-        assert config.cosmos_client_options == options
-
-    def test_credential_parameter(self):
-        """Test credential parameter handling"""
-        # Mock credential (in real usage this would be a TokenCredential instance)
-        mock_credential = object()  # Placeholder for actual TokenCredential
-        config = CosmosDBStorageConfig(credential=mock_credential)
-        assert config.credential is mock_credential

microsoft_agents_storage_cosmos-0.4.0.dev4/tests/test_cosmos_db_storage.py

@@ -1,299 +0,0 @@
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-
-import gc
-
-import pytest
-import pytest_asyncio
-
-from azure.cosmos import documents
-from azure.cosmos.aio import CosmosClient
-from azure.cosmos.exceptions import CosmosResourceNotFoundError
-
-from microsoft_agents.storage.cosmos import CosmosDBStorage, CosmosDBStorageConfig
-from microsoft_agents.storage.cosmos.key_ops import sanitize_key
-
-from microsoft_agents.hosting.core.storage._storage_test_utils import (
-    QuickCRUDStorageTests,
-    MockStoreItem,
-    MockStoreItemB,
-    StorageBaseline,
-)
-
-EMULATOR_RUNNING = False
-
-
-def create_config(compat_mode):
-    return CosmosDBStorageConfig(
-        cosmos_db_endpoint="https://localhost:8081",
-        auth_key=(
-            "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGG"
-            "yPMbIZnqyMsEcaGQy67XIw/Jw=="
-        ),
-        database_id="test-db",
-        container_id="bot-storage",
-        compatibility_mode=compat_mode,
-        container_throughput=800,
-    )
-
-
-@pytest.fixture
-def config():
-    return create_config(compat_mode=False)
-
-
-async def create_cosmos_env(config, compat_mode=False, existing=False):
-    """Creates the Cosmos DB environment for testing.
-
-    If existing is False, creates a new database and container, deleting any
-    existing ones with the same name. If existing is True, creates the database
-    and container if they do not already exist."""
-
-    cosmos_client = CosmosClient(
-        config.cosmos_db_endpoint,
-        config.auth_key,
-    )
-
-    if not existing:
-        try:
-            await cosmos_client.delete_database(config.database_id)
-        except Exception:
-            pass
-        database = await cosmos_client.create_database(id=config.database_id)
-
-        try:
-            await database.delete_container(config.container_id)
-        except Exception:
-            pass
-
-        partition_key = {
-            "paths": ["/_partitionKey"] if compat_mode else ["/id"],
-            "kind": documents.PartitionKind.Hash,
-        }
-        container_client = await database.create_container(
-            id=config.container_id,
-            partition_key=partition_key,
-            offer_throughput=config.container_throughput,
-        )
-    else:
-        database = await cosmos_client.create_database_if_not_exists(
-            id=config.database_id
-        )
-        container_client = database.get_container_client(config.container_id)
-
-    return container_client
-
-
-async def cosmos_db_storage_instance(compat_mode=False, existing=False):
-    config = create_config(compat_mode)
-    container_client = await create_cosmos_env(
-        config, compat_mode=compat_mode, existing=existing
-    )
-    storage = CosmosDBStorage(config)
-    return storage, container_client
-
-
-@pytest_asyncio.fixture()
-async def cosmos_db_storage():
-    storage, _ = await cosmos_db_storage_instance()
-    return storage
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("test_require_compat", [True, False])
-@pytest.mark.skipif(not EMULATOR_RUNNING, reason="Needs the emulator to run.")
-async def test_cosmos_db_storage_flow_existing_container_and_persistence(
-    test_require_compat,
-):
-
-    config = create_config(compat_mode=test_require_compat)
-    container_client = await create_cosmos_env(config)
-
-    initial_data = {
-        "__some_key": MockStoreItem({"id": "item2", "value": "data2"}),
-        "?test": MockStoreItem({"id": "?test", "value": "data1"}),
-        "!another_key": MockStoreItem({"id": "item3", "value": "data3"}),
-        "1230": MockStoreItemB({"id": "item8", "value": "data"}, False),
-        "key-with-dash": MockStoreItem({"id": "item4", "value": "data"}),
-        "key.with.dot": MockStoreItem({"id": "item5", "value": "data"}),
-        "key/with/slash": MockStoreItem({"id": "item6", "value": "data"}),
-        "another key": MockStoreItemB({"id": "item7", "value": "data"}, True),
-    }
-
-    baseline_storage = StorageBaseline(initial_data)
-
-    for key, value in initial_data.items():
-        doc = {
-            "id": sanitize_key(
-                key,
-                config.key_suffix,
-                test_require_compat,
-            ),
-            "realId": key,
-            "document": value.store_item_to_json(),
-        }
-        await container_client.upsert_item(body=doc)
-
-    storage = CosmosDBStorage(config)
-    assert await baseline_storage.equals(storage)
-    assert (
-        await storage.read(["1230", "another key"], target_cls=MockStoreItemB)
-    ) == baseline_storage.read(["1230", "another key"])
-
-    changes = {
-        "?test": MockStoreItem({"id": "?test", "value": "data1_changed"}),
-        "__some_key": MockStoreItem({"id": "item2", "value": "data2_changed"}),
-        "new_item": MockStoreItem({"id": "new_item", "value": "new_data"}),
-    }
-
-    baseline_storage.write(changes)
-    await storage.write(changes)
-
-    baseline_storage.delete(["!another_key", "?test"])
-    await storage.delete(["!another_key", "?test"])
-    assert await baseline_storage.equals(storage)
-
-    del storage
-    gc.collect()
-    storage = CosmosDBStorage(config)
-
-    escaped_key = storage._sanitize("?test")
-    with pytest.raises(CosmosResourceNotFoundError):
-        await container_client.read_item(
-            escaped_key, storage._get_partition_key(escaped_key)
-        )
-
-    escaped_key = storage._sanitize("1230")
-    item = (
-        await container_client.read_item(
-            escaped_key, storage._get_partition_key(escaped_key)
-        )
-    ).get("document")
-    assert MockStoreItemB.from_json_to_store_item(item) == initial_data["1230"]
-
-
-@pytest.mark.skipif(not EMULATOR_RUNNING, reason="Needs the emulator to run.")
-class TestCosmosDBStorage(QuickCRUDStorageTests):
-
-    def get_compat_mode(self):
-        return False
-
-    async def storage(self, initial_data=None, existing=False):
-        storage, _ = await cosmos_db_storage_instance(
-            compat_mode=self.get_compat_mode(), existing=existing
-        )
-        if initial_data:
-            await storage.write(initial_data)
-        return storage
-
-    @pytest.mark.asyncio
-    async def test_initialize(self, cosmos_db_storage):
-        await cosmos_db_storage.initialize()
-        await cosmos_db_storage.initialize()
-        await cosmos_db_storage.write(
-            {"some_Key": MockStoreItem({"id": "123", "data": "value"})}
-        )
-        await cosmos_db_storage.initialize()
-        assert (
-            await cosmos_db_storage.read(["some_Key"], target_cls=MockStoreItem)
-        ) == {"some_Key": MockStoreItem({"id": "123", "data": "value"})}
-
-    @pytest.mark.asyncio
-    async def test_external_change_is_visible(self):
-        cosmos_storage, container_client = await cosmos_db_storage_instance()
-        assert (await cosmos_storage.read(["key"], target_cls=MockStoreItem)) == {}
-        assert (await cosmos_storage.read(["key2"], target_cls=MockStoreItem)) == {}
-        await container_client.upsert_item(
-            {
-                "id": "key",
-                "realId": "key",
-                "document": {"id": "key", "value": "data"},
-                "partitionKey": "",
-            }
-        )
-        await container_client.upsert_item(
-            {
-                "id": "key2",
-                "realId": "key2",
-                "document": {"id": "key2", "value": "new_val"},
-                "partitionKey": "",
-            }
-        )
-        assert (await cosmos_storage.read(["key"], target_cls=MockStoreItem))[
-            "key"
-        ] == MockStoreItem({"id": "key", "value": "data"})
-        assert (await cosmos_storage.read(["key2"], target_cls=MockStoreItem))[
-            "key2"
-        ] == MockStoreItem({"id": "key2", "value": "new_val"})
-
-
-@pytest.mark.skipif(not EMULATOR_RUNNING, reason="Needs the emulator to run.")
-class TestCosmosDBStorageWithCompat(TestCosmosDBStorage):
-    def get_compat_mode(self):
-        return True
-
-
-@pytest.mark.skipif(not EMULATOR_RUNNING, reason="Needs the emulator to run.")
-class TestCosmosDBStorageInit:
-
-    def test_raises_error_when_no_endpoint_provided(self, config):
-        config.cosmos_db_endpoint = None
-        with pytest.raises(ValueError):
-            CosmosDBStorage(config)
-
-    def test_raises_error_when_no_auth_key_provided(self, config):
-        config.auth_key = None
-        with pytest.raises(ValueError):
-            CosmosDBStorage(config)
-
-    def test_raises_error_when_suffix_provided_but_compat(self, config):
-        config.auth_key = None
-        config.compatibility_mode = True
-        with pytest.raises(ValueError):
-            CosmosDBStorage(config)
-
-    def test_raises_error_when_no_database_id_provided(self, config):
-        config.database_id = None
-        with pytest.raises(ValueError):
-            CosmosDBStorage(config)
-
-    def test_raises_error_when_no_container_id_provided(self, config):
-        config.container_id = None
-        with pytest.raises(ValueError):
-            CosmosDBStorage(config)
-
-    @pytest.mark.asyncio
-    @pytest.mark.parametrize("compat_mode", [True, False])
-    async def test_raises_error_different_partition_key(self, compat_mode):
-        config = create_config(compat_mode=compat_mode)
-        await create_cosmos_env(config, compat_mode=compat_mode)
-        storage = CosmosDBStorage(config)
-
-        with pytest.raises(Exception):
-
-            cosmos_client = CosmosClient(
-                config.cosmos_db_endpoint,
-                config.auth_key,
-            )
-            try:
-                await cosmos_client.delete_database(config.database_id)
-            except Exception:
-                pass
-            database = await cosmos_client.create_database(id=config.database_id)
-
-            try:
-                await database.delete_container(config.container_id)
-            except Exception:
-                pass
-
-            partition_key = {
-                "paths": ["/fake_part_key"],
-                "kind": documents.PartitionKind.Hash,
-            }
-            container_client = await database.create_container(
-                id=config.container_id,
-                partition_key=partition_key,
-                offer_throughput=config.container_throughput,
-            )
-            storage = CosmosDBStorage(config)
-            await storage.initialize()

microsoft_agents_storage_cosmos-0.4.0.dev4/tests/test_key_ops.py

@@ -1,250 +0,0 @@
-import hashlib
-import pytest
-from microsoft_agents.storage.cosmos.key_ops import truncate_key, sanitize_key
-
-# thank you AI
-
-
-@pytest.mark.parametrize(
-    "input_key,expected",
-    [
-        ("validKey123", "validKey123"),
-        ("simple", "simple"),
-        ("CamelCase", "CamelCase"),
-        ("under_score", "under_score"),
-        ("with-dash", "with-dash"),
-        ("with.dot", "with.dot"),
-    ],
-)
-def test_sanitize_key_simple(input_key, expected):
-    assert sanitize_key(input_key) == expected
-
-
-@pytest.mark.parametrize(
-    "input_key,expected",
-    [
-        ("key\\value", "key*92value"),
-        ("key?value", "key*63value"),
-        ("key/value", "key*47value"),
-        ("key#value", "key*35value"),
-        ("key\tvalue", "key*9value"),
-        ("key\nvalue", "key*10value"),
-        ("key\rvalue", "key*13value"),
-        ("key*value", "key*42value"),
-    ],
-)
-def test_sanitize_key_forbidden_chars(input_key, expected):
-    assert sanitize_key(input_key) == expected
-
-
-@pytest.mark.parametrize(
-    "input_key,expected",
-    [
-        ("key/with\\many?bad#chars", "key*47with*92many*63bad*35chars"),
-        ("a\\b/c?d#e\tf\ng\rh*i", "a*92b*47c*63d*35e*9f*10g*13h*42i"),
-        ("key/with\\many?bad#chars", "key*47with*92many*63bad*35chars"),
-    ],
-)
-def test_sanitize_key_multiple_forbidden_chars(input_key, expected):
-    assert sanitize_key(input_key) == expected
-
-
-def test_sanitize_key_with_long_key_with_forbidden_chars():
-    long_key = "a?2/!@\t3." * 100  # Create a long key
-    sanitized = sanitize_key(long_key)
-    assert len(sanitized) <= 255  # Should be truncated
-    # Ensure forbidden characters are replaced
-    assert "?" not in sanitized
-    assert "/" not in sanitized
-    assert "\t" not in sanitized
-
-
-def test_sanitize_key_with_long_key_with_forbidden_chars_with_suffix():
-    long_key = "a?2/!@\t3." * 100  # Create a long key
-    sanitized = sanitize_key(long_key, key_suffix="_suff?#*")
-    assert len(sanitized) <= 255  # Should be truncated
-    # Ensure forbidden characters are replaced
-    assert "?" not in sanitized
-    assert "/" not in sanitized
-    assert "#" not in sanitized
-
-
-def test_sanitize_key_with_long_key_with_forbidden_chars_with_suffix_compat_mode():
-    long_key = "a?2/!@\t3." * 100  # Create a long key
-    sanitized = sanitize_key(long_key, key_suffix="_suff?#*", compatibility_mode=True)
-    assert len(sanitized) <= 255  # Should be truncated
-    # Ensure forbidden characters are replaced
-    assert "?" not in sanitized
-    assert "/" not in sanitized
-    assert "#" not in sanitized
-
-
-@pytest.mark.parametrize(
-    "input_key,expected",
-    [
-        ("", ""),
-        ("   ", "   "),
-    ],
-)
-def test_sanitize_key_empty_and_whitespace(input_key, expected):
-    assert sanitize_key(input_key) == expected
-
-
-@pytest.mark.parametrize(
-    "input_key,suffix,expected",
-    [
-        ("key", "_suffix", "key_suffix"),
-        ("test", "123", "test123"),
-        ("key/value", "_clean", "key*47value_clean"),
-        ("", "_suffix", "_suffix"),
-    ],
-)
-def test_sanitize_key_with_suffix(input_key, suffix, expected):
-    assert sanitize_key(input_key, key_suffix=suffix) == expected
-
-
-def test_sanitize_key_suffix_with_truncation():
-    long_key = "a" * 250
-    suffix = "_suffix"
-    result = sanitize_key(long_key, key_suffix=suffix, compatibility_mode=True)
-    assert len(result) <= 255
-    assert (
-        result.endswith(suffix) or len(result) == 255
-    )  # Either has suffix or was truncated
-
-
-def test_sanitize_key_truncation_compatibility_mode():
-    long_key = "a" * 300
-    result = sanitize_key(long_key, compatibility_mode=True)
-    assert len(result) <= 255
-
-    # Should contain hash when truncated
-    very_long_key = "b" * 500
-    result2 = sanitize_key(very_long_key, compatibility_mode=True)
-    assert len(result2) == 255
-
-
-def test_sanitize_key_no_truncation():
-    long_key = "a" * 300
-    result = sanitize_key(long_key, compatibility_mode=False)
-    assert result == long_key  # Should be unchanged
-    assert len(result) == 300
-
-
-@pytest.mark.parametrize(
-    "input_key,expected",
-    [
-        ("short", "short"),
-        ("a" * 254, "a" * 254),
-        ("a" * 255, "a" * 255),
-    ],
-)
-def test_truncate_key_short_strings(input_key, expected):
-    assert truncate_key(input_key) == expected
-
-
-def test_truncate_key_long_strings():
-    long_key = "a" * 300
-    result = truncate_key(long_key)
-    assert len(result) == 255
-
-    # Result should end with SHA256 hash
-    expected_hash = hashlib.sha256(long_key.encode("utf-8")).hexdigest()
-    assert result.endswith(expected_hash)
-
-    # First part should be original key truncated
-    expected_prefix_len = 255 - len(expected_hash)
-    assert result.startswith("a" * expected_prefix_len)
-
-
-@pytest.mark.parametrize(
-    "input_key,compatibility_mode,expected_unchanged",
-    [
-        ("a" * 300, False, True),  # Should be unchanged
-        ("x" * 1000, False, True),  # Should be unchanged
-        (
-            "key/with\\special?chars#and\ttabs\nand\rmore*",
-            False,
-            True,
-        ),  # Should be unchanged
-    ],
-)
-def test_truncate_key_compatibility_mode_disabled(
-    input_key, compatibility_mode, expected_unchanged
-):
-    result = truncate_key(input_key, compatibility_mode=compatibility_mode)
-    if expected_unchanged:
-        assert result == input_key
-
-
-@pytest.mark.parametrize(
-    "input_key,expected_length",
-    [
-        ("a" * 255, 255),
-        ("a" * 256, 255),
-    ],
-)
-def test_truncate_key_exact_and_over_limit(input_key, expected_length):
-    result = truncate_key(input_key)
-    assert len(result) == expected_length
-
-    if len(input_key) == 255:
-        assert result == input_key
-    else:
-        assert result != input_key
-
-
-def test_truncate_key_hash_consistency():
-    long_key = "consistent_test_key_" * 20  # > 255 chars
-    result1 = truncate_key(long_key)
-    result2 = truncate_key(long_key)
-    assert result1 == result2
-    assert len(result1) == 255
-
-
-@pytest.mark.parametrize(
-    "key1,key2",
-    [
-        ("a" * 300, "b" * 300),
-        ("consistent_test_key_" * 20, "different_test_key_" * 20),
-    ],
-)
-def test_truncate_key_different_inputs_different_outputs(key1, key2):
-    result1 = truncate_key(key1)
-    result2 = truncate_key(key2)
-    assert result1 != result2
-    assert len(result1) == len(result2) == 255
-
-
-def test_sanitize_key_integration():
-    # Key with forbidden chars that will be long after sanitization + suffix
-    base_key = "test/key\\with?many#forbidden\tchars\nand\rmore*" * 10
-    suffix = "_integration_test"
-
-    result = sanitize_key(base_key, key_suffix=suffix, compatibility_mode=True)
-
-    # Should be sanitized and truncated
-    assert len(result) <= 255
-    assert "*47" in result or "*92" in result  # Contains sanitized chars
-
-    # Test without truncation
-    result_no_trunc = sanitize_key(
-        base_key, key_suffix=suffix, compatibility_mode=False
-    )
-    assert (
-        "*47" in result_no_trunc or "*92" in result_no_trunc
-    )  # Contains sanitized chars
-    assert result_no_trunc.endswith(suffix)
-
-
-@pytest.mark.parametrize(
-    "input_key,expected",
-    [
-        ("key_ñ_测试", "key_ñ_测试"),
-        ("123456789", "123456789"),
-        ("MyKey/WithSlash", "MyKey*47WithSlash"),
-    ],
-)
-def test_edge_cases(input_key, expected):
-    result = sanitize_key(input_key)
-    assert result == expected