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 <cursoragent@cursor.com>
This commit is contained in:
Brian Bjarke Jensen
co-authored by
Cursor
Cursor
parent
089a1287f8
commit
725407c88f
@@ -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
|
||||
@@ -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)
|
||||
@@ -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__])
|
||||
Reference in New Issue
Block a user