mirror of
https://github.com/trufflesecurity/trufflehog.git
synced 2024-11-15 09:27:30 +00:00
379 lines
12 KiB
Go
379 lines
12 KiB
Go
package cache
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
type mockCollector struct{ mock.Mock }
|
|
|
|
func (m *mockCollector) RecordHits(cacheName string, hits uint64) { m.Called(cacheName, hits) }
|
|
func (m *mockCollector) RecordMisses(cacheName string, misses uint64) { m.Called(cacheName, misses) }
|
|
|
|
func (m *mockCollector) RecordSet(cacheName string) { m.Called(cacheName) }
|
|
func (m *mockCollector) RecordHit(cacheName string) { m.Called(cacheName) }
|
|
func (m *mockCollector) RecordMiss(cacheName string) { m.Called(cacheName) }
|
|
func (m *mockCollector) RecordDelete(cacheName string) { m.Called(cacheName) }
|
|
func (m *mockCollector) RecordClear(cacheName string) { m.Called(cacheName) }
|
|
|
|
type mockCache[T any] struct{ mock.Mock }
|
|
|
|
func (m *mockCache[T]) Set(key string, val T) { m.Called(key, val) }
|
|
|
|
func (m *mockCache[T]) Get(key string) (T, bool) {
|
|
args := m.Called(key)
|
|
var zero T
|
|
if args.Get(0) != nil {
|
|
return args.Get(0).(T), args.Bool(1)
|
|
}
|
|
return zero, args.Bool(1)
|
|
}
|
|
|
|
func (m *mockCache[T]) Exists(key string) bool {
|
|
args := m.Called(key)
|
|
return args.Bool(0)
|
|
}
|
|
|
|
func (m *mockCache[T]) Delete(key string) { m.Called(key) }
|
|
|
|
func (m *mockCache[T]) Clear() { m.Called() }
|
|
|
|
func (m *mockCache[T]) Count() int {
|
|
args := m.Called()
|
|
return args.Int(0)
|
|
}
|
|
|
|
func (m *mockCache[T]) Keys() []string {
|
|
args := m.Called()
|
|
return args.Get(0).([]string)
|
|
}
|
|
|
|
func (m *mockCache[T]) Values() []T {
|
|
args := m.Called()
|
|
return args.Get(0).([]T)
|
|
}
|
|
|
|
func (m *mockCache[T]) Contents() string {
|
|
args := m.Called()
|
|
return args.String(0)
|
|
}
|
|
|
|
// setupCache initializes the mock cache and metrics collector, then wraps them with the WithMetrics decorator.
|
|
func setupCache[T any](t *testing.T) (*WithMetrics[T], *mockCache[T], *mockCollector) {
|
|
t.Helper()
|
|
|
|
collector := new(mockCollector)
|
|
cache := new(mockCache[T])
|
|
wrappedCache := NewCacheWithMetrics[T](cache, collector, "test_cache")
|
|
assert.NotNil(t, wrappedCache, "WithMetrics cache should not be nil")
|
|
|
|
return wrappedCache, cache, collector
|
|
}
|
|
|
|
func TestNewLRUCache(t *testing.T) {
|
|
c, _, _ := setupCache[int](t)
|
|
assert.Equal(t, "test_cache", c.cacheName)
|
|
}
|
|
|
|
func TestCacheSet(t *testing.T) {
|
|
c, cacheMock, collectorMock := setupCache[string](t)
|
|
|
|
collectorMock.On("RecordSet", "test_cache").Once()
|
|
cacheMock.On("Set", "key", "value").Once()
|
|
|
|
c.Set("key", "value")
|
|
|
|
collectorMock.AssertCalled(t, "RecordSet", "test_cache")
|
|
cacheMock.AssertCalled(t, "Set", "key", "value")
|
|
}
|
|
|
|
func TestCacheGet(t *testing.T) {
|
|
c, cacheMock, collectorMock := setupCache[string](t)
|
|
|
|
collectorMock.On("RecordSet", "test_cache").Once()
|
|
cacheMock.On("Set", "key", "value").Once()
|
|
|
|
collectorMock.On("RecordHit", "test_cache").Once()
|
|
cacheMock.On("Get", "key").Return("value", true).Once()
|
|
|
|
collectorMock.On("RecordMiss", "test_cache").Once()
|
|
cacheMock.On("Get", "non_existent").Return("", false).Once()
|
|
|
|
c.Set("key", "value")
|
|
collectorMock.AssertCalled(t, "RecordSet", "test_cache")
|
|
cacheMock.AssertCalled(t, "Set", "key", "value")
|
|
|
|
value, found := c.Get("key")
|
|
assert.True(t, found, "Expected to find the key")
|
|
assert.Equal(t, "value", value, "Expected value to match")
|
|
collectorMock.AssertCalled(t, "RecordHit", "test_cache")
|
|
cacheMock.AssertCalled(t, "Get", "key")
|
|
|
|
_, found = c.Get("non_existent")
|
|
assert.False(t, found, "Expected not to find the key")
|
|
collectorMock.AssertCalled(t, "RecordMiss", "test_cache")
|
|
cacheMock.AssertCalled(t, "Get", "non_existent")
|
|
|
|
collectorMock.AssertExpectations(t)
|
|
cacheMock.AssertExpectations(t)
|
|
}
|
|
|
|
func TestCacheExists(t *testing.T) {
|
|
c, cacheMock, collectorMock := setupCache[string](t)
|
|
|
|
collectorMock.On("RecordSet", "test_cache").Once()
|
|
cacheMock.On("Set", "key", "value").Once()
|
|
|
|
collectorMock.On("RecordHit", "test_cache").Once()
|
|
cacheMock.On("Exists", "key").Return(true).Once()
|
|
|
|
collectorMock.On("RecordMiss", "test_cache").Once()
|
|
cacheMock.On("Exists", "non_existent").Return(false).Once()
|
|
|
|
c.Set("key", "value")
|
|
collectorMock.AssertCalled(t, "RecordSet", "test_cache")
|
|
cacheMock.AssertCalled(t, "Set", "key", "value")
|
|
|
|
exists := c.Exists("key")
|
|
assert.True(t, exists, "Expected the key to exist")
|
|
collectorMock.AssertCalled(t, "RecordHit", "test_cache")
|
|
cacheMock.AssertCalled(t, "Exists", "key")
|
|
|
|
exists = c.Exists("non_existent")
|
|
assert.False(t, exists, "Expected the key not to exist")
|
|
collectorMock.AssertCalled(t, "RecordMiss", "test_cache")
|
|
cacheMock.AssertCalled(t, "Exists", "non_existent")
|
|
|
|
collectorMock.AssertExpectations(t)
|
|
cacheMock.AssertExpectations(t)
|
|
}
|
|
|
|
func TestCacheDelete(t *testing.T) {
|
|
c, cacheMock, collectorMock := setupCache[string](t)
|
|
|
|
collectorMock.On("RecordSet", "test_cache").Once()
|
|
cacheMock.On("Set", "key", "value").Once()
|
|
|
|
collectorMock.On("RecordDelete", "test_cache").Once()
|
|
cacheMock.On("Delete", "key").Once()
|
|
|
|
cacheMock.On("Get", "key").Return("", false).Once()
|
|
|
|
collectorMock.On("RecordMiss", "test_cache").Once()
|
|
|
|
c.Set("key", "value")
|
|
collectorMock.AssertCalled(t, "RecordSet", "test_cache")
|
|
cacheMock.AssertCalled(t, "Set", "key", "value")
|
|
|
|
c.Delete("key")
|
|
collectorMock.AssertCalled(t, "RecordDelete", "test_cache")
|
|
cacheMock.AssertCalled(t, "Delete", "key")
|
|
|
|
_, found := c.Get("key")
|
|
assert.False(t, found, "Expected not to find the deleted key")
|
|
collectorMock.AssertCalled(t, "RecordMiss", "test_cache")
|
|
cacheMock.AssertCalled(t, "Get", "key")
|
|
|
|
collectorMock.AssertExpectations(t)
|
|
cacheMock.AssertExpectations(t)
|
|
}
|
|
|
|
func TestCacheClear(t *testing.T) {
|
|
c, cacheMock, collectorMock := setupCache[string](t)
|
|
|
|
collectorMock.On("RecordSet", "test_cache").Twice()
|
|
cacheMock.On("Set", "key1", "value1").Once()
|
|
cacheMock.On("Set", "key2", "value2").Once()
|
|
|
|
collectorMock.On("RecordClear", "test_cache").Once()
|
|
cacheMock.On("Clear").Once()
|
|
|
|
cacheMock.On("Get", "key1").Return("", false).Once()
|
|
cacheMock.On("Get", "key2").Return("", false).Once()
|
|
|
|
c.Set("key1", "value1")
|
|
c.Set("key2", "value2")
|
|
collectorMock.AssertNumberOfCalls(t, "RecordSet", 2)
|
|
cacheMock.AssertCalled(t, "Set", "key1", "value1")
|
|
cacheMock.AssertCalled(t, "Set", "key2", "value2")
|
|
|
|
c.Clear()
|
|
collectorMock.AssertCalled(t, "RecordClear", "test_cache")
|
|
cacheMock.AssertCalled(t, "Clear")
|
|
|
|
collectorMock.On("RecordMiss", "test_cache").Twice()
|
|
_, found1 := c.Get("key1")
|
|
_, found2 := c.Get("key2")
|
|
assert.False(t, found1, "Expected not to find key1 after clear")
|
|
assert.False(t, found2, "Expected not to find key2 after clear")
|
|
collectorMock.AssertNumberOfCalls(t, "RecordMiss", 2)
|
|
cacheMock.AssertCalled(t, "Get", "key1")
|
|
cacheMock.AssertCalled(t, "Get", "key2")
|
|
|
|
collectorMock.AssertExpectations(t)
|
|
cacheMock.AssertExpectations(t)
|
|
}
|
|
|
|
func TestCacheCount(t *testing.T) {
|
|
c, cacheMock, collectorMock := setupCache[string](t)
|
|
|
|
collectorMock.On("RecordSet", "test_cache").Times(3)
|
|
cacheMock.On("Set", mock.Anything, mock.Anything).Times(3)
|
|
|
|
cacheMock.On("Count").Return(3).Once()
|
|
|
|
collectorMock.On("RecordDelete", "test_cache").Once()
|
|
cacheMock.On("Delete", "key2").Once()
|
|
cacheMock.On("Count").Return(2).Once()
|
|
|
|
collectorMock.On("RecordClear", "test_cache").Once()
|
|
cacheMock.On("Clear").Once()
|
|
cacheMock.On("Count").Return(0).Once()
|
|
|
|
c.Set("key1", "value1")
|
|
c.Set("key2", "value2")
|
|
c.Set("key3", "value3")
|
|
assert.Equal(t, 3, c.Count(), "Expected count to be 3")
|
|
collectorMock.AssertNumberOfCalls(t, "RecordSet", 3)
|
|
cacheMock.AssertNumberOfCalls(t, "Set", 3)
|
|
cacheMock.AssertCalled(t, "Count")
|
|
|
|
c.Delete("key2")
|
|
assert.Equal(t, 2, c.Count(), "Expected count to be 2 after deletion")
|
|
collectorMock.AssertCalled(t, "RecordDelete", "test_cache")
|
|
cacheMock.AssertCalled(t, "Delete", "key2")
|
|
cacheMock.AssertCalled(t, "Count")
|
|
|
|
c.Clear()
|
|
assert.Equal(t, 0, c.Count(), "Expected count to be 0 after clear")
|
|
collectorMock.AssertCalled(t, "RecordClear", "test_cache")
|
|
cacheMock.AssertCalled(t, "Clear")
|
|
cacheMock.AssertCalled(t, "Count")
|
|
|
|
collectorMock.AssertExpectations(t)
|
|
cacheMock.AssertExpectations(t)
|
|
}
|
|
|
|
func TestCacheKeys(t *testing.T) {
|
|
c, cacheMock, collectorMock := setupCache[string](t)
|
|
|
|
collectorMock.On("RecordSet", "test_cache").Times(3)
|
|
cacheMock.On("Set", mock.Anything, mock.Anything).Times(3)
|
|
|
|
collectorMock.On("RecordDelete", "test_cache").Once()
|
|
cacheMock.On("Delete", "key2").Once()
|
|
cacheMock.On("Clear").Once()
|
|
collectorMock.On("RecordClear", "test_cache").Once()
|
|
|
|
cacheMock.On("Keys").Return([]string{"key1", "key2", "key3"}).Once()
|
|
cacheMock.On("Keys").Return([]string{"key1", "key3"}).Once()
|
|
cacheMock.On("Keys").Return([]string{}).Once()
|
|
|
|
c.Set("key1", "value1")
|
|
c.Set("key2", "value2")
|
|
c.Set("key3", "value3")
|
|
collectorMock.AssertNumberOfCalls(t, "RecordSet", 3)
|
|
cacheMock.AssertNumberOfCalls(t, "Set", 3)
|
|
|
|
keys := c.Keys()
|
|
assert.Len(t, keys, 3, "Expected 3 keys")
|
|
assert.ElementsMatch(t, []string{"key1", "key2", "key3"}, keys, "Keys do not match expected values")
|
|
|
|
c.Delete("key2")
|
|
keys = c.Keys()
|
|
assert.Len(t, keys, 2, "Expected 2 keys after deletion")
|
|
assert.ElementsMatch(t, []string{"key1", "key3"}, keys, "Keys do not match expected values after deletion")
|
|
collectorMock.AssertCalled(t, "RecordDelete", "test_cache")
|
|
|
|
c.Clear()
|
|
keys = c.Keys()
|
|
assert.Len(t, keys, 0, "Expected no keys after clear")
|
|
collectorMock.AssertCalled(t, "RecordClear", "test_cache")
|
|
|
|
collectorMock.AssertExpectations(t)
|
|
cacheMock.AssertExpectations(t)
|
|
}
|
|
|
|
func TestCacheValues(t *testing.T) {
|
|
c, cacheMock, collectorMock := setupCache[string](t)
|
|
|
|
collectorMock.On("RecordSet", "test_cache").Times(3)
|
|
cacheMock.On("Set", mock.Anything, mock.Anything).Times(3)
|
|
|
|
collectorMock.On("RecordDelete", "test_cache").Once()
|
|
cacheMock.On("Delete", "key2").Once()
|
|
collectorMock.On("RecordClear", "test_cache").Once()
|
|
cacheMock.On("Clear").Once()
|
|
|
|
cacheMock.On("Values").Return([]string{"value1", "value2", "value3"}).Once()
|
|
cacheMock.On("Values").Return([]string{"value1", "value3"}).Once()
|
|
cacheMock.On("Values").Return([]string{}).Once()
|
|
|
|
c.Set("key1", "value1")
|
|
c.Set("key2", "value2")
|
|
c.Set("key3", "value3")
|
|
collectorMock.AssertNumberOfCalls(t, "RecordSet", 3)
|
|
cacheMock.AssertNumberOfCalls(t, "Set", 3)
|
|
|
|
values := c.Values()
|
|
assert.Len(t, values, 3, "Expected 3 values")
|
|
assert.ElementsMatch(t, []string{"value1", "value2", "value3"}, values, "Values do not match expected values")
|
|
|
|
c.Delete("key2")
|
|
values = c.Values()
|
|
assert.Len(t, values, 2, "Expected 2 values after deletion")
|
|
assert.ElementsMatch(t, []string{"value1", "value3"}, values, "Values do not match expected values after deletion")
|
|
collectorMock.AssertCalled(t, "RecordDelete", "test_cache")
|
|
|
|
c.Clear()
|
|
values = c.Values()
|
|
assert.Len(t, values, 0, "Expected no values after clear")
|
|
collectorMock.AssertCalled(t, "RecordClear", "test_cache")
|
|
|
|
collectorMock.AssertExpectations(t)
|
|
cacheMock.AssertExpectations(t)
|
|
}
|
|
|
|
func TestCacheContents(t *testing.T) {
|
|
c, cacheMock, collectorMock := setupCache[string](t)
|
|
|
|
collectorMock.On("RecordSet", "test_cache").Times(3)
|
|
cacheMock.On("Set", mock.Anything, mock.Anything).Times(3)
|
|
|
|
collectorMock.On("RecordDelete", "test_cache").Once()
|
|
cacheMock.On("Delete", "key2").Once()
|
|
collectorMock.On("RecordClear", "test_cache").Once()
|
|
cacheMock.On("Clear").Once()
|
|
|
|
cacheMock.On("Contents").Return("key1, key2, key3").Once()
|
|
cacheMock.On("Contents").Return("key1, key3").Once()
|
|
cacheMock.On("Contents").Return("[]").Once()
|
|
|
|
c.Set("key1", "value1")
|
|
c.Set("key2", "value2")
|
|
c.Set("key3", "value3")
|
|
collectorMock.AssertNumberOfCalls(t, "RecordSet", 3)
|
|
cacheMock.AssertNumberOfCalls(t, "Set", 3)
|
|
|
|
contents := c.Contents()
|
|
assert.Contains(t, contents, "key1", "Contents should contain key1")
|
|
assert.Contains(t, contents, "key2", "Contents should contain key2")
|
|
assert.Contains(t, contents, "key3", "Contents should contain key3")
|
|
|
|
c.Delete("key2")
|
|
contents = c.Contents()
|
|
assert.Contains(t, contents, "key1", "Contents should contain key1")
|
|
assert.NotContains(t, contents, "key2", "Contents should not contain key2")
|
|
assert.Contains(t, contents, "key3", "Contents should contain key3")
|
|
collectorMock.AssertCalled(t, "RecordDelete", "test_cache")
|
|
|
|
c.Clear()
|
|
contents = c.Contents()
|
|
assert.Equal(t, "[]", contents, "Contents should be empty after clear")
|
|
collectorMock.AssertCalled(t, "RecordClear", "test_cache")
|
|
|
|
collectorMock.AssertExpectations(t)
|
|
cacheMock.AssertExpectations(t)
|
|
}
|