feat: added Clear() method to flush all cache data

eko · Oct 24, 2019 · 7847237 · 7847237
1 parent 16d5e61
commit 7847237
Show file tree

Hide file tree

Showing 32 changed files with 509 additions and 0 deletions.
diff --git a/README.md b/README.md
@@ -60,6 +60,8 @@ if err != nil {
 value := cacheManager.Get("my-key")
 
 cacheManager.Delete("my-key")
+
+cacheManager.Clear() // Clears the entire cache, in case you want to flush all cache
 ```
 
 #### Memory (using Bigcache)

diff --git a/cache/cache.go b/cache/cache.go
@@ -50,6 +50,11 @@ func (c *Cache) Invalidate(options store.InvalidateOptions) error {
 	return c.codec.Invalidate(options)
 }
 
+// Clear resets all cache data
+func (c *Cache) Clear() error {
+	return c.codec.Clear()
+}
+
 // GetCodec returns the current codec
 func (c *Cache) GetCodec() codec.CodecInterface {
 	return c.codec

diff --git a/cache/cache_test.go b/cache/cache_test.go
@@ -188,6 +188,36 @@ func TestCacheInvalidateWhenError(t *testing.T) {
 	assert.Equal(t, expectedErr, err)
 }
 
+func TestCacheClear(t *testing.T) {
+	// Given
+	store := &mocksStore.StoreInterface{}
+	store.On("Clear").Return(nil)
+
+	cache := New(store)
+
+	// When
+	err := cache.Clear()
+
+	// Then
+	assert.Nil(t, err)
+}
+
+func TestCacheClearWhenError(t *testing.T) {
+	// Given
+	expectedErr := errors.New("Unexpected error during invalidation")
+
+	store := &mocksStore.StoreInterface{}
+	store.On("Clear").Return(expectedErr)
+
+	cache := New(store)
+
+	// When
+	err := cache.Clear()
+
+	// Then
+	assert.Equal(t, expectedErr, err)
+}
+
 func TestCacheDeleteWhenError(t *testing.T) {
 	// Given
 	expectedErr := errors.New("Unable to delete key")

diff --git a/cache/chain.go b/cache/chain.go
@@ -75,6 +75,15 @@ func (c *ChainCache) Invalidate(options store.InvalidateOptions) error {
 	return nil
 }
 
+// Clear resets all cache data
+func (c *ChainCache) Clear() error {
+	for _, cache := range c.caches {
+		cache.Clear()
+	}
+
+	return nil
+}
+
 // setUntil sets a value in available caches, eventually until a given cache layer
 func (c *ChainCache) setUntil(key, object interface{}, until *string) {
 	for _, cache := range c.caches {

diff --git a/cache/chain_test.go b/cache/chain_test.go
@@ -302,6 +302,44 @@ func TestChainInvalidateWhenError(t *testing.T) {
 	assert.Nil(t, err)
 }
 
+func TestChainClear(t *testing.T) {
+	// Given
+	// Cache 1
+	cache1 := &mocksCache.SetterCacheInterface{}
+	cache1.On("Clear").Return(nil)
+
+	// Cache 2
+	cache2 := &mocksCache.SetterCacheInterface{}
+	cache2.On("Clear").Return(nil)
+
+	cache := NewChain(cache1, cache2)
+
+	// When
+	err := cache.Clear()
+
+	// Then
+	assert.Nil(t, err)
+}
+
+func TestChainClearWhenError(t *testing.T) {
+	// Given
+	// Cache 1
+	cache1 := &mocksCache.SetterCacheInterface{}
+	cache1.On("Clear").Return(errors.New("An unexpected error has occurred while invalidation data"))
+
+	// Cache 2
+	cache2 := &mocksCache.SetterCacheInterface{}
+	cache2.On("Clear").Return(nil)
+
+	cache := NewChain(cache1, cache2)
+
+	// When
+	err := cache.Clear()
+
+	// Then
+	assert.Nil(t, err)
+}
+
 func TestChainGetType(t *testing.T) {
 	// Given
 	cache1 := &mocksCache.SetterCacheInterface{}

diff --git a/cache/interface.go b/cache/interface.go
@@ -11,6 +11,7 @@ type CacheInterface interface {
 	Set(key, object interface{}, options *store.Options) error
 	Delete(key interface{}) error
 	Invalidate(options store.InvalidateOptions) error
+	Clear() error
 	GetType() string
 }
 

diff --git a/cache/loadable.go b/cache/loadable.go
@@ -64,6 +64,11 @@ func (c *LoadableCache) Invalidate(options store.InvalidateOptions) error {
 	return c.cache.Invalidate(options)
 }
 
+// Clear resets all cache data
+func (c *LoadableCache) Clear() error {
+	return c.cache.Clear()
+}
+
 // GetType returns the cache type
 func (c *LoadableCache) GetType() string {
 	return LoadableType

diff --git a/cache/loadable_test.go b/cache/loadable_test.go
@@ -199,6 +199,44 @@ func TestLoadableInvalidateWhenError(t *testing.T) {
 	assert.Equal(t, expectedErr, err)
 }
 
+func TestLoadableClear(t *testing.T) {
+	// Given
+	cache1 := &mocksCache.SetterCacheInterface{}
+	cache1.On("Clear").Return(nil)
+
+	loadFunc := func(key interface{}) (interface{}, error) {
+		return "a value", nil
+	}
+
+	cache := NewLoadable(loadFunc, cache1)
+
+	// When
+	err := cache.Clear()
+
+	// Then
+	assert.Nil(t, err)
+}
+
+func TestLoadableClearWhenError(t *testing.T) {
+	// Given
+	expectedErr := errors.New("Unexpected error when invalidating data")
+
+	cache1 := &mocksCache.SetterCacheInterface{}
+	cache1.On("Clear").Return(expectedErr)
+
+	loadFunc := func(key interface{}) (interface{}, error) {
+		return "a value", nil
+	}
+
+	cache := NewLoadable(loadFunc, cache1)
+
+	// When
+	err := cache.Clear()
+
+	// Then
+	assert.Equal(t, expectedErr, err)
+}
+
 func TestLoadableGetType(t *testing.T) {
 	// Given
 	cache1 := &mocksCache.SetterCacheInterface{}

diff --git a/cache/metric.go b/cache/metric.go
@@ -48,6 +48,11 @@ func (c *MetricCache) Invalidate(options store.InvalidateOptions) error {
 	return c.cache.Invalidate(options)
 }
 
+// Clear resets all cache data
+func (c *MetricCache) Clear() error {
+	return c.cache.Clear()
+}
+
 // Get obtains a value from cache and also records metrics
 func (c *MetricCache) updateMetrics(cache CacheInterface) {
 	switch current := cache.(type) {

diff --git a/cache/metric_test.go b/cache/metric_test.go
@@ -189,6 +189,40 @@ func TestMetricInvalidateWhenError(t *testing.T) {
 	assert.Equal(t, expectedErr, err)
 }
 
+func TestMetricClear(t *testing.T) {
+	// Given
+	cache1 := &mocksCache.SetterCacheInterface{}
+	cache1.On("Clear").Return(nil)
+
+	metrics := &mocksMetrics.MetricsInterface{}
+
+	cache := NewMetric(metrics, cache1)
+
+	// When
+	err := cache.Clear()
+
+	// Then
+	assert.Nil(t, err)
+}
+
+func TestMetricClearWhenError(t *testing.T) {
+	// Given
+	expectedErr := errors.New("Unexpected error while clearing cache")
+
+	cache1 := &mocksCache.SetterCacheInterface{}
+	cache1.On("Clear").Return(expectedErr)
+
+	metrics := &mocksMetrics.MetricsInterface{}
+
+	cache := NewMetric(metrics, cache1)
+
+	// When
+	err := cache.Clear()
+
+	// Then
+	assert.Equal(t, expectedErr, err)
+}
+
 func TestMetricGetType(t *testing.T) {
 	// Given
 	cache1 := &mocksCache.SetterCacheInterface{}

diff --git a/codec/codec.go b/codec/codec.go
@@ -14,6 +14,8 @@ type Stats struct {
 	DeleteError       int
 	InvalidateSuccess int
 	InvalidateError   int
+	ClearSuccess      int
+	ClearError        int
 }
 
 // Codec represents an instance of a cache store
@@ -83,6 +85,19 @@ func (c *Codec) Invalidate(options store.InvalidateOptions) error {
 	return err
 }
 
+// Clear resets all codec store data
+func (c *Codec) Clear() error {
+	err := c.store.Clear()
+
+	if err == nil {
+		c.stats.ClearSuccess++
+	} else {
+		c.stats.ClearError++
+	}
+
+	return err
+}
+
 // GetStore returns the store associated to this codec
 func (c *Codec) GetStore() store.StoreInterface {
 	return c.store

diff --git a/codec/codec_test.go b/codec/codec_test.go
@@ -49,6 +49,8 @@ func TestGetWhenHit(t *testing.T) {
 	assert.Equal(t, 0, codec.GetStats().DeleteError)
 	assert.Equal(t, 0, codec.GetStats().InvalidateSuccess)
 	assert.Equal(t, 0, codec.GetStats().InvalidateError)
+	assert.Equal(t, 0, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 0, codec.GetStats().ClearError)
 }
 
 func TestGetWhenMiss(t *testing.T) {
@@ -75,6 +77,8 @@ func TestGetWhenMiss(t *testing.T) {
 	assert.Equal(t, 0, codec.GetStats().DeleteError)
 	assert.Equal(t, 0, codec.GetStats().InvalidateSuccess)
 	assert.Equal(t, 0, codec.GetStats().InvalidateError)
+	assert.Equal(t, 0, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 0, codec.GetStats().ClearError)
 }
 
 func TestSetWhenSuccess(t *testing.T) {
@@ -108,6 +112,8 @@ func TestSetWhenSuccess(t *testing.T) {
 	assert.Equal(t, 0, codec.GetStats().DeleteError)
 	assert.Equal(t, 0, codec.GetStats().InvalidateSuccess)
 	assert.Equal(t, 0, codec.GetStats().InvalidateError)
+	assert.Equal(t, 0, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 0, codec.GetStats().ClearError)
 }
 
 func TestSetWhenError(t *testing.T) {
@@ -143,6 +149,8 @@ func TestSetWhenError(t *testing.T) {
 	assert.Equal(t, 0, codec.GetStats().DeleteError)
 	assert.Equal(t, 0, codec.GetStats().InvalidateSuccess)
 	assert.Equal(t, 0, codec.GetStats().InvalidateError)
+	assert.Equal(t, 0, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 0, codec.GetStats().ClearError)
 }
 
 func TestDeleteWhenSuccess(t *testing.T) {
@@ -166,6 +174,8 @@ func TestDeleteWhenSuccess(t *testing.T) {
 	assert.Equal(t, 0, codec.GetStats().DeleteError)
 	assert.Equal(t, 0, codec.GetStats().InvalidateSuccess)
 	assert.Equal(t, 0, codec.GetStats().InvalidateError)
+	assert.Equal(t, 0, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 0, codec.GetStats().ClearError)
 }
 
 func TesDeleteWhenError(t *testing.T) {
@@ -191,6 +201,8 @@ func TesDeleteWhenError(t *testing.T) {
 	assert.Equal(t, 1, codec.GetStats().DeleteError)
 	assert.Equal(t, 0, codec.GetStats().InvalidateSuccess)
 	assert.Equal(t, 0, codec.GetStats().InvalidateError)
+	assert.Equal(t, 0, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 0, codec.GetStats().ClearError)
 }
 
 func TestInvalidateWhenSuccess(t *testing.T) {
@@ -218,6 +230,8 @@ func TestInvalidateWhenSuccess(t *testing.T) {
 	assert.Equal(t, 0, codec.GetStats().DeleteError)
 	assert.Equal(t, 1, codec.GetStats().InvalidateSuccess)
 	assert.Equal(t, 0, codec.GetStats().InvalidateError)
+	assert.Equal(t, 0, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 0, codec.GetStats().ClearError)
 }
 
 func TestInvalidateWhenError(t *testing.T) {
@@ -247,6 +261,60 @@ func TestInvalidateWhenError(t *testing.T) {
 	assert.Equal(t, 0, codec.GetStats().DeleteError)
 	assert.Equal(t, 0, codec.GetStats().InvalidateSuccess)
 	assert.Equal(t, 1, codec.GetStats().InvalidateError)
+	assert.Equal(t, 0, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 0, codec.GetStats().ClearError)
+}
+
+func TestClearWhenSuccess(t *testing.T) {
+	// Given
+	store := &mocksStore.StoreInterface{}
+	store.On("Clear").Return(nil)
+
+	codec := New(store)
+
+	// When
+	err := codec.Clear()
+
+	// Then
+	assert.Nil(t, err)
+
+	assert.Equal(t, 0, codec.GetStats().Hits)
+	assert.Equal(t, 0, codec.GetStats().Miss)
+	assert.Equal(t, 0, codec.GetStats().SetSuccess)
+	assert.Equal(t, 0, codec.GetStats().SetError)
+	assert.Equal(t, 0, codec.GetStats().DeleteSuccess)
+	assert.Equal(t, 0, codec.GetStats().DeleteError)
+	assert.Equal(t, 0, codec.GetStats().InvalidateSuccess)
+	assert.Equal(t, 0, codec.GetStats().InvalidateError)
+	assert.Equal(t, 1, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 0, codec.GetStats().ClearError)
+}
+
+func TestClearWhenError(t *testing.T) {
+	// Given
+	expectedErr := errors.New("Unexpected error when clearing cache")
+
+	store := &mocksStore.StoreInterface{}
+	store.On("Clear").Return(expectedErr)
+
+	codec := New(store)
+
+	// When
+	err := codec.Clear()
+
+	// Then
+	assert.Equal(t, expectedErr, err)
+
+	assert.Equal(t, 0, codec.GetStats().Hits)
+	assert.Equal(t, 0, codec.GetStats().Miss)
+	assert.Equal(t, 0, codec.GetStats().SetSuccess)
+	assert.Equal(t, 0, codec.GetStats().SetError)
+	assert.Equal(t, 0, codec.GetStats().DeleteSuccess)
+	assert.Equal(t, 0, codec.GetStats().DeleteError)
+	assert.Equal(t, 0, codec.GetStats().InvalidateSuccess)
+	assert.Equal(t, 0, codec.GetStats().InvalidateError)
+	assert.Equal(t, 0, codec.GetStats().ClearSuccess)
+	assert.Equal(t, 1, codec.GetStats().ClearError)
 }
 
 func TestGetStore(t *testing.T) {

diff --git a/codec/interface.go b/codec/interface.go
@@ -10,6 +10,7 @@ type CodecInterface interface {
 	Set(key interface{}, value interface{}, options *store.Options) error
 	Delete(key interface{}) error
 	Invalidate(options store.InvalidateOptions) error
+	Clear() error
 
 	GetStore() store.StoreInterface
 	GetStats() *Stats