gmakstutis/cognee
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: adds redis adapter and corresponding structure unit tests

Browse source
This commit is contained in:
hajdul88 2025-10-10 11:33:11 +02:00
parent aeafdc1dd8
commit 417e476ee2
3 changed files with 638 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

283
cognee/tests/unit/infrastructure/databases/cache/redis/test_redis_adapter.py vendored Normal file
View file

@ -0,0 +1,283 @@
"""Tests for the RedisAdapter class."""
import pytest
from unittest.mock import MagicMock, patch
import redis
from cognee.infrastructure.databases.cache.redis.RedisAdapter import RedisAdapter
from cognee.infrastructure.databases.cache.cache_db_interface import CacheDBInterface
@pytest.fixture
def mock_redis():
"""Fixture to mock redis.Redis client."""
with patch("redis.Redis") as mock:
yield mock
@pytest.fixture
def redis_adapter(mock_redis):
"""Fixture to create a RedisAdapter instance with mocked Redis client."""
adapter = RedisAdapter(
host="localhost",
port=6379,
lock_name="test-lock",
timeout=240,
blocking_timeout=300,
)
return adapter
def test_redis_adapter_initialization(mock_redis):
"""Test that RedisAdapter initializes correctly."""
adapter = RedisAdapter(
host="localhost",
port=6379,
lock_name="my-lock",
timeout=120,
blocking_timeout=150,
)
assert adapter.host == "localhost"
assert adapter.port == 6379
assert adapter.lock_key == "my-lock"
assert adapter.timeout == 120
assert adapter.blocking_timeout == 150
assert adapter.lock is None
mock_redis.assert_called_once_with(host="localhost", port=6379)
def test_redis_adapter_inherits_cache_db_interface(mock_redis):
"""Test that RedisAdapter properly inherits from CacheDBInterface."""
adapter = RedisAdapter(
host="localhost",
port=6379,
lock_name="test-lock",
)
assert isinstance(adapter, CacheDBInterface)
def test_redis_adapter_custom_parameters(mock_redis):
"""Test RedisAdapter with custom parameters."""
adapter = RedisAdapter(
host="redis.example.com",
port=6380,
lock_name="custom-lock-key",
timeout=60,
blocking_timeout=90,
)
assert adapter.host == "redis.example.com"
assert adapter.port == 6380
assert adapter.lock_key == "custom-lock-key"
assert adapter.timeout == 60
assert adapter.blocking_timeout == 90
def test_acquire_lock_success(redis_adapter):
"""Test successful lock acquisition."""
mock_lock = MagicMock()
mock_lock.acquire.return_value = True
redis_adapter.redis.lock.return_value = mock_lock
result = redis_adapter.acquire()
assert result is mock_lock
assert redis_adapter.lock is mock_lock
redis_adapter.redis.lock.assert_called_once_with(
name="test-lock",
timeout=240,
blocking_timeout=300,
)
mock_lock.acquire.assert_called_once()
def test_acquire_lock_failure(redis_adapter):
"""Test lock acquisition failure raises RuntimeError."""
mock_lock = MagicMock()
mock_lock.acquire.return_value = False
redis_adapter.redis.lock.return_value = mock_lock
with pytest.raises(RuntimeError, match="Could not acquire Redis lock: test-lock"):
redis_adapter.acquire()
redis_adapter.redis.lock.assert_called_once()
mock_lock.acquire.assert_called_once()
def test_acquire_lock_with_custom_parameters():
"""Test lock acquisition with custom timeout parameters."""
with patch("redis.Redis") as mock_redis_class:
adapter = RedisAdapter(
host="localhost",
port=6379,
lock_name="custom-lock",
timeout=100,
blocking_timeout=200,
)
mock_lock = MagicMock()
mock_lock.acquire.return_value = True
adapter.redis.lock.return_value = mock_lock
adapter.acquire()
adapter.redis.lock.assert_called_once_with(
name="custom-lock",
timeout=100,
blocking_timeout=200,
)
def test_release_lock_success(redis_adapter):
"""Test successful lock release."""
mock_lock = MagicMock()
redis_adapter.lock = mock_lock
redis_adapter.release()
mock_lock.release.assert_called_once()
assert redis_adapter.lock is None
def test_release_lock_when_none(redis_adapter):
"""Test releasing lock when no lock is held."""
redis_adapter.lock = None
redis_adapter.release()
def test_release_lock_handles_lock_error(redis_adapter):
"""Test that release handles redis.exceptions.LockError gracefully."""
mock_lock = MagicMock()
mock_lock.release.side_effect = redis.exceptions.LockError("Lock not owned")
redis_adapter.lock = mock_lock
redis_adapter.release()
mock_lock.release.assert_called_once()
def test_release_lock_propagates_other_exceptions(redis_adapter):
"""Test that release propagates non-LockError exceptions."""
mock_lock = MagicMock()
mock_lock.release.side_effect = redis.exceptions.ConnectionError("Connection lost")
redis_adapter.lock = mock_lock
with pytest.raises(redis.exceptions.ConnectionError):
redis_adapter.release()
def test_hold_context_manager_success(redis_adapter):
"""Test hold context manager with successful acquisition and release."""
mock_lock = MagicMock()
mock_lock.acquire.return_value = True
redis_adapter.redis.lock.return_value = mock_lock
with redis_adapter.hold():
assert redis_adapter.lock is mock_lock
mock_lock.acquire.assert_called_once()
mock_lock.release.assert_called_once()
def test_hold_context_manager_with_exception(redis_adapter):
"""Test that hold context manager releases lock even when exception occurs."""
mock_lock = MagicMock()
mock_lock.acquire.return_value = True
redis_adapter.redis.lock.return_value = mock_lock
with pytest.raises(ValueError):
with redis_adapter.hold():
mock_lock.acquire.assert_called_once()
raise ValueError("Test exception")
mock_lock.release.assert_called_once()
def test_hold_context_manager_acquire_failure(redis_adapter):
"""Test hold context manager when lock acquisition fails."""
mock_lock = MagicMock()
mock_lock.acquire.return_value = False
redis_adapter.redis.lock.return_value = mock_lock
with pytest.raises(RuntimeError, match="Could not acquire Redis lock"):
with redis_adapter.hold():
pass
mock_lock.release.assert_not_called()
def test_multiple_acquire_release_cycles(redis_adapter):
"""Test multiple acquire/release cycles."""
mock_lock1 = MagicMock()
mock_lock1.acquire.return_value = True
mock_lock2 = MagicMock()
mock_lock2.acquire.return_value = True
redis_adapter.redis.lock.side_effect = [mock_lock1, mock_lock2]
redis_adapter.acquire()
assert redis_adapter.lock is mock_lock1
redis_adapter.release()
assert redis_adapter.lock is None
redis_adapter.acquire()
assert redis_adapter.lock is mock_lock2
redis_adapter.release()
assert redis_adapter.lock is None
def test_redis_adapter_redis_client_initialization():
"""Test that Redis client is initialized with correct connection parameters."""
with patch("redis.Redis") as mock_redis_class:
mock_redis_instance = MagicMock()
mock_redis_class.return_value = mock_redis_instance
adapter = RedisAdapter(
host="redis-server.example.com",
port=6380,
lock_name="test-lock",
)
mock_redis_class.assert_called_once_with(
host="redis-server.example.com",
port=6380,
)
assert adapter.redis is mock_redis_instance
def test_lock_name_vs_lock_key_parameter():
"""Test that lock_name parameter is correctly assigned to lock_key attribute."""
with patch("redis.Redis"):
adapter = RedisAdapter(
host="localhost",
port=6379,
lock_name="my-custom-lock-name",
)
assert adapter.lock_key == "my-custom-lock-name"
def test_default_timeout_parameters():
"""Test default timeout parameters."""
with patch("redis.Redis"):
adapter = RedisAdapter(
host="localhost",
port=6379,
lock_name="test-lock",
)
assert adapter.timeout == 240
assert adapter.blocking_timeout == 300
def test_release_clears_lock_reference(redis_adapter):
"""Test that release clears the lock reference."""
mock_lock = MagicMock()
redis_adapter.lock = mock_lock
redis_adapter.release()
assert redis_adapter.lock is None

127
cognee/tests/unit/infrastructure/databases/cache/test_cache_config.py vendored Normal file
View file

@ -0,0 +1,127 @@
"""Tests for cache configuration."""
import pytest
from unittest.mock import patch
from cognee.infrastructure.databases.cache.config import CacheConfig, get_cache_config
@pytest.fixture(autouse=True)
def reset_cache_config_singleton():
"""Reset the singleton instance between tests."""
get_cache_config.cache_clear()
yield
get_cache_config.cache_clear()
def test_cache_config_defaults():
"""Test that CacheConfig has the correct default values."""
config = CacheConfig()
assert config.caching is False
assert config.shared_kuzu_lock is False
assert config.cache_host == "localhost"
assert config.cache_port == 6379
assert config.agentic_lock_expire == 240
assert config.agentic_lock_timeout == 300
def test_cache_config_custom_values():
"""Test that CacheConfig accepts custom values."""
config = CacheConfig(
caching=True,
shared_kuzu_lock=True,
cache_host="redis.example.com",
cache_port=6380,
agentic_lock_expire=120,
agentic_lock_timeout=180,
)
assert config.caching is True
assert config.shared_kuzu_lock is True
assert config.cache_host == "redis.example.com"
assert config.cache_port == 6380
assert config.agentic_lock_expire == 120
assert config.agentic_lock_timeout == 180
def test_cache_config_to_dict():
"""Test the to_dict method returns all configuration values."""
config = CacheConfig(
caching=True,
shared_kuzu_lock=True,
cache_host="test-host",
cache_port=7000,
agentic_lock_expire=100,
agentic_lock_timeout=200,
)
config_dict = config.to_dict()
assert config_dict == {
"caching": True,
"shared_kuzu_lock": True,
"cache_host": "test-host",
"cache_port": 7000,
"agentic_lock_expire": 100,
"agentic_lock_timeout": 200,
}
def test_get_cache_config_singleton():
"""Test that get_cache_config returns the same instance."""
config1 = get_cache_config()
config2 = get_cache_config()
assert config1 is config2
def test_cache_config_from_environment():
"""Test that CacheConfig reads from environment variables."""
with patch.dict(
"os.environ",
{
"CACHING": "true",
"SHARED_KUZU_LOCK": "true",
"CACHE_HOST": "env-redis",
"CACHE_PORT": "6380",
"AGENTIC_LOCK_EXPIRE": "300",
"AGENTIC_LOCK_TIMEOUT": "400",
},
):
get_cache_config.cache_clear()
config = get_cache_config()
assert config.caching is True
assert config.shared_kuzu_lock is True
assert config.cache_host == "env-redis"
assert config.cache_port == 6380
assert config.agentic_lock_expire == 300
assert config.agentic_lock_timeout == 400
def test_cache_config_extra_fields_allowed():
"""Test that CacheConfig allows extra fields due to extra='allow'."""
config = CacheConfig(extra_field="extra_value", another_field=123)
# Extra fields should be accepted without error
assert hasattr(config, "extra_field")
assert config.extra_field == "extra_value"
assert hasattr(config, "another_field")
assert config.another_field == 123
def test_cache_config_port_type_validation():
"""Test that cache_port validates integer type."""
with pytest.raises(Exception): # Pydantic validation error
CacheConfig(cache_port="not_a_number")
def test_cache_config_boolean_type_validation():
"""Test that boolean fields accept various truthy/falsy values."""
config1 = CacheConfig(caching="true", shared_kuzu_lock="yes")
assert config1.caching is True
assert config1.shared_kuzu_lock is True
config2 = CacheConfig(caching="false", shared_kuzu_lock="no")
assert config2.caching is False
assert config2.shared_kuzu_lock is False

228
cognee/tests/unit/infrastructure/databases/cache/test_cache_engine.py vendored Normal file
View file

@ -0,0 +1,228 @@
"""Tests for cache engine factory methods."""
import pytest
from unittest.mock import patch, MagicMock
from cognee.infrastructure.databases.cache.get_cache_engine import (
create_cache_engine,
get_cache_engine,
)
from cognee.infrastructure.databases.cache.redis.RedisAdapter import RedisAdapter
@pytest.fixture(autouse=True)
def reset_factory_cache():
"""Reset the lru_cache between tests."""
create_cache_engine.cache_clear()
yield
create_cache_engine.cache_clear()
@pytest.fixture
def mock_cache_config():
"""Fixture to mock cache configuration."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.get_cache_config") as mock:
mock_config = MagicMock()
mock_config.caching = True
mock_config.cache_host = "localhost"
mock_config.cache_port = 6379
mock_config.agentic_lock_expire = 240
mock_config.agentic_lock_timeout = 300
mock.return_value = mock_config
yield mock_config
def test_create_cache_engine_with_caching_enabled(mock_cache_config):
"""Test that create_cache_engine returns RedisAdapter when caching is enabled."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config") as mock_config:
mock_config.caching = True
with patch("redis.Redis"):
engine = create_cache_engine(
cache_host="localhost",
cache_port=6379,
lock_key="test-lock",
agentic_lock_expire=240,
agentic_lock_timeout=300,
)
assert engine is not None
assert isinstance(engine, RedisAdapter)
assert engine.host == "localhost"
assert engine.port == 6379
assert engine.lock_key == "test-lock"
assert engine.timeout == 240
assert engine.blocking_timeout == 300
def test_create_cache_engine_with_caching_disabled():
"""Test that create_cache_engine returns None when caching is disabled."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config") as mock_config:
mock_config.caching = False
engine = create_cache_engine(
cache_host="localhost",
cache_port=6379,
lock_key="test-lock",
)
assert engine is None
def test_create_cache_engine_caching():
"""Test that create_cache_engine uses lru_cache and returns same instance."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config") as mock_config:
mock_config.caching = True
with patch("redis.Redis"):
engine1 = create_cache_engine(
cache_host="localhost",
cache_port=6379,
lock_key="test-lock",
)
engine2 = create_cache_engine(
cache_host="localhost",
cache_port=6379,
lock_key="test-lock",
)
assert engine1 is engine2
def test_create_cache_engine_different_params():
"""Test that create_cache_engine returns different instances for different parameters."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config") as mock_config:
mock_config.caching = True
with patch("redis.Redis"):
engine1 = create_cache_engine(
cache_host="localhost",
cache_port=6379,
lock_key="lock-1",
)
engine2 = create_cache_engine(
cache_host="localhost",
cache_port=6379,
lock_key="lock-2",
)
assert engine1 is not engine2
assert engine1.lock_key == "lock-1"
assert engine2.lock_key == "lock-2"
def test_create_cache_engine_custom_timeouts():
"""Test that create_cache_engine accepts custom timeout values."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config") as mock_config:
mock_config.caching = True
with patch("redis.Redis"):
engine = create_cache_engine(
cache_host="redis.example.com",
cache_port=6380,
lock_key="custom-lock",
agentic_lock_expire=120,
agentic_lock_timeout=150,
)
assert isinstance(engine, RedisAdapter)
assert engine.host == "redis.example.com"
assert engine.port == 6380
assert engine.timeout == 120
assert engine.blocking_timeout == 150
def test_get_cache_engine_uses_config(mock_cache_config):
"""Test that get_cache_engine uses configuration values."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config", mock_cache_config):
mock_cache_config.caching = True
with patch("redis.Redis"):
with patch(
"cognee.infrastructure.databases.cache.get_cache_engine.create_cache_engine"
) as mock_create:
mock_create.return_value = MagicMock()
get_cache_engine("my-lock-key")
mock_create.assert_called_once_with(
cache_host="localhost",
cache_port=6379,
lock_key="my-lock-key",
agentic_lock_expire=240,
agentic_lock_timeout=300,
)
def test_get_cache_engine_with_custom_config():
"""Test that get_cache_engine properly uses custom config values."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config") as mock_config:
mock_config.caching = True
mock_config.cache_host = "custom-redis"
mock_config.cache_port = 7000
mock_config.agentic_lock_expire = 100
mock_config.agentic_lock_timeout = 200
with patch("redis.Redis"):
engine = get_cache_engine("test-key")
assert isinstance(engine, RedisAdapter)
assert engine.host == "custom-redis"
assert engine.port == 7000
assert engine.lock_key == "test-key"
assert engine.timeout == 100
assert engine.blocking_timeout == 200
def test_get_cache_engine_when_disabled():
"""Test that get_cache_engine returns None when caching is disabled."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config") as mock_config:
mock_config.caching = False
engine = get_cache_engine("test-key")
assert engine is None
def test_create_cache_engine_default_timeout_values():
"""Test that create_cache_engine uses default timeout values."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config") as mock_config:
mock_config.caching = True
with patch("redis.Redis"):
engine = create_cache_engine(
cache_host="localhost",
cache_port=6379,
lock_key="test-lock",
)
assert isinstance(engine, RedisAdapter)
assert engine.timeout == 240
assert engine.blocking_timeout == 300
def test_full_workflow_with_context_manager():
"""Test complete workflow: config -> factory -> adapter with context manager."""
with patch("cognee.infrastructure.databases.cache.get_cache_engine.config") as mock_config:
mock_config.caching = True
mock_config.cache_host = "localhost"
mock_config.cache_port = 6379
mock_config.agentic_lock_expire = 240
mock_config.agentic_lock_timeout = 300
with patch("redis.Redis") as mock_redis_class:
mock_redis_instance = MagicMock()
mock_redis_class.return_value = mock_redis_instance
mock_lock = MagicMock()
mock_lock.acquire.return_value = True
mock_redis_instance.lock.return_value = mock_lock
engine = get_cache_engine("integration-test-lock")
assert isinstance(engine, RedisAdapter)
with engine.hold():
mock_lock.acquire.assert_called_once()
mock_lock.release.assert_called_once()