stats_test.go

package loadingcache_test

import (
	"context"
	"testing"
	"time"

	"github.com/benbjohnson/clock"
	"github.com/stretchr/testify/require"

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

func TestStatsHitAndMiss(t *testing.T) {
	type K int
	type V string
	matrixTest(t, matrixTestOptions[K, V]{}, func(t *testing.T, _ context.Context, cache loadingcache.Cache[K, V]) {
		_, err := cache.Get(context.TODO(), 1)
		require.Error(t, err)
		require.Equal(t, int64(1), cache.Stats().MissCount())

		cache.Put(1, "a")
		_, err = cache.Get(context.TODO(), 1)
		require.NoError(t, err)
		require.Equal(t, int64(1), cache.Stats().HitCount())

		require.Equal(t, float64(0.5), cache.Stats().HitRate())
		require.Equal(t, float64(0.5), cache.Stats().MissRate())
		require.Equal(t, int64(2), cache.Stats().RequestCount())
	})
}

func TestLoadTimes(t *testing.T) {
	type K int
	type V int

	mockClock := clock.NewMock()
	loadTime := 100 * time.Millisecond
	matrixTest(t, matrixTestOptions[K, V]{
		cacheOptions: []loadingcache.CacheOption[K, V]{
			loadingcache.WithClock[K, V](mockClock),
			loadingcache.WithLoadFunc(func(_ context.Context, key K) (V, error) {
				// Simulating that the loading takes 100ms
				mockClock.Add(loadTime)
				return V(key), nil
			}),
		},
	},
		func(t *testing.T, ctx context.Context, cache loadingcache.Cache[K, V]) {
			for i := 1; i <= 10; i++ {
				_, err := cache.Get(context.TODO(), K(i))
				require.NoError(t, err)
				require.Equal(t, time.Duration(i)*loadTime, cache.Stats().LoadTotalTime())
			}
			// Since there were no misses, the average load time should match the individual load time
			require.Equal(t, loadTime, cache.Stats().AverageLoadPenalty())
		})
}

func TestLoadSuccessAndError(t *testing.T) {
	type K int
	type V string

	loadFunc := &testLoadFunc[K, V]{}
	matrixTest(t, matrixTestOptions[K, V]{
		cacheOptions: []loadingcache.CacheOption[K, V]{
			loadingcache.WithLoadFunc(loadFunc.LoadFunc),
		},
	},
		func(t *testing.T, _ context.Context, cache loadingcache.Cache[K, V]) {
			// Clean up after ourselves
			defer func() {
				loadFunc.fail = false
			}()

			// Doing 10 successful loads
			i := 0
			for ; i < 10; i++ {
				_, err := cache.Get(context.TODO(), K(i))
				require.NoError(t, err)
			}
			// Doing 6 error loads
			loadFunc.fail = true
			for ; i < 16; i++ {
				_, err := cache.Get(context.TODO(), K(i))
				require.Error(t, err)
			}

			require.Equal(t, int64(10), cache.Stats().LoadSuccessCount())
			require.Equal(t, int64(6), cache.Stats().LoadErrorCount())
			require.Equal(t, float64(0.375), cache.Stats().LoadErrorRate())
		})
}