Scope integration fixtures per backend subdirectory.

Split Redis and MinIO container setup into backend-specific conftest modules so only the containers needed for collected tests are imported and started.

Co-authored-by: Cursor <[email protected]>

tests/integration/redis/_containers.py

@@ -0,0 +1,90 @@
+"""Redis container session helpers for integration tests."""
+
+from collections.abc import Generator
+from typing import Any, cast
+
+import redis
+from testcontainers.core.container import DockerContainer
+from testcontainers.core.waiting_utils import WaitStrategy, WaitStrategyTarget
+
+from python_repositories.config import RedisConfig
+
+REDIS_PORT = 6379
+
+
+class _RedisPingWaitStrategy(WaitStrategy):
+    def __init__(self) -> None:
+        super().__init__()
+        self.with_transient_exceptions(redis.exceptions.ConnectionError)
+
+    def wait_until_ready(self, container: WaitStrategyTarget) -> None:
+        redis_container = cast("RedisTestContainer", container)
+        if not self._poll(lambda: redis_container.get_client().ping()):
+            raise redis.exceptions.ConnectionError("Could not connect to Redis")
+
+
+class RedisTestContainer(DockerContainer):
+    """Redis container using wait strategies instead of the deprecated decorator."""
+
+    def __init__(self, image: str, port: int = REDIS_PORT) -> None:
+        super().__init__(image, _wait_strategy=_RedisPingWaitStrategy())
+        self.port = port
+        self.with_exposed_ports(self.port)
+
+    def get_client(self, **kwargs: Any) -> redis.Redis:
+        return redis.Redis(
+            host=self.get_container_host_ip(),
+            port=self.get_exposed_port(self.port),
+            **kwargs,
+        )
+
+
+_redis_uri: str | None = None
+_redis_container: RedisTestContainer | None = None
+_raw_redis_client: redis.Redis | None = None
+_redis_uri_refs = 0
+_raw_redis_client_refs = 0
+
+
+def redis_uri() -> Generator[str, None, None]:
+    """Yield a session-scoped Redis URI, starting the container once."""
+    global _redis_uri, _redis_container, _redis_uri_refs
+    if _redis_uri is None:
+        _redis_container = RedisTestContainer(image="redis/redis-stack:7.2.0-v0")
+        _redis_container.start()
+        redis_host = _redis_container.get_container_host_ip()
+        redis_port = _redis_container.get_exposed_port(REDIS_PORT)
+        _redis_uri = f"redis://{redis_host}:{redis_port}"
+
+    _redis_uri_refs += 1
+    yield _redis_uri
+    _redis_uri_refs -= 1
+
+    if _redis_uri_refs == 0 and _redis_container is not None:
+        _redis_container.stop()
+        _redis_container = None
+        _redis_uri = None
+
+
+def redis_config_from_container(uri: str) -> RedisConfig:
+    """Build RedisConfig from a container URI."""
+    return RedisConfig(uri=uri)
+
+
+def raw_redis_client_from_container(uri: str) -> Generator[redis.Redis, None, None]:
+    """Yield a session-scoped raw Redis client, reusing one client per session."""
+    global _raw_redis_client, _raw_redis_client_refs
+    if _raw_redis_client is None:
+        _raw_redis_client = redis.Redis.from_url(
+            url=uri,
+            socket_connect_timeout=10,
+        )
+
+    _raw_redis_client_refs += 1
+    yield _raw_redis_client
+    _raw_redis_client_refs -= 1
+
+    if _raw_redis_client_refs == 0 and _raw_redis_client is not None:
+        _raw_redis_client.flushall()
+        _raw_redis_client.close()
+        _raw_redis_client = None

tests/integration/redis/conftest.py

@@ -0,0 +1,31 @@
+"""Redis integration test fixtures."""
+
+from collections.abc import Generator
+
+import pytest
+import redis
+
+from python_repositories.config import RedisConfig
+from tests.integration.redis._containers import (
+    raw_redis_client_from_container,
+    redis_config_from_container,
+    redis_uri,
+)
+
+
+@pytest.fixture(scope="session")
+def redis_container() -> Generator[str, None, None]:
+    """Set up a Redis container for testing and yield the Redis URI."""
+    yield from redis_uri()
+
+
+@pytest.fixture(scope="session")
+def redis_config(redis_container: str) -> RedisConfig:
+    """Provide RedisConfig built from the test container."""
+    return redis_config_from_container(redis_container)
+
+
+@pytest.fixture(scope="session")
+def raw_redis_client(redis_container: str) -> Generator[redis.Redis, None, None]:
+    """Provide a raw Redis client connected to the test Redis container."""
+    yield from raw_redis_client_from_container(redis_container)

