[MM 19840] Create a Cache Interface abstraction to support multiple cache backends (#13384)

* Refactor to use structured logging * Properly formatted with gofmt * created interface Cache, but construction of cache is still coupled. * Implementing cache factories to build caches * Simple redis implementation without error handling. Keys and values by default are string * refactor NewLocalCacheLayer to inject cache factory * Removed redis impl to focus on cache abstraction * CacheFactory injected on sqlsupplier and saved in Store struct * remove useless private method * replace concrete declaration of lru cache to cache abstraction * discard spaces * Renamed factory to provider because concrete implementations of factories may hold an state (such as a redis client for example) * refactor to include all caches in the same package cache and subpackages * method close cache. This method will be used for concrete implementations that need to release resources (close a connection, etc) * closing cacheprovider and releasing resources while closing sql store * fixed merge conflict fail * gofmt files * remove unused property from post_store * naming refactor to avoid stutter. Added godocs on interface * Store doesnt know anything about the cache and provider. Cache provider will be built after loading config and injected in localCacheLayer * fixed broken test * cache provider initialized before RunOldAppInitialization which initializes the localcachelayer * move statusCache to server to initialize it with the new cache provider * update terms_service and channel_layer to have new cacheProvider * gofmt * Add Connect method to the cache provider * mock cacheprovider in user_layer_test Co-authored-by: Ben Schumacher <ben.schumacher@mattermost.com> Co-authored-by: mattermod <mattermod@users.noreply.github.com>
2020-01-09 09:57:28 +01:00
--- a/store/localcachelayer/channel_layer_test.go
+++ b/store/localcachelayer/channel_layer_test.go
@@ -23,7 +23,8 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		count, err := cachedStore.Channel().GetMemberCount("id", true)
 		require.Nil(t, err)
@@ -37,7 +38,8 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {

 	t.Run("first call not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetMemberCount("id", true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
@@ -47,7 +49,8 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {

 	t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetMemberCount("id", false)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
@@ -59,7 +62,8 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {

 	t.Run("first call with GetMemberCountFromCache not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		count := cachedStore.Channel().GetMemberCountFromCache("id")
 		assert.Equal(t, count, countResult)
@@ -71,7 +75,8 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {

 	t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetMemberCount("id", true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
@@ -82,7 +87,8 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {

 	t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetMemberCount("id", true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
@@ -97,7 +103,8 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		count, err := cachedStore.Channel().GetPinnedPostCount("id", true)
 		require.Nil(t, err)
@@ -111,7 +118,8 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {

 	t.Run("first call not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetPinnedPostCount("id", true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
@@ -121,7 +129,8 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {

 	t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetPinnedPostCount("id", false)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
@@ -133,7 +142,8 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {

 	t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetPinnedPostCount("id", true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
@@ -144,7 +154,8 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {

 	t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetPinnedPostCount("id", true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
@@ -159,7 +170,8 @@ func TestChannelStoreGuestCountCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		count, err := cachedStore.Channel().GetGuestCount("id", true)
 		require.Nil(t, err)
@@ -173,7 +185,8 @@ func TestChannelStoreGuestCountCache(t *testing.T) {

 	t.Run("first call not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetGuestCount("id", true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
@@ -183,7 +196,8 @@ func TestChannelStoreGuestCountCache(t *testing.T) {

 	t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetGuestCount("id", false)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
@@ -195,7 +209,8 @@ func TestChannelStoreGuestCountCache(t *testing.T) {

 	t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetGuestCount("id", true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
@@ -206,7 +221,8 @@ func TestChannelStoreGuestCountCache(t *testing.T) {

 	t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().GetGuestCount("id", true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
@@ -221,7 +237,8 @@ func TestChannelStoreChannel(t *testing.T) {
 	fakeChannel := model.Channel{Id: channelId}
 	t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		channel, err := cachedStore.Channel().Get(channelId, true)
 		require.Nil(t, err)
@@ -235,7 +252,8 @@ func TestChannelStoreChannel(t *testing.T) {

 	t.Run("first call not cached, second force no cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().Get(channelId, true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
@@ -245,7 +263,8 @@ func TestChannelStoreChannel(t *testing.T) {

 	t.Run("first call force no cached, second not cached, third cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
 		cachedStore.Channel().Get(channelId, false)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
 		cachedStore.Channel().Get(channelId, true)
@@ -256,7 +275,8 @@ func TestChannelStoreChannel(t *testing.T) {

 	t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Channel().Get(channelId, true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
@@ -267,7 +287,8 @@ func TestChannelStoreChannel(t *testing.T) {

 	t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
 		cachedStore.Channel().Get(channelId, true)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
 		cachedStore.Channel().InvalidateChannel(channelId)
--- a/store/localcachelayer/emoji_layer_test.go
+++ b/store/localcachelayer/emoji_layer_test.go
@@ -22,7 +22,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		emoji, err := cachedStore.Emoji().Get("123", true)
 		require.Nil(t, err)
@@ -36,7 +37,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by name not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		emoji, err := cachedStore.Emoji().GetByName("name123", true)
 		require.Nil(t, err)
@@ -50,7 +52,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by id not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Emoji().Get("123", true)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
@@ -60,7 +63,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by name not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Emoji().GetByName("name123", true)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
@@ -70,7 +74,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by id force not cached, second not cached, third cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Emoji().Get("123", false)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
@@ -82,7 +87,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by name force not cached, second not cached, third cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Emoji().GetByName("name123", false)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
@@ -94,7 +100,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by id, second call by name cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Emoji().Get("123", true)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
@@ -104,7 +111,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by name, second call by id cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Emoji().GetByName("name123", true)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
@@ -114,7 +122,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by id not cached, invalidate, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Emoji().Get("123", true)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
@@ -125,7 +134,8 @@ func TestEmojiStoreCache(t *testing.T) {

 	t.Run("first call by name not cached, invalidate, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Emoji().GetByName("name123", true)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
--- a/store/localcachelayer/layer.go
+++ b/store/localcachelayer/layer.go
@@ -6,8 +6,8 @@ package localcachelayer
 import (
 	"github.com/mattermost/mattermost-server/v5/einterfaces"
 	"github.com/mattermost/mattermost-server/v5/model"
+	"github.com/mattermost/mattermost-server/v5/services/cache"
 	"github.com/mattermost/mattermost-server/v5/store"
-	"github.com/mattermost/mattermost-server/v5/utils"
 )

 const (
@@ -56,65 +56,74 @@ const (

 type LocalCacheStore struct {
 	store.Store
-	metrics                      einterfaces.MetricsInterface
-	cluster                      einterfaces.ClusterInterface
-	reaction                     LocalCacheReactionStore
-	reactionCache                *utils.Cache
-	role                         LocalCacheRoleStore
-	roleCache                    *utils.Cache
-	scheme                       LocalCacheSchemeStore
-	schemeCache                  *utils.Cache
-	emoji                        LocalCacheEmojiStore
-	emojiCacheById               *utils.Cache
-	emojiIdCacheByName           *utils.Cache
-	channel                      LocalCacheChannelStore
-	channelMemberCountsCache     *utils.Cache
-	channelGuestCountCache       *utils.Cache
-	channelPinnedPostCountsCache *utils.Cache
-	channelByIdCache             *utils.Cache
-	webhook                      LocalCacheWebhookStore
-	webhookCache                 *utils.Cache
-	post                         LocalCachePostStore
-	postLastPostsCache           *utils.Cache
-	lastPostTimeCache            *utils.Cache
-	user                         LocalCacheUserStore
-	userProfileByIdsCache        *utils.Cache
-	team                         LocalCacheTeamStore
-	teamAllTeamIdsForUserCache   *utils.Cache
-	termsOfService               LocalCacheTermsOfServiceStore
-	termsOfServiceCache          *utils.Cache
+	metrics            einterfaces.MetricsInterface
+	cluster            einterfaces.ClusterInterface
+	reaction           LocalCacheReactionStore
+	reactionCache      cache.Cache
+	role               LocalCacheRoleStore
+	roleCache          cache.Cache
+	scheme             LocalCacheSchemeStore
+	schemeCache        cache.Cache
+	emoji              LocalCacheEmojiStore
+	emojiCacheById     cache.Cache
+	emojiIdCacheByName cache.Cache
+	channel            LocalCacheChannelStore
+
+	channelMemberCountsCache     cache.Cache
+	channelGuestCountCache       cache.Cache
+	channelPinnedPostCountsCache cache.Cache
+	channelByIdCache             cache.Cache
+
+	webhook                    LocalCacheWebhookStore
+	webhookCache               cache.Cache
+	post                       LocalCachePostStore
+	postLastPostsCache         cache.Cache
+	lastPostTimeCache          cache.Cache
+	user                       LocalCacheUserStore
+	userProfileByIdsCache      cache.Cache
+	team                       LocalCacheTeamStore
+	teamAllTeamIdsForUserCache cache.Cache
+	termsOfService             LocalCacheTermsOfServiceStore
+	termsOfServiceCache        cache.Cache
 }

-func NewLocalCacheLayer(baseStore store.Store, metrics einterfaces.MetricsInterface, cluster einterfaces.ClusterInterface) LocalCacheStore {
+func NewLocalCacheLayer(baseStore store.Store, metrics einterfaces.MetricsInterface, cluster einterfaces.ClusterInterface, cacheProvider cache.Provider) LocalCacheStore {
+
 	localCacheStore := LocalCacheStore{
 		Store:   baseStore,
 		cluster: cluster,
 		metrics: metrics,
 	}
-	localCacheStore.reactionCache = utils.NewLruWithParams(REACTION_CACHE_SIZE, "Reaction", REACTION_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_REACTIONS)
+	localCacheStore.reactionCache = cacheProvider.NewCacheWithParams(REACTION_CACHE_SIZE, "Reaction", REACTION_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_REACTIONS)
 	localCacheStore.reaction = LocalCacheReactionStore{ReactionStore: baseStore.Reaction(), rootStore: &localCacheStore}
-	localCacheStore.roleCache = utils.NewLruWithParams(ROLE_CACHE_SIZE, "Role", ROLE_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_ROLES)
+	localCacheStore.roleCache = cacheProvider.NewCacheWithParams(ROLE_CACHE_SIZE, "Role", ROLE_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_ROLES)
 	localCacheStore.role = LocalCacheRoleStore{RoleStore: baseStore.Role(), rootStore: &localCacheStore}
-	localCacheStore.schemeCache = utils.NewLruWithParams(SCHEME_CACHE_SIZE, "Scheme", SCHEME_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_SCHEMES)
+	localCacheStore.schemeCache = cacheProvider.NewCacheWithParams(SCHEME_CACHE_SIZE, "Scheme", SCHEME_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_SCHEMES)
 	localCacheStore.scheme = LocalCacheSchemeStore{SchemeStore: baseStore.Scheme(), rootStore: &localCacheStore}
-	localCacheStore.webhookCache = utils.NewLruWithParams(WEBHOOK_CACHE_SIZE, "Webhook", WEBHOOK_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_WEBHOOKS)
+	localCacheStore.webhookCache = cacheProvider.NewCacheWithParams(WEBHOOK_CACHE_SIZE, "Webhook", WEBHOOK_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_WEBHOOKS)
 	localCacheStore.webhook = LocalCacheWebhookStore{WebhookStore: baseStore.Webhook(), rootStore: &localCacheStore}
-	localCacheStore.emojiCacheById = utils.NewLruWithParams(EMOJI_CACHE_SIZE, "EmojiById", EMOJI_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_EMOJIS_BY_ID)
-	localCacheStore.emojiIdCacheByName = utils.NewLruWithParams(EMOJI_CACHE_SIZE, "EmojiByName", EMOJI_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_EMOJIS_ID_BY_NAME)
+	localCacheStore.emojiCacheById = cacheProvider.NewCacheWithParams(EMOJI_CACHE_SIZE, "EmojiById", EMOJI_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_EMOJIS_BY_ID)
+	localCacheStore.emojiIdCacheByName = cacheProvider.NewCacheWithParams(EMOJI_CACHE_SIZE, "EmojiByName", EMOJI_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_EMOJIS_ID_BY_NAME)
 	localCacheStore.emoji = LocalCacheEmojiStore{EmojiStore: baseStore.Emoji(), rootStore: &localCacheStore}
-	localCacheStore.channelPinnedPostCountsCache = utils.NewLruWithParams(CHANNEL_PINNEDPOSTS_COUNTS_CACHE_SIZE, "ChannelPinnedPostsCounts", CHANNEL_PINNEDPOSTS_COUNTS_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_PINNEDPOSTS_COUNTS)
-	localCacheStore.channelMemberCountsCache = utils.NewLruWithParams(CHANNEL_MEMBERS_COUNTS_CACHE_SIZE, "ChannelMemberCounts", CHANNEL_MEMBERS_COUNTS_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBER_COUNTS)
-	localCacheStore.channelGuestCountCache = utils.NewLruWithParams(CHANNEL_GUEST_COUNT_CACHE_SIZE, "ChannelGuestsCount", CHANNEL_GUEST_COUNT_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_GUEST_COUNT)
-	localCacheStore.channelByIdCache = utils.NewLruWithParams(model.CHANNEL_CACHE_SIZE, "channelById", CHANNEL_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL)
+
+	localCacheStore.channelPinnedPostCountsCache = cacheProvider.NewCacheWithParams(CHANNEL_PINNEDPOSTS_COUNTS_CACHE_SIZE, "ChannelPinnedPostsCounts", CHANNEL_PINNEDPOSTS_COUNTS_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_PINNEDPOSTS_COUNTS)
+	localCacheStore.channelMemberCountsCache = cacheProvider.NewCacheWithParams(CHANNEL_MEMBERS_COUNTS_CACHE_SIZE, "ChannelMemberCounts", CHANNEL_MEMBERS_COUNTS_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBER_COUNTS)
+	localCacheStore.channelGuestCountCache = cacheProvider.NewCacheWithParams(CHANNEL_GUEST_COUNT_CACHE_SIZE, "ChannelGuestsCount", CHANNEL_GUEST_COUNT_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_GUEST_COUNT)
+	localCacheStore.channelByIdCache = cacheProvider.NewCacheWithParams(model.CHANNEL_CACHE_SIZE, "channelById", CHANNEL_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL)
+
 	localCacheStore.channel = LocalCacheChannelStore{ChannelStore: baseStore.Channel(), rootStore: &localCacheStore}
-	localCacheStore.lastPostTimeCache = utils.NewLruWithParams(LAST_POST_TIME_CACHE_SIZE, "LastPostTime", LAST_POST_TIME_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_LAST_POST_TIME)
-	localCacheStore.postLastPostsCache = utils.NewLruWithParams(LAST_POSTS_CACHE_SIZE, "LastPost", LAST_POSTS_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_LAST_POSTS)
+
+	localCacheStore.postLastPostsCache = cacheProvider.NewCacheWithParams(LAST_POSTS_CACHE_SIZE, "LastPost", LAST_POSTS_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_LAST_POSTS)
+	localCacheStore.lastPostTimeCache = cacheProvider.NewCacheWithParams(LAST_POST_TIME_CACHE_SIZE, "LastPostTime", LAST_POST_TIME_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_LAST_POST_TIME)
+
 	localCacheStore.post = LocalCachePostStore{PostStore: baseStore.Post(), rootStore: &localCacheStore}
-	localCacheStore.termsOfServiceCache = utils.NewLruWithParams(TERMS_OF_SERVICE_CACHE_SIZE, "TermsOfService", TERMS_OF_SERVICE_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_TERMS_OF_SERVICE)
+
+	localCacheStore.termsOfServiceCache = cacheProvider.NewCacheWithParams(TERMS_OF_SERVICE_CACHE_SIZE, "TermsOfService", TERMS_OF_SERVICE_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_TERMS_OF_SERVICE)
 	localCacheStore.termsOfService = LocalCacheTermsOfServiceStore{TermsOfServiceStore: baseStore.TermsOfService(), rootStore: &localCacheStore}
-	localCacheStore.userProfileByIdsCache = utils.NewLruWithParams(USER_PROFILE_BY_ID_CACHE_SIZE, "UserProfileByIds", USER_PROFILE_BY_ID_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_PROFILE_BY_IDS)
+	localCacheStore.userProfileByIdsCache = cacheProvider.NewCacheWithParams(USER_PROFILE_BY_ID_CACHE_SIZE, "UserProfileByIds", USER_PROFILE_BY_ID_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_PROFILE_BY_IDS)
+
 	localCacheStore.user = LocalCacheUserStore{UserStore: baseStore.User(), rootStore: &localCacheStore}
-	localCacheStore.teamAllTeamIdsForUserCache = utils.NewLruWithParams(TEAM_CACHE_SIZE, "Team", TEAM_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_TEAMS)
+	localCacheStore.teamAllTeamIdsForUserCache = cacheProvider.NewCacheWithParams(TEAM_CACHE_SIZE, "Team", TEAM_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_TEAMS)
 	localCacheStore.team = LocalCacheTeamStore{TeamStore: baseStore.Team(), rootStore: &localCacheStore}

 	if cluster != nil {
@@ -182,7 +191,7 @@ func (s LocalCacheStore) DropAllTables() {
 	s.Store.DropAllTables()
 }

-func (s *LocalCacheStore) doInvalidateCacheCluster(cache *utils.Cache, key string) {
+func (s *LocalCacheStore) doInvalidateCacheCluster(cache cache.Cache, key string) {
 	cache.Remove(key)
 	if s.cluster != nil {
 		msg := &model.ClusterMessage{
@@ -194,11 +203,11 @@ func (s *LocalCacheStore) doInvalidateCacheCluster(cache *utils.Cache, key strin
 	}
 }

-func (s *LocalCacheStore) doStandardAddToCache(cache *utils.Cache, key string, value interface{}) {
+func (s *LocalCacheStore) doStandardAddToCache(cache cache.Cache, key string, value interface{}) {
 	cache.AddWithDefaultExpires(key, value)
 }

-func (s *LocalCacheStore) doStandardReadCache(cache *utils.Cache, key string) interface{} {
+func (s *LocalCacheStore) doStandardReadCache(cache cache.Cache, key string) interface{} {
 	if cacheItem, ok := cache.Get(key); ok {
 		if s.metrics != nil {
 			s.metrics.IncrementMemCacheHitCounter(cache.Name())
@@ -213,7 +222,7 @@ func (s *LocalCacheStore) doStandardReadCache(cache *utils.Cache, key string) in
 	return nil
 }

-func (s *LocalCacheStore) doClearCacheCluster(cache *utils.Cache) {
+func (s *LocalCacheStore) doClearCacheCluster(cache cache.Cache) {
 	cache.Purge()
 	if s.cluster != nil {
 		msg := &model.ClusterMessage{
--- a/store/localcachelayer/layer_test.go
+++ b/store/localcachelayer/layer_test.go
@@ -71,7 +71,7 @@ func initStores() {
 		go func() {
 			defer wg.Done()
 			st.SqlSupplier = sqlstore.NewSqlSupplier(*st.SqlSettings, nil)
-			st.Store = NewLocalCacheLayer(st.SqlSupplier, nil, nil)
+			st.Store = NewLocalCacheLayer(st.SqlSupplier, nil, nil, getMockCacheProvider())
 			st.Store.DropAllTables()
 			st.Store.MarkSystemRanUnitTests()
 		}()
--- a/store/localcachelayer/main_test.go
+++ b/store/localcachelayer/main_test.go
@@ -8,13 +8,29 @@ import (
 	"testing"

 	"github.com/mattermost/mattermost-server/v5/model"
+	"github.com/mattermost/mattermost-server/v5/services/cache/lru"
 	"github.com/mattermost/mattermost-server/v5/store"
 	"github.com/mattermost/mattermost-server/v5/store/storetest/mocks"
 	"github.com/mattermost/mattermost-server/v5/testlib"
+	"github.com/stretchr/testify/mock"
 )

 var mainHelper *testlib.MainHelper

+func getMockCacheProvider() *mocks.CacheProvider {
+	mockCacheProvider := mocks.CacheProvider{}
+	//todo: replace this line with mocks for all tests
+	mockCache := lru.New(128)
+
+	mockCacheProvider.On("NewCacheWithParams",
+		mock.AnythingOfType("int"),
+		mock.AnythingOfType("string"),
+		mock.AnythingOfType("int64"),
+		mock.AnythingOfType("string")).Return(mockCache)
+
+	return &mockCacheProvider
+}
+
 func getMockStore() *mocks.Store {
 	mockStore := mocks.Store{}

--- a/store/localcachelayer/post_layer_test.go
+++ b/store/localcachelayer/post_layer_test.go
@@ -29,7 +29,8 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {

 	t.Run("GetEtag: first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		expectedResult := fmt.Sprintf("%v.%v", model.CurrentVersion, fakeLastTime)

@@ -44,7 +45,8 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {

 	t.Run("GetEtag: first call not cached, second force no cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Post().GetEtag(channelId, true)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 1)
@@ -54,7 +56,8 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {

 	t.Run("GetEtag: first call not cached, invalidate, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Post().GetEtag(channelId, true)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 1)
@@ -65,7 +68,8 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {

 	t.Run("GetEtag: first call not cached, clear caches, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Post().GetEtag(channelId, true)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 1)
@@ -76,7 +80,8 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {

 	t.Run("GetPostsSince: first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		expectedResult := model.NewPostList()

@@ -93,7 +98,8 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {

 	t.Run("GetPostsSince: first call not cached, second force no cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Post().GetPostsSince(fakeOptions, true)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
@@ -103,7 +109,8 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {

 	t.Run("GetPostsSince: first call not cached, invalidate, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Post().GetPostsSince(fakeOptions, true)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
@@ -114,7 +121,8 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {

 	t.Run("GetPostsSince: first call not cached, clear caches, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Post().GetPostsSince(fakeOptions, true)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
@@ -130,7 +138,8 @@ func TestPostStoreCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true)
 		require.Nil(t, err)
@@ -143,7 +152,8 @@ func TestPostStoreCache(t *testing.T) {

 	t.Run("first call not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true)
 		require.Nil(t, err)
@@ -156,7 +166,8 @@ func TestPostStoreCache(t *testing.T) {

 	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true)
 		require.Nil(t, err)
--- a/store/localcachelayer/reaction_layer_test.go
+++ b/store/localcachelayer/reaction_layer_test.go
@@ -22,7 +22,8 @@ func TestReactionStoreCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		reaction, err := cachedStore.Reaction().GetForPost("123", true)
 		require.Nil(t, err)
@@ -36,7 +37,8 @@ func TestReactionStoreCache(t *testing.T) {

 	t.Run("first call not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Reaction().GetForPost("123", true)
 		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)
@@ -46,7 +48,8 @@ func TestReactionStoreCache(t *testing.T) {

 	t.Run("first call not cached, save, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Reaction().GetForPost("123", true)
 		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)
@@ -57,7 +60,8 @@ func TestReactionStoreCache(t *testing.T) {

 	t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Reaction().GetForPost("123", true)
 		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)
--- a/store/localcachelayer/role_layer_test.go
+++ b/store/localcachelayer/role_layer_test.go
@@ -22,7 +22,8 @@ func TestRoleStoreCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		role, err := cachedStore.Role().GetByName("role-name")
 		require.Nil(t, err)
@@ -36,7 +37,8 @@ func TestRoleStoreCache(t *testing.T) {

 	t.Run("first call not cached, save, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Role().GetByName("role-name")
 		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)
@@ -47,7 +49,8 @@ func TestRoleStoreCache(t *testing.T) {

 	t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Role().GetByName("role-name")
 		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)
@@ -58,7 +61,8 @@ func TestRoleStoreCache(t *testing.T) {

 	t.Run("first call not cached, permanent delete all, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Role().GetByName("role-name")
 		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)
--- a/store/localcachelayer/scheme_layer_test.go
+++ b/store/localcachelayer/scheme_layer_test.go
@@ -22,7 +22,8 @@ func TestSchemeStoreCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		scheme, err := cachedStore.Scheme().Get("123")
 		require.Nil(t, err)
@@ -36,7 +37,8 @@ func TestSchemeStoreCache(t *testing.T) {

 	t.Run("first call not cached, save, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Scheme().Get("123")
 		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)
@@ -47,7 +49,8 @@ func TestSchemeStoreCache(t *testing.T) {

 	t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Scheme().Get("123")
 		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)
@@ -58,7 +61,8 @@ func TestSchemeStoreCache(t *testing.T) {

 	t.Run("first call not cached, permanent delete all, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Scheme().Get("123")
 		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)
--- a/store/localcachelayer/team_layer_test.go
+++ b/store/localcachelayer/team_layer_test.go
@@ -22,7 +22,8 @@ func TestTeamStoreCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotUserTeamIds, err := cachedStore.Team().GetUserTeamIds(fakeUserId, true)
 		require.Nil(t, err)
@@ -37,7 +38,8 @@ func TestTeamStoreCache(t *testing.T) {

 	t.Run("first call not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotUserTeamIds, err := cachedStore.Team().GetUserTeamIds(fakeUserId, true)
 		require.Nil(t, err)
@@ -52,7 +54,8 @@ func TestTeamStoreCache(t *testing.T) {

 	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotUserTeamIds, err := cachedStore.Team().GetUserTeamIds(fakeUserId, true)
 		require.Nil(t, err)
--- a/store/localcachelayer/terms_of_service_layer_test.go
+++ b/store/localcachelayer/terms_of_service_layer_test.go
@@ -23,7 +23,8 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {

 	t.Run("first call by latest not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		termsOfService, err := cachedStore.TermsOfService().GetLatest(true)
 		require.Nil(t, err)
@@ -37,7 +38,8 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {

 	t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		termsOfService, err := cachedStore.TermsOfService().Get("123", true)
 		require.Nil(t, err)
@@ -51,7 +53,8 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {

 	t.Run("first call by id not cached, second force no cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.TermsOfService().Get("123", true)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
@@ -61,7 +64,8 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {

 	t.Run("first call latest not cached, second force no cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.TermsOfService().GetLatest(true)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
@@ -71,7 +75,8 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {

 	t.Run("first call by id force no cached, second not cached, third cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.TermsOfService().Get("123", false)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
@@ -83,7 +88,8 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {

 	t.Run("first call latest force no cached, second not cached, third cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.TermsOfService().GetLatest(false)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
@@ -95,7 +101,8 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {

 	t.Run("first call latest, second call by id cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.TermsOfService().GetLatest(true)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
@@ -105,7 +112,8 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {

 	t.Run("first call by id not cached, save, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.TermsOfService().Get("123", false)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
@@ -116,7 +124,8 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {

 	t.Run("first get latest not cached, save new, then get latest, returning different data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.TermsOfService().GetLatest(true)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
--- a/store/localcachelayer/user_layer_test.go
+++ b/store/localcachelayer/user_layer_test.go
@@ -25,7 +25,8 @@ func TestUserStoreGetProfileByIdsCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotUser, err := cachedStore.User().GetProfileByIds(fakeUserIds, &store.UserGetByIdsOpts{}, true)
 		require.Nil(t, err)
@@ -38,7 +39,8 @@ func TestUserStoreGetProfileByIdsCache(t *testing.T) {

 	t.Run("first call not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotUser, err := cachedStore.User().GetProfileByIds(fakeUserIds, &store.UserGetByIdsOpts{}, true)
 		require.Nil(t, err)
@@ -51,7 +53,8 @@ func TestUserStoreGetProfileByIdsCache(t *testing.T) {

 	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotUser, err := cachedStore.User().GetProfileByIds(fakeUserIds, &store.UserGetByIdsOpts{}, true)
 		require.Nil(t, err)
@@ -71,7 +74,8 @@ func TestUserStoreGetCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotUser, err := cachedStore.User().Get(fakeUserId)
 		require.Nil(t, err)
@@ -84,7 +88,8 @@ func TestUserStoreGetCache(t *testing.T) {

 	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		gotUser, err := cachedStore.User().Get(fakeUserId)
 		require.Nil(t, err)
--- a/store/localcachelayer/webhook_layer_test.go
+++ b/store/localcachelayer/webhook_layer_test.go
@@ -23,7 +23,8 @@ func TestWebhookStoreCache(t *testing.T) {

 	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		incomingWebhook, err := cachedStore.Webhook().GetIncoming("123", true)
 		require.Nil(t, err)
@@ -37,7 +38,8 @@ func TestWebhookStoreCache(t *testing.T) {

 	t.Run("first call not cached, second force not cached", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Webhook().GetIncoming("123", true)
 		mockStore.Webhook().(*mocks.WebhookStore).AssertNumberOfCalls(t, "GetIncoming", 1)
@@ -47,7 +49,8 @@ func TestWebhookStoreCache(t *testing.T) {

 	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
 		mockStore := getMockStore()
-		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)

 		cachedStore.Webhook().GetIncoming("123", true)
 		mockStore.Webhook().(*mocks.WebhookStore).AssertNumberOfCalls(t, "GetIncoming", 1)
--- a/store/sqlstore/channel_store.go
+++ b/store/sqlstore/channel_store.go
@@ -18,8 +18,8 @@ import (
 	"github.com/mattermost/mattermost-server/v5/einterfaces"
 	"github.com/mattermost/mattermost-server/v5/mlog"
 	"github.com/mattermost/mattermost-server/v5/model"
+	"github.com/mattermost/mattermost-server/v5/services/cache/lru"
 	"github.com/mattermost/mattermost-server/v5/store"
-	"github.com/mattermost/mattermost-server/v5/utils"
 )

 const (
@@ -274,9 +274,9 @@ type publicChannel struct {
 	Purpose     string `json:"purpose"`
 }

-var allChannelMembersForUserCache = utils.NewLru(ALL_CHANNEL_MEMBERS_FOR_USER_CACHE_SIZE)
-var allChannelMembersNotifyPropsForChannelCache = utils.NewLru(ALL_CHANNEL_MEMBERS_NOTIFY_PROPS_FOR_CHANNEL_CACHE_SIZE)
-var channelByNameCache = utils.NewLru(model.CHANNEL_CACHE_SIZE)
+var allChannelMembersForUserCache = lru.New(ALL_CHANNEL_MEMBERS_FOR_USER_CACHE_SIZE)
+var allChannelMembersNotifyPropsForChannelCache = lru.New(ALL_CHANNEL_MEMBERS_NOTIFY_PROPS_FOR_CHANNEL_CACHE_SIZE)
+var channelByNameCache = lru.New(model.CHANNEL_CACHE_SIZE)

 func (s SqlChannelStore) ClearCaches() {
 	allChannelMembersForUserCache.Purge()
--- a/store/sqlstore/file_info_store.go
+++ b/store/sqlstore/file_info_store.go
@@ -11,8 +11,9 @@ import (

 	"github.com/mattermost/mattermost-server/v5/einterfaces"
 	"github.com/mattermost/mattermost-server/v5/model"
+	"github.com/mattermost/mattermost-server/v5/services/cache"
+	"github.com/mattermost/mattermost-server/v5/services/cache/lru"
 	"github.com/mattermost/mattermost-server/v5/store"
-	"github.com/mattermost/mattermost-server/v5/utils"
 )

 type SqlFileInfoStore struct {
@@ -25,7 +26,7 @@ const (
 	FILE_INFO_CACHE_SEC  = 1800 // 30 minutes
 )

-var fileInfoCache *utils.Cache = utils.NewLru(FILE_INFO_CACHE_SIZE)
+var fileInfoCache cache.Cache = lru.New(FILE_INFO_CACHE_SIZE)

 func (fs SqlFileInfoStore) ClearCaches() {
 	fileInfoCache.Purge()
--- a/store/sqlstore/user_store.go
+++ b/store/sqlstore/user_store.go
@@ -16,8 +16,9 @@ import (

 	"github.com/mattermost/mattermost-server/v5/einterfaces"
 	"github.com/mattermost/mattermost-server/v5/model"
+	"github.com/mattermost/mattermost-server/v5/services/cache"
+	"github.com/mattermost/mattermost-server/v5/services/cache/lru"
 	"github.com/mattermost/mattermost-server/v5/store"
-	"github.com/mattermost/mattermost-server/v5/utils"
 )

 const (
@@ -41,7 +42,7 @@ type SqlUserStore struct {
 	usersQuery sq.SelectBuilder
 }

-var profilesInChannelCache *utils.Cache = utils.NewLru(PROFILES_IN_CHANNEL_CACHE_SIZE)
+var profilesInChannelCache cache.Cache = lru.New(PROFILES_IN_CHANNEL_CACHE_SIZE)

 func (us SqlUserStore) ClearCaches() {
 	profilesInChannelCache.Purge()
--- a/store/storetest/mocks/Cache.go
+++ b/store/storetest/mocks/Cache.go
@@ -0,0 +1,145 @@
+// Code generated by mockery v1.0.0. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+
+	time "time"
+)
+
+// Cache is an autogenerated mock type for the Cache type
+type Cache struct {
+	mock.Mock
+}
+
+// Add provides a mock function with given fields: key, value
+func (_m *Cache) Add(key interface{}, value interface{}) {
+	_m.Called(key, value)
+}
+
+// AddWithDefaultExpires provides a mock function with given fields: key, value
+func (_m *Cache) AddWithDefaultExpires(key interface{}, value interface{}) {
+	_m.Called(key, value)
+}
+
+// AddWithExpiresInSecs provides a mock function with given fields: key, value, expireAtSecs
+func (_m *Cache) AddWithExpiresInSecs(key interface{}, value interface{}, expireAtSecs int64) {
+	_m.Called(key, value, expireAtSecs)
+}
+
+// Get provides a mock function with given fields: key
+func (_m *Cache) Get(key interface{}) (interface{}, bool) {
+	ret := _m.Called(key)
+
+	var r0 interface{}
+	if rf, ok := ret.Get(0).(func(interface{}) interface{}); ok {
+		r0 = rf(key)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(interface{})
+		}
+	}
+
+	var r1 bool
+	if rf, ok := ret.Get(1).(func(interface{}) bool); ok {
+		r1 = rf(key)
+	} else {
+		r1 = ret.Get(1).(bool)
+	}
+
+	return r0, r1
+}
+
+// GetInvalidateClusterEvent provides a mock function with given fields:
+func (_m *Cache) GetInvalidateClusterEvent() string {
+	ret := _m.Called()
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// GetOrAdd provides a mock function with given fields: key, value, ttl
+func (_m *Cache) GetOrAdd(key interface{}, value interface{}, ttl time.Duration) (interface{}, bool) {
+	ret := _m.Called(key, value, ttl)
+
+	var r0 interface{}
+	if rf, ok := ret.Get(0).(func(interface{}, interface{}, time.Duration) interface{}); ok {
+		r0 = rf(key, value, ttl)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(interface{})
+		}
+	}
+
+	var r1 bool
+	if rf, ok := ret.Get(1).(func(interface{}, interface{}, time.Duration) bool); ok {
+		r1 = rf(key, value, ttl)
+	} else {
+		r1 = ret.Get(1).(bool)
+	}
+
+	return r0, r1
+}
+
+// Keys provides a mock function with given fields:
+func (_m *Cache) Keys() []interface{} {
+	ret := _m.Called()
+
+	var r0 []interface{}
+	if rf, ok := ret.Get(0).(func() []interface{}); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]interface{})
+		}
+	}
+
+	return r0
+}
+
+// Len provides a mock function with given fields:
+func (_m *Cache) Len() int {
+	ret := _m.Called()
+
+	var r0 int
+	if rf, ok := ret.Get(0).(func() int); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+
+	return r0
+}
+
+// Name provides a mock function with given fields:
+func (_m *Cache) Name() string {
+	ret := _m.Called()
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// Purge provides a mock function with given fields:
+func (_m *Cache) Purge() {
+	_m.Called()
+}
+
+// Remove provides a mock function with given fields: key
+func (_m *Cache) Remove(key interface{}) {
+	_m.Called(key)
+}
--- a/store/storetest/mocks/CacheProvider.go
+++ b/store/storetest/mocks/CacheProvider.go
@@ -0,0 +1,57 @@
+// Code generated by mockery v1.0.0. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	cache "github.com/mattermost/mattermost-server/v5/services/cache"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// CacheProvider is an autogenerated mock type for the CacheProvider type
+type CacheProvider struct {
+	mock.Mock
+}
+
+// NewCache provides a mock function with given fields: size
+func (_m *CacheProvider) NewCache(size int) cache.Cache {
+	ret := _m.Called(size)
+
+	var r0 cache.Cache
+	if rf, ok := ret.Get(0).(func(int) cache.Cache); ok {
+		r0 = rf(size)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(cache.Cache)
+		}
+	}
+
+	return r0
+}
+
+// Connect provides a mock function with given fields:
+func (_m *CacheProvider) Connect() {
+	_m.Called()
+}
+
+// Close provides a mock function with given fields:
+func (_m *CacheProvider) Close() {
+	_m.Called()
+}
+
+// NewCacheWithParams provides a mock function with given fields: size, name, defaultExpiry, invalidateClusterEvent
+func (_m *CacheProvider) NewCacheWithParams(size int, name string, defaultExpiry int64, invalidateClusterEvent string) cache.Cache {
+	ret := _m.Called(size, name, defaultExpiry, invalidateClusterEvent)
+
+	var r0 cache.Cache
+	if rf, ok := ret.Get(0).(func(int, string, int64, string) cache.Cache); ok {
+		r0 = rf(size, name, defaultExpiry, invalidateClusterEvent)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(cache.Cache)
+		}
+	}
+
+	return r0
+}
--- a/store/storetest/store.go
+++ b/store/storetest/store.go
@@ -4,10 +4,9 @@
 package storetest

 import (
-	"github.com/stretchr/testify/mock"
-
 	"github.com/mattermost/mattermost-server/v5/store"
 	"github.com/mattermost/mattermost-server/v5/store/storetest/mocks"
+	"github.com/stretchr/testify/mock"
 )

 // Store can be used to provide mock stores for testing.