snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/channels/app/channel_category_test.go

@@ -0,0 +1,792 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+)
+
+func TestSidebarCategory(t *testing.T) {
+	mainHelper.Parallel(t)
+	th := Setup(t).InitBasic(t)
+
+	basicChannel2 := th.CreateChannel(t, th.BasicTeam)
+	defer func() {
+		err := th.App.PermanentDeleteChannel(th.Context, basicChannel2)
+		require.Nil(t, err)
+	}()
+	user := th.CreateUser(t)
+	defer func() {
+		err := th.App.Srv().Store().User().PermanentDelete(th.Context, user.Id)
+		require.NoError(t, err)
+	}()
+	th.LinkUserToTeam(t, user, th.BasicTeam)
+	th.AddUserToChannel(t, user, basicChannel2)
+
+	var createdCategory *model.SidebarCategoryWithChannels
+	t.Run("CreateSidebarCategory", func(t *testing.T) {
+		catData := model.SidebarCategoryWithChannels{
+			SidebarCategory: model.SidebarCategory{
+				DisplayName: "TEST",
+			},
+			Channels: []string{th.BasicChannel.Id, basicChannel2.Id, basicChannel2.Id},
+		}
+		_, err := th.App.CreateSidebarCategory(th.Context, user.Id, th.BasicTeam.Id, &catData)
+		require.NotNil(t, err, "Should return error due to duplicate IDs")
+		catData.Channels = []string{th.BasicChannel.Id, basicChannel2.Id}
+		cat, err := th.App.CreateSidebarCategory(th.Context, user.Id, th.BasicTeam.Id, &catData)
+		require.Nil(t, err, "Expected no error")
+		require.NotNil(t, cat, "Expected category object, got nil")
+		createdCategory = cat
+	})
+
+	t.Run("UpdateSidebarCategories", func(t *testing.T) {
+		require.NotNil(t, createdCategory)
+		createdCategory.Channels = []string{th.BasicChannel.Id}
+		updatedCat, err := th.App.UpdateSidebarCategories(th.Context, user.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{createdCategory})
+		require.Nil(t, err, "Expected no error")
+		require.NotNil(t, updatedCat, "Expected category object, got nil")
+		require.Len(t, updatedCat, 1)
+		require.Len(t, updatedCat[0].Channels, 1)
+		require.Equal(t, updatedCat[0].Channels[0], th.BasicChannel.Id)
+	})
+
+	t.Run("UpdateSidebarCategoryOrder", func(t *testing.T) {
+		err := th.App.UpdateSidebarCategoryOrder(th.Context, user.Id, th.BasicTeam.Id, []string{th.BasicChannel.Id, basicChannel2.Id})
+		require.NotNil(t, err, "Should return error due to invalid order")
+
+		actualOrder, err := th.App.GetSidebarCategoryOrder(th.Context, user.Id, th.BasicTeam.Id)
+		require.Nil(t, err, "Should fetch order successfully")
+
+		actualOrder[2], actualOrder[3] = actualOrder[3], actualOrder[2]
+		err = th.App.UpdateSidebarCategoryOrder(th.Context, user.Id, th.BasicTeam.Id, actualOrder)
+		require.Nil(t, err, "Should update order successfully")
+
+		// We create a copy of actualOrder to prevent racy read
+		// of the slice when the broadcast message is sent from webhub.
+		newOrder := make([]string, len(actualOrder))
+		copy(newOrder, actualOrder)
+		newOrder[2] = "asd"
+		err = th.App.UpdateSidebarCategoryOrder(th.Context, user.Id, th.BasicTeam.Id, newOrder)
+		require.NotNil(t, err, "Should return error due to invalid id")
+	})
+
+	t.Run("GetSidebarCategoryOrder", func(t *testing.T) {
+		catOrder, err := th.App.GetSidebarCategoryOrder(th.Context, user.Id, th.BasicTeam.Id)
+		require.Nil(t, err, "Expected no error")
+		require.Len(t, catOrder, 4)
+		require.Equal(t, catOrder[1], createdCategory.Id, "the newly created category should be after favorites")
+	})
+}
+
+func TestGetSidebarCategories(t *testing.T) {
+	mainHelper.Parallel(t)
+	t.Run("should return the sidebar categories for the given user/team", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		_, err := th.App.CreateSidebarCategory(th.Context, th.BasicUser.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
+			SidebarCategory: model.SidebarCategory{
+				UserId:      th.BasicUser.Id,
+				TeamId:      th.BasicTeam.Id,
+				DisplayName: "new category",
+			},
+		})
+		require.Nil(t, err)
+
+		categories, err := th.App.GetSidebarCategoriesForTeamForUser(th.Context, th.BasicUser.Id, th.BasicTeam.Id)
+		assert.Nil(t, err)
+		assert.Len(t, categories.Categories, 4)
+	})
+
+	t.Run("should create the initial categories even if migration hasn't ran yet", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		// Manually add the user to the team without going through the app layer to simulate a pre-existing user/team
+		// relationship that hasn't been migrated yet
+		team := th.CreateTeam(t)
+		_, err := th.App.Srv().Store().Team().SaveMember(th.Context, &model.TeamMember{
+			TeamId:     team.Id,
+			UserId:     th.BasicUser.Id,
+			SchemeUser: true,
+		}, 100)
+		require.NoError(t, err)
+
+		categories, appErr := th.App.GetSidebarCategoriesForTeamForUser(th.Context, th.BasicUser.Id, team.Id)
+		assert.Nil(t, appErr)
+		assert.Len(t, categories.Categories, 3)
+	})
+
+	t.Run("should return a store error if a db table is missing", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		// Temporarily renaming a table to force a DB error.
+		_, err := th.SQLStore.GetMaster().Exec("ALTER TABLE SidebarCategories RENAME TO SidebarCategoriesTest")
+		require.NoError(t, err)
+		defer func() {
+			_, err := th.SQLStore.GetMaster().Exec("ALTER TABLE SidebarCategoriesTest RENAME TO SidebarCategories")
+			require.NoError(t, err)
+		}()
+
+		categories, appErr := th.App.GetSidebarCategoriesForTeamForUser(th.Context, th.BasicUser.Id, th.BasicTeam.Id)
+		assert.Nil(t, categories)
+		assert.NotNil(t, appErr)
+		assert.Equal(t, "app.channel.sidebar_categories.app_error", appErr.Id)
+	})
+}
+
+func TestUpdateSidebarCategories(t *testing.T) {
+	mainHelper.Parallel(t)
+	t.Run("should mute and unmute all channels in a category when it is muted or unmuted", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		categories, err := th.App.GetSidebarCategoriesForTeamForUser(th.Context, th.BasicUser.Id, th.BasicTeam.Id)
+		require.Nil(t, err)
+
+		channelsCategory := categories.Categories[1]
+
+		// Create some channels to be part of the channels category
+		channel1 := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel1)
+
+		channel2 := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel2)
+
+		// Mute the category
+		updated, err := th.App.UpdateSidebarCategories(th.Context, th.BasicUser.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:    channelsCategory.Id,
+					Muted: true,
+				},
+				Channels: []string{channel1.Id, channel2.Id},
+			},
+		})
+		require.Nil(t, err)
+		assert.True(t, updated[0].Muted)
+
+		// Confirm that the channels are now muted
+		member1, err := th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.True(t, member1.IsChannelMuted())
+		member2, err := th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.True(t, member2.IsChannelMuted())
+
+		// Unmute the category
+		updated, err = th.App.UpdateSidebarCategories(th.Context, th.BasicUser.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:    channelsCategory.Id,
+					Muted: false,
+				},
+				Channels: []string{channel1.Id, channel2.Id},
+			},
+		})
+		require.Nil(t, err)
+		assert.False(t, updated[0].Muted)
+
+		// Confirm that the channels are now unmuted
+		member1, err = th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.False(t, member1.IsChannelMuted())
+		member2, err = th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.False(t, member2.IsChannelMuted())
+	})
+
+	t.Run("should mute and unmute channels moved from an unmuted category to a muted one and back", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		// Create some channels
+		channel1 := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel1)
+
+		channel2 := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel2)
+
+		// And some categories
+		mutedCategory, err := th.App.CreateSidebarCategory(th.Context, th.BasicUser.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
+			SidebarCategory: model.SidebarCategory{
+				DisplayName: "muted",
+				Muted:       true,
+			},
+		})
+		require.Nil(t, err)
+		require.True(t, mutedCategory.Muted)
+
+		unmutedCategory, err := th.App.CreateSidebarCategory(th.Context, th.BasicUser.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
+			SidebarCategory: model.SidebarCategory{
+				DisplayName: "unmuted",
+				Muted:       false,
+			},
+			Channels: []string{channel1.Id, channel2.Id},
+		})
+		require.Nil(t, err)
+		require.False(t, unmutedCategory.Muted)
+
+		// Move the channels
+		_, err = th.App.UpdateSidebarCategories(th.Context, th.BasicUser.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          mutedCategory.Id,
+					DisplayName: mutedCategory.DisplayName,
+					Muted:       mutedCategory.Muted,
+				},
+				Channels: []string{channel1.Id, channel2.Id},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          unmutedCategory.Id,
+					DisplayName: unmutedCategory.DisplayName,
+					Muted:       unmutedCategory.Muted,
+				},
+				Channels: []string{},
+			},
+		})
+		require.Nil(t, err)
+
+		// Confirm that the channels are now muted
+		member1, err := th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.True(t, member1.IsChannelMuted())
+		member2, err := th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.True(t, member2.IsChannelMuted())
+
+		// Move the channels back
+		_, err = th.App.UpdateSidebarCategories(th.Context, th.BasicUser.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          mutedCategory.Id,
+					DisplayName: mutedCategory.DisplayName,
+					Muted:       mutedCategory.Muted,
+				},
+				Channels: []string{},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          unmutedCategory.Id,
+					DisplayName: unmutedCategory.DisplayName,
+					Muted:       unmutedCategory.Muted,
+				},
+				Channels: []string{channel1.Id, channel2.Id},
+			},
+		})
+		require.Nil(t, err)
+
+		// Confirm that the channels are now unmuted
+		member1, err = th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.False(t, member1.IsChannelMuted())
+		member2, err = th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.False(t, member2.IsChannelMuted())
+	})
+
+	t.Run("should not mute or unmute channels moved between muted categories", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		// Create some channels
+		channel1 := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel1)
+
+		channel2 := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel2)
+
+		// And some categories
+		category1, err := th.App.CreateSidebarCategory(th.Context, th.BasicUser.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
+			SidebarCategory: model.SidebarCategory{
+				DisplayName: "category1",
+				Muted:       true,
+			},
+		})
+		require.Nil(t, err)
+		require.True(t, category1.Muted)
+
+		category2, err := th.App.CreateSidebarCategory(th.Context, th.BasicUser.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
+			SidebarCategory: model.SidebarCategory{
+				DisplayName: "category2",
+				Muted:       true,
+			},
+			Channels: []string{channel1.Id, channel2.Id},
+		})
+		require.Nil(t, err)
+		require.True(t, category2.Muted)
+
+		// Move the unmuted channels
+		_, err = th.App.UpdateSidebarCategories(th.Context, th.BasicUser.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          category1.Id,
+					DisplayName: category1.DisplayName,
+					Muted:       category1.Muted,
+				},
+				Channels: []string{channel1.Id, channel2.Id},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          category2.Id,
+					DisplayName: category2.DisplayName,
+					Muted:       category2.Muted,
+				},
+				Channels: []string{},
+			},
+		})
+		require.Nil(t, err)
+
+		// Confirm that the channels are still unmuted
+		member1, err := th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.False(t, member1.IsChannelMuted())
+		member2, err := th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.False(t, member2.IsChannelMuted())
+
+		// Mute the channels manually
+		_, err = th.App.ToggleMuteChannel(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		_, err = th.App.ToggleMuteChannel(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+
+		// Move the muted channels back
+		_, err = th.App.UpdateSidebarCategories(th.Context, th.BasicUser.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          category1.Id,
+					DisplayName: category1.DisplayName,
+					Muted:       category1.Muted,
+				},
+				Channels: []string{},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          category2.Id,
+					DisplayName: category2.DisplayName,
+					Muted:       category2.Muted,
+				},
+				Channels: []string{channel1.Id, channel2.Id},
+			},
+		})
+		require.Nil(t, err)
+
+		// Confirm that the channels are still muted
+		member1, err = th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.True(t, member1.IsChannelMuted())
+		member2, err = th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.True(t, member2.IsChannelMuted())
+	})
+
+	t.Run("should not mute or unmute channels moved between unmuted categories", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		// Create some channels
+		channel1 := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel1)
+
+		channel2 := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel2)
+
+		// And some categories
+		category1, err := th.App.CreateSidebarCategory(th.Context, th.BasicUser.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
+			SidebarCategory: model.SidebarCategory{
+				DisplayName: "category1",
+				Muted:       false,
+			},
+		})
+		require.Nil(t, err)
+		require.False(t, category1.Muted)
+
+		category2, err := th.App.CreateSidebarCategory(th.Context, th.BasicUser.Id, th.BasicTeam.Id, &model.SidebarCategoryWithChannels{
+			SidebarCategory: model.SidebarCategory{
+				DisplayName: "category2",
+				Muted:       false,
+			},
+			Channels: []string{channel1.Id, channel2.Id},
+		})
+		require.Nil(t, err)
+		require.False(t, category2.Muted)
+
+		// Move the unmuted channels
+		_, err = th.App.UpdateSidebarCategories(th.Context, th.BasicUser.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          category1.Id,
+					DisplayName: category1.DisplayName,
+					Muted:       category1.Muted,
+				},
+				Channels: []string{channel1.Id, channel2.Id},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          category2.Id,
+					DisplayName: category2.DisplayName,
+					Muted:       category2.Muted,
+				},
+				Channels: []string{},
+			},
+		})
+		require.Nil(t, err)
+
+		// Confirm that the channels are still unmuted
+		member1, err := th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.False(t, member1.IsChannelMuted())
+		member2, err := th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.False(t, member2.IsChannelMuted())
+
+		// Mute the channels manually
+		_, err = th.App.ToggleMuteChannel(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		_, err = th.App.ToggleMuteChannel(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+
+		// Move the muted channels back
+		_, err = th.App.UpdateSidebarCategories(th.Context, th.BasicUser.Id, th.BasicTeam.Id, []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          category1.Id,
+					DisplayName: category1.DisplayName,
+					Muted:       category1.Muted,
+				},
+				Channels: []string{},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          category2.Id,
+					DisplayName: category2.DisplayName,
+					Muted:       category2.Muted,
+				},
+				Channels: []string{channel1.Id, channel2.Id},
+			},
+		})
+		require.Nil(t, err)
+
+		// Confirm that the channels are still muted
+		member1, err = th.App.GetChannelMember(th.Context, channel1.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.True(t, member1.IsChannelMuted())
+		member2, err = th.App.GetChannelMember(th.Context, channel2.Id, th.BasicUser.Id)
+		require.Nil(t, err)
+		assert.True(t, member2.IsChannelMuted())
+	})
+}
+
+func TestSetChannelManagedCategory(t *testing.T) {
+	mainHelper.Parallel(t)
+	th := Setup(t).InitBasic(t)
+
+	session := &model.Session{UserId: th.BasicUser.Id, Props: model.StringMap{}}
+	rctx := th.Context.WithSession(session)
+
+	t.Run("should set a managed category on a public channel", func(t *testing.T) {
+		channel := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel)
+		err := th.App.SetChannelManagedCategory(rctx, channel.Id, "Operations")
+		require.Nil(t, err)
+
+		mappings, err := th.App.GetVisibleManagedCategoryMappings(rctx, th.BasicTeam.Id)
+		require.Nil(t, err)
+		assert.Equal(t, "Operations", mappings[channel.Id])
+	})
+
+	t.Run("should overwrite an existing managed category", func(t *testing.T) {
+		channel := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel)
+		err := th.App.SetChannelManagedCategory(rctx, channel.Id, "Alpha")
+		require.Nil(t, err)
+
+		err = th.App.SetChannelManagedCategory(rctx, channel.Id, "Bravo")
+		require.Nil(t, err)
+
+		mappings, err := th.App.GetVisibleManagedCategoryMappings(rctx, th.BasicTeam.Id)
+		require.Nil(t, err)
+		assert.Equal(t, "Bravo", mappings[channel.Id])
+	})
+}
+
+func TestClearChannelManagedCategory(t *testing.T) {
+	mainHelper.Parallel(t)
+	th := Setup(t).InitBasic(t)
+
+	session := &model.Session{UserId: th.BasicUser.Id, Props: model.StringMap{}}
+	rctx := th.Context.WithSession(session)
+
+	t.Run("should clear an existing managed category", func(t *testing.T) {
+		channel := th.CreateChannel(t, th.BasicTeam)
+		th.AddUserToChannel(t, th.BasicUser, channel)
+		err := th.App.SetChannelManagedCategory(rctx, channel.Id, "Operations")
+		require.Nil(t, err)
+
+		err = th.App.ClearChannelManagedCategory(rctx, channel.Id)
+		require.Nil(t, err)
+
+		mappings, err := th.App.GetVisibleManagedCategoryMappings(rctx, th.BasicTeam.Id)
+		require.Nil(t, err)
+		_, exists := mappings[channel.Id]
+		assert.False(t, exists, "expected channel.Id to be absent from mappings")
+	})
+
+	t.Run("should not error when clearing a channel with no managed category", func(t *testing.T) {
+		channel := th.CreateChannel(t, th.BasicTeam)
+		err := th.App.ClearChannelManagedCategory(rctx, channel.Id)
+		require.Nil(t, err)
+	})
+}
+
+func TestGetVisibleManagedCategoryMappings(t *testing.T) {
+	mainHelper.Parallel(t)
+	th := Setup(t).InitBasic(t)
+
+	session := &model.Session{UserId: th.BasicUser.Id, Props: model.StringMap{}}
+	rctx := th.Context.WithSession(session)
+
+	t.Run("should return empty map when no managed categories exist", func(t *testing.T) {
+		team := th.CreateTeam(t)
+		th.LinkUserToTeam(t, th.BasicUser, team)
+
+		mappings, err := th.App.GetVisibleManagedCategoryMappings(rctx, team.Id)
+		require.Nil(t, err)
+		assert.Empty(t, mappings)
+	})
+
+	t.Run("should return mappings only for channels the user is a member of", func(t *testing.T) {
+		team := th.CreateTeam(t)
+		th.LinkUserToTeam(t, th.BasicUser, team)
+
+		channel1 := th.CreateChannel(t, team)
+
+		otherUser := th.CreateUser(t)
+		th.LinkUserToTeam(t, otherUser, team)
+		otherSession := &model.Session{UserId: otherUser.Id, Props: model.StringMap{}}
+		otherCtx := th.Context.WithSession(otherSession)
+
+		channel2, appErr := th.App.CreateChannel(otherCtx, &model.Channel{
+			DisplayName: "other_channel",
+			Name:        "other_" + model.NewId(),
+			Type:        model.ChannelTypeOpen,
+			TeamId:      team.Id,
+			CreatorId:   otherUser.Id,
+		}, true)
+		require.Nil(t, appErr)
+
+		err := th.App.SetChannelManagedCategory(rctx, channel1.Id, "Alpha")
+		require.Nil(t, err)
+		err = th.App.SetChannelManagedCategory(otherCtx, channel2.Id, "Bravo")
+		require.Nil(t, err)
+
+		mappings, err := th.App.GetVisibleManagedCategoryMappings(rctx, team.Id)
+		require.Nil(t, err)
+
+		assert.Equal(t, "Alpha", mappings[channel1.Id])
+		_, hasCh2 := mappings[channel2.Id]
+		assert.False(t, hasCh2, "should not include channel user is not a member of")
+	})
+
+	t.Run("should return multiple category mappings", func(t *testing.T) {
+		team := th.CreateTeam(t)
+		th.LinkUserToTeam(t, th.BasicUser, team)
+
+		channel1 := th.CreateChannel(t, team)
+		th.AddUserToChannel(t, th.BasicUser, channel1)
+		channel2 := th.CreateChannel(t, team)
+		th.AddUserToChannel(t, th.BasicUser, channel2)
+
+		err := th.App.SetChannelManagedCategory(rctx, channel1.Id, "Ops")
+		require.Nil(t, err)
+		err = th.App.SetChannelManagedCategory(rctx, channel2.Id, "Intel")
+		require.Nil(t, err)
+
+		mappings, err := th.App.GetVisibleManagedCategoryMappings(rctx, team.Id)
+		require.Nil(t, err)
+		assert.Equal(t, "Ops", mappings[channel1.Id])
+		assert.Equal(t, "Intel", mappings[channel2.Id])
+	})
+}
+
+func TestDiffChannelsBetweenCategories(t *testing.T) {
+	mainHelper.Parallel(t)
+	t.Run("should return nothing when the categories contain identical channels", func(t *testing.T) {
+		originalCategories := []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category1",
+					DisplayName: "Category One",
+				},
+				Channels: []string{"channel1", "channel2", "channel3"},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category2",
+					DisplayName: "Category Two",
+				},
+				Channels: []string{"channel4", "channel5"},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category3",
+					DisplayName: "Category Three",
+				},
+				Channels: []string{},
+			},
+		}
+
+		updatedCategories := []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category1",
+					DisplayName: "Category Won",
+				},
+				Channels: []string{"channel1", "channel2", "channel3"},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category2",
+					DisplayName: "Category Too",
+				},
+				Channels: []string{"channel4", "channel5"},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category3",
+					DisplayName: "Category 🌲",
+				},
+				Channels: []string{},
+			},
+		}
+
+		channelsDiff := diffChannelsBetweenCategories(updatedCategories, originalCategories)
+		assert.Equal(t, map[string]*categoryChannelDiff{}, channelsDiff)
+	})
+
+	t.Run("should return nothing when the categories contain identical channels", func(t *testing.T) {
+		originalCategories := []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category1",
+					DisplayName: "Category One",
+				},
+				Channels: []string{"channel1", "channel2", "channel3"},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category2",
+					DisplayName: "Category Two",
+				},
+				Channels: []string{"channel4", "channel5"},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category3",
+					DisplayName: "Category Three",
+				},
+				Channels: []string{},
+			},
+		}
+
+		updatedCategories := []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category1",
+					DisplayName: "Category Won",
+				},
+				Channels: []string{},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category2",
+					DisplayName: "Category Too",
+				},
+				Channels: []string{"channel5", "channel2"},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category3",
+					DisplayName: "Category 🌲",
+				},
+				Channels: []string{"channel4", "channel1", "channel3"},
+			},
+		}
+
+		channelsDiff := diffChannelsBetweenCategories(updatedCategories, originalCategories)
+		assert.Equal(
+			t,
+			map[string]*categoryChannelDiff{
+				"channel1": {
+					fromCategoryId: "category1",
+					toCategoryId:   "category3",
+				},
+				"channel2": {
+					fromCategoryId: "category1",
+					toCategoryId:   "category2",
+				},
+				"channel3": {
+					fromCategoryId: "category1",
+					toCategoryId:   "category3",
+				},
+				"channel4": {
+					fromCategoryId: "category2",
+					toCategoryId:   "category3",
+				},
+			},
+			channelsDiff,
+		)
+	})
+
+	t.Run("should not return channels that are moved in our out of the categories implicitly", func(t *testing.T) {
+		// This case could change to actually return the channels in the future, but we don't need to handle it right now
+		originalCategories := []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category1",
+					DisplayName: "Category One",
+				},
+				Channels: []string{"channel1", "channel2"},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category2",
+					DisplayName: "Category Two",
+				},
+				Channels: []string{"channel3"},
+			},
+		}
+
+		updatedCategories := []*model.SidebarCategoryWithChannels{
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category1",
+					DisplayName: "Category Won",
+				},
+				Channels: []string{"channel1", "channel3"},
+			},
+			{
+				SidebarCategory: model.SidebarCategory{
+					Id:          "category2",
+					DisplayName: "Category Too",
+				},
+				Channels: []string{"channel4"},
+			},
+		}
+
+		channelsDiff := diffChannelsBetweenCategories(updatedCategories, originalCategories)
+		assert.Equal(
+			t,
+			map[string]*categoryChannelDiff{
+				"channel3": {
+					fromCategoryId: "category2",
+					toCategoryId:   "category1",
+				},
+			},
+			channelsDiff,
+		)
+	})
+}