diff --git a/go.mod b/go.mod
index 4a9180b01abb0f615dd45a8455b6e2e2d36a538f..63de9afb6a6cab76b4b155e7f090d3dc470806b9 100644
--- a/go.mod
+++ b/go.mod
@@ -42,12 +42,14 @@ require (
github.com/gosimple/unidecode v1.0.1 // indirect
github.com/hashicorp/errwrap v1.1.0 // indirect
github.com/klauspost/compress v1.17.3 // indirect
+ github.com/kr/pretty v0.3.1 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/montanaflynn/stats v0.7.1 // indirect
github.com/nats-io/nkeys v0.4.6 // indirect
github.com/nats-io/nuid v1.0.1 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
+ github.com/rogpeppe/go-internal v1.10.0 // indirect
github.com/stretchr/objx v0.5.1 // indirect
github.com/xdg-go/pbkdf2 v1.0.0 // indirect
github.com/xdg-go/scram v1.1.2 // indirect
@@ -60,4 +62,5 @@ require (
golang.org/x/text v0.14.0 // indirect
google.golang.org/appengine v1.6.8 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20231106174013-bbf56f31fb17 // indirect
+ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
)
diff --git a/go.sum b/go.sum
index 99f21976387246e1c16c702e8a8ec8a3f613311b..3273d5c5392761e9f4e31b6736f355f3bd1eba6d 100644
--- a/go.sum
+++ b/go.sum
@@ -9,6 +9,7 @@ github.com/avast/retry-go/v4 v4.5.1 h1:AxIx0HGi4VZ3I02jr78j5lZ3M6x1E0Ivxa6b0pUUh
github.com/avast/retry-go/v4 v4.5.1/go.mod h1:/sipNsvNB3RRuT5iNcb6h73nw3IBmXJ/H3XrCQYSOpc=
github.com/bep/gowebp v0.2.0 h1:ZVfK8i9PpZqKHEmthQSt3qCnnHycbLzBPEsVtk2ch2Q=
github.com/bep/gowebp v0.2.0/go.mod h1:ZhFodwdiFp8ehGJpF4LdPl6unxZm9lLFjxD3z2h2AgI=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/davecgh/go-spew v0.0.0-20161028175848-04cdfd42973b/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -54,6 +55,13 @@ github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHm
github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
github.com/klauspost/compress v1.17.3 h1:qkRjuerhUU1EmXLYGkSH6EZL+vPSxIrYjLNAK4slzwA=
github.com/klauspost/compress v1.17.3/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/lucasb-eyer/go-colorful v1.0.2/go.mod h1:0MS4r+7BZKSJ5mw4/S5MPN+qHFF1fYclkSPilDOKW0s=
github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
@@ -74,6 +82,7 @@ github.com/nats-io/nkeys v0.4.6 h1:IzVe95ru2CT6ta874rt9saQRkWfe2nFj1NtvYSLqMzY=
github.com/nats-io/nkeys v0.4.6/go.mod h1:4DxZNzenSVd1cYQoAa8948QY3QDjrHfcfVADymtkpts=
github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -81,6 +90,9 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498/go.mod h1:6lkG1x+13OShEf0EaOCaTQYyB7d5nSbb181KtjlS+84=
github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
github.com/sanity-io/litter v1.2.0/go.mod h1:JF6pZUFgu2Q0sBZ+HSV35P8TVPI1TTzEwyu9FXAw2W4=
@@ -181,8 +193,9 @@ google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp0
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/pkg/account/client.go b/pkg/account/client.go
index 53ae9fb81924ec95370b3e9110de8fbfb93d3400..112a71f67fe130bb57c6483ad4793565bca8d0bd 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/cache.go b/pkg/cache/cache.go
index c71b426f00cbca17ca0b2597e222e3e2a57ea58d..e8feb4ce5309bfa92feec72c4624190a3c1e1c79 100644
--- a/pkg/cache/cache.go
+++ b/pkg/cache/cache.go
@@ -1,88 +1,7 @@
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
-)
-
-type Cache struct {
- cache *lru.Cache[interface{}, interface{}]
- ttl time.Duration
- logger *zap.Logger
-}
-
-type item struct {
- value interface{}
- expiredAt time.Time
-}
-
-func NewCache(size int, ttl time.Duration, opts ...interface{}) *Cache {
- if size == 0 {
- size = defaultCacheSize
- }
- if ttl == 0 {
- ttl = defaultTTL
- }
- c, err := lru.New[interface{}, interface{}](size)
- if err != nil {
- panic(err)
- }
- ch := &Cache{
- 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 *Cache) 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 *Cache) 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 *Cache) 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
+type Cache interface {
+ Set(key, value any) error
+ Get(key any) (any, error)
+ Remove(key any) error
}
diff --git a/pkg/cache/memory_cache.go b/pkg/cache/memory_cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..12b9b55812bbfb11646f828a4a3e643027687c4b
--- /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 b0d4304a499f0970cc695b667429c896763c1a33..b7cf246f6923f6fe131de760a5cbf3272fec2da1 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.go b/pkg/clients/middleware/caching_middleware.go
index 1733c0de4a8dde8f011d46b2b77005f8924e60bb..08af3a47a7cd3f23b8ae07e4050f9e18f1be1ee3 100644
--- a/pkg/clients/middleware/caching_middleware.go
+++ b/pkg/clients/middleware/caching_middleware.go
@@ -12,7 +12,7 @@ func makeKey(ss ...string) string {
return strings.Join(ss, "-")
}
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Clients) service.Clients {
return &cachingMiddleware{
cache: cache,
@@ -22,7 +22,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Clients
}
diff --git a/pkg/clients/middleware/caching_middleware_test.go b/pkg/clients/middleware/caching_middleware_test.go
index b842e1183a5425a4b3aec8d59b0720e5627767ed..2a90c1db2c322ca9509cb2bf9bdd63b252e67c68 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.go b/pkg/collaborators/middleware/caching_middleware.go
index ea595919431cd653e74ca0ffe24b62ff3b2d0a10..7533ae551ed47a421d3fe8ed643ce679e07fddc2 100644
--- a/pkg/collaborators/middleware/caching_middleware.go
+++ b/pkg/collaborators/middleware/caching_middleware.go
@@ -12,7 +12,7 @@ func makeKey(ss ...string) string {
return strings.Join(ss, "-")
}
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Collaborators) service.Collaborators {
return &cachingMiddleware{
cache: cache,
@@ -22,7 +22,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Collaborators
}
diff --git a/pkg/collaborators/middleware/caching_middleware_test.go b/pkg/collaborators/middleware/caching_middleware_test.go
index b7dc09281a9f972e9eafde3dd87ce628b0ea2fae..ea2ccaddb2621c306e317d6d873a455489a6a2a6 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.go b/pkg/collections/middleware/caching_middleware.go
index 469c39df98e1edb80495257999b6fecf81011247..de34d42af02f7259c66aea5799210c50c0e1961e 100644
--- a/pkg/collections/middleware/caching_middleware.go
+++ b/pkg/collections/middleware/caching_middleware.go
@@ -19,7 +19,7 @@ func makeKey(spaceId, envId, collectionId string, disableSchemaIncludes bool) st
return s
}
-func CachingMiddleware(cache *cache.Cache, envs envService.Environments) Middleware {
+func CachingMiddleware(cache cache.Cache, envs envService.Environments) Middleware {
return func(next service.Collections) service.Collections {
return &cachingMiddleware{
cache: cache,
@@ -30,7 +30,7 @@ func CachingMiddleware(cache *cache.Cache, envs envService.Environments) Middlew
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Collections
envs envService.Environments
}
diff --git a/pkg/collections/middleware/caching_middleware_test.go b/pkg/collections/middleware/caching_middleware_test.go
index c9e58b6886e121bf6b1f2edd37d9f4d9a69c9319..ac284ce5464af7469fee9ad4a7babf377b9c335a 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 af5ba5bf9956cfaa51e0636acff0d98c82edfb38..bbdd62bb9474afd54ce63606055c244311478adc 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 1de0dd684a2344264ad217c2834fbb74f19d837f..e3fb962c22cd76d4adc2cbd5ca9d6195eb9e41d6 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.go b/pkg/environments/middleware/caching_middleware.go
index dfe5b927117bfecdb56d11ab0e14582e43ef75b7..0801730a0e93947c847352a9710a02f85ae94ee0 100644
--- a/pkg/environments/middleware/caching_middleware.go
+++ b/pkg/environments/middleware/caching_middleware.go
@@ -12,7 +12,7 @@ func makeKey(ss ...string) string {
return strings.Join(ss, "-")
}
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Environments) service.Environments {
return &cachingMiddleware{
cache: cache,
@@ -22,7 +22,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Environments
}
diff --git a/pkg/environments/middleware/caching_middleware_test.go b/pkg/environments/middleware/caching_middleware_test.go
index 2e1b73a8366873dfb31b8d9fd24d31ac894025ee..784ce35632e2bcd74993ce499f4ec1db329041d7 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.go b/pkg/invitations/middleware/caching_middleware.go
index 651514a530039e7859fe146bd921c9d82e9ebd01..5f2a1086a15c09d55b5461e029036b091d68dcfe 100644
--- a/pkg/invitations/middleware/caching_middleware.go
+++ b/pkg/invitations/middleware/caching_middleware.go
@@ -8,7 +8,7 @@ import (
services "git.perx.ru/perxis/perxis-go/pkg/options"
)
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Invitations) service.Invitations {
return &cachingMiddleware{
cache: cache,
@@ -18,7 +18,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Invitations
}
diff --git a/pkg/invitations/middleware/caching_middleware_test.go b/pkg/invitations/middleware/caching_middleware_test.go
index 8c83d76ec0a35f1fa06e1065da3624ab3f7198e3..e7fac6f545463644ddd7476a43123f248b9a16b8 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.go b/pkg/items/middleware/caching_middleware.go
index 2d76f2150eeacc1cd70e9697c3db63853ef47908..6b11851381fb9dc13b630477052f05d4148bc765 100644
--- a/pkg/items/middleware/caching_middleware.go
+++ b/pkg/items/middleware/caching_middleware.go
@@ -13,7 +13,7 @@ func makeKey(ss ...string) string {
return strings.Join(ss, "-")
}
-func CachingMiddleware(cache, cachePublished *cache.Cache, envs envService.Environments) Middleware {
+func CachingMiddleware(cache, cachePublished cache.Cache, envs envService.Environments) Middleware {
return func(next service.Items) service.Items {
return &cachingMiddleware{
cache: cache,
@@ -25,8 +25,8 @@ func CachingMiddleware(cache, cachePublished *cache.Cache, envs envService.Envir
}
type cachingMiddleware struct {
- cache *cache.Cache
- cachePublished *cache.Cache
+ cache cache.Cache
+ cachePublished cache.Cache
envs envService.Environments
service.Items
}
diff --git a/pkg/items/middleware/caching_middleware_test.go b/pkg/items/middleware/caching_middleware_test.go
index b7ea569db094e7905b6aae2ce8bebfb381849f95..c3e862b1ffe3dd5e7fdde976cc4aa09e316a600f 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.go b/pkg/locales/middleware/caching_middleware.go
index 9d1624950aab3d798070844ed2e9d89142430c2c..13928a5166f2187e85a5e7da63861509e3f69d3a 100644
--- a/pkg/locales/middleware/caching_middleware.go
+++ b/pkg/locales/middleware/caching_middleware.go
@@ -7,7 +7,7 @@ import (
service "git.perx.ru/perxis/perxis-go/pkg/locales"
)
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Locales) service.Locales {
return &cachingMiddleware{
cache: cache,
@@ -17,7 +17,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Locales
}
diff --git a/pkg/locales/middleware/caching_middleware_test.go b/pkg/locales/middleware/caching_middleware_test.go
index d39e78d78e487c7c2c90f906559dee400aaa414b..281aa49611a83e4a0a28f1064dbf5fe149dd29f3 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.go b/pkg/members/middleware/caching_middleware.go
index cffbc7c46a35da518eee412044cc18c1e2aa9970..0af3f76f9e5aa1eeeee01c36f2e7509e35e951c3 100644
--- a/pkg/members/middleware/caching_middleware.go
+++ b/pkg/members/middleware/caching_middleware.go
@@ -12,7 +12,7 @@ func makeKey(ss ...string) string {
return strings.Join(ss, "-")
}
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Members) service.Members {
return &cachingMiddleware{
cache: cache,
@@ -22,7 +22,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Members
}
diff --git a/pkg/members/middleware/caching_middleware_test.go b/pkg/members/middleware/caching_middleware_test.go
index 4564dbe41a1fb943e86ad247a171497cffe01c18..eda7eb3a2a85123d36d20f09e9bd0c5188b609a9 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.go b/pkg/organizations/middleware/caching_middleware.go
index 8350fb9275f51461165062d1f5d759bd5a17241a..18649df9511f12a658cbb3966d507a76108939d8 100644
--- a/pkg/organizations/middleware/caching_middleware.go
+++ b/pkg/organizations/middleware/caching_middleware.go
@@ -8,7 +8,7 @@ import (
service "git.perx.ru/perxis/perxis-go/pkg/organizations"
)
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Organizations) service.Organizations {
return &cachingMiddleware{
cache: cache,
@@ -18,7 +18,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Organizations
}
diff --git a/pkg/organizations/middleware/caching_middleware_test.go b/pkg/organizations/middleware/caching_middleware_test.go
index f468baf0d6d3653e54f90856bf8731c2626ddc65..19cd14d5b2e808f3d4c22f77d8b115a27a9025cf 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.go b/pkg/roles/middleware/caching_middleware.go
index 86725074b2d211f916c8ec126ad866ca89a0cc56..3f46087ec59e3ee71cd441b87e16a995d82eb7ea 100644
--- a/pkg/roles/middleware/caching_middleware.go
+++ b/pkg/roles/middleware/caching_middleware.go
@@ -12,7 +12,7 @@ func makeKey(ss ...string) string {
return strings.Join(ss, "-")
}
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Roles) service.Roles {
return &cachingMiddleware{
cache: cache,
@@ -22,7 +22,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Roles
}
diff --git a/pkg/roles/middleware/caching_middleware_test.go b/pkg/roles/middleware/caching_middleware_test.go
index ff0165f8e9234d70d084a934d923b4e0b721ee0e..9d5d64f4231cf8bd86d533224fd50e762eebdcab 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.go b/pkg/spaces/middleware/caching_middleware.go
index 99c50a90e56fc8d25a34eca38962689f48f5abf3..f99e21a1f4a254ef6fb0890d09776b9b4738fd38 100644
--- a/pkg/spaces/middleware/caching_middleware.go
+++ b/pkg/spaces/middleware/caching_middleware.go
@@ -9,7 +9,7 @@ import (
func orgKey(orgID string) string { return "org-" + orgID }
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Spaces) service.Spaces {
m := &cachingMiddleware{
cache: cache,
@@ -21,7 +21,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Spaces
}
diff --git a/pkg/spaces/middleware/caching_middleware_test.go b/pkg/spaces/middleware/caching_middleware_test.go
index a79a136f41690d0a6c6a16709bb9a591e5688735..e87ceb38c79c6b15d76ab6f6ff8f628a680a5aa6 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.go b/pkg/users/middleware/caching_middleware.go
index c5674b82f0a1176304dc2efc0b60b7458839e347..8397bfd3a5c2a02c9ff52c42f9d1e23d431aed8e 100644
--- a/pkg/users/middleware/caching_middleware.go
+++ b/pkg/users/middleware/caching_middleware.go
@@ -8,7 +8,7 @@ import (
service "git.perx.ru/perxis/perxis-go/pkg/users"
)
-func CachingMiddleware(cache *cache.Cache) Middleware {
+func CachingMiddleware(cache cache.Cache) Middleware {
return func(next service.Users) service.Users {
return &cachingMiddleware{
cache: cache,
@@ -18,7 +18,7 @@ func CachingMiddleware(cache *cache.Cache) Middleware {
}
type cachingMiddleware struct {
- cache *cache.Cache
+ cache cache.Cache
next service.Users
}
diff --git a/pkg/users/middleware/caching_middleware_test.go b/pkg/users/middleware/caching_middleware_test.go
index fde23379bebd1957e7084fb7dc51ac45be467b59..edc9176baac6656a1d70995b0881055b83642293 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()