mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
446 lines
13 KiB
Python
446 lines
13 KiB
Python
# SPDX-License-Identifier: Apache-2.0
|
|
# Copyright (c) 2025 NoDupeLabs
|
|
|
|
"""Tests to achieve 100% coverage on query_cache.py module.
|
|
|
|
This test file targets the missing coverage in:
|
|
- query_cache.py: QueryCache class methods
|
|
"""
|
|
|
|
import time
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
from nodupe.tools.databases.query_cache import (
|
|
QueryCache,
|
|
QueryCacheError,
|
|
create_query_cache,
|
|
)
|
|
|
|
|
|
class TestQueryCacheInit:
|
|
"""Tests for QueryCache initialization."""
|
|
|
|
def test_init_default_values(self):
|
|
"""Test QueryCache with default values."""
|
|
cache = QueryCache()
|
|
assert cache.max_size == 1000
|
|
assert cache.ttl_seconds == 3600
|
|
|
|
def test_init_custom_values(self):
|
|
"""Test QueryCache with custom values."""
|
|
cache = QueryCache(max_size=500, ttl_seconds=1800)
|
|
assert cache.max_size == 500
|
|
assert cache.ttl_seconds == 1800
|
|
|
|
def test_init_stats_initialized(self):
|
|
"""Test stats are initialized correctly."""
|
|
cache = QueryCache()
|
|
stats = cache._stats
|
|
|
|
assert stats['hits'] == 0
|
|
assert stats['misses'] == 0
|
|
assert stats['evictions'] == 0
|
|
assert stats['insertions'] == 0
|
|
|
|
|
|
class TestGetResult:
|
|
"""Tests for get_result method."""
|
|
|
|
def test_get_result_miss(self):
|
|
"""Test get_result when not cached."""
|
|
cache = QueryCache()
|
|
result = cache.get_result("SELECT * FROM test")
|
|
assert result is None
|
|
|
|
def test_get_result_hit(self):
|
|
"""Test get_result when cached."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", result={"data": "value"})
|
|
|
|
result = cache.get_result("SELECT * FROM test")
|
|
assert result == {"data": "value"}
|
|
|
|
def test_get_result_with_params(self):
|
|
"""Test get_result with parameters."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test WHERE id = ?", params={"id": 1}, result=[1])
|
|
|
|
result = cache.get_result("SELECT * FROM test WHERE id = ?", params={"id": 1})
|
|
assert result == [1]
|
|
|
|
def test_get_result_params_mismatch(self):
|
|
"""Test get_result with different parameters."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", params={"id": 1}, result=[1])
|
|
|
|
result = cache.get_result("SELECT * FROM test", params={"id": 2})
|
|
assert result is None
|
|
|
|
def test_get_result_expired(self):
|
|
"""Test get_result when entry is expired."""
|
|
cache = QueryCache(ttl_seconds=1)
|
|
|
|
# Manually add with old timestamp
|
|
cache._cache["select * from test:none"] = ({"data": "value"}, time.monotonic() - 10)
|
|
|
|
result = cache.get_result("SELECT * FROM test")
|
|
assert result is None
|
|
|
|
|
|
class TestSetResult:
|
|
"""Tests for set_result method."""
|
|
|
|
def test_set_result_basic(self):
|
|
"""Test basic set_result."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", result={"data": "value"})
|
|
|
|
assert "select * from test:none" in cache._cache
|
|
|
|
def test_set_result_with_params(self):
|
|
"""Test set_result with parameters."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", params={"id": 1}, result=[1])
|
|
|
|
# Check that key is generated with params hash
|
|
keys = list(cache._cache.keys())
|
|
assert any("select * from test:" in k for k in keys)
|
|
|
|
def test_set_result_updates_stats(self):
|
|
"""Test set_result updates insertion stats."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", result={"data": "value"})
|
|
|
|
assert cache._stats['insertions'] == 1
|
|
|
|
def test_set_result_eviction_when_full(self):
|
|
"""Test set_result evicts oldest when cache is full."""
|
|
cache = QueryCache(max_size=2)
|
|
|
|
cache.set_result("SELECT 1", result=1)
|
|
cache.set_result("SELECT 2", result=2)
|
|
cache.set_result("SELECT 3", result=3)
|
|
|
|
assert len(cache._cache) == 2
|
|
assert cache._stats['evictions'] == 1
|
|
|
|
|
|
class TestInvalidate:
|
|
"""Tests for invalidate method."""
|
|
|
|
def test_invalidate_existing(self):
|
|
"""Test invalidating existing entry."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", result={"data": "value"})
|
|
|
|
result = cache.invalidate("SELECT * FROM test")
|
|
|
|
assert result is True
|
|
assert "select * from test:none" not in cache._cache
|
|
|
|
def test_invalidate_nonexisting(self):
|
|
"""Test invalidating non-existing entry."""
|
|
cache = QueryCache()
|
|
result = cache.invalidate("SELECT * FROM nonexistent")
|
|
|
|
assert result is False
|
|
|
|
|
|
class TestInvalidateAll:
|
|
"""Tests for invalidate_all method."""
|
|
|
|
def test_invalidate_all(self):
|
|
"""Test invalidating all entries."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT 1", result=1)
|
|
cache.set_result("SELECT 2", result=2)
|
|
|
|
cache.invalidate_all()
|
|
|
|
assert len(cache._cache) == 0
|
|
assert cache._stats['evictions'] == 2
|
|
|
|
|
|
class TestInvalidateByPrefix:
|
|
"""Tests for invalidate_by_prefix method."""
|
|
|
|
def test_invalidate_by_prefix(self):
|
|
"""Test invalidating by prefix."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM users", result=[1])
|
|
cache.set_result("SELECT * FROM posts", result=[2])
|
|
cache.set_result("SELECT * FROM comments", result=[3])
|
|
|
|
count = cache.invalidate_by_prefix("select * from users")
|
|
|
|
assert count == 1
|
|
|
|
def test_invalidate_by_prefix_no_match(self):
|
|
"""Test invalidating by prefix with no match."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM users", result=[1])
|
|
|
|
count = cache.invalidate_by_prefix("nonexistent")
|
|
|
|
assert count == 0
|
|
|
|
|
|
class TestValidateCache:
|
|
"""Tests for validate_cache method."""
|
|
|
|
def test_validate_cache_removes_expired(self):
|
|
"""Test validate_cache removes expired entries."""
|
|
cache = QueryCache(ttl_seconds=1)
|
|
|
|
# Manually add with old timestamp
|
|
cache._cache["test:none"] = ({"data": "value"}, time.monotonic() - 10)
|
|
|
|
removed = cache.validate_cache()
|
|
|
|
assert removed == 1
|
|
assert "test:none" not in cache._cache
|
|
|
|
def test_validate_cache_none_expired(self):
|
|
"""Test validate_cache when no entries expired."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", result={"data": "value"})
|
|
|
|
removed = cache.validate_cache()
|
|
|
|
assert removed == 0
|
|
|
|
|
|
class TestGetStats:
|
|
"""Tests for get_stats method."""
|
|
|
|
def test_get_stats_basic(self):
|
|
"""Test basic get_stats."""
|
|
cache = QueryCache()
|
|
stats = cache.get_stats()
|
|
|
|
assert 'hits' in stats
|
|
assert 'misses' in stats
|
|
assert 'evictions' in stats
|
|
assert 'insertions' in stats
|
|
assert 'size' in stats
|
|
assert 'capacity' in stats
|
|
assert 'hit_rate' in stats
|
|
|
|
def test_get_stats_with_hits(self):
|
|
"""Test get_stats with cache hits."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", result={"data": "value"})
|
|
cache.get_result("SELECT * FROM test") # Hit
|
|
cache.get_result("SELECT * FROM test") # Hit
|
|
|
|
stats = cache.get_stats()
|
|
assert stats['hits'] == 2
|
|
assert stats['hit_rate'] == 1.0
|
|
|
|
def test_get_stats_hit_rate_no_activity(self):
|
|
"""Test hit rate calculation with no activity."""
|
|
cache = QueryCache()
|
|
stats = cache.get_stats()
|
|
|
|
assert stats['hit_rate'] == 0.0
|
|
|
|
|
|
class TestGetCacheSize:
|
|
"""Tests for get_cache_size method."""
|
|
|
|
def test_get_cache_size_empty(self):
|
|
"""Test get_cache_size when empty."""
|
|
cache = QueryCache()
|
|
assert cache.get_cache_size() == 0
|
|
|
|
def test_get_cache_size_with_entries(self):
|
|
"""Test get_cache_size with entries."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", result={"data": "value"})
|
|
|
|
assert cache.get_cache_size() == 1
|
|
|
|
|
|
class TestIsCached:
|
|
"""Tests for is_cached method."""
|
|
|
|
def test_is_cached_true(self):
|
|
"""Test is_cached when cached."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", result={"data": "value"})
|
|
|
|
assert cache.is_cached("SELECT * FROM test") is True
|
|
|
|
def test_is_cached_false(self):
|
|
"""Test is_cached when not cached."""
|
|
cache = QueryCache()
|
|
assert cache.is_cached("SELECT * FROM nonexistent") is False
|
|
|
|
|
|
class TestCleanupExpired:
|
|
"""Tests for cleanup_expired method."""
|
|
|
|
def test_cleanup_expired(self):
|
|
"""Test cleanup_expired."""
|
|
cache = QueryCache(ttl_seconds=1)
|
|
|
|
# Manually add with old timestamp
|
|
cache._cache["test:none"] = ({"data": "value"}, time.monotonic() - 10)
|
|
|
|
removed = cache.cleanup_expired()
|
|
|
|
assert removed == 1
|
|
|
|
|
|
class TestResize:
|
|
"""Tests for resize method."""
|
|
|
|
def test_resize_smaller(self):
|
|
"""Test resizing to smaller size."""
|
|
cache = QueryCache(max_size=10)
|
|
cache.set_result("SELECT 1", result=1)
|
|
cache.set_result("SELECT 2", result=2)
|
|
|
|
cache.resize(1)
|
|
|
|
assert cache.max_size == 1
|
|
assert len(cache._cache) == 1
|
|
|
|
def test_resize_larger(self):
|
|
"""Test resizing to larger size."""
|
|
cache = QueryCache(max_size=2)
|
|
cache.resize(10)
|
|
assert cache.max_size == 10
|
|
|
|
|
|
class TestGetMemoryUsage:
|
|
"""Tests for get_memory_usage method."""
|
|
|
|
def test_get_memory_usage_empty(self):
|
|
"""Test get_memory_usage when empty."""
|
|
cache = QueryCache()
|
|
usage = cache.get_memory_usage()
|
|
assert usage == 0
|
|
|
|
def test_get_memory_usage_with_entries(self):
|
|
"""Test get_memory_usage with entries."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM test", result={"data": "value"})
|
|
|
|
usage = cache.get_memory_usage()
|
|
assert usage > 0
|
|
|
|
|
|
class TestGenerateKey:
|
|
"""Tests for _generate_key method."""
|
|
|
|
def test_generate_key_no_params(self):
|
|
"""Test _generate_key without params."""
|
|
cache = QueryCache()
|
|
key = cache._generate_key("SELECT * FROM test")
|
|
|
|
assert "select * from test" in key
|
|
assert "none" in key
|
|
|
|
def test_generate_key_with_params(self):
|
|
"""Test _generate_key with params."""
|
|
cache = QueryCache()
|
|
key = cache._generate_key("SELECT * FROM test", params={"id": 1})
|
|
|
|
assert "select * from test" in key
|
|
|
|
def test_generate_key_normalizes_query(self):
|
|
"""Test _generate_key normalizes query."""
|
|
cache = QueryCache()
|
|
key1 = cache._generate_key("SELECT * FROM test")
|
|
key2 = cache._generate_key("select * from test")
|
|
|
|
assert key1 == key2
|
|
|
|
def test_generate_key_with_different_params(self):
|
|
"""Test _generate_key with different params produces different keys."""
|
|
cache = QueryCache()
|
|
key1 = cache._generate_key("SELECT * FROM test", params={"id": 1})
|
|
key2 = cache._generate_key("SELECT * FROM test", params={"id": 2})
|
|
|
|
assert key1 != key2
|
|
|
|
|
|
class TestClearByQueryPattern:
|
|
"""Tests for clear_by_query_pattern method."""
|
|
|
|
def test_clear_by_query_pattern(self):
|
|
"""Test clearing by query pattern."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM users", result=[1])
|
|
cache.set_result("SELECT * FROM posts", result=[2])
|
|
|
|
count = cache.clear_by_query_pattern("users")
|
|
|
|
assert count == 1
|
|
|
|
def test_clear_by_query_pattern_case_insensitive(self):
|
|
"""Test clearing by query pattern is case insensitive."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM users", result=[1])
|
|
|
|
count = cache.clear_by_query_pattern("USERS")
|
|
|
|
assert count == 1
|
|
|
|
|
|
class TestGetCachedQueries:
|
|
"""Tests for get_cached_queries method."""
|
|
|
|
def test_get_cached_queries(self):
|
|
"""Test getting cached queries."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM users", result=[1])
|
|
cache.set_result("SELECT * FROM posts", result=[2])
|
|
|
|
queries = cache.get_cached_queries()
|
|
|
|
assert len(queries) == 2
|
|
|
|
def test_get_cached_queries_deduplicates(self):
|
|
"""Test get_cached_queries deduplicates."""
|
|
cache = QueryCache()
|
|
cache.set_result("SELECT * FROM users", params={"id": 1}, result=[1])
|
|
cache.set_result("SELECT * FROM users", params={"id": 2}, result=[2])
|
|
|
|
queries = cache.get_cached_queries()
|
|
|
|
assert len(queries) == 1
|
|
|
|
|
|
class TestCreateQueryCache:
|
|
"""Tests for create_query_cache factory function."""
|
|
|
|
def test_create_query_cache_default(self):
|
|
"""Test create_query_cache with defaults."""
|
|
cache = create_query_cache()
|
|
assert isinstance(cache, QueryCache)
|
|
assert cache.max_size == 1000
|
|
assert cache.ttl_seconds == 3600
|
|
|
|
def test_create_query_cache_custom(self):
|
|
"""Test create_query_cache with custom values."""
|
|
cache = create_query_cache(max_size=500, ttl_seconds=1800)
|
|
assert cache.max_size == 500
|
|
assert cache.ttl_seconds == 1800
|
|
|
|
|
|
class TestQueryCacheError:
|
|
"""Tests for QueryCacheError exception."""
|
|
|
|
def test_query_cache_error_creation(self):
|
|
"""Test QueryCacheError can be created."""
|
|
error = QueryCacheError("Test error")
|
|
assert str(error) == "Test error"
|
|
|
|
def test_query_cache_error_inheritance(self):
|
|
"""Test QueryCacheError inherits from Exception."""
|
|
error = QueryCacheError("Test")
|
|
assert isinstance(error, Exception)
|