364 строки
12 KiB
Go
364 строки
12 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package sharedchannel
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/mattermost/mattermost/server/public/model"
|
|
"github.com/mattermost/mattermost/server/public/plugin/plugintest/mock"
|
|
"github.com/mattermost/mattermost/server/public/shared/mlog"
|
|
"github.com/mattermost/mattermost/server/v8/channels/store/storetest/mocks"
|
|
)
|
|
|
|
// setupMembershipTest creates the common test fixtures for membership sync tests.
|
|
// Returns a Service, the mock stores, and IDs for the channel, remote, and team.
|
|
func setupMembershipTest(t *testing.T) (*Service, *MockServerIface, *MockAppIface, *mocks.Store, *mocks.SharedChannelStore, *mocks.ChannelStore, *mocks.UserStore) {
|
|
t.Helper()
|
|
|
|
mockServer := &MockServerIface{}
|
|
logger := mlog.CreateConsoleTestLogger(t)
|
|
mockServer.On("Log").Return(logger)
|
|
mockApp := &MockAppIface{}
|
|
scs := &Service{
|
|
server: mockServer,
|
|
app: mockApp,
|
|
}
|
|
|
|
mockStore := &mocks.Store{}
|
|
mockSharedChannelStore := &mocks.SharedChannelStore{}
|
|
mockChannelStore := &mocks.ChannelStore{}
|
|
mockUserStore := &mocks.UserStore{}
|
|
|
|
mockStore.On("SharedChannel").Return(mockSharedChannelStore)
|
|
mockStore.On("Channel").Return(mockChannelStore)
|
|
mockStore.On("User").Return(mockUserStore)
|
|
mockServer.On("GetStore").Return(mockStore)
|
|
|
|
// Enable membership sync feature flag
|
|
mockConfig := model.Config{}
|
|
mockConfig.SetDefaults()
|
|
mockConfig.FeatureFlags.EnableSharedChannelsMemberSync = true
|
|
mockServer.On("Config").Return(&mockConfig)
|
|
|
|
return scs, mockServer, mockApp, mockStore, mockSharedChannelStore, mockChannelStore, mockUserStore
|
|
}
|
|
|
|
func TestOnReceiveMembershipChanges_ChannelIdMismatch(t *testing.T) {
|
|
scs, _, _, _, mockSharedChannelStore, mockChannelStore, _ := setupMembershipTest(t)
|
|
|
|
channelId := model.NewId()
|
|
remoteId := model.NewId()
|
|
rc := &model.RemoteCluster{RemoteId: remoteId}
|
|
|
|
channel := &model.Channel{Id: channelId, Type: model.ChannelTypeOpen}
|
|
mockChannelStore.On("Get", channelId, true).Return(channel, nil)
|
|
mockSharedChannelStore.On("Get", channelId).Return(&model.SharedChannel{ChannelId: channelId}, nil)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: model.NewId(), // different channel ID
|
|
UserId: model.NewId(),
|
|
IsAdd: true,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc, nil)
|
|
require.NoError(t, err) // function returns nil even on individual failures
|
|
|
|
// The conflict check should never have been called since the mismatch was caught first
|
|
mockSharedChannelStore.AssertNotCalled(t, "GetUserChanges", mock.Anything, mock.Anything, mock.Anything)
|
|
}
|
|
|
|
func TestProcessMemberAdd_RejectsLocalUser(t *testing.T) {
|
|
scs, _, mockApp, _, mockSharedChannelStore, mockChannelStore, mockUserStore := setupMembershipTest(t)
|
|
|
|
channelId := model.NewId()
|
|
remoteId := model.NewId()
|
|
localUserId := model.NewId()
|
|
rc := &model.RemoteCluster{RemoteId: remoteId}
|
|
|
|
channel := &model.Channel{Id: channelId, Type: model.ChannelTypeOpen}
|
|
mockChannelStore.On("Get", channelId, true).Return(channel, nil)
|
|
mockSharedChannelStore.On("Get", channelId).Return(&model.SharedChannel{ChannelId: channelId}, nil)
|
|
|
|
// Local user has no remote ID
|
|
localUser := &model.User{Id: localUserId}
|
|
mockUserStore.On("Get", mockTypeContext, localUserId).Return(localUser, nil)
|
|
|
|
// No conflict
|
|
mockSharedChannelStore.On("GetUserChanges", localUserId, channelId, mock.AnythingOfType("int64")).Return([]*model.SharedChannelUser{}, nil)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: localUserId,
|
|
IsAdd: true,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc, nil)
|
|
require.NoError(t, err) // function returns nil even on individual failures
|
|
|
|
mockApp.AssertNotCalled(t, "AddUserToChannel", mock.Anything, mock.Anything, mock.Anything, mock.Anything)
|
|
}
|
|
|
|
func TestProcessMemberAdd_RejectsOtherRemoteUser(t *testing.T) {
|
|
scs, _, mockApp, _, mockSharedChannelStore, mockChannelStore, mockUserStore := setupMembershipTest(t)
|
|
|
|
channelId := model.NewId()
|
|
remoteId := model.NewId()
|
|
otherRemoteId := model.NewId()
|
|
userId := model.NewId()
|
|
rc := &model.RemoteCluster{RemoteId: remoteId}
|
|
|
|
channel := &model.Channel{Id: channelId, Type: model.ChannelTypeOpen}
|
|
mockChannelStore.On("Get", channelId, true).Return(channel, nil)
|
|
mockSharedChannelStore.On("Get", channelId).Return(&model.SharedChannel{ChannelId: channelId}, nil)
|
|
|
|
// User belongs to a different remote
|
|
otherRemoteUser := &model.User{Id: userId, RemoteId: &otherRemoteId}
|
|
mockUserStore.On("Get", mockTypeContext, userId).Return(otherRemoteUser, nil)
|
|
|
|
// No conflict
|
|
mockSharedChannelStore.On("GetUserChanges", userId, channelId, mock.AnythingOfType("int64")).Return([]*model.SharedChannelUser{}, nil)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: true,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc, nil)
|
|
require.NoError(t, err)
|
|
|
|
mockApp.AssertNotCalled(t, "AddUserToChannel", mock.Anything, mock.Anything, mock.Anything, mock.Anything)
|
|
}
|
|
|
|
func TestProcessMemberAdd_AllowsOwnRemoteUser(t *testing.T) {
|
|
scs, _, mockApp, _, mockSharedChannelStore, mockChannelStore, mockUserStore := setupMembershipTest(t)
|
|
|
|
channelId := model.NewId()
|
|
remoteId := model.NewId()
|
|
userId := model.NewId()
|
|
rc := &model.RemoteCluster{RemoteId: remoteId}
|
|
|
|
channel := &model.Channel{Id: channelId, Type: model.ChannelTypeOpen}
|
|
mockChannelStore.On("Get", channelId, true).Return(channel, nil)
|
|
mockSharedChannelStore.On("Get", channelId).Return(&model.SharedChannel{ChannelId: channelId}, nil)
|
|
|
|
// User belongs to the sending remote
|
|
remoteUser := &model.User{Id: userId, RemoteId: &remoteId}
|
|
mockUserStore.On("Get", mockTypeContext, userId).Return(remoteUser, nil)
|
|
|
|
// No conflict
|
|
mockSharedChannelStore.On("GetUserChanges", userId, channelId, mock.AnythingOfType("int64")).Return([]*model.SharedChannelUser{}, nil)
|
|
|
|
// Expect the add to proceed
|
|
mockApp.On("AddUserToChannel", mockTypeReqContext, mockTypeUser, mockTypeChannel, false).Return(&model.ChannelMember{}, nil)
|
|
mockSharedChannelStore.On("UpdateUserLastMembershipSyncAt", userId, channelId, remoteId, int64(1000)).Return(nil)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: true,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc, nil)
|
|
require.NoError(t, err)
|
|
|
|
mockApp.AssertCalled(t, "AddUserToChannel", mockTypeReqContext, mockTypeUser, mockTypeChannel, false)
|
|
}
|
|
|
|
func TestProcessMemberRemove_RejectsLocalUser(t *testing.T) {
|
|
scs, _, mockApp, _, mockSharedChannelStore, mockChannelStore, mockUserStore := setupMembershipTest(t)
|
|
|
|
channelId := model.NewId()
|
|
remoteId := model.NewId()
|
|
localUserId := model.NewId()
|
|
rc := &model.RemoteCluster{RemoteId: remoteId}
|
|
|
|
channel := &model.Channel{Id: channelId, Type: model.ChannelTypeOpen}
|
|
mockChannelStore.On("Get", channelId, true).Return(channel, nil)
|
|
mockSharedChannelStore.On("Get", channelId).Return(&model.SharedChannel{ChannelId: channelId}, nil)
|
|
|
|
// Local user has no remote ID
|
|
localUser := &model.User{Id: localUserId}
|
|
mockUserStore.On("Get", mockTypeContext, localUserId).Return(localUser, nil)
|
|
|
|
// No conflict
|
|
mockSharedChannelStore.On("GetUserChanges", localUserId, channelId, mock.AnythingOfType("int64")).Return([]*model.SharedChannelUser{}, nil)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: localUserId,
|
|
IsAdd: false,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc, nil)
|
|
require.NoError(t, err)
|
|
|
|
mockApp.AssertNotCalled(t, "RemoveUserFromChannel", mock.Anything, mock.Anything, mock.Anything, mock.Anything)
|
|
}
|
|
|
|
func TestProcessMemberRemove_RejectsOtherRemoteUser(t *testing.T) {
|
|
scs, _, mockApp, _, mockSharedChannelStore, mockChannelStore, mockUserStore := setupMembershipTest(t)
|
|
|
|
channelId := model.NewId()
|
|
remoteId := model.NewId()
|
|
otherRemoteId := model.NewId()
|
|
userId := model.NewId()
|
|
rc := &model.RemoteCluster{RemoteId: remoteId}
|
|
|
|
channel := &model.Channel{Id: channelId, Type: model.ChannelTypeOpen}
|
|
mockChannelStore.On("Get", channelId, true).Return(channel, nil)
|
|
mockSharedChannelStore.On("Get", channelId).Return(&model.SharedChannel{ChannelId: channelId}, nil)
|
|
|
|
// User belongs to a different remote
|
|
otherRemoteUser := &model.User{Id: userId, RemoteId: &otherRemoteId}
|
|
mockUserStore.On("Get", mockTypeContext, userId).Return(otherRemoteUser, nil)
|
|
|
|
// No conflict
|
|
mockSharedChannelStore.On("GetUserChanges", userId, channelId, mock.AnythingOfType("int64")).Return([]*model.SharedChannelUser{}, nil)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: false,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc, nil)
|
|
require.NoError(t, err)
|
|
|
|
mockApp.AssertNotCalled(t, "RemoveUserFromChannel", mock.Anything, mock.Anything, mock.Anything, mock.Anything)
|
|
}
|
|
|
|
func TestProcessMemberRemove_AllowsOwnRemoteUser(t *testing.T) {
|
|
scs, _, mockApp, _, mockSharedChannelStore, mockChannelStore, mockUserStore := setupMembershipTest(t)
|
|
|
|
channelId := model.NewId()
|
|
remoteId := model.NewId()
|
|
userId := model.NewId()
|
|
rc := &model.RemoteCluster{RemoteId: remoteId}
|
|
|
|
channel := &model.Channel{Id: channelId, Type: model.ChannelTypeOpen}
|
|
mockChannelStore.On("Get", channelId, true).Return(channel, nil)
|
|
mockSharedChannelStore.On("Get", channelId).Return(&model.SharedChannel{ChannelId: channelId}, nil)
|
|
|
|
// User belongs to the sending remote
|
|
remoteUser := &model.User{Id: userId, RemoteId: &remoteId}
|
|
mockUserStore.On("Get", mockTypeContext, userId).Return(remoteUser, nil)
|
|
|
|
// No conflict
|
|
mockSharedChannelStore.On("GetUserChanges", userId, channelId, mock.AnythingOfType("int64")).Return([]*model.SharedChannelUser{}, nil)
|
|
|
|
// Expect the remove to proceed
|
|
mockApp.On("RemoveUserFromChannel", mockTypeReqContext, userId, "", channel).Return(nil)
|
|
mockSharedChannelStore.On("UpdateUserLastMembershipSyncAt", userId, channelId, remoteId, int64(1000)).Return(nil)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: false,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc, nil)
|
|
require.NoError(t, err)
|
|
|
|
mockApp.AssertCalled(t, "RemoveUserFromChannel", mockTypeReqContext, userId, "", channel)
|
|
}
|
|
|
|
func TestProcessMemberAdd_RejectsLocalUser_ErrorMessage(t *testing.T) {
|
|
scs, _, _, _, _, _, mockUserStore := setupMembershipTest(t)
|
|
|
|
channelId := model.NewId()
|
|
remoteId := model.NewId()
|
|
localUserId := model.NewId()
|
|
rc := &model.RemoteCluster{RemoteId: remoteId}
|
|
|
|
channel := &model.Channel{Id: channelId, Type: model.ChannelTypeOpen}
|
|
|
|
// Local user (no remote ID) — needed for the fallback User().Get path
|
|
mockUserStore.On("Get", mockTypeContext, localUserId).Return(&model.User{Id: localUserId}, nil)
|
|
|
|
change := &model.MembershipChangeMsg{
|
|
ChannelId: channelId,
|
|
UserId: localUserId,
|
|
IsAdd: true,
|
|
ChangeTime: 1000,
|
|
}
|
|
err := scs.processMemberAdd(change, channel, rc, 1000)
|
|
require.Error(t, err)
|
|
assert.ErrorIs(t, err, ErrRemoteIDMismatch)
|
|
assert.Contains(t, err.Error(), "membership add sync failed")
|
|
}
|
|
|
|
func TestProcessMemberRemove_RejectsLocalUser_ErrorMessage(t *testing.T) {
|
|
scs, _, _, _, _, mockChannelStore, mockUserStore := setupMembershipTest(t)
|
|
|
|
channelId := model.NewId()
|
|
remoteId := model.NewId()
|
|
localUserId := model.NewId()
|
|
rc := &model.RemoteCluster{RemoteId: remoteId}
|
|
|
|
channel := &model.Channel{Id: channelId, Type: model.ChannelTypeOpen}
|
|
mockChannelStore.On("Get", channelId, true).Return(channel, nil)
|
|
|
|
// Local user (no remote ID)
|
|
mockUserStore.On("Get", mockTypeContext, localUserId).Return(&model.User{Id: localUserId}, nil)
|
|
|
|
change := &model.MembershipChangeMsg{
|
|
ChannelId: channelId,
|
|
UserId: localUserId,
|
|
IsAdd: false,
|
|
ChangeTime: 1000,
|
|
}
|
|
|
|
err := scs.processMemberRemove(change, rc, 1000)
|
|
require.Error(t, err)
|
|
assert.ErrorIs(t, err, ErrRemoteIDMismatch)
|
|
assert.Contains(t, err.Error(), "membership remove sync failed")
|
|
}
|