Github/temporal
1
0
Fork 0
mirror of https://github.com/temporalio/temporal.git synced 2026-08-30 18:41:49 -07:00
Code Issues Packages Projects Releases Wiki Activity

Clean up LRU cache test assertions (#11785)

Browse Source 
Address hundreds of linter issues.
This commit is contained in:
Stephan Behnke
2026-08-25 14:38:16 -07:00
committed by GitHub
parent ee5b0d8c1a
commit cc4199dd0c
2 changed files with 228 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

413
common/cache/lru_test.go vendored
View File

@@ -7,12 +7,12 @@ import (
"time"
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.temporal.io/server/common/clock"
"go.temporal.io/server/common/dynamicconfig"
"go.temporal.io/server/common/metrics"
"go.temporal.io/server/common/metrics/metricstest"
"go.temporal.io/server/common/testing/await"
)
type (
@@ -37,52 +37,52 @@ func TestLRU(t *testing.T) {
cache := NewWithMetrics(4, nil, metricsHandler)
cache.Put("A", "Foo")
assert.Equal(t, "Foo", cache.Get("A"))
assert.Nil(t, cache.Get("B"))
assert.Equal(t, 1, cache.Size())
require.Equal(t, "Foo", cache.Get("A"))
require.Nil(t, cache.Get("B"))
require.Equal(t, 1, cache.Size())
snapshot := capture.Snapshot()
assert.Equal(t, float64(4), snapshot[metrics.CacheSize.Name()][0].Value)
assert.Equal(t, float64(1), snapshot[metrics.CacheUsage.Name()][0].Value)
require.InDelta(t, float64(4), snapshot[metrics.CacheSize.Name()][0].Value, 0)
require.InDelta(t, float64(1), snapshot[metrics.CacheUsage.Name()][0].Value, 0)
capture = metricsHandler.StartCapture()
cache.Put("B", "Bar")
cache.Put("C", "Cid")
cache.Put("D", "Delt")
assert.Equal(t, 4, cache.Size())
require.Equal(t, 4, cache.Size())
snapshot = capture.Snapshot()
assert.Equal(t, float64(4), snapshot[metrics.CacheUsage.Name()][2].Value)
require.InDelta(t, float64(4), snapshot[metrics.CacheUsage.Name()][2].Value, 0)
assert.Equal(t, "Bar", cache.Get("B"))
assert.Equal(t, "Cid", cache.Get("C"))
assert.Equal(t, "Delt", cache.Get("D"))
require.Equal(t, "Bar", cache.Get("B"))
require.Equal(t, "Cid", cache.Get("C"))
require.Equal(t, "Delt", cache.Get("D"))
cache.Put("A", "Foo2")
assert.Equal(t, "Foo2", cache.Get("A"))
assert.Equal(t, 4, cache.Size())
require.Equal(t, "Foo2", cache.Get("A"))
require.Equal(t, 4, cache.Size())
capture = metricsHandler.StartCapture()
cache.Put("E", "Epsi")
assert.Equal(t, "Epsi", cache.Get("E"))
assert.Equal(t, "Foo2", cache.Get("A"))
assert.Nil(t, cache.Get("B")) // Oldest, should be evicted
assert.Equal(t, 4, cache.Size())
require.Equal(t, "Epsi", cache.Get("E"))
require.Equal(t, "Foo2", cache.Get("A"))
require.Nil(t, cache.Get("B")) // Oldest, should be evicted
require.Equal(t, 4, cache.Size())
snapshot = capture.Snapshot()
assert.Equal(t, 2, len(snapshot[metrics.CacheUsage.Name()]))
assert.Equal(t, float64(4), snapshot[metrics.CacheUsage.Name()][1].Value)
require.Len(t, snapshot[metrics.CacheUsage.Name()], 2)
require.InDelta(t, float64(4), snapshot[metrics.CacheUsage.Name()][1].Value, 0)
// Access C, D is now LRU
cache.Get("C")
cache.Put("F", "Felp")
assert.Nil(t, cache.Get("D"))
assert.Equal(t, 4, cache.Size())
require.Nil(t, cache.Get("D"))
require.Equal(t, 4, cache.Size())
capture = metricsHandler.StartCapture()
cache.Delete("A")
assert.Nil(t, cache.Get("A"))
assert.Equal(t, 3, cache.Size())
require.Nil(t, cache.Get("A"))
require.Equal(t, 3, cache.Size())
snapshot = capture.Snapshot()
assert.Equal(t, 1, len(snapshot[metrics.CacheUsage.Name()]))
assert.Equal(t, float64(3), snapshot[metrics.CacheUsage.Name()][0].Value)
require.Len(t, snapshot[metrics.CacheUsage.Name()], 1)
require.InDelta(t, float64(3), snapshot[metrics.CacheUsage.Name()][0].Value, 0)
}
func TestGenerics(t *testing.T) {
@@ -97,20 +97,20 @@ func TestGenerics(t *testing.T) {
cache := NewLRU(5, metrics.NoopMetricsHandler)
cache.Put(key, value)
assert.Equal(t, value, cache.Get(key))
assert.Equal(t, value, cache.Get(keyType{
require.Equal(t, value, cache.Get(key))
require.Equal(t, value, cache.Get(keyType{
dummyString: "some random key",
dummyInt: 59,
}))
assert.Nil(t, cache.Get(keyType{
require.Nil(t, cache.Get(keyType{
dummyString: "some other random key",
dummyInt: 56,
}))
assert.Equal(t, 1, cache.Size())
require.Equal(t, 1, cache.Size())
cache.Put(key, "some other random value")
assert.Equal(t, "some other random value", cache.Get(key))
assert.Equal(t, 1, cache.Size())
require.Equal(t, "some other random value", cache.Get(key))
require.Equal(t, 1, cache.Size())
}
func TestLRUWithTTL(t *testing.T) {
@@ -127,20 +127,20 @@ func TestLRUWithTTL(t *testing.T) {
metricsHandler,
)
cache.Put("A", "foo")
assert.Equal(t, "foo", cache.Get("A"))
require.Equal(t, "foo", cache.Get("A"))
snapshot := capture.Snapshot()
assert.Equal(t, float64(5), snapshot[metrics.CacheSize.Name()][0].Value)
assert.Equal(t, float64(1), snapshot[metrics.CacheUsage.Name()][0].Value)
assert.Equal(t, time.Millisecond*100, snapshot[metrics.CacheTtl.Name()][0].Value)
assert.Equal(t, time.Duration(0), snapshot[metrics.CacheEntryAgeOnGet.Name()][0].Value)
require.InDelta(t, float64(5), snapshot[metrics.CacheSize.Name()][0].Value, 0)
require.InDelta(t, float64(1), snapshot[metrics.CacheUsage.Name()][0].Value, 0)
require.Equal(t, time.Millisecond*100, snapshot[metrics.CacheTtl.Name()][0].Value)
require.Equal(t, time.Duration(0), snapshot[metrics.CacheEntryAgeOnGet.Name()][0].Value)
timeSource.Advance(time.Millisecond * 300)
assert.Nil(t, cache.Get("A"))
require.Nil(t, cache.Get("A"))
snapshot = capture.Snapshot()
assert.Equal(t, 2, len(snapshot[metrics.CacheUsage.Name()]))
assert.Equal(t, float64(0), snapshot[metrics.CacheUsage.Name()][1].Value)
assert.Equal(t, 0, cache.Size())
assert.Equal(t, 1, len(snapshot[metrics.CacheEntryAgeOnGet.Name()]))
assert.Equal(t, time.Millisecond*300, snapshot[metrics.CacheEntryAgeOnEviction.Name()][0].Value)
require.Len(t, snapshot[metrics.CacheUsage.Name()], 2)
require.InDelta(t, float64(0), snapshot[metrics.CacheUsage.Name()][1].Value, 0)
require.Equal(t, 0, cache.Size())
require.Len(t, snapshot[metrics.CacheEntryAgeOnGet.Name()], 1)
require.Equal(t, time.Millisecond*300, snapshot[metrics.CacheEntryAgeOnEviction.Name()][0].Value)
}
func TestLRUCacheConcurrentAccess(t *testing.T) {
@@ -162,24 +162,18 @@ func TestLRUCacheConcurrentAccess(t *testing.T) {
start := make(chan struct{})
var wg sync.WaitGroup
for range 20 {
wg.Add(2)
// concurrent get and put
go func() {
defer wg.Done()
wg.Go(func() {
<-start
for range 1000 {
cache.Get("A")
cache.Put("A", "fooo")
}
}()
})
// concurrent iteration
go func() {
defer wg.Done()
wg.Go(func() {
<-start
for range 50 {
@@ -189,7 +183,7 @@ func TestLRUCacheConcurrentAccess(t *testing.T) {
}
it.Close()
}
}()
})
}
close(start)
@@ -208,9 +202,9 @@ func TestTTL(t *testing.T) {
)
cache.Put("A", t)
assert.Equal(t, t, cache.Get("A"))
require.Equal(t, t, cache.Get("A"))
timeSource.Advance(time.Millisecond * 100)
assert.Nil(t, cache.Get("A"))
require.Nil(t, cache.Get("A"))
}
func TestTTLWithPin(t *testing.T) {
@@ -229,27 +223,27 @@ func TestTTLWithPin(t *testing.T) {
capture := metricsHandler.StartCapture()
_, err := cache.PutIfNotExist("A", t)
assert.NoError(t, err)
assert.Equal(t, t, cache.Get("A"))
assert.Equal(t, 1, cache.Size())
require.NoError(t, err)
require.Equal(t, t, cache.Get("A"))
require.Equal(t, 1, cache.Size())
snapshot := capture.Snapshot()
assert.Equal(t, float64(1), snapshot[metrics.CacheUsage.Name()][0].Value)
assert.Equal(t, float64(1), snapshot[metrics.CachePinnedUsage.Name()][0].Value)
require.InDelta(t, float64(1), snapshot[metrics.CacheUsage.Name()][0].Value, 0)
require.InDelta(t, float64(1), snapshot[metrics.CachePinnedUsage.Name()][0].Value, 0)
capture = metricsHandler.StartCapture()
timeSource.Advance(time.Millisecond * 100)
assert.Equal(t, t, cache.Get("A"))
assert.Equal(t, 1, cache.Size())
require.Equal(t, t, cache.Get("A"))
require.Equal(t, 1, cache.Size())
// release 3 time since put if not exist also increase the counter
cache.Release("A")
cache.Release("A")
cache.Release("A")
snapshot = capture.Snapshot()
assert.Equal(t, float64(0), snapshot[metrics.CachePinnedUsage.Name()][0].Value)
assert.Nil(t, cache.Get("A"))
assert.Equal(t, 0, cache.Size())
require.InDelta(t, float64(0), snapshot[metrics.CachePinnedUsage.Name()][0].Value, 0)
require.Nil(t, cache.Get("A"))
require.Equal(t, 0, cache.Size())
snapshot = capture.Snapshot()
// cache.Release() will emit cacheUsage 3 times. cache.Get() will emit cacheUsage once.
assert.Equal(t, float64(0), snapshot[metrics.CacheUsage.Name()][3].Value)
require.InDelta(t, float64(0), snapshot[metrics.CacheUsage.Name()][3].Value, 0)
}
func TestMaxSizeWithPin_MidItem(t *testing.T) {
@@ -265,39 +259,39 @@ func TestMaxSizeWithPin_MidItem(t *testing.T) {
)
_, err := cache.PutIfNotExist("A", t)
assert.NoError(t, err)
assert.Equal(t, 1, cache.Size())
require.NoError(t, err)
require.Equal(t, 1, cache.Size())
_, err = cache.PutIfNotExist("B", t)
assert.NoError(t, err)
assert.Equal(t, 2, cache.Size())
require.NoError(t, err)
require.Equal(t, 2, cache.Size())
_, err = cache.PutIfNotExist("C", t)
assert.Error(t, err)
assert.Equal(t, 2, cache.Size())
require.Error(t, err)
require.Equal(t, 2, cache.Size())
assert.Equal(t, t, cache.Get("A"))
require.Equal(t, t, cache.Get("A"))
cache.Release("A") // get will also increase the ref count
assert.Equal(t, t, cache.Get("B"))
require.Equal(t, t, cache.Get("B"))
cache.Release("B") // get will also increase the ref count
assert.Equal(t, 2, cache.Size())
require.Equal(t, 2, cache.Size())
cache.Release("B") // B's ref count is 0
_, err = cache.PutIfNotExist("C", t)
assert.NoError(t, err)
assert.Equal(t, t, cache.Get("C"))
require.NoError(t, err)
require.Equal(t, t, cache.Get("C"))
cache.Release("C") // get will also increase the ref count
assert.Equal(t, 2, cache.Size())
require.Equal(t, 2, cache.Size())
cache.Release("A") // A's ref count is 0
cache.Release("C") // C's ref count is 0
assert.Equal(t, 2, cache.Size())
require.Equal(t, 2, cache.Size())
timeSource.Advance(time.Millisecond * 100)
assert.Nil(t, cache.Get("A"))
assert.Nil(t, cache.Get("B"))
assert.Nil(t, cache.Get("C"))
assert.Equal(t, 0, cache.Size())
require.Nil(t, cache.Get("A"))
require.Nil(t, cache.Get("B"))
require.Nil(t, cache.Get("C"))
require.Equal(t, 0, cache.Size())
}
func TestMaxSizeWithPin_LastItem(t *testing.T) {
@@ -313,39 +307,39 @@ func TestMaxSizeWithPin_LastItem(t *testing.T) {
)
_, err := cache.PutIfNotExist("A", t)
assert.NoError(t, err)
assert.Equal(t, 1, cache.Size())
require.NoError(t, err)
require.Equal(t, 1, cache.Size())
_, err = cache.PutIfNotExist("B", t)
assert.NoError(t, err)
assert.Equal(t, 2, cache.Size())
require.NoError(t, err)
require.Equal(t, 2, cache.Size())
_, err = cache.PutIfNotExist("C", t)
assert.Error(t, err)
assert.Equal(t, 2, cache.Size())
require.Error(t, err)
require.Equal(t, 2, cache.Size())
assert.Equal(t, t, cache.Get("A"))
require.Equal(t, t, cache.Get("A"))
cache.Release("A") // get will also increase the ref count
assert.Equal(t, t, cache.Get("B"))
require.Equal(t, t, cache.Get("B"))
cache.Release("B") // get will also increase the ref count
assert.Equal(t, 2, cache.Size())
require.Equal(t, 2, cache.Size())
cache.Release("A") // A's ref count is 0
_, err = cache.PutIfNotExist("C", t)
assert.NoError(t, err)
assert.Equal(t, t, cache.Get("C"))
require.NoError(t, err)
require.Equal(t, t, cache.Get("C"))
cache.Release("C") // get will also increase the ref count
assert.Equal(t, 2, cache.Size())
require.Equal(t, 2, cache.Size())
cache.Release("B") // B's ref count is 0
cache.Release("C") // C's ref count is 0
assert.Equal(t, 2, cache.Size())
require.Equal(t, 2, cache.Size())
timeSource.Advance(time.Millisecond * 100)
assert.Nil(t, cache.Get("A"))
assert.Nil(t, cache.Get("B"))
assert.Nil(t, cache.Get("C"))
assert.Equal(t, 0, cache.Size())
require.Nil(t, cache.Get("A"))
require.Nil(t, cache.Get("B"))
require.Nil(t, cache.Get("C"))
require.Equal(t, 0, cache.Size())
}
func TestIterator(t *testing.T) {
@@ -372,7 +366,7 @@ func TestIterator(t *testing.T) {
actual[entry.Key().(string)] = entry.Value().(string)
}
it.Close()
assert.Equal(t, expected, actual)
require.Equal(t, expected, actual)
it = cache.Iterator()
for i := 0; i < len(expected); i++ {
@@ -380,7 +374,7 @@ func TestIterator(t *testing.T) {
actual[entry.Key().(string)] = entry.Value().(string)
}
it.Close()
assert.Equal(t, expected, actual)
require.Equal(t, expected, actual)
}
func TestZeroSizeCache(t *testing.T) {
@@ -388,18 +382,18 @@ func TestZeroSizeCache(t *testing.T) {
cache := NewLRU(0, metrics.NoopMetricsHandler)
_, err := cache.PutIfNotExist("A", t)
assert.NoError(t, err)
assert.Equal(t, nil, cache.Get("A"))
assert.Equal(t, 0, cache.Size())
require.NoError(t, err)
require.Nil(t, cache.Get("A"))
require.Equal(t, 0, cache.Size())
it := cache.Iterator()
assert.False(t, it.HasNext())
require.False(t, it.HasNext())
it.Close()
cache.Release("A")
cache.Delete("A")
v, err := cache.PutIfNotExist("A", t)
assert.Equal(t, v, t)
assert.Nil(t, err)
assert.Equal(t, 0, cache.Size())
require.Equal(t, t, v)
require.NoError(t, err)
require.Equal(t, 0, cache.Size())
}
func TestCache_ItemSizeTooLarge(t *testing.T) {
@@ -409,13 +403,13 @@ func TestCache_ItemSizeTooLarge(t *testing.T) {
cache := NewLRU(maxTotalBytes, metrics.NoopMetricsHandler)
res := cache.Put(uuid.New(), &testEntryWithCacheSize{maxTotalBytes})
assert.Equal(t, res, nil)
assert.Equal(t, 10, cache.Size())
require.Nil(t, res)
require.Equal(t, 10, cache.Size())
res, err := cache.PutIfNotExist(uuid.New(), &testEntryWithCacheSize{maxTotalBytes + 1})
assert.Equal(t, err, ErrCacheItemTooLarge)
assert.Equal(t, res, nil)
assert.Equal(t, 10, cache.Size())
require.Equal(t, ErrCacheItemTooLarge, err)
require.Nil(t, res)
require.Equal(t, 10, cache.Size())
}
@@ -433,9 +427,10 @@ func TestCache_ItemHasCacheSizeDefined(t *testing.T) {
startWG.Add(numPuts)
endWG.Add(numPuts)
sizeDuringPuts := make(chan int)
go func() {
startWG.Wait()
assert.True(t, cache.Size() < maxTotalBytes)
await.Snd(t, sizeDuringPuts, cache.Size())
}()
for range numPuts {
go func() {
@@ -448,7 +443,9 @@ func TestCache_ItemHasCacheSizeDefined(t *testing.T) {
startWG.Done()
}
size := await.Rcv(t, sizeDuringPuts)
endWG.Wait()
require.Less(t, size, maxTotalBytes)
}
func TestCache_ItemHasCacheSizeDefined_PutWithNewKeys(t *testing.T) {
@@ -459,21 +456,21 @@ func TestCache_ItemHasCacheSizeDefined_PutWithNewKeys(t *testing.T) {
// Put with new key and value size greater than cache size, should not be added to cache
cache.Put(uuid.New(), &testEntryWithCacheSize{15})
assert.Equal(t, 0, cache.Size())
require.Equal(t, 0, cache.Size())
// Put with new key and value size less than cache size, should be added to cache
cache.Put(uuid.New(), &testEntryWithCacheSize{5})
assert.Equal(t, 5, cache.Size())
require.Equal(t, 5, cache.Size())
// Put with new key and value size less than cache size, should evict 0 ref items and added to cache
cache.Put(uuid.New(), &testEntryWithCacheSize{10})
assert.Equal(t, 10, cache.Size())
require.Equal(t, 10, cache.Size())
// Put with new key and value size less than cache size, should evict 0 ref items until enough spaces and added to cache
cache.Put(uuid.New(), &testEntryWithCacheSize{3})
assert.Equal(t, 3, cache.Size())
require.Equal(t, 3, cache.Size())
cache.Put(uuid.New(), &testEntryWithCacheSize{7})
assert.Equal(t, 10, cache.Size())
require.Equal(t, 10, cache.Size())
}
func TestCache_ItemHasCacheSizeDefined_PutWithSameKeyAndDifferentSizes(t *testing.T) {
@@ -484,32 +481,32 @@ func TestCache_ItemHasCacheSizeDefined_PutWithSameKeyAndDifferentSizes(t *testin
key1 := "A"
cache.Put(key1, &testEntryWithCacheSize{4})
assert.Equal(t, 4, cache.Size())
require.Equal(t, 4, cache.Size())
key2 := "B"
cache.Put(key2, &testEntryWithCacheSize{4})
// 4 + 4 = 8 < 10 should not evict any items
assert.Equal(t, 8, cache.Size())
require.Equal(t, 8, cache.Size())
// put same key with smaller size, should not evict any items
cache.Put(key2, &testEntryWithCacheSize{3})
assert.Equal(t, cache.Get(key1), &testEntryWithCacheSize{4})
require.Equal(t, &testEntryWithCacheSize{4}, cache.Get(key1))
// 8 - 4 + 3 = 7 < 10, should not evict any items
assert.Equal(t, 7, cache.Size())
require.Equal(t, 7, cache.Size())
// put same key with larger size, but below cache size, should not evict any items
cache.Put(key2, &testEntryWithCacheSize{6})
// 7 - 3 + 6 = 10 =< 10, should not evict any items
assert.Equal(t, 10, cache.Size())
require.Equal(t, 10, cache.Size())
// get key1 after to make it the most recently used
assert.Equal(t, cache.Get(key2), &testEntryWithCacheSize{6})
assert.Equal(t, cache.Get(key1), &testEntryWithCacheSize{4})
require.Equal(t, &testEntryWithCacheSize{6}, cache.Get(key2))
require.Equal(t, &testEntryWithCacheSize{4}, cache.Get(key1))
// put same key with larger size, but take all cache size, should evict all items
cache.Put(key2, &testEntryWithCacheSize{10})
// 10 - 4 - 6 + 10 = 10 =< 10, should evict all items
assert.Equal(t, 10, cache.Size())
assert.Equal(t, cache.Get(key1), nil)
assert.Equal(t, cache.Get(key2), &testEntryWithCacheSize{10})
require.Equal(t, 10, cache.Size())
require.Nil(t, cache.Get(key1))
require.Equal(t, &testEntryWithCacheSize{10}, cache.Get(key2))
}
func TestCache_ItemHasCacheSizeDefined_PutWithSameKey(t *testing.T) {
@@ -522,21 +519,21 @@ func TestCache_ItemHasCacheSizeDefined_PutWithSameKey(t *testing.T) {
// Put with same key and value size greater than cache size, should not be added to cache
cache.Put(key, &testEntryWithCacheSize{15})
assert.Equal(t, 0, cache.Size())
require.Equal(t, 0, cache.Size())
// Put with same key and value size less than cache size, should be added to cache
cache.Put(key, &testEntryWithCacheSize{5})
assert.Equal(t, 5, cache.Size())
require.Equal(t, 5, cache.Size())
// Put with same key and value size less than cache size, should be evicted until enough space and added to cache
cache.Put(key, &testEntryWithCacheSize{10})
assert.Equal(t, 10, cache.Size())
require.Equal(t, 10, cache.Size())
// Put with same key and value size less than cache size, should be evicted until enough space and added to cache
cache.Put(key, &testEntryWithCacheSize{3})
assert.Equal(t, 3, cache.Size())
require.Equal(t, 3, cache.Size())
cache.Put(key, &testEntryWithCacheSize{7})
assert.Equal(t, 7, cache.Size())
require.Equal(t, 7, cache.Size())
}
func TestCache_ItemHasCacheSizeDefined_PutIfNotExistWithNewKeys(t *testing.T) {
@@ -547,27 +544,27 @@ func TestCache_ItemHasCacheSizeDefined_PutIfNotExistWithNewKeys(t *testing.T) {
// PutIfNotExist with new keys with size greater than cache size, should return error and not add to cache
val, err := cache.PutIfNotExist(uuid.New(), &testEntryWithCacheSize{15})
assert.Equal(t, ErrCacheItemTooLarge, err)
assert.Nil(t, val)
assert.Equal(t, 0, cache.Size())
require.Equal(t, ErrCacheItemTooLarge, err)
require.Nil(t, val)
require.Equal(t, 0, cache.Size())
// PutIfNotExist with new keys with size less than cache size, should add to cache
val, err = cache.PutIfNotExist(uuid.New(), &testEntryWithCacheSize{5})
assert.NoError(t, err)
assert.Equal(t, &testEntryWithCacheSize{5}, val)
assert.Equal(t, 5, cache.Size())
require.NoError(t, err)
require.Equal(t, &testEntryWithCacheSize{5}, val)
require.Equal(t, 5, cache.Size())
// PutIfNotExist with new keys with size less than cache size, should evict item and add to cache
val, err = cache.PutIfNotExist(uuid.New(), &testEntryWithCacheSize{10})
assert.NoError(t, err)
assert.Equal(t, &testEntryWithCacheSize{10}, val)
assert.Equal(t, 10, cache.Size())
require.NoError(t, err)
require.Equal(t, &testEntryWithCacheSize{10}, val)
require.Equal(t, 10, cache.Size())
// PutIfNotExist with new keys with size less than cache size, should evict item and add to cache
val, err = cache.PutIfNotExist(uuid.New(), &testEntryWithCacheSize{5})
assert.NoError(t, err)
assert.Equal(t, &testEntryWithCacheSize{5}, val)
assert.Equal(t, 5, cache.Size())
require.NoError(t, err)
require.Equal(t, &testEntryWithCacheSize{5}, val)
require.Equal(t, 5, cache.Size())
}
func TestCache_ItemHasCacheSizeDefined_PutIfNotExistWithSameKey(t *testing.T) {
@@ -579,21 +576,21 @@ func TestCache_ItemHasCacheSizeDefined_PutIfNotExistWithSameKey(t *testing.T) {
// PutIfNotExist with new keys with size greater than cache size, should return error and not add to cache
val, err := cache.PutIfNotExist(key, &testEntryWithCacheSize{15})
assert.Equal(t, ErrCacheItemTooLarge, err)
assert.Nil(t, val)
assert.Equal(t, 0, cache.Size())
require.Equal(t, ErrCacheItemTooLarge, err)
require.Nil(t, val)
require.Equal(t, 0, cache.Size())
// PutIfNotExist with new keys with size less than cache size, should add to cache
val, err = cache.PutIfNotExist(key, &testEntryWithCacheSize{5})
assert.NoError(t, err)
assert.Equal(t, &testEntryWithCacheSize{5}, val)
assert.Equal(t, 5, cache.Size())
require.NoError(t, err)
require.Equal(t, &testEntryWithCacheSize{5}, val)
require.Equal(t, 5, cache.Size())
// PutIfNotExist with same keys with size less than cache size, should not be added to cache
val, err = cache.PutIfNotExist(key, &testEntryWithCacheSize{10})
assert.NoError(t, err)
assert.Equal(t, &testEntryWithCacheSize{5}, val)
assert.Equal(t, 5, cache.Size())
require.NoError(t, err)
require.Equal(t, &testEntryWithCacheSize{5}, val)
require.Equal(t, 5, cache.Size())
}
func TestCache_PutIfNotExistWithNewKeys_Pin(t *testing.T) {
@@ -603,24 +600,24 @@ func TestCache_PutIfNotExistWithNewKeys_Pin(t *testing.T) {
cache := New(maxTotalBytes, &Options{Pin: true})
val, err := cache.PutIfNotExist(uuid.New(), &testEntryWithCacheSize{15})
assert.Equal(t, ErrCacheItemTooLarge, err)
assert.Nil(t, val)
assert.Equal(t, 0, cache.Size())
require.Equal(t, ErrCacheItemTooLarge, err)
require.Nil(t, val)
require.Equal(t, 0, cache.Size())
val, err = cache.PutIfNotExist(uuid.New(), &testEntryWithCacheSize{3})
assert.NoError(t, err)
assert.Equal(t, &testEntryWithCacheSize{3}, val)
assert.Equal(t, 3, cache.Size())
require.NoError(t, err)
require.Equal(t, &testEntryWithCacheSize{3}, val)
require.Equal(t, 3, cache.Size())
val, err = cache.PutIfNotExist(uuid.New(), &testEntryWithCacheSize{7})
assert.NoError(t, err)
assert.Equal(t, &testEntryWithCacheSize{7}, val)
assert.Equal(t, 10, cache.Size())
require.NoError(t, err)
require.Equal(t, &testEntryWithCacheSize{7}, val)
require.Equal(t, 10, cache.Size())
val, err = cache.PutIfNotExist(uuid.New(), &testEntryWithCacheSize{8})
assert.Equal(t, ErrCacheFull, err)
assert.Nil(t, val)
assert.Equal(t, 10, cache.Size())
require.Equal(t, ErrCacheFull, err)
require.Nil(t, val)
require.Equal(t, 10, cache.Size())
}
func TestCache_PutIfNotExistWithSameKeys_Pin(t *testing.T) {
@@ -631,19 +628,19 @@ func TestCache_PutIfNotExistWithSameKeys_Pin(t *testing.T) {
key := uuid.New()
val, err := cache.PutIfNotExist(key, &testEntryWithCacheSize{15})
assert.Equal(t, ErrCacheItemTooLarge, err)
assert.Nil(t, val)
assert.Equal(t, 0, cache.Size())
require.Equal(t, ErrCacheItemTooLarge, err)
require.Nil(t, val)
require.Equal(t, 0, cache.Size())
val, err = cache.PutIfNotExist(key, &testEntryWithCacheSize{3})
assert.NoError(t, err)
assert.Equal(t, &testEntryWithCacheSize{3}, val)
assert.Equal(t, 3, cache.Size())
require.NoError(t, err)
require.Equal(t, &testEntryWithCacheSize{3}, val)
require.Equal(t, 3, cache.Size())
val, err = cache.PutIfNotExist(key, &testEntryWithCacheSize{7})
assert.NoError(t, err)
assert.Equal(t, &testEntryWithCacheSize{3}, val)
assert.Equal(t, 3, cache.Size())
require.NoError(t, err)
require.Equal(t, &testEntryWithCacheSize{3}, val)
require.Equal(t, 3, cache.Size())
}
func TestCache_ItemSizeChangeBeforeRelease(t *testing.T) {
@@ -663,19 +660,19 @@ func TestCache_ItemSizeChangeBeforeRelease(t *testing.T) {
}
key1 := uuid.New()
_, err := cache.PutIfNotExist(key1, entry1)
assert.NoError(t, err)
assert.Equal(t, 1, cache.Size())
require.NoError(t, err)
require.Equal(t, 1, cache.Size())
entry1.cacheSize = 5
cache.Release(key1)
assert.Equal(t, 5, cache.Size())
require.Equal(t, 5, cache.Size())
_, err = cache.PutIfNotExist(key1, entry1)
assert.NoError(t, err)
assert.Equal(t, 5, cache.Size())
require.NoError(t, err)
require.Equal(t, 5, cache.Size())
entry1.cacheSize = 10
cache.Release(key1)
assert.Equal(t, 10, cache.Size())
require.Equal(t, 10, cache.Size())
// Inserting another entry when cache is full. entry1 should be evicted from cache.
entry2 := &testEntryWithCacheSize{
@@ -683,19 +680,19 @@ func TestCache_ItemSizeChangeBeforeRelease(t *testing.T) {
}
key2 := uuid.New()
_, err = cache.PutIfNotExist(key2, entry2)
assert.NoError(t, err)
assert.Equal(t, 2, cache.Size())
require.NoError(t, err)
require.Equal(t, 2, cache.Size())
// Inserting entry1 again to make cache full again.
entry1.cacheSize = 8
_, err = cache.PutIfNotExist(key1, entry1)
assert.NoError(t, err)
assert.Equal(t, 10, cache.Size())
require.NoError(t, err)
require.Equal(t, 10, cache.Size())
// Increasing the size of entry1 before releasing. This will make the cache size > max limit.
entry1.cacheSize = 10
cache.Release(key1)
// Cache should have evicted entry1 to bring cache size under max limit.
assert.Equal(t, 2, cache.Size())
require.Equal(t, 2, cache.Size())
}
func TestCache_InvokeLifecycleCallbacks(t *testing.T) {
@@ -709,11 +706,11 @@ func TestCache_InvokeLifecycleCallbacks(t *testing.T) {
TTL: ttl,
TimeSource: timeSource,
OnPut: func(val any) {
require.Equal(t, val, "value")
require.Equal(t, "value", val)
onPut++
},
OnEvict: func(val any) {
require.Equal(t, val, "value")
require.Equal(t, "value", val)
onEvict++
},
},
@@ -732,7 +729,7 @@ func TestCache_InvokeLifecycleCallbacks(t *testing.T) {
cache.Put("key", "value")
timeSource.Advance(2 * ttl)
assert.Nil(t, cache.Get("key"))
require.Nil(t, cache.Get("key"))
require.Equal(t, 2, onEvict, "expected OnEvict callback to be invoked")
}
@@ -761,9 +758,9 @@ func TestCache_UnusedExpiry(t *testing.T) {
cache.Put(1, 1)
r.Equal(1, cache.Size())
r.Eventually(func() bool {
await.Require(t.Context(), t, func(t *await.T) {
timeSource.Advance(loopInterval)
return cache.Size() == 0
require.Equal(t, 0, cache.Size())
}, 2*time.Second, 100*time.Millisecond)
cache.Put(2, 2)
@@ -771,14 +768,18 @@ func TestCache_UnusedExpiry(t *testing.T) {
cache.Put(3, 3)
r.Equal(2, cache.Size())
r.Eventually(func() bool {
await.Require(t.Context(), t, func(t *await.T) {
timeSource.Advance(loopInterval)
return cache.Size() == 1 && cache.Get(2) == nil && cache.Get(3) == 3
require.Equal(t, 1, cache.Size())
require.Nil(t, cache.Get(2))
require.Equal(t, 3, cache.Get(3))
}, 2*time.Second, 100*time.Millisecond)
r.Eventually(func() bool {
await.Require(t.Context(), t, func(t *await.T) {
timeSource.Advance(loopInterval)
return cache.Size() == 0 && cache.Get(2) == nil && cache.Get(3) == nil
require.Equal(t, 0, cache.Size())
require.Nil(t, cache.Get(2))
require.Nil(t, cache.Get(3))
}, 2*time.Second, 100*time.Millisecond)
// Stop the background goroutine, confirm no active expiration.
@@ -791,19 +792,12 @@ func TestCache_UnusedExpiry(t *testing.T) {
l.loops.Wait()
close(c)
}()
r.Eventually(func() bool {
select {
case <-c:
return true
default:
return false
}
}, 2*time.Second, 100*time.Millisecond)
await.Rcv(t, c)
timeSource.Advance(ttl + 1*time.Second)
// The cache should still have entry 4,
r.Equal(1, cache.Size())
// but this Get call will check the (hard) ttl & expire it.
r.Equal(nil, cache.Get(4))
r.Nil(cache.Get(4))
}
func TestCache_UnusedExpiryPin(t *testing.T) {
@@ -837,15 +831,16 @@ func TestCache_UnusedExpiryPin(t *testing.T) {
r.NoError(err)
r.Equal(2, cache.Size())
r.Eventually(func() bool {
await.Require(t.Context(), t, func(t *await.T) {
timeSource.Advance(loopInterval)
return cache.Size() == 1 && cache.Get(1) == nil
require.Equal(t, 1, cache.Size())
require.Nil(t, cache.Get(1))
}, 1*time.Second, 100*time.Millisecond)
cache.Release(2)
r.Eventually(func() bool {
await.Require(t.Context(), t, func(t *await.T) {
timeSource.Advance(loopInterval)
return cache.Size() == 0
require.Equal(t, 0, cache.Size())
}, 1*time.Second, 100*time.Millisecond)
}

55
common/cache/simple_test.go vendored
View File

@@ -5,35 +5,35 @@ import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestSimple(t *testing.T) {
cache := NewSimple(nil)
cache.Put("A", "Foo")
assert.Equal(t, "Foo", cache.Get("A"))
assert.Nil(t, cache.Get("B"))
assert.Equal(t, 1, cache.Size())
require.Equal(t, "Foo", cache.Get("A"))
require.Nil(t, cache.Get("B"))
require.Equal(t, 1, cache.Size())
cache.Put("B", "Bar")
cache.Put("C", "Cid")
cache.Put("D", "Delt")
assert.Equal(t, 4, cache.Size())
require.Equal(t, 4, cache.Size())
assert.Equal(t, "Bar", cache.Get("B"))
assert.Equal(t, "Cid", cache.Get("C"))
assert.Equal(t, "Delt", cache.Get("D"))
require.Equal(t, "Bar", cache.Get("B"))
require.Equal(t, "Cid", cache.Get("C"))
require.Equal(t, "Delt", cache.Get("D"))
cache.Put("A", "Foo2")
assert.Equal(t, "Foo2", cache.Get("A"))
require.Equal(t, "Foo2", cache.Get("A"))
cache.Put("E", "Epsi")
assert.Equal(t, "Epsi", cache.Get("E"))
assert.Equal(t, "Foo2", cache.Get("A"))
require.Equal(t, "Epsi", cache.Get("E"))
require.Equal(t, "Foo2", cache.Get("A"))
cache.Delete("A")
assert.Nil(t, cache.Get("A"))
require.Nil(t, cache.Get("A"))
}
func TestSimpleGenerics(t *testing.T) {
@@ -46,12 +46,12 @@ func TestSimpleGenerics(t *testing.T) {
cache := NewSimple(nil)
cache.Put(key, value)
assert.Equal(t, value, cache.Get(key))
assert.Equal(t, value, cache.Get(keyType{
require.Equal(t, value, cache.Get(key))
require.Equal(t, value, cache.Get(keyType{
dummyString: "some random key",
dummyInt: 59,
}))
assert.Nil(t, cache.Get(keyType{
require.Nil(t, cache.Get(keyType{
dummyString: "some other random key",
dummyInt: 56,
}))
@@ -74,24 +74,18 @@ func TestSimpleCacheConcurrentAccess(t *testing.T) {
start := make(chan struct{})
var wg sync.WaitGroup
for range 20 {
wg.Add(2)
// concurrent get and put
go func() {
defer wg.Done()
wg.Go(func() {
<-start
for range 1000 {
cache.Get("A")
cache.Put("A", "fooo")
}
}()
})
// concurrent iteration
go func() {
defer wg.Done()
wg.Go(func() {
<-start
for range 50 {
@@ -101,7 +95,7 @@ func TestSimpleCacheConcurrentAccess(t *testing.T) {
}
it.Close()
}
}()
})
}
close(start)
@@ -113,19 +107,18 @@ func TestSimpleRemoveFunc(t *testing.T) {
cache := NewSimple(&SimpleOptions{
RemovedFunc: func(i any) {
_, ok := i.(*testing.T)
assert.True(t, ok)
ch <- true
ch <- ok
},
})
cache.Put("testing", t)
cache.Delete("testing")
assert.Nil(t, cache.Get("testing"))
require.Nil(t, cache.Get("testing"))
timeout := time.NewTimer(time.Millisecond * 300)
select {
case b := <-ch:
assert.True(t, b)
require.True(t, b)
case <-timeout.C:
t.Error("RemovedFunc did not send true on channel ch")
}
@@ -154,7 +147,7 @@ func TestSimpleIterator(t *testing.T) {
actual[entry.Key().(string)] = entry.Value().(string)
}
it.Close()
assert.Equal(t, expected, actual)
require.Equal(t, expected, actual)
it = cache.Iterator()
for i := 0; i < len(expected); i++ {
@@ -163,5 +156,5 @@ func TestSimpleIterator(t *testing.T) {
actual[entry.Key().(string)] = entry.Value().(string)
}
it.Close()
assert.Equal(t, expected, actual)
require.Equal(t, expected, actual)
}