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.
398 lines
13 KiB
Go
398 lines
13 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package sharedchannel
|
|
|
|
import (
|
|
"net/http"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/hanzoteam/server/server/public/model"
|
|
"github.com/hanzoteam/server/server/public/plugin/plugintest/mock"
|
|
"github.com/hanzoteam/server/server/public/shared/mlog"
|
|
"github.com/hanzoteam/server/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)
|
|
|
|
mockConfig := model.Config{}
|
|
mockConfig.SetDefaults()
|
|
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)
|
|
require.NoError(t, err) // function returns nil even on individual failures
|
|
}
|
|
|
|
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)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: localUserId,
|
|
IsAdd: true,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc)
|
|
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)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: true,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc)
|
|
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)
|
|
|
|
// Expect the add to proceed
|
|
mockApp.On("AddUserToChannel", mockTypeReqContext, mockTypeUser, mockTypeChannel, true).Return(&model.ChannelMember{}, nil)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: true,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc)
|
|
require.NoError(t, err)
|
|
|
|
mockApp.AssertCalled(t, "AddUserToChannel", mockTypeReqContext, mockTypeUser, mockTypeChannel, true)
|
|
}
|
|
|
|
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)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: localUserId,
|
|
IsAdd: false,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc)
|
|
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)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: false,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc)
|
|
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)
|
|
|
|
// Expect the remove to proceed
|
|
mockApp.On("RemoveUserFromChannel", mockTypeReqContext, userId, "", channel).Return(nil)
|
|
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
MembershipChanges: []*model.MembershipChangeMsg{
|
|
{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: false,
|
|
ChangeTime: 1000,
|
|
},
|
|
},
|
|
}
|
|
|
|
err := scs.onReceiveMembershipChanges(syncMsg, rc)
|
|
require.NoError(t, err)
|
|
|
|
mockApp.AssertCalled(t, "RemoveUserFromChannel", mockTypeReqContext, userId, "", channel)
|
|
}
|
|
|
|
func TestProcessMemberAdd_SkipsLocalUser(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,
|
|
}
|
|
syncMsg := &model.SyncMsg{
|
|
ChannelId: channelId,
|
|
}
|
|
|
|
err := scs.processMemberAdd(change, channel, rc, syncMsg)
|
|
require.NoError(t, err, "local users should be silently skipped")
|
|
}
|
|
|
|
func TestProcessMemberRemove_SkipsLocalUser(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)
|
|
require.NoError(t, err, "local users should be silently skipped")
|
|
}
|
|
|
|
func TestProcessMemberAdd_IdempotentForExistingMember(t *testing.T) {
|
|
scs, _, mockApp, _, _, _, 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}
|
|
|
|
// User belongs to the sending remote
|
|
remoteUser := &model.User{Id: userId, RemoteId: &remoteId}
|
|
mockUserStore.On("Get", mockTypeContext, userId).Return(remoteUser, nil)
|
|
|
|
// Simulate "already added" error from AddUserToChannel
|
|
alreadyAddedErr := model.NewAppError("AddUserToChannel", errIDSaveMemberExists, nil, "", http.StatusBadRequest)
|
|
mockApp.On("AddUserToChannel", mockTypeReqContext, mockTypeUser, mockTypeChannel, true).Return(nil, alreadyAddedErr)
|
|
|
|
syncMsg := &model.SyncMsg{ChannelId: channelId}
|
|
change := &model.MembershipChangeMsg{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: true,
|
|
ChangeTime: 1000,
|
|
}
|
|
|
|
err := scs.processMemberAdd(change, channel, rc, syncMsg)
|
|
require.NoError(t, err, "should succeed for already-added user (idempotent)")
|
|
}
|
|
|
|
func TestProcessMemberRemove_IdempotentForNonMember(t *testing.T) {
|
|
scs, _, mockApp, _, _, 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)
|
|
|
|
// User belongs to the sending remote
|
|
remoteUser := &model.User{Id: userId, RemoteId: &remoteId}
|
|
mockUserStore.On("Get", mockTypeContext, userId).Return(remoteUser, nil)
|
|
|
|
// Simulate "not found" error from RemoveUserFromChannel
|
|
notFoundErr := model.NewAppError("RemoveUserFromChannel", errIDGetChannelMemberMissing, nil, "", http.StatusNotFound)
|
|
mockApp.On("RemoveUserFromChannel", mockTypeReqContext, userId, "", channel).Return(notFoundErr)
|
|
|
|
change := &model.MembershipChangeMsg{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
IsAdd: false,
|
|
ChangeTime: 1000,
|
|
}
|
|
|
|
err := scs.processMemberRemove(change, rc)
|
|
require.NoError(t, err, "should succeed for already-removed user (idempotent)")
|
|
}
|