Spaces:
Sleeping
Sleeping
| package cache_test | |
| import ( | |
| "context" | |
| "strings" | |
| "testing" | |
| "time" | |
| "github.com/AmaniQuery/amaniquery/internal/cache" | |
| ) | |
| // TestLRUCache_SetGet verifies basic set/get operations | |
| func TestLRUCache_SetGet(t *testing.T) { | |
| lru := cache.NewLRUCache(100) | |
| // Test set and get | |
| lru.Set("key1", []byte("value1"), time.Hour) | |
| value, found := lru.Get("key1") | |
| if !found { | |
| t.Fatal("Expected to find key1") | |
| } | |
| if string(value) != "value1" { | |
| t.Errorf("Expected 'value1', got '%s'", string(value)) | |
| } | |
| // Test missing key | |
| _, found = lru.Get("nonexistent") | |
| if found { | |
| t.Error("Expected not to find nonexistent key") | |
| } | |
| } | |
| // TestLRUCache_Update verifies updating existing keys | |
| func TestLRUCache_Update(t *testing.T) { | |
| lru := cache.NewLRUCache(100) | |
| lru.Set("key1", []byte("original"), time.Hour) | |
| lru.Set("key1", []byte("updated"), time.Hour) | |
| value, found := lru.Get("key1") | |
| if !found { | |
| t.Fatal("Expected to find key1") | |
| } | |
| if string(value) != "updated" { | |
| t.Errorf("Expected 'updated', got '%s'", string(value)) | |
| } | |
| } | |
| // TestLRUCache_Eviction verifies LRU eviction when over capacity | |
| func TestLRUCache_Eviction(t *testing.T) { | |
| lru := cache.NewLRUCache(3) | |
| // Fill cache to capacity | |
| lru.Set("key1", []byte("value1"), time.Hour) | |
| lru.Set("key2", []byte("value2"), time.Hour) | |
| lru.Set("key3", []byte("value3"), time.Hour) | |
| // Access key1 to make it recently used | |
| lru.Get("key1") | |
| // Add new key, should evict key2 (least recently used) | |
| lru.Set("key4", []byte("value4"), time.Hour) | |
| // key2 should be evicted | |
| _, found := lru.Get("key2") | |
| if found { | |
| t.Error("Expected key2 to be evicted") | |
| } | |
| // key1 should still exist (was accessed recently) | |
| _, found = lru.Get("key1") | |
| if !found { | |
| t.Error("Expected key1 to still exist") | |
| } | |
| // key3 and key4 should exist | |
| _, found = lru.Get("key3") | |
| if !found { | |
| t.Error("Expected key3 to exist") | |
| } | |
| _, found = lru.Get("key4") | |
| if !found { | |
| t.Error("Expected key4 to exist") | |
| } | |
| } | |
| // TestLRUCache_Delete verifies deletion operations | |
| func TestLRUCache_Delete(t *testing.T) { | |
| lru := cache.NewLRUCache(100) | |
| lru.Set("key1", []byte("value1"), time.Hour) | |
| lru.Set("key2", []byte("value2"), time.Hour) | |
| lru.Delete("key1") | |
| _, found := lru.Get("key1") | |
| if found { | |
| t.Error("Expected key1 to be deleted") | |
| } | |
| // key2 should still exist | |
| _, found = lru.Get("key2") | |
| if !found { | |
| t.Error("Expected key2 to still exist") | |
| } | |
| } | |
| // TestLRUCache_DeleteNonexistent verifies deleting nonexistent keys doesn't panic | |
| func TestLRUCache_DeleteNonexistent(t *testing.T) { | |
| lru := cache.NewLRUCache(100) | |
| // Should not panic | |
| lru.Delete("nonexistent") | |
| } | |
| // TestCacheMissError tests the error type | |
| func TestCacheMissError(t *testing.T) { | |
| err := cache.ErrCacheMiss | |
| if err.Error() != "cache miss" { | |
| t.Errorf("Expected 'cache miss', got '%s'", err.Error()) | |
| } | |
| } | |
| // TestMultiTierCache_LocalOnly tests cache without Redis connection | |
| func TestMultiTierCache_LocalOnly(t *testing.T) { | |
| // Create cache with invalid Redis URL to ensure Redis is not used | |
| cfg := cache.Config{ | |
| RedisURL: "redis://invalid:6379", // Will fail connection | |
| LocalSize: 100, | |
| TTL: time.Hour, | |
| MaxRetries: 1, | |
| PoolSize: 1, | |
| } | |
| c, err := cache.New(cfg) | |
| if err != nil { | |
| t.Fatalf("Failed to create cache: %v", err) | |
| } | |
| defer c.Close() | |
| ctx := context.Background() | |
| // Set and get should work with local cache | |
| err = c.Set(ctx, "key1", []byte("value1"), 0) | |
| if err != nil { | |
| t.Fatalf("Set failed: %v", err) | |
| } | |
| value, err := c.Get(ctx, "key1") | |
| if err != nil { | |
| t.Fatalf("Get failed: %v", err) | |
| } | |
| if string(value) != "value1" { | |
| t.Errorf("Expected 'value1', got '%s'", string(value)) | |
| } | |
| } | |
| // TestMultiTierCache_CacheMiss tests cache miss behavior | |
| func TestMultiTierCache_CacheMiss(t *testing.T) { | |
| cfg := cache.Config{ | |
| RedisURL: "redis://invalid:6379", | |
| LocalSize: 100, | |
| TTL: time.Hour, | |
| MaxRetries: 1, | |
| PoolSize: 1, | |
| } | |
| c, err := cache.New(cfg) | |
| if err != nil { | |
| t.Fatalf("Failed to create cache: %v", err) | |
| } | |
| defer c.Close() | |
| ctx := context.Background() | |
| _, err = c.Get(ctx, "nonexistent") | |
| if err == nil { | |
| t.Error("Expected cache miss error") | |
| } | |
| } | |
| // TestMultiTierCache_Delete tests deletion | |
| func TestMultiTierCache_Delete(t *testing.T) { | |
| cfg := cache.Config{ | |
| RedisURL: "redis://invalid:6379", | |
| LocalSize: 100, | |
| TTL: time.Hour, | |
| MaxRetries: 1, | |
| PoolSize: 1, | |
| } | |
| c, err := cache.New(cfg) | |
| if err != nil { | |
| t.Fatalf("Failed to create cache: %v", err) | |
| } | |
| defer c.Close() | |
| ctx := context.Background() | |
| // Set then delete | |
| _ = c.Set(ctx, "key1", []byte("value1"), 0) | |
| err = c.Delete(ctx, "key1") | |
| if err != nil { | |
| t.Fatalf("Delete failed: %v", err) | |
| } | |
| // Should be gone | |
| _, err = c.Get(ctx, "key1") | |
| if err == nil { | |
| t.Error("Expected cache miss after delete") | |
| } | |
| } | |
| // TestMultiTierCache_JSON tests JSON operations | |
| func TestMultiTierCache_JSON(t *testing.T) { | |
| cfg := cache.Config{ | |
| RedisURL: "redis://invalid:6379", | |
| LocalSize: 100, | |
| TTL: time.Hour, | |
| MaxRetries: 1, | |
| PoolSize: 1, | |
| } | |
| c, err := cache.New(cfg) | |
| if err != nil { | |
| t.Fatalf("Failed to create cache: %v", err) | |
| } | |
| defer c.Close() | |
| ctx := context.Background() | |
| type testData struct { | |
| Name string `json:"name"` | |
| Value int `json:"value"` | |
| } | |
| original := testData{Name: "test", Value: 42} | |
| err = c.SetJSON(ctx, "json-key", original, 0) | |
| if err != nil { | |
| t.Fatalf("SetJSON failed: %v", err) | |
| } | |
| var result testData | |
| err = c.GetJSON(ctx, "json-key", &result) | |
| if err != nil { | |
| t.Fatalf("GetJSON failed: %v", err) | |
| } | |
| if result.Name != original.Name || result.Value != original.Value { | |
| t.Errorf("JSON mismatch: expected %+v, got %+v", original, result) | |
| } | |
| } | |
| // TestMultiTierCache_Metrics tests metrics tracking | |
| func TestMultiTierCache_Metrics(t *testing.T) { | |
| cfg := cache.Config{ | |
| RedisURL: "redis://invalid:6379", | |
| LocalSize: 100, | |
| TTL: time.Hour, | |
| MaxRetries: 1, | |
| PoolSize: 1, | |
| } | |
| c, err := cache.New(cfg) | |
| if err != nil { | |
| t.Fatalf("Failed to create cache: %v", err) | |
| } | |
| defer c.Close() | |
| ctx := context.Background() | |
| // Set and get to generate metrics | |
| _ = c.Set(ctx, "key1", []byte("value1"), 0) | |
| _, _ = c.Get(ctx, "key1") // Hit | |
| _, _ = c.Get(ctx, "key2") // Miss | |
| metrics := c.GetMetrics() | |
| if metrics.LocalHits != 1 { | |
| t.Errorf("Expected 1 local hit, got %d", metrics.LocalHits) | |
| } | |
| if metrics.LocalMisses != 1 { | |
| t.Errorf("Expected 1 local miss, got %d", metrics.LocalMisses) | |
| } | |
| } | |
| // TestLRUCache_TTLExpiry verifies entries are not served past their TTL | |
| // (regression guard for stale L1 data outliving the Redis expiry). | |
| func TestLRUCache_TTLExpiry(t *testing.T) { | |
| lru := cache.NewLRUCache(10) | |
| lru.Set("key1", []byte("value1"), 50*time.Millisecond) | |
| lru.Set("key2", []byte("value2"), time.Hour) | |
| // Immediately readable | |
| if _, found := lru.Get("key1"); !found { | |
| t.Fatal("Expected key1 to be present before expiry") | |
| } | |
| time.Sleep(60 * time.Millisecond) | |
| if _, found := lru.Get("key1"); found { | |
| t.Error("Expected key1 to have expired") | |
| } | |
| if _, found := lru.Get("key2"); !found { | |
| t.Error("Expected key2 (long TTL) to still be present") | |
| } | |
| } | |
| // TestLRUCache_DeletePrefix verifies prefix-based eviction removes only the | |
| // matching keys (regression guard for pattern/prefix invalidation). | |
| func TestLRUCache_DeletePrefix(t *testing.T) { | |
| lru := cache.NewLRUCache(10) | |
| lru.Set("L1:nbo:rag:a", []byte("1"), time.Hour) | |
| lru.Set("L1:nbo:rag:b", []byte("2"), time.Hour) | |
| lru.Set("L1:nbo:legal:c", []byte("3"), time.Hour) | |
| lru.DeletePrefix("L1:nbo:rag:") | |
| if _, found := lru.Get("L1:nbo:rag:a"); found { | |
| t.Error("Expected rag:a to be deleted") | |
| } | |
| if _, found := lru.Get("L1:nbo:rag:b"); found { | |
| t.Error("Expected rag:b to be deleted") | |
| } | |
| if _, found := lru.Get("L1:nbo:legal:c"); !found { | |
| t.Error("Expected non-matching key to survive") | |
| } | |
| } | |
| // TestMultiTierCache_DeleteByPrefixPattern verifies prefix invalidation matches | |
| // readable NormalizeKey keys (regression guard: hashed keys could never be | |
| // matched by prefix patterns, silently no-op'ing admin invalidations). | |
| func TestMultiTierCache_DeleteByPrefixPattern(t *testing.T) { | |
| cfg := cache.Config{ | |
| RedisURL: "redis://invalid:6379", | |
| LocalSize: 100, | |
| TTL: time.Hour, | |
| MaxRetries: 1, | |
| PoolSize: 1, | |
| KeyPrefix: "L1:nbo:", | |
| } | |
| c, err := cache.New(cfg) | |
| if err != nil { | |
| t.Fatalf("Failed to create cache: %v", err) | |
| } | |
| defer c.Close() | |
| ctx := context.Background() | |
| ragKey := c.NormalizeKey("rag", "who owns the land registry") | |
| legalKey := c.NormalizeKey("legal", "statute of limitations kenya") | |
| if !strings.HasPrefix(ragKey, "L1:nbo:rag:") { | |
| t.Fatalf("expected readable key prefix, got %q", ragKey) | |
| } | |
| if err := c.Set(ctx, ragKey, []byte("rag-answer"), time.Hour); err != nil { | |
| t.Fatalf("Set failed: %v", err) | |
| } | |
| if err := c.Set(ctx, legalKey, []byte("legal-answer"), time.Hour); err != nil { | |
| t.Fatalf("Set failed: %v", err) | |
| } | |
| if err := c.DeleteByPrefix(ctx, "rag:"); err != nil { | |
| t.Fatalf("DeleteByPrefix failed: %v", err) | |
| } | |
| if _, err := c.Get(ctx, ragKey); err == nil { | |
| t.Error("Expected rag key to be invalidated by prefix") | |
| } | |
| if _, err := c.Get(ctx, legalKey); err != nil { | |
| t.Error("Expected legal key to survive prefix invalidation") | |
| } | |
| } | |
| // BenchmarkLRUCache_Set benchmarks LRU set operations | |
| func BenchmarkLRUCache_Set(b *testing.B) { | |
| lru := cache.NewLRUCache(10000) | |
| b.ResetTimer() | |
| for i := 0; i < b.N; i++ { | |
| lru.Set("key"+string(rune(i%1000)), []byte("value"), time.Hour) | |
| } | |
| } | |
| // BenchmarkLRUCache_Get benchmarks LRU get operations | |
| func BenchmarkLRUCache_Get(b *testing.B) { | |
| lru := cache.NewLRUCache(10000) | |
| // Pre-populate | |
| for i := 0; i < 1000; i++ { | |
| lru.Set("key"+string(rune(i)), []byte("value"), time.Hour) | |
| } | |
| b.ResetTimer() | |
| for i := 0; i < b.N; i++ { | |
| lru.Get("key" + string(rune(i%1000))) | |
| } | |
| } | |