mirror of
https://github.com/hanzoai/team.git
synced 2026-09-30 01:57:35 +00:00
zeekay
8feb24ea1f
The server module named github.com/hanzoai/team/server/v8 — a path that resolves to the retired workspace's repository, not this one — while server/public still published github.com/mattermost/mattermost/server/public. Both are github.com/hanzoteam/server/... now, which is where this code actually lives. That second half is what made the binary unbootable. Upstream's public path stayed claimed by upstream, mattermost-plugin-ai imported it, and the build linked public/model twice; public/plugin's gob.Register then ran twice under one name and panicked at init, before main. Reverting the rename traded the brand for a working binary. Rebranding the plugin alongside it needs no such trade: the agents fork is github.com/hanzoteam/agents/v2 against our public module, so no module named mattermost/mattermost is in the graph at all. Measured: `go list -deps ./cmd/mattermost` names exactly one public/model, and it is ours.
248 lines
13 KiB
Go
248 lines
13 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package localcachelayer
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/mock"
|
|
|
|
"github.com/hanzoteam/server/server/public/model"
|
|
"github.com/hanzoteam/server/server/public/shared/request"
|
|
"github.com/hanzoteam/server/server/v8/channels/store"
|
|
"github.com/hanzoteam/server/server/v8/channels/store/sqlstore"
|
|
"github.com/hanzoteam/server/server/v8/channels/store/storetest/mocks"
|
|
"github.com/hanzoteam/server/server/v8/channels/testlib"
|
|
"github.com/hanzoteam/server/server/v8/platform/services/cache"
|
|
cachemocks "github.com/hanzoteam/server/server/v8/platform/services/cache/mocks"
|
|
)
|
|
|
|
var mainHelper *testlib.MainHelper
|
|
|
|
func getMockCacheProvider() cache.Provider {
|
|
mockCacheProvider := cachemocks.Provider{}
|
|
// Each NewCache call returns a fresh LRU so that caches are isolated
|
|
// from each other, matching production behaviour.
|
|
call := mockCacheProvider.On("NewCache", mock.Anything)
|
|
call.Run(func(args mock.Arguments) {
|
|
call.ReturnArguments = mock.Arguments{cache.NewLRU(&cache.CacheOptions{Size: 128}), nil}
|
|
})
|
|
mockCacheProvider.On("Type").Return("lru")
|
|
return &mockCacheProvider
|
|
}
|
|
|
|
func getMockStore(t *testing.T) *mocks.Store {
|
|
mockStore := mocks.Store{}
|
|
|
|
fakeReaction := model.Reaction{PostId: "123"}
|
|
mockReactionsStore := mocks.ReactionStore{}
|
|
mockReactionsStore.On("Save", &fakeReaction).Return(&model.Reaction{}, nil)
|
|
mockReactionsStore.On("Delete", &fakeReaction).Return(&model.Reaction{}, nil)
|
|
mockReactionsStore.On("GetForPost", "123", false).Return([]*model.Reaction{&fakeReaction}, nil)
|
|
mockReactionsStore.On("GetForPost", "123", true).Return([]*model.Reaction{&fakeReaction}, nil)
|
|
mockStore.On("Reaction").Return(&mockReactionsStore)
|
|
|
|
mockAutoTranslationStore := mocks.AutoTranslationStore{}
|
|
// GetLatestPostUpdateAtForChannel now takes only channelID (no locale) since caching is per-channel
|
|
mockAutoTranslationStore.On("GetLatestPostUpdateAtForChannel", "channelId").Return(int64(5000), nil)
|
|
mockStore.On("AutoTranslation").Return(&mockAutoTranslationStore)
|
|
|
|
fakeRole := model.Role{Id: "123", Name: "role-name"}
|
|
fakeRole2 := model.Role{Id: "456", Name: "role-name2"}
|
|
mockRolesStore := mocks.RoleStore{}
|
|
mockRolesStore.On("Save", &fakeRole).Return(&model.Role{}, nil)
|
|
mockRolesStore.On("SavePreservingUnknownPermissions", &fakeRole).Return(&model.Role{}, nil)
|
|
mockRolesStore.On("Delete", "123").Return(&fakeRole, nil)
|
|
mockRolesStore.On("GetByName", mock.Anything, "role-name").Return(&fakeRole, nil)
|
|
mockRolesStore.On("GetByNames", []string{"role-name"}).Return([]*model.Role{&fakeRole}, nil)
|
|
mockRolesStore.On("GetByNames", []string{"role-name2"}).Return([]*model.Role{&fakeRole2}, nil)
|
|
mockRolesStore.On("PermanentDeleteAll").Return(nil)
|
|
mockStore.On("Role").Return(&mockRolesStore)
|
|
|
|
fakeScheme := model.Scheme{Id: "123", Name: "scheme-name"}
|
|
mockSchemesStore := mocks.SchemeStore{}
|
|
mockSchemesStore.On("Save", &fakeScheme).Return(&model.Scheme{}, nil)
|
|
mockSchemesStore.On("Delete", "123").Return(&model.Scheme{}, nil)
|
|
mockSchemesStore.On("Get", "123").Return(&fakeScheme, nil)
|
|
mockSchemesStore.On("PermanentDeleteAll").Return(nil)
|
|
mockStore.On("Scheme").Return(&mockSchemesStore)
|
|
|
|
fakeFileInfo := model.FileInfo{Id: "123", PostId: "123"}
|
|
mockFileInfoStore := mocks.FileInfoStore{}
|
|
mockFileInfoStore.On("GetForPost", "123", true, true, false).Return([]*model.FileInfo{&fakeFileInfo}, nil)
|
|
mockFileInfoStore.On("GetForPost", "123", true, true, true).Return([]*model.FileInfo{&fakeFileInfo}, nil)
|
|
mockFileInfoStore.On("GetByIds", []string{"123"}, true, false, false).Return([]*model.FileInfo{&fakeFileInfo}, nil)
|
|
mockStore.On("FileInfo").Return(&mockFileInfoStore)
|
|
|
|
fakeWebhook := model.IncomingWebhook{Id: "123"}
|
|
mockWebhookStore := mocks.WebhookStore{}
|
|
mockWebhookStore.On("GetIncoming", "123", true).Return(&fakeWebhook, nil)
|
|
mockWebhookStore.On("GetIncoming", "123", false).Return(&fakeWebhook, nil)
|
|
mockStore.On("Webhook").Return(&mockWebhookStore)
|
|
|
|
fakeEmoji := model.Emoji{Id: "123", Name: "name123"}
|
|
fakeEmoji2 := model.Emoji{Id: "321", Name: "name321"}
|
|
ctxEmoji := model.Emoji{Id: "master", Name: "name123"}
|
|
mockEmojiStore := mocks.EmojiStore{}
|
|
mockEmojiStore.On("Get", mock.Anything, "123", true).Return(&fakeEmoji, nil)
|
|
mockEmojiStore.On("Get", mock.Anything, "123", false).Return(&fakeEmoji, nil)
|
|
mockEmojiStore.On("Get", mock.IsType(&request.Context{}), "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", false).Return(&fakeEmoji, nil)
|
|
mockEmojiStore.On("GetMultipleByName", mock.IsType(&request.Context{}), []string{"name123"}).Return([]*model.Emoji{&fakeEmoji}, nil)
|
|
mockEmojiStore.On("GetMultipleByName", mock.IsType(&request.Context{}), []string{"name123", "name321"}).Return([]*model.Emoji{&fakeEmoji, &fakeEmoji2}, nil)
|
|
mockEmojiStore.On("GetByName", mock.IsType(&request.Context{}), "master", true).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", &ctxEmoji, int64(0)).Return(nil)
|
|
mockStore.On("Emoji").Return(&mockEmojiStore)
|
|
|
|
mockCount := int64(10)
|
|
mockGuestCount := int64(12)
|
|
channelId := "channel1"
|
|
fakeChannel1 := model.Channel{Id: channelId, Name: "channel1-name"}
|
|
fakeChannel2 := model.Channel{Id: "channel2", Name: "channel2-name"}
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
mockChannelStore.On("ClearCaches").Return()
|
|
mockChannelStore.On("Save", mock.IsType(&request.Context{}), &fakeChannel1, int64(0)).Return(&fakeChannel1, nil)
|
|
mockChannelStore.On("Update", mock.IsType(&request.Context{}), &fakeChannel1).Return(&fakeChannel1, nil)
|
|
mockChannelStore.On("GetMemberCount", "id", true).Return(mockCount, nil)
|
|
mockChannelStore.On("GetMemberCount", "id", false).Return(mockCount, nil)
|
|
mockChannelStore.On("GetGuestCount", "id", true).Return(mockGuestCount, nil)
|
|
mockChannelStore.On("GetGuestCount", "id", false).Return(mockGuestCount, nil)
|
|
mockChannelStore.On("Get", channelId, true).Return(&fakeChannel1, nil)
|
|
mockChannelStore.On("Get", channelId, false).Return(&fakeChannel1, nil)
|
|
mockChannelStore.On("GetMany", []string{channelId}, true).Return(model.ChannelList{&fakeChannel1}, nil)
|
|
mockChannelStore.On("GetMany", []string{channelId}, false).Return(model.ChannelList{&fakeChannel1}, nil)
|
|
mockChannelStore.On("GetMany", []string{fakeChannel2.Id}, true).Return(model.ChannelList{&fakeChannel2}, nil)
|
|
mockChannelStore.On("GetByNames", "team1", []string{fakeChannel1.Name}, true).Return([]*model.Channel{&fakeChannel1}, nil)
|
|
mockChannelStore.On("GetByNames", "team1", []string{fakeChannel2.Name}, true).Return([]*model.Channel{&fakeChannel2}, nil)
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
|
|
mockChannelsMemberCount := map[string]int64{
|
|
"channel1": 10,
|
|
"channel2": 20,
|
|
}
|
|
mockChannelStore.On("GetChannelsMemberCount", []string{"channel1", "channel2"}).Return(mockChannelsMemberCount, nil)
|
|
|
|
mockPinnedPostsCount := int64(10)
|
|
mockChannelStore.On("GetPinnedPostCount", "id", true).Return(mockPinnedPostsCount, nil)
|
|
mockChannelStore.On("GetPinnedPostCount", "id", false).Return(mockPinnedPostsCount, nil)
|
|
|
|
fakePosts := &model.PostList{}
|
|
fakeOptions := model.GetPostsOptions{ChannelId: "123", PerPage: 30}
|
|
mockPostStore := mocks.PostStore{}
|
|
mockPostStore.On("GetPosts", mock.AnythingOfType("*request.Context"), fakeOptions, true, map[string]bool{}).Return(fakePosts, nil)
|
|
mockPostStore.On("GetPosts", mock.AnythingOfType("*request.Context"), fakeOptions, false, map[string]bool{}).Return(fakePosts, nil)
|
|
mockPostStore.On("InvalidateLastPostTimeCache", "12360")
|
|
|
|
mockPostStoreOptions := model.GetPostsSinceOptions{
|
|
ChannelId: "channelId",
|
|
Time: 1,
|
|
SkipFetchThreads: false,
|
|
}
|
|
|
|
mockPostStoreEtagResult := fmt.Sprintf("%v.%v", model.CurrentVersion, 1)
|
|
mockPostStore.On("ClearCaches")
|
|
mockPostStore.On("InvalidateLastPostTimeCache", "channelId")
|
|
mockPostStore.On("GetEtag", "channelId", true, false, false).Return(mockPostStoreEtagResult)
|
|
mockPostStore.On("GetEtag", "channelId", false, false, false).Return(mockPostStoreEtagResult)
|
|
mockPostStore.On("GetEtag", "channelId", true, false, true).Return(mockPostStoreEtagResult)
|
|
mockPostStore.On("GetEtag", "channelId", false, false, true).Return(mockPostStoreEtagResult)
|
|
mockPostStore.On("GetPostsSince", mock.AnythingOfType("*request.Context"), mockPostStoreOptions, true, map[string]bool{}).Return(model.NewPostList(), nil)
|
|
mockPostStore.On("GetPostsSince", mock.AnythingOfType("*request.Context"), mockPostStoreOptions, false, map[string]bool{}).Return(model.NewPostList(), nil)
|
|
mockStore.On("Post").Return(&mockPostStore)
|
|
|
|
fakeTermsOfService := model.TermsOfService{Id: "123", CreateAt: 11111, UserId: "321", Text: "Terms of service test"}
|
|
mockTermsOfServiceStore := mocks.TermsOfServiceStore{}
|
|
mockTermsOfServiceStore.On("InvalidateTermsOfService", "123")
|
|
mockTermsOfServiceStore.On("Save", &fakeTermsOfService).Return(&fakeTermsOfService, nil)
|
|
mockTermsOfServiceStore.On("GetLatest", true).Return(&fakeTermsOfService, nil)
|
|
mockTermsOfServiceStore.On("GetLatest", false).Return(&fakeTermsOfService, nil)
|
|
mockTermsOfServiceStore.On("Get", "123", true).Return(&fakeTermsOfService, nil)
|
|
mockTermsOfServiceStore.On("Get", "123", false).Return(&fakeTermsOfService, nil)
|
|
mockStore.On("TermsOfService").Return(&mockTermsOfServiceStore)
|
|
|
|
fakeUser := []*model.User{{
|
|
Id: "123",
|
|
AuthData: new("authData"),
|
|
AuthService: "authService",
|
|
}}
|
|
mockUserStore := mocks.UserStore{}
|
|
mockUserStore.On("GetProfileByIds", mock.Anything, []string{"123"}, &store.UserGetByIdsOpts{}, true).Return(fakeUser, nil)
|
|
mockUserStore.On("GetProfileByIds", mock.Anything, []string{"123"}, &store.UserGetByIdsOpts{}, false).Return(fakeUser, nil)
|
|
|
|
fakeProfilesInChannelMap := map[string]*model.User{
|
|
"456": {Id: "456"},
|
|
}
|
|
mockUserStore.On("GetAllProfilesInChannel", mock.Anything, "123", true).Return(fakeProfilesInChannelMap, nil)
|
|
mockUserStore.On("GetAllProfilesInChannel", mock.Anything, "123", false).Return(fakeProfilesInChannelMap, nil)
|
|
mockUserStore.On("GetAllProfiles", mock.AnythingOfType("*model.UserGetOptions")).Return(fakeUser, nil)
|
|
|
|
mockUserStore.On("Get", mock.Anything, "123").Return(fakeUser[0], nil)
|
|
users := []*model.User{
|
|
fakeUser[0],
|
|
{
|
|
Id: "456",
|
|
AuthData: new("authData"),
|
|
AuthService: "authService",
|
|
},
|
|
}
|
|
mockUserStore.On("GetMany", mock.Anything, []string{"123", "456"}).Return(users, nil)
|
|
mockUserStore.On("GetMany", mock.Anything, []string{"123"}).Return(users[0:1], nil)
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
|
|
fakeUserTeamIds := []string{"1", "2", "3"}
|
|
mockTeamStore := mocks.TeamStore{}
|
|
mockTeamStore.On("GetUserTeamIds", "123", true).Return(fakeUserTeamIds, nil)
|
|
mockTeamStore.On("GetUserTeamIds", "123", false).Return(fakeUserTeamIds, nil)
|
|
mockStore.On("Team").Return(&mockTeamStore)
|
|
|
|
mockContentFlaggingStore := mocks.ContentFlaggingStore{}
|
|
mockStore.On("ContentFlagging").Return(&mockContentFlaggingStore)
|
|
|
|
mockSessionAttributeStore := mocks.SessionAttributeStore{}
|
|
mockStore.On("SessionAttribute").Return(&mockSessionAttributeStore)
|
|
|
|
fakeField := model.PropertyField{ID: "field-id", GroupID: "group-id", Name: "field-name"}
|
|
mockPropertyFieldStore := mocks.PropertyFieldStore{}
|
|
mockPropertyFieldStore.On("GetForGroup", context.Background(), "group-id").Return([]*model.PropertyField{&fakeField}, nil)
|
|
mockPropertyFieldStore.On("Create", &fakeField).Return(&fakeField, nil)
|
|
mockPropertyFieldStore.On("Update", "group-id", []*model.PropertyField{&fakeField}, map[string]int64(nil)).Return([]*model.PropertyField{&fakeField}, nil)
|
|
mockPropertyFieldStore.On("Delete", "group-id", "field-id").Return(nil)
|
|
mockStore.On("PropertyField").Return(&mockPropertyFieldStore)
|
|
|
|
mockReadReceiptStore := &mocks.ReadReceiptStore{}
|
|
mockStore.On("ReadReceipt").Return(mockReadReceiptStore)
|
|
|
|
fakeTemporaryPost := model.TemporaryPost{
|
|
ID: "123",
|
|
Type: model.PostTypeBurnOnRead,
|
|
ExpireAt: model.GetMillis() + 300000,
|
|
Message: "test message",
|
|
FileIDs: []string{"file1"},
|
|
}
|
|
mockTemporaryPostStore := mocks.TemporaryPostStore{}
|
|
mockTemporaryPostStore.On("Save", mock.Anything, mock.AnythingOfType("*model.TemporaryPost")).Return(&fakeTemporaryPost, nil)
|
|
mockTemporaryPostStore.On("Delete", mock.Anything, "123").Return(nil)
|
|
mockTemporaryPostStore.On("Get", mock.Anything, "123", false).Return(&fakeTemporaryPost, nil)
|
|
mockTemporaryPostStore.On("Get", mock.Anything, "123", true).Return(&fakeTemporaryPost, nil)
|
|
mockTemporaryPostStore.On("InvalidateTemporaryPost", "123").Return()
|
|
mockStore.On("TemporaryPost").Return(&mockTemporaryPostStore)
|
|
|
|
return &mockStore
|
|
}
|
|
|
|
func TestMain(m *testing.M) {
|
|
mainHelper = testlib.NewMainHelperWithOptions(nil)
|
|
defer mainHelper.Close()
|
|
|
|
initStores(mainHelper.Logger)
|
|
mainHelper.Main(m)
|
|
tearDownStores()
|
|
}
|