IntenseWebs/mattermost
3
0
Fork 0
mirror of https://github.com/mattermost/mattermost.git synced 2025-02-25 18:55:24 -06:00
Code Issues Packages Projects Releases Wiki Activity

Migrate emojiStore to use request.CTX instead of context.Context (#24514)

Browse Source 
* migrate emojistore to request.ctx

* use mlog.CreateConsoleTestLogger

* Add comment to WithMaster and RequestContextWithMaster
This commit is contained in:
Felipe Martin 2023-09-11 17:07:29 +02:00 committed by GitHub
parent e9cc03c1c8
commit f65dad83bb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 233 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
server/channels/app/emoji.go
View File

@ -5,7 +5,6 @@ package app
import ( import (
"bytes" "bytes"
"context"
"encoding/json" "encoding/json"
"errors" "errors"
"fmt" "fmt"
@ -60,7 +59,7 @@ func (a *App) CreateEmoji(c request.CTX, sessionUserId string, emoji *model.Emoj
return nil, model.NewAppError("createEmoji", "api.emoji.create.other_user.app_error", nil, "", http.StatusForbidden) return nil, model.NewAppError("createEmoji", "api.emoji.create.other_user.app_error", nil, "", http.StatusForbidden)
} }
if existingEmoji, err := a.Srv().Store().Emoji().GetByName(context.Background(), emoji.Name, true); err == nil && existingEmoji != nil { if existingEmoji, err := a.Srv().Store().Emoji().GetByName(c, emoji.Name, true); err == nil && existingEmoji != nil {
return nil, model.NewAppError("createEmoji", "api.emoji.create.duplicate.app_error", nil, "", http.StatusBadRequest).Wrap(err) return nil, model.NewAppError("createEmoji", "api.emoji.create.duplicate.app_error", nil, "", http.StatusBadRequest).Wrap(err)
} }
@ -191,7 +190,7 @@ func (a *App) GetEmoji(c request.CTX, emojiId string) (*model.Emoji, *model.AppE
return nil, model.NewAppError("GetEmoji", "api.emoji.storage.app_error", nil, "", http.StatusForbidden) return nil, model.NewAppError("GetEmoji", "api.emoji.storage.app_error", nil, "", http.StatusForbidden)
} }
emoji, err := a.Srv().Store().Emoji().Get(c.Context(), emojiId, true) emoji, err := a.Srv().Store().Emoji().Get(c, emojiId, true)
if err != nil { if err != nil {
var nfErr *store.ErrNotFound var nfErr *store.ErrNotFound
switch { switch {
@ -214,7 +213,7 @@ func (a *App) GetEmojiByName(c request.CTX, emojiName string) (*model.Emoji, *mo
return nil, model.NewAppError("GetEmojiByName", "api.emoji.storage.app_error", nil, "", http.StatusForbidden) return nil, model.NewAppError("GetEmojiByName", "api.emoji.storage.app_error", nil, "", http.StatusForbidden)
} }
emoji, err := a.Srv().Store().Emoji().GetByName(c.Context(), emojiName, true) emoji, err := a.Srv().Store().Emoji().GetByName(c, emojiName, true)
if err != nil { if err != nil {
var nfErr *store.ErrNotFound var nfErr *store.ErrNotFound
switch { switch {
@ -247,7 +246,7 @@ func (a *App) GetMultipleEmojiByName(c request.CTX, names []string) ([]*model.Em
return []*model.Emoji{}, nil return []*model.Emoji{}, nil
} }
emoji, err := a.Srv().Store().Emoji().GetMultipleByName(c.Context(), names) emoji, err := a.Srv().Store().Emoji().GetMultipleByName(c, names)
if err != nil { if err != nil {
return nil, model.NewAppError("GetMultipleEmojiByName", "app.emoji.get_by_name.app_error", nil, fmt.Sprintf("names=%v, %v", names, err.Error()), http.StatusInternalServerError) return nil, model.NewAppError("GetMultipleEmojiByName", "app.emoji.get_by_name.app_error", nil, fmt.Sprintf("names=%v, %v", names, err.Error()), http.StatusInternalServerError)
} }
@ -256,7 +255,7 @@ func (a *App) GetMultipleEmojiByName(c request.CTX, names []string) ([]*model.Em
} }
func (a *App) GetEmojiImage(c request.CTX, emojiId string) ([]byte, string, *model.AppError) { func (a *App) GetEmojiImage(c request.CTX, emojiId string) ([]byte, string, *model.AppError) {
_, storeErr := a.Srv().Store().Emoji().Get(c.Context(), emojiId, true) _, storeErr := a.Srv().Store().Emoji().Get(c, emojiId, true)
if storeErr != nil { if storeErr != nil {
var nfErr *store.ErrNotFound var nfErr *store.ErrNotFound
switch { switch {
@ -302,7 +301,7 @@ func (a *App) GetEmojiStaticURL(c request.CTX, emojiName string) (string, *model
return path.Join(subPath, "/static/emoji", id+".png"), nil return path.Join(subPath, "/static/emoji", id+".png"), nil
} }
emoji, err := a.Srv().Store().Emoji().GetByName(context.Background(), emojiName, true) emoji, err := a.Srv().Store().Emoji().GetByName(c, emojiName, true)
if err == nil { if err == nil {
return path.Join(subPath, "/api/v4/emoji", emoji.Id, "image"), nil return path.Join(subPath, "/api/v4/emoji", emoji.Id, "image"), nil
} }

2
server/channels/app/import_functions.go
View File

@ -1953,7 +1953,7 @@ func (a *App) importEmoji(c request.CTX, data *imports.EmojiImportData, dryRun b
var emoji *model.Emoji var emoji *model.Emoji
emoji, err := a.Srv().Store().Emoji().GetByName(context.Background(), *data.Name, true) emoji, err := a.Srv().Store().Emoji().GetByName(c, *data.Name, true)
if err != nil { if err != nil {
var nfErr *store.ErrNotFound var nfErr *store.ErrNotFound
if !errors.As(err, &nfErr) { if !errors.As(err, &nfErr) {

4
server/channels/app/import_functions_test.go
View File

@ -4168,7 +4168,7 @@ func TestImportImportEmoji(t *testing.T) {
appErr := th.App.importEmoji(th.Context, &data, true) appErr := th.App.importEmoji(th.Context, &data, true)
assert.NotNil(t, appErr, "Invalid emoji should have failed dry run") assert.NotNil(t, appErr, "Invalid emoji should have failed dry run")
emoji, nErr := th.App.Srv().Store().Emoji().GetByName(context.Background(), *data.Name, true) emoji, nErr := th.App.Srv().Store().Emoji().GetByName(th.Context, *data.Name, true)
assert.Nil(t, emoji, "Emoji should not have been imported") assert.Nil(t, emoji, "Emoji should not have been imported")
assert.Error(t, nErr) assert.Error(t, nErr)
@ -4188,7 +4188,7 @@ func TestImportImportEmoji(t *testing.T) {
appErr = th.App.importEmoji(th.Context, &data, false) appErr = th.App.importEmoji(th.Context, &data, false)
assert.Nil(t, appErr, "Valid emoji should have succeeded apply mode") assert.Nil(t, appErr, "Valid emoji should have succeeded apply mode")
emoji, nErr = th.App.Srv().Store().Emoji().GetByName(context.Background(), *data.Name, true) emoji, nErr = th.App.Srv().Store().Emoji().GetByName(th.Context, *data.Name, true)
assert.NotNil(t, emoji, "Emoji should have been imported") assert.NotNil(t, emoji, "Emoji should have been imported")
assert.NoError(t, nErr, "Emoji should have been imported without any error") assert.NoError(t, nErr, "Emoji should have been imported without any error")

46
server/channels/store/localcachelayer/channel_layer_test.go
View File

@ -22,7 +22,7 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {
countResult := int64(10) countResult := int64(10)
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -38,7 +38,7 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {
}) })
t.Run("first call not cached, second force not cached", func(t *testing.T) { t.Run("first call not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -50,7 +50,7 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {
}) })
t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) { t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -64,7 +64,7 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {
}) })
t.Run("first call with GetMemberCountFromCache not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call with GetMemberCountFromCache not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -78,7 +78,7 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {
}) })
t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) { t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -91,7 +91,7 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) { t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -111,7 +111,7 @@ func TestChannelStoreChannelsMemberCountCache(t *testing.T) {
} }
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -127,7 +127,7 @@ func TestChannelStoreChannelsMemberCountCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) { t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -145,7 +145,7 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {
countResult := int64(10) countResult := int64(10)
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -161,7 +161,7 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {
}) })
t.Run("first call not cached, second force not cached", func(t *testing.T) { t.Run("first call not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -173,7 +173,7 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {
}) })
t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) { t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -187,7 +187,7 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {
}) })
t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) { t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -200,7 +200,7 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) { t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -217,7 +217,7 @@ func TestChannelStoreGuestCountCache(t *testing.T) {
countResult := int64(12) countResult := int64(12)
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -233,7 +233,7 @@ func TestChannelStoreGuestCountCache(t *testing.T) {
}) })
t.Run("first call not cached, second force not cached", func(t *testing.T) { t.Run("first call not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -245,7 +245,7 @@ func TestChannelStoreGuestCountCache(t *testing.T) {
}) })
t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) { t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -259,7 +259,7 @@ func TestChannelStoreGuestCountCache(t *testing.T) {
}) })
t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) { t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -272,7 +272,7 @@ func TestChannelStoreGuestCountCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) { t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -289,7 +289,7 @@ func TestChannelStoreChannel(t *testing.T) {
channelId := "channel1" channelId := "channel1"
fakeChannel := model.Channel{Id: channelId} fakeChannel := model.Channel{Id: channelId}
t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -305,7 +305,7 @@ func TestChannelStoreChannel(t *testing.T) {
}) })
t.Run("first call not cached, second force no cached", func(t *testing.T) { t.Run("first call not cached, second force no cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -317,7 +317,7 @@ func TestChannelStoreChannel(t *testing.T) {
}) })
t.Run("first call force no cached, second not cached, third cached", func(t *testing.T) { t.Run("first call force no cached, second not cached, third cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -330,7 +330,7 @@ func TestChannelStoreChannel(t *testing.T) {
}) })
t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) { t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -343,7 +343,7 @@ func TestChannelStoreChannel(t *testing.T) {
}) })
t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) { t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

22
server/channels/store/localcachelayer/emoji_layer.go
View File

@ -5,10 +5,10 @@ package localcachelayer
import ( import (
"bytes" "bytes"
"context"
"sync" "sync"
"github.com/mattermost/mattermost/server/public/model" "github.com/mattermost/mattermost/server/public/model"
"github.com/mattermost/mattermost/server/public/shared/request"
"github.com/mattermost/mattermost/server/v8/channels/store" "github.com/mattermost/mattermost/server/v8/channels/store"
"github.com/mattermost/mattermost/server/v8/channels/store/sqlstore" "github.com/mattermost/mattermost/server/v8/channels/store/sqlstore"
) )
@ -44,7 +44,7 @@ func (es *LocalCacheEmojiStore) handleClusterInvalidateEmojiIdByName(msg *model.
} }
} }
func (es *LocalCacheEmojiStore) Get(ctx context.Context, id string, allowFromCache bool) (*model.Emoji, error) { func (es *LocalCacheEmojiStore) Get(c request.CTX, id string, allowFromCache bool) (*model.Emoji, error) {
if allowFromCache { if allowFromCache {
if emoji, ok := es.getFromCacheById(id); ok { if emoji, ok := es.getFromCacheById(id); ok {
return emoji, nil return emoji, nil
@ -55,12 +55,12 @@ func (es *LocalCacheEmojiStore) Get(ctx context.Context, id string, allowFromCac
es.emojiByIdMut.Lock() es.emojiByIdMut.Lock()
if es.emojiByIdInvalidations[id] { if es.emojiByIdInvalidations[id] {
// And then remove the key from the map. // And then remove the key from the map.
ctx = sqlstore.WithMaster(ctx) c = sqlstore.RequestContextWithMaster(c)
delete(es.emojiByIdInvalidations, id) delete(es.emojiByIdInvalidations, id)
} }
es.emojiByIdMut.Unlock() es.emojiByIdMut.Unlock()
emoji, err := es.EmojiStore.Get(ctx, id, allowFromCache) emoji, err := es.EmojiStore.Get(c, id, allowFromCache)
if allowFromCache && err == nil { if allowFromCache && err == nil {
es.addToCache(emoji) es.addToCache(emoji)
@ -69,9 +69,9 @@ func (es *LocalCacheEmojiStore) Get(ctx context.Context, id string, allowFromCac
return emoji, err return emoji, err
} }
func (es *LocalCacheEmojiStore) GetByName(ctx context.Context, name string, allowFromCache bool) (*model.Emoji, error) { func (es *LocalCacheEmojiStore) GetByName(c request.CTX, name string, allowFromCache bool) (*model.Emoji, error) {
if id, ok := model.GetSystemEmojiId(name); ok { if id, ok := model.GetSystemEmojiId(name); ok {
return es.Get(ctx, id, allowFromCache) return es.Get(c, id, allowFromCache)
} }
if allowFromCache { if allowFromCache {
@ -83,13 +83,13 @@ func (es *LocalCacheEmojiStore) GetByName(ctx context.Context, name string, allo
// If it was invalidated, then we need to query master. // If it was invalidated, then we need to query master.
es.emojiByNameMut.Lock() es.emojiByNameMut.Lock()
if es.emojiByNameInvalidations[name] { if es.emojiByNameInvalidations[name] {
ctx = sqlstore.WithMaster(ctx) c = sqlstore.RequestContextWithMaster(c)
// And then remove the key from the map. // And then remove the key from the map.
delete(es.emojiByNameInvalidations, name) delete(es.emojiByNameInvalidations, name)
} }
es.emojiByNameMut.Unlock() es.emojiByNameMut.Unlock()
emoji, err := es.EmojiStore.GetByName(ctx, name, allowFromCache) emoji, err := es.EmojiStore.GetByName(c, name, allowFromCache)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -101,7 +101,7 @@ func (es *LocalCacheEmojiStore) GetByName(ctx context.Context, name string, allo
return emoji, nil return emoji, nil
} }
func (es *LocalCacheEmojiStore) GetMultipleByName(ctx context.Context, names []string) ([]*model.Emoji, error) { func (es *LocalCacheEmojiStore) GetMultipleByName(c request.CTX, names []string) ([]*model.Emoji, error) {
emojis := []*model.Emoji{} emojis := []*model.Emoji{}
remainingEmojiNames := make([]string, 0) remainingEmojiNames := make([]string, 0)
@ -112,7 +112,7 @@ func (es *LocalCacheEmojiStore) GetMultipleByName(ctx context.Context, names []s
// If it was invalidated, then we need to query master. // If it was invalidated, then we need to query master.
es.emojiByNameMut.Lock() es.emojiByNameMut.Lock()
if es.emojiByNameInvalidations[name] { if es.emojiByNameInvalidations[name] {
ctx = sqlstore.WithMaster(ctx) c = sqlstore.RequestContextWithMaster(c)
// And then remove the key from the map. // And then remove the key from the map.
delete(es.emojiByNameInvalidations, name) delete(es.emojiByNameInvalidations, name)
} }
@ -123,7 +123,7 @@ func (es *LocalCacheEmojiStore) GetMultipleByName(ctx context.Context, names []s
} }
if len(remainingEmojiNames) > 0 { if len(remainingEmojiNames) > 0 {
remainingEmojis, err := es.EmojiStore.GetMultipleByName(ctx, remainingEmojiNames) remainingEmojis, err := es.EmojiStore.GetMultipleByName(c, remainingEmojiNames)
if err != nil { if err != nil {
return nil, err return nil, err
} }

106
server/channels/store/localcachelayer/emoji_layer_test.go
View File

@ -4,13 +4,13 @@
package localcachelayer package localcachelayer
import ( import (
"context"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/mattermost/mattermost/server/public/model" "github.com/mattermost/mattermost/server/public/model"
"github.com/mattermost/mattermost/server/public/shared/request"
"github.com/mattermost/mattermost/server/v8/channels/store/storetest" "github.com/mattermost/mattermost/server/v8/channels/store/storetest"
"github.com/mattermost/mattermost/server/v8/channels/store/storetest/mocks" "github.com/mattermost/mattermost/server/v8/channels/store/storetest/mocks"
) )
@ -25,49 +25,52 @@ func TestEmojiStoreCache(t *testing.T) {
ctxEmoji := model.Emoji{Id: "master", Name: "name123"} ctxEmoji := model.Emoji{Id: "master", Name: "name123"}
t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
emoji, err := cachedStore.Emoji().Get(context.Background(), "123", true) emoji, err := cachedStore.Emoji().Get(c, "123", true)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, emoji, &fakeEmoji) assert.Equal(t, emoji, &fakeEmoji)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
emoji, err = cachedStore.Emoji().Get(context.Background(), "123", true) emoji, err = cachedStore.Emoji().Get(c, "123", true)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, emoji, &fakeEmoji) assert.Equal(t, emoji, &fakeEmoji)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
}) })
t.Run("GetByName: first call by name not cached, second cached and returning same data", func(t *testing.T) { t.Run("GetByName: first call by name not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
emoji, err := cachedStore.Emoji().GetByName(context.Background(), "name123", true) emoji, err := cachedStore.Emoji().GetByName(c, "name123", true)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, emoji, &fakeEmoji) assert.Equal(t, emoji, &fakeEmoji)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
emoji, err = cachedStore.Emoji().GetByName(context.Background(), "name123", true) emoji, err = cachedStore.Emoji().GetByName(c, "name123", true)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, emoji, &fakeEmoji) assert.Equal(t, emoji, &fakeEmoji)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
}) })
t.Run("GetMultipleByName: first call by name not cached, second cached and returning same data", func(t *testing.T) { t.Run("GetMultipleByName: first call by name not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
emojis, err := cachedStore.Emoji().GetMultipleByName(context.Background(), []string{"name123"}) emojis, err := cachedStore.Emoji().GetMultipleByName(c, []string{"name123"})
require.NoError(t, err) require.NoError(t, err)
require.Len(t, emojis, 1) require.Len(t, emojis, 1)
assert.Equal(t, emojis[0], &fakeEmoji) assert.Equal(t, emojis[0], &fakeEmoji)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetMultipleByName", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetMultipleByName", 1)
emojis, err = cachedStore.Emoji().GetMultipleByName(context.Background(), []string{"name123"}) emojis, err = cachedStore.Emoji().GetMultipleByName(c, []string{"name123"})
require.NoError(t, err) require.NoError(t, err)
require.Len(t, emojis, 1) require.Len(t, emojis, 1)
assert.Equal(t, emojis[0], &fakeEmoji) assert.Equal(t, emojis[0], &fakeEmoji)
@ -75,18 +78,19 @@ func TestEmojiStoreCache(t *testing.T) {
}) })
t.Run("GetMultipleByName: multiple elements", func(t *testing.T) { t.Run("GetMultipleByName: multiple elements", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
emojis, err := cachedStore.Emoji().GetMultipleByName(context.Background(), []string{"name123", "name321"}) emojis, err := cachedStore.Emoji().GetMultipleByName(c, []string{"name123", "name321"})
require.NoError(t, err) require.NoError(t, err)
require.Len(t, emojis, 2) require.Len(t, emojis, 2)
assert.Equal(t, emojis[0], &fakeEmoji) assert.Equal(t, emojis[0], &fakeEmoji)
assert.Equal(t, emojis[1], &fakeEmoji2) assert.Equal(t, emojis[1], &fakeEmoji2)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetMultipleByName", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetMultipleByName", 1)
emojis, err = cachedStore.Emoji().GetMultipleByName(context.Background(), []string{"name123"}) emojis, err = cachedStore.Emoji().GetMultipleByName(c, []string{"name123"})
require.NoError(t, err) require.NoError(t, err)
require.Len(t, emojis, 1) require.Len(t, emojis, 1)
assert.Equal(t, emojis[0], &fakeEmoji) assert.Equal(t, emojis[0], &fakeEmoji)
@ -94,132 +98,142 @@ func TestEmojiStoreCache(t *testing.T) {
}) })
t.Run("first call by id not cached, second force not cached", func(t *testing.T) { t.Run("first call by id not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().Get(context.Background(), "123", true) cachedStore.Emoji().Get(c, "123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
cachedStore.Emoji().Get(context.Background(), "123", false) cachedStore.Emoji().Get(c, "123", false)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
}) })
t.Run("first call by name not cached, second force not cached", func(t *testing.T) { t.Run("first call by name not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().GetByName(context.Background(), "name123", true) cachedStore.Emoji().GetByName(c, "name123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
cachedStore.Emoji().GetByName(context.Background(), "name123", false) cachedStore.Emoji().GetByName(c, "name123", false)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
}) })
t.Run("first call by id force not cached, second not cached, third cached", func(t *testing.T) { t.Run("first call by id force not cached, second not cached, third cached", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().Get(context.Background(), "123", false) cachedStore.Emoji().Get(c, "123", false)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
cachedStore.Emoji().Get(context.Background(), "123", true) cachedStore.Emoji().Get(c, "123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
cachedStore.Emoji().Get(context.Background(), "123", true) cachedStore.Emoji().Get(c, "123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
}) })
t.Run("first call by name force not cached, second not cached, third cached", func(t *testing.T) { t.Run("first call by name force not cached, second not cached, third cached", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().GetByName(context.Background(), "name123", false) cachedStore.Emoji().GetByName(c, "name123", false)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
cachedStore.Emoji().GetByName(context.Background(), "name123", true) cachedStore.Emoji().GetByName(c, "name123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
cachedStore.Emoji().GetByName(context.Background(), "name123", true) cachedStore.Emoji().GetByName(c, "name123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
}) })
t.Run("first call by id, second call by name and GetMultipleByName cached", func(t *testing.T) { t.Run("first call by id, second call by name and GetMultipleByName cached", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().Get(context.Background(), "123", true) cachedStore.Emoji().Get(c, "123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
cachedStore.Emoji().GetByName(context.Background(), "name123", true) cachedStore.Emoji().GetByName(c, "name123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 0) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 0)
cachedStore.Emoji().GetMultipleByName(context.Background(), []string{"name123"}) cachedStore.Emoji().GetMultipleByName(c, []string{"name123"})
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetMultipleByName", 0) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetMultipleByName", 0)
}) })
t.Run("first call by name, second call by id cached", func(t *testing.T) { t.Run("first call by name, second call by id cached", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().GetByName(context.Background(), "name123", true) cachedStore.Emoji().GetByName(c, "name123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
cachedStore.Emoji().Get(context.Background(), "123", true) cachedStore.Emoji().Get(c, "123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 0) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 0)
}) })
t.Run("first call by id not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("first call by id not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().Get(context.Background(), "123", true) cachedStore.Emoji().Get(c, "123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
cachedStore.Emoji().Delete(&fakeEmoji, 0) cachedStore.Emoji().Delete(&fakeEmoji, 0)
cachedStore.Emoji().Get(context.Background(), "123", true) cachedStore.Emoji().Get(c, "123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
}) })
t.Run("call by id, use master", func(t *testing.T) { t.Run("call by id, use master", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().Get(context.Background(), "master", true) cachedStore.Emoji().Get(c, "master", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
cachedStore.Emoji().Delete(&ctxEmoji, 0) cachedStore.Emoji().Delete(&ctxEmoji, 0)
cachedStore.Emoji().Get(context.Background(), "master", true) cachedStore.Emoji().Get(c, "master", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
}) })
t.Run("first call by name not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("first call by name not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().GetByName(context.Background(), "name123", true) cachedStore.Emoji().GetByName(c, "name123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
cachedStore.Emoji().Delete(&fakeEmoji, 0) cachedStore.Emoji().Delete(&fakeEmoji, 0)
cachedStore.Emoji().GetByName(context.Background(), "name123", true) cachedStore.Emoji().GetByName(c, "name123", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
}) })
t.Run("call by name, use master", func(t *testing.T) { t.Run("call by name, use master", func(t *testing.T) {
mockStore := getMockStore() c := request.TestContext(t)
mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Emoji().GetByName(context.Background(), "master", true) cachedStore.Emoji().GetByName(c, "master", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
cachedStore.Emoji().Delete(&ctxEmoji, 0) cachedStore.Emoji().Delete(&ctxEmoji, 0)
cachedStore.Emoji().GetByName(context.Background(), "master", true) cachedStore.Emoji().GetByName(c, "master", true)
mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2) mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
}) })
} }

6
server/channels/store/localcachelayer/file_info_layer_test.go
View File

@ -22,7 +22,7 @@ func TestFileInfoStoreCache(t *testing.T) {
fakeFileInfo := model.FileInfo{PostId: "123"} fakeFileInfo := model.FileInfo{PostId: "123"}
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -37,7 +37,7 @@ func TestFileInfoStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, second force no cached", func(t *testing.T) { t.Run("first call not cached, second force no cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -49,7 +49,7 @@ func TestFileInfoStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

15
server/channels/store/localcachelayer/main_test.go
View File

@ -11,6 +11,7 @@ import (
"github.com/stretchr/testify/mock" "github.com/stretchr/testify/mock"
"github.com/mattermost/mattermost/server/public/model" "github.com/mattermost/mattermost/server/public/model"
"github.com/mattermost/mattermost/server/public/shared/request"
"github.com/mattermost/mattermost/server/v8/channels/store" "github.com/mattermost/mattermost/server/v8/channels/store"
"github.com/mattermost/mattermost/server/v8/channels/store/sqlstore" "github.com/mattermost/mattermost/server/v8/channels/store/sqlstore"
"github.com/mattermost/mattermost/server/v8/channels/store/storetest/mocks" "github.com/mattermost/mattermost/server/v8/channels/store/storetest/mocks"
@ -28,7 +29,7 @@ func getMockCacheProvider() cache.Provider {
return &mockCacheProvider return &mockCacheProvider
} }
func getMockStore() *mocks.Store { func getMockStore(t *testing.T) *mocks.Store {
mockStore := mocks.Store{} mockStore := mocks.Store{}
fakeReaction := model.Reaction{PostId: "123"} fakeReaction := model.Reaction{PostId: "123"}
@ -74,14 +75,14 @@ func getMockStore() *mocks.Store {
mockEmojiStore := mocks.EmojiStore{} mockEmojiStore := mocks.EmojiStore{}
mockEmojiStore.On("Get", mock.Anything, "123", true).Return(&fakeEmoji, nil) mockEmojiStore.On("Get", mock.Anything, "123", true).Return(&fakeEmoji, nil)
mockEmojiStore.On("Get", mock.Anything, "123", false).Return(&fakeEmoji, nil) mockEmojiStore.On("Get", mock.Anything, "123", false).Return(&fakeEmoji, nil)
mockEmojiStore.On("Get", context.Background(), "master", true).Return(&ctxEmoji, nil) mockEmojiStore.On("Get", mock.IsType(&request.Context{}), "master", true).Return(&ctxEmoji, nil)
mockEmojiStore.On("Get", sqlstore.WithMaster(context.Background()), "master", true).Return(&ctxEmoji, nil) mockEmojiStore.On("Get", sqlstore.RequestContextWithMaster(request.TestContext(t)), "master", true).Return(&ctxEmoji, nil)
mockEmojiStore.On("GetByName", mock.Anything, "name123", true).Return(&fakeEmoji, nil) mockEmojiStore.On("GetByName", mock.Anything, "name123", true).Return(&fakeEmoji, nil)
mockEmojiStore.On("GetByName", mock.Anything, "name123", false).Return(&fakeEmoji, nil) mockEmojiStore.On("GetByName", mock.Anything, "name123", false).Return(&fakeEmoji, nil)
mockEmojiStore.On("GetMultipleByName", context.Background(), []string{"name123"}).Return([]*model.Emoji{&fakeEmoji}, nil) mockEmojiStore.On("GetMultipleByName", mock.IsType(&request.Context{}), []string{"name123"}).Return([]*model.Emoji{&fakeEmoji}, nil)
mockEmojiStore.On("GetMultipleByName", context.Background(), []string{"name123", "name321"}).Return([]*model.Emoji{&fakeEmoji, &fakeEmoji2}, nil) mockEmojiStore.On("GetMultipleByName", mock.IsType(&request.Context{}), []string{"name123", "name321"}).Return([]*model.Emoji{&fakeEmoji, &fakeEmoji2}, nil)
mockEmojiStore.On("GetByName", context.Background(), "master", true).Return(&ctxEmoji, nil) mockEmojiStore.On("GetByName", mock.IsType(&request.Context{}), "master", true).Return(&ctxEmoji, nil)
mockEmojiStore.On("GetByName", sqlstore.WithMaster(context.Background()), "master", false).Return(&ctxEmoji, nil) mockEmojiStore.On("GetByName", sqlstore.RequestContextWithMaster(request.TestContext(t)), "master", false).Return(&ctxEmoji, nil)
mockEmojiStore.On("Delete", &fakeEmoji, int64(0)).Return(nil) mockEmojiStore.On("Delete", &fakeEmoji, int64(0)).Return(nil)
mockEmojiStore.On("Delete", &ctxEmoji, int64(0)).Return(nil) mockEmojiStore.On("Delete", &ctxEmoji, int64(0)).Return(nil)
mockStore.On("Emoji").Return(&mockEmojiStore) mockStore.On("Emoji").Return(&mockEmojiStore)

22
server/channels/store/localcachelayer/post_layer_test.go
View File

@ -29,7 +29,7 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
} }
t.Run("GetEtag: first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("GetEtag: first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -46,7 +46,7 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
}) })
t.Run("GetEtag: first call not cached, second force no cached", func(t *testing.T) { t.Run("GetEtag: first call not cached, second force no cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -58,7 +58,7 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
}) })
t.Run("GetEtag: first call not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("GetEtag: first call not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -71,7 +71,7 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
}) })
t.Run("GetEtag: first call not cached, clear caches, and then not cached again", func(t *testing.T) { t.Run("GetEtag: first call not cached, clear caches, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -84,7 +84,7 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
}) })
t.Run("GetPostsSince: first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("GetPostsSince: first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -103,7 +103,7 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
}) })
t.Run("GetPostsSince: first call not cached, second force no cached", func(t *testing.T) { t.Run("GetPostsSince: first call not cached, second force no cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -115,7 +115,7 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
}) })
t.Run("GetPostsSince: first call not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("GetPostsSince: first call not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -128,7 +128,7 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
}) })
t.Run("GetPostsSince: first call not cached, clear caches, and then not cached again", func(t *testing.T) { t.Run("GetPostsSince: first call not cached, clear caches, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -146,7 +146,7 @@ func TestPostStoreCache(t *testing.T) {
fakeOptions := model.GetPostsOptions{ChannelId: "123", PerPage: 30} fakeOptions := model.GetPostsOptions{ChannelId: "123", PerPage: 30}
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -161,7 +161,7 @@ func TestPostStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, second force not cached", func(t *testing.T) { t.Run("first call not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -176,7 +176,7 @@ func TestPostStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

8
server/channels/store/localcachelayer/reaction_layer_test.go
View File

@ -22,7 +22,7 @@ func TestReactionStoreCache(t *testing.T) {
fakeReaction := model.Reaction{PostId: "123"} fakeReaction := model.Reaction{PostId: "123"}
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -37,7 +37,7 @@ func TestReactionStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, second force not cached", func(t *testing.T) { t.Run("first call not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -49,7 +49,7 @@ func TestReactionStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, save, and then not cached again", func(t *testing.T) { t.Run("first call not cached, save, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -62,7 +62,7 @@ func TestReactionStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) { t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

8
server/channels/store/localcachelayer/role_layer_test.go
View File

@ -23,7 +23,7 @@ func TestRoleStoreCache(t *testing.T) {
fakeRole := model.Role{Id: "123", Name: "role-name"} fakeRole := model.Role{Id: "123", Name: "role-name"}
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -39,7 +39,7 @@ func TestRoleStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, save, and then not cached again", func(t *testing.T) { t.Run("first call not cached, save, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -52,7 +52,7 @@ func TestRoleStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) { t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -65,7 +65,7 @@ func TestRoleStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, permanent delete all, and then not cached again", func(t *testing.T) { t.Run("first call not cached, permanent delete all, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

8
server/channels/store/localcachelayer/scheme_layer_test.go
View File

@ -22,7 +22,7 @@ func TestSchemeStoreCache(t *testing.T) {
fakeScheme := model.Scheme{Id: "123", Name: "scheme-name"} fakeScheme := model.Scheme{Id: "123", Name: "scheme-name"}
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -38,7 +38,7 @@ func TestSchemeStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, save, and then not cached again", func(t *testing.T) { t.Run("first call not cached, save, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -51,7 +51,7 @@ func TestSchemeStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) { t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -64,7 +64,7 @@ func TestSchemeStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, permanent delete all, and then not cached again", func(t *testing.T) { t.Run("first call not cached, permanent delete all, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

6
server/channels/store/localcachelayer/team_layer_test.go
View File

@ -22,7 +22,7 @@ func TestTeamStoreCache(t *testing.T) {
fakeUserTeamIds := []string{"1", "2", "3"} fakeUserTeamIds := []string{"1", "2", "3"}
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -39,7 +39,7 @@ func TestTeamStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, second force not cached", func(t *testing.T) { t.Run("first call not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -56,7 +56,7 @@ func TestTeamStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

18
server/channels/store/localcachelayer/terms_of_service_layer_test.go
View File

@ -23,7 +23,7 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
fakeTermsOfService := model.TermsOfService{Id: "123", CreateAt: 11111, UserId: "321", Text: "Terms of service test"} fakeTermsOfService := model.TermsOfService{Id: "123", CreateAt: 11111, UserId: "321", Text: "Terms of service test"}
t.Run("first call by latest not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call by latest not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -39,7 +39,7 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
}) })
t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -55,7 +55,7 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
}) })
t.Run("first call by id not cached, second force no cached", func(t *testing.T) { t.Run("first call by id not cached, second force no cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -67,7 +67,7 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
}) })
t.Run("first call latest not cached, second force no cached", func(t *testing.T) { t.Run("first call latest not cached, second force no cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -79,7 +79,7 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
}) })
t.Run("first call by id force no cached, second not cached, third cached", func(t *testing.T) { t.Run("first call by id force no cached, second not cached, third cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -93,7 +93,7 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
}) })
t.Run("first call latest force no cached, second not cached, third cached", func(t *testing.T) { t.Run("first call latest force no cached, second not cached, third cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -107,7 +107,7 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
}) })
t.Run("first call latest, second call by id cached", func(t *testing.T) { t.Run("first call latest, second call by id cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -119,7 +119,7 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
}) })
t.Run("first call by id not cached, save, and then not cached again", func(t *testing.T) { t.Run("first call by id not cached, save, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -132,7 +132,7 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
}) })
t.Run("first get latest not cached, save new, then get latest, returning different data", func(t *testing.T) { t.Run("first get latest not cached, save new, then get latest, returning different data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

26
server/channels/store/localcachelayer/user_layer_test.go
View File

@ -30,7 +30,7 @@ func TestUserStoreCache(t *testing.T) {
}} }}
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -45,7 +45,7 @@ func TestUserStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, second force not cached", func(t *testing.T) { t.Run("first call not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -60,7 +60,7 @@ func TestUserStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -76,7 +76,7 @@ func TestUserStoreCache(t *testing.T) {
}) })
t.Run("should always return a copy of the stored data", func(t *testing.T) { t.Run("should always return a copy of the stored data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -126,7 +126,7 @@ func TestUserStoreProfilesInChannelCache(t *testing.T) {
} }
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -141,7 +141,7 @@ func TestUserStoreProfilesInChannelCache(t *testing.T) {
}) })
t.Run("first call not cached, second force not cached", func(t *testing.T) { t.Run("first call not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -156,7 +156,7 @@ func TestUserStoreProfilesInChannelCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate by channel, and then not cached again", func(t *testing.T) { t.Run("first call not cached, invalidate by channel, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -173,7 +173,7 @@ func TestUserStoreProfilesInChannelCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate by user, and then not cached again", func(t *testing.T) { t.Run("first call not cached, invalidate by user, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -198,7 +198,7 @@ func TestUserStoreGetCache(t *testing.T) {
AuthService: "authService", AuthService: "authService",
} }
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -213,7 +213,7 @@ func TestUserStoreGetCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -230,7 +230,7 @@ func TestUserStoreGetCache(t *testing.T) {
}) })
t.Run("should always return a copy of the stored data", func(t *testing.T) { t.Run("should always return a copy of the stored data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -273,7 +273,7 @@ func TestUserStoreGetManyCache(t *testing.T) {
AuthService: "authService", AuthService: "authService",
} }
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -291,7 +291,7 @@ func TestUserStoreGetManyCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate one user, and then check that one is cached and one is fetched from db", func(t *testing.T) { t.Run("first call not cached, invalidate one user, and then check that one is cached and one is fetched from db", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

6
server/channels/store/localcachelayer/webhook_layer_test.go
View File

@ -22,7 +22,7 @@ func TestWebhookStoreCache(t *testing.T) {
fakeWebhook := model.IncomingWebhook{Id: "123"} fakeWebhook := model.IncomingWebhook{Id: "123"}
t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -38,7 +38,7 @@ func TestWebhookStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, second force not cached", func(t *testing.T) { t.Run("first call not cached, second force not cached", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
@ -50,7 +50,7 @@ func TestWebhookStoreCache(t *testing.T) {
}) })
t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) { t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
mockStore := getMockStore() mockStore := getMockStore(t)
mockCacheProvider := getMockCacheProvider() mockCacheProvider := getMockCacheProvider()
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)

