mirror of
https://github.com/mattermost/mattermost.git
synced 2026-05-28 04:35:04 -04:00
ebc066e7fd
* [MM-68273] Add system messages for share / unshare events * Fix CI * Address feedback * Fix CI * Remove unknown prop * Add missing tests
324 lines
12 KiB
Go
324 lines
12 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package sharedchannel
|
|
|
|
import (
|
|
"errors"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/mock"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/mattermost/mattermost/server/public/model"
|
|
"github.com/mattermost/mattermost/server/public/shared/i18n"
|
|
"github.com/mattermost/mattermost/server/public/shared/mlog"
|
|
"github.com/mattermost/mattermost/server/v8/channels/store/storetest/mocks"
|
|
)
|
|
|
|
// testNoopPlatform satisfies PlatformIface for API tests that trigger websocket/cache notifications.
|
|
type testNoopPlatform struct{}
|
|
|
|
func (testNoopPlatform) InvalidateCacheForUser(userID string) {}
|
|
|
|
func (testNoopPlatform) InvalidateCacheForChannel(channel *model.Channel) {}
|
|
|
|
func TestUnshareChannel_systemPostsForEachRemoteWorkspace(t *testing.T) {
|
|
channelID := model.NewId()
|
|
teamID := model.NewId()
|
|
channel := &model.Channel{Id: channelID, TeamId: teamID, Name: "town-square", DisplayName: "Town Square"}
|
|
|
|
remoteIDA := model.NewId()
|
|
remoteIDB := model.NewId()
|
|
remotes := []*model.SharedChannelRemote{
|
|
{Id: model.NewId(), ChannelId: channelID, RemoteId: remoteIDA, DeleteAt: 0},
|
|
{Id: model.NewId(), ChannelId: channelID, RemoteId: remoteIDB, DeleteAt: 0},
|
|
}
|
|
rcA := &model.RemoteCluster{RemoteId: remoteIDA, DisplayName: "Workspace A"}
|
|
rcB := &model.RemoteCluster{RemoteId: remoteIDB, Name: "internal-b"}
|
|
|
|
mockServer := &MockServerIface{}
|
|
logger := mlog.CreateConsoleTestLogger(t)
|
|
mockServer.On("Log").Return(logger)
|
|
|
|
mockStore := &mocks.Store{}
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
mockSharedChannelStore := mocks.SharedChannelStore{}
|
|
mockRemoteClusterStore := mocks.RemoteClusterStore{}
|
|
|
|
mockServer.On("GetStore").Return(mockStore)
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
mockStore.On("SharedChannel").Return(&mockSharedChannelStore)
|
|
mockStore.On("RemoteCluster").Return(&mockRemoteClusterStore)
|
|
|
|
mockChannelStore.On("Get", channelID, true).Return(channel, nil).Once()
|
|
mockChannelStore.On("Get", channelID, false).Return(channel, nil).Once()
|
|
|
|
mockSharedChannelStore.On("GetRemotes", 0, 10000, model.SharedChannelRemoteFilterOpts{
|
|
ChannelId: channelID,
|
|
IncludeUnconfirmed: true,
|
|
}).Return(remotes, nil).Once()
|
|
mockSharedChannelStore.On("Delete", channelID).Return(true, nil).Once()
|
|
|
|
mockRemoteClusterStore.On("Get", remoteIDA, false).Return(rcA, nil).Once()
|
|
mockRemoteClusterStore.On("Get", remoteIDB, false).Return(rcB, nil).Once()
|
|
|
|
mockApp := &MockAppIface{}
|
|
bot := &model.Bot{UserId: model.NewId()}
|
|
var postedWorkspaces []string
|
|
mockApp.On("GetSystemBot", mock.Anything).Return(bot, (*model.AppError)(nil))
|
|
mockApp.On("Publish", mock.Anything).Return()
|
|
mockApp.On("CreatePost", mock.Anything, mock.AnythingOfType("*model.Post"), mock.AnythingOfType("*model.Channel"), mock.Anything).
|
|
Run(func(args mock.Arguments) {
|
|
post := args.Get(1).(*model.Post)
|
|
wn, _ := post.GetProps()[model.PostPropsSharedChannelWorkspaceName].(string)
|
|
assert.Equal(t, model.SharedChannelStatePostValueUnshared, post.GetProps()[model.PostPropsSharedChannelState])
|
|
postedWorkspaces = append(postedWorkspaces, wn)
|
|
assert.Equal(t,
|
|
i18n.T("shared_channel.system_message.no_longer_shared", map[string]any{"WorkspaceName": wn}),
|
|
post.Message,
|
|
)
|
|
}).Return(&model.Post{}, false, (*model.AppError)(nil))
|
|
|
|
scs := &Service{
|
|
server: mockServer,
|
|
platform: testNoopPlatform{},
|
|
app: mockApp,
|
|
}
|
|
|
|
deleted, err := scs.UnshareChannel(channelID)
|
|
require.NoError(t, err)
|
|
assert.True(t, deleted)
|
|
|
|
mockApp.AssertNumberOfCalls(t, "CreatePost", 2)
|
|
assert.ElementsMatch(t, []string{"Workspace A", "internal-b"}, postedWorkspaces)
|
|
mockApp.AssertExpectations(t)
|
|
mockSharedChannelStore.AssertExpectations(t)
|
|
mockRemoteClusterStore.AssertExpectations(t)
|
|
}
|
|
|
|
func TestUnshareChannel_whenListRemotesFails_stillUnsharesWithoutSystemPosts(t *testing.T) {
|
|
channelID := model.NewId()
|
|
channel := &model.Channel{Id: channelID, TeamId: model.NewId()}
|
|
|
|
mockServer := &MockServerIface{}
|
|
logger := mlog.CreateConsoleTestLogger(t)
|
|
mockServer.On("Log").Return(logger)
|
|
|
|
mockStore := &mocks.Store{}
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
mockSharedChannelStore := mocks.SharedChannelStore{}
|
|
|
|
mockServer.On("GetStore").Return(mockStore)
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
mockStore.On("SharedChannel").Return(&mockSharedChannelStore)
|
|
|
|
mockChannelStore.On("Get", channelID, true).Return(channel, nil).Once()
|
|
mockChannelStore.On("Get", channelID, false).Return(channel, nil).Once()
|
|
|
|
listErr := errors.New("store remotes unavailable")
|
|
mockSharedChannelStore.On("GetRemotes", 0, 10000, model.SharedChannelRemoteFilterOpts{
|
|
ChannelId: channelID,
|
|
IncludeUnconfirmed: true,
|
|
}).Return(([]*model.SharedChannelRemote)(nil), listErr).Once()
|
|
mockSharedChannelStore.On("Delete", channelID).Return(true, nil).Once()
|
|
|
|
mockApp := &MockAppIface{}
|
|
mockApp.On("Publish", mock.Anything).Return()
|
|
|
|
scs := &Service{
|
|
server: mockServer,
|
|
platform: testNoopPlatform{},
|
|
app: mockApp,
|
|
}
|
|
|
|
deleted, err := scs.UnshareChannel(channelID)
|
|
require.NoError(t, err)
|
|
assert.True(t, deleted)
|
|
|
|
mockApp.AssertNotCalled(t, "CreatePost")
|
|
mockApp.AssertExpectations(t)
|
|
}
|
|
|
|
func TestUnshareChannel_whenRemoteClusterMissingUsesRemoteIdInPost(t *testing.T) {
|
|
channelID := model.NewId()
|
|
channel := &model.Channel{Id: channelID, TeamId: model.NewId()}
|
|
remoteID := model.NewId()
|
|
remotes := []*model.SharedChannelRemote{
|
|
{Id: model.NewId(), ChannelId: channelID, RemoteId: remoteID, DeleteAt: 0},
|
|
}
|
|
|
|
mockServer := &MockServerIface{}
|
|
logger := mlog.CreateConsoleTestLogger(t)
|
|
mockServer.On("Log").Return(logger)
|
|
|
|
mockStore := &mocks.Store{}
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
mockSharedChannelStore := mocks.SharedChannelStore{}
|
|
mockRemoteClusterStore := mocks.RemoteClusterStore{}
|
|
|
|
mockServer.On("GetStore").Return(mockStore)
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
mockStore.On("SharedChannel").Return(&mockSharedChannelStore)
|
|
mockStore.On("RemoteCluster").Return(&mockRemoteClusterStore)
|
|
|
|
mockChannelStore.On("Get", channelID, true).Return(channel, nil).Once()
|
|
mockChannelStore.On("Get", channelID, false).Return(channel, nil).Once()
|
|
mockSharedChannelStore.On("GetRemotes", 0, 10000, model.SharedChannelRemoteFilterOpts{
|
|
ChannelId: channelID,
|
|
IncludeUnconfirmed: true,
|
|
}).Return(remotes, nil).Once()
|
|
mockSharedChannelStore.On("Delete", channelID).Return(true, nil).Once()
|
|
mockRemoteClusterStore.On("Get", remoteID, false).Return((*model.RemoteCluster)(nil), errors.New("not found")).Once()
|
|
|
|
mockApp := &MockAppIface{}
|
|
bot := &model.Bot{UserId: model.NewId()}
|
|
mockApp.On("GetSystemBot", mock.Anything).Return(bot, (*model.AppError)(nil))
|
|
mockApp.On("Publish", mock.Anything).Return()
|
|
mockApp.On("CreatePost", mock.Anything, mock.AnythingOfType("*model.Post"), mock.AnythingOfType("*model.Channel"), mock.Anything).
|
|
Run(func(args mock.Arguments) {
|
|
post := args.Get(1).(*model.Post)
|
|
assert.Equal(t, remoteID, post.GetProps()[model.PostPropsSharedChannelWorkspaceName])
|
|
}).Return(&model.Post{}, false, (*model.AppError)(nil))
|
|
|
|
scs := &Service{
|
|
server: mockServer,
|
|
platform: testNoopPlatform{},
|
|
app: mockApp,
|
|
}
|
|
|
|
_, err := scs.UnshareChannel(channelID)
|
|
require.NoError(t, err)
|
|
mockApp.AssertNumberOfCalls(t, "CreatePost", 1)
|
|
}
|
|
|
|
func TestUninviteRemoteFromChannel_postsUnsharedSystemMessage(t *testing.T) {
|
|
channelID := model.NewId()
|
|
remoteID := model.NewId()
|
|
scrID := model.NewId()
|
|
channel := &model.Channel{Id: channelID, TeamId: model.NewId()}
|
|
scr := &model.SharedChannelRemote{
|
|
Id: scrID,
|
|
ChannelId: channelID,
|
|
RemoteId: remoteID,
|
|
DeleteAt: 0,
|
|
}
|
|
rc := &model.RemoteCluster{RemoteId: remoteID, DisplayName: "Peer workspace"}
|
|
remaining := []*model.SharedChannelRemote{{Id: model.NewId(), ChannelId: channelID, RemoteId: model.NewId(), DeleteAt: 0}}
|
|
|
|
mockServer := &MockServerIface{}
|
|
logger := mlog.CreateConsoleTestLogger(t)
|
|
mockServer.On("Log").Return(logger)
|
|
setupMockServerWithConfig(mockServer)
|
|
|
|
mockStore := &mocks.Store{}
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
mockSharedChannelStore := mocks.SharedChannelStore{}
|
|
mockRemoteClusterStore := mocks.RemoteClusterStore{}
|
|
|
|
mockServer.On("GetStore").Return(mockStore)
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
mockStore.On("SharedChannel").Return(&mockSharedChannelStore)
|
|
mockStore.On("RemoteCluster").Return(&mockRemoteClusterStore)
|
|
|
|
mockSharedChannelStore.On("GetRemoteByIds", channelID, remoteID).Return(scr, nil).Once()
|
|
mockSharedChannelStore.On("DeleteRemote", scrID).Return(true, nil).Once()
|
|
mockChannelStore.On("Get", channelID, true).Return(channel, nil).Once()
|
|
mockRemoteClusterStore.On("Get", remoteID, false).Return(rc, nil).Once()
|
|
mockSharedChannelStore.On("GetRemotes", 0, 1, model.SharedChannelRemoteFilterOpts{
|
|
ChannelId: channelID,
|
|
IncludeUnconfirmed: true,
|
|
}).Return(remaining, nil).Once()
|
|
|
|
mockApp := &MockAppIface{}
|
|
bot := &model.Bot{UserId: model.NewId()}
|
|
mockApp.On("GetSystemBot", mock.Anything).Return(bot, (*model.AppError)(nil))
|
|
mockApp.On("CreatePost", mock.Anything, mock.AnythingOfType("*model.Post"), mock.AnythingOfType("*model.Channel"), mock.Anything).
|
|
Run(func(args mock.Arguments) {
|
|
post := args.Get(1).(*model.Post)
|
|
assert.Equal(t, "Peer workspace", post.GetProps()[model.PostPropsSharedChannelWorkspaceName])
|
|
assert.Equal(t, model.SharedChannelStatePostValueUnshared, post.GetProps()[model.PostPropsSharedChannelState])
|
|
}).Return(&model.Post{}, false, (*model.AppError)(nil))
|
|
|
|
scs := &Service{
|
|
server: mockServer,
|
|
platform: testNoopPlatform{},
|
|
app: mockApp,
|
|
}
|
|
|
|
err := scs.UninviteRemoteFromChannel(channelID, remoteID)
|
|
require.NoError(t, err)
|
|
|
|
mockApp.AssertNumberOfCalls(t, "CreatePost", 1)
|
|
mockSharedChannelStore.AssertNotCalled(t, "Delete", mock.Anything)
|
|
mockApp.AssertExpectations(t)
|
|
mockRemoteClusterStore.AssertExpectations(t)
|
|
}
|
|
|
|
func TestUninviteRemoteFromChannel_whenLastRemoteUnsharesChannel(t *testing.T) {
|
|
channelID := model.NewId()
|
|
remoteID := model.NewId()
|
|
scrID := model.NewId()
|
|
channel := &model.Channel{Id: channelID, TeamId: model.NewId()}
|
|
scr := &model.SharedChannelRemote{
|
|
Id: scrID,
|
|
ChannelId: channelID,
|
|
RemoteId: remoteID,
|
|
DeleteAt: 0,
|
|
}
|
|
rc := &model.RemoteCluster{RemoteId: remoteID, DisplayName: "Last peer"}
|
|
|
|
mockServer := &MockServerIface{}
|
|
logger := mlog.CreateConsoleTestLogger(t)
|
|
mockServer.On("Log").Return(logger)
|
|
setupMockServerWithConfig(mockServer)
|
|
|
|
mockStore := &mocks.Store{}
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
mockSharedChannelStore := mocks.SharedChannelStore{}
|
|
mockRemoteClusterStore := mocks.RemoteClusterStore{}
|
|
|
|
mockServer.On("GetStore").Return(mockStore)
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
mockStore.On("SharedChannel").Return(&mockSharedChannelStore)
|
|
mockStore.On("RemoteCluster").Return(&mockRemoteClusterStore)
|
|
|
|
mockSharedChannelStore.On("GetRemoteByIds", channelID, remoteID).Return(scr, nil).Once()
|
|
mockSharedChannelStore.On("DeleteRemote", scrID).Return(true, nil).Once()
|
|
// Channel load for uninvite system post, then UnshareChannel initial get, then UnshareChannel post-delete get.
|
|
mockChannelStore.On("Get", channelID, true).Return(channel, nil).Times(2)
|
|
mockChannelStore.On("Get", channelID, false).Return(channel, nil).Once()
|
|
mockRemoteClusterStore.On("Get", remoteID, false).Return(rc, nil).Once()
|
|
|
|
mockSharedChannelStore.On("GetRemotes", 0, 1, model.SharedChannelRemoteFilterOpts{
|
|
ChannelId: channelID,
|
|
IncludeUnconfirmed: true,
|
|
}).Return([]*model.SharedChannelRemote{}, nil).Once()
|
|
mockSharedChannelStore.On("GetRemotes", 0, 10000, model.SharedChannelRemoteFilterOpts{
|
|
ChannelId: channelID,
|
|
IncludeUnconfirmed: true,
|
|
}).Return([]*model.SharedChannelRemote{}, nil).Once()
|
|
mockSharedChannelStore.On("Delete", channelID).Return(true, nil).Once()
|
|
|
|
mockApp := &MockAppIface{}
|
|
bot := &model.Bot{UserId: model.NewId()}
|
|
mockApp.On("GetSystemBot", mock.Anything).Return(bot, (*model.AppError)(nil))
|
|
mockApp.On("Publish", mock.Anything).Return()
|
|
mockApp.On("CreatePost", mock.Anything, mock.AnythingOfType("*model.Post"), mock.AnythingOfType("*model.Channel"), mock.Anything).
|
|
Return(&model.Post{}, false, (*model.AppError)(nil))
|
|
|
|
scs := &Service{
|
|
server: mockServer,
|
|
platform: testNoopPlatform{},
|
|
app: mockApp,
|
|
}
|
|
|
|
err := scs.UninviteRemoteFromChannel(channelID, remoteID)
|
|
require.NoError(t, err)
|
|
|
|
// One system post from UninviteRemoteFromChannel; UnshareChannel sees no remotes so it does not add more.
|
|
mockApp.AssertNumberOfCalls(t, "CreatePost", 1)
|
|
mockSharedChannelStore.AssertCalled(t, "Delete", channelID)
|
|
mockRemoteClusterStore.AssertExpectations(t)
|
|
}
|