cache_utils_test.go

package loadingcache_test

import (
	"context"
	"fmt"
	"hash/fnv"
	"testing"

	"github.com/benbjohnson/clock"
	"github.com/pkg/errors"
	"go.uber.org/goleak"

	"github.com/devzero-inc/loadingcache"
)

type testRemovalListener[K comparable, V any] struct {
	lastRemovalNotification loadingcache.RemovalNotification[K, V]
}

func (t *testRemovalListener[K, V]) Listener(notification loadingcache.RemovalNotification[K, V]) {
	t.lastRemovalNotification = notification
}

// testLoadFunc provides a configurable loading function that may fail
type testLoadFunc[K comparable, V ~string] struct {
	fail bool
}

func (t *testLoadFunc[K, V]) LoadFunc(_ context.Context, key K) (V, error) {
	var Nil V
	if t.fail {
		return Nil, errors.New("failing on request")
	}
	return V(fmt.Sprint(key)), nil
}

// stringHashCodeFunc is a test hash code function for strings which uses fnv.New32a
func stringHashCodeFunc[Key ~string]() func(k Key) uint64 {
	return func(k Key) uint64 {
		h := fnv.New32a()
		if _, err := h.Write([]byte(string(k))); err != nil {
			panic(err)
		}
		return uint64(h.Sum32())
	}
}

// uintHashCodeFunc is a test hash code function for ints which just passes them through
func uintHashCodeFunc[Key ~int]() func(k Key) uint64 {
	return func(k Key) uint64 {
		return uint64(k)
	}
}

func matrixBenchmark[K ~int, V any](b *testing.B,
	options []loadingcache.CacheOption[K, V],
	setupFunc matrixBenchmarkSetupFunc[K, V],
	testFunc matrixBenchmarkFunc[K, V],
) {
	matrixOptions := cacheMatrixOptions(options)
	b.ResetTimer()
	for name := range matrixOptions {
		cache := loadingcache.New(matrixOptions[name]...)
		setupFunc(b, cache)
		b.Run(name, func(b *testing.B) {
			b.ResetTimer()
			testFunc(b, cache)
		})
	}
}

type matrixBenchmarkSetupFunc[K comparable, V any] func(b *testing.B, cache loadingcache.Cache[K, V])

type matrixBenchmarkFunc[K comparable, V any] func(b *testing.B, cache loadingcache.Cache[K, V])

func noopBenchmarkSetupFunc[K comparable, V any]() matrixBenchmarkSetupFunc[K, V] {
	return func(b *testing.B, cache loadingcache.Cache[K, V]) {}
}

func matrixTest[K ~int, V any](t *testing.T, options matrixTestOptions[K, V], testFunc matrixTestFunc[K, V]) {
	defer goleak.VerifyNone(t)
	matrixOptions := cacheMatrixOptions(options.cacheOptions)
	for name := range matrixOptions {
		utils := &matrixTestUtils{}
		cacheOptions := matrixOptions[name]
		mockClock := clock.NewMock()
		utils.clock = mockClock
		// Place our clock first, allowing the user to override if necessary
		cacheOptions = append([]loadingcache.CacheOption[K, V]{
			loadingcache.WithClock[K, V](mockClock),
		}, cacheOptions...)
		ctx := put(context.Background(), utils)
		cache := loadingcache.New(cacheOptions...)
		if options.setupFunc != nil {
			options.setupFunc(t, cache)
		}
		t.Run(name, func(t *testing.T) {
			defer cache.Close()
			testFunc(t, ctx, cache)
		})
	}
}

type matrixTestOptions[K comparable, V any] struct {
	cacheOptions []loadingcache.CacheOption[K, V]
	setupFunc    func(t *testing.T, cache loadingcache.Cache[K, V])
}

type matrixTestUtils struct {
	clock *clock.Mock
}

type utilsKey struct{}

func put(ctx context.Context, utils *matrixTestUtils) context.Context {
	return context.WithValue(ctx, utilsKey{}, utils)
}

func get(ctx context.Context) *matrixTestUtils {
	val := ctx.Value(utilsKey{})
	if val == nil {
		panic("could not find utils in context")
	}
	return val.(*matrixTestUtils)
}

type matrixTestFunc[K comparable, V any] func(t *testing.T, ctx context.Context, cache loadingcache.Cache[K, V])

func cacheMatrixOptions[K ~int, V any](baseOptions []loadingcache.CacheOption[K, V]) map[string][]loadingcache.CacheOption[K, V] {
	matrix := map[string][]loadingcache.CacheOption[K, V]{}

	var simpleOptions []loadingcache.CacheOption[K, V]
	simpleOptions = append(simpleOptions, baseOptions...)
	simpleOptions = append(simpleOptions, loadingcache.WithShardCount[K, V](1))
	matrix["Simple"] = simpleOptions

	for _, shardCount := range []int{2, 3, 16, 32} {
		var shardedOptions []loadingcache.CacheOption[K, V]
		shardedOptions = append(shardedOptions, baseOptions...)
		shardedOptions = append(shardedOptions,
			loadingcache.WithShardCount[K, V](shardCount),
			loadingcache.WithHashCodeFunc[K, V](uintHashCodeFunc[K]()),
		)
		matrix[fmt.Sprintf("Sharded (%d)", shardCount)] = shardedOptions
	}
	return matrix
}