ec1f89217a
Full Mattermost server source with integrated Community Enterprise features. Includes vendor directory for offline/air-gapped builds. Structure: - enterprise-impl/: Enterprise feature implementations - enterprise-community/: Init files that register implementations - enterprise/: Bridge imports (community_imports.go) - vendor/: All dependencies for offline builds Build (online): go build ./cmd/mattermost Build (offline/air-gapped): go build -mod=vendor ./cmd/mattermost 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
3654 lines
127 KiB
Go
3654 lines
127 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package app
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/mattermost/mattermost/server/v8/channels/app/teams"
|
|
"github.com/mattermost/mattermost/server/v8/channels/app/users"
|
|
|
|
"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/v8/channels/store/storetest/mocks"
|
|
)
|
|
|
|
func TestPermanentDeleteChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.ServiceSettings.EnableIncomingWebhooks = true
|
|
*cfg.ServiceSettings.EnableOutgoingWebhooks = true
|
|
})
|
|
|
|
channel, appErr := th.App.CreateChannel(th.Context, &model.Channel{DisplayName: "deletion-test", Name: "deletion-test", Type: model.ChannelTypeOpen, TeamId: th.BasicTeam.Id}, false)
|
|
require.NotNil(t, channel, "Channel shouldn't be nil")
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
incoming, appErr := th.App.CreateIncomingWebhookForChannel(th.BasicUser.Id, channel, &model.IncomingWebhook{ChannelId: channel.Id})
|
|
require.NotNil(t, incoming, "incoming webhook should not be nil")
|
|
require.Nil(t, appErr, "Unable to create Incoming Webhook for Channel")
|
|
defer func(hookID string) {
|
|
appErr = th.App.DeleteIncomingWebhook(hookID)
|
|
require.Nil(t, appErr)
|
|
}(incoming.Id)
|
|
|
|
incoming, appErr = th.App.GetIncomingWebhook(incoming.Id)
|
|
require.NotNil(t, incoming, "incoming webhook should not be nil")
|
|
require.Nil(t, appErr, "Unable to get new incoming webhook")
|
|
|
|
outgoing, appErr := th.App.CreateOutgoingWebhook(&model.OutgoingWebhook{
|
|
ChannelId: channel.Id,
|
|
TeamId: channel.TeamId,
|
|
CreatorId: th.BasicUser.Id,
|
|
CallbackURLs: []string{"https://foo"},
|
|
})
|
|
require.Nil(t, appErr)
|
|
defer func(hookID string) {
|
|
appErr = th.App.DeleteOutgoingWebhook(hookID)
|
|
require.Nil(t, appErr)
|
|
}(outgoing.Id)
|
|
|
|
outgoing, appErr = th.App.GetOutgoingWebhook(outgoing.Id)
|
|
require.NotNil(t, outgoing, "Outgoing webhook should not be nil")
|
|
require.Nil(t, appErr, "Unable to get new outgoing webhook")
|
|
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
|
|
incoming, appErr = th.App.GetIncomingWebhook(incoming.Id)
|
|
require.Nil(t, incoming, "Incoming webhook should be nil")
|
|
require.NotNil(t, appErr, "Incoming webhook wasn't deleted")
|
|
|
|
outgoing, appErr = th.App.GetOutgoingWebhook(outgoing.Id)
|
|
require.Nil(t, outgoing, "Outgoing webhook should be nil")
|
|
require.NotNil(t, appErr, "Outgoing webhook wasn't deleted")
|
|
}
|
|
|
|
func TestRemoveAllDeactivatedMembersFromChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
var appErr *model.AppError
|
|
|
|
team := th.CreateTeam()
|
|
channel := th.CreateChannel(th.Context, team)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
appErr = th.App.PermanentDeleteTeam(th.Context, team)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, team.Id, th.BasicUser.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
deactivatedUser := th.CreateUser()
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, team.Id, deactivatedUser.Id, "")
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.AddUserToChannel(th.Context, deactivatedUser, channel, false)
|
|
require.Nil(t, appErr)
|
|
channelMembers, appErr := th.App.GetChannelMembersPage(th.Context, channel.Id, 0, 10000000)
|
|
require.Nil(t, appErr)
|
|
require.Len(t, channelMembers, 2)
|
|
_, appErr = th.App.UpdateActive(th.Context, deactivatedUser, false)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.RemoveAllDeactivatedMembersFromChannel(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
|
|
channelMembers, appErr = th.App.GetChannelMembersPage(th.Context, channel.Id, 0, 10000000)
|
|
require.Nil(t, appErr)
|
|
require.Len(t, channelMembers, 1)
|
|
}
|
|
|
|
func TestMoveChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
t.Run("should move channels between teams", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
var appErr *model.AppError
|
|
|
|
sourceTeam := th.CreateTeam()
|
|
targetTeam := th.CreateTeam()
|
|
channel1 := th.CreateChannel(th.Context, sourceTeam)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channel1)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.PermanentDeleteTeam(th.Context, sourceTeam)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.PermanentDeleteTeam(th.Context, targetTeam)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, sourceTeam.Id, th.BasicUser.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, sourceTeam.Id, th.BasicUser2.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, targetTeam.Id, th.BasicUser.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser, channel1, false)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser2, channel1, false)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.MoveChannel(th.Context, targetTeam, channel1, th.BasicUser)
|
|
require.NotNil(t, appErr, "Should have failed due to mismatched members.")
|
|
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, targetTeam.Id, th.BasicUser2.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.MoveChannel(th.Context, targetTeam, channel1, th.BasicUser)
|
|
require.Nil(t, appErr)
|
|
|
|
// Test moving a channel with a deactivated user who isn't in the destination team.
|
|
// It should fail, unless removeDeactivatedMembers is true.
|
|
deactivatedUser := th.CreateUser()
|
|
channel2 := th.CreateChannel(th.Context, sourceTeam)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channel2)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, sourceTeam.Id, deactivatedUser.Id, "")
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser, channel2, false)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, deactivatedUser, channel2, false)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.UpdateActive(th.Context, deactivatedUser, false)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.MoveChannel(th.Context, targetTeam, channel2, th.BasicUser)
|
|
require.NotNil(t, appErr, "Should have failed due to mismatched deactivated member.")
|
|
|
|
// Test moving a channel with no members.
|
|
channel3 := &model.Channel{
|
|
DisplayName: "dn_" + model.NewId(),
|
|
Name: "name_" + model.NewId(),
|
|
Type: model.ChannelTypeOpen,
|
|
TeamId: sourceTeam.Id,
|
|
CreatorId: th.BasicUser.Id,
|
|
}
|
|
|
|
channel3, appErr = th.App.CreateChannel(th.Context, channel3, false)
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channel3)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
appErr = th.App.MoveChannel(th.Context, targetTeam, channel3, th.BasicUser)
|
|
assert.Nil(t, appErr)
|
|
})
|
|
|
|
t.Run("should remove sidebar entries when moving channels from one team to another", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
sourceTeam := th.CreateTeam()
|
|
targetTeam := th.CreateTeam()
|
|
channel := th.CreateChannel(th.Context, sourceTeam)
|
|
|
|
th.LinkUserToTeam(th.BasicUser, sourceTeam)
|
|
th.LinkUserToTeam(th.BasicUser, targetTeam)
|
|
th.AddUserToChannel(th.BasicUser, channel)
|
|
|
|
// Put the channel in a custom category so that it explicitly exists in SidebarChannels
|
|
category, appErr := th.App.CreateSidebarCategory(th.Context, th.BasicUser.Id, sourceTeam.Id, &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
DisplayName: "new category",
|
|
},
|
|
Channels: []string{channel.Id},
|
|
})
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, []string{channel.Id}, category.Channels)
|
|
|
|
appErr = th.App.MoveChannel(th.Context, targetTeam, channel, th.BasicUser)
|
|
require.Nil(t, appErr)
|
|
|
|
moved, appErr := th.App.GetChannel(th.Context, channel.Id)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, targetTeam.Id, moved.TeamId)
|
|
|
|
// The channel should no longer be on the old team
|
|
updatedCategory, appErr := th.App.GetSidebarCategory(th.Context, category.Id)
|
|
require.Nil(t, appErr)
|
|
assert.Equal(t, []string{}, updatedCategory.Channels)
|
|
|
|
// And it should be on the new team instead
|
|
categories, appErr := th.App.GetSidebarCategoriesForTeamForUser(th.Context, th.BasicUser.Id, targetTeam.Id)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, model.SidebarCategoryChannels, categories.Categories[1].Type)
|
|
assert.Contains(t, categories.Categories[1].Channels, channel.Id)
|
|
})
|
|
|
|
t.Run("should update threads when moving channels between teams", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
sourceTeam := th.CreateTeam()
|
|
targetTeam := th.CreateTeam()
|
|
channel := th.CreateChannel(th.Context, sourceTeam)
|
|
|
|
th.LinkUserToTeam(th.BasicUser, sourceTeam)
|
|
th.LinkUserToTeam(th.BasicUser, targetTeam)
|
|
th.AddUserToChannel(th.BasicUser, channel)
|
|
|
|
// Create a thread in the channel
|
|
post := &model.Post{
|
|
UserId: th.BasicUser.Id,
|
|
ChannelId: channel.Id,
|
|
Message: "test",
|
|
}
|
|
post, appErr := th.App.CreatePost(th.Context, post, channel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
|
|
// Post a reply to the thread
|
|
reply := &model.Post{
|
|
UserId: th.BasicUser.Id,
|
|
ChannelId: channel.Id,
|
|
RootId: post.Id,
|
|
Message: "reply",
|
|
}
|
|
_, appErr = th.App.CreatePost(th.Context, reply, channel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
|
|
// Check that the thread count before move
|
|
threads, appErr := th.App.GetThreadsForUser(th.Context, th.BasicUser.Id, targetTeam.Id, model.GetUserThreadsOpts{})
|
|
require.Nil(t, appErr)
|
|
|
|
require.Zero(t, threads.Total)
|
|
|
|
// Move the channel to the target team
|
|
appErr = th.App.MoveChannel(th.Context, targetTeam, channel, th.BasicUser)
|
|
require.Nil(t, appErr)
|
|
|
|
// Check that the thread was moved
|
|
threads, appErr = th.App.GetThreadsForUser(th.Context, th.BasicUser.Id, targetTeam.Id, model.GetUserThreadsOpts{})
|
|
require.Nil(t, appErr)
|
|
|
|
require.Equal(t, int64(1), threads.Total)
|
|
// Check that the thread count after move
|
|
threads, appErr = th.App.GetThreadsForUser(th.Context, th.BasicUser.Id, sourceTeam.Id, model.GetUserThreadsOpts{})
|
|
require.Nil(t, appErr)
|
|
|
|
require.Zero(t, threads.Total)
|
|
})
|
|
}
|
|
|
|
func TestRemoveUsersFromChannelNotMemberOfTeam(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
team := th.CreateTeam()
|
|
team2 := th.CreateTeam()
|
|
channel1 := th.CreateChannel(th.Context, team)
|
|
defer func() {
|
|
appErr := th.App.PermanentDeleteChannel(th.Context, channel1)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.PermanentDeleteTeam(th.Context, team)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.PermanentDeleteTeam(th.Context, team2)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
_, _, appErr := th.App.AddUserToTeam(th.Context, team.Id, th.BasicUser.Id, "")
|
|
require.Nil(t, appErr)
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, team2.Id, th.BasicUser.Id, "")
|
|
require.Nil(t, appErr)
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, team.Id, th.BasicUser2.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser, channel1, false)
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser2, channel1, false)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.RemoveUsersFromChannelNotMemberOfTeam(th.Context, th.SystemAdminUser, channel1, team2)
|
|
require.Nil(t, appErr)
|
|
|
|
channelMembers, appErr := th.App.GetChannelMembersPage(th.Context, channel1.Id, 0, 10000000)
|
|
require.Nil(t, appErr)
|
|
require.Len(t, channelMembers, 1)
|
|
members := make([]model.ChannelMember, len(channelMembers))
|
|
copy(members, channelMembers)
|
|
require.Equal(t, members[0].UserId, th.BasicUser.Id)
|
|
}
|
|
|
|
func TestJoinDefaultChannelsCreatesChannelMemberHistoryRecordTownSquare(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// figure out the initial number of users in town square
|
|
channel, err := th.App.Srv().Store().Channel().GetByName(th.BasicTeam.Id, "town-square", true)
|
|
require.NoError(t, err)
|
|
townSquareChannelID := channel.Id
|
|
users, nErr := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{townSquareChannelID})
|
|
require.NoError(t, nErr)
|
|
initialNumTownSquareUsers := len(users)
|
|
|
|
// create a new user that joins the default channels
|
|
user := th.CreateUser()
|
|
appErr := th.App.JoinDefaultChannels(th.Context, th.BasicTeam.Id, user, false, "")
|
|
require.Nil(t, appErr)
|
|
|
|
// there should be a ChannelMemberHistory record for the user
|
|
histories, nErr := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{townSquareChannelID})
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, histories, initialNumTownSquareUsers+1)
|
|
|
|
found := false
|
|
for _, history := range histories {
|
|
if user.Id == history.UserId && townSquareChannelID == history.ChannelId {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
assert.True(t, found)
|
|
}
|
|
|
|
func TestJoinDefaultChannelsCreatesChannelMemberHistoryRecordOffTopic(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// figure out the initial number of users in off-topic
|
|
channel, err := th.App.Srv().Store().Channel().GetByName(th.BasicTeam.Id, "off-topic", true)
|
|
require.NoError(t, err)
|
|
offTopicChannelId := channel.Id
|
|
users, nErr := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{offTopicChannelId})
|
|
require.NoError(t, nErr)
|
|
initialNumTownSquareUsers := len(users)
|
|
|
|
// create a new user that joins the default channels
|
|
user := th.CreateUser()
|
|
appError := th.App.JoinDefaultChannels(th.Context, th.BasicTeam.Id, user, false, "")
|
|
require.Nil(t, appError)
|
|
|
|
// there should be a ChannelMemberHistory record for the user
|
|
histories, nErr := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{offTopicChannelId})
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, histories, initialNumTownSquareUsers+1)
|
|
|
|
found := false
|
|
for _, history := range histories {
|
|
if user.Id == history.UserId && offTopicChannelId == history.ChannelId {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
assert.True(t, found)
|
|
}
|
|
|
|
func TestJoinDefaultChannelsExperimentalDefaultChannels(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
basicChannel2 := th.CreateChannel(th.Context, th.BasicTeam)
|
|
defer func() {
|
|
appErr := th.App.PermanentDeleteChannel(th.Context, basicChannel2)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
defaultChannelList := []string{th.BasicChannel.Name, basicChannel2.Name, basicChannel2.Name}
|
|
th.App.Config().TeamSettings.ExperimentalDefaultChannels = defaultChannelList
|
|
|
|
user := th.CreateUser()
|
|
appErr := th.App.JoinDefaultChannels(th.Context, th.BasicTeam.Id, user, false, "")
|
|
require.Nil(t, appErr)
|
|
|
|
for _, channelName := range defaultChannelList {
|
|
channel, appErr := th.App.GetChannelByName(th.Context, channelName, th.BasicTeam.Id, false)
|
|
require.Nil(t, appErr, "Expected nil, didn't receive nil")
|
|
|
|
member, appErr := th.App.GetChannelMember(th.Context, channel.Id, user.Id)
|
|
require.Nil(t, appErr, "Expected nil object, didn't receive nil")
|
|
require.NotNil(t, member, "Expected member object, got nil")
|
|
}
|
|
}
|
|
|
|
func TestJoinDefaultChannelsExperimentalDefaultChannelsMissing(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
basicChannel2 := th.CreateChannel(th.Context, th.BasicTeam)
|
|
defer func() {
|
|
appErr := th.App.PermanentDeleteChannel(th.Context, basicChannel2)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
defaultChannelList := []string{th.BasicChannel.Name, basicChannel2.Name, "thischanneldoesnotexist", basicChannel2.Name}
|
|
th.App.Config().TeamSettings.ExperimentalDefaultChannels = defaultChannelList
|
|
|
|
user := th.CreateUser()
|
|
require.Nil(t, th.App.JoinDefaultChannels(th.Context, th.BasicTeam.Id, user, false, ""))
|
|
|
|
for _, channelName := range defaultChannelList {
|
|
if channelName == "thischanneldoesnotexist" {
|
|
continue // skip the non-existent channel
|
|
}
|
|
|
|
channel, appErr := th.App.GetChannelByName(th.Context, channelName, th.BasicTeam.Id, false)
|
|
require.Nil(t, appErr, "Expected nil, didn't receive nil")
|
|
|
|
member, appErr := th.App.GetChannelMember(th.Context, channel.Id, user.Id)
|
|
|
|
require.NotNil(t, member, "Expected member object, got nil")
|
|
require.Nil(t, appErr, "Expected nil object, didn't receive nil")
|
|
}
|
|
}
|
|
|
|
func TestCreateChannelPublicCreatesChannelMemberHistoryRecord(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// creates a public channel and adds basic user to it
|
|
publicChannel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
|
|
// there should be a ChannelMemberHistory record for the user
|
|
histories, err := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{publicChannel.Id})
|
|
require.NoError(t, err)
|
|
assert.Len(t, histories, 1)
|
|
assert.Equal(t, th.BasicUser.Id, histories[0].UserId)
|
|
assert.Equal(t, publicChannel.Id, histories[0].ChannelId)
|
|
}
|
|
|
|
func TestCreateChannelPrivateCreatesChannelMemberHistoryRecord(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// creates a private channel and adds basic user to it
|
|
privateChannel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypePrivate)
|
|
|
|
// there should be a ChannelMemberHistory record for the user
|
|
histories, err := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{privateChannel.Id})
|
|
require.NoError(t, err)
|
|
assert.Len(t, histories, 1)
|
|
assert.Equal(t, th.BasicUser.Id, histories[0].UserId)
|
|
assert.Equal(t, privateChannel.Id, histories[0].ChannelId)
|
|
}
|
|
|
|
func TestCreateChannelDisplayNameTrimsWhitespace(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
channel, appErr := th.App.CreateChannel(th.Context, &model.Channel{DisplayName: " Public 1 ", Name: "public1", Type: model.ChannelTypeOpen, TeamId: th.BasicTeam.Id}, false)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, channel.DisplayName, "Public 1")
|
|
}
|
|
|
|
func TestUpdateChannelPrivacy(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
privateChannel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypePrivate)
|
|
privateChannel.Type = model.ChannelTypeOpen
|
|
|
|
publicChannel, appErr := th.App.UpdateChannelPrivacy(th.Context, privateChannel, th.BasicUser)
|
|
require.Nil(t, appErr, "Failed to update channel privacy.")
|
|
assert.Equal(t, publicChannel.Id, privateChannel.Id)
|
|
assert.Equal(t, publicChannel.Type, model.ChannelTypeOpen)
|
|
}
|
|
|
|
func TestGetOrCreateDirectChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
team1 := th.CreateTeam()
|
|
team2 := th.CreateTeam()
|
|
|
|
user1 := th.CreateUser()
|
|
th.LinkUserToTeam(user1, team1)
|
|
|
|
user2 := th.CreateUser()
|
|
th.LinkUserToTeam(user2, team2)
|
|
|
|
bot1 := th.CreateBot()
|
|
|
|
t.Run("Bot can create with restriction", func(t *testing.T) {
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
setting := model.DirectMessageTeam
|
|
cfg.TeamSettings.RestrictDirectMessage = &setting
|
|
})
|
|
|
|
// Create a session for the bot owner so IsBotOwnedByCurrentUserOrPlugin can work
|
|
session, err := th.App.CreateSession(th.Context, &model.Session{
|
|
UserId: th.BasicUser.Id,
|
|
Roles: th.BasicUser.GetRawRoles(),
|
|
})
|
|
require.Nil(t, err)
|
|
rctx := th.Context.WithSession(session)
|
|
|
|
// check with bot in first userid param
|
|
channel, appErr := th.App.GetOrCreateDirectChannel(rctx, bot1.UserId, user1.Id)
|
|
require.NotNil(t, channel, "channel should be non-nil")
|
|
require.Nil(t, appErr)
|
|
|
|
// check with bot in second userid param
|
|
channel, appErr = th.App.GetOrCreateDirectChannel(rctx, user1.Id, bot1.UserId)
|
|
require.NotNil(t, channel, "channel should be non-nil")
|
|
require.Nil(t, appErr)
|
|
})
|
|
|
|
t.Run("User from other team cannot create with restriction", func(t *testing.T) {
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
setting := model.DirectMessageTeam
|
|
cfg.TeamSettings.RestrictDirectMessage = &setting
|
|
})
|
|
|
|
channel, appErr := th.App.GetOrCreateDirectChannel(th.Context, user1.Id, user2.Id)
|
|
require.Nil(t, channel, "channel should be nil")
|
|
require.NotNil(t, appErr)
|
|
})
|
|
|
|
t.Run("Cannot create with a remote user", func(t *testing.T) {
|
|
user2.RemoteId = model.NewPointer(model.NewId())
|
|
_, appErr := th.App.UpdateUser(th.Context, user2, false)
|
|
require.Nil(t, appErr)
|
|
|
|
dm, appErr := th.App.GetOrCreateDirectChannel(th.Context, user1.Id, user2.Id)
|
|
require.Nil(t, dm)
|
|
require.NotNil(t, appErr)
|
|
})
|
|
}
|
|
|
|
func TestCreateGroupChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
user1 := th.CreateUser()
|
|
user2 := th.CreateUser()
|
|
|
|
groupUserIds := make([]string, 0)
|
|
groupUserIds = append(groupUserIds, user1.Id)
|
|
groupUserIds = append(groupUserIds, user2.Id)
|
|
groupUserIds = append(groupUserIds, th.BasicUser.Id)
|
|
|
|
t.Run("Should not allow to create a group with a remote user", func(t *testing.T) {
|
|
user2.RemoteId = model.NewPointer(model.NewId())
|
|
_, appErr := th.App.UpdateUser(th.Context, user2, false)
|
|
require.Nil(t, appErr)
|
|
|
|
dm, appErr := th.App.CreateGroupChannel(th.Context, groupUserIds, th.BasicUser.Id)
|
|
require.NotNil(t, appErr)
|
|
require.Nil(t, dm)
|
|
})
|
|
}
|
|
|
|
func TestCreateGroupChannelCreatesChannelMemberHistoryRecord(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
user1 := th.CreateUser()
|
|
user2 := th.CreateUser()
|
|
|
|
groupUserIds := make([]string, 0)
|
|
groupUserIds = append(groupUserIds, user1.Id)
|
|
groupUserIds = append(groupUserIds, user2.Id)
|
|
groupUserIds = append(groupUserIds, th.BasicUser.Id)
|
|
|
|
channel, appErr := th.App.CreateGroupChannel(th.Context, groupUserIds, th.BasicUser.Id)
|
|
|
|
require.Nil(t, appErr, "Failed to create group channel.")
|
|
histories, nErr := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{channel.Id})
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, histories, 3)
|
|
|
|
channelMemberHistoryUserIds := make([]string, 0)
|
|
for _, history := range histories {
|
|
assert.Equal(t, channel.Id, history.ChannelId)
|
|
channelMemberHistoryUserIds = append(channelMemberHistoryUserIds, history.UserId)
|
|
}
|
|
|
|
sort.Strings(groupUserIds)
|
|
sort.Strings(channelMemberHistoryUserIds)
|
|
assert.Equal(t, groupUserIds, channelMemberHistoryUserIds)
|
|
}
|
|
|
|
func TestCreateDirectChannelCreatesChannelMemberHistoryRecord(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t)
|
|
defer th.TearDown()
|
|
|
|
user1 := th.CreateUser()
|
|
user2 := th.CreateUser()
|
|
|
|
channel, appErr := th.App.GetOrCreateDirectChannel(th.Context, user1.Id, user2.Id)
|
|
require.Nil(t, appErr, "Failed to create direct channel.")
|
|
|
|
histories, nErr := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{channel.Id})
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, histories, 2)
|
|
|
|
historyId0 := histories[0].UserId
|
|
historyId1 := histories[1].UserId
|
|
switch historyId0 {
|
|
case user1.Id:
|
|
assert.Equal(t, user2.Id, historyId1)
|
|
case user2.Id:
|
|
assert.Equal(t, user1.Id, historyId1)
|
|
default:
|
|
require.Fail(t, "Unexpected user id in ChannelMemberHistory table", historyId0)
|
|
}
|
|
}
|
|
|
|
func TestGetDirectChannelCreatesChannelMemberHistoryRecord(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t)
|
|
defer th.TearDown()
|
|
|
|
user1 := th.CreateUser()
|
|
user2 := th.CreateUser()
|
|
|
|
// this function call implicitly creates a direct channel between the two users if one doesn't already exist
|
|
channel, appErr := th.App.GetOrCreateDirectChannel(th.Context, user1.Id, user2.Id)
|
|
require.Nil(t, appErr, "Failed to create direct channel.")
|
|
|
|
// there should be a ChannelMemberHistory record for both users
|
|
histories, nErr := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{channel.Id})
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, histories, 2)
|
|
|
|
historyId0 := histories[0].UserId
|
|
historyId1 := histories[1].UserId
|
|
switch historyId0 {
|
|
case user1.Id:
|
|
assert.Equal(t, user2.Id, historyId1)
|
|
case user2.Id:
|
|
assert.Equal(t, user1.Id, historyId1)
|
|
default:
|
|
require.Fail(t, "Unexpected user id in ChannelMemberHistory table", historyId0)
|
|
}
|
|
}
|
|
|
|
func TestAddUserToChannelCreatesChannelMemberHistoryRecord(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic().DeleteBots()
|
|
defer th.TearDown()
|
|
|
|
// create a user and add it to a channel
|
|
user := th.CreateUser()
|
|
_, appErr := th.App.AddTeamMember(th.Context, th.BasicTeam.Id, user.Id)
|
|
require.Nil(t, appErr, "Failed to add user to team.")
|
|
|
|
groupUserIds := make([]string, 0)
|
|
groupUserIds = append(groupUserIds, th.BasicUser.Id)
|
|
groupUserIds = append(groupUserIds, user.Id)
|
|
|
|
channel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, user, channel, false)
|
|
require.Nil(t, appErr, "Failed to add user to channel.")
|
|
|
|
// there should be a ChannelMemberHistory record for the user
|
|
histories, nErr := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{channel.Id})
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, histories, 2)
|
|
channelMemberHistoryUserIds := make([]string, 0)
|
|
for _, history := range histories {
|
|
assert.Equal(t, channel.Id, history.ChannelId)
|
|
channelMemberHistoryUserIds = append(channelMemberHistoryUserIds, history.UserId)
|
|
}
|
|
assert.Equal(t, groupUserIds, channelMemberHistoryUserIds)
|
|
}
|
|
|
|
func TestUsersAndPostsCreateActivityInChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic().DeleteBots()
|
|
defer th.TearDown()
|
|
|
|
user := th.CreateUser()
|
|
_, err := th.App.AddTeamMember(th.Context, th.BasicTeam.Id, user.Id)
|
|
require.Nil(t, err, "Failed to add user to team.")
|
|
user3 := th.CreateUser()
|
|
_, err = th.App.AddTeamMember(th.Context, th.BasicTeam.Id, user3.Id)
|
|
require.Nil(t, err, "Failed to add user to team.")
|
|
user4 := th.CreateUser()
|
|
_, err = th.App.AddTeamMember(th.Context, th.BasicTeam.Id, user4.Id)
|
|
require.Nil(t, err, "Failed to add user to team.")
|
|
|
|
channel1 := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
channel2 := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
channel3 := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
channel4 := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
channel5 := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
channel6 := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
|
|
// user3 is already in channel3
|
|
_, err = th.App.AddUserToChannel(th.Context, user3, channel3, false)
|
|
require.Nil(t, err, "Failed to add user to channel.")
|
|
// user4 is already in channel4 (for the second part of the test)
|
|
_, err = th.App.AddUserToChannel(th.Context, user4, channel4, false)
|
|
require.Nil(t, err, "Failed to add user to channel.")
|
|
|
|
// make sure we don't catch earlier posts
|
|
time.Sleep(10 * time.Millisecond)
|
|
testStart := model.GetMillis()
|
|
|
|
// Test: previous activity (user3 and 4's adds) aren't showing up:
|
|
channelIds, nErr := th.App.Srv().Store().ChannelMemberHistory().GetChannelsWithActivityDuring(testStart, testStart+10000)
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, channelIds, 0)
|
|
|
|
// Posts, adds, and leaves should create activity
|
|
post := &model.Post{
|
|
ChannelId: channel1.Id,
|
|
Message: "root post",
|
|
UserId: th.BasicUser.Id,
|
|
}
|
|
_, err = th.App.CreatePost(th.Context, post, channel1, model.CreatePostFlags{})
|
|
require.Nil(t, err, "Failed to create post.")
|
|
|
|
_, err = th.App.AddUserToChannel(th.Context, user, channel2, false)
|
|
require.Nil(t, err, "Failed to add user to channel.")
|
|
|
|
err = th.App.RemoveUserFromChannel(th.Context, user3.Id, user3.Id, channel3)
|
|
require.Nil(t, err, "Failed to add user to channel.")
|
|
|
|
// Test: there should be a ChannelMemberHistory record for the users and the post
|
|
channelIds, nErr = th.App.Srv().Store().ChannelMemberHistory().GetChannelsWithActivityDuring(testStart, model.GetMillis())
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, channelIds, 3)
|
|
assert.ElementsMatch(t, []string{channel1.Id, channel2.Id, channel3.Id}, channelIds)
|
|
|
|
testEnd := model.GetMillis()
|
|
// In case the tests are running very fast:
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
// Now, we do not find activity for new posts, leaves, or adds after the test is over
|
|
post2 := &model.Post{
|
|
ChannelId: channel5.Id,
|
|
Message: "root post",
|
|
UserId: th.BasicUser.Id,
|
|
}
|
|
err = th.App.RemoveUserFromChannel(th.Context, user4.Id, user4.Id, channel4)
|
|
require.Nil(t, err, "Failed to create post.")
|
|
_, err = th.App.CreatePost(th.Context, post2, channel5, model.CreatePostFlags{})
|
|
require.Nil(t, err, "Failed to create post.")
|
|
_, err = th.App.AddUserToChannel(th.Context, user, channel6, false)
|
|
require.Nil(t, err, "Failed to add user to channel.")
|
|
|
|
// Test: we get the same three channels as before, not channels 4, 5, 6 which have activity after testEnd
|
|
channelIds, nErr = th.App.Srv().Store().ChannelMemberHistory().GetChannelsWithActivityDuring(testStart, testEnd)
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, channelIds, 3)
|
|
assert.ElementsMatch(t, []string{channel1.Id, channel2.Id, channel3.Id}, channelIds)
|
|
}
|
|
|
|
func TestLeaveDefaultChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
guest := th.CreateGuest()
|
|
th.LinkUserToTeam(guest, th.BasicTeam)
|
|
|
|
townSquare, appErr := th.App.GetChannelByName(th.Context, "town-square", th.BasicTeam.Id, false)
|
|
require.Nil(t, appErr)
|
|
th.AddUserToChannel(guest, townSquare)
|
|
th.AddUserToChannel(th.BasicUser, townSquare)
|
|
|
|
t.Run("User tries to leave the default channel", func(t *testing.T) {
|
|
appErr = th.App.LeaveChannel(th.Context, townSquare.Id, th.BasicUser.Id)
|
|
assert.NotNil(t, appErr, "It should fail to remove a regular user from the default channel")
|
|
assert.Equal(t, appErr.Id, "api.channel.remove.default.app_error")
|
|
_, appErr = th.App.GetChannelMember(th.Context, townSquare.Id, th.BasicUser.Id)
|
|
assert.Nil(t, appErr)
|
|
})
|
|
|
|
t.Run("Guest leaves the default channel", func(t *testing.T) {
|
|
appErr = th.App.LeaveChannel(th.Context, townSquare.Id, guest.Id)
|
|
assert.Nil(t, appErr, "It should allow to remove a guest user from the default channel")
|
|
_, appErr = th.App.GetChannelMember(th.Context, townSquare.Id, guest.Id)
|
|
assert.NotNil(t, appErr)
|
|
})
|
|
|
|
t.Run("Trying to leave the default channel should not delete thread memberships", func(t *testing.T) {
|
|
post := &model.Post{
|
|
ChannelId: townSquare.Id,
|
|
Message: "root post",
|
|
UserId: th.BasicUser.Id,
|
|
}
|
|
rpost, appErr := th.App.CreatePost(th.Context, post, th.BasicChannel, model.CreatePostFlags{SetOnline: true})
|
|
require.Nil(t, appErr)
|
|
|
|
reply := &model.Post{
|
|
ChannelId: townSquare.Id,
|
|
Message: "reply post",
|
|
UserId: th.BasicUser.Id,
|
|
RootId: rpost.Id,
|
|
}
|
|
_, appErr = th.App.CreatePost(th.Context, reply, th.BasicChannel, model.CreatePostFlags{SetOnline: true})
|
|
require.Nil(t, appErr)
|
|
|
|
threads, appErr := th.App.GetThreadsForUser(th.Context, th.BasicUser.Id, townSquare.TeamId, model.GetUserThreadsOpts{})
|
|
require.Nil(t, appErr)
|
|
require.Len(t, threads.Threads, 1)
|
|
|
|
appErr = th.App.LeaveChannel(th.Context, townSquare.Id, th.BasicUser.Id)
|
|
assert.NotNil(t, appErr, "It should fail to remove a regular user from the default channel")
|
|
assert.Equal(t, appErr.Id, "api.channel.remove.default.app_error")
|
|
|
|
threads, appErr = th.App.GetThreadsForUser(th.Context, th.BasicUser.Id, townSquare.TeamId, model.GetUserThreadsOpts{})
|
|
require.Nil(t, appErr)
|
|
require.Len(t, threads.Threads, 1)
|
|
})
|
|
}
|
|
|
|
func TestLeaveChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
createThread := func(channel *model.Channel) (rpost *model.Post) {
|
|
t.Helper()
|
|
post := &model.Post{
|
|
ChannelId: channel.Id,
|
|
Message: "root post",
|
|
UserId: th.BasicUser.Id,
|
|
}
|
|
|
|
rpost, appErr := th.App.CreatePost(th.Context, post, th.BasicChannel, model.CreatePostFlags{SetOnline: true})
|
|
require.Nil(t, appErr)
|
|
|
|
reply := &model.Post{
|
|
ChannelId: channel.Id,
|
|
Message: "reply post",
|
|
UserId: th.BasicUser.Id,
|
|
RootId: rpost.Id,
|
|
}
|
|
_, appErr = th.App.CreatePost(th.Context, reply, th.BasicChannel, model.CreatePostFlags{SetOnline: true})
|
|
require.Nil(t, appErr)
|
|
|
|
return rpost
|
|
}
|
|
|
|
t.Run("thread memberships are deleted", func(t *testing.T) {
|
|
createThread(th.BasicChannel)
|
|
channel2 := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
createThread(channel2)
|
|
|
|
threads, appErr := th.App.GetThreadsForUser(th.Context, th.BasicUser.Id, th.BasicChannel.TeamId, model.GetUserThreadsOpts{})
|
|
require.Nil(t, appErr)
|
|
require.Len(t, threads.Threads, 2)
|
|
|
|
appErr = th.App.LeaveChannel(th.Context, th.BasicChannel.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.GetChannelMember(th.Context, th.BasicChannel.Id, th.BasicUser.Id)
|
|
require.NotNil(t, appErr, "It should remove channel membership")
|
|
|
|
threads, appErr = th.App.GetThreadsForUser(th.Context, th.BasicUser.Id, th.BasicChannel.TeamId, model.GetUserThreadsOpts{})
|
|
require.Nil(t, appErr)
|
|
require.Len(t, threads.Threads, 1)
|
|
})
|
|
|
|
t.Run("can leave private channel as last member", func(t *testing.T) {
|
|
channel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypePrivate)
|
|
|
|
count, appErr := th.App.GetChannelMemberCount(th.Context, channel.Id)
|
|
require.Nil(t, appErr, "It should get the channel member count")
|
|
require.Equal(t, int64(1), count)
|
|
|
|
appErr = th.App.LeaveChannel(th.Context, channel.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
})
|
|
}
|
|
|
|
func TestLeaveLastChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
guest := th.CreateGuest()
|
|
th.LinkUserToTeam(guest, th.BasicTeam)
|
|
|
|
townSquare, appErr := th.App.GetChannelByName(th.Context, "town-square", th.BasicTeam.Id, false)
|
|
require.Nil(t, appErr)
|
|
th.AddUserToChannel(guest, townSquare)
|
|
th.AddUserToChannel(guest, th.BasicChannel)
|
|
|
|
t.Run("Guest leaves not last channel", func(t *testing.T) {
|
|
appErr = th.App.LeaveChannel(th.Context, townSquare.Id, guest.Id)
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.GetTeamMember(th.Context, th.BasicTeam.Id, guest.Id)
|
|
assert.Nil(t, appErr, "It should maintain the team membership")
|
|
})
|
|
|
|
t.Run("Guest leaves last channel", func(t *testing.T) {
|
|
appErr = th.App.LeaveChannel(th.Context, th.BasicChannel.Id, guest.Id)
|
|
assert.Nil(t, appErr, "It should allow to remove a guest user from the default channel")
|
|
_, appErr = th.App.GetChannelMember(th.Context, th.BasicChannel.Id, guest.Id)
|
|
assert.NotNil(t, appErr)
|
|
_, appErr = th.App.GetTeamMember(th.Context, th.BasicTeam.Id, guest.Id)
|
|
assert.Nil(t, appErr, "It should remove the team membership")
|
|
})
|
|
}
|
|
|
|
func TestAddChannelMemberNoUserRequestor(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// create a user and add it to a channel
|
|
user := th.CreateUser()
|
|
_, appErr := th.App.AddTeamMember(th.Context, th.BasicTeam.Id, user.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
groupUserIds := make([]string, 0)
|
|
groupUserIds = append(groupUserIds, th.BasicUser.Id)
|
|
groupUserIds = append(groupUserIds, user.Id)
|
|
|
|
channel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
|
|
_, appErr = th.App.AddChannelMember(th.Context, user.Id, channel, ChannelMemberOpts{})
|
|
require.Nil(t, appErr, "Failed to add user to channel.")
|
|
|
|
// there should be a ChannelMemberHistory record for the user
|
|
histories, nErr := th.App.Srv().Store().ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, []string{channel.Id})
|
|
require.NoError(t, nErr)
|
|
assert.Len(t, histories, 2)
|
|
channelMemberHistoryUserIds := make([]string, 0)
|
|
for _, history := range histories {
|
|
assert.Equal(t, channel.Id, history.ChannelId)
|
|
channelMemberHistoryUserIds = append(channelMemberHistoryUserIds, history.UserId)
|
|
}
|
|
assert.Equal(t, groupUserIds, channelMemberHistoryUserIds)
|
|
|
|
postList, nErr := th.App.Srv().Store().Post().GetPosts(th.Context, model.GetPostsOptions{ChannelId: channel.Id, Page: 0, PerPage: 1}, false, map[string]bool{})
|
|
require.NoError(t, nErr)
|
|
|
|
if assert.Len(t, postList.Order, 1) {
|
|
post := postList.Posts[postList.Order[0]]
|
|
|
|
assert.Equal(t, model.PostTypeJoinChannel, post.Type)
|
|
assert.Equal(t, user.Id, post.UserId)
|
|
assert.Equal(t, user.Username, post.GetProp("username"))
|
|
}
|
|
}
|
|
|
|
func TestAddChannelMemberDeletedUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
user := th.CreateUser()
|
|
_, appErr := th.App.AddTeamMember(th.Context, th.BasicTeam.Id, user.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
deactivated, appErr := th.App.UpdateActive(th.Context, user, false)
|
|
require.Greater(t, deactivated.DeleteAt, int64(0))
|
|
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.AddChannelMember(th.Context, user.Id, th.BasicChannel, ChannelMemberOpts{})
|
|
require.NotNil(t, appErr)
|
|
}
|
|
|
|
func TestAppUpdateChannelScheme(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
channel := th.BasicChannel
|
|
mockID := model.NewPointer("x")
|
|
channel.SchemeId = mockID
|
|
|
|
updatedChannel, appErr := th.App.UpdateChannelScheme(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
|
|
if updatedChannel.SchemeId != mockID {
|
|
require.Fail(t, "Wrong Channel SchemeId")
|
|
}
|
|
}
|
|
|
|
func TestSetChannelsMuted(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
t.Run("should mute and unmute the given channels", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
channel1 := th.BasicChannel
|
|
|
|
channel2 := th.CreateChannel(th.Context, th.BasicTeam)
|
|
th.AddUserToChannel(th.BasicUser, channel2)
|
|
|
|
// Ensure that both channels start unmuted
|
|
member1, appErr := th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
require.False(t, member1.IsChannelMuted())
|
|
|
|
member2, appErr := th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
require.False(t, member2.IsChannelMuted())
|
|
|
|
// Mute both channels
|
|
updated, appErr := th.App.setChannelsMuted(th.Context, []string{channel1.Id, channel2.Id}, th.BasicUser.Id, true)
|
|
require.Nil(t, appErr)
|
|
assert.True(t, updated[0].IsChannelMuted())
|
|
assert.True(t, updated[1].IsChannelMuted())
|
|
|
|
// Verify that the channels are muted in the database
|
|
member1, appErr = th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
require.True(t, member1.IsChannelMuted())
|
|
|
|
member2, appErr = th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
require.True(t, member2.IsChannelMuted())
|
|
|
|
// Unm both channels
|
|
updated, appErr = th.App.setChannelsMuted(th.Context, []string{channel1.Id, channel2.Id}, th.BasicUser.Id, false)
|
|
require.Nil(t, appErr)
|
|
assert.False(t, updated[0].IsChannelMuted())
|
|
assert.False(t, updated[1].IsChannelMuted())
|
|
|
|
// Verify that the channels are muted in the database
|
|
member1, appErr = th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
require.False(t, member1.IsChannelMuted())
|
|
|
|
member2, appErr = th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
require.False(t, member2.IsChannelMuted())
|
|
})
|
|
}
|
|
|
|
func TestFillInChannelProps(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
channelPublic1, appErr := th.App.CreateChannel(th.Context, &model.Channel{DisplayName: "Public 1", Name: "public1", Type: model.ChannelTypeOpen, TeamId: th.BasicTeam.Id}, false)
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channelPublic1)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
channelPublic2, appErr := th.App.CreateChannel(th.Context, &model.Channel{DisplayName: "Public 2", Name: "public2", Type: model.ChannelTypeOpen, TeamId: th.BasicTeam.Id}, false)
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channelPublic2)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
channelPrivate, appErr := th.App.CreateChannel(th.Context, &model.Channel{DisplayName: "Private", Name: "private", Type: model.ChannelTypePrivate, TeamId: th.BasicTeam.Id}, false)
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channelPrivate)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
otherTeamId := model.NewId()
|
|
otherTeam := &model.Team{
|
|
DisplayName: "dn_" + otherTeamId,
|
|
Name: "name" + otherTeamId,
|
|
Email: "success+" + otherTeamId + "@simulator.amazonses.com",
|
|
Type: model.TeamOpen,
|
|
}
|
|
otherTeam, appErr = th.App.CreateTeam(th.Context, otherTeam)
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteTeam(th.Context, otherTeam)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
channelOtherTeam, appErr := th.App.CreateChannel(th.Context, &model.Channel{DisplayName: "Other Team Channel", Name: "other-team", Type: model.ChannelTypeOpen, TeamId: otherTeam.Id}, false)
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channelOtherTeam)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
// Note that purpose is intentionally plaintext below.
|
|
|
|
t.Run("single channels", func(t *testing.T) {
|
|
testCases := []struct {
|
|
Description string
|
|
Channel *model.Channel
|
|
ExpectedChannelProps map[string]any
|
|
}{
|
|
{
|
|
"channel on basic team without references",
|
|
&model.Channel{
|
|
TeamId: th.BasicTeam.Id,
|
|
Header: "No references",
|
|
Purpose: "No references",
|
|
},
|
|
nil,
|
|
},
|
|
{
|
|
"channel on basic team",
|
|
&model.Channel{
|
|
TeamId: th.BasicTeam.Id,
|
|
Header: "~public1, ~private, ~other-team",
|
|
Purpose: "~public2, ~private, ~other-team",
|
|
},
|
|
map[string]any{
|
|
"channel_mentions": map[string]any{
|
|
"public1": map[string]any{
|
|
"display_name": "Public 1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"channel on other team",
|
|
&model.Channel{
|
|
TeamId: otherTeam.Id,
|
|
Header: "~public1, ~private, ~other-team",
|
|
Purpose: "~public2, ~private, ~other-team",
|
|
},
|
|
map[string]any{
|
|
"channel_mentions": map[string]any{
|
|
"other-team": map[string]any{
|
|
"display_name": "Other Team Channel",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
t.Run(testCase.Description, func(t *testing.T) {
|
|
appErr = th.App.FillInChannelProps(th.Context, testCase.Channel)
|
|
require.Nil(t, appErr)
|
|
|
|
assert.Equal(t, testCase.ExpectedChannelProps, testCase.Channel.Props)
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("multiple channels", func(t *testing.T) {
|
|
testCases := []struct {
|
|
Description string
|
|
Channels model.ChannelList
|
|
ExpectedChannelProps map[string]any
|
|
}{
|
|
{
|
|
"single channel on basic team",
|
|
model.ChannelList{
|
|
{
|
|
Name: "test",
|
|
TeamId: th.BasicTeam.Id,
|
|
Header: "~public1, ~private, ~other-team",
|
|
Purpose: "~public2, ~private, ~other-team",
|
|
},
|
|
},
|
|
map[string]any{
|
|
"test": map[string]any{
|
|
"channel_mentions": map[string]any{
|
|
"public1": map[string]any{
|
|
"display_name": "Public 1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple channels on basic team",
|
|
model.ChannelList{
|
|
{
|
|
Name: "test",
|
|
TeamId: th.BasicTeam.Id,
|
|
Header: "~public1, ~private, ~other-team",
|
|
Purpose: "~public2, ~private, ~other-team",
|
|
},
|
|
{
|
|
Name: "test2",
|
|
TeamId: th.BasicTeam.Id,
|
|
Header: "~private, ~other-team",
|
|
Purpose: "~public2, ~private, ~other-team",
|
|
},
|
|
{
|
|
Name: "test3",
|
|
TeamId: th.BasicTeam.Id,
|
|
Header: "No references",
|
|
Purpose: "No references",
|
|
},
|
|
},
|
|
map[string]any{
|
|
"test": map[string]any{
|
|
"channel_mentions": map[string]any{
|
|
"public1": map[string]any{
|
|
"display_name": "Public 1",
|
|
},
|
|
},
|
|
},
|
|
"test2": map[string]any(nil),
|
|
"test3": map[string]any(nil),
|
|
},
|
|
},
|
|
{
|
|
"multiple channels across teams",
|
|
model.ChannelList{
|
|
{
|
|
Name: "test",
|
|
TeamId: th.BasicTeam.Id,
|
|
Header: "~public1, ~private, ~other-team",
|
|
Purpose: "~public2, ~private, ~other-team",
|
|
},
|
|
{
|
|
Name: "test2",
|
|
TeamId: otherTeam.Id,
|
|
Header: "~private, ~other-team",
|
|
Purpose: "~public2, ~private, ~other-team",
|
|
},
|
|
{
|
|
Name: "test3",
|
|
TeamId: th.BasicTeam.Id,
|
|
Header: "No references",
|
|
Purpose: "No references",
|
|
},
|
|
},
|
|
map[string]any{
|
|
"test": map[string]any{
|
|
"channel_mentions": map[string]any{
|
|
"public1": map[string]any{
|
|
"display_name": "Public 1",
|
|
},
|
|
},
|
|
},
|
|
"test2": map[string]any{
|
|
"channel_mentions": map[string]any{
|
|
"other-team": map[string]any{
|
|
"display_name": "Other Team Channel",
|
|
},
|
|
},
|
|
},
|
|
"test3": map[string]any(nil),
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
t.Run(testCase.Description, func(t *testing.T) {
|
|
appErr = th.App.FillInChannelsProps(th.Context, testCase.Channels)
|
|
require.Nil(t, appErr)
|
|
|
|
for _, channel := range testCase.Channels {
|
|
assert.Equal(t, testCase.ExpectedChannelProps[channel.Name], channel.Props)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestRenameChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
testCases := []struct {
|
|
Name string
|
|
Channel *model.Channel
|
|
ExpectError bool
|
|
ChannelName string
|
|
ExpectedName string
|
|
ExpectedDisplayName string
|
|
}{
|
|
{
|
|
"Rename open channel",
|
|
th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen),
|
|
false,
|
|
"newchannelname",
|
|
"newchannelname",
|
|
"New Display Name",
|
|
},
|
|
{
|
|
"Fail on rename open channel with bad name",
|
|
th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen),
|
|
true,
|
|
"6zii9a9g6pruzj451x3esok54h__wr4j4g8zqtnhmkw771pfpynqwo",
|
|
"",
|
|
"",
|
|
},
|
|
{
|
|
"Success on rename open channel with consecutive underscores in name",
|
|
th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen),
|
|
false,
|
|
"foo__bar",
|
|
"foo__bar",
|
|
"New Display Name",
|
|
},
|
|
{
|
|
"Fail on rename direct message channel",
|
|
th.CreateDmChannel(th.BasicUser2),
|
|
true,
|
|
"newchannelname",
|
|
"",
|
|
"",
|
|
},
|
|
{
|
|
"Fail on rename group message channel",
|
|
th.CreateGroupChannel(th.Context, th.BasicUser2, th.CreateUser()),
|
|
true,
|
|
"newchannelname",
|
|
"",
|
|
"",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.Name, func(t *testing.T) {
|
|
channel, err := th.App.RenameChannel(th.Context, tc.Channel, tc.ChannelName, "New Display Name")
|
|
if tc.ExpectError {
|
|
assert.NotNil(t, err)
|
|
} else {
|
|
assert.Equal(t, tc.ExpectedName, channel.Name)
|
|
assert.Equal(t, tc.ExpectedDisplayName, channel.DisplayName)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetChannelMembersTimezones(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
_, appErr := th.App.AddChannelMember(th.Context, th.BasicUser2.Id, th.BasicChannel, ChannelMemberOpts{})
|
|
require.Nil(t, appErr, "Failed to add user to channel.")
|
|
|
|
user := th.BasicUser
|
|
user.Timezone["useAutomaticTimezone"] = "false"
|
|
user.Timezone["manualTimezone"] = "XOXO/BLABLA"
|
|
_, appErr = th.App.UpdateUser(th.Context, user, false)
|
|
require.Nil(t, appErr)
|
|
|
|
user2 := th.BasicUser2
|
|
user2.Timezone["automaticTimezone"] = "NoWhere/Island"
|
|
_, appErr = th.App.UpdateUser(th.Context, user2, false)
|
|
require.Nil(t, appErr)
|
|
|
|
user3 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser, appErr := th.App.CreateUser(th.Context, &user3)
|
|
require.Nil(t, appErr)
|
|
|
|
_, _, appErr = th.App.AddUserToTeam(th.Context, th.BasicTeam.Id, ruser.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, ruser, th.BasicChannel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
ruser.Timezone["automaticTimezone"] = "NoWhere/Island"
|
|
_, appErr = th.App.UpdateUser(th.Context, ruser, false)
|
|
require.Nil(t, appErr)
|
|
|
|
user4 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser, _ = th.App.CreateUser(th.Context, &user4)
|
|
_, appErr = th.App.AddUserToChannel(th.Context, ruser, th.BasicChannel, false)
|
|
require.NotNil(t, appErr, "user should not be able to join the channel without being in the team.")
|
|
|
|
timezones, appErr := th.App.GetChannelMembersTimezones(th.Context, th.BasicChannel.Id)
|
|
require.Nil(t, appErr, "Failed to get the timezones for a channel.")
|
|
|
|
assert.Equal(t, 2, len(timezones))
|
|
}
|
|
|
|
func TestGetChannelsForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
channel := &model.Channel{
|
|
DisplayName: "Public",
|
|
Name: "public",
|
|
Type: model.ChannelTypeOpen,
|
|
CreatorId: th.BasicUser.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
}
|
|
_, appErr := th.App.CreateChannel(th.Context, channel, true)
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
defer th.TearDown()
|
|
|
|
channelList, appErr := th.App.GetChannelsForTeamForUser(th.Context, th.BasicTeam.Id, th.BasicUser.Id, &model.ChannelSearchOpts{
|
|
IncludeDeleted: false,
|
|
LastDeleteAt: 0,
|
|
})
|
|
require.Nil(t, appErr)
|
|
require.Len(t, channelList, 4)
|
|
|
|
appErr = th.App.DeleteChannel(th.Context, channel, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// Now we get all the non-archived channels for the user
|
|
channelList, appErr = th.App.GetChannelsForTeamForUser(th.Context, th.BasicTeam.Id, th.BasicUser.Id, &model.ChannelSearchOpts{
|
|
IncludeDeleted: false,
|
|
LastDeleteAt: 0,
|
|
})
|
|
require.Nil(t, appErr)
|
|
require.Len(t, channelList, 3)
|
|
|
|
// Now we get all the channels, even though are archived, for the user
|
|
channelList, appErr = th.App.GetChannelsForTeamForUser(th.Context, th.BasicTeam.Id, th.BasicUser.Id, &model.ChannelSearchOpts{
|
|
IncludeDeleted: true,
|
|
LastDeleteAt: 0,
|
|
})
|
|
require.Nil(t, appErr)
|
|
require.Len(t, channelList, 4)
|
|
}
|
|
|
|
func TestGetPublicChannelsForTeam(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t)
|
|
team := th.CreateTeam()
|
|
defer th.TearDown()
|
|
|
|
var expectedChannels []*model.Channel
|
|
|
|
townSquare, appErr := th.App.GetChannelByName(th.Context, "town-square", team.Id, false)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, townSquare)
|
|
expectedChannels = append(expectedChannels, townSquare)
|
|
|
|
offTopic, appErr := th.App.GetChannelByName(th.Context, "off-topic", team.Id, false)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, offTopic)
|
|
expectedChannels = append(expectedChannels, offTopic)
|
|
|
|
for i := range 8 {
|
|
channel := model.Channel{
|
|
DisplayName: fmt.Sprintf("Public %v", i),
|
|
Name: fmt.Sprintf("public_%v", i),
|
|
Type: model.ChannelTypeOpen,
|
|
TeamId: team.Id,
|
|
}
|
|
var rchannel *model.Channel
|
|
rchannel, appErr = th.App.CreateChannel(th.Context, &channel, false)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, rchannel)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, rchannel)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
// Store the user ids for comparison later
|
|
expectedChannels = append(expectedChannels, rchannel)
|
|
}
|
|
|
|
// Fetch public channels multiple times
|
|
channelList, appErr := th.App.GetPublicChannelsForTeam(th.Context, team.Id, 0, 5)
|
|
require.Nil(t, appErr)
|
|
channelList2, appErr := th.App.GetPublicChannelsForTeam(th.Context, team.Id, 5, 5)
|
|
require.Nil(t, appErr)
|
|
|
|
channels := append(channelList, channelList2...)
|
|
assert.ElementsMatch(t, expectedChannels, channels)
|
|
}
|
|
|
|
func TestGetPrivateChannelsForTeam(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t)
|
|
team := th.CreateTeam()
|
|
defer th.TearDown()
|
|
|
|
var expectedChannels []*model.Channel
|
|
for i := range 8 {
|
|
channel := model.Channel{
|
|
DisplayName: fmt.Sprintf("Private %v", i),
|
|
Name: fmt.Sprintf("private_%v", i),
|
|
Type: model.ChannelTypePrivate,
|
|
TeamId: team.Id,
|
|
}
|
|
var rchannel *model.Channel
|
|
rchannel, appErr := th.App.CreateChannel(th.Context, &channel, false)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, rchannel)
|
|
defer func() {
|
|
appErr := th.App.PermanentDeleteChannel(th.Context, rchannel)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
// Store the user ids for comparison later
|
|
expectedChannels = append(expectedChannels, rchannel)
|
|
}
|
|
|
|
// Fetch private channels multiple times
|
|
channelList, appErr := th.App.GetPrivateChannelsForTeam(th.Context, team.Id, 0, 5)
|
|
require.Nil(t, appErr)
|
|
channelList2, appErr := th.App.GetPrivateChannelsForTeam(th.Context, team.Id, 5, 5)
|
|
require.Nil(t, appErr)
|
|
|
|
channels := append(channelList, channelList2...)
|
|
assert.ElementsMatch(t, expectedChannels, channels)
|
|
}
|
|
|
|
func TestUpdateChannelMemberRolesChangingGuest(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("from guest to user", func(t *testing.T) {
|
|
user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser, _ := th.App.CreateGuest(th.Context, &user)
|
|
|
|
_, _, appErr := th.App.AddUserToTeam(th.Context, th.BasicTeam.Id, ruser.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, ruser, th.BasicChannel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.UpdateChannelMemberRoles(th.Context, th.BasicChannel.Id, ruser.Id, "channel_user")
|
|
require.NotNil(t, appErr, "Should fail when try to modify the guest role")
|
|
})
|
|
|
|
t.Run("from user to guest", func(t *testing.T) {
|
|
user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser, _ := th.App.CreateUser(th.Context, &user)
|
|
|
|
_, _, appErr := th.App.AddUserToTeam(th.Context, th.BasicTeam.Id, ruser.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, ruser, th.BasicChannel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.UpdateChannelMemberRoles(th.Context, th.BasicChannel.Id, ruser.Id, "channel_guest")
|
|
require.NotNil(t, appErr, "Should fail when try to modify the guest role")
|
|
})
|
|
|
|
t.Run("from user to admin", func(t *testing.T) {
|
|
user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser, _ := th.App.CreateUser(th.Context, &user)
|
|
|
|
_, _, appErr := th.App.AddUserToTeam(th.Context, th.BasicTeam.Id, ruser.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, ruser, th.BasicChannel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.UpdateChannelMemberRoles(th.Context, th.BasicChannel.Id, ruser.Id, "channel_user channel_admin")
|
|
require.Nil(t, appErr, "Should work when you not modify guest role")
|
|
})
|
|
|
|
t.Run("from guest to guest plus custom", func(t *testing.T) {
|
|
user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser, _ := th.App.CreateGuest(th.Context, &user)
|
|
|
|
_, _, appErr := th.App.AddUserToTeam(th.Context, th.BasicTeam.Id, ruser.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, ruser, th.BasicChannel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.CreateRole(&model.Role{Name: "custom", DisplayName: "custom", Description: "custom"})
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.UpdateChannelMemberRoles(th.Context, th.BasicChannel.Id, ruser.Id, "channel_guest custom")
|
|
require.Nil(t, appErr, "Should work when you not modify guest role")
|
|
})
|
|
|
|
t.Run("a guest cant have user role", func(t *testing.T) {
|
|
user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser, _ := th.App.CreateGuest(th.Context, &user)
|
|
|
|
_, _, appErr := th.App.AddUserToTeam(th.Context, th.BasicTeam.Id, ruser.Id, "")
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, ruser, th.BasicChannel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.UpdateChannelMemberRoles(th.Context, th.BasicChannel.Id, ruser.Id, "channel_guest channel_user")
|
|
require.NotNil(t, appErr, "Should work when you not modify guest role")
|
|
})
|
|
}
|
|
|
|
func TestDefaultChannelNames(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t)
|
|
defer th.TearDown()
|
|
|
|
actual := th.App.DefaultChannelNames(th.Context)
|
|
expect := []string{"town-square", "off-topic"}
|
|
require.ElementsMatch(t, expect, actual)
|
|
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
cfg.TeamSettings.ExperimentalDefaultChannels = []string{"foo", "bar"}
|
|
})
|
|
|
|
actual = th.App.DefaultChannelNames(th.Context)
|
|
expect = []string{"town-square", "foo", "bar"}
|
|
require.ElementsMatch(t, expect, actual)
|
|
}
|
|
|
|
func TestSearchChannelsForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
c1, appErr := th.App.CreateChannel(th.Context, &model.Channel{DisplayName: "test-dev-1", Name: "test-dev-1", Type: model.ChannelTypeOpen, TeamId: th.BasicTeam.Id}, false)
|
|
require.Nil(t, appErr)
|
|
|
|
c2, appErr := th.App.CreateChannel(th.Context, &model.Channel{DisplayName: "test-dev-2", Name: "test-dev-2", Type: model.ChannelTypeOpen, TeamId: th.BasicTeam.Id}, false)
|
|
require.Nil(t, appErr)
|
|
|
|
c3, appErr := th.App.CreateChannel(th.Context, &model.Channel{DisplayName: "dev-3", Name: "dev-3", Type: model.ChannelTypeOpen, TeamId: th.BasicTeam.Id}, false)
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, c1)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, c2)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.PermanentDeleteChannel(th.Context, c3)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
// add user to test-dev-1 and dev3
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser, c1, false)
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser, c3, false)
|
|
require.Nil(t, appErr)
|
|
|
|
searchAndCheck := func(t *testing.T, term string, expectedDisplayNames []string) {
|
|
res, searchErr := th.App.SearchChannelsForUser(th.Context, th.BasicUser.Id, th.BasicTeam.Id, term)
|
|
require.Nil(t, searchErr)
|
|
require.Len(t, res, len(expectedDisplayNames))
|
|
|
|
resultDisplayNames := []string{}
|
|
for _, c := range res {
|
|
resultDisplayNames = append(resultDisplayNames, c.Name)
|
|
}
|
|
require.ElementsMatch(t, expectedDisplayNames, resultDisplayNames)
|
|
}
|
|
|
|
t.Run("Search for test, only test-dev-1 should be returned", func(t *testing.T) {
|
|
searchAndCheck(t, "test", []string{"test-dev-1"})
|
|
})
|
|
|
|
t.Run("Search for dev, both test-dev-1 and dev-3 should be returned", func(t *testing.T) {
|
|
searchAndCheck(t, "dev", []string{"test-dev-1", "dev-3"})
|
|
})
|
|
|
|
t.Run("After adding user to test-dev-2, search for dev, the three channels should be returned", func(t *testing.T) {
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser, c2, false)
|
|
require.Nil(t, appErr)
|
|
|
|
searchAndCheck(t, "dev", []string{"test-dev-1", "test-dev-2", "dev-3"})
|
|
})
|
|
}
|
|
|
|
func TestMarkChannelAsUnreadFromPost(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
u1 := th.BasicUser
|
|
u2 := th.BasicUser2
|
|
c1 := th.BasicChannel
|
|
pc1 := th.CreatePrivateChannel(th.Context, th.BasicTeam)
|
|
th.AddUserToChannel(u2, c1)
|
|
th.AddUserToChannel(u1, pc1)
|
|
th.AddUserToChannel(u2, pc1)
|
|
|
|
p1 := th.CreatePost(c1)
|
|
p2 := th.CreatePost(c1)
|
|
p3 := th.CreatePost(c1)
|
|
|
|
pp1 := th.CreatePost(pc1)
|
|
require.NotNil(t, pp1)
|
|
pp2 := th.CreatePost(pc1)
|
|
|
|
unread, appErr := th.App.GetChannelUnread(th.Context, c1.Id, u1.Id)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(4), unread.MsgCount)
|
|
unread, appErr = th.App.GetChannelUnread(th.Context, c1.Id, u2.Id)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(4), unread.MsgCount)
|
|
_, appErr = th.App.MarkChannelsAsViewed(th.Context, []string{c1.Id, pc1.Id}, u1.Id, "", false, false)
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.MarkChannelsAsViewed(th.Context, []string{c1.Id, pc1.Id}, u2.Id, "", false, false)
|
|
require.Nil(t, appErr)
|
|
unread, appErr = th.App.GetChannelUnread(th.Context, c1.Id, u2.Id)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(0), unread.MsgCount)
|
|
|
|
t.Run("Unread but last one", func(t *testing.T) {
|
|
response, appErr := th.App.MarkChannelAsUnreadFromPost(th.Context, p2.Id, u1.Id, true)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, response)
|
|
assert.Equal(t, int64(2), response.MsgCount)
|
|
unread, appErr := th.App.GetChannelUnread(th.Context, c1.Id, u1.Id)
|
|
require.Nil(t, appErr)
|
|
assert.Equal(t, int64(2), unread.MsgCount)
|
|
assert.Equal(t, p2.CreateAt-1, response.LastViewedAt)
|
|
})
|
|
|
|
t.Run("Unread last one", func(t *testing.T) {
|
|
response, appErr := th.App.MarkChannelAsUnreadFromPost(th.Context, p3.Id, u1.Id, true)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, response)
|
|
assert.Equal(t, int64(3), response.MsgCount)
|
|
unread, appErr := th.App.GetChannelUnread(th.Context, c1.Id, u1.Id)
|
|
require.Nil(t, appErr)
|
|
assert.Equal(t, int64(1), unread.MsgCount)
|
|
assert.Equal(t, p3.CreateAt-1, response.LastViewedAt)
|
|
})
|
|
|
|
t.Run("Unread first one", func(t *testing.T) {
|
|
response, appErr := th.App.MarkChannelAsUnreadFromPost(th.Context, p1.Id, u1.Id, true)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, response)
|
|
assert.Equal(t, int64(1), response.MsgCount)
|
|
unread, appErr := th.App.GetChannelUnread(th.Context, c1.Id, u1.Id)
|
|
require.Nil(t, appErr)
|
|
assert.Equal(t, int64(3), unread.MsgCount)
|
|
assert.Equal(t, p1.CreateAt-1, response.LastViewedAt)
|
|
})
|
|
|
|
t.Run("Other users are unaffected", func(t *testing.T) {
|
|
unread, appErr := th.App.GetChannelUnread(th.Context, c1.Id, u2.Id)
|
|
require.Nil(t, appErr)
|
|
assert.Equal(t, int64(0), unread.MsgCount)
|
|
})
|
|
|
|
t.Run("Unread on a private channel", func(t *testing.T) {
|
|
response, appErr := th.App.MarkChannelAsUnreadFromPost(th.Context, pp1.Id, u1.Id, true)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, response)
|
|
assert.Equal(t, int64(0), response.MsgCount)
|
|
unread, appErr := th.App.GetChannelUnread(th.Context, pc1.Id, u1.Id)
|
|
require.Nil(t, appErr)
|
|
assert.Equal(t, int64(2), unread.MsgCount)
|
|
assert.Equal(t, pp1.CreateAt-1, response.LastViewedAt)
|
|
|
|
response, appErr = th.App.MarkChannelAsUnreadFromPost(th.Context, pp2.Id, u1.Id, true)
|
|
assert.Nil(t, appErr)
|
|
assert.Equal(t, int64(1), response.MsgCount)
|
|
unread, appErr = th.App.GetChannelUnread(th.Context, pc1.Id, u1.Id)
|
|
require.Nil(t, appErr)
|
|
assert.Equal(t, int64(1), unread.MsgCount)
|
|
assert.Equal(t, pp2.CreateAt-1, response.LastViewedAt)
|
|
})
|
|
|
|
t.Run("Unread with mentions", func(t *testing.T) {
|
|
c2 := th.CreateChannel(th.Context, th.BasicTeam)
|
|
_, appErr := th.App.AddUserToChannel(th.Context, u2, c2, false)
|
|
require.Nil(t, appErr)
|
|
|
|
p4, appErr := th.App.CreatePost(th.Context, &model.Post{
|
|
UserId: u2.Id,
|
|
ChannelId: c2.Id,
|
|
Message: "@" + u1.Username,
|
|
}, c2, model.CreatePostFlags{SetOnline: true})
|
|
require.Nil(t, appErr)
|
|
th.CreatePost(c2)
|
|
|
|
_, appErr = th.App.CreatePost(th.Context, &model.Post{
|
|
UserId: u2.Id,
|
|
ChannelId: c2.Id,
|
|
RootId: p4.Id,
|
|
Message: "@" + u1.Username,
|
|
}, c2, model.CreatePostFlags{SetOnline: true})
|
|
require.Nil(t, appErr)
|
|
|
|
response, appErr := th.App.MarkChannelAsUnreadFromPost(th.Context, p4.Id, u1.Id, true)
|
|
assert.Nil(t, appErr)
|
|
assert.Equal(t, int64(1), response.MsgCount)
|
|
assert.Equal(t, int64(2), response.MentionCount)
|
|
assert.Equal(t, int64(1), response.MentionCountRoot)
|
|
|
|
unread, appErr := th.App.GetChannelUnread(th.Context, c2.Id, u1.Id)
|
|
require.Nil(t, appErr)
|
|
assert.Equal(t, int64(2), unread.MsgCount)
|
|
assert.Equal(t, int64(2), unread.MentionCount)
|
|
assert.Equal(t, int64(1), unread.MentionCountRoot)
|
|
})
|
|
|
|
t.Run("Unread on a DM channel", func(t *testing.T) {
|
|
dc := th.CreateDmChannel(u2)
|
|
|
|
dm1 := th.CreatePost(dc)
|
|
th.CreatePost(dc)
|
|
th.CreatePost(dc)
|
|
|
|
_, appErr := th.App.CreatePost(th.Context, &model.Post{ChannelId: dc.Id, UserId: th.BasicUser.Id, Message: "testReply", RootId: dm1.Id}, dc, model.CreatePostFlags{})
|
|
assert.Nil(t, appErr)
|
|
|
|
response, appErr := th.App.MarkChannelAsUnreadFromPost(th.Context, dm1.Id, u2.Id, true)
|
|
assert.Nil(t, appErr)
|
|
assert.Equal(t, int64(0), response.MsgCount)
|
|
assert.Equal(t, int64(4), response.MentionCount)
|
|
assert.Equal(t, int64(3), response.MentionCountRoot)
|
|
|
|
unread, appErr := th.App.GetChannelUnread(th.Context, dc.Id, u2.Id)
|
|
require.Nil(t, appErr)
|
|
assert.Equal(t, int64(4), unread.MsgCount)
|
|
assert.Equal(t, int64(4), unread.MentionCount)
|
|
assert.Equal(t, int64(3), unread.MentionCountRoot)
|
|
})
|
|
|
|
t.Run("Can't unread an imaginary post", func(t *testing.T) {
|
|
response, err := th.App.MarkChannelAsUnreadFromPost(th.Context, "invalid4ofngungryquinj976y", u1.Id, true)
|
|
assert.NotNil(t, err)
|
|
assert.Nil(t, response)
|
|
})
|
|
}
|
|
|
|
func TestAddUserToChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
user1 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser1, _ := th.App.CreateUser(th.Context, &user1)
|
|
defer func() {
|
|
appErr := th.App.PermanentDeleteUser(th.Context, &user1)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
bot := th.CreateBot()
|
|
botUser, _ := th.App.GetUser(bot.UserId)
|
|
defer func() {
|
|
appErr := th.App.PermanentDeleteBot(th.Context, botUser.Id)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
_, appErr := th.App.AddTeamMember(th.Context, th.BasicTeam.Id, ruser1.Id)
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.AddTeamMember(th.Context, th.BasicTeam.Id, bot.UserId)
|
|
require.Nil(t, appErr)
|
|
|
|
group := th.CreateGroup()
|
|
|
|
_, appErr = th.App.UpsertGroupMember(group.Id, user1.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
gs, appErr := th.App.UpsertGroupSyncable(&model.GroupSyncable{
|
|
AutoAdd: true,
|
|
SyncableId: th.BasicChannel.Id,
|
|
Type: model.GroupSyncableTypeChannel,
|
|
GroupId: group.Id,
|
|
SchemeAdmin: false,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.JoinChannel(th.Context, th.BasicChannel, ruser1.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// verify user was added as a non-admin
|
|
cm1, appErr := th.App.GetChannelMember(th.Context, th.BasicChannel.Id, ruser1.Id)
|
|
require.Nil(t, appErr)
|
|
require.False(t, cm1.SchemeAdmin)
|
|
|
|
user2 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser2, _ := th.App.CreateUser(th.Context, &user2)
|
|
defer func() {
|
|
appErr = th.App.PermanentDeleteUser(th.Context, &user2)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
_, appErr = th.App.AddTeamMember(th.Context, th.BasicTeam.Id, ruser2.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.UpsertGroupMember(group.Id, user2.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
gs.SchemeAdmin = true
|
|
_, appErr = th.App.UpdateGroupSyncable(gs)
|
|
require.Nil(t, appErr)
|
|
|
|
appErr = th.App.JoinChannel(th.Context, th.BasicChannel, ruser2.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// Should allow a bot to be added to a public group synced channel
|
|
_, appErr = th.App.AddUserToChannel(th.Context, botUser, th.BasicChannel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
// verify user was added as an admin
|
|
cm2, appErr := th.App.GetChannelMember(th.Context, th.BasicChannel.Id, ruser2.Id)
|
|
require.Nil(t, appErr)
|
|
require.True(t, cm2.SchemeAdmin)
|
|
|
|
privateChannel := th.CreatePrivateChannel(th.Context, th.BasicTeam)
|
|
privateChannel.GroupConstrained = model.NewPointer(true)
|
|
_, appErr = th.App.UpdateChannel(th.Context, privateChannel)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.UpsertGroupSyncable(&model.GroupSyncable{
|
|
GroupId: group.Id,
|
|
SyncableId: privateChannel.Id,
|
|
Type: model.GroupSyncableTypeChannel,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
// Should allow a group synced user to be added to a group synced private channel
|
|
_, appErr = th.App.AddUserToChannel(th.Context, ruser1, privateChannel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
// Should allow a bot to be added to a private group synced channel
|
|
_, appErr = th.App.AddUserToChannel(th.Context, botUser, privateChannel, false)
|
|
require.Nil(t, appErr)
|
|
}
|
|
|
|
func TestRemoveUserFromChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
|
|
ruser, _ := th.App.CreateUser(th.Context, &user)
|
|
defer func() {
|
|
appErr := th.App.PermanentDeleteUser(th.Context, ruser)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
bot := th.CreateBot()
|
|
botUser, _ := th.App.GetUser(bot.UserId)
|
|
defer func() {
|
|
appErr := th.App.PermanentDeleteBot(th.Context, botUser.Id)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
|
|
_, appErr := th.App.AddTeamMember(th.Context, th.BasicTeam.Id, ruser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.AddTeamMember(th.Context, th.BasicTeam.Id, bot.UserId)
|
|
require.Nil(t, appErr)
|
|
|
|
privateChannel := th.CreatePrivateChannel(th.Context, th.BasicTeam)
|
|
|
|
_, appErr = th.App.AddUserToChannel(th.Context, ruser, privateChannel, false)
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.AddUserToChannel(th.Context, botUser, privateChannel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
group := th.CreateGroup()
|
|
_, appErr = th.App.UpsertGroupMember(group.Id, ruser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
_, appErr = th.App.UpsertGroupSyncable(&model.GroupSyncable{
|
|
GroupId: group.Id,
|
|
SyncableId: privateChannel.Id,
|
|
Type: model.GroupSyncableTypeChannel,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
privateChannel.GroupConstrained = model.NewPointer(true)
|
|
_, appErr = th.App.UpdateChannel(th.Context, privateChannel)
|
|
require.Nil(t, appErr)
|
|
|
|
// Should not allow a group synced user to be removed from channel
|
|
appErr = th.App.RemoveUserFromChannel(th.Context, ruser.Id, th.SystemAdminUser.Id, privateChannel)
|
|
assert.Equal(t, appErr.Id, "api.channel.remove_members.denied")
|
|
|
|
// Should allow a user to remove themselves from group synced channel
|
|
appErr = th.App.RemoveUserFromChannel(th.Context, ruser.Id, ruser.Id, privateChannel)
|
|
require.Nil(t, appErr)
|
|
|
|
// Should allow a bot to be removed from a group synced channel
|
|
appErr = th.App.RemoveUserFromChannel(th.Context, botUser.Id, th.SystemAdminUser.Id, privateChannel)
|
|
require.Nil(t, appErr)
|
|
}
|
|
|
|
func TestPatchChannelModerationsForChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
err := th.App.SetPhase2PermissionsMigrationStatus(true)
|
|
require.NoError(t, err)
|
|
channel := th.BasicChannel
|
|
|
|
user := th.BasicUser
|
|
th.AddUserToChannel(user, channel)
|
|
|
|
createPosts := model.ChannelModeratedPermissions[0]
|
|
createReactions := model.ChannelModeratedPermissions[1]
|
|
manageMembers := model.ChannelModeratedPermissions[2]
|
|
channelMentions := model.ChannelModeratedPermissions[3]
|
|
manageBookmarks := model.ChannelModeratedPermissions[4]
|
|
|
|
nonChannelModeratedPermission := model.PermissionCreateBot.Id
|
|
|
|
testCases := []struct {
|
|
Name string
|
|
ChannelModerationsPatch []*model.ChannelModerationPatch
|
|
PermissionsModeratedByPatch map[string]*model.ChannelModeratedRoles
|
|
RevertChannelModerationsPatch []*model.ChannelModerationPatch
|
|
HigherScopedMemberPermissions []string
|
|
HigherScopedGuestPermissions []string
|
|
ShouldError bool
|
|
ShouldHaveNoChannelScheme bool
|
|
}{
|
|
{
|
|
Name: "Removing create posts from members role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{
|
|
createPosts: {
|
|
Members: &model.ChannelModeratedRole{Value: false, Enabled: true},
|
|
},
|
|
},
|
|
RevertChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(true)},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "Removing create reactions from members role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createReactions,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{
|
|
createReactions: {
|
|
Members: &model.ChannelModeratedRole{Value: false, Enabled: true},
|
|
},
|
|
},
|
|
RevertChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createReactions,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(true)},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "Removing channel mentions from members role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &channelMentions,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{
|
|
channelMentions: {
|
|
Members: &model.ChannelModeratedRole{Value: false, Enabled: true},
|
|
},
|
|
},
|
|
RevertChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &channelMentions,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(true)},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "Removing manage members from members role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &manageMembers,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{
|
|
manageMembers: {
|
|
Members: &model.ChannelModeratedRole{Value: false, Enabled: true},
|
|
},
|
|
},
|
|
RevertChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &manageMembers,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(true)},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "Removing manage bookmarks from members role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &manageBookmarks,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{
|
|
manageBookmarks: {
|
|
Members: &model.ChannelModeratedRole{Value: false, Enabled: true},
|
|
},
|
|
},
|
|
RevertChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &manageBookmarks,
|
|
Roles: &model.ChannelModeratedRolesPatch{Members: model.NewPointer(true)},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "Removing create posts from guests role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{Guests: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{
|
|
createPosts: {
|
|
Guests: &model.ChannelModeratedRole{Value: false, Enabled: true},
|
|
},
|
|
},
|
|
RevertChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{Guests: model.NewPointer(true)},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "Removing create reactions from guests role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createReactions,
|
|
Roles: &model.ChannelModeratedRolesPatch{Guests: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{
|
|
createReactions: {
|
|
Guests: &model.ChannelModeratedRole{Value: false, Enabled: true},
|
|
},
|
|
},
|
|
RevertChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createReactions,
|
|
Roles: &model.ChannelModeratedRolesPatch{Guests: model.NewPointer(true)},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "Removing channel mentions from guests role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &channelMentions,
|
|
Roles: &model.ChannelModeratedRolesPatch{Guests: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{
|
|
channelMentions: {
|
|
Guests: &model.ChannelModeratedRole{Value: false, Enabled: true},
|
|
},
|
|
},
|
|
RevertChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &channelMentions,
|
|
Roles: &model.ChannelModeratedRolesPatch{Guests: model.NewPointer(true)},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "Removing manage members from guests role should not error",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &manageMembers,
|
|
Roles: &model.ChannelModeratedRolesPatch{Guests: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{},
|
|
ShouldError: false,
|
|
ShouldHaveNoChannelScheme: true,
|
|
},
|
|
{
|
|
Name: "Removing manage bookmarks from guests role should not error",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &manageBookmarks,
|
|
Roles: &model.ChannelModeratedRolesPatch{Guests: model.NewPointer(false)},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{},
|
|
ShouldError: false,
|
|
ShouldHaveNoChannelScheme: true,
|
|
},
|
|
{
|
|
Name: "Removing a permission that is not channel moderated should not error",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &nonChannelModeratedPermission,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(false),
|
|
Guests: model.NewPointer(false),
|
|
},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{},
|
|
ShouldError: false,
|
|
ShouldHaveNoChannelScheme: true,
|
|
},
|
|
{
|
|
Name: "Error when adding a permission that is disabled in the parent member role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(true),
|
|
Guests: model.NewPointer(false),
|
|
},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{},
|
|
HigherScopedMemberPermissions: []string{},
|
|
ShouldError: true,
|
|
},
|
|
{
|
|
Name: "Error when adding a permission that is disabled in the parent guest role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(false),
|
|
Guests: model.NewPointer(true),
|
|
},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{},
|
|
HigherScopedGuestPermissions: []string{},
|
|
ShouldError: true,
|
|
},
|
|
{
|
|
Name: "Removing a permission from the member role that is disabled in the parent guest role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(false),
|
|
},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{
|
|
createPosts: {
|
|
Members: &model.ChannelModeratedRole{Value: false, Enabled: true},
|
|
Guests: &model.ChannelModeratedRole{Value: false, Enabled: false},
|
|
},
|
|
createReactions: {
|
|
Guests: &model.ChannelModeratedRole{Value: false, Enabled: false},
|
|
},
|
|
channelMentions: {
|
|
Guests: &model.ChannelModeratedRole{Value: false, Enabled: false},
|
|
},
|
|
},
|
|
HigherScopedGuestPermissions: []string{},
|
|
ShouldError: false,
|
|
},
|
|
{
|
|
Name: "Channel should have no scheme when all moderated permissions are equivalent to higher scoped role",
|
|
ChannelModerationsPatch: []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(true),
|
|
Guests: model.NewPointer(true),
|
|
},
|
|
},
|
|
{
|
|
Name: &createReactions,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(true),
|
|
Guests: model.NewPointer(true),
|
|
},
|
|
},
|
|
{
|
|
Name: &channelMentions,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(true),
|
|
Guests: model.NewPointer(true),
|
|
},
|
|
},
|
|
{
|
|
Name: &manageMembers,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(true),
|
|
},
|
|
},
|
|
{
|
|
Name: &manageBookmarks,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(true),
|
|
},
|
|
},
|
|
},
|
|
PermissionsModeratedByPatch: map[string]*model.ChannelModeratedRoles{},
|
|
ShouldHaveNoChannelScheme: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.Name, func(t *testing.T) {
|
|
higherScopedPermissionsOverridden := tc.HigherScopedMemberPermissions != nil || tc.HigherScopedGuestPermissions != nil
|
|
// If the test case restricts higher scoped permissions.
|
|
if higherScopedPermissionsOverridden {
|
|
higherScopedGuestRoleName, higherScopedMemberRoleName, _, _ := th.App.GetTeamSchemeChannelRoles(th.Context, channel.TeamId)
|
|
if tc.HigherScopedMemberPermissions != nil {
|
|
higherScopedMemberRole, appErr := th.App.GetRoleByName(th.Context, higherScopedMemberRoleName)
|
|
require.Nil(t, appErr)
|
|
originalPermissions := higherScopedMemberRole.Permissions
|
|
|
|
_, appErr = th.App.PatchRole(higherScopedMemberRole, &model.RolePatch{Permissions: &tc.HigherScopedMemberPermissions})
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
_, appErr := th.App.PatchRole(higherScopedMemberRole, &model.RolePatch{Permissions: &originalPermissions})
|
|
require.Nil(t, appErr)
|
|
}()
|
|
}
|
|
|
|
if tc.HigherScopedGuestPermissions != nil {
|
|
higherScopedGuestRole, appErr := th.App.GetRoleByName(th.Context, higherScopedGuestRoleName)
|
|
require.Nil(t, appErr)
|
|
originalPermissions := higherScopedGuestRole.Permissions
|
|
|
|
_, appErr = th.App.PatchRole(higherScopedGuestRole, &model.RolePatch{Permissions: &tc.HigherScopedGuestPermissions})
|
|
require.Nil(t, appErr)
|
|
defer func() {
|
|
_, appErr := th.App.PatchRole(higherScopedGuestRole, &model.RolePatch{Permissions: &originalPermissions})
|
|
require.Nil(t, appErr)
|
|
}()
|
|
}
|
|
}
|
|
|
|
moderations, appErr := th.App.PatchChannelModerationsForChannel(th.Context, channel, tc.ChannelModerationsPatch)
|
|
if tc.ShouldError {
|
|
require.NotNil(t, appErr)
|
|
require.Equal(t, http.StatusForbidden, appErr.StatusCode)
|
|
return
|
|
}
|
|
require.Nil(t, appErr)
|
|
|
|
updatedChannel, _ := th.App.GetChannel(th.Context, channel.Id)
|
|
if tc.ShouldHaveNoChannelScheme {
|
|
require.Nil(t, updatedChannel.SchemeId)
|
|
} else {
|
|
require.NotNil(t, updatedChannel.SchemeId)
|
|
}
|
|
|
|
for _, moderation := range moderations {
|
|
// If the permission is not found in the expected modified permissions table then require it to be true
|
|
if permission, found := tc.PermissionsModeratedByPatch[moderation.Name]; found && permission.Members != nil {
|
|
require.Equal(t, moderation.Roles.Members.Value, permission.Members.Value)
|
|
require.Equal(t, moderation.Roles.Members.Enabled, permission.Members.Enabled)
|
|
} else {
|
|
require.Equal(t, moderation.Roles.Members.Value, true)
|
|
require.Equal(t, moderation.Roles.Members.Enabled, true)
|
|
}
|
|
|
|
if permission, found := tc.PermissionsModeratedByPatch[moderation.Name]; found && permission.Guests != nil {
|
|
require.Equal(t, moderation.Roles.Guests.Value, permission.Guests.Value)
|
|
require.Equal(t, moderation.Roles.Guests.Enabled, permission.Guests.Enabled)
|
|
} else if moderation.Name == manageMembers || moderation.Name == "manage_bookmarks" {
|
|
require.Empty(t, moderation.Roles.Guests)
|
|
} else {
|
|
require.Equal(t, moderation.Roles.Guests.Value, true)
|
|
require.Equal(t, moderation.Roles.Guests.Enabled, true)
|
|
}
|
|
}
|
|
|
|
if tc.RevertChannelModerationsPatch != nil {
|
|
_, appErr := th.App.PatchChannelModerationsForChannel(th.Context, channel, tc.RevertChannelModerationsPatch)
|
|
require.Nil(t, appErr)
|
|
}
|
|
})
|
|
}
|
|
|
|
t.Run("Handles concurrent patch requests gracefully", func(t *testing.T) {
|
|
addCreatePosts := []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(false),
|
|
Guests: model.NewPointer(false),
|
|
},
|
|
},
|
|
}
|
|
removeCreatePosts := []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(false),
|
|
Guests: model.NewPointer(false),
|
|
},
|
|
},
|
|
}
|
|
|
|
wg := sync.WaitGroup{}
|
|
wg.Add(20)
|
|
for range 10 {
|
|
go func() {
|
|
_, appErr := th.App.PatchChannelModerationsForChannel(th.Context, channel.DeepCopy(), addCreatePosts)
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.PatchChannelModerationsForChannel(th.Context, channel.DeepCopy(), removeCreatePosts)
|
|
require.Nil(t, appErr)
|
|
wg.Done()
|
|
}()
|
|
}
|
|
for range 10 {
|
|
go func() {
|
|
_, appErr := th.App.PatchChannelModerationsForChannel(th.Context, channel.DeepCopy(), addCreatePosts)
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.PatchChannelModerationsForChannel(th.Context, channel.DeepCopy(), removeCreatePosts)
|
|
require.Nil(t, appErr)
|
|
wg.Done()
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
|
|
higherScopedGuestRoleName, higherScopedMemberRoleName, _, _ := th.App.GetTeamSchemeChannelRoles(th.Context, channel.TeamId)
|
|
higherScopedMemberRole, _ := th.App.GetRoleByName(th.Context, higherScopedMemberRoleName)
|
|
higherScopedGuestRole, _ := th.App.GetRoleByName(th.Context, higherScopedGuestRoleName)
|
|
assert.Contains(t, higherScopedMemberRole.Permissions, createPosts)
|
|
assert.Contains(t, higherScopedGuestRole.Permissions, createPosts)
|
|
})
|
|
|
|
t.Run("Updates the authorization to create post", func(t *testing.T) {
|
|
addCreatePosts := []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(true),
|
|
},
|
|
},
|
|
}
|
|
removeCreatePosts := []*model.ChannelModerationPatch{
|
|
{
|
|
Name: &createPosts,
|
|
Roles: &model.ChannelModeratedRolesPatch{
|
|
Members: model.NewPointer(false),
|
|
},
|
|
},
|
|
}
|
|
|
|
mockSession := model.Session{UserId: user.Id}
|
|
|
|
_, appErr := th.App.PatchChannelModerationsForChannel(th.Context, channel.DeepCopy(), addCreatePosts)
|
|
require.Nil(t, appErr)
|
|
require.True(t, th.App.SessionHasPermissionToChannel(th.Context, mockSession, channel.Id, model.PermissionCreatePost))
|
|
|
|
_, appErr = th.App.PatchChannelModerationsForChannel(th.Context, channel.DeepCopy(), removeCreatePosts)
|
|
require.Nil(t, appErr)
|
|
require.False(t, th.App.SessionHasPermissionToChannel(th.Context, mockSession, channel.Id, model.PermissionCreatePost))
|
|
})
|
|
}
|
|
|
|
func TestClearChannelMembersCache(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
mockStore := th.App.Srv().Store().(*mocks.Store)
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
cms := model.ChannelMembers{}
|
|
for range 200 {
|
|
cms = append(cms, model.ChannelMember{
|
|
ChannelId: "1",
|
|
})
|
|
}
|
|
mockChannelStore.On("GetMembers", model.ChannelMembersGetOptions{
|
|
ChannelID: "channelID",
|
|
Offset: 0,
|
|
Limit: 100,
|
|
}).Return(cms, nil)
|
|
mockChannelStore.On("GetMembers", model.ChannelMembersGetOptions{
|
|
ChannelID: "channelID",
|
|
Offset: 100,
|
|
Limit: 100,
|
|
}).Return(model.ChannelMembers{
|
|
model.ChannelMember{
|
|
ChannelId: "1",
|
|
},
|
|
}, nil)
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
mockStore.On("GetDBSchemaVersion").Return(1, nil)
|
|
|
|
require.NoError(t, th.App.ClearChannelMembersCache(th.Context, "channelID"))
|
|
}
|
|
|
|
func TestGetMemberCountsByGroup(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
mockStore := th.App.Srv().Store().(*mocks.Store)
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
cmc := []*model.ChannelMemberCountByGroup{}
|
|
for i := range 5 {
|
|
cmc = append(cmc, &model.ChannelMemberCountByGroup{
|
|
GroupId: model.NewId(),
|
|
ChannelMemberCount: int64(i),
|
|
ChannelMemberTimezonesCount: int64(i),
|
|
})
|
|
}
|
|
mockChannelStore.On("GetMemberCountsByGroup", mock.AnythingOfType("*request.Context"), "channelID", true).Return(cmc, nil)
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
mockStore.On("GetDBSchemaVersion").Return(1, nil)
|
|
resp, appErr := th.App.GetMemberCountsByGroup(th.Context, "channelID", true)
|
|
require.Nil(t, appErr)
|
|
require.ElementsMatch(t, cmc, resp)
|
|
}
|
|
|
|
func TestGetChannelsMemberCount(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
mockStore := th.App.Srv().Store().(*mocks.Store)
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
channelsMemberCount := map[string]int64{
|
|
"channel1": int64(10),
|
|
"channel2": int64(20),
|
|
}
|
|
mockChannelStore.On("GetChannelsMemberCount", []string{"channel1", "channel2"}).Return(channelsMemberCount, nil)
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
mockStore.On("GetDBSchemaVersion").Return(1, nil)
|
|
resp, appErr := th.App.GetChannelsMemberCount(th.Context, []string{"channel1", "channel2"})
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, channelsMemberCount, resp)
|
|
}
|
|
|
|
func TestViewChannelCollapsedThreadsTurnedOff(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
u1 := th.BasicUser
|
|
u2 := th.BasicUser2
|
|
c1 := th.BasicChannel
|
|
th.AddUserToChannel(u2, c1)
|
|
|
|
// Enable CRT
|
|
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.ServiceSettings.ThreadAutoFollow = true
|
|
*cfg.ServiceSettings.CollapsedThreads = model.CollapsedThreadsDefaultOn
|
|
})
|
|
|
|
// Turn off CRT for user
|
|
preference := model.Preference{
|
|
UserId: u1.Id,
|
|
Category: model.PreferenceCategoryDisplaySettings,
|
|
Name: model.PreferenceNameCollapsedThreadsEnabled,
|
|
Value: "off",
|
|
}
|
|
var preferences model.Preferences
|
|
preferences = append(preferences, preference)
|
|
err := th.App.Srv().Store().Preference().Save(preferences)
|
|
require.NoError(t, err)
|
|
|
|
// mention the user in a root post
|
|
post1 := &model.Post{
|
|
ChannelId: c1.Id,
|
|
Message: "root post @" + u1.Username,
|
|
UserId: u2.Id,
|
|
}
|
|
rpost1, appErr := th.App.CreatePost(th.Context, post1, c1, model.CreatePostFlags{SetOnline: true})
|
|
require.Nil(t, appErr)
|
|
|
|
// mention the user in a reply post
|
|
post2 := &model.Post{
|
|
ChannelId: c1.Id,
|
|
Message: "reply post @" + u1.Username,
|
|
UserId: u2.Id,
|
|
RootId: rpost1.Id,
|
|
}
|
|
_, appErr = th.App.CreatePost(th.Context, post2, c1, model.CreatePostFlags{SetOnline: true})
|
|
require.Nil(t, appErr)
|
|
|
|
// Check we have unread mention in the thread
|
|
threads, appErr := th.App.GetThreadsForUser(th.Context, u1.Id, c1.TeamId, model.GetUserThreadsOpts{})
|
|
require.Nil(t, appErr)
|
|
found := false
|
|
for _, thread := range threads.Threads {
|
|
if thread.PostId == rpost1.Id {
|
|
require.EqualValues(t, int64(1), thread.UnreadMentions)
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
require.Truef(t, found, "did not find created thread in user's threads")
|
|
|
|
// Mark channel as read from a client that supports CRT
|
|
_, appErr = th.App.MarkChannelsAsViewed(th.Context, []string{c1.Id}, u1.Id, th.Context.Session().Id, true, th.App.IsCRTEnabledForUser(th.Context, u1.Id))
|
|
require.Nil(t, appErr)
|
|
|
|
// Thread should be marked as read because CRT has been turned off by user
|
|
threads, appErr = th.App.GetThreadsForUser(th.Context, u1.Id, c1.TeamId, model.GetUserThreadsOpts{})
|
|
require.Nil(t, appErr)
|
|
found = false
|
|
for _, thread := range threads.Threads {
|
|
if thread.PostId == rpost1.Id {
|
|
require.Zero(t, thread.UnreadMentions)
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
require.Truef(t, found, "did not find created thread in user's threads")
|
|
}
|
|
|
|
func TestMarkChannelAsUnreadFromPostCollapsedThreadsTurnedOff(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
// Enable CRT
|
|
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.ServiceSettings.ThreadAutoFollow = true
|
|
*cfg.ServiceSettings.CollapsedThreads = model.CollapsedThreadsDefaultOn
|
|
})
|
|
|
|
th.AddUserToChannel(th.BasicUser2, th.BasicChannel)
|
|
|
|
// Turn off CRT for user
|
|
preference := model.Preference{
|
|
UserId: th.BasicUser.Id,
|
|
Category: model.PreferenceCategoryDisplaySettings,
|
|
Name: model.PreferenceNameCollapsedThreadsEnabled,
|
|
Value: "off",
|
|
}
|
|
var preferences model.Preferences
|
|
preferences = append(preferences, preference)
|
|
err := th.App.Srv().Store().Preference().Save(preferences)
|
|
require.NoError(t, err)
|
|
|
|
// user2: first root mention @user1
|
|
// - user1: hello
|
|
// - user2: mention @u1
|
|
// - user1: another reply
|
|
// - user2: another mention @u1
|
|
// user1: a root post
|
|
// user2: Another root mention @u1
|
|
user1Mention := " @" + th.BasicUser.Username
|
|
rootPost1, appErr := th.App.CreatePost(th.Context, &model.Post{UserId: th.BasicUser2.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "first root mention" + user1Mention}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.CreatePost(th.Context, &model.Post{RootId: rootPost1.Id, UserId: th.BasicUser.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "hello"}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
replyPost1, appErr := th.App.CreatePost(th.Context, &model.Post{RootId: rootPost1.Id, UserId: th.BasicUser2.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "mention" + user1Mention}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.CreatePost(th.Context, &model.Post{RootId: rootPost1.Id, UserId: th.BasicUser.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "another reply"}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.CreatePost(th.Context, &model.Post{RootId: rootPost1.Id, UserId: th.BasicUser2.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "another mention" + user1Mention}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.CreatePost(th.Context, &model.Post{UserId: th.BasicUser.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "a root post"}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.CreatePost(th.Context, &model.Post{UserId: th.BasicUser2.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "another root mention" + user1Mention}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
|
|
t.Run("Mark reply post as unread", func(t *testing.T) {
|
|
_, appErr := th.App.MarkChannelAsUnreadFromPost(th.Context, replyPost1.Id, th.BasicUser.Id, true)
|
|
require.Nil(t, appErr)
|
|
// Get channel unreads
|
|
// Easier to reason with ChannelUnread now, than channelUnreadAt from the previous call
|
|
channelUnread, appErr := th.App.GetChannelUnread(th.Context, th.BasicChannel.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
require.Equal(t, int64(3), channelUnread.MentionCount)
|
|
// MentionCountRoot should be zero for a user that has CRT turned off
|
|
require.Equal(t, int64(0), channelUnread.MentionCountRoot)
|
|
|
|
require.Equal(t, int64(5), channelUnread.MsgCount)
|
|
// MentionCountRoot should be zero for a user that has CRT turned off
|
|
require.Equal(t, channelUnread.MsgCountRoot, int64(0))
|
|
|
|
threadMembership, appErr := th.App.GetThreadMembershipForUser(th.BasicUser.Id, rootPost1.Id)
|
|
require.Nil(t, appErr)
|
|
thread, appErr := th.App.GetThreadForUser(th.Context, threadMembership, false)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(2), thread.UnreadMentions)
|
|
require.Equal(t, int64(3), thread.UnreadReplies)
|
|
})
|
|
|
|
t.Run("Mark root post as unread", func(t *testing.T) {
|
|
_, appErr := th.App.MarkChannelAsUnreadFromPost(th.Context, rootPost1.Id, th.BasicUser.Id, true)
|
|
require.Nil(t, appErr)
|
|
// Get channel unreads
|
|
// Easier to reason with ChannelUnread now, than channelUnreadAt from the previous call
|
|
channelUnread, appErr := th.App.GetChannelUnread(th.Context, th.BasicChannel.Id, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
require.Equal(t, int64(4), channelUnread.MentionCount)
|
|
require.Equal(t, int64(2), channelUnread.MentionCountRoot)
|
|
|
|
require.Equal(t, int64(7), channelUnread.MsgCount)
|
|
require.Equal(t, int64(3), channelUnread.MsgCountRoot)
|
|
})
|
|
}
|
|
|
|
func TestMarkUnreadCRTOffUpdatesThreads(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.ServiceSettings.ThreadAutoFollow = true
|
|
*cfg.ServiceSettings.CollapsedThreads = model.CollapsedThreadsDefaultOff
|
|
})
|
|
|
|
t.Run("Mentions counted correctly if post is edited", func(t *testing.T) {
|
|
user3 := th.CreateUser()
|
|
defer func() {
|
|
appErr := th.App.PermanentDeleteUser(th.Context, user3)
|
|
require.Nil(t, appErr)
|
|
}()
|
|
rootPost, appErr := th.App.CreatePost(th.Context, &model.Post{UserId: th.BasicUser.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "root post"}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
r1, appErr := th.App.CreatePost(th.Context, &model.Post{RootId: rootPost.Id, UserId: th.BasicUser2.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "reply 1"}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.CreatePost(th.Context, &model.Post{RootId: rootPost.Id, UserId: th.BasicUser.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "reply 2 @" + user3.Username}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
_, appErr = th.App.CreatePost(th.Context, &model.Post{RootId: rootPost.Id, UserId: th.BasicUser2.Id, CreateAt: model.GetMillis(), ChannelId: th.BasicChannel.Id, Message: "reply 3"}, th.BasicChannel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
editedPost := r1.Clone()
|
|
editedPost.Message += " edited"
|
|
_, appErr = th.App.UpdatePost(th.Context, editedPost, &model.UpdatePostOptions{SafeUpdate: false})
|
|
require.Nil(t, appErr)
|
|
|
|
th.LinkUserToTeam(user3, th.BasicTeam)
|
|
th.AddUserToChannel(user3, th.BasicChannel)
|
|
|
|
_, appErr = th.App.MarkChannelAsUnreadFromPost(th.Context, editedPost.Id, user3.Id, false)
|
|
require.Nil(t, appErr)
|
|
threadMembership, appErr := th.App.GetThreadMembershipForUser(user3.Id, rootPost.Id)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, threadMembership)
|
|
require.True(t, threadMembership.Following)
|
|
assert.Equal(t, int64(1), threadMembership.UnreadMentions)
|
|
})
|
|
}
|
|
|
|
func TestIsCRTEnabledForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
type preference struct {
|
|
val string
|
|
err error
|
|
}
|
|
|
|
testCases := []struct {
|
|
desc string
|
|
appCRT string
|
|
pref preference
|
|
expected bool
|
|
}{
|
|
{
|
|
desc: "Returns false when system config is disabled",
|
|
appCRT: model.CollapsedThreadsDisabled,
|
|
expected: false,
|
|
},
|
|
{
|
|
desc: "Returns true when system config is always_on",
|
|
appCRT: model.CollapsedThreadsAlwaysOn,
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "Returns true when system config is default_on and user has no preference",
|
|
appCRT: model.CollapsedThreadsDefaultOn,
|
|
pref: preference{"test", errors.New("err")},
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "Returns false when system config is default_off and user has no preference",
|
|
appCRT: model.CollapsedThreadsDefaultOff,
|
|
pref: preference{"qwe", errors.New("err")},
|
|
expected: false,
|
|
},
|
|
{
|
|
desc: "Returns true when system config is default_on and user has on preference",
|
|
appCRT: model.CollapsedThreadsDefaultOn,
|
|
pref: preference{"on", nil},
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "Returns false when system config is default_on and user has off preference",
|
|
appCRT: model.CollapsedThreadsDefaultOn,
|
|
pref: preference{"off", nil},
|
|
expected: false,
|
|
},
|
|
{
|
|
desc: "Returns true when system config is default_off and user has on preference",
|
|
appCRT: model.CollapsedThreadsDefaultOff,
|
|
pref: preference{"on", nil},
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "Returns false when system config is default_off and user has off preference",
|
|
appCRT: model.CollapsedThreadsDefaultOff,
|
|
pref: preference{"off", nil},
|
|
expected: false,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.desc, func(t *testing.T) {
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
th.App.Config().ServiceSettings.CollapsedThreads = &tc.appCRT
|
|
|
|
mockStore := th.App.Srv().Store().(*mocks.Store)
|
|
mockPreferenceStore := mocks.PreferenceStore{}
|
|
mockPreferenceStore.On("Get", mock.Anything, model.PreferenceCategoryDisplaySettings, model.PreferenceNameCollapsedThreadsEnabled).Return(&model.Preference{Value: tc.pref.val}, tc.pref.err)
|
|
mockStore.On("Preference").Return(&mockPreferenceStore)
|
|
|
|
res := th.App.IsCRTEnabledForUser(th.Context, mock.Anything)
|
|
|
|
assert.Equal(t, tc.expected, res)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetDirectOrGroupMessageMembersCommonTeams(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
teamsToCreate := 2
|
|
usersToCreate := 4 // at least 3 users to create a GM channel, last user is not in any team
|
|
teams := make([]string, 0, teamsToCreate)
|
|
for i := 0; i < cap(teams); i++ {
|
|
team := th.CreateTeam()
|
|
defer func(team *model.Team) {
|
|
appErr := th.App.PermanentDeleteTeam(th.Context, team)
|
|
require.Nil(t, appErr)
|
|
}(team)
|
|
teams = append(teams, team.Id)
|
|
}
|
|
|
|
users := make([]string, 0, usersToCreate)
|
|
for i := 0; i < cap(users); i++ {
|
|
user := th.CreateUser()
|
|
defer func(user *model.User) {
|
|
appErr := th.App.PermanentDeleteUser(th.Context, user)
|
|
require.Nil(t, appErr)
|
|
}(user)
|
|
users = append(users, user.Id)
|
|
}
|
|
|
|
for _, teamId := range teams {
|
|
// add first 3 users to each team, last user is not in any team
|
|
for i := range 3 {
|
|
_, _, appErr := th.App.AddUserToTeam(th.Context, teamId, users[i], "")
|
|
require.Nil(t, appErr)
|
|
}
|
|
}
|
|
|
|
// create GM channel with first 3 users who share common teams
|
|
gmChannel, appErr := th.App.createGroupChannel(th.Context, users[:3], users[0])
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, gmChannel)
|
|
|
|
// normally you can't create a GM channel with users that don't share any teams, but we do it here to test the edge case
|
|
// create GM channel with last 3 users, where last member is not in any team
|
|
otherGMChannel, appErr := th.App.createGroupChannel(th.Context, users[1:], users[0])
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, otherGMChannel)
|
|
|
|
t.Run("Get teams for GM channel", func(t *testing.T) {
|
|
commonTeams, appErr := th.App.GetDirectOrGroupMessageMembersCommonTeams(th.Context, gmChannel.Id)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, 2, len(commonTeams))
|
|
})
|
|
|
|
t.Run("No common teams", func(t *testing.T) {
|
|
commonTeams, appErr := th.App.GetDirectOrGroupMessageMembersCommonTeams(th.Context, otherGMChannel.Id)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, 0, len(commonTeams))
|
|
})
|
|
}
|
|
|
|
func TestConvertGroupMessageToChannel(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
mockStore := th.App.Srv().Store().(*mocks.Store)
|
|
|
|
mockChannelStore := mocks.ChannelStore{}
|
|
mockStore.On("Channel").Return(&mockChannelStore)
|
|
mockChannelStore.On("Get", "channelidchannelidchanneli", true).Return(&model.Channel{
|
|
Id: "channelidchannelidchanneli",
|
|
CreateAt: time.Now().Unix(),
|
|
UpdateAt: time.Now().Unix(),
|
|
Type: model.ChannelTypeGroup,
|
|
}, nil)
|
|
mockChannelStore.On("Update", mock.AnythingOfType("*request.Context"), mock.AnythingOfType("*model.Channel")).Return(&model.Channel{}, nil)
|
|
mockChannelStore.On("InvalidateChannel", "channelidchannelidchanneli")
|
|
mockChannelStore.On("InvalidateChannelByName", "team_id_1", "new_name").Times(1)
|
|
mockChannelStore.On("InvalidateChannelByName", "dm", "")
|
|
mockChannelStore.On("GetMember", mock.AnythingOfType("*request.Context"), "channelidchannelidchanneli", "user_id_1").Return(&model.ChannelMember{}, nil)
|
|
mockChannelStore.On("UpdateMember", mock.AnythingOfType("*request.Context"), mock.AnythingOfType("*model.ChannelMember")).Return(&model.ChannelMember{UserId: "user_id_1"}, nil)
|
|
mockChannelStore.On("InvalidateAllChannelMembersForUser", "user_id_1").Return()
|
|
mockChannelStore.On("InvalidatePinnedPostCount", "channelidchannelidchanneli")
|
|
mockChannelStore.On("GetAllChannelMembersNotifyPropsForChannel", "channelidchannelidchanneli", true).Return(map[string]model.StringMap{}, nil)
|
|
mockChannelStore.On("IncrementMentionCount", "", []string{}, true, false).Return(nil)
|
|
mockChannelStore.On("DeleteAllSidebarChannelForChannel", "channelidchannelidchanneli").Return(nil)
|
|
mockChannelStore.On("GetSidebarCategories", "user_id_1", "team_id_1").Return(
|
|
&model.OrderedSidebarCategories{
|
|
Categories: model.SidebarCategoriesWithChannels{
|
|
{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Type: model.SidebarCategoryChannels,
|
|
},
|
|
},
|
|
},
|
|
}, nil)
|
|
mockChannelStore.On("GetSidebarCategories", "user_id_2", "team_id_1").Return(
|
|
&model.OrderedSidebarCategories{
|
|
Categories: model.SidebarCategoriesWithChannels{
|
|
{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Type: model.SidebarCategoryChannels,
|
|
},
|
|
},
|
|
},
|
|
}, nil)
|
|
mockChannelStore.On("UpdateSidebarCategories", "user_id_1", "team_id_1", mock.Anything).Return(
|
|
[]*model.SidebarCategoryWithChannels{
|
|
{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Type: model.SidebarCategoryChannels,
|
|
},
|
|
},
|
|
},
|
|
[]*model.SidebarCategoryWithChannels{
|
|
{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Type: model.SidebarCategoryChannels,
|
|
},
|
|
},
|
|
},
|
|
nil,
|
|
)
|
|
mockChannelStore.On("UpdateSidebarCategories", "user_id_2", "team_id_1", mock.Anything).Return(
|
|
[]*model.SidebarCategoryWithChannels{
|
|
{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Type: model.SidebarCategoryChannels,
|
|
},
|
|
},
|
|
},
|
|
[]*model.SidebarCategoryWithChannels{
|
|
{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Type: model.SidebarCategoryChannels,
|
|
},
|
|
},
|
|
},
|
|
nil,
|
|
)
|
|
|
|
mockTeamStore := mocks.TeamStore{}
|
|
mockStore.On("Team").Return(&mockTeamStore)
|
|
mockTeamStore.On("GetMember", mock.AnythingOfType("*request.Context"), "team_id_1", "user_id_1").Return(&model.TeamMember{}, nil)
|
|
mockTeamStore.On("GetCommonTeamIDsForMultipleUsers", []string{"user_id_1", "user_id_2"}).Return([]string{"team_id_1", "team_id_2", "team_id_3"}, nil).Times(1)
|
|
mockTeamStore.On("GetMany", []string{"team_id_1", "team_id_2", "team_id_3"}).Return(
|
|
[]*model.Team{
|
|
{Id: "team_id_1", DisplayName: "Team 1"},
|
|
{Id: "team_id_2", DisplayName: "Team 2"},
|
|
{Id: "team_id_3", DisplayName: "Team 3"},
|
|
},
|
|
nil,
|
|
)
|
|
|
|
mockUserStore := mocks.UserStore{}
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
mockUserStore.On("Get", context.Background(), "user_id_1").Return(&model.User{Username: "username_1"}, nil)
|
|
mockUserStore.On("GetProfilesInChannel", mock.AnythingOfType("*model.UserGetOptions")).Return([]*model.User{
|
|
{Id: "user_id_1", Username: "user_id_1"},
|
|
{Id: "user_id_2", Username: "user_id_2"},
|
|
}, nil)
|
|
mockUserStore.On("GetAllProfilesInChannel", mock.Anything, mock.Anything, mock.Anything).Return(map[string]*model.User{}, nil)
|
|
mockUserStore.On("InvalidateProfilesInChannelCacheByUser", "user_id_1").Return()
|
|
mockUserStore.On("InvalidateProfileCacheForUser", "user_id_1").Return()
|
|
|
|
mockPostStore := mocks.PostStore{}
|
|
mockStore.On("Post").Return(&mockPostStore)
|
|
mockPostStore.On("Save", mock.AnythingOfType("*request.Context"), mock.AnythingOfType("*model.Post")).Return(&model.Post{}, nil)
|
|
mockPostStore.On("InvalidateLastPostTimeCache", "channelidchannelidchanneli")
|
|
|
|
mockSystemStore := mocks.SystemStore{}
|
|
mockStore.On("System").Return(&mockSystemStore)
|
|
mockSystemStore.On("GetByName", model.MigrationKeyAdvancedPermissionsPhase2).Return(nil, nil)
|
|
|
|
var err error
|
|
|
|
th.App.ch.srv.userService, err = users.New(users.ServiceConfig{
|
|
UserStore: &mockUserStore,
|
|
ConfigFn: th.App.ch.srv.platform.Config,
|
|
SessionStore: &mocks.SessionStore{},
|
|
OAuthStore: &mocks.OAuthStore{},
|
|
LicenseFn: th.App.ch.srv.License,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
th.App.ch.srv.teamService, err = teams.New(teams.ServiceConfig{
|
|
TeamStore: &mockTeamStore,
|
|
ChannelStore: &mockChannelStore,
|
|
GroupStore: &mocks.GroupStore{},
|
|
Users: th.App.ch.srv.userService,
|
|
WebHub: th.App.ch.srv.platform,
|
|
ConfigFn: th.App.ch.srv.platform.Config,
|
|
LicenseFn: th.App.ch.srv.License,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
conversionRequest := &model.GroupMessageConversionRequestBody{
|
|
ChannelID: "channelidchannelidchanneli",
|
|
TeamID: "team_id_1",
|
|
Name: "new_name",
|
|
DisplayName: "New Display Name",
|
|
}
|
|
|
|
convertedChannel, appErr := th.App.ConvertGroupMessageToChannel(th.Context, "user_id_1", conversionRequest)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, model.ChannelTypePrivate, convertedChannel.Type)
|
|
}
|
|
|
|
func TestPatchChannelMembersNotifyProps(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should update multiple users' notify props", func(t *testing.T) {
|
|
user1 := th.CreateUser()
|
|
user2 := th.CreateUser()
|
|
|
|
channel1 := th.CreateChannel(th.Context, th.BasicTeam)
|
|
channel2 := th.CreateChannel(th.Context, th.BasicTeam)
|
|
|
|
th.LinkUserToTeam(user1, th.BasicTeam)
|
|
th.LinkUserToTeam(user2, th.BasicTeam)
|
|
th.AddUserToChannel(user1, channel1)
|
|
th.AddUserToChannel(user1, channel2)
|
|
th.AddUserToChannel(user2, channel1)
|
|
th.AddUserToChannel(user2, channel2)
|
|
|
|
result, appErr := th.App.PatchChannelMembersNotifyProps(th.Context, []*model.ChannelMemberIdentifier{
|
|
{UserId: user1.Id, ChannelId: channel1.Id},
|
|
{UserId: user1.Id, ChannelId: channel2.Id},
|
|
{UserId: user2.Id, ChannelId: channel1.Id},
|
|
}, map[string]string{
|
|
model.DesktopNotifyProp: model.ChannelNotifyNone,
|
|
"custom_key": "custom_value",
|
|
})
|
|
|
|
require.Nil(t, appErr)
|
|
|
|
// Confirm specified fields were updated
|
|
assert.Equal(t, model.ChannelNotifyNone, result[0].NotifyProps[model.DesktopNotifyProp])
|
|
assert.Equal(t, "custom_value", result[0].NotifyProps["custom_key"])
|
|
assert.Equal(t, model.ChannelNotifyNone, result[1].NotifyProps[model.DesktopNotifyProp])
|
|
assert.Equal(t, "custom_value", result[1].NotifyProps["custom_key"])
|
|
assert.Equal(t, model.ChannelNotifyNone, result[2].NotifyProps[model.DesktopNotifyProp])
|
|
assert.Equal(t, "custom_value", result[2].NotifyProps["custom_key"])
|
|
|
|
// Confirm unspecified fields were unchanged
|
|
assert.Equal(t, model.ChannelNotifyDefault, result[0].NotifyProps[model.PushNotifyProp])
|
|
assert.Equal(t, model.ChannelNotifyDefault, result[1].NotifyProps[model.PushNotifyProp])
|
|
assert.Equal(t, model.ChannelNotifyDefault, result[2].NotifyProps[model.PushNotifyProp])
|
|
|
|
// Confirm other members were unchanged
|
|
otherMember, appErr := th.App.GetChannelMember(th.Context, channel2.Id, user2.Id)
|
|
|
|
require.Nil(t, appErr)
|
|
|
|
assert.Equal(t, model.ChannelNotifyDefault, otherMember.NotifyProps[model.DesktopNotifyProp])
|
|
assert.Equal(t, "", otherMember.NotifyProps["custom_key"])
|
|
assert.Equal(t, model.ChannelNotifyDefault, otherMember.NotifyProps[model.PushNotifyProp])
|
|
})
|
|
|
|
t.Run("should send WS events for each user", func(t *testing.T) {
|
|
user1 := th.CreateUser()
|
|
user2 := th.CreateUser()
|
|
|
|
channel1 := th.CreateChannel(th.Context, th.BasicTeam)
|
|
channel2 := th.CreateChannel(th.Context, th.BasicTeam)
|
|
|
|
th.LinkUserToTeam(user1, th.BasicTeam)
|
|
th.LinkUserToTeam(user2, th.BasicTeam)
|
|
th.AddUserToChannel(user1, channel1)
|
|
th.AddUserToChannel(user1, channel2)
|
|
th.AddUserToChannel(user2, channel1)
|
|
|
|
eventTypesFilter := []model.WebsocketEventType{model.WebsocketEventChannelMemberUpdated}
|
|
|
|
messages1, closeWS1 := connectFakeWebSocket(t, th, user1.Id, "", eventTypesFilter)
|
|
defer closeWS1()
|
|
messages2, closeWS2 := connectFakeWebSocket(t, th, user2.Id, "", eventTypesFilter)
|
|
defer closeWS2()
|
|
|
|
_, appErr := th.App.PatchChannelMembersNotifyProps(th.Context, []*model.ChannelMemberIdentifier{
|
|
{UserId: user1.Id, ChannelId: channel1.Id},
|
|
{UserId: user1.Id, ChannelId: channel2.Id},
|
|
{UserId: user2.Id, ChannelId: channel1.Id},
|
|
}, map[string]string{
|
|
model.DesktopNotifyProp: model.ChannelNotifyNone,
|
|
"custom_key": "custom_value",
|
|
})
|
|
|
|
require.Nil(t, appErr)
|
|
|
|
// User1, Channel1
|
|
received := <-messages1
|
|
assert.Equal(t, model.WebsocketEventChannelMemberUpdated, received.EventType())
|
|
|
|
member := decodeJSON(received.GetData()["channelMember"], &model.ChannelMember{})
|
|
assert.Equal(t, user1.Id, member.UserId)
|
|
assert.Contains(t, []string{channel1.Id, channel2.Id}, member.ChannelId)
|
|
assert.Equal(t, model.ChannelNotifyNone, member.NotifyProps[model.DesktopNotifyProp])
|
|
assert.Equal(t, "custom_value", member.NotifyProps["custom_key"])
|
|
assert.Equal(t, model.ChannelNotifyDefault, member.NotifyProps[model.PushNotifyProp])
|
|
|
|
// User1, Channel2
|
|
received = <-messages1
|
|
assert.Equal(t, model.WebsocketEventChannelMemberUpdated, received.EventType())
|
|
|
|
member = decodeJSON(received.GetData()["channelMember"], &model.ChannelMember{})
|
|
assert.Equal(t, user1.Id, member.UserId)
|
|
assert.Contains(t, []string{channel1.Id, channel2.Id}, member.ChannelId)
|
|
assert.Equal(t, model.ChannelNotifyNone, member.NotifyProps[model.DesktopNotifyProp])
|
|
assert.Equal(t, "custom_value", member.NotifyProps["custom_key"])
|
|
assert.Equal(t, model.ChannelNotifyDefault, member.NotifyProps[model.PushNotifyProp])
|
|
|
|
// User2, Channel1
|
|
received = <-messages2
|
|
assert.Equal(t, model.WebsocketEventChannelMemberUpdated, received.EventType())
|
|
|
|
member = decodeJSON(received.GetData()["channelMember"], &model.ChannelMember{})
|
|
assert.Equal(t, user2.Id, member.UserId)
|
|
assert.Equal(t, channel1.Id, member.ChannelId)
|
|
assert.Equal(t, model.ChannelNotifyNone, member.NotifyProps[model.DesktopNotifyProp])
|
|
assert.Equal(t, "custom_value", member.NotifyProps["custom_key"])
|
|
assert.Equal(t, model.ChannelNotifyDefault, member.NotifyProps[model.PushNotifyProp])
|
|
})
|
|
|
|
t.Run("should return an error when trying to update too many users at once", func(t *testing.T) {
|
|
identifiers := make([]*model.ChannelMemberIdentifier, 201)
|
|
for i := range identifiers {
|
|
identifiers[i] = &model.ChannelMemberIdentifier{UserId: "fakeuser", ChannelId: "fakechannel"}
|
|
}
|
|
|
|
_, appErr := th.App.PatchChannelMembersNotifyProps(th.Context, identifiers, map[string]string{})
|
|
|
|
assert.NotNil(t, appErr)
|
|
})
|
|
}
|
|
|
|
func TestGetChannelFileCount(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
channel := th.BasicChannel
|
|
|
|
// Create a post with files
|
|
post := &model.Post{
|
|
ChannelId: channel.Id,
|
|
Message: "This is a test post",
|
|
UserId: th.BasicUser.Id,
|
|
}
|
|
post, appErr := th.App.CreatePost(th.Context, post, channel, model.CreatePostFlags{})
|
|
require.Nil(t, appErr)
|
|
|
|
fileInfo1 := &model.FileInfo{
|
|
Name: "file1.txt",
|
|
MimeType: "text/plain",
|
|
ChannelId: channel.Id,
|
|
CreatorId: th.BasicUser.Id,
|
|
PostId: post.Id,
|
|
Path: "/path/to/file1.txt",
|
|
}
|
|
_, err := th.App.Srv().Store().FileInfo().Save(th.Context, fileInfo1)
|
|
require.NoError(t, err)
|
|
|
|
fileInfo2 := &model.FileInfo{
|
|
Name: "file2.txt",
|
|
MimeType: "text/plain",
|
|
ChannelId: channel.Id,
|
|
CreatorId: th.BasicUser.Id,
|
|
PostId: post.Id,
|
|
Path: "/path/to/file2.txt",
|
|
}
|
|
_, err = th.App.Srv().Store().FileInfo().Save(th.Context, fileInfo2)
|
|
require.NoError(t, err)
|
|
|
|
// Create a file without a post
|
|
fileInfo3 := &model.FileInfo{
|
|
Name: "file3.txt",
|
|
MimeType: "text/plain",
|
|
ChannelId: channel.Id,
|
|
CreatorId: th.BasicUser.Id,
|
|
Path: "/path/to/file3.txt",
|
|
}
|
|
_, err = th.App.Srv().Store().FileInfo().Save(th.Context, fileInfo3)
|
|
require.NoError(t, err)
|
|
|
|
count, appErr := th.App.GetChannelFileCount(th.Context, channel.Id)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(2), count)
|
|
}
|
|
|
|
func TestCheckIfChannelIsRestrictedDM(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
channel := th.CreateDmChannel(th.BasicUser2)
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.TeamSettings.RestrictDirectMessage = model.DirectMessageTeam
|
|
})
|
|
|
|
// Ensure the two users do not share a team
|
|
teams, err := th.App.GetTeamsForUser(th.BasicUser.Id)
|
|
require.Nil(t, err)
|
|
for _, team := range teams {
|
|
teamErr := th.App.RemoveUserFromTeam(th.Context, team.Id, th.BasicUser.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, teamErr)
|
|
}
|
|
teams, err = th.App.GetTeamsForUser(th.BasicUser2.Id)
|
|
require.Nil(t, err)
|
|
for _, team := range teams {
|
|
teamErr := th.App.RemoveUserFromTeam(th.Context, team.Id, th.BasicUser2.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, teamErr)
|
|
}
|
|
|
|
team1 := th.CreateTeam()
|
|
team2 := th.CreateTeam()
|
|
th.LinkUserToTeam(th.BasicUser, team1)
|
|
th.LinkUserToTeam(th.BasicUser2, team2)
|
|
|
|
t.Run("should be restricted", func(t *testing.T) {
|
|
restricted, err := th.App.CheckIfChannelIsRestrictedDM(th.Context, channel)
|
|
require.Nil(t, err)
|
|
require.True(t, restricted)
|
|
})
|
|
|
|
t.Run("setting set to any", func(t *testing.T) {
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.TeamSettings.RestrictDirectMessage = model.DirectMessageAny
|
|
})
|
|
|
|
restricted, err := th.App.CheckIfChannelIsRestrictedDM(th.Context, channel)
|
|
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.TeamSettings.RestrictDirectMessage = model.DirectMessageTeam
|
|
})
|
|
|
|
require.Nil(t, err)
|
|
require.False(t, restricted)
|
|
})
|
|
|
|
t.Run("channel is not a direct or group channel", func(t *testing.T) {
|
|
openChannel := th.CreateChannel(th.Context, th.BasicTeam)
|
|
restricted, err := th.App.CheckIfChannelIsRestrictedDM(th.Context, openChannel)
|
|
require.Nil(t, err)
|
|
require.False(t, restricted)
|
|
})
|
|
|
|
t.Run("group message where users share a team", func(t *testing.T) {
|
|
team := th.CreateTeam()
|
|
user1 := th.CreateUser()
|
|
user2 := th.CreateUser()
|
|
th.LinkUserToTeam(user1, team)
|
|
th.LinkUserToTeam(user2, team)
|
|
th.LinkUserToTeam(th.BasicUser, team)
|
|
|
|
groupChannel := th.CreateGroupChannel(th.Context, user1, user2)
|
|
|
|
restricted, err := th.App.CheckIfChannelIsRestrictedDM(th.Context, groupChannel)
|
|
require.Nil(t, err)
|
|
require.False(t, restricted)
|
|
})
|
|
}
|
|
|
|
func TestUpdateChannel(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should be able to update banner info", func(t *testing.T) {
|
|
channel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
|
|
channel.BannerInfo = &model.ChannelBannerInfo{
|
|
Enabled: model.NewPointer(true),
|
|
Text: model.NewPointer("banner text"),
|
|
BackgroundColor: model.NewPointer("#000000"),
|
|
}
|
|
|
|
updatedChannel, appErr := th.App.UpdateChannel(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, updatedChannel.BannerInfo)
|
|
require.True(t, *updatedChannel.BannerInfo.Enabled)
|
|
require.Equal(t, "banner text", *updatedChannel.BannerInfo.Text)
|
|
require.Equal(t, "#000000", *updatedChannel.BannerInfo.BackgroundColor)
|
|
|
|
channel.BannerInfo.Enabled = model.NewPointer(false)
|
|
updatedChannel, appErr = th.App.UpdateChannel(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, updatedChannel.BannerInfo)
|
|
require.False(t, *updatedChannel.BannerInfo.Enabled)
|
|
})
|
|
}
|
|
|
|
func TestPatchChannel(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should be able to patch banner info", func(t *testing.T) {
|
|
channel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
|
|
patch := &model.ChannelPatch{
|
|
BannerInfo: &model.ChannelBannerInfo{
|
|
Enabled: model.NewPointer(true),
|
|
Text: model.NewPointer("banner text"),
|
|
BackgroundColor: model.NewPointer("#000000"),
|
|
},
|
|
}
|
|
|
|
patchedChannel, appErr := th.App.PatchChannel(th.Context, channel, patch, channel.CreatorId)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, patchedChannel.BannerInfo)
|
|
require.True(t, *patchedChannel.BannerInfo.Enabled)
|
|
require.Equal(t, "banner text", *patchedChannel.BannerInfo.Text)
|
|
require.Equal(t, "#000000", *patchedChannel.BannerInfo.BackgroundColor)
|
|
|
|
patch = &model.ChannelPatch{
|
|
BannerInfo: &model.ChannelBannerInfo{
|
|
Text: model.NewPointer("text 1"),
|
|
},
|
|
}
|
|
|
|
patchedChannel, appErr = th.App.PatchChannel(th.Context, channel, patch, channel.CreatorId)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, patchedChannel.BannerInfo)
|
|
require.True(t, *patchedChannel.BannerInfo.Enabled)
|
|
require.Equal(t, "text 1", *patchedChannel.BannerInfo.Text)
|
|
require.Equal(t, "#000000", *patchedChannel.BannerInfo.BackgroundColor)
|
|
|
|
patch = &model.ChannelPatch{
|
|
BannerInfo: &model.ChannelBannerInfo{
|
|
BackgroundColor: model.NewPointer("#FF00FF"),
|
|
},
|
|
}
|
|
|
|
patchedChannel, appErr = th.App.PatchChannel(th.Context, channel, patch, channel.CreatorId)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, patchedChannel.BannerInfo)
|
|
require.True(t, *patchedChannel.BannerInfo.Enabled)
|
|
require.Equal(t, "text 1", *patchedChannel.BannerInfo.Text)
|
|
require.Equal(t, "#FF00FF", *patchedChannel.BannerInfo.BackgroundColor)
|
|
|
|
// should be able to unset fields as well
|
|
patch = &model.ChannelPatch{
|
|
BannerInfo: &model.ChannelBannerInfo{
|
|
Enabled: model.NewPointer(false),
|
|
},
|
|
}
|
|
|
|
patchedChannel, appErr = th.App.PatchChannel(th.Context, channel, patch, channel.CreatorId)
|
|
require.Nil(t, appErr)
|
|
require.NotNil(t, patchedChannel.BannerInfo)
|
|
require.False(t, *patchedChannel.BannerInfo.Enabled)
|
|
})
|
|
|
|
t.Run("should not allow saving channel with invalid background info", func(t *testing.T) {
|
|
channel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
|
|
// enabling banner without data is invalid
|
|
patch := &model.ChannelPatch{
|
|
BannerInfo: &model.ChannelBannerInfo{
|
|
Enabled: model.NewPointer(true),
|
|
},
|
|
}
|
|
|
|
patchedChannel, appErr := th.App.PatchChannel(th.Context, channel, patch, channel.CreatorId)
|
|
require.Nil(t, patchedChannel)
|
|
require.NotNil(t, appErr)
|
|
require.Equal(t, http.StatusBadRequest, appErr.StatusCode)
|
|
require.Equal(t, "model.channel.is_valid.banner_info.text.empty.app_error", appErr.Id)
|
|
})
|
|
|
|
t.Run("cannot configure channel banner on DMs", func(t *testing.T) {
|
|
dmChannel := th.CreateDmChannel(th.BasicUser2)
|
|
|
|
// enabling banner without data is invalid
|
|
patch := &model.ChannelPatch{
|
|
BannerInfo: &model.ChannelBannerInfo{
|
|
Enabled: model.NewPointer(true),
|
|
},
|
|
}
|
|
|
|
patchedChannel, appErr := th.App.PatchChannel(th.Context, dmChannel, patch, dmChannel.CreatorId)
|
|
require.Nil(t, patchedChannel)
|
|
require.NotNil(t, appErr)
|
|
require.Equal(t, appErr.StatusCode, http.StatusBadRequest)
|
|
require.Equal(t, "model.channel.is_valid.banner_info.channel_type.app_error", appErr.Id)
|
|
})
|
|
|
|
t.Run("cannot configure channel banner on GMs", func(t *testing.T) {
|
|
user3 := th.CreateUser()
|
|
gmChannel := th.CreateGroupChannel(th.Context, th.BasicUser2, user3)
|
|
|
|
// enabling banner without data is invalid
|
|
patch := &model.ChannelPatch{
|
|
BannerInfo: &model.ChannelBannerInfo{
|
|
Enabled: model.NewPointer(true),
|
|
},
|
|
}
|
|
|
|
patchedChannel, appErr := th.App.PatchChannel(th.Context, gmChannel, patch, gmChannel.CreatorId)
|
|
require.Nil(t, patchedChannel)
|
|
require.NotNil(t, appErr)
|
|
require.Equal(t, appErr.StatusCode, http.StatusBadRequest)
|
|
require.Equal(t, "model.channel.is_valid.banner_info.channel_type.app_error", appErr.Id)
|
|
})
|
|
|
|
t.Run("cannot patch restricted DM", func(t *testing.T) {
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.TeamSettings.RestrictDirectMessage = model.DirectMessageTeam
|
|
})
|
|
|
|
// Create a DM channel between two users who don't share a team
|
|
dmChannel := th.CreateDmChannel(th.BasicUser2)
|
|
|
|
// Ensure the two users do not share a team
|
|
teams, err := th.App.GetTeamsForUser(th.BasicUser.Id)
|
|
require.Nil(t, err)
|
|
for _, team := range teams {
|
|
teamErr := th.App.RemoveUserFromTeam(th.Context, team.Id, th.BasicUser.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, teamErr)
|
|
}
|
|
teams, err = th.App.GetTeamsForUser(th.BasicUser2.Id)
|
|
require.Nil(t, err)
|
|
for _, team := range teams {
|
|
teamErr := th.App.RemoveUserFromTeam(th.Context, team.Id, th.BasicUser2.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, teamErr)
|
|
}
|
|
|
|
// Create separate teams for each user
|
|
team1 := th.CreateTeam()
|
|
team2 := th.CreateTeam()
|
|
th.LinkUserToTeam(th.BasicUser, team1)
|
|
th.LinkUserToTeam(th.BasicUser2, team2)
|
|
|
|
patch := &model.ChannelPatch{
|
|
DisplayName: model.NewPointer("Updated DM"),
|
|
}
|
|
|
|
_, appErr := th.App.PatchChannel(th.Context, dmChannel, patch, th.BasicUser.Id)
|
|
require.NotNil(t, appErr)
|
|
require.Equal(t, "api.channel.patch_update_channel.restricted_dm.app_error", appErr.Id)
|
|
require.Equal(t, http.StatusBadRequest, appErr.StatusCode)
|
|
|
|
// Reset config
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.TeamSettings.RestrictDirectMessage = model.DirectMessageAny
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestCreateChannelWithCategorySorting(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// Enable ExperimentalChannelCategorySorting
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.ExperimentalSettings.ExperimentalChannelCategorySorting = true
|
|
})
|
|
|
|
t.Run("should set category when adding user to channel with category and trim white spaces", func(t *testing.T) {
|
|
channel := &model.Channel{
|
|
DisplayName: " Category / Channel Name ",
|
|
Name: "name1",
|
|
Type: model.ChannelTypeOpen,
|
|
TeamId: th.BasicTeam.Id,
|
|
}
|
|
|
|
channel, appErr := th.App.CreateChannelWithUser(th.Context, channel, th.BasicUser.Id)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, "Channel Name", channel.DisplayName)
|
|
require.Equal(t, "Category", channel.DefaultCategoryName)
|
|
|
|
// Verify channel is in default category
|
|
categories, appErr := th.App.GetSidebarCategoriesForTeamForUser(th.Context, th.BasicUser.Id, th.BasicTeam.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
foundCategory := false
|
|
for _, category := range categories.Categories {
|
|
if category.DisplayName == "Category" {
|
|
foundCategory = true
|
|
assert.Contains(t, category.Channels, channel.Id)
|
|
break
|
|
}
|
|
}
|
|
assert.True(t, foundCategory, "Category 'Category' not found in sidebar categories")
|
|
|
|
// Add user to channel
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser2, channel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
// Verify channel is in default category
|
|
categories2, appErr := th.App.GetSidebarCategoriesForTeamForUser(th.Context, th.BasicUser2.Id, th.BasicTeam.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
foundCategory2 := false
|
|
for _, category := range categories2.Categories {
|
|
if category.DisplayName == "Category" {
|
|
foundCategory2 = true
|
|
assert.Contains(t, category.Channels, channel.Id)
|
|
break
|
|
}
|
|
}
|
|
assert.True(t, foundCategory2, "Category 'Category' not found in sidebar categories")
|
|
})
|
|
|
|
t.Run("should not set category when feature is disabled", func(t *testing.T) {
|
|
channel := &model.Channel{
|
|
DisplayName: "Category2/Channel Name",
|
|
Name: "name2",
|
|
Type: model.ChannelTypeOpen,
|
|
TeamId: th.BasicTeam.Id,
|
|
}
|
|
|
|
channel, appErr := th.App.CreateChannel(th.Context, channel, false)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, "Channel Name", channel.DisplayName)
|
|
require.Equal(t, "Category2", channel.DefaultCategoryName)
|
|
|
|
// Disable ExperimentalChannelCategorySorting
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.ExperimentalSettings.ExperimentalChannelCategorySorting = false
|
|
})
|
|
|
|
// Add user to channel
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser, channel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
// Verify channel is in default category
|
|
categories, appErr := th.App.GetSidebarCategoriesForTeamForUser(th.Context, th.BasicUser.Id, th.BasicTeam.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
foundCategory := false
|
|
for _, category := range categories.Categories {
|
|
if category.DisplayName == "Category2" {
|
|
foundCategory = true
|
|
break
|
|
}
|
|
}
|
|
assert.False(t, foundCategory, "Category 'Category2' not found in sidebar categories")
|
|
})
|
|
}
|
|
|
|
func TestPatchChannelWithCategorySorting(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// Enable ExperimentalChannelCategorySorting
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.ExperimentalSettings.ExperimentalChannelCategorySorting = true
|
|
})
|
|
|
|
// Create initial channel
|
|
channel := th.createChannel(th.Context, th.BasicTeam, model.ChannelTypeOpen)
|
|
channel.DisplayName = "Initial Name"
|
|
channel, appErr := th.App.UpdateChannel(th.Context, channel)
|
|
require.Nil(t, appErr)
|
|
|
|
// Add user to channel
|
|
_, appErr = th.App.AddUserToChannel(th.Context, th.BasicUser, channel, false)
|
|
require.Nil(t, appErr)
|
|
|
|
// Patch channel with new display name containing category
|
|
patch := &model.ChannelPatch{
|
|
DisplayName: model.NewPointer(" New Category / New Channel Name "),
|
|
}
|
|
|
|
patchedChannel, appErr := th.App.PatchChannel(th.Context, channel, patch, channel.CreatorId)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, "New Channel Name", patchedChannel.DisplayName)
|
|
require.Equal(t, "New Category", patchedChannel.DefaultCategoryName)
|
|
|
|
// Test that category is not updated when feature is disabled
|
|
th.App.UpdateConfig(func(cfg *model.Config) {
|
|
*cfg.ExperimentalSettings.ExperimentalChannelCategorySorting = false
|
|
})
|
|
|
|
patch = &model.ChannelPatch{
|
|
DisplayName: model.NewPointer("Disabled Category/Channel Name"),
|
|
}
|
|
|
|
patchedChannel, appErr = th.App.PatchChannel(th.Context, channel, patch, channel.CreatorId)
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, "Disabled Category/Channel Name", patchedChannel.DisplayName)
|
|
require.Equal(t, "New Category", patchedChannel.DefaultCategoryName)
|
|
}
|