tests/integration/redis/redis_adapter_test.py

@@ -0,0 +1,299 @@
+"""Integration tests for the RedisAdapter."""
+
+from collections.abc import Generator
+import logging
+
+import pytest
+import redis
+from redis.commands.json.path import Path as RedisPath
+
+from python_repositories.adapters.redis_adapter import RedisAdapter
+from python_repositories.config import RedisConfig
+
+pytestmark = [pytest.mark.integration, pytest.mark.needs_redis]
+
+
+@pytest.fixture(scope="module")
+def data() -> Generator[dict[str, str], None, None]:
+    """Provide a sample data dictionary for tests."""
+    yield {"foo": "bar"}
+
+
+@pytest.fixture(scope="function")
+def data_in_redis(
+    raw_redis_client: redis.Redis,
+    data: dict[str, str],
+) -> Generator[tuple[str, dict[str, str]], None, None]:
+    """Fixture to set up a known value in Redis before each test."""
+    key = "test_key"
+    path = RedisPath.root_path()
+    raw_redis_client.json().set(key, path, data)
+
+    yield key, data
+
+    raw_redis_client.delete(key)
+
+
+@pytest.fixture(scope="module")
+def redis_adapter(redis_config: RedisConfig) -> Generator[RedisAdapter, None, None]:
+    """Fixture to provide a connected RedisAdapter instance."""
+    adapter = RedisAdapter(config=redis_config)
+    adapter.connect()
+    yield adapter
+    adapter.disconnect()
+
+
+@pytest.fixture(scope="function", autouse=True)
+def clear_redis(raw_redis_client: redis.Redis) -> None:
+    """Fixture to clear all Redis keys before each test."""
+    raw_redis_client.flushall()
+
+
+def test_should_log_info_when_already_connected(
+    redis_adapter: RedisAdapter,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that the RedisAdapter logs info when connect is called while already connected."""
+    with caplog.at_level(logging.INFO):
+        redis_adapter.connect()
+    assert "Already connected" in caplog.text
+    assert "Redis" in caplog.text
+
+
+def test_should_raise_connection_error_when_unable_to_connect() -> None:
+    """Test that the RedisAdapter raises ConnectionError when unable to connect."""
+    adapter = RedisAdapter(config=RedisConfig(uri="redis://invalid:6379"))
+    with pytest.raises(ConnectionError):
+        adapter.connect()
+    assert adapter._client is None
+    assert not adapter.is_connected()
+
+
+def test_connect_raises_connection_error_when_unable_to_ping(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when ping fails."""
+
+    class MockRedis:
+        """A mock Redis client that simulates a failed ping."""
+
+        def ping(self) -> bool:
+            return False
+
+    monkeypatch.setattr("redis.Redis.from_url", lambda *a, **kw: MockRedis())
+
+    adapter = RedisAdapter(config=RedisConfig(uri="redis://invalid:6379"))
+    with pytest.raises(ConnectionError, match="Could not connect to Redis"):
+        adapter.connect()
+
+
+def test_should_log_error_on_exception_during_exit(
+    redis_config: RedisConfig,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that the RedisAdapter logs an error when an exception occurs during context exit."""
+    try:
+        with RedisAdapter(config=redis_config) as adapter:
+            assert adapter.is_connected()
+            raise ValueError("Simulated error")
+    except ValueError:
+        pass
+    assert "Error while exiting context" in caplog.text
+
+
+def test_should_have_context_manager(redis_config: RedisConfig) -> None:
+    """Test that the RedisAdapter can be used as a context manager."""
+    with RedisAdapter(config=redis_config) as adapter:
+        assert adapter._client is not None
+    assert adapter._client is None
+
+
+def test_should_get_value(
+    data_in_redis: tuple[str, dict[str, str]],
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter can get a value."""
+    key, data = data_in_redis
+    value = redis_adapter.get(key)
+    assert value is not None
+    assert value == data
+
+
+def test_should_get_none_for_missing_key(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that getting a non-existent key returns None."""
+    value = redis_adapter.get("nonexistent_key")
+    assert value is None
+
+
+def test_should_raise_value_error_on_invalid_get_key(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when getting with an invalid key."""
+    invalid_keys = ["", 123, None]
+    for key in invalid_keys:
+        with pytest.raises(ValueError):
+            redis_adapter.get(key)  # type: ignore
+
+
+def test_should_raise_connection_error_on_get_when_not_connected(
+    redis_config: RedisConfig,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when getting while not connected."""
+    adapter = RedisAdapter(config=redis_config)
+    with pytest.raises(ConnectionError):
+        adapter.get("some_key")
+
+
+def test_should_set_value(
+    data: dict[str, str],
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter can set a value."""
+    key = "test_key"
+    received_data = redis_adapter.get(key)
+    assert received_data is None
+    redis_adapter.set(key, data)
+    received_data = redis_adapter.get(key)
+    assert received_data is not None
+    assert received_data == data
+
+
+def test_should_update_value(
+    data_in_redis: tuple[str, dict[str, str]],
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter can update an existing value."""
+    key, _ = data_in_redis
+    new_data = {"new_key": "new_value"}
+    received_data = redis_adapter.get(key)
+    assert received_data is not None
+    assert received_data != new_data
+    redis_adapter.set(key, new_data)
+    assert redis_adapter.get(key) == new_data
+
+
+def test_should_raise_value_error_on_invalid_set_key(
+    redis_adapter: RedisAdapter,
+    data: dict[str, str],
+) -> None:
+    """Test that the RedisAdapter raises ValueError when setting with an invalid key."""
+    invalid_keys = ["", 123, None]
+    for key in invalid_keys:
+        with pytest.raises(ValueError):
+            redis_adapter.set(key, data)  # type: ignore
+
+
+def test_should_raise_value_error_on_invalid_set_data(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when setting with invalid data."""
+    key = "test_key"
+    invalid_data = ["", 123, None, [], {}]
+    for data in invalid_data:
+        with pytest.raises(ValueError):
+            redis_adapter.set(key, data)  # type: ignore
+
+
+def test_should_raise_connection_error_on_set_when_not_connected(
+    redis_config: RedisConfig,
+    data: dict[str, str],
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when setting while not connected."""
+    adapter = RedisAdapter(config=redis_config)
+    with pytest.raises(ConnectionError):
+        adapter.set("test_key", data)
+
+
+def test_should_delete_key(
+    data_in_redis: tuple[str, dict[str, str]],
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that deleting a key removes it from Redis."""
+    key, _ = data_in_redis
+    received_data = redis_adapter.get(key)
+    assert received_data is not None
+    redis_adapter.delete(key)
+    assert redis_adapter.get(key) is None
+
+
+def test_should_raise_value_error_on_invalid_delete_key(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when deleting with an invalid key."""
+    invalid_keys = ["", 123, None]
+    for key in invalid_keys:
+        with pytest.raises(ValueError):
+            redis_adapter.delete(key)  # type: ignore
+
+
+def test_should_raise_connection_error_on_delete_when_not_connected(
+    redis_config: RedisConfig,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when deleting while not connected."""
+    adapter = RedisAdapter(config=redis_config)
+    with pytest.raises(ConnectionError):
+        adapter.delete("some_key")
+
+
+def test_should_list_keys(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test listing keys matching a pattern returns correct keys."""
+    redis_adapter.set("key1", {"a": 1})
+    redis_adapter.set("key2", {"b": 2})
+    keys = redis_adapter.list_keys("key*")
+    assert set(keys) == {"key1", "key2"}
+
+
+def test_should_raise_value_error_on_invalid_list_keys_pattern(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when listing keys with an invalid pattern."""
+    invalid_patterns = ["", 123, None]
+    for pattern in invalid_patterns:
+        with pytest.raises(ValueError):
+            redis_adapter.list_keys(pattern)  # type: ignore
+
+
+def test_should_raise_connection_error_on_list_keys_when_not_connected(
+    redis_config: RedisConfig,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when listing keys while not connected."""
+    adapter = RedisAdapter(config=redis_config)
+    with pytest.raises(ConnectionError):
+        adapter.list_keys("some_pattern")
+
+
+def test_should_scan_keys(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test scanning keys matching a pattern returns correct keys."""
+    redis_adapter.set("key1", {"a": 1})
+    redis_adapter.set("key2", {"b": 2})
+    keys = set(redis_adapter.scan_keys("key*"))
+    assert keys == {"key1", "key2"}
+
+
+def test_should_raise_value_error_on_invalid_scan_keys_pattern(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when scanning keys with an invalid pattern."""
+    invalid_patterns = ["", 123, None]
+    for pattern in invalid_patterns:
+        with pytest.raises(ValueError):
+            list(redis_adapter.scan_keys(pattern))  # type: ignore[arg-type]
+
+
+def test_should_raise_connection_error_on_scan_keys_when_not_connected(
+    redis_config: RedisConfig,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when scanning keys while not connected."""
+    adapter = RedisAdapter(config=redis_config)
+    with pytest.raises(ConnectionError):
+        list(adapter.scan_keys("some_pattern"))
+
+
+if __name__ == "__main__":
+    pytest.main(["-s", "-v", __file__])