mirror of
https://github.com/hanzoai/team.git
synced 2026-09-30 01:57:35 +00:00
8dba67e1b8
* move category permissions to api In https://github.com/mattermost/mattermost/pull/21038, we changed the behaviour of the channel category store to filter out deleted teams and teams for which the user was not a member. This was necessary in part due to querying multiple teams via GraphQL. With GraphQL no longer supported, let's move the permissions to the API instead and remove the `JOIN` to filter out teams in the store. Note that we /don't/ prevent access to deleted teams. For better or worse, deleted teams remain largely accessible via other API endpoints anyway. * remove ExcludeTeam / GraphQL support As part of https://github.com/mattermost/mattermost/pull/20353, we added `ExcludeTeam` and the associated logic to support a GraphQL API. With GraphQL no longer supported, let's simplify this logic and remove the filtering and associated complexity. * Fix shadow variable declaration in channel_store_categories.go Fixed golangci-lint error by reusing existing err variable rather than shadowing it. * fix build issue * Remove SidebarCategorySearchOpts and simplify API to use teamID string Per code review feedback, this change removes the SidebarCategorySearchOpts struct entirely since the Type field was never used in the store implementation. All methods now accept a simple teamID string parameter instead of the struct, which simplifies the API and makes the code clearer. Changes: - Remove SidebarCategorySearchOpts struct from store.go - Update CreateInitialSidebarCategories and GetSidebarCategories signatures - Update all implementations (sqlstore, retrylayer, timerlayer, mocks) - Update all callers to pass teamID string directly - Clean up unused imports --------- Co-authored-by: Hanzo Dev <[email protected]>
1630 lines
62 KiB
Go
1630 lines
62 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package api4
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/mattermost/mattermost/server/public/model"
|
|
)
|
|
|
|
func TestCreateCategoryForTeamForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should silently prevent the user from creating a category with an invalid channel ID", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
// Attempt to create the category
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
DisplayName: "test",
|
|
},
|
|
Channels: []string{th.BasicChannel.Id, "notachannel", th.BasicChannel2.Id},
|
|
}
|
|
|
|
received, _, err := client.CreateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, category)
|
|
require.NoError(t, err)
|
|
assert.NotContains(t, received.Channels, "notachannel")
|
|
assert.Equal(t, []string{th.BasicChannel.Id, th.BasicChannel2.Id}, received.Channels)
|
|
})
|
|
|
|
t.Run("should silently prevent the user from creating a category with a channel that they're not a member of", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
// Have another user create a channel that user isn't a part of
|
|
channel, _, err := th.SystemAdminClient.CreateChannel(context.Background(), &model.Channel{
|
|
TeamId: th.BasicTeam.Id,
|
|
Type: model.ChannelTypeOpen,
|
|
Name: "testchannel",
|
|
DisplayName: "testchannel",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to create the category
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
DisplayName: "test",
|
|
},
|
|
Channels: []string{th.BasicChannel.Id, channel.Id},
|
|
}
|
|
|
|
received, _, err := client.CreateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, category)
|
|
require.NoError(t, err)
|
|
assert.NotContains(t, received.Channels, channel.Id)
|
|
assert.Equal(t, []string{th.BasicChannel.Id}, received.Channels)
|
|
})
|
|
|
|
t.Run("should return expected sort order value", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
customCategory, _, err := client.CreateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
DisplayName: "custom123",
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Initial new category sort order is 10 (first)
|
|
require.Equal(t, int64(10), customCategory.SortOrder)
|
|
})
|
|
|
|
t.Run("should not crash with null input", func(t *testing.T) {
|
|
require.NotPanics(t, func() {
|
|
user, client := setupUserForSubtest(t, th)
|
|
payload := []byte(`null`)
|
|
route := fmt.Sprintf("/users/%s/teams/%s/channels/categories", user.Id, th.BasicTeam.Id)
|
|
r, err := client.DoAPIPostBytes(context.Background(), route, payload)
|
|
require.Error(t, err)
|
|
closeBody(r)
|
|
})
|
|
})
|
|
|
|
t.Run("should return error when user tries to create a category for a team they're not a member of", func(t *testing.T) {
|
|
// Create a user
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
// Create a team and add the user to it
|
|
team, appErr := th.App.CreateTeam(th.Context, &model.Team{
|
|
DisplayName: "Team for testing",
|
|
Name: "test-team-" + model.NewId(),
|
|
Email: th.GenerateTestEmail(),
|
|
Type: model.TeamOpen,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
th.LinkUserToTeam(user, team)
|
|
|
|
// Create a client and log in
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Now remove the user from the team
|
|
appErr = th.App.RemoveUserFromTeam(th.Context, team.Id, user.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// Attempt to create a category for the team the user is no longer a member of
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: team.Id,
|
|
DisplayName: "test category",
|
|
},
|
|
}
|
|
|
|
_, resp, err := client.CreateSidebarCategoryForTeamForUser(context.Background(), user.Id, team.Id, category)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should publish expected WS payload", func(t *testing.T) {
|
|
userWSClient := th.CreateConnectedWebSocketClient(t)
|
|
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: th.BasicUser.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
DisplayName: "test",
|
|
},
|
|
Channels: []string{th.BasicChannel.Id, "notachannel", th.BasicChannel2.Id},
|
|
}
|
|
|
|
received, _, err := th.Client.CreateSidebarCategoryForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, category)
|
|
require.NoError(t, err)
|
|
|
|
testCategories := []*model.SidebarCategoryWithChannels{
|
|
{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Id: received.Id,
|
|
UserId: th.BasicUser.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
Sorting: model.SidebarCategorySortRecent,
|
|
Muted: true,
|
|
},
|
|
Channels: []string{th.BasicChannel.Id},
|
|
},
|
|
}
|
|
|
|
testCategories, _, err = th.Client.UpdateSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, testCategories)
|
|
require.NoError(t, err)
|
|
|
|
b, err := json.Marshal(testCategories)
|
|
require.NoError(t, err)
|
|
expected := string(b)
|
|
|
|
var caught bool
|
|
func() {
|
|
for {
|
|
select {
|
|
case ev := <-userWSClient.EventChannel:
|
|
if ev.EventType() == model.WebsocketEventSidebarCategoryUpdated {
|
|
caught = true
|
|
data := ev.GetData()
|
|
|
|
updatedCategoriesData, ok := data["updatedCategories"]
|
|
require.True(t, ok)
|
|
require.EqualValues(t, expected, updatedCategoriesData)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
require.Truef(t, caught, "User should have received %s event", model.WebsocketEventSidebarCategoryUpdated)
|
|
})
|
|
}
|
|
|
|
func TestUpdateCategoryForTeamForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should update the channel order of the Channels category", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory := categories.Categories[1]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
require.Len(t, channelsCategory.Channels, 5) // Town Square, Off Topic, and the 3 channels created by InitBasic
|
|
|
|
// Should return the correct values from the API
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: channelsCategory.SidebarCategory,
|
|
Channels: []string{channelsCategory.Channels[1], channelsCategory.Channels[0], channelsCategory.Channels[4], channelsCategory.Channels[3], channelsCategory.Channels[2]},
|
|
}
|
|
|
|
received, _, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, channelsCategory.Id, updatedCategory)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, channelsCategory.Id, received.Id)
|
|
assert.Equal(t, updatedCategory.Channels, received.Channels)
|
|
|
|
// And when requesting the category later
|
|
received, _, err = client.GetSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, channelsCategory.Id, "")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, channelsCategory.Id, received.Id)
|
|
assert.Equal(t, updatedCategory.Channels, received.Channels)
|
|
})
|
|
|
|
t.Run("should update the sort order of the DM category", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
dmsCategory := categories.Categories[2]
|
|
require.Equal(t, model.SidebarCategoryDirectMessages, dmsCategory.Type)
|
|
require.Equal(t, model.SidebarCategorySortRecent, dmsCategory.Sorting)
|
|
|
|
// Should return the correct values from the API
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: dmsCategory.SidebarCategory,
|
|
Channels: dmsCategory.Channels,
|
|
}
|
|
updatedCategory.Sorting = model.SidebarCategorySortAlphabetical
|
|
|
|
received, _, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, dmsCategory.Id, updatedCategory)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, dmsCategory.Id, received.Id)
|
|
assert.Equal(t, model.SidebarCategorySortAlphabetical, received.Sorting)
|
|
|
|
// And when requesting the category later
|
|
received, _, err = client.GetSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, dmsCategory.Id, "")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, dmsCategory.Id, received.Id)
|
|
assert.Equal(t, model.SidebarCategorySortAlphabetical, received.Sorting)
|
|
})
|
|
|
|
t.Run("should update the display name of a custom category", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
customCategory, _, err := client.CreateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
DisplayName: "custom123",
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "custom123", customCategory.DisplayName)
|
|
|
|
// Should return the correct values from the API
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: customCategory.SidebarCategory,
|
|
Channels: customCategory.Channels,
|
|
}
|
|
updatedCategory.DisplayName = "abcCustom"
|
|
|
|
received, _, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, customCategory.Id, updatedCategory)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, customCategory.Id, received.Id)
|
|
assert.Equal(t, updatedCategory.DisplayName, received.DisplayName)
|
|
|
|
// And when requesting the category later
|
|
received, _, err = client.GetSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, customCategory.Id, "")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, customCategory.Id, received.Id)
|
|
assert.Equal(t, updatedCategory.DisplayName, received.DisplayName)
|
|
})
|
|
|
|
t.Run("should update the channel order of the category even if it contains archived channels", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory := categories.Categories[1]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
require.Len(t, channelsCategory.Channels, 5) // Town Square, Off Topic, and the 3 channels created by InitBasic
|
|
|
|
// Delete one of the channels
|
|
_, err = client.DeleteChannel(context.Background(), th.BasicChannel.Id)
|
|
require.NoError(t, err)
|
|
|
|
// Should still be able to reorder the channels
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: channelsCategory.SidebarCategory,
|
|
Channels: []string{channelsCategory.Channels[1], channelsCategory.Channels[0], channelsCategory.Channels[4], channelsCategory.Channels[3], channelsCategory.Channels[2]},
|
|
}
|
|
|
|
received, _, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, channelsCategory.Id, updatedCategory)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, channelsCategory.Id, received.Id)
|
|
assert.Equal(t, updatedCategory.Channels, received.Channels)
|
|
})
|
|
|
|
t.Run("should silently prevent the user from adding an invalid channel ID", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory := categories.Categories[1]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: channelsCategory.SidebarCategory,
|
|
Channels: append(channelsCategory.Channels, "notachannel"),
|
|
}
|
|
|
|
received, _, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, channelsCategory.Id, updatedCategory)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, channelsCategory.Id, received.Id)
|
|
assert.NotContains(t, received.Channels, "notachannel")
|
|
assert.Equal(t, channelsCategory.Channels, received.Channels)
|
|
})
|
|
|
|
t.Run("should silently prevent the user from adding a channel that they're not a member of", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory := categories.Categories[1]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
|
|
// Have another user create a channel that user isn't a part of
|
|
channel, _, err := th.SystemAdminClient.CreateChannel(context.Background(), &model.Channel{
|
|
TeamId: th.BasicTeam.Id,
|
|
Type: model.ChannelTypeOpen,
|
|
Name: "testchannel",
|
|
DisplayName: "testchannel",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to update the category
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: channelsCategory.SidebarCategory,
|
|
Channels: append(channelsCategory.Channels, channel.Id),
|
|
}
|
|
|
|
received, _, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, channelsCategory.Id, updatedCategory)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, channelsCategory.Id, received.Id)
|
|
assert.NotContains(t, received.Channels, channel.Id)
|
|
assert.Equal(t, channelsCategory.Channels, received.Channels)
|
|
})
|
|
|
|
t.Run("muting a category should mute all of its channels", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory := categories.Categories[1]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
require.True(t, len(channelsCategory.Channels) > 0)
|
|
|
|
// Mute the category
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Id: channelsCategory.Id,
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
Sorting: channelsCategory.Sorting,
|
|
Muted: true,
|
|
},
|
|
Channels: channelsCategory.Channels,
|
|
}
|
|
|
|
received, _, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, channelsCategory.Id, updatedCategory)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, channelsCategory.Id, received.Id)
|
|
assert.True(t, received.Muted)
|
|
|
|
// Check that the muted category was saved in the database
|
|
received, _, err = client.GetSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, channelsCategory.Id, "")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, channelsCategory.Id, received.Id)
|
|
assert.True(t, received.Muted)
|
|
|
|
// Confirm that the channels in the category were muted
|
|
member, _, err := client.GetChannelMember(context.Background(), channelsCategory.Channels[0], user.Id, "")
|
|
require.NoError(t, err)
|
|
assert.True(t, member.IsChannelMuted())
|
|
})
|
|
|
|
t.Run("should not be able to mute DM category", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
dmsCategory := categories.Categories[2]
|
|
require.Equal(t, model.SidebarCategoryDirectMessages, dmsCategory.Type)
|
|
require.Len(t, dmsCategory.Channels, 0)
|
|
|
|
// Ensure a DM channel exists
|
|
dmChannel, _, err := client.CreateDirectChannel(context.Background(), user.Id, th.BasicUser.Id)
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to mute the category
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Id: dmsCategory.Id,
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
Sorting: dmsCategory.Sorting,
|
|
Muted: true,
|
|
},
|
|
Channels: []string{dmChannel.Id},
|
|
}
|
|
|
|
received, _, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, dmsCategory.Id, updatedCategory)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, dmsCategory.Id, received.Id)
|
|
assert.False(t, received.Muted)
|
|
|
|
// Check that the muted category was not saved in the database
|
|
received, _, err = client.GetSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, dmsCategory.Id, "")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, dmsCategory.Id, received.Id)
|
|
assert.False(t, received.Muted)
|
|
|
|
// Confirm that the channels in the category were not muted
|
|
member, _, err := client.GetChannelMember(context.Background(), dmChannel.Id, user.Id, "")
|
|
require.NoError(t, err)
|
|
assert.False(t, member.IsChannelMuted())
|
|
})
|
|
|
|
t.Run("should not crash with null input", func(t *testing.T) {
|
|
require.NotPanics(t, func() {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
dmsCategory := categories.Categories[2]
|
|
|
|
payload := []byte(`null`)
|
|
route := fmt.Sprintf("/users/%s/teams/%s/channels/categories/%s", user.Id, th.BasicTeam.Id, dmsCategory.Id)
|
|
r, err := client.DoAPIPutBytes(context.Background(), route, payload)
|
|
require.Error(t, err)
|
|
closeBody(r)
|
|
})
|
|
})
|
|
|
|
t.Run("should return error when user tries to update a category for a team they're not a member of", func(t *testing.T) {
|
|
// Create a user
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
// Create a team and add the user to it
|
|
team, appErr := th.App.CreateTeam(th.Context, &model.Team{
|
|
DisplayName: "Team for testing",
|
|
Name: "test-team-" + model.NewId(),
|
|
Email: th.GenerateTestEmail(),
|
|
Type: model.TeamOpen,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
th.LinkUserToTeam(user, team)
|
|
|
|
// Create a client and log in
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Get categories to have valid category IDs
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, team.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
// Store a category to use after team membership is revoked
|
|
categoryToUpdate := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Id: categories.Categories[0].Id,
|
|
UserId: user.Id,
|
|
TeamId: team.Id,
|
|
DisplayName: "Updated Category",
|
|
Type: categories.Categories[0].Type,
|
|
},
|
|
Channels: categories.Categories[0].Channels,
|
|
}
|
|
|
|
// Remove the user from the team
|
|
appErr = th.App.RemoveUserFromTeam(th.Context, team.Id, user.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// Attempt to update a category for the team after being removed
|
|
_, resp, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, team.Id, categoryToUpdate.Id, categoryToUpdate)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
}
|
|
|
|
func TestUpdateCategoriesForTeamForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should silently prevent the user from adding an invalid channel ID", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory := categories.Categories[1]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: channelsCategory.SidebarCategory,
|
|
Channels: append(channelsCategory.Channels, "notachannel"),
|
|
}
|
|
|
|
received, _, err := client.UpdateSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{updatedCategory})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, channelsCategory.Id, received[0].Id)
|
|
assert.NotContains(t, received[0].Channels, "notachannel")
|
|
assert.Equal(t, channelsCategory.Channels, received[0].Channels)
|
|
})
|
|
|
|
t.Run("should silently prevent the user from adding a channel that they're not a member of", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory := categories.Categories[1]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
|
|
// Have another user create a channel that user isn't a part of
|
|
channel, _, err := th.SystemAdminClient.CreateChannel(context.Background(), &model.Channel{
|
|
TeamId: th.BasicTeam.Id,
|
|
Type: model.ChannelTypeOpen,
|
|
Name: "testchannel",
|
|
DisplayName: "testchannel",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to update the category
|
|
updatedCategory := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: channelsCategory.SidebarCategory,
|
|
Channels: append(channelsCategory.Channels, channel.Id),
|
|
}
|
|
|
|
received, _, err := client.UpdateSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{updatedCategory})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, channelsCategory.Id, received[0].Id)
|
|
assert.NotContains(t, received[0].Channels, channel.Id)
|
|
assert.Equal(t, channelsCategory.Channels, received[0].Channels)
|
|
})
|
|
|
|
t.Run("should update order", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory := categories.Categories[1]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
|
|
_, _, err = client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, []string{categories.Order[1], categories.Order[0], categories.Order[2]})
|
|
require.NoError(t, err)
|
|
|
|
categories, _, err = client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory = categories.Categories[0]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
|
|
// validate order
|
|
newOrder, _, err := client.GetSidebarCategoryOrderForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, newOrder, categories.Order)
|
|
|
|
// try to update with missing category
|
|
_, _, err = client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, []string{categories.Order[1], categories.Order[0]})
|
|
require.Error(t, err)
|
|
|
|
// try to update with invalid category
|
|
_, _, err = client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, []string{categories.Order[1], categories.Order[0], "asd"})
|
|
require.Error(t, err)
|
|
})
|
|
|
|
t.Run("should return error when user tries to update categories for a team they're not a member of", func(t *testing.T) {
|
|
// Create a user
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
// Create a team and add the user to it
|
|
team, appErr := th.App.CreateTeam(th.Context, &model.Team{
|
|
DisplayName: "Team for testing",
|
|
Name: "test-team-" + model.NewId(),
|
|
Email: th.GenerateTestEmail(),
|
|
Type: model.TeamOpen,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
th.LinkUserToTeam(user, team)
|
|
|
|
// Create a client and log in
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Get categories to have valid category IDs
|
|
existingCategories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, team.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, existingCategories.Categories)
|
|
|
|
// Prepare categories to update after team membership is revoked
|
|
categoriesToUpdate := []*model.SidebarCategoryWithChannels{
|
|
{
|
|
SidebarCategory: model.SidebarCategory{
|
|
Id: existingCategories.Categories[0].Id,
|
|
UserId: user.Id,
|
|
TeamId: team.Id,
|
|
DisplayName: "Updated Category",
|
|
Type: existingCategories.Categories[0].Type,
|
|
},
|
|
Channels: existingCategories.Categories[0].Channels,
|
|
},
|
|
}
|
|
|
|
// Remove the user from the team
|
|
appErr = th.App.RemoveUserFromTeam(th.Context, team.Id, user.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// Attempt to update categories for the team after being removed
|
|
_, resp, err := client.UpdateSidebarCategoriesForTeamForUser(context.Background(), user.Id, team.Id, categoriesToUpdate)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
}
|
|
|
|
func TestGetCategoriesForTeamForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should return categories when user has permission", func(t *testing.T) {
|
|
// Get categories for the basic user
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, categories)
|
|
require.Len(t, categories.Categories, 3) // Default categories: Channels, Favorites, Direct Messages
|
|
require.Len(t, categories.Order, 3)
|
|
})
|
|
|
|
t.Run("should return error when user doesn't have permission", func(t *testing.T) {
|
|
// Create a new user that's not on the team
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to get categories for the basic user
|
|
_, resp, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error for a team the user is not a member of", func(t *testing.T) {
|
|
// Create a new user and team
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
team, appErr := th.App.CreateTeam(th.Context, &model.Team{
|
|
DisplayName: "Team for testing",
|
|
Name: "test-team-" + model.NewId(),
|
|
Email: th.GenerateTestEmail(),
|
|
Type: model.TeamOpen,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
// Log in as the new user
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to get categories for a team the user is not a member of
|
|
_, resp, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, team.Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid user id", func(t *testing.T) {
|
|
_, resp, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), "invalid_user_id", th.BasicTeam.Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid team id", func(t *testing.T) {
|
|
_, resp, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, "invalid_team_id", "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error when user is not logged in", func(t *testing.T) {
|
|
client := th.CreateClient()
|
|
_, resp, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
|
})
|
|
}
|
|
|
|
func TestGetCategoryOrderForTeamForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should return category order when user has permission", func(t *testing.T) {
|
|
// Get categories first to ensure order exists
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, categories)
|
|
require.Len(t, categories.Order, 3) // Default categories: Channels, Favorites, Direct Messages
|
|
|
|
// Get order
|
|
order, _, err := th.Client.GetSidebarCategoryOrderForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, order)
|
|
require.Len(t, order, 3)
|
|
require.ElementsMatch(t, categories.Order, order)
|
|
})
|
|
|
|
t.Run("should return error when user doesn't have permission", func(t *testing.T) {
|
|
// Create a new user that's not on the team
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to get order for the basic user
|
|
_, resp, err := client.GetSidebarCategoryOrderForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid user id", func(t *testing.T) {
|
|
_, resp, err := th.Client.GetSidebarCategoryOrderForTeamForUser(context.Background(), "invalid_user_id", th.BasicTeam.Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid team id", func(t *testing.T) {
|
|
_, resp, err := th.Client.GetSidebarCategoryOrderForTeamForUser(context.Background(), th.BasicUser.Id, "invalid_team_id", "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error when user is not logged in", func(t *testing.T) {
|
|
client := th.CreateClient()
|
|
_, resp, err := client.GetSidebarCategoryOrderForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error when user tries to get category order for a team they're not a member of", func(t *testing.T) {
|
|
// Create a user
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
// Create a team and add the user to it
|
|
team, appErr := th.App.CreateTeam(th.Context, &model.Team{
|
|
DisplayName: "Team for testing",
|
|
Name: "test-team-" + model.NewId(),
|
|
Email: th.GenerateTestEmail(),
|
|
Type: model.TeamOpen,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
th.LinkUserToTeam(user, team)
|
|
|
|
// Create a client and log in
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Verify the user can access categories initially
|
|
_, _, err = client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, team.Id, "")
|
|
require.NoError(t, err)
|
|
|
|
// Remove the user from the team
|
|
appErr = th.App.RemoveUserFromTeam(th.Context, team.Id, user.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// Attempt to get the category order for the team after being removed
|
|
_, resp, err := client.GetSidebarCategoryOrderForTeamForUser(context.Background(), user.Id, team.Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
}
|
|
|
|
func TestUpdateCategoryOrderForTeamForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should update order", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
|
|
channelsCategory := categories.Categories[1]
|
|
require.Equal(t, model.SidebarCategoryChannels, channelsCategory.Type)
|
|
|
|
// Update order
|
|
newOrder := []string{categories.Order[1], categories.Order[0], categories.Order[2]}
|
|
updatedOrder, _, err := client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, newOrder)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, newOrder, updatedOrder)
|
|
|
|
// Verify order was updated
|
|
categories, _, err = client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.Len(t, categories.Categories, 3)
|
|
require.Len(t, categories.Order, 3)
|
|
require.EqualValues(t, newOrder, categories.Order)
|
|
})
|
|
|
|
t.Run("should return error when user doesn't have permission", func(t *testing.T) {
|
|
// Create a new user that's not on the team
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Get categories for basic user to try to update
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to update order for the basic user
|
|
newOrder := []string{categories.Order[1], categories.Order[0], categories.Order[2]}
|
|
_, resp, err := client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, newOrder)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid category id", func(t *testing.T) {
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
|
|
// Try to update with an invalid category ID
|
|
newOrder := []string{categories.Order[0], "invalid_category_id", categories.Order[2]}
|
|
_, resp, err := th.Client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, newOrder)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusBadRequest, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with missing category", func(t *testing.T) {
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
|
|
// Try to update with a missing category
|
|
newOrder := []string{categories.Order[1], categories.Order[0]} // Missing one category
|
|
_, resp, err := th.Client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, newOrder)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusInternalServerError, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid user id", func(t *testing.T) {
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
|
|
newOrder := []string{categories.Order[1], categories.Order[0], categories.Order[2]}
|
|
_, resp, err := th.Client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), "invalid_user_id", th.BasicTeam.Id, newOrder)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid team id", func(t *testing.T) {
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
|
|
newOrder := []string{categories.Order[1], categories.Order[0], categories.Order[2]}
|
|
_, resp, err := th.Client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), th.BasicUser.Id, "invalid_team_id", newOrder)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error when user is not logged in", func(t *testing.T) {
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
|
|
client := th.CreateClient()
|
|
newOrder := []string{categories.Order[1], categories.Order[0], categories.Order[2]}
|
|
_, resp, err := client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, newOrder)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should not crash with null input", func(t *testing.T) {
|
|
require.NotPanics(t, func() {
|
|
user, client := setupUserForSubtest(t, th)
|
|
payload := []byte(`null`)
|
|
route := fmt.Sprintf("/users/%s/teams/%s/channels/categories/order", user.Id, th.BasicTeam.Id)
|
|
r, err := client.DoAPIPutBytes(context.Background(), route, payload)
|
|
require.Error(t, err)
|
|
closeBody(r)
|
|
})
|
|
})
|
|
|
|
t.Run("should return error when user tries to update category order for a team they're not a member of", func(t *testing.T) {
|
|
// Create a user
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
// Create a team and add the user to it
|
|
team, appErr := th.App.CreateTeam(th.Context, &model.Team{
|
|
DisplayName: "Team for testing",
|
|
Name: "test-team-" + model.NewId(),
|
|
Email: th.GenerateTestEmail(),
|
|
Type: model.TeamOpen,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
th.LinkUserToTeam(user, team)
|
|
|
|
// Create a client and log in
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Get categories to have a valid order
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, team.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Order)
|
|
|
|
// Remove the user from the team
|
|
appErr = th.App.RemoveUserFromTeam(th.Context, team.Id, user.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// Attempt to update the category order for the team after being removed
|
|
_, resp, err := client.UpdateSidebarCategoryOrderForTeamForUser(context.Background(), user.Id, team.Id, categories.Order)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
}
|
|
|
|
func TestGetCategoryForTeamForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
t.Run("should return category when user has permission", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
// Get categories first to get a valid category ID
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
// Get specific category
|
|
category := categories.Categories[0]
|
|
received, _, err := client.GetSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, category.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, received)
|
|
require.Equal(t, category.Id, received.Id)
|
|
require.Equal(t, category.DisplayName, received.DisplayName)
|
|
require.Equal(t, category.Type, received.Type)
|
|
})
|
|
|
|
t.Run("should return error when user doesn't have permission", func(t *testing.T) {
|
|
// Create a new user that's not on the team
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Get categories for basic user to get a valid category ID
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
// Attempt to get category for the basic user
|
|
_, resp, err := client.GetSidebarCategoryForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, categories.Categories[0].Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid user id", func(t *testing.T) {
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
_, resp, err := th.Client.GetSidebarCategoryForTeamForUser(context.Background(), "invalid_user_id", th.BasicTeam.Id, categories.Categories[0].Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid team id", func(t *testing.T) {
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
_, resp, err := th.Client.GetSidebarCategoryForTeamForUser(context.Background(), th.BasicUser.Id, "invalid_team_id", categories.Categories[0].Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid category id", func(t *testing.T) {
|
|
_, resp, err := th.Client.GetSidebarCategoryForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "invalid_category_id", "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusBadRequest, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error when user is not logged in", func(t *testing.T) {
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
client := th.CreateClient()
|
|
_, resp, err := client.GetSidebarCategoryForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, categories.Categories[0].Id, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should not crash with null input", func(t *testing.T) {
|
|
require.NotPanics(t, func() {
|
|
user, client := setupUserForSubtest(t, th)
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
route := fmt.Sprintf("/users/%s/teams/%s/channels/categories/%s", user.Id, th.BasicTeam.Id, categories.Categories[0].Id)
|
|
r, err := client.DoAPIGet(context.Background(), route, "")
|
|
require.NoError(t, err)
|
|
closeBody(r)
|
|
})
|
|
})
|
|
|
|
t.Run("should return error when user tries to get category for a team they're not a member of", func(t *testing.T) {
|
|
// Create a user
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
// Create a team and add the user to it
|
|
team, appErr := th.App.CreateTeam(th.Context, &model.Team{
|
|
DisplayName: "Team for testing",
|
|
Name: "test-team-" + model.NewId(),
|
|
Email: th.GenerateTestEmail(),
|
|
Type: model.TeamOpen,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
th.LinkUserToTeam(user, team)
|
|
|
|
// Create a client and log in
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Get categories to have valid category IDs
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, team.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
// Store a category ID to use after team membership is revoked
|
|
categoryID := categories.Categories[0].Id
|
|
|
|
// Remove the user from the team
|
|
appErr = th.App.RemoveUserFromTeam(th.Context, team.Id, user.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// Attempt to get a category for the team after being removed
|
|
_, resp, err := client.GetSidebarCategoryForTeamForUser(context.Background(), user.Id, team.Id, categoryID, "")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
}
|
|
|
|
func TestValidateSidebarCategory(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// Create a test context with logger once for all subtests
|
|
c := &Context{
|
|
App: th.App,
|
|
AppContext: th.Context,
|
|
Logger: th.App.Log(),
|
|
}
|
|
|
|
t.Run("should validate category with valid channels", func(t *testing.T) {
|
|
user, _ := setupUserForSubtest(t, th)
|
|
|
|
// Create a category with channels the user is a member of
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
},
|
|
Channels: []string{th.BasicChannel.Id, th.BasicChannel2.Id},
|
|
}
|
|
|
|
err := validateSidebarCategory(c, th.BasicTeam.Id, user.Id, category)
|
|
require.Nil(t, err)
|
|
require.Len(t, category.Channels, 2)
|
|
require.Contains(t, category.Channels, th.BasicChannel.Id)
|
|
require.Contains(t, category.Channels, th.BasicChannel2.Id)
|
|
})
|
|
|
|
t.Run("should filter out invalid channel IDs", func(t *testing.T) {
|
|
user, _ := setupUserForSubtest(t, th)
|
|
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
},
|
|
Channels: []string{th.BasicChannel.Id, "invalid_channel_id"},
|
|
}
|
|
|
|
err := validateSidebarCategory(c, th.BasicTeam.Id, user.Id, category)
|
|
require.Nil(t, err)
|
|
require.Len(t, category.Channels, 1)
|
|
require.Contains(t, category.Channels, th.BasicChannel.Id)
|
|
require.NotContains(t, category.Channels, "invalid_channel_id")
|
|
})
|
|
|
|
t.Run("should filter out channels user is not a member of", func(t *testing.T) {
|
|
user, _ := setupUserForSubtest(t, th)
|
|
|
|
// Create a channel that the user is not a member of
|
|
channel, appErr := th.App.CreateChannel(th.Context, &model.Channel{
|
|
TeamId: th.BasicTeam.Id,
|
|
Type: model.ChannelTypeOpen,
|
|
Name: "testchannel",
|
|
DisplayName: "Test Channel",
|
|
}, false)
|
|
require.Nil(t, appErr)
|
|
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
},
|
|
Channels: []string{th.BasicChannel.Id, channel.Id},
|
|
}
|
|
|
|
err := validateSidebarCategory(c, th.BasicTeam.Id, user.Id, category)
|
|
require.Nil(t, err)
|
|
require.Len(t, category.Channels, 1)
|
|
require.Contains(t, category.Channels, th.BasicChannel.Id)
|
|
require.NotContains(t, category.Channels, channel.Id)
|
|
})
|
|
|
|
t.Run("should return error with invalid team id", func(t *testing.T) {
|
|
user, _ := setupUserForSubtest(t, th)
|
|
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: "invalid_team_id",
|
|
},
|
|
Channels: []string{th.BasicChannel.Id},
|
|
}
|
|
|
|
err := validateSidebarCategory(c, "invalid_team_id", user.Id, category)
|
|
require.NotNil(t, err)
|
|
require.Equal(t, http.StatusBadRequest, err.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid user id", func(t *testing.T) {
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: "invalid_user_id",
|
|
TeamId: th.BasicTeam.Id,
|
|
},
|
|
Channels: []string{th.BasicChannel.Id},
|
|
}
|
|
|
|
err := validateSidebarCategory(c, th.BasicTeam.Id, "invalid_user_id", category)
|
|
require.NotNil(t, err)
|
|
require.Equal(t, http.StatusBadRequest, err.StatusCode)
|
|
})
|
|
|
|
t.Run("should handle empty channel list", func(t *testing.T) {
|
|
user, _ := setupUserForSubtest(t, th)
|
|
|
|
category := &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
},
|
|
Channels: []string{},
|
|
}
|
|
|
|
err := validateSidebarCategory(c, th.BasicTeam.Id, user.Id, category)
|
|
require.Nil(t, err)
|
|
require.Empty(t, category.Channels)
|
|
})
|
|
}
|
|
|
|
func TestValidateSidebarCategoryChannels(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// Create a test context with logger once for all subtests
|
|
c := &Context{
|
|
App: th.App,
|
|
AppContext: th.Context,
|
|
Logger: th.App.Log(),
|
|
}
|
|
|
|
t.Run("should filter valid channels", func(t *testing.T) {
|
|
// Create test channelMap
|
|
channelMap := channelListToMap(model.ChannelList{
|
|
th.BasicChannel,
|
|
th.BasicChannel2,
|
|
})
|
|
|
|
// Test with valid channel IDs
|
|
channelIds := []string{
|
|
th.BasicChannel.Id,
|
|
th.BasicChannel2.Id,
|
|
}
|
|
|
|
filtered := validateSidebarCategoryChannels(c, th.BasicUser.Id, channelIds, channelMap)
|
|
require.Len(t, filtered, 2)
|
|
require.ElementsMatch(t, channelIds, filtered)
|
|
})
|
|
|
|
t.Run("should filter out invalid channels", func(t *testing.T) {
|
|
channelMap := channelListToMap(model.ChannelList{
|
|
th.BasicChannel,
|
|
})
|
|
|
|
channelIds := []string{
|
|
th.BasicChannel.Id,
|
|
"invalid_channel_id",
|
|
}
|
|
|
|
filtered := validateSidebarCategoryChannels(c, th.BasicUser.Id, channelIds, channelMap)
|
|
require.Len(t, filtered, 1)
|
|
require.Contains(t, filtered, th.BasicChannel.Id)
|
|
require.NotContains(t, filtered, "invalid_channel_id")
|
|
})
|
|
|
|
t.Run("should handle empty channel list", func(t *testing.T) {
|
|
channelMap := channelListToMap(model.ChannelList{})
|
|
channelIds := []string{th.BasicChannel.Id}
|
|
|
|
filtered := validateSidebarCategoryChannels(c, th.BasicUser.Id, channelIds, channelMap)
|
|
require.Empty(t, filtered)
|
|
})
|
|
|
|
t.Run("should handle empty channelIds", func(t *testing.T) {
|
|
channelMap := channelListToMap(model.ChannelList{
|
|
th.BasicChannel,
|
|
th.BasicChannel2,
|
|
})
|
|
|
|
filtered := validateSidebarCategoryChannels(c, th.BasicUser.Id, []string{}, channelMap)
|
|
require.Empty(t, filtered)
|
|
})
|
|
|
|
t.Run("should handle nil inputs", func(t *testing.T) {
|
|
filtered := validateSidebarCategoryChannels(c, th.BasicUser.Id, nil, nil)
|
|
require.Empty(t, filtered)
|
|
})
|
|
|
|
t.Run("should prevent duplicate channel IDs", func(t *testing.T) {
|
|
channelMap := channelListToMap(model.ChannelList{
|
|
th.BasicChannel,
|
|
})
|
|
|
|
// Include duplicate channel IDs
|
|
channelIds := []string{
|
|
th.BasicChannel.Id,
|
|
th.BasicChannel.Id,
|
|
}
|
|
|
|
filtered := validateSidebarCategoryChannels(c, th.BasicUser.Id, channelIds, channelMap)
|
|
require.Len(t, filtered, 1)
|
|
require.Equal(t, []string{th.BasicChannel.Id}, filtered)
|
|
})
|
|
}
|
|
|
|
func TestDeleteCategoryForTeamForUser(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
t.Run("should move channels to default categories when custom category is deleted", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
// Create a custom category with different types of channels
|
|
customCategory, _, err := client.CreateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
DisplayName: "Custom Category",
|
|
Type: model.SidebarCategoryCustom,
|
|
},
|
|
// Add public, private channels and DM
|
|
Channels: []string{th.BasicChannel.Id, th.BasicPrivateChannel.Id},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, customCategory)
|
|
|
|
// Create a DM channel
|
|
dmChannel, _, err := client.CreateDirectChannel(context.Background(), user.Id, th.BasicUser2.Id)
|
|
require.NoError(t, err)
|
|
|
|
// Add DM to custom category
|
|
customCategory.Channels = append(customCategory.Channels, dmChannel.Id)
|
|
updatedCategory, _, err := client.UpdateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, customCategory.Id, customCategory)
|
|
require.NoError(t, err)
|
|
require.ElementsMatch(t, []string{th.BasicChannel.Id, th.BasicPrivateChannel.Id, dmChannel.Id}, updatedCategory.Channels)
|
|
|
|
// Delete the custom category
|
|
resp, err := client.DeleteSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, customCategory.Id)
|
|
require.NoError(t, err)
|
|
require.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
// Get all categories to verify channel redistribution
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
|
|
// Find default categories
|
|
var channelsCategory, dmsCategory *model.SidebarCategoryWithChannels
|
|
for _, cat := range categories.Categories {
|
|
switch cat.Type {
|
|
case model.SidebarCategoryChannels:
|
|
channelsCategory = cat
|
|
case model.SidebarCategoryDirectMessages:
|
|
dmsCategory = cat
|
|
}
|
|
}
|
|
|
|
require.NotNil(t, channelsCategory, "Channels category should exist")
|
|
require.NotNil(t, dmsCategory, "DMs category should exist")
|
|
|
|
// Verify public and private channels moved to channels category
|
|
require.Contains(t, channelsCategory.Channels, th.BasicChannel.Id, "Public channel should be in channels category")
|
|
require.Contains(t, channelsCategory.Channels, th.BasicPrivateChannel.Id, "Private channel should be in channels category")
|
|
|
|
// Verify DM moved to DMs category
|
|
require.Contains(t, dmsCategory.Channels, dmChannel.Id, "DM should be in direct messages category")
|
|
})
|
|
|
|
t.Run("should delete category when user has permission", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
// Create a new custom category to delete (don't delete default categories)
|
|
category, _, err := client.CreateSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: th.BasicTeam.Id,
|
|
DisplayName: "Custom Category",
|
|
Type: model.SidebarCategoryCustom,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, category)
|
|
|
|
// Delete the category
|
|
resp, err := client.DeleteSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, category.Id)
|
|
require.NoError(t, err)
|
|
require.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
// Verify category was deleted
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
for _, cat := range categories.Categories {
|
|
require.NotEqual(t, category.Id, cat.Id)
|
|
}
|
|
})
|
|
|
|
t.Run("should return error when user doesn't have permission", func(t *testing.T) {
|
|
// Create a new user that's not on the team
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Get categories for basic user to get a valid category ID
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
// Attempt to delete category for the basic user
|
|
resp, err := client.DeleteSidebarCategoryForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, categories.Categories[0].Id)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid user id", func(t *testing.T) {
|
|
// Get a valid category ID first
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
resp, err := th.Client.DeleteSidebarCategoryForTeamForUser(context.Background(), "invalid_user_id", th.BasicTeam.Id, categories.Categories[0].Id)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid team id", func(t *testing.T) {
|
|
// Get a valid category ID first
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
resp, err := th.Client.DeleteSidebarCategoryForTeamForUser(context.Background(), th.BasicUser.Id, "invalid_team_id", categories.Categories[0].Id)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusNotFound, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error with invalid category id", func(t *testing.T) {
|
|
resp, err := th.Client.DeleteSidebarCategoryForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "invalid_category_id")
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusBadRequest, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should return error when user is not logged in", func(t *testing.T) {
|
|
// Get a valid category ID first
|
|
categories, _, err := th.Client.GetSidebarCategoriesForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
client := th.CreateClient()
|
|
resp, err := client.DeleteSidebarCategoryForTeamForUser(context.Background(), th.BasicUser.Id, th.BasicTeam.Id, categories.Categories[0].Id)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("should not allow deletion of default categories", func(t *testing.T) {
|
|
user, client := setupUserForSubtest(t, th)
|
|
|
|
categories, _, err := client.GetSidebarCategoriesForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, "")
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, categories.Categories)
|
|
|
|
// Try to delete each default category
|
|
for _, category := range categories.Categories {
|
|
if category.Type != model.SidebarCategoryCustom {
|
|
resp, err := client.DeleteSidebarCategoryForTeamForUser(context.Background(), user.Id, th.BasicTeam.Id, category.Id)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusBadRequest, resp.StatusCode)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("should return error when user tries to delete a category for a team they're not a member of", func(t *testing.T) {
|
|
// Create a user
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: "password",
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
// Create a team and add the user to it
|
|
team, appErr := th.App.CreateTeam(th.Context, &model.Team{
|
|
DisplayName: "Team for testing",
|
|
Name: "test-team-" + model.NewId(),
|
|
Email: th.GenerateTestEmail(),
|
|
Type: model.TeamOpen,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
th.LinkUserToTeam(user, team)
|
|
|
|
// Create a client and log in
|
|
client := th.CreateClient()
|
|
_, _, err := client.Login(context.Background(), user.Email, "password")
|
|
require.NoError(t, err)
|
|
|
|
// Create a custom category
|
|
customCategory, _, err := client.CreateSidebarCategoryForTeamForUser(context.Background(), user.Id, team.Id, &model.SidebarCategoryWithChannels{
|
|
SidebarCategory: model.SidebarCategory{
|
|
UserId: user.Id,
|
|
TeamId: team.Id,
|
|
DisplayName: "Custom Category",
|
|
Type: model.SidebarCategoryCustom,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, customCategory)
|
|
|
|
// Remove the user from the team
|
|
appErr = th.App.RemoveUserFromTeam(th.Context, team.Id, user.Id, th.SystemAdminUser.Id)
|
|
require.Nil(t, appErr)
|
|
|
|
// Attempt to delete the category for the team after being removed
|
|
resp, err := client.DeleteSidebarCategoryForTeamForUser(context.Background(), user.Id, team.Id, customCategory.Id)
|
|
require.Error(t, err)
|
|
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
}
|
|
|
|
func setupUserForSubtest(t *testing.T, th *TestHelper) (*model.User, *model.Client4) {
|
|
password := "password"
|
|
user, appErr := th.App.CreateUser(th.Context, &model.User{
|
|
Email: th.GenerateTestEmail(),
|
|
Username: "user_" + model.NewId(),
|
|
Password: password,
|
|
})
|
|
require.Nil(t, appErr)
|
|
|
|
th.LinkUserToTeam(user, th.BasicTeam)
|
|
th.AddUserToChannel(user, th.BasicChannel)
|
|
th.AddUserToChannel(user, th.BasicChannel2)
|
|
th.AddUserToChannel(user, th.BasicPrivateChannel)
|
|
|
|
client := th.CreateClient()
|
|
user, _, err := client.Login(context.Background(), user.Email, password)
|
|
require.NoError(t, err)
|
|
|
|
return user, client
|
|
}
|