Add more tests

Author: Thomas Stromberg

cache_persist_test.go

@@ -439,3 +439,186 @@ func TestCache_SetExplicitTTLOverridesDefault(t *testing.T) {
 		t.Error("key1 should be expired after explicit TTL")
 	}
 }
+
+func TestCache_SetAsync(t *testing.T) {
+	ctx := context.Background()
+	cache, err := New[string, int](ctx)
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer func() {
+		if err := cache.Close(); err != nil {
+			t.Logf("Close error: %v", err)
+		}
+	}()
+
+	// SetAsync should return immediately
+	if err := cache.SetAsync(ctx, "key1", 42, 0); err != nil {
+		t.Fatalf("SetAsync: %v", err)
+	}
+
+	// Value should be immediately available in memory
+	val, found, err := cache.Get(ctx, "key1")
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	if !found {
+		t.Error("key1 should be found after SetAsync")
+	}
+	if val != 42 {
+		t.Errorf("Get value = %d; want 42", val)
+	}
+}
+
+func TestCache_WithOptions(t *testing.T) {
+	ctx := context.Background()
+
+	// Test WithMemorySize
+	cache, err := New[string, int](ctx, WithMemorySize(500))
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	if cache.opts.MemorySize != 500 {
+		t.Errorf("memory size = %d; want 500", cache.opts.MemorySize)
+	}
+	cache.Close()
+
+	// Test WithDefaultTTL
+	cache, err = New[string, int](ctx, WithDefaultTTL(5*time.Minute))
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	if cache.opts.DefaultTTL != 5*time.Minute {
+		t.Errorf("default TTL = %v; want 5m", cache.opts.DefaultTTL)
+	}
+	cache.Close()
+
+	// Test WithWarmup
+	cache, err = New[string, int](ctx, WithWarmup(100))
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	if cache.opts.WarmupLimit != 100 {
+		t.Errorf("warmup limit = %d; want 100", cache.opts.WarmupLimit)
+	}
+	cache.Close()
+
+	// Test WithCleanup
+	cache, err = New[string, int](ctx, WithCleanup(1*time.Hour))
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	if !cache.opts.CleanupEnabled {
+		t.Error("cleanup should be enabled")
+	}
+	if cache.opts.CleanupMaxAge != 1*time.Hour {
+		t.Errorf("cleanup max age = %v; want 1h", cache.opts.CleanupMaxAge)
+	}
+	cache.Close()
+}
+
+func TestCache_DeleteNonExistent(t *testing.T) {
+	ctx := context.Background()
+	cache, err := New[string, int](ctx)
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer cache.Close()
+
+	// Delete non-existent key should not error
+	cache.Delete(ctx, "does-not-exist")
+
+	// Cache should still work
+	if err := cache.Set(ctx, "key1", 42, 0); err != nil {
+		t.Fatalf("Set: %v", err)
+	}
+	val, found, _ := cache.Get(ctx, "key1")
+	if !found || val != 42 {
+		t.Error("cache should still work after deleting non-existent key")
+	}
+}
+
+func TestCache_EvictFromMain(t *testing.T) {
+	ctx := context.Background()
+	// Small cache to force eviction from main queue
+	cache, err := New[int, int](ctx, WithMemorySize(10))
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer cache.Close()
+
+	// Fill small queue and promote items to main by accessing them twice
+	for i := range 15 {
+		cache.Set(ctx, i, i, 0)
+		// Access immediately to promote to main
+		cache.Get(ctx, i)
+	}
+
+	// Add more items to force eviction from main queue
+	for i := 100; i < 110; i++ {
+		cache.Set(ctx, i, i, 0)
+		cache.Get(ctx, i)
+	}
+
+	// Cache should not exceed capacity
+	if cache.Len() > 10 {
+		t.Errorf("cache length = %d; should not exceed 10", cache.Len())
+	}
+}
+
+func TestCache_GetExpired(t *testing.T) {
+	ctx := context.Background()
+	cache, err := New[string, int](ctx)
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer cache.Close()
+
+	// Set with very short TTL
+	if err := cache.Set(ctx, "key1", 42, 1*time.Millisecond); err != nil {
+		t.Fatalf("Set: %v", err)
+	}
+
+	// Wait for expiration
+	time.Sleep(10 * time.Millisecond)
+
+	// Get should return not found
+	_, found, err := cache.Get(ctx, "key1")
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	if found {
+		t.Error("expired key should not be found")
+	}
+}
+
+func TestCache_SetUpdateExisting(t *testing.T) {
+	ctx := context.Background()
+	cache, err := New[string, int](ctx)
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer cache.Close()
+
+	// Set initial value
+	if err := cache.Set(ctx, "key1", 42, 0); err != nil {
+		t.Fatalf("Set: %v", err)
+	}
+
+	// Update value
+	if err := cache.Set(ctx, "key1", 100, 0); err != nil {
+		t.Fatalf("Set update: %v", err)
+	}
+
+	// Should have new value
+	val, found, err := cache.Get(ctx, "key1")
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	if !found {
+		t.Error("key1 should be found")
+	}
+	if val != 100 {
+		t.Errorf("Get value = %d; want 100", val)
+	}
+}