projax/internal/cache/ttl_test.go

package cache

import (
	"strconv"
	"sync"
	"testing"
	"time"
)

func TestGetEmpty(t *testing.T) {
	c := NewTTL[int](50 * time.Millisecond)
	if v, ok := c.Get("nope"); ok || v != 0 {
		t.Fatalf("empty Get: got (%v, %v), want (0, false)", v, ok)
	}
}

func TestSetGet(t *testing.T) {
	c := NewTTL[string](50 * time.Millisecond)
	c.Set("k", "v")
	got, ok := c.Get("k")
	if !ok || got != "v" {
		t.Fatalf("got (%q, %v), want (v, true)", got, ok)
	}
}

func TestGetAfterTTL(t *testing.T) {
	c := NewTTL[string](20 * time.Millisecond)
	c.Set("k", "v")
	time.Sleep(50 * time.Millisecond)
	if _, ok := c.Get("k"); ok {
		t.Fatalf("expected miss after TTL")
	}
	// Internal: the expired entry must be removed.
	c.mu.RLock()
	_, present := c.rows["k"]
	c.mu.RUnlock()
	if present {
		t.Fatalf("expired entry was not removed on miss")
	}
}

func TestSetOverwrites(t *testing.T) {
	c := NewTTL[int](1 * time.Second)
	c.Set("k", 1)
	c.Set("k", 2)
	got, ok := c.Get("k")
	if !ok || got != 2 {
		t.Fatalf("got (%d, %v), want (2, true)", got, ok)
	}
}

func TestInvalidateOnlyTargetsKey(t *testing.T) {
	c := NewTTL[int](1 * time.Second)
	c.Set("a", 1)
	c.Set("b", 2)
	c.Invalidate("a")
	if _, ok := c.Get("a"); ok {
		t.Fatalf("a should be gone")
	}
	if v, ok := c.Get("b"); !ok || v != 2 {
		t.Fatalf("b should survive Invalidate of a; got (%d, %v)", v, ok)
	}
}

func TestInvalidateAll(t *testing.T) {
	c := NewTTL[int](1 * time.Second)
	c.Set("a", 1)
	c.Set("b", 2)
	c.InvalidateAll()
	if _, ok := c.Get("a"); ok {
		t.Fatalf("a should be gone")
	}
	if _, ok := c.Get("b"); ok {
		t.Fatalf("b should be gone")
	}
}

func TestNilReceiverSafe(t *testing.T) {
	var c *TTLCache[string]
	if v, ok := c.Get("k"); ok || v != "" {
		t.Errorf("nil Get should miss, got (%q, %v)", v, ok)
	}
	c.Set("k", "v") // must not panic
	c.Invalidate("k")
	c.InvalidateAll()
}

func TestPointerPayload(t *testing.T) {
	type payload struct{ N int }
	c := NewTTL[*payload](1 * time.Second)
	if v, ok := c.Get("k"); ok || v != nil {
		t.Fatalf("pointer miss should yield (nil, false), got (%v, %v)", v, ok)
	}
	c.Set("k", &payload{N: 42})
	v, ok := c.Get("k")
	if !ok || v == nil || v.N != 42 {
		t.Fatalf("got (%+v, %v), want non-nil N=42", v, ok)
	}
}

// TestRaceCleanConcurrentAccess runs many goroutines Setting / Getting /
// Invalidating overlapping keys. Run with `go test -race ./internal/cache/`
// to catch any unprotected writes — the test body itself only checks
// non-panic + final-count sanity.
func TestRaceCleanConcurrentAccess(t *testing.T) {
	c := NewTTL[int](250 * time.Millisecond)
	const workers = 8
	const ops = 200
	var wg sync.WaitGroup
	for w := 0; w < workers; w++ {
		wg.Add(1)
		go func(seed int) {
			defer wg.Done()
			for i := 0; i < ops; i++ {
				key := "k" + strconv.Itoa((seed*ops+i)%5)
				switch i % 4 {
				case 0:
					c.Set(key, i)
				case 1:
					_, _ = c.Get(key)
				case 2:
					c.Invalidate(key)
				case 3:
					if i%50 == 0 {
						c.InvalidateAll()
					} else {
						_, _ = c.Get(key)
					}
				}
			}
		}(w)
	}
	wg.Wait()
}