6
server/channels/store/opentracinglayer/opentracinglayer.go
View File

@ -3425,7 +3425,7 @@ func (s *OpenTracingLayerEmojiStore) Delete(emoji *model.Emoji, timestamp int64)
return err return err
} }
func (s *OpenTracingLayerEmojiStore) Get(ctx context.Context, id string, allowFromCache bool) (*model.Emoji, error) { func (s *OpenTracingLayerEmojiStore) Get(ctx request.CTX, id string, allowFromCache bool) (*model.Emoji, error) {
origCtx := s.Root.Store.Context() origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "EmojiStore.Get") span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "EmojiStore.Get")
s.Root.Store.SetContext(newCtx) s.Root.Store.SetContext(newCtx)
@ -3443,7 +3443,7 @@ func (s *OpenTracingLayerEmojiStore) Get(ctx context.Context, id string, allowFr
return result, err return result, err
} }
func (s *OpenTracingLayerEmojiStore) GetByName(ctx context.Context, name string, allowFromCache bool) (*model.Emoji, error) { func (s *OpenTracingLayerEmojiStore) GetByName(ctx request.CTX, name string, allowFromCache bool) (*model.Emoji, error) {
origCtx := s.Root.Store.Context() origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "EmojiStore.GetByName") span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "EmojiStore.GetByName")
s.Root.Store.SetContext(newCtx) s.Root.Store.SetContext(newCtx)
@ -3479,7 +3479,7 @@ func (s *OpenTracingLayerEmojiStore) GetList(offset int, limit int, sort string)
return result, err return result, err
} }
func (s *OpenTracingLayerEmojiStore) GetMultipleByName(ctx context.Context, names []string) ([]*model.Emoji, error) { func (s *OpenTracingLayerEmojiStore) GetMultipleByName(ctx request.CTX, names []string) ([]*model.Emoji, error) {
origCtx := s.Root.Store.Context() origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "EmojiStore.GetMultipleByName") span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "EmojiStore.GetMultipleByName")
s.Root.Store.SetContext(newCtx) s.Root.Store.SetContext(newCtx)

6
server/channels/store/retrylayer/retrylayer.go
View File

@ -3829,7 +3829,7 @@ func (s *RetryLayerEmojiStore) Delete(emoji *model.Emoji, timestamp int64) error
} }
func (s *RetryLayerEmojiStore) Get(ctx context.Context, id string, allowFromCache bool) (*model.Emoji, error) { func (s *RetryLayerEmojiStore) Get(ctx request.CTX, id string, allowFromCache bool) (*model.Emoji, error) {
tries := 0 tries := 0
for { for {
@ -3850,7 +3850,7 @@ func (s *RetryLayerEmojiStore) Get(ctx context.Context, id string, allowFromCach
} }
func (s *RetryLayerEmojiStore) GetByName(ctx context.Context, name string, allowFromCache bool) (*model.Emoji, error) { func (s *RetryLayerEmojiStore) GetByName(ctx request.CTX, name string, allowFromCache bool) (*model.Emoji, error) {
tries := 0 tries := 0
for { for {
@ -3892,7 +3892,7 @@ func (s *RetryLayerEmojiStore) GetList(offset int, limit int, sort string) ([]*m
} }
func (s *RetryLayerEmojiStore) GetMultipleByName(ctx context.Context, names []string) ([]*model.Emoji, error) { func (s *RetryLayerEmojiStore) GetMultipleByName(ctx request.CTX, names []string) ([]*model.Emoji, error) {
tries := 0 tries := 0
for { for {

12
server/channels/store/sqlstore/context.go
View File

@ -5,6 +5,8 @@ package sqlstore
import ( import (
"context" "context"
"github.com/mattermost/mattermost/server/public/shared/request"
) )
// storeContextKey is the base type for all context keys for the store. // storeContextKey is the base type for all context keys for the store.
@ -19,10 +21,20 @@ const (
) )
// WithMaster adds the context value that master DB should be selected for this request. // WithMaster adds the context value that master DB should be selected for this request.
//
// Deprecated: This method is deprecated and there's ongoing change to use `request.CTX` across
// instead of `context.Context`. Please use `RequestContextWithMaster` instead.
func WithMaster(ctx context.Context) context.Context { func WithMaster(ctx context.Context) context.Context {
return context.WithValue(ctx, storeContextKey(useMaster), true) return context.WithValue(ctx, storeContextKey(useMaster), true)
} }
// RequestContextWithMaster adds the context value that master DB should be selected for this request.
func RequestContextWithMaster(c request.CTX) request.CTX {
ctx := WithMaster(c.Context())
c.SetContext(ctx)
return c
}
// hasMaster is a helper function to check whether master DB should be selected or not. // hasMaster is a helper function to check whether master DB should be selected or not.
func hasMaster(ctx context.Context) bool { func hasMaster(ctx context.Context) bool {
if v := ctx.Value(storeContextKey(useMaster)); v != nil { if v := ctx.Value(storeContextKey(useMaster)); v != nil {

18
server/channels/store/sqlstore/emoji_store.go
View File

@ -4,7 +4,6 @@
package sqlstore package sqlstore
import ( import (
"context"
"database/sql" "database/sql"
"fmt" "fmt"
"strings" "strings"
@ -12,6 +11,7 @@ import (
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/mattermost/mattermost/server/public/model" "github.com/mattermost/mattermost/server/public/model"
"github.com/mattermost/mattermost/server/public/shared/request"
"github.com/mattermost/mattermost/server/v8/channels/store" "github.com/mattermost/mattermost/server/v8/channels/store"
"github.com/mattermost/mattermost/server/v8/einterfaces" "github.com/mattermost/mattermost/server/v8/einterfaces"
) )
@ -44,21 +44,21 @@ func (es SqlEmojiStore) Save(emoji *model.Emoji) (*model.Emoji, error) {
return emoji, nil return emoji, nil
} }
func (es SqlEmojiStore) Get(ctx context.Context, id string, allowFromCache bool) (*model.Emoji, error) { func (es SqlEmojiStore) Get(c request.CTX, id string, allowFromCache bool) (*model.Emoji, error) {
return es.getBy(ctx, "Id", id) return es.getBy(c, "Id", id)
} }
func (es SqlEmojiStore) GetByName(ctx context.Context, name string, allowFromCache bool) (*model.Emoji, error) { func (es SqlEmojiStore) GetByName(c request.CTX, name string, allowFromCache bool) (*model.Emoji, error) {
return es.getBy(ctx, "Name", name) return es.getBy(c, "Name", name)
} }
func (es SqlEmojiStore) GetMultipleByName(ctx context.Context, names []string) ([]*model.Emoji, error) { func (es SqlEmojiStore) GetMultipleByName(c request.CTX, names []string) ([]*model.Emoji, error) {
// Creating (?, ?, ?) len(names) number of times. // Creating (?, ?, ?) len(names) number of times.
keys := strings.Join(strings.Fields(strings.Repeat("? ", len(names))), ",") keys := strings.Join(strings.Fields(strings.Repeat("? ", len(names))), ",")
args := makeStringArgs(names) args := makeStringArgs(names)
emojis := []*model.Emoji{} emojis := []*model.Emoji{}
if err := es.DBXFromContext(ctx).Select(&emojis, if err := es.DBXFromContext(c.Context()).Select(&emojis,
`SELECT `SELECT
* *
FROM FROM
@ -134,10 +134,10 @@ func (es SqlEmojiStore) Search(name string, prefixOnly bool, limit int) ([]*mode
} }
// getBy returns one active (not deleted) emoji, found by any one column (what/key). // getBy returns one active (not deleted) emoji, found by any one column (what/key).
func (es SqlEmojiStore) getBy(ctx context.Context, what, key string) (*model.Emoji, error) { func (es SqlEmojiStore) getBy(c request.CTX, what, key string) (*model.Emoji, error) {
var emoji model.Emoji var emoji model.Emoji
err := es.DBXFromContext(ctx).Get(&emoji, err := es.DBXFromContext(c.Context()).Get(&emoji,
`SELECT `SELECT
* *
FROM FROM

6
server/channels/store/store.go
View File

@ -662,9 +662,9 @@ type DesktopTokensStore interface {
type EmojiStore interface { type EmojiStore interface {
Save(emoji *model.Emoji) (*model.Emoji, error) Save(emoji *model.Emoji) (*model.Emoji, error)
Get(ctx context.Context, id string, allowFromCache bool) (*model.Emoji, error) Get(ctx request.CTX, id string, allowFromCache bool) (*model.Emoji, error)
GetByName(ctx context.Context, name string, allowFromCache bool) (*model.Emoji, error) GetByName(ctx request.CTX, name string, allowFromCache bool) (*model.Emoji, error)
GetMultipleByName(ctx context.Context, names []string) ([]*model.Emoji, error) GetMultipleByName(ctx request.CTX, names []string) ([]*model.Emoji, error)
GetList(offset, limit int, sort string) ([]*model.Emoji, error) GetList(offset, limit int, sort string) ([]*model.Emoji, error)
Delete(emoji *model.Emoji, timestamp int64) error Delete(emoji *model.Emoji, timestamp int64) error
Search(name string, prefixOnly bool, limit int) ([]*model.Emoji, error) Search(name string, prefixOnly bool, limit int) ([]*model.Emoji, error)

22
server/channels/store/storetest/emoji_store.go
View File

@ -4,11 +4,11 @@
package storetest package storetest
import ( import (
"context"
"testing" "testing"
"time" "time"
"github.com/mattermost/mattermost/server/public/model" "github.com/mattermost/mattermost/server/public/model"
"github.com/mattermost/mattermost/server/public/shared/request"
"github.com/mattermost/mattermost/server/v8/channels/store" "github.com/mattermost/mattermost/server/v8/channels/store"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
@ -53,6 +53,8 @@ func testEmojiSaveDelete(t *testing.T, ss store.Store) {
} }
func testEmojiGet(t *testing.T, ss store.Store) { func testEmojiGet(t *testing.T, ss store.Store) {
c := request.TestContext(t)
emojis := []model.Emoji{ emojis := []model.Emoji{
{ {
CreatorId: model.NewId(), CreatorId: model.NewId(),
@ -81,17 +83,19 @@ func testEmojiGet(t *testing.T, ss store.Store) {
}() }()
for _, emoji := range emojis { for _, emoji := range emojis {
_, err := ss.Emoji().Get(context.Background(), emoji.Id, false) _, err := ss.Emoji().Get(c, emoji.Id, false)
require.NoErrorf(t, err, "failed to get emoji with id %v", emoji.Id) require.NoErrorf(t, err, "failed to get emoji with id %v", emoji.Id)
} }
for _, emoji := range emojis { for _, emoji := range emojis {
_, err := ss.Emoji().Get(context.Background(), emoji.Id, true) _, err := ss.Emoji().Get(c, emoji.Id, true)
require.NoErrorf(t, err, "failed to get emoji with id %v", emoji.Id) require.NoErrorf(t, err, "failed to get emoji with id %v", emoji.Id)
} }
} }
func testEmojiGetByName(t *testing.T, ss store.Store) { func testEmojiGetByName(t *testing.T, ss store.Store) {
c := request.TestContext(t)
emojis := []model.Emoji{ emojis := []model.Emoji{
{ {
CreatorId: model.NewId(), CreatorId: model.NewId(),
@ -120,12 +124,14 @@ func testEmojiGetByName(t *testing.T, ss store.Store) {
}() }()
for _, emoji := range emojis { for _, emoji := range emojis {
_, err := ss.Emoji().GetByName(context.Background(), emoji.Name, true) _, err := ss.Emoji().GetByName(c, emoji.Name, true)
require.NoErrorf(t, err, "failed to get emoji with name %v", emoji.Name) require.NoErrorf(t, err, "failed to get emoji with name %v", emoji.Name)
} }
} }
func testEmojiGetMultipleByName(t *testing.T, ss store.Store) { func testEmojiGetMultipleByName(t *testing.T, ss store.Store) {
c := request.TestContext(t)
emojis := []model.Emoji{ emojis := []model.Emoji{
{ {
CreatorId: model.NewId(), CreatorId: model.NewId(),
@ -154,26 +160,26 @@ func testEmojiGetMultipleByName(t *testing.T, ss store.Store) {
}() }()
t.Run("one emoji", func(t *testing.T) { t.Run("one emoji", func(t *testing.T) {
received, err := ss.Emoji().GetMultipleByName(context.Background(), []string{emojis[0].Name}) received, err := ss.Emoji().GetMultipleByName(c, []string{emojis[0].Name})
require.NoError(t, err, "could not get emoji") require.NoError(t, err, "could not get emoji")
require.Len(t, received, 1, "got incorrect emoji") require.Len(t, received, 1, "got incorrect emoji")
require.Equal(t, *received[0], emojis[0], "got incorrect emoji") require.Equal(t, *received[0], emojis[0], "got incorrect emoji")
}) })
t.Run("multiple emojis", func(t *testing.T) { t.Run("multiple emojis", func(t *testing.T) {
received, err := ss.Emoji().GetMultipleByName(context.Background(), []string{emojis[0].Name, emojis[1].Name, emojis[2].Name}) received, err := ss.Emoji().GetMultipleByName(c, []string{emojis[0].Name, emojis[1].Name, emojis[2].Name})
require.NoError(t, err, "could not get emojis") require.NoError(t, err, "could not get emojis")
require.Len(t, received, 3, "got incorrect emojis") require.Len(t, received, 3, "got incorrect emojis")
}) })
t.Run("one nonexistent emoji", func(t *testing.T) { t.Run("one nonexistent emoji", func(t *testing.T) {
received, err := ss.Emoji().GetMultipleByName(context.Background(), []string{"ab"}) received, err := ss.Emoji().GetMultipleByName(c, []string{"ab"})
require.NoError(t, err, "could not get emoji", err) require.NoError(t, err, "could not get emoji", err)
require.Empty(t, received, "got incorrect emoji") require.Empty(t, received, "got incorrect emoji")
}) })
t.Run("multiple emojis with nonexistent names", func(t *testing.T) { t.Run("multiple emojis with nonexistent names", func(t *testing.T) {
received, err := ss.Emoji().GetMultipleByName(context.Background(), []string{emojis[0].Name, emojis[1].Name, emojis[2].Name, "abcd", "1234"}) received, err := ss.Emoji().GetMultipleByName(c, []string{emojis[0].Name, emojis[1].Name, emojis[2].Name, "abcd", "1234"})
require.NoError(t, err, "could not get emojis") require.NoError(t, err, "could not get emojis")
require.Len(t, received, 3, "got incorrect emojis") require.Len(t, received, 3, "got incorrect emojis")
}) })

27
server/channels/store/storetest/mocks/EmojiStore.go
View File

@ -5,9 +5,8 @@
package mocks package mocks
import ( import (
context "context"
model "github.com/mattermost/mattermost/server/public/model" model "github.com/mattermost/mattermost/server/public/model"
request "github.com/mattermost/mattermost/server/public/shared/request"
mock "github.com/stretchr/testify/mock" mock "github.com/stretchr/testify/mock"
) )
@ -31,15 +30,15 @@ func (_m *EmojiStore) Delete(emoji *model.Emoji, timestamp int64) error {
} }
// Get provides a mock function with given fields: ctx, id, allowFromCache // Get provides a mock function with given fields: ctx, id, allowFromCache
func (_m *EmojiStore) Get(ctx context.Context, id string, allowFromCache bool) (*model.Emoji, error) { func (_m *EmojiStore) Get(ctx request.CTX, id string, allowFromCache bool) (*model.Emoji, error) {
ret := _m.Called(ctx, id, allowFromCache) ret := _m.Called(ctx, id, allowFromCache)
var r0 *model.Emoji var r0 *model.Emoji
var r1 error var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, bool) (*model.Emoji, error)); ok { if rf, ok := ret.Get(0).(func(request.CTX, string, bool) (*model.Emoji, error)); ok {
return rf(ctx, id, allowFromCache) return rf(ctx, id, allowFromCache)
} }
if rf, ok := ret.Get(0).(func(context.Context, string, bool) *model.Emoji); ok { if rf, ok := ret.Get(0).(func(request.CTX, string, bool) *model.Emoji); ok {
r0 = rf(ctx, id, allowFromCache) r0 = rf(ctx, id, allowFromCache)
} else { } else {
if ret.Get(0) != nil { if ret.Get(0) != nil {
@ -47,7 +46,7 @@ func (_m *EmojiStore) Get(ctx context.Context, id string, allowFromCache bool) (
} }
} }
if rf, ok := ret.Get(1).(func(context.Context, string, bool) error); ok { if rf, ok := ret.Get(1).(func(request.CTX, string, bool) error); ok {
r1 = rf(ctx, id, allowFromCache) r1 = rf(ctx, id, allowFromCache)
} else { } else {
r1 = ret.Error(1) r1 = ret.Error(1)
@ -57,15 +56,15 @@ func (_m *EmojiStore) Get(ctx context.Context, id string, allowFromCache bool) (
} }
// GetByName provides a mock function with given fields: ctx, name, allowFromCache // GetByName provides a mock function with given fields: ctx, name, allowFromCache
func (_m *EmojiStore) GetByName(ctx context.Context, name string, allowFromCache bool) (*model.Emoji, error) { func (_m *EmojiStore) GetByName(ctx request.CTX, name string, allowFromCache bool) (*model.Emoji, error) {
ret := _m.Called(ctx, name, allowFromCache) ret := _m.Called(ctx, name, allowFromCache)
var r0 *model.Emoji var r0 *model.Emoji
var r1 error var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, bool) (*model.Emoji, error)); ok { if rf, ok := ret.Get(0).(func(request.CTX, string, bool) (*model.Emoji, error)); ok {
return rf(ctx, name, allowFromCache) return rf(ctx, name, allowFromCache)
} }
if rf, ok := ret.Get(0).(func(context.Context, string, bool) *model.Emoji); ok { if rf, ok := ret.Get(0).(func(request.CTX, string, bool) *model.Emoji); ok {
r0 = rf(ctx, name, allowFromCache) r0 = rf(ctx, name, allowFromCache)
} else { } else {
if ret.Get(0) != nil { if ret.Get(0) != nil {
@ -73,7 +72,7 @@ func (_m *EmojiStore) GetByName(ctx context.Context, name string, allowFromCache
} }
} }
if rf, ok := ret.Get(1).(func(context.Context, string, bool) error); ok { if rf, ok := ret.Get(1).(func(request.CTX, string, bool) error); ok {
r1 = rf(ctx, name, allowFromCache) r1 = rf(ctx, name, allowFromCache)
} else { } else {
r1 = ret.Error(1) r1 = ret.Error(1)
@ -109,15 +108,15 @@ func (_m *EmojiStore) GetList(offset int, limit int, sort string) ([]*model.Emoj
} }
// GetMultipleByName provides a mock function with given fields: ctx, names // GetMultipleByName provides a mock function with given fields: ctx, names
func (_m *EmojiStore) GetMultipleByName(ctx context.Context, names []string) ([]*model.Emoji, error) { func (_m *EmojiStore) GetMultipleByName(ctx request.CTX, names []string) ([]*model.Emoji, error) {
ret := _m.Called(ctx, names) ret := _m.Called(ctx, names)
var r0 []*model.Emoji var r0 []*model.Emoji
var r1 error var r1 error
if rf, ok := ret.Get(0).(func(context.Context, []string) ([]*model.Emoji, error)); ok { if rf, ok := ret.Get(0).(func(request.CTX, []string) ([]*model.Emoji, error)); ok {
return rf(ctx, names) return rf(ctx, names)
} }
if rf, ok := ret.Get(0).(func(context.Context, []string) []*model.Emoji); ok { if rf, ok := ret.Get(0).(func(request.CTX, []string) []*model.Emoji); ok {
r0 = rf(ctx, names) r0 = rf(ctx, names)
} else { } else {
if ret.Get(0) != nil { if ret.Get(0) != nil {
@ -125,7 +124,7 @@ func (_m *EmojiStore) GetMultipleByName(ctx context.Context, names []string) ([]
} }
} }
if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok { if rf, ok := ret.Get(1).(func(request.CTX, []string) error); ok {
r1 = rf(ctx, names) r1 = rf(ctx, names)
} else { } else {
r1 = ret.Error(1) r1 = ret.Error(1)

6
server/channels/store/timerlayer/timerlayer.go
View File

@ -3139,7 +3139,7 @@ func (s *TimerLayerEmojiStore) Delete(emoji *model.Emoji, timestamp int64) error
return err return err
} }
func (s *TimerLayerEmojiStore) Get(ctx context.Context, id string, allowFromCache bool) (*model.Emoji, error) { func (s *TimerLayerEmojiStore) Get(ctx request.CTX, id string, allowFromCache bool) (*model.Emoji, error) {
start := time.Now() start := time.Now()
result, err := s.EmojiStore.Get(ctx, id, allowFromCache) result, err := s.EmojiStore.Get(ctx, id, allowFromCache)
@ -3155,7 +3155,7 @@ func (s *TimerLayerEmojiStore) Get(ctx context.Context, id string, allowFromCach
return result, err return result, err
} }
func (s *TimerLayerEmojiStore) GetByName(ctx context.Context, name string, allowFromCache bool) (*model.Emoji, error) { func (s *TimerLayerEmojiStore) GetByName(ctx request.CTX, name string, allowFromCache bool) (*model.Emoji, error) {
start := time.Now() start := time.Now()
result, err := s.EmojiStore.GetByName(ctx, name, allowFromCache) result, err := s.EmojiStore.GetByName(ctx, name, allowFromCache)
@ -3187,7 +3187,7 @@ func (s *TimerLayerEmojiStore) GetList(offset int, limit int, sort string) ([]*m
return result, err return result, err
} }
func (s *TimerLayerEmojiStore) GetMultipleByName(ctx context.Context, names []string) ([]*model.Emoji, error) { func (s *TimerLayerEmojiStore) GetMultipleByName(ctx request.CTX, names []string) ([]*model.Emoji, error) {
start := time.Now() start := time.Now()
result, err := s.EmojiStore.GetMultipleByName(ctx, names) result, err := s.EmojiStore.GetMultipleByName(ctx, names)

8
server/public/shared/request/context.go
View File

@ -5,6 +5,7 @@ package request
import ( import (
"context" "context"
"testing"
"github.com/mattermost/mattermost/server/public/model" "github.com/mattermost/mattermost/server/public/model"
"github.com/mattermost/mattermost/server/public/shared/i18n" "github.com/mattermost/mattermost/server/public/shared/i18n"
@ -46,6 +47,13 @@ func EmptyContext(logger mlog.LoggerIFace) *Context {
} }
} }
// TestContext creates an empty context with a new logger to use in testing where a test helper is
// not required.
func TestContext(t *testing.T) *Context {
logger := mlog.CreateConsoleTestLogger(t)
return EmptyContext(logger)
}
func (c *Context) T(translationID string, args ...any) string { func (c *Context) T(translationID string, args ...any) string {
return c.t(translationID, args...) return c.t(translationID, args...)
} }