687 lines
24 KiB
Python
687 lines
24 KiB
Python
"""Tests for storage backends."""
|
|
|
|
import json
|
|
import time
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
from semantic_llm_cache.backends import MemoryBackend
|
|
from semantic_llm_cache.backends.sqlite import SQLiteBackend # noqa: F401
|
|
from semantic_llm_cache.config import CacheEntry
|
|
from semantic_llm_cache.exceptions import CacheBackendError
|
|
|
|
|
|
class TestBaseBackend:
|
|
"""Tests for BaseBackend abstract class."""
|
|
|
|
def test_cosine_similarity(self):
|
|
"""Test cosine similarity helper method."""
|
|
backend = MemoryBackend()
|
|
|
|
entry1 = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
embedding=[1.0, 0.0, 0.0],
|
|
)
|
|
entry2 = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
embedding=[1.0, 0.0, 0.0],
|
|
)
|
|
entry3 = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
embedding=[0.0, 1.0, 0.0],
|
|
)
|
|
|
|
# Test _find_best_match
|
|
candidates = [("key1", entry1), ("key2", entry2), ("key3", entry3)]
|
|
|
|
# Query matching entry1
|
|
result = backend._find_best_match(candidates, [1.0, 0.0, 0.0], threshold=0.9)
|
|
assert result is not None
|
|
key, entry, sim = result
|
|
assert sim == pytest.approx(1.0)
|
|
|
|
|
|
class TestMemoryBackend:
|
|
"""Tests for MemoryBackend."""
|
|
|
|
def test_set_and_get(self, backend, sample_entry):
|
|
"""Test basic set and get operations."""
|
|
backend.set("key1", sample_entry)
|
|
retrieved = backend.get("key1")
|
|
|
|
assert retrieved is not None
|
|
assert retrieved.prompt == sample_entry.prompt
|
|
assert retrieved.response == sample_entry.response
|
|
|
|
def test_get_nonexistent(self, backend):
|
|
"""Test getting non-existent key returns None."""
|
|
result = backend.get("nonexistent")
|
|
assert result is None
|
|
|
|
def test_delete(self, backend, sample_entry):
|
|
"""Test delete operation."""
|
|
backend.set("key1", sample_entry)
|
|
assert backend.get("key1") is not None
|
|
|
|
assert backend.delete("key1") is True
|
|
assert backend.get("key1") is None
|
|
|
|
def test_delete_nonexistent(self, backend):
|
|
"""Test deleting non-existent key returns False."""
|
|
assert backend.delete("nonexistent") is False
|
|
|
|
def test_clear(self, backend, sample_entry):
|
|
"""Test clear operation."""
|
|
backend.set("key1", sample_entry)
|
|
backend.set("key2", sample_entry)
|
|
backend.clear()
|
|
|
|
assert backend.get("key1") is None
|
|
assert backend.get("key2") is None
|
|
|
|
def test_iterate_all(self, backend):
|
|
"""Test iterating over all entries."""
|
|
entry1 = CacheEntry(prompt="p1", response="r1", created_at=time.time())
|
|
entry2 = CacheEntry(prompt="p2", response="r2", created_at=time.time())
|
|
|
|
backend.set("key1", entry1)
|
|
backend.set("key2", entry2)
|
|
|
|
results = backend.iterate()
|
|
assert len(results) == 2
|
|
|
|
def test_iterate_with_namespace(self, backend):
|
|
"""Test iterating with namespace filter."""
|
|
entry1 = CacheEntry(
|
|
prompt="p1", response="r1", namespace="ns1", created_at=time.time()
|
|
)
|
|
entry2 = CacheEntry(
|
|
prompt="p2", response="r2", namespace="ns2", created_at=time.time()
|
|
)
|
|
|
|
backend.set("key1", entry1)
|
|
backend.set("key2", entry2)
|
|
|
|
results = backend.iterate(namespace="ns1")
|
|
assert len(results) == 1
|
|
assert results[0][1].namespace == "ns1"
|
|
|
|
def test_find_similar(self, backend):
|
|
"""Test finding semantically similar entries."""
|
|
entry1 = CacheEntry(
|
|
prompt="What is Python?",
|
|
response="r1",
|
|
embedding=[1.0, 0.0, 0.0],
|
|
created_at=time.time(),
|
|
)
|
|
entry2 = CacheEntry(
|
|
prompt="What is Rust?",
|
|
response="r2",
|
|
embedding=[0.0, 1.0, 0.0],
|
|
created_at=time.time(),
|
|
)
|
|
|
|
backend.set("key1", entry1)
|
|
backend.set("key2", entry2)
|
|
|
|
# Find similar to entry1
|
|
result = backend.find_similar([1.0, 0.0, 0.0], threshold=0.9)
|
|
assert result is not None
|
|
key, entry, sim = result
|
|
assert key == "key1"
|
|
|
|
def test_find_similar_no_match(self, backend):
|
|
"""Test find_similar returns None when below threshold."""
|
|
entry = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
embedding=[1.0, 0.0, 0.0],
|
|
created_at=time.time(),
|
|
)
|
|
|
|
backend.set("key1", entry)
|
|
|
|
# Query with orthogonal vector
|
|
result = backend.find_similar([0.0, 1.0, 0.0], threshold=0.9)
|
|
assert result is None
|
|
|
|
def test_get_stats(self, backend):
|
|
"""Test get_stats returns correct info."""
|
|
entry = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
created_at=time.time(),
|
|
)
|
|
|
|
backend.set("key1", entry)
|
|
stats = backend.get_stats()
|
|
|
|
assert stats["size"] == 1
|
|
assert "hits" in stats
|
|
assert "misses" in stats
|
|
|
|
def test_hit_count_increments(self, backend, sample_entry):
|
|
"""Test hit count increments on cache hit."""
|
|
backend.set("key1", sample_entry)
|
|
|
|
backend.get("key1") # First hit
|
|
backend.get("key1") # Second hit
|
|
|
|
entry = backend.get("key1")
|
|
assert entry.hit_count >= 1
|
|
|
|
def test_lru_eviction(self):
|
|
"""Test LRU eviction when max_size is reached."""
|
|
backend = MemoryBackend(max_size=2)
|
|
|
|
entry1 = CacheEntry(prompt="p1", response="r1", created_at=time.time())
|
|
entry2 = CacheEntry(prompt="p2", response="r2", created_at=time.time())
|
|
entry3 = CacheEntry(prompt="p3", response="r3", created_at=time.time())
|
|
|
|
backend.set("key1", entry1)
|
|
backend.set("key2", entry2)
|
|
assert backend.get_stats()["size"] == 2
|
|
|
|
backend.set("key3", entry3)
|
|
# Should evict oldest (key1)
|
|
assert backend.get_stats()["size"] == 2
|
|
|
|
def test_expired_entry_not_returned(self, backend):
|
|
"""Test expired entries are not returned."""
|
|
entry = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
ttl=1,
|
|
created_at=time.time() - 2, # 2 seconds ago with 1s TTL
|
|
)
|
|
|
|
backend.set("key1", entry)
|
|
result = backend.get("key1")
|
|
assert result is None
|
|
|
|
|
|
class TestSQLiteBackend:
|
|
"""Tests for SQLiteBackend."""
|
|
|
|
@pytest.fixture
|
|
def sqlite_backend(self, tmp_path):
|
|
"""Create SQLite backend with temp database."""
|
|
from semantic_llm_cache.backends.sqlite import SQLiteBackend
|
|
|
|
db_path = tmp_path / "test_cache.db"
|
|
return SQLiteBackend(db_path)
|
|
|
|
def test_set_and_get(self, sqlite_backend, sample_entry):
|
|
"""Test basic set and get operations."""
|
|
sqlite_backend.set("key1", sample_entry)
|
|
retrieved = sqlite_backend.get("key1")
|
|
|
|
assert retrieved is not None
|
|
assert retrieved.prompt == sample_entry.prompt
|
|
assert retrieved.response == sample_entry.response
|
|
|
|
def test_persistence(self, sqlite_backend, sample_entry, tmp_path):
|
|
"""Test entries persist across backend instances."""
|
|
db_path = tmp_path / "test_persist.db"
|
|
|
|
# Create first instance
|
|
backend1 = SQLiteBackend(db_path)
|
|
backend1.set("key1", sample_entry)
|
|
|
|
# Create second instance (simulates restart)
|
|
backend2 = SQLiteBackend(db_path)
|
|
retrieved = backend2.get("key1")
|
|
|
|
assert retrieved is not None
|
|
assert retrieved.prompt == sample_entry.prompt
|
|
|
|
def test_get_stats(self, sqlite_backend):
|
|
"""Test get_stats returns correct info."""
|
|
entry = CacheEntry(prompt="test", response="response", created_at=time.time())
|
|
sqlite_backend.set("key1", entry)
|
|
|
|
stats = sqlite_backend.get_stats()
|
|
assert stats["size"] == 1
|
|
assert "db_path" in stats
|
|
|
|
def test_clear(self, sqlite_backend, sample_entry):
|
|
"""Test clear operation."""
|
|
sqlite_backend.set("key1", sample_entry)
|
|
sqlite_backend.clear()
|
|
|
|
assert sqlite_backend.get("key1") is None
|
|
|
|
def test_close_and_reopen(self, sqlite_backend, sample_entry):
|
|
"""Test closing and reopening connection."""
|
|
sqlite_backend.set("key1", sample_entry)
|
|
sqlite_backend.close()
|
|
|
|
# Should be able to use after close (reopens connection)
|
|
retrieved = sqlite_backend.get("key1")
|
|
assert retrieved is not None
|
|
|
|
|
|
class TestRedisBackend:
|
|
"""Tests for RedisBackend."""
|
|
|
|
@pytest.fixture
|
|
def mock_redis(self):
|
|
"""Create mock Redis client."""
|
|
with patch("semantic_llm_cache.backends.redis.redis_lib") as mock:
|
|
mock_client = MagicMock()
|
|
mock.from_url.return_value = mock_client
|
|
mock_client.ping.return_value = True
|
|
mock_client.get.return_value = None
|
|
mock_client.keys.return_value = []
|
|
mock_client.delete.return_value = 1
|
|
yield mock_client
|
|
|
|
@pytest.fixture
|
|
def redis_backend(self, mock_redis):
|
|
"""Create Redis backend with mocked client."""
|
|
from semantic_llm_cache.backends.redis import RedisBackend
|
|
|
|
backend = RedisBackend(url="redis://localhost:6379/0")
|
|
backend._redis = mock_redis
|
|
return backend
|
|
|
|
def test_set_and_get(self, redis_backend, mock_redis, sample_entry):
|
|
"""Test basic set and get operations."""
|
|
# Mock get to return stored data
|
|
mock_redis.get.return_value = json.dumps({
|
|
"prompt": sample_entry.prompt,
|
|
"response": sample_entry.response,
|
|
"embedding": sample_entry.embedding,
|
|
"created_at": sample_entry.created_at,
|
|
"ttl": sample_entry.ttl,
|
|
"namespace": sample_entry.namespace,
|
|
"hit_count": 0,
|
|
"input_tokens": sample_entry.input_tokens,
|
|
"output_tokens": sample_entry.output_tokens,
|
|
}).encode()
|
|
|
|
redis_backend.set("key1", sample_entry)
|
|
retrieved = redis_backend.get("key1")
|
|
|
|
assert retrieved is not None
|
|
assert retrieved.prompt == sample_entry.prompt
|
|
# set is called twice: once for initial set, once to update hit_count
|
|
assert mock_redis.set.call_count == 2
|
|
|
|
def test_get_nonexistent(self, redis_backend, mock_redis):
|
|
"""Test getting non-existent key returns None."""
|
|
mock_redis.get.return_value = None
|
|
result = redis_backend.get("nonexistent")
|
|
assert result is None
|
|
|
|
def test_delete(self, redis_backend, mock_redis, sample_entry):
|
|
"""Test delete operation."""
|
|
mock_redis.delete.return_value = 1
|
|
result = redis_backend.delete("key1")
|
|
assert result is True
|
|
mock_redis.delete.assert_called_once()
|
|
|
|
def test_delete_nonexistent(self, redis_backend, mock_redis):
|
|
"""Test deleting non-existent key returns False."""
|
|
mock_redis.delete.return_value = 0
|
|
result = redis_backend.delete("nonexistent")
|
|
assert result is False
|
|
|
|
def test_clear(self, redis_backend, mock_redis):
|
|
"""Test clear operation."""
|
|
mock_redis.keys.return_value = [b"semantic_llm_cache:key1", b"semantic_llm_cache:key2"]
|
|
redis_backend.clear()
|
|
mock_redis.delete.assert_called_once()
|
|
|
|
def test_clear_empty(self, redis_backend, mock_redis):
|
|
"""Test clear with no entries."""
|
|
mock_redis.keys.return_value = []
|
|
redis_backend.clear()
|
|
mock_redis.delete.assert_not_called()
|
|
|
|
def test_iterate_all(self, redis_backend, mock_redis, sample_entry):
|
|
"""Test iterating over all entries."""
|
|
entry_dict = {
|
|
"prompt": sample_entry.prompt,
|
|
"response": sample_entry.response,
|
|
"embedding": sample_entry.embedding,
|
|
"created_at": sample_entry.created_at,
|
|
"ttl": sample_entry.ttl,
|
|
"namespace": sample_entry.namespace,
|
|
"hit_count": 0,
|
|
"input_tokens": sample_entry.input_tokens,
|
|
"output_tokens": sample_entry.output_tokens,
|
|
}
|
|
|
|
mock_redis.keys.return_value = [b"semantic_llm_cache:key1", b"semantic_llm_cache:key2"]
|
|
mock_redis.get.return_value = json.dumps(entry_dict).encode()
|
|
|
|
results = redis_backend.iterate()
|
|
assert len(results) == 2
|
|
|
|
def test_iterate_with_namespace(self, redis_backend, mock_redis, sample_entry):
|
|
"""Test iterating with namespace filter."""
|
|
entry1_dict = {
|
|
"prompt": "p1",
|
|
"response": "r1",
|
|
"embedding": None,
|
|
"created_at": time.time(),
|
|
"ttl": None,
|
|
"namespace": "ns1",
|
|
"hit_count": 0,
|
|
"input_tokens": 0,
|
|
"output_tokens": 0,
|
|
}
|
|
entry2_dict = entry1_dict.copy()
|
|
entry2_dict["namespace"] = "ns2"
|
|
|
|
call_count = [0]
|
|
|
|
def mock_get(key):
|
|
call_count[0] += 1
|
|
if call_count[0] == 1:
|
|
return json.dumps(entry1_dict).encode()
|
|
return json.dumps(entry2_dict).encode()
|
|
|
|
mock_redis.keys.return_value = [b"semantic_llm_cache:key1", b"semantic_llm_cache:key2"]
|
|
mock_redis.get.side_effect = mock_get
|
|
|
|
results = redis_backend.iterate(namespace="ns1")
|
|
assert len(results) == 1
|
|
assert results[0][1].namespace == "ns1"
|
|
|
|
def test_find_similar(self, redis_backend, mock_redis):
|
|
"""Test finding semantically similar entries."""
|
|
entry_dict = {
|
|
"prompt": "What is Python?",
|
|
"response": "r1",
|
|
"embedding": [1.0, 0.0, 0.0],
|
|
"created_at": time.time(),
|
|
"ttl": None,
|
|
"namespace": "default",
|
|
"hit_count": 0,
|
|
"input_tokens": 0,
|
|
"output_tokens": 0,
|
|
}
|
|
|
|
mock_redis.keys.return_value = [b"semantic_llm_cache:key1"]
|
|
mock_redis.get.return_value = json.dumps(entry_dict).encode()
|
|
|
|
result = redis_backend.find_similar([1.0, 0.0, 0.0], threshold=0.9)
|
|
assert result is not None
|
|
key, entry, sim = result
|
|
assert key == "key1"
|
|
|
|
def test_find_similar_no_match(self, redis_backend, mock_redis):
|
|
"""Test find_similar returns None when below threshold."""
|
|
entry_dict = {
|
|
"prompt": "test",
|
|
"response": "response",
|
|
"embedding": [1.0, 0.0, 0.0],
|
|
"created_at": time.time(),
|
|
"ttl": None,
|
|
"namespace": "default",
|
|
"hit_count": 0,
|
|
"input_tokens": 0,
|
|
"output_tokens": 0,
|
|
}
|
|
|
|
mock_redis.keys.return_value = [b"semantic_llm_cache:key1"]
|
|
mock_redis.get.return_value = json.dumps(entry_dict).encode()
|
|
|
|
# Query with orthogonal vector
|
|
result = redis_backend.find_similar([0.0, 1.0, 0.0], threshold=0.9)
|
|
assert result is None
|
|
|
|
def test_get_stats(self, redis_backend, mock_redis):
|
|
"""Test get_stats returns correct info."""
|
|
mock_redis.keys.return_value = [b"semantic_llm_cache:key1", b"semantic_llm_cache:key2"]
|
|
stats = redis_backend.get_stats()
|
|
|
|
assert "prefix" in stats
|
|
assert stats["size"] == 2
|
|
assert stats["prefix"] == "semantic_llm_cache:"
|
|
|
|
def test_get_stats_error_handling(self, redis_backend, mock_redis):
|
|
"""Test get_stats handles Redis errors gracefully."""
|
|
mock_redis.keys.side_effect = Exception("Connection lost")
|
|
stats = redis_backend.get_stats()
|
|
|
|
assert "error" in stats
|
|
assert stats["size"] == 0
|
|
|
|
def test_make_key(self, redis_backend):
|
|
"""Test key prefixing."""
|
|
result = redis_backend._make_key("test_key")
|
|
assert result == "semantic_llm_cache:test_key"
|
|
|
|
def test_entry_to_dict(self, redis_backend, sample_entry):
|
|
"""Test converting entry to dictionary."""
|
|
result = redis_backend._entry_to_dict(sample_entry)
|
|
assert result["prompt"] == sample_entry.prompt
|
|
assert result["response"] == sample_entry.response
|
|
assert result["embedding"] == sample_entry.embedding
|
|
|
|
def test_dict_to_entry(self, redis_backend):
|
|
"""Test converting dictionary to entry."""
|
|
data = {
|
|
"prompt": "test",
|
|
"response": "response",
|
|
"embedding": [1.0, 0.0],
|
|
"created_at": time.time(),
|
|
"ttl": 100,
|
|
"namespace": "test_ns",
|
|
"hit_count": 5,
|
|
"input_tokens": 100,
|
|
"output_tokens": 50,
|
|
}
|
|
|
|
entry = redis_backend._dict_to_entry(data)
|
|
assert entry.prompt == "test"
|
|
assert entry.namespace == "test_ns"
|
|
assert entry.hit_count == 5
|
|
|
|
def test_dict_to_entry_defaults(self, redis_backend):
|
|
"""Test dict_to_entry uses defaults for missing fields."""
|
|
data = {
|
|
"prompt": "test",
|
|
"response": "response",
|
|
"created_at": time.time(),
|
|
}
|
|
|
|
entry = redis_backend._dict_to_entry(data)
|
|
assert entry.embedding is None
|
|
assert entry.ttl is None
|
|
assert entry.namespace == "default"
|
|
assert entry.hit_count == 0
|
|
assert entry.input_tokens == 0
|
|
assert entry.output_tokens == 0
|
|
|
|
def test_connection_failure(self):
|
|
"""Test connection failure raises CacheBackendError."""
|
|
from semantic_llm_cache.backends.redis import RedisBackend
|
|
from semantic_llm_cache.exceptions import CacheBackendError
|
|
|
|
# Need to patch both the import and the from_url call
|
|
with patch("semantic_llm_cache.backends.redis.redis_lib") as mock_redis:
|
|
mock_client = MagicMock()
|
|
mock_client.ping.side_effect = Exception("Connection refused")
|
|
mock_redis.from_url.return_value = mock_client
|
|
|
|
with pytest.raises(CacheBackendError, match="Failed to connect"):
|
|
RedisBackend(url="redis://localhost:9999/0")
|
|
|
|
def test_set_with_ttl(self, redis_backend, mock_redis, sample_entry):
|
|
"""Test setting entry with TTL."""
|
|
sample_entry.ttl = 3600
|
|
redis_backend.set("key1", sample_entry)
|
|
|
|
call_args = mock_redis.set.call_args
|
|
assert call_args[1]["ex"] == 3600
|
|
|
|
def test_get_expired_entry(self, redis_backend, mock_redis):
|
|
"""Test expired entry is not returned."""
|
|
expired_dict = {
|
|
"prompt": "test",
|
|
"response": "response",
|
|
"embedding": None,
|
|
"created_at": time.time() - 1000,
|
|
"ttl": 100, # 100 seconds TTL, created 1000 seconds ago
|
|
"namespace": "default",
|
|
"hit_count": 0,
|
|
"input_tokens": 0,
|
|
"output_tokens": 0,
|
|
}
|
|
|
|
mock_redis.get.return_value = json.dumps(expired_dict).encode()
|
|
mock_redis.delete.return_value = 1
|
|
|
|
result = redis_backend.get("expired_key")
|
|
assert result is None
|
|
mock_redis.delete.assert_called_once()
|
|
|
|
def test_close(self, redis_backend, mock_redis):
|
|
"""Test closing Redis connection."""
|
|
redis_backend.close()
|
|
mock_redis.close.assert_called_once()
|
|
|
|
def test_close_error_handling(self, redis_backend, mock_redis):
|
|
"""Test close handles errors gracefully."""
|
|
mock_redis.close.side_effect = Exception("Close error")
|
|
# Should not raise
|
|
redis_backend.close()
|
|
|
|
def test_iterate_with_expired_entries(self, redis_backend, mock_redis):
|
|
"""Test iterate filters out expired entries."""
|
|
expired_dict = {
|
|
"prompt": "expired",
|
|
"response": "response",
|
|
"embedding": None,
|
|
"created_at": time.time() - 1000,
|
|
"ttl": 100,
|
|
"namespace": "default",
|
|
"hit_count": 0,
|
|
"input_tokens": 0,
|
|
"output_tokens": 0,
|
|
}
|
|
valid_dict = {
|
|
"prompt": "valid",
|
|
"response": "response",
|
|
"embedding": None,
|
|
"created_at": time.time(),
|
|
"ttl": None,
|
|
"namespace": "default",
|
|
"hit_count": 0,
|
|
"input_tokens": 0,
|
|
"output_tokens": 0,
|
|
}
|
|
|
|
call_count = [0]
|
|
|
|
def mock_get(key):
|
|
call_count[0] += 1
|
|
if call_count[0] == 1:
|
|
return json.dumps(expired_dict).encode()
|
|
return json.dumps(valid_dict).encode()
|
|
|
|
mock_redis.keys.return_value = [b"semantic_llm_cache:expired", b"semantic_llm_cache:valid"]
|
|
mock_redis.get.side_effect = mock_get
|
|
|
|
results = redis_backend.iterate()
|
|
# Only valid entry should be returned
|
|
assert len(results) == 1
|
|
assert results[0][1].prompt == "valid"
|
|
|
|
def test_set_error_handling(self, redis_backend, mock_redis, sample_entry):
|
|
"""Test set handles Redis errors."""
|
|
from semantic_llm_cache.exceptions import CacheBackendError
|
|
|
|
mock_redis.set.side_effect = Exception("Redis error")
|
|
|
|
with pytest.raises(CacheBackendError, match="Failed to set"):
|
|
redis_backend.set("key1", sample_entry)
|
|
|
|
def test_delete_error_handling(self, redis_backend, mock_redis):
|
|
"""Test delete handles Redis errors."""
|
|
from semantic_llm_cache.exceptions import CacheBackendError
|
|
|
|
mock_redis.delete.side_effect = Exception("Redis error")
|
|
|
|
with pytest.raises(CacheBackendError, match="Failed to delete"):
|
|
redis_backend.delete("key1")
|
|
|
|
def test_iterate_error_handling(self, redis_backend, mock_redis):
|
|
"""Test iterate handles Redis errors."""
|
|
from semantic_llm_cache.exceptions import CacheBackendError
|
|
|
|
mock_redis.keys.side_effect = Exception("Redis error")
|
|
|
|
with pytest.raises(CacheBackendError, match="Failed to iterate"):
|
|
redis_backend.iterate()
|
|
|
|
def test_get_json_error(self, redis_backend, mock_redis):
|
|
"""Test get handles invalid JSON."""
|
|
import json
|
|
mock_redis.get.return_value = b"invalid json"
|
|
|
|
# The JSON decode error should be wrapped in CacheBackendError
|
|
with pytest.raises((CacheBackendError, json.JSONDecodeError)):
|
|
redis_backend.get("key1")
|
|
|
|
def test_import_error_without_package(self):
|
|
"""Test ImportError when redis package not installed."""
|
|
# This test validates the import guard in redis.py
|
|
from semantic_llm_cache.backends import redis as redis_module
|
|
|
|
# Check that RedisBackend is defined
|
|
assert hasattr(redis_module, "RedisBackend")
|
|
|
|
|
|
class TestCacheEntry:
|
|
"""Tests for CacheEntry dataclass."""
|
|
|
|
def test_is_expired_with_none_ttl(self):
|
|
"""Test entry with None TTL never expires."""
|
|
entry = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
ttl=None,
|
|
created_at=time.time() - 10000,
|
|
)
|
|
assert not entry.is_expired(time.time())
|
|
|
|
def test_is_expired_with_ttl(self):
|
|
"""Test entry with TTL expires correctly."""
|
|
entry = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
ttl=10,
|
|
created_at=time.time() - 15,
|
|
)
|
|
assert entry.is_expired(time.time())
|
|
|
|
def test_is_expired_not_yet(self):
|
|
"""Test entry not yet expired."""
|
|
entry = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
ttl=10,
|
|
created_at=time.time() - 5,
|
|
)
|
|
assert not entry.is_expired(time.time())
|
|
|
|
def test_estimate_cost(self):
|
|
"""Test cost estimation."""
|
|
entry = CacheEntry(
|
|
prompt="test",
|
|
response="response",
|
|
input_tokens=1000,
|
|
output_tokens=500,
|
|
)
|
|
cost = entry.estimate_cost(0.001, 0.002)
|
|
# 1000/1000 * 0.001 + 500/1000 * 0.002 = 0.001 + 0.001 = 0.002
|
|
assert cost == pytest.approx(0.002)
|