From c8093a14f82a97089ad47358ed0686b3913bd141 Mon Sep 17 00:00:00 2001
From: ensiouel <ensiouel@gmail.com>
Date: Mon, 18 Dec 2023 14:51:38 +0300
Subject: [PATCH] =?UTF-8?q?refactor:=20=D1=81=D1=82=D1=80=D1=83=D0=BA?=
=?UTF-8?q?=D1=82=D1=83=D1=80=D0=B0=20Cache=20=D0=BF=D0=B5=D1=80=D0=B5?=
=?UTF-8?q?=D0=B8=D0=BC=D0=B5=D0=BD=D0=BE=D0=B2=D0=B0=D0=BD=D0=B0=20=D0=B2?=
=?UTF-8?q?=20MemoryCache,=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83?=
=?UTF-8?q?=D0=BA=D1=82=D0=BE=D1=80=20=D0=BF=D0=B5=D1=80=D0=B5=D0=B8=D0=BC?=
=?UTF-8?q?=D0=B5=D0=BD=D0=BE=D0=B2=D0=B0=D0=BD=20=D0=B2=20NewMemoryCache?=
=?UTF-8?q?=20=D0=B8=20=D0=B8=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=BB=D0=B5?=
=?UTF-8?q?=D0=BD=20=D0=B2=20=D0=BC=D0=B5=D1=81=D1=82=D0=B0=D1=85,=20?=
=?UTF-8?q?=D0=B3=D0=B4=D0=B5=20=D0=B8=D1=81=D0=BF=D0=BE=D0=BB=D1=8C=D0=B7?=
=?UTF-8?q?=D1=83=D0=B5=D1=82=D1=81=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
pkg/account/client.go | 6 +-
pkg/cache/memory_cache.go | 90 +++++++++++++++++++
.../{cache_test.go => memory_cache_test.go} | 6 +-
.../middleware/caching_middleware_test.go | 22 ++---
.../middleware/caching_middleware_test.go | 10 +--
.../middleware/caching_middleware_test.go | 22 ++---
pkg/content/client.go | 18 ++--
pkg/delivery/client/client.go | 8 +-
.../middleware/caching_middleware_test.go | 22 ++---
.../middleware/caching_middleware_test.go | 8 +-
.../middleware/caching_middleware_test.go | 38 ++++----
.../middleware/caching_middleware_test.go | 8 +-
.../middleware/caching_middleware_test.go | 10 +--
.../middleware/caching_middleware_test.go | 8 +-
.../middleware/caching_middleware_test.go | 12 +--
.../middleware/caching_middleware_test.go | 14 +--
.../middleware/caching_middleware_test.go | 10 +--
17 files changed, 201 insertions(+), 111 deletions(-)
create mode 100644 pkg/cache/memory_cache.go
rename pkg/cache/{cache_test.go => memory_cache_test.go} (93%)
diff --git a/pkg/account/client.go b/pkg/account/client.go
index 53ae9fb8..112a71f6 100644
--- a/pkg/account/client.go
+++ b/pkg/account/client.go
@@ -53,9 +53,9 @@ func NewClient(conn *grpc.ClientConn, opts ...Option) *Account {
func WithCaching(client *Account, size int, ttl time.Duration) *Account {
c := *client
- c.Members = serviceMembers.CachingMiddleware(cache.NewCache(size, ttl))(client.Members)
- c.Organizations = serviceOrganizations.CachingMiddleware(cache.NewCache(size, ttl))(client.Organizations)
- c.Users = serviceUsers.CachingMiddleware(cache.NewCache(size, ttl))(client.Users)
+ c.Members = serviceMembers.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Members)
+ c.Organizations = serviceOrganizations.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Organizations)
+ c.Users = serviceUsers.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Users)
return &c
}
diff --git a/pkg/cache/memory_cache.go b/pkg/cache/memory_cache.go
new file mode 100644
index 00000000..12b9b558
--- /dev/null
+++ b/pkg/cache/memory_cache.go
@@ -0,0 +1,90 @@
+package cache
+
+import (
+ "fmt"
+ "time"
+
+ "git.perx.ru/perxis/perxis-go/pkg/service"
+ lru "github.com/hashicorp/golang-lru/v2"
+ "go.uber.org/zap"
+)
+
+const (
+ defaultCacheSize = 1000
+ defaultTTL = 30 * time.Second
+)
+
+var _ Cache = &MemoryCache{}
+
+type MemoryCache struct {
+ cache *lru.Cache[interface{}, interface{}]
+ ttl time.Duration
+ logger *zap.Logger
+}
+
+type item struct {
+ value interface{}
+ expiredAt time.Time
+}
+
+func NewMemoryCache(size int, ttl time.Duration, opts ...interface{}) *MemoryCache {
+ if size == 0 {
+ size = defaultCacheSize
+ }
+ if ttl == 0 {
+ ttl = defaultTTL
+ }
+ c, err := lru.New[interface{}, interface{}](size)
+ if err != nil {
+ panic(err)
+ }
+ ch := &MemoryCache{
+ cache: c,
+ ttl: ttl,
+ logger: zap.NewNop(),
+ }
+
+ for _, o := range opts {
+ switch p := o.(type) {
+ case *zap.Logger:
+ ch.logger = p
+ }
+ }
+
+ ch.logger = ch.logger.Named("Cache")
+
+ return ch
+}
+
+func (c *MemoryCache) Set(key, value interface{}) (err error) {
+ c.cache.Add(key, &item{value: value, expiredAt: time.Now().Add(c.ttl)})
+ c.logger.Debug("Set", zap.String("key", fmt.Sprintf("%v", key)), zap.String("ptr", fmt.Sprintf("%p", value)))
+ return nil
+}
+
+func (c *MemoryCache) Get(key interface{}) (value interface{}, err error) {
+ val, ok := c.cache.Get(key)
+ if ok {
+ v := val.(*item)
+ if v.expiredAt.Before(time.Now()) {
+ _ = c.Remove(key)
+ c.logger.Debug("Expired", zap.String("key", fmt.Sprintf("%v", key)), zap.String("ptr", fmt.Sprintf("%p", v.value)))
+ return nil, service.ErrNotFound
+ }
+ c.logger.Debug("Hit", zap.String("key", fmt.Sprintf("%v", key)), zap.String("ptr", fmt.Sprintf("%p", v.value)))
+ return v.value, nil
+ }
+ c.logger.Debug("Miss", zap.String("key", fmt.Sprintf("%v", key)))
+ return nil, service.ErrNotFound
+}
+
+func (c *MemoryCache) Remove(key interface{}) (err error) {
+ present := c.cache.Remove(key)
+ c.logger.Debug("Remove", zap.String("key", fmt.Sprintf("%v", key)))
+
+ if !present {
+ err = service.ErrNotFound
+ }
+
+ return
+}
diff --git a/pkg/cache/cache_test.go b/pkg/cache/memory_cache_test.go
similarity index 93%
rename from pkg/cache/cache_test.go
rename to pkg/cache/memory_cache_test.go
index b0d4304a..b7cf246f 100644
--- a/pkg/cache/cache_test.go
+++ b/pkg/cache/memory_cache_test.go
@@ -10,7 +10,7 @@ import (
func TestCache(t *testing.T) {
t.Run("Simple", func(t *testing.T) {
- c := NewCache(10, 0)
+ c := NewMemoryCache(10, 0)
{
val, err := c.Get("test_key")
@@ -37,7 +37,7 @@ func TestCache(t *testing.T) {
}
})
t.Run("Value Evicted", func(t *testing.T) {
- c := NewCache(1, 0)
+ c := NewMemoryCache(1, 0)
{
err := c.Set("test_key_1", "test_val_1")
@@ -62,7 +62,7 @@ func TestCache(t *testing.T) {
})
t.Run("TTL expired", func(t *testing.T) {
- c := NewCache(10, 10*time.Millisecond)
+ c := NewMemoryCache(10, 10*time.Millisecond)
err := c.Set("test_key", "test_val")
require.NoError(t, err)
diff --git a/pkg/clients/middleware/caching_middleware_test.go b/pkg/clients/middleware/caching_middleware_test.go
index b842e118..2a90c1db 100644
--- a/pkg/clients/middleware/caching_middleware_test.go
+++ b/pkg/clients/middleware/caching_middleware_test.go
@@ -31,7 +31,7 @@ func TestClientsCache(t *testing.T) {
t.Run("Get from cache", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}, nil).Once()
@@ -52,7 +52,7 @@ func TestClientsCache(t *testing.T) {
t.Run("GetBy from cache", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("GetBy", mock.Anything, spaceID, &clients.GetByParams{OAuthClientID: clientID}).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}, nil).Once()
@@ -73,7 +73,7 @@ func TestClientsCache(t *testing.T) {
t.Run("List", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
@@ -92,7 +92,7 @@ func TestClientsCache(t *testing.T) {
t.Run("After Update", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}, nil).Once()
cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
@@ -143,7 +143,7 @@ func TestClientsCache(t *testing.T) {
t.Run("After Update(List)", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
@@ -172,7 +172,7 @@ func TestClientsCache(t *testing.T) {
t.Run("After Delete", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}, nil).Once()
cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
@@ -222,7 +222,7 @@ func TestClientsCache(t *testing.T) {
t.Run("After Delete(List)", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
@@ -250,7 +250,7 @@ func TestClientsCache(t *testing.T) {
t.Run("After Create", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1"}}, nil).Once()
@@ -279,7 +279,7 @@ func TestClientsCache(t *testing.T) {
t.Run("After Enable", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
tr := true
cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}, Disabled: &tr}, nil).Once()
@@ -329,7 +329,7 @@ func TestClientsCache(t *testing.T) {
t.Run("After Enable(List)", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
tr := true
cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}, Disabled: &tr}}, nil).Once()
@@ -359,7 +359,7 @@ func TestClientsCache(t *testing.T) {
t.Run("After TTL expired", func(t *testing.T) {
cs := &csmocks.Clients{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID}}, nil).Once()
cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID}}, nil).Once()
diff --git a/pkg/collaborators/middleware/caching_middleware_test.go b/pkg/collaborators/middleware/caching_middleware_test.go
index b7dc0928..ea2ccadd 100644
--- a/pkg/collaborators/middleware/caching_middleware_test.go
+++ b/pkg/collaborators/middleware/caching_middleware_test.go
@@ -31,7 +31,7 @@ func TestCollaboratorsCache(t *testing.T) {
t.Run("Get from cache", func(t *testing.T) {
cs := &csmocks.Collaborators{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("Get", mock.Anything, spaceID, userID).Return(spaceRole, nil).Once()
@@ -48,7 +48,7 @@ func TestCollaboratorsCache(t *testing.T) {
t.Run("ListCollaborators from cache", func(t *testing.T) {
cs := &csmocks.Collaborators{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("ListCollaborators", mock.Anything, spaceID).Return([]*collaborators.Collaborator{{SpaceID: spaceID, Subject: userID, Role: spaceRole}}, nil).Once()
@@ -64,7 +64,7 @@ func TestCollaboratorsCache(t *testing.T) {
t.Run("ListSpaces from cache", func(t *testing.T) {
cs := &csmocks.Collaborators{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("ListSpaces", mock.Anything, userID).Return([]*collaborators.Collaborator{{SpaceID: spaceID, Subject: userID, Role: spaceRole}}, nil).Once()
@@ -81,7 +81,7 @@ func TestCollaboratorsCache(t *testing.T) {
t.Run("After Remove", func(t *testing.T) {
cs := &csmocks.Collaborators{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("Get", mock.Anything, spaceID, userID).Return(spaceRole, nil).Once()
cs.On("ListCollaborators", mock.Anything, spaceID).Return([]*collaborators.Collaborator{{SpaceID: spaceID, Subject: userID, Role: spaceRole}}, nil).Once()
@@ -135,7 +135,7 @@ func TestCollaboratorsCache(t *testing.T) {
t.Run("After TTL expired", func(t *testing.T) {
cs := &csmocks.Collaborators{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
cs.On("Get", mock.Anything, spaceID, userID).Return(spaceRole, nil).Once()
cs.On("ListCollaborators", mock.Anything, spaceID).Return([]*collaborators.Collaborator{{SpaceID: spaceID, Subject: userID, Role: spaceRole}}, nil).Once()
diff --git a/pkg/collections/middleware/caching_middleware_test.go b/pkg/collections/middleware/caching_middleware_test.go
index c9e58b68..ac284ce5 100644
--- a/pkg/collections/middleware/caching_middleware_test.go
+++ b/pkg/collections/middleware/caching_middleware_test.go
@@ -36,7 +36,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
@@ -60,7 +60,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
col.On("Get", mock.Anything, spaceID, envAlias, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
@@ -84,7 +84,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
col.On("Get", mock.Anything, spaceID, envID, colID, mock.Anything).Run(func(args mock.Arguments) {
@@ -104,7 +104,7 @@ func TestCollections_Cache(t *testing.T) {
// col := &colsmocks.Collections{}
// env := &envmocks.Environments{}
//
- // svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ // svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
//
// col.On("List", mock.Anything, spaceID, envID).Return([]*collections.Collection{{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}}, nil).Once()
// env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
@@ -130,7 +130,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
col.On("List", mock.Anything, spaceID, envAlias, mock.Anything).Return([]*collections.Collection{{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}}, nil).Once()
col.On("List", mock.Anything, spaceID, envID, mock.Anything).Return([]*collections.Collection{{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}}, nil).Once()
@@ -150,7 +150,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
@@ -199,7 +199,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
//env.On("Get", mock.Anything, spaceID, envAlias).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
@@ -252,7 +252,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Twice()
col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
@@ -317,7 +317,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Twice()
col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
@@ -379,7 +379,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
//env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
col.On("List", mock.Anything, spaceID, envID, mock.Anything).Return([]*collections.Collection{{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}}, nil).Twice()
@@ -430,7 +430,7 @@ func TestCollections_Cache(t *testing.T) {
col := &colsmocks.Collections{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil)
col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
diff --git a/pkg/content/client.go b/pkg/content/client.go
index af5ba5bf..bbdd62bb 100644
--- a/pkg/content/client.go
+++ b/pkg/content/client.go
@@ -76,15 +76,15 @@ func NewClient(conn *grpc.ClientConn, opts ...Option) *Content {
func WithCaching(client *Content, size int, ttl time.Duration) *Content {
c := *client
- c.Clients = clientsSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Clients)
- c.Environments = environmentsSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Environments)
- c.Locales = localesSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Locales)
- c.Roles = rolesSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Roles)
- c.Spaces = spacesSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Spaces)
- c.Items = itemsSvc.CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), c.Environments)(client.Items)
- c.Collections = collectionsSvc.CachingMiddleware(cache.NewCache(size, ttl), c.Environments)(client.Collections)
- c.Collaborators = collaboratorsSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Collaborators)
- c.Invitations = invitationsSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Invitations)
+ c.Clients = clientsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Clients)
+ c.Environments = environmentsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Environments)
+ c.Locales = localesSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Locales)
+ c.Roles = rolesSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Roles)
+ c.Spaces = spacesSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Spaces)
+ c.Items = itemsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), c.Environments)(client.Items)
+ c.Collections = collectionsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl), c.Environments)(client.Collections)
+ c.Collaborators = collaboratorsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Collaborators)
+ c.Invitations = invitationsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Invitations)
return &c
}
diff --git a/pkg/delivery/client/client.go b/pkg/delivery/client/client.go
index 1de0dd68..e3fb962c 100644
--- a/pkg/delivery/client/client.go
+++ b/pkg/delivery/client/client.go
@@ -44,10 +44,10 @@ func NewClient(conn *grpc.ClientConn, opts ...Option) (delivery.Delivery, error)
func WithCaching(cfg *deliveryservice.Config, size int, ttl time.Duration) *deliveryservice.Config {
c := *cfg
- c.Environments = environments.CachingMiddleware(cache.NewCache(size, ttl))(cfg.Environments)
- c.Locales = locales.CachingMiddleware(cache.NewCache(size, ttl))(cfg.Locales)
- c.Items = items.CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), c.Environments)(cfg.Items)
- c.Collections = collections.CachingMiddleware(cache.NewCache(size, ttl), c.Environments)(cfg.Collections)
+ c.Environments = environments.CachingMiddleware(cache.NewMemoryCache(size, ttl))(cfg.Environments)
+ c.Locales = locales.CachingMiddleware(cache.NewMemoryCache(size, ttl))(cfg.Locales)
+ c.Items = items.CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), c.Environments)(cfg.Items)
+ c.Collections = collections.CachingMiddleware(cache.NewMemoryCache(size, ttl), c.Environments)(cfg.Collections)
return &c
}
diff --git a/pkg/environments/middleware/caching_middleware_test.go b/pkg/environments/middleware/caching_middleware_test.go
index 2e1b73a8..784ce356 100644
--- a/pkg/environments/middleware/caching_middleware_test.go
+++ b/pkg/environments/middleware/caching_middleware_test.go
@@ -31,7 +31,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("Get from cache", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}, nil).Once()
@@ -52,7 +52,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("Get from cache(by Alias)", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("Get", mock.Anything, spaceID, envAlias).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}, nil).Once()
@@ -73,7 +73,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("List from cache", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment"}}, nil).Once()
@@ -91,7 +91,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("After SetAlias", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{"envID2"}}, nil).Once()
envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{"envID2"}}}, nil).Once()
@@ -135,7 +135,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("After RemoveAlias", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{"envID2", envAlias}}, nil).Once()
envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{"envID2", envAlias}}}, nil).Once()
@@ -184,7 +184,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("After Update", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}, nil).Once()
envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}}, nil).Once()
@@ -235,7 +235,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("After Update(List)", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}}, nil).Once()
envs.On("Update", mock.Anything, mock.Anything).Return(nil).Once()
@@ -262,7 +262,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("After Delete", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}, nil).Once()
envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}}, nil).Once()
@@ -311,7 +311,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("After Create", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment"}}, nil).Once()
@@ -338,7 +338,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("After size exceeded", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(1, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(1, ttl))(envs)
envs.On("Get", mock.Anything, spaceID, "envID2").Return(&environments.Environment{ID: "envID2", SpaceID: spaceID, Description: "Environment2"}, nil).Once()
envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment"}, nil).Once()
@@ -364,7 +364,7 @@ func TestEnvironmentsCache(t *testing.T) {
t.Run("After TTL expired", func(t *testing.T) {
envs := &mocksenvironments.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment"}, nil).Once()
v1, err := svc.Get(ctx, spaceID, envID)
diff --git a/pkg/invitations/middleware/caching_middleware_test.go b/pkg/invitations/middleware/caching_middleware_test.go
index 8c83d76e..e7fac6f5 100644
--- a/pkg/invitations/middleware/caching_middleware_test.go
+++ b/pkg/invitations/middleware/caching_middleware_test.go
@@ -32,7 +32,7 @@ func TestLocalesCache(t *testing.T) {
t.Run("Get from Cache", func(t *testing.T) {
inv := &invmocks.Invitations{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(inv)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(inv)
inv.On("Get", mock.Anything, invID).Return(&invitations.Invitation{ID: invID, Email: email, OrgID: orgID}, nil).Once()
@@ -50,7 +50,7 @@ func TestLocalesCache(t *testing.T) {
t.Run("Get from Accept", func(t *testing.T) {
inv := &invmocks.Invitations{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(inv)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(inv)
inv.On("Get", mock.Anything, invID).Return(&invitations.Invitation{ID: invID, Email: email, OrgID: orgID}, nil).Once()
@@ -77,7 +77,7 @@ func TestLocalesCache(t *testing.T) {
t.Run("Get from Delete", func(t *testing.T) {
inv := &invmocks.Invitations{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(inv)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(inv)
inv.On("Get", mock.Anything, invID).Return(&invitations.Invitation{ID: invID, Email: email, OrgID: orgID}, nil).Once()
@@ -104,7 +104,7 @@ func TestLocalesCache(t *testing.T) {
t.Run("After TTL expired", func(t *testing.T) {
inv := &invmocks.Invitations{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(inv)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(inv)
inv.On("Get", mock.Anything, invID).Return(&invitations.Invitation{ID: invID, Email: email, OrgID: orgID}, nil).Once()
diff --git a/pkg/items/middleware/caching_middleware_test.go b/pkg/items/middleware/caching_middleware_test.go
index b7ea569d..c3e862b1 100644
--- a/pkg/items/middleware/caching_middleware_test.go
+++ b/pkg/items/middleware/caching_middleware_test.go
@@ -37,7 +37,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -61,7 +61,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envAlias, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -85,7 +85,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -109,7 +109,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("GetPublished", mock.Anything, spaceID, envAlias, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -138,7 +138,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Twice()
itms.On("GetPublished", mock.Anything, spaceID, envAlias, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -176,7 +176,7 @@ func TestItemsCache(t *testing.T) {
env := &envmocks.Environments{}
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, Data: map[string]interface{}{"f1": "d1"}}, nil).Once()
@@ -208,7 +208,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -241,7 +241,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -273,7 +273,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -313,7 +313,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -346,7 +346,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -379,7 +379,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, Data: map[string]interface{}{"f1": "d1"}}, nil).Once()
@@ -412,7 +412,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -445,7 +445,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished, Data: map[string]interface{}{"f1": "d1"}}, nil).Once()
@@ -486,7 +486,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -527,7 +527,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -568,7 +568,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -609,7 +609,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
@@ -657,7 +657,7 @@ func TestItemsCache(t *testing.T) {
itms := &itmsmocks.Items{}
env := &envmocks.Environments{}
- svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
diff --git a/pkg/locales/middleware/caching_middleware_test.go b/pkg/locales/middleware/caching_middleware_test.go
index d39e78d7..281aa496 100644
--- a/pkg/locales/middleware/caching_middleware_test.go
+++ b/pkg/locales/middleware/caching_middleware_test.go
@@ -28,7 +28,7 @@ func TestLocalesCache(t *testing.T) {
t.Run("List from Cache", func(t *testing.T) {
loc := &locmocks.Locales{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(loc)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(loc)
loc.On("List", mock.Anything, spaceID).Return([]*locales.Locale{{ID: loc1, Name: "name1", SpaceID: spaceID}}, nil).Once()
@@ -46,7 +46,7 @@ func TestLocalesCache(t *testing.T) {
t.Run("After Delete", func(t *testing.T) {
loc := &locmocks.Locales{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(loc)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(loc)
loc.On("List", mock.Anything, spaceID).Return([]*locales.Locale{{ID: loc1, Name: "name1", SpaceID: spaceID}}, nil).Once()
@@ -74,7 +74,7 @@ func TestLocalesCache(t *testing.T) {
t.Run("After Create", func(t *testing.T) {
loc := &locmocks.Locales{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(loc)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(loc)
loc.On("List", mock.Anything, spaceID).Return([]*locales.Locale{{ID: loc1, Name: "name1", SpaceID: spaceID}}, nil).Once()
@@ -106,7 +106,7 @@ func TestLocalesCache(t *testing.T) {
t.Run("After TTL expired", func(t *testing.T) {
loc := &locmocks.Locales{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(loc)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(loc)
loc.On("List", mock.Anything, spaceID).Return([]*locales.Locale{{ID: loc1, Name: "name1", SpaceID: spaceID}}, nil).Once()
diff --git a/pkg/members/middleware/caching_middleware_test.go b/pkg/members/middleware/caching_middleware_test.go
index 4564dbe4..eda7eb3a 100644
--- a/pkg/members/middleware/caching_middleware_test.go
+++ b/pkg/members/middleware/caching_middleware_test.go
@@ -26,7 +26,7 @@ func TestMembersCache(t *testing.T) {
t.Run("Get from cache", func(t *testing.T) {
mbrs := &mocksmembers.Members{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
@@ -43,7 +43,7 @@ func TestMembersCache(t *testing.T) {
t.Run("Invalidate cache", func(t *testing.T) {
t.Run("After Set", func(t *testing.T) {
mbrs := &mocksmembers.Members{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
@@ -69,7 +69,7 @@ func TestMembersCache(t *testing.T) {
t.Run("After Remove", func(t *testing.T) {
mbrs := &mocksmembers.Members{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
@@ -96,7 +96,7 @@ func TestMembersCache(t *testing.T) {
t.Run("After RemoveAll", func(t *testing.T) {
mbrs := &mocksmembers.Members{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
mbrs.On("ListMembers", mock.Anything, orgId).Return([]*members.Member{{OrgId: orgId, UserId: userId, Role: members.RoleOwner}}, nil)
@@ -124,7 +124,7 @@ func TestMembersCache(t *testing.T) {
t.Run("After TTL expired", func(t *testing.T) {
mbrs := &mocksmembers.Members{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
diff --git a/pkg/organizations/middleware/caching_middleware_test.go b/pkg/organizations/middleware/caching_middleware_test.go
index f468baf0..19cd14d5 100644
--- a/pkg/organizations/middleware/caching_middleware_test.go
+++ b/pkg/organizations/middleware/caching_middleware_test.go
@@ -28,7 +28,7 @@ func TestOrganizationsCache(t *testing.T) {
t.Run("Get from cache", func(t *testing.T) {
orgs := &mocksorgs.Organizations{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(orgs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(orgs)
orgs.On("Get", mock.Anything, orgId).Return(&organizations.Organization{ID: orgId, Name: "Organization"}, nil).Once()
@@ -45,7 +45,7 @@ func TestOrganizationsCache(t *testing.T) {
t.Run("Invalidate cache", func(t *testing.T) {
t.Run("After Update", func(t *testing.T) {
orgs := &mocksorgs.Organizations{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(orgs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(orgs)
orgs.On("Get", mock.Anything, orgId).Return(&organizations.Organization{ID: orgId, Name: "Organization"}, nil).Once()
@@ -70,7 +70,7 @@ func TestOrganizationsCache(t *testing.T) {
t.Run("After Delete", func(t *testing.T) {
orgs := &mocksorgs.Organizations{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(orgs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(orgs)
orgs.On("Get", mock.Anything, orgId).Return(&organizations.Organization{ID: orgId, Name: "Organization"}, nil).Once()
@@ -94,7 +94,7 @@ func TestOrganizationsCache(t *testing.T) {
t.Run("After TTL expired", func(t *testing.T) {
orgs := &mocksorgs.Organizations{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(orgs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(orgs)
orgs.On("Get", mock.Anything, orgId).Return(&organizations.Organization{ID: orgId, Name: "Organization"}, nil).Once()
diff --git a/pkg/roles/middleware/caching_middleware_test.go b/pkg/roles/middleware/caching_middleware_test.go
index ff0165f8..9d5d64f4 100644
--- a/pkg/roles/middleware/caching_middleware_test.go
+++ b/pkg/roles/middleware/caching_middleware_test.go
@@ -30,7 +30,7 @@ func TestRolesCache(t *testing.T) {
t.Run("Get from cache", func(t *testing.T) {
rl := &rsmocks.Roles{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
rl.On("Get", mock.Anything, spaceID, roleID).Return(&roles.Role{ID: roleID, SpaceID: spaceID, Description: "Role"}, nil).Once()
@@ -47,7 +47,7 @@ func TestRolesCache(t *testing.T) {
t.Run("List from cache", func(t *testing.T) {
rl := &rsmocks.Roles{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
rl.On("List", mock.Anything, spaceID).Return([]*roles.Role{{ID: roleID, SpaceID: spaceID, Description: "Role"}}, nil).Once()
@@ -65,7 +65,7 @@ func TestRolesCache(t *testing.T) {
t.Run("After Update", func(t *testing.T) {
rl := &rsmocks.Roles{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
rl.On("Get", mock.Anything, spaceID, roleID).Return(&roles.Role{ID: roleID, SpaceID: spaceID, Description: "Role"}, nil).Once()
rl.On("List", mock.Anything, spaceID).Return([]*roles.Role{{ID: roleID, SpaceID: spaceID, Description: "Role"}}, nil).Once()
@@ -106,7 +106,7 @@ func TestRolesCache(t *testing.T) {
t.Run("After Delete", func(t *testing.T) {
rl := &rsmocks.Roles{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
rl.On("Get", mock.Anything, spaceID, roleID).Return(&roles.Role{ID: roleID, SpaceID: spaceID, Description: "Role"}, nil).Once()
rl.On("List", mock.Anything, spaceID).Return([]*roles.Role{{ID: roleID, SpaceID: spaceID, Description: "Role"}}, nil).Once()
@@ -149,7 +149,7 @@ func TestRolesCache(t *testing.T) {
t.Run("After Create", func(t *testing.T) {
rl := &rsmocks.Roles{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
rl.On("List", mock.Anything, spaceID).Return([]*roles.Role{{ID: roleID, SpaceID: spaceID, Description: "Role"}}, nil).Once()
@@ -177,7 +177,7 @@ func TestRolesCache(t *testing.T) {
t.Run("After TTL expired", func(t *testing.T) {
rl := &rsmocks.Roles{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
rl.On("Get", mock.Anything, spaceID, roleID).Return(&roles.Role{ID: roleID, SpaceID: spaceID, Description: "Role"}, nil).Once()
diff --git a/pkg/spaces/middleware/caching_middleware_test.go b/pkg/spaces/middleware/caching_middleware_test.go
index a79a136f..e87ceb38 100644
--- a/pkg/spaces/middleware/caching_middleware_test.go
+++ b/pkg/spaces/middleware/caching_middleware_test.go
@@ -31,7 +31,7 @@ func TestRolesCache(t *testing.T) {
t.Run("Get from cache", func(t *testing.T) {
sp := &spmocks.Spaces{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
@@ -48,7 +48,7 @@ func TestRolesCache(t *testing.T) {
t.Run("List from cache", func(t *testing.T) {
sp := &spmocks.Spaces{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
@@ -66,7 +66,7 @@ func TestRolesCache(t *testing.T) {
t.Run("After Update", func(t *testing.T) {
sp := &spmocks.Spaces{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
@@ -107,7 +107,7 @@ func TestRolesCache(t *testing.T) {
t.Run("After UpdateConfig", func(t *testing.T) {
sp := &spmocks.Spaces{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
@@ -148,7 +148,7 @@ func TestRolesCache(t *testing.T) {
t.Run("After Delete", func(t *testing.T) {
sp := &spmocks.Spaces{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
@@ -189,7 +189,7 @@ func TestRolesCache(t *testing.T) {
t.Run("After Create", func(t *testing.T) {
sp := &spmocks.Spaces{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
@@ -217,7 +217,7 @@ func TestRolesCache(t *testing.T) {
t.Run("After TTL expired", func(t *testing.T) {
sp := &spmocks.Spaces{}
- svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
diff --git a/pkg/users/middleware/caching_middleware_test.go b/pkg/users/middleware/caching_middleware_test.go
index fde23379..edc9176b 100644
--- a/pkg/users/middleware/caching_middleware_test.go
+++ b/pkg/users/middleware/caching_middleware_test.go
@@ -29,7 +29,7 @@ func TestUsersCache(t *testing.T) {
usrs := &mocks.Users{}
ctx := context.Background()
- svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
usrs.On("Get", mock.Anything, userID).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()
@@ -51,7 +51,7 @@ func TestUsersCache(t *testing.T) {
usrs := &mocks.Users{}
ctx := context.Background()
- svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
usrs.On("GetByIdentity", mock.Anything, identity).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()
@@ -74,7 +74,7 @@ func TestUsersCache(t *testing.T) {
usrs := &mocks.Users{}
ctx := context.Background()
- svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
usrs.On("Get", mock.Anything, userID).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()
usrs.On("Update", mock.Anything, mock.Anything).Return(nil).Once()
@@ -107,7 +107,7 @@ func TestUsersCache(t *testing.T) {
usrs := &mocks.Users{}
ctx := context.Background()
- svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
usrs.On("Get", mock.Anything, userID).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()
usrs.On("Delete", mock.Anything, mock.Anything).Return(nil).Once()
@@ -140,7 +140,7 @@ func TestUsersCache(t *testing.T) {
usrs := &mocks.Users{}
ctx := context.Background()
- svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+ svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
usrs.On("Get", mock.Anything, userID).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()
--
GitLab