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

server/channels/store/storetest/attributes_store.go

@@ -0,0 +1,831 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	testPropertyGroupName = "test_property_group"
+	testPropertyA         = "test_property_a"
+	testPropertyB         = "test_property_b"
+	testPropertyC         = "test_property_c"
+	testPropertyValueA1   = "value_a1"
+	testPropertyValueA2   = "value_a2"
+	testPropertyValueB1   = "value_b1"
+	testPropertyValueC1   = "option_1"
+	testPropertyValueC2   = "option_2"
+)
+
+var (
+	testTeamID = model.NewId()
+)
+
+func TestAttributesStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("RefreshAndGet", func(t *testing.T) { testAttributesStoreRefresh(t, rctx, ss) })
+	t.Run("GetChannelSubject", func(t *testing.T) { testAttributesStoreGetChannelSubject(t, rctx, ss) })
+	t.Run("EmptyMultiselect", func(t *testing.T) { testAttributesStoreEmptyMultiselect(t, rctx, ss) })
+	t.Run("SearchUsers", func(t *testing.T) { testAttributesStoreSearchUsers(t, rctx, ss, s) })
+	t.Run("SearchUsersBySubjectID", func(t *testing.T) { testAttributesStoreSearchUsersBySubjectID(t, rctx, ss, s) })
+	t.Run("GetChannelMembersToRemove", func(t *testing.T) { testAttributesStoreGetChannelMembersToRemove(t, rctx, ss, s) })
+	t.Run("GetTeamMembersToRemove", func(t *testing.T) { testAttributesStoreGetTeamMembersToRemove(t, rctx, ss, s) })
+}
+
+// To help mental model of the test users created by this function:
+//   - user[0] : {
+//     "test_property_a":"value_a1",
+//     "test_property_b":"value_b1"
+//     }
+//   - user[1] : {
+//     "test_property_a":"value_a2"
+//     }
+//   - user[2] : {
+//     "test_property_a": "value_a1"
+//     "test_property_c": "option_2" // this is select type
+//     }
+//   - user[3] : {}
+func createTestUsers(t *testing.T, rctx request.CTX, ss store.Store) ([]*model.User, string, func()) {
+	maxUsersPerTeam := 50
+
+	u1 := model.User{
+		Email:    MakeEmail(),
+		Username: model.NewUsername(),
+	}
+
+	_, err := ss.User().Save(rctx, &u1)
+	require.NoError(t, err, "couldn't save user")
+
+	_, nErr := ss.Team().SaveMember(rctx, &model.TeamMember{TeamId: testTeamID, UserId: u1.Id}, maxUsersPerTeam)
+	require.NoError(t, nErr)
+
+	u2 := model.User{
+		Email:    MakeEmail(),
+		Username: model.NewUsername(),
+	}
+	_, err = ss.User().Save(rctx, &u2)
+	require.NoError(t, err, "couldn't save user")
+
+	_, nErr = ss.Team().SaveMember(rctx, &model.TeamMember{TeamId: testTeamID, UserId: u2.Id}, maxUsersPerTeam)
+	require.NoError(t, nErr)
+
+	// user3 does not have any attributes
+	u3 := model.User{
+		Email:    MakeEmail(),
+		Username: model.NewUsername(),
+	}
+
+	_, err = ss.User().Save(rctx, &u3)
+	require.NoError(t, err, "couldn't save user")
+
+	// user3 does not have any attributes
+	u4 := model.User{
+		Email:    MakeEmail(),
+		Username: model.NewUsername(),
+	}
+
+	_, err = ss.User().Save(rctx, &u4)
+	require.NoError(t, err, "couldn't save user")
+
+	group, err := ss.PropertyGroup().Register(&model.PropertyGroup{Name: testPropertyGroupName, Version: model.PropertyGroupVersionV1})
+	require.NoError(t, err)
+	require.NotZero(t, group.ID)
+	require.Equal(t, testPropertyGroupName, group.Name)
+	groupID := group.ID
+
+	fieldA, err := ss.PropertyField().Create(&model.PropertyField{
+		GroupID:    groupID,
+		Name:       testPropertyA,
+		Type:       model.PropertyFieldTypeText,
+		ObjectType: model.PropertyFieldObjectTypeUser,
+		TargetType: string(model.PropertyFieldTargetLevelSystem),
+	})
+	require.NoError(t, err)
+	fieldB, err := ss.PropertyField().Create(&model.PropertyField{
+		GroupID:    groupID,
+		Name:       testPropertyB,
+		Type:       model.PropertyFieldTypeText,
+		ObjectType: model.PropertyFieldObjectTypeUser,
+		TargetType: string(model.PropertyFieldTargetLevelSystem),
+	})
+	require.NoError(t, err)
+	attrs := map[string]any{
+		"options": []any{
+			map[string]any{"id": model.NewId(), "name": testPropertyValueC1, "color": ""},
+			map[string]any{"id": model.NewId(), "name": testPropertyValueC2, "color": ""},
+		},
+	}
+	fieldC, err := ss.PropertyField().Create(&model.PropertyField{
+		GroupID:    groupID,
+		Name:       "test_property_c",
+		Type:       model.PropertyFieldTypeSelect,
+		Attrs:      attrs,
+		ObjectType: model.PropertyFieldObjectTypeUser,
+		TargetType: string(model.PropertyFieldTargetLevelSystem),
+	})
+	require.NoError(t, err)
+
+	vala1, err := json.Marshal(testPropertyValueA1)
+	require.NoError(t, err)
+	vala2, err := json.Marshal(testPropertyValueA2)
+	require.NoError(t, err)
+	valab1, err := json.Marshal(testPropertyValueB1)
+	require.NoError(t, err)
+	valc2, err := json.Marshal(attrs["options"].([]any)[0].(map[string]any)["id"])
+	require.NoError(t, err)
+
+	pva1, err := ss.PropertyValue().Create(&model.PropertyValue{
+		TargetID:   u1.Id,
+		TargetType: model.PropertyValueTargetTypeUser,
+		GroupID:    groupID,
+		FieldID:    fieldA.ID,
+		Value:      vala1,
+	})
+	require.NoError(t, err)
+
+	pvb1, err := ss.PropertyValue().Create(&model.PropertyValue{
+		TargetID:   u1.Id,
+		TargetType: model.PropertyValueTargetTypeUser,
+		GroupID:    groupID,
+		FieldID:    fieldB.ID,
+		Value:      valab1,
+	})
+	require.NoError(t, err)
+
+	pva2, err := ss.PropertyValue().Create(&model.PropertyValue{
+		TargetID:   u2.Id,
+		TargetType: model.PropertyValueTargetTypeUser,
+		GroupID:    groupID,
+		FieldID:    fieldA.ID,
+		Value:      vala2,
+	})
+	require.NoError(t, err)
+
+	pva3, err := ss.PropertyValue().Create(&model.PropertyValue{
+		TargetID:   u3.Id,
+		TargetType: model.PropertyValueTargetTypeUser,
+		GroupID:    groupID,
+		FieldID:    fieldA.ID,
+		Value:      vala1,
+	})
+	require.NoError(t, err)
+
+	pva4, err := ss.PropertyValue().Create(&model.PropertyValue{
+		TargetID:   u3.Id,
+		TargetType: model.PropertyValueTargetTypeUser,
+		GroupID:    groupID,
+		FieldID:    fieldC.ID,
+		Value:      valc2,
+	})
+	require.NoError(t, err)
+
+	return []*model.User{&u1, &u2, &u3}, groupID, func() {
+		for _, pv := range []*model.PropertyValue{pva1, pvb1, pva2, pva3, pva4} {
+			dErr := ss.PropertyValue().Delete(groupID, pv.ID)
+			require.NoError(t, dErr, "couldn't delete property value")
+		}
+		for _, field := range []*model.PropertyField{fieldA, fieldB, fieldC} {
+			dErr := ss.PropertyField().Delete(groupID, field.ID)
+			require.NoError(t, dErr, "couldn't delete property field")
+		}
+		for _, u := range []*model.User{&u1, &u2, &u3, &u4} {
+			dErr := ss.User().PermanentDelete(rctx, u.Id)
+			require.NoError(t, dErr, "couldn't delete user")
+		}
+	}
+}
+
+func testAttributesStoreRefresh(t *testing.T, rctx request.CTX, ss store.Store) {
+	users, groupID, cleanup := createTestUsers(t, rctx, ss)
+	t.Cleanup(cleanup)
+
+	t.Run("Refresh attributes", func(t *testing.T) {
+		err := ss.Attributes().RefreshAttributes()
+		require.NoError(t, err, "couldn't refresh attributes")
+
+		// Check if the attributes are set correctly
+		for _, user := range users {
+			subject, err := ss.Attributes().GetSubject(rctx, user.Id, groupID, model.PropertyFieldObjectTypeUser)
+			require.NoError(t, err, "couldn't get subject")
+
+			require.Equal(t, user.Id, subject.ID)
+			require.Equal(t, "user", subject.Type)
+		}
+	})
+
+	t.Run("Get non-existing subject", func(t *testing.T) {
+		subject, err := ss.Attributes().GetSubject(rctx, "non-existing-id", groupID, model.PropertyFieldObjectTypeUser)
+		require.Error(t, err, "expected error when getting non-existing subject")
+		require.IsType(t, &store.ErrNotFound{}, err, "expected not found error")
+		require.Nil(t, subject, "expected nil subject for non-existing ID")
+	})
+}
+
+// testAttributesStoreGetChannelSubject verifies the per-object-type view split
+// (migration 000216): a channel-scoped attribute is readable via
+// GetSubject(..., "channel") from ChannelAttributeView, and is *not* visible
+// through the user view — proving the two views filter by ObjectType.
+func testAttributesStoreGetChannelSubject(t *testing.T, rctx request.CTX, ss store.Store) {
+	group, err := ss.PropertyGroup().Register(&model.PropertyGroup{Name: model.NewId(), Version: model.PropertyGroupVersionV1})
+	require.NoError(t, err)
+	groupID := group.ID
+
+	field, err := ss.PropertyField().Create(&model.PropertyField{
+		GroupID:    groupID,
+		Name:       "channel_prop",
+		Type:       model.PropertyFieldTypeText,
+		ObjectType: model.PropertyFieldObjectTypeChannel,
+		TargetType: string(model.PropertyFieldTargetLevelSystem),
+	})
+	require.NoError(t, err)
+
+	channelID := model.NewId()
+	val, err := json.Marshal("channel_value")
+	require.NoError(t, err)
+	pv, err := ss.PropertyValue().Create(&model.PropertyValue{
+		TargetID:   channelID,
+		TargetType: model.PropertyValueTargetTypeChannel,
+		GroupID:    groupID,
+		FieldID:    field.ID,
+		Value:      val,
+	})
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		require.NoError(t, ss.PropertyValue().Delete(groupID, pv.ID))
+		require.NoError(t, ss.PropertyField().Delete(groupID, field.ID))
+	})
+
+	require.NoError(t, ss.Attributes().RefreshAttributes())
+
+	t.Run("channel view returns channel attributes", func(t *testing.T) {
+		subject, err := ss.Attributes().GetSubject(rctx, channelID, groupID, model.PropertyFieldObjectTypeChannel)
+		require.NoError(t, err)
+		require.Equal(t, channelID, subject.ID)
+		require.Equal(t, model.PropertyValueTargetTypeChannel, subject.Type)
+		require.Equal(t, "channel_value", subject.Attributes["channel_prop"])
+	})
+
+	t.Run("user view does not see the channel row", func(t *testing.T) {
+		subject, err := ss.Attributes().GetSubject(rctx, channelID, groupID, model.PropertyFieldObjectTypeUser)
+		require.Error(t, err)
+		require.IsType(t, &store.ErrNotFound{}, err)
+		require.Nil(t, subject)
+	})
+}
+
+// testAttributesStoreEmptyMultiselect pins the fail-closed contract for
+// multiselect attributes (migration 000216): an empty multiselect resolves to
+// NULL in the matview, never an empty array. The view builds the value with
+// jsonb_agg over the joined option rows, and jsonb_agg over zero rows yields
+// NULL — there is no NULLIF/COALESCE. A refactor that wrapped it in
+// COALESCE(..., '[]') would silently flip fail-closed to fail-open (an empty tag
+// set would start satisfying an "in"/membership rule) with the rest of the suite
+// still green, so assert the NULL directly.
+func testAttributesStoreEmptyMultiselect(t *testing.T, rctx request.CTX, ss store.Store) {
+	group, err := ss.PropertyGroup().Register(&model.PropertyGroup{Name: model.NewId(), Version: model.PropertyGroupVersionV1})
+	require.NoError(t, err)
+	groupID := group.ID
+
+	optID1, optID2 := model.NewId(), model.NewId()
+	field, err := ss.PropertyField().Create(&model.PropertyField{
+		GroupID: groupID,
+		Name:    "tags",
+		Type:    model.PropertyFieldTypeMultiselect,
+		Attrs: map[string]any{"options": []any{
+			map[string]any{"id": optID1, "name": "blue", "color": ""},
+			map[string]any{"id": optID2, "name": "green", "color": ""},
+		}},
+		ObjectType: model.PropertyFieldObjectTypeChannel,
+		TargetType: string(model.PropertyFieldTargetLevelSystem),
+	})
+	require.NoError(t, err)
+
+	emptyChannelID := model.NewId()
+	fullChannelID := model.NewId()
+
+	emptyVal, err := json.Marshal([]string{})
+	require.NoError(t, err)
+	fullVal, err := json.Marshal([]string{optID1, optID2})
+	require.NoError(t, err)
+
+	pvEmpty, err := ss.PropertyValue().Create(&model.PropertyValue{
+		TargetID:   emptyChannelID,
+		TargetType: model.PropertyValueTargetTypeChannel,
+		GroupID:    groupID,
+		FieldID:    field.ID,
+		Value:      emptyVal,
+	})
+	require.NoError(t, err)
+	pvFull, err := ss.PropertyValue().Create(&model.PropertyValue{
+		TargetID:   fullChannelID,
+		TargetType: model.PropertyValueTargetTypeChannel,
+		GroupID:    groupID,
+		FieldID:    field.ID,
+		Value:      fullVal,
+	})
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		require.NoError(t, ss.PropertyValue().Delete(groupID, pvEmpty.ID))
+		require.NoError(t, ss.PropertyValue().Delete(groupID, pvFull.ID))
+		require.NoError(t, ss.PropertyField().Delete(groupID, field.ID))
+	})
+
+	require.NoError(t, ss.Attributes().RefreshAttributes())
+
+	t.Run("empty multiselect resolves to NULL, not []", func(t *testing.T) {
+		subject, err := ss.Attributes().GetSubject(rctx, emptyChannelID, groupID, model.PropertyFieldObjectTypeChannel)
+		require.NoError(t, err)
+		// nil (JSON null), never []any{} — an empty slice would satisfy a
+		// membership rule and open the fail-open hole this test guards.
+		require.Nil(t, subject.Attributes["tags"])
+	})
+
+	t.Run("populated multiselect resolves to option names", func(t *testing.T) {
+		subject, err := ss.Attributes().GetSubject(rctx, fullChannelID, groupID, model.PropertyFieldObjectTypeChannel)
+		require.NoError(t, err)
+		require.ElementsMatch(t, []any{"blue", "green"}, subject.Attributes["tags"])
+	})
+}
+
+func testAttributesStoreSearchUsers(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	users, _, cleanup := createTestUsers(t, rctx, ss)
+	t.Cleanup(cleanup)
+	require.Len(t, users, 3, "expected 3 users")
+
+	err := ss.Attributes().RefreshAttributes()
+	require.NoError(t, err, "couldn't refresh attributes")
+
+	t.Run("Search users without query", func(t *testing.T) {
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{})
+		require.NoError(t, err, "couldn't search users")
+		require.Len(t, subjects, 4, "expected 4 users")
+		require.Equal(t, int64(4), count, "expected count 4 users")
+	})
+
+	t.Run("Search users without query, limit by team", func(t *testing.T) {
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			TeamID: testTeamID,
+		})
+		require.NoError(t, err, "couldn't search users")
+		require.Len(t, subjects, 2, "expected 2 users")
+		require.Equal(t, int64(2), count, "expected count 2 users")
+	})
+
+	t.Run("Search users with a random value query", func(t *testing.T) {
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			Query: "Attributes ->> '$." + testPropertyA + "' = ?",
+			Args:  []any{"random_value"},
+		})
+		require.NoError(t, err, "couldn't search users")
+		require.Empty(t, subjects, "expected no users with the query")
+		require.Equal(t, int64(0), count, "expected count 0 users")
+	})
+
+	t.Run("Search users with a valid value query", func(t *testing.T) {
+		query := "Attributes ->> '" + testPropertyB + "' = $1::text"
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			Query: query,
+			Args:  []any{testPropertyValueB1},
+		})
+		require.NoError(t, err, "couldn't search users")
+		require.Len(t, subjects, 1, "expected 1 user with the query")
+		require.Equal(t, subjects[0].Id, users[0].Id, "expected user ID to match")
+		require.Equal(t, int64(1), count, "expected count 1 user")
+	})
+
+	t.Run("Search users with a valid value query and limit", func(t *testing.T) {
+		query := "Attributes ->> '" + testPropertyA + "' = $1::text"
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			Query: query,
+			Args:  []any{testPropertyValueA1},
+			Limit: 1,
+		})
+		require.NoError(t, err, "couldn't search users")
+		require.Len(t, subjects, 1, "expected 1 user with the query")
+		if users[0].Id < users[2].Id {
+			require.Equal(t, subjects[0].Id, users[0].Id, "expected user ID to match")
+		} else {
+			require.Equal(t, subjects[0].Id, users[2].Id, "expected user ID to match")
+		}
+		require.Equal(t, int64(2), count, "expected count 1 user")
+	})
+
+	t.Run("Search users with pagination", func(t *testing.T) {
+		query := "Attributes ->> '" + testPropertyA + "' = $1::text"
+
+		cursor := strings.Repeat("0", 26)
+		for range 5 {
+			subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+				Query: query,
+				Args:  []any{testPropertyValueA1},
+				Limit: 1,
+				Cursor: model.SubjectCursor{
+					TargetID: cursor,
+				},
+			})
+			if len(subjects) == 0 {
+				break
+			}
+			cursor = subjects[0].Id
+
+			require.NoError(t, err, "couldn't search users")
+			require.Len(t, subjects, 1, "expected 1 user with the query")
+			require.Equal(t, int64(2), count, "expected count 2 user with the query")
+		}
+	})
+
+	// Regression test: pagination must page on Users.Id, not the LEFT-JOINed
+	// UserAttributeView.TargetID. A user with no custom-attribute row has a NULL
+	// TargetID, so a "TargetID > cursor" predicate silently drops them from
+	// every page. Native-only policies (e.g. user.verified) match exactly such
+	// users, and the membership sync always seeds a cursor, so this manifested
+	// as the sync adding zero members while the Test modal (no cursor) showed
+	// the full set.
+	t.Run("Search paginates users with no attribute row", func(t *testing.T) {
+		// A fresh user with no custom attributes => no UserAttributeView row.
+		u := model.User{Email: MakeEmail(), Username: model.NewUsername()}
+		_, err := ss.User().Save(rctx, &u)
+		require.NoError(t, err, "couldn't save attribute-less user")
+		t.Cleanup(func() {
+			require.NoError(t, ss.User().PermanentDelete(rctx, u.Id), "couldn't delete attribute-less user")
+		})
+
+		require.NoError(t, ss.Attributes().RefreshAttributes(), "couldn't refresh attributes")
+
+		// Native-style predicate against the Users table; matches the user above
+		// despite the missing UserAttributeView row.
+		subjects, _, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			Query: "Users.Email = $1::text",
+			Args:  []any{u.Email},
+			Cursor: model.SubjectCursor{
+				TargetID: strings.Repeat("0", 26),
+			},
+		})
+		require.NoError(t, err, "couldn't search attribute-less user with cursor")
+		require.Len(t, subjects, 1, "attribute-less user must be returned despite the pagination cursor")
+		require.Equal(t, u.Id, subjects[0].Id, "expected the attribute-less user")
+	})
+}
+
+func testAttributesStoreGetChannelMembersToRemove(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	users, _, cleanup := createTestUsers(t, rctx, ss)
+	t.Cleanup(cleanup)
+	require.Len(t, users, 3, "expected 3 users")
+
+	err := ss.Attributes().RefreshAttributes()
+	require.NoError(t, err, "couldn't refresh attributes")
+
+	ch, err := ss.Channel().Save(rctx, &model.Channel{
+		Name:     "test-channel",
+		TeamId:   testTeamID,
+		Type:     model.ChannelTypePrivate,
+		CreateAt: model.GetMillis(),
+	}, 1000)
+	require.NoError(t, err, "couldn't save channel")
+
+	defaultNotifyProps := model.GetDefaultChannelNotifyProps()
+
+	cm1, err := ss.Channel().SaveMember(rctx, &model.ChannelMember{
+		ChannelId:   ch.Id,
+		UserId:      users[0].Id,
+		NotifyProps: defaultNotifyProps,
+	})
+	require.NoError(t, err, "couldn't save channel member for user 1")
+	cm2, err := ss.Channel().SaveMember(rctx, &model.ChannelMember{
+		ChannelId:   ch.Id,
+		UserId:      users[1].Id,
+		NotifyProps: defaultNotifyProps,
+	})
+	require.NoError(t, err, "couldn't save channel member for user 2")
+	cm3, err := ss.Channel().SaveMember(rctx, &model.ChannelMember{
+		ChannelId:   ch.Id,
+		UserId:      users[2].Id,
+		NotifyProps: defaultNotifyProps,
+	})
+	require.NoError(t, err, "couldn't save channel member for user 3")
+	t.Cleanup(func() {
+		dErr := ss.Channel().RemoveMember(rctx, cm1.ChannelId, cm1.UserId)
+		require.NoError(t, dErr, "couldn't delete channel member for user 1")
+		dErr = ss.Channel().RemoveMember(rctx, cm2.ChannelId, cm2.UserId)
+		require.NoError(t, dErr, "couldn't delete channel member for user 2")
+		dErr = ss.Channel().RemoveMember(rctx, cm3.ChannelId, cm3.UserId)
+		require.NoError(t, dErr, "couldn't delete channel member for user 3")
+		dErr = ss.Channel().Delete(ch.Id, model.GetMillis())
+		require.NoError(t, dErr, "couldn't delete channel")
+	})
+
+	t.Run("Get channel members to remove single attribute", func(t *testing.T) {
+		query := "Attributes ->> '" + testPropertyA + "' = $1::text" // Attributes ->> '$.Clearance' >= $1::text
+		members, err := ss.Attributes().GetChannelMembersToRemove(rctx, ch.Id, model.SubjectSearchOptions{
+			Query: query,
+			Args:  []any{testPropertyValueA1},
+		})
+		require.NoError(t, err, "couldn't get channel members to remove")
+		require.Len(t, members, 1, "expected 1 channel members to remove")
+	})
+
+	t.Run("Get channel members to remove multiple attribute", func(t *testing.T) {
+		query := "Attributes ->> '" + testPropertyA + "' = $1::text AND Attributes ->> '" + testPropertyB + "' = $2::text"
+		members, err := ss.Attributes().GetChannelMembersToRemove(rctx, ch.Id, model.SubjectSearchOptions{
+			Query: query,
+			Args:  []any{testPropertyValueA1, testPropertyValueB1},
+		})
+		require.NoError(t, err, "couldn't get channel members to remove")
+		require.Len(t, members, 2, "expected 2 channel members to remove")
+	})
+
+	t.Run("Get channel members to remove with empty query", func(t *testing.T) {
+		members, err := ss.Attributes().GetChannelMembersToRemove(rctx, ch.Id, model.SubjectSearchOptions{
+			Query: "",
+		})
+		require.NoError(t, err, "couldn't get channel members to remove")
+		require.Len(t, members, 3, "expected 3 channel members to remove")
+	})
+
+	t.Run("Get channel members for select type attribute", func(t *testing.T) {
+		query := "Attributes ->> '" + testPropertyC + "' = $1::text"
+		members, err := ss.Attributes().GetChannelMembersToRemove(rctx, ch.Id, model.SubjectSearchOptions{
+			Query: query,
+			Args:  []any{testPropertyValueC1},
+		})
+		require.NoError(t, err, "couldn't get channel members to remove")
+		require.Len(t, members, 2, "expected 2 channel member to remove")
+	})
+
+	// Regression test: a native-attribute policy resolves against the Users
+	// table (the query is joined to Users), and a member with no UserAttributeView
+	// row who satisfies it must NOT be removed. Before the fix, native columns
+	// failed to resolve (no Users join) and the "OR UserAttributeView.TargetID IS
+	// NULL" clause removed attribute-less members outright.
+	t.Run("native policy keeps members with no attribute row", func(t *testing.T) {
+		extra := model.User{Email: MakeEmail(), Username: model.NewUsername()}
+		_, err := ss.User().Save(rctx, &extra)
+		require.NoError(t, err, "couldn't save attribute-less member")
+		_, err = ss.Channel().SaveMember(rctx, &model.ChannelMember{
+			ChannelId:   ch.Id,
+			UserId:      extra.Id,
+			NotifyProps: defaultNotifyProps,
+		})
+		require.NoError(t, err, "couldn't add attribute-less member")
+		t.Cleanup(func() {
+			require.NoError(t, ss.Channel().RemoveMember(rctx, ch.Id, extra.Id), "couldn't remove attribute-less member")
+			require.NoError(t, ss.User().PermanentDelete(rctx, extra.Id), "couldn't delete attribute-less member")
+		})
+
+		require.NoError(t, ss.Attributes().RefreshAttributes(), "couldn't refresh attributes")
+
+		// Native-style predicate satisfied by every active user, including the
+		// attribute-less member.
+		members, err := ss.Attributes().GetChannelMembersToRemove(rctx, ch.Id, model.SubjectSearchOptions{
+			Query: "Users.DeleteAt = $1::bigint",
+			Args:  []any{int64(0)},
+		})
+		require.NoError(t, err, "native removal query must not error")
+		require.Empty(t, members, "members satisfying a native policy must not be removed, even without an attribute row")
+	})
+}
+
+func testAttributesStoreGetTeamMembersToRemove(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	users, _, cleanup := createTestUsers(t, rctx, ss)
+	t.Cleanup(cleanup)
+	require.Len(t, users, 3, "expected 3 users")
+
+	err := ss.Attributes().RefreshAttributes()
+	require.NoError(t, err, "couldn't refresh attributes")
+
+	// Use a fresh team so membership is exactly the three users below,
+	// independent of createTestUsers seeding members into testTeamID.
+	teamID := model.NewId()
+	for _, u := range users {
+		_, nErr := ss.Team().SaveMember(rctx, &model.TeamMember{TeamId: teamID, UserId: u.Id}, 1000)
+		require.NoError(t, nErr, "couldn't save team member")
+	}
+	t.Cleanup(func() {
+		for _, u := range users {
+			dErr := ss.Team().RemoveMember(rctx, teamID, u.Id)
+			require.NoError(t, dErr, "couldn't delete team member")
+		}
+	})
+
+	t.Run("Get team members to remove single attribute", func(t *testing.T) {
+		query := "Attributes ->> '" + testPropertyA + "' = $1::text"
+		members, err := ss.Attributes().GetTeamMembersToRemove(rctx, teamID, model.SubjectSearchOptions{
+			Query: query,
+			Args:  []any{testPropertyValueA1},
+		})
+		require.NoError(t, err, "couldn't get team members to remove")
+		require.Len(t, members, 1, "expected 1 team member to remove")
+	})
+
+	t.Run("Get team members to remove multiple attribute", func(t *testing.T) {
+		query := "Attributes ->> '" + testPropertyA + "' = $1::text AND Attributes ->> '" + testPropertyB + "' = $2::text"
+		members, err := ss.Attributes().GetTeamMembersToRemove(rctx, teamID, model.SubjectSearchOptions{
+			Query: query,
+			Args:  []any{testPropertyValueA1, testPropertyValueB1},
+		})
+		require.NoError(t, err, "couldn't get team members to remove")
+		require.Len(t, members, 2, "expected 2 team members to remove")
+	})
+
+	t.Run("Get team members to remove with empty query", func(t *testing.T) {
+		members, err := ss.Attributes().GetTeamMembersToRemove(rctx, teamID, model.SubjectSearchOptions{
+			Query: "",
+		})
+		require.NoError(t, err, "couldn't get team members to remove")
+		require.Len(t, members, 3, "expected all 3 team members to remove")
+	})
+
+	t.Run("Get team members to remove honors limit and cursor", func(t *testing.T) {
+		first, err := ss.Attributes().GetTeamMembersToRemove(rctx, teamID, model.SubjectSearchOptions{
+			Limit: 1,
+		})
+		require.NoError(t, err, "couldn't get team members to remove")
+		require.Len(t, first, 1, "expected the limit to cap results at 1")
+
+		second, err := ss.Attributes().GetTeamMembersToRemove(rctx, teamID, model.SubjectSearchOptions{
+			Limit: 10,
+			Cursor: model.SubjectCursor{
+				TargetID: first[0].UserId,
+			},
+		})
+		require.NoError(t, err, "couldn't get team members to remove")
+		require.Len(t, second, 2, "expected the remaining 2 members after the cursor")
+		for _, m := range second {
+			require.Greater(t, m.UserId, first[0].UserId, "cursor must exclude already-seen members")
+		}
+	})
+
+	t.Run("Get team members to remove excludes soft-deleted members", func(t *testing.T) {
+		// TeamMembers are soft-deleted, so a former member keeps a row with
+		// DeleteAt != 0. Such rows must never be returned as removal candidates.
+		removed := users[0]
+		require.NoError(t, ss.Team().RemoveMember(rctx, teamID, removed.Id), "couldn't soft-delete team member")
+		t.Cleanup(func() {
+			_, nErr := ss.Team().SaveMember(rctx, &model.TeamMember{TeamId: teamID, UserId: removed.Id}, 1000)
+			require.NoError(t, nErr, "couldn't restore team member")
+		})
+
+		members, err := ss.Attributes().GetTeamMembersToRemove(rctx, teamID, model.SubjectSearchOptions{})
+		require.NoError(t, err, "couldn't get team members to remove")
+		require.Len(t, members, 2, "soft-deleted member must be excluded")
+		for _, m := range members {
+			require.NotEqual(t, removed.Id, m.UserId, "soft-deleted member must not appear")
+		}
+	})
+
+	// Regression test: a native-attribute policy resolves against the Users
+	// table (the query is joined to Users), and a member with no UserAttributeView
+	// row who satisfies it must NOT be removed. Before the fix, native columns
+	// failed to resolve (no Users join) and the "OR UserAttributeView.TargetID IS
+	// NULL" clause removed attribute-less members outright.
+	t.Run("native policy keeps members with no attribute row", func(t *testing.T) {
+		extra := model.User{Email: MakeEmail(), Username: model.NewUsername()}
+		_, err := ss.User().Save(rctx, &extra)
+		require.NoError(t, err, "couldn't save attribute-less member")
+		_, nErr := ss.Team().SaveMember(rctx, &model.TeamMember{TeamId: teamID, UserId: extra.Id}, 1000)
+		require.NoError(t, nErr, "couldn't add attribute-less member")
+		t.Cleanup(func() {
+			require.NoError(t, ss.Team().RemoveMember(rctx, teamID, extra.Id), "couldn't remove attribute-less member")
+			require.NoError(t, ss.User().PermanentDelete(rctx, extra.Id), "couldn't delete attribute-less member")
+		})
+
+		require.NoError(t, ss.Attributes().RefreshAttributes(), "couldn't refresh attributes")
+
+		// Native-style predicate satisfied by every active user, including the
+		// attribute-less member.
+		members, err := ss.Attributes().GetTeamMembersToRemove(rctx, teamID, model.SubjectSearchOptions{
+			Query: "Users.DeleteAt = $1::bigint",
+			Args:  []any{int64(0)},
+		})
+		require.NoError(t, err, "native removal query must not error")
+		require.Empty(t, members, "members satisfying a native policy must not be removed, even without an attribute row")
+	})
+}
+
+func testAttributesStoreSearchUsersBySubjectID(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	users, _, cleanup := createTestUsers(t, rctx, ss)
+	t.Cleanup(cleanup)
+	require.Len(t, users, 3, "expected 3 users")
+
+	err := ss.Attributes().RefreshAttributes()
+	require.NoError(t, err, "couldn't refresh attributes")
+
+	t.Run("Search users by specific SubjectID", func(t *testing.T) {
+		// Test searching for the first user by their ID
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			SubjectID: users[0].Id,
+		})
+		require.NoError(t, err, "couldn't search users by SubjectID")
+		require.Len(t, subjects, 1, "expected 1 user")
+		require.Equal(t, int64(1), count, "expected count 1")
+		require.Equal(t, users[0].Id, subjects[0].Id, "expected the specific user")
+	})
+
+	t.Run("Search users by non-existent SubjectID", func(t *testing.T) {
+		// Test with a non-existent user ID
+		nonExistentID := model.NewId()
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			SubjectID: nonExistentID,
+		})
+		require.NoError(t, err, "couldn't search users by non-existent SubjectID")
+		require.Len(t, subjects, 0, "expected 0 users for non-existent ID")
+		require.Equal(t, int64(0), count, "expected count 0 for non-existent ID")
+	})
+
+	t.Run("Search users by SubjectID with query filter", func(t *testing.T) {
+		// Test combining SubjectID with a query filter
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			SubjectID: users[0].Id,
+			Query:     "Attributes ->> '" + testPropertyA + "' = $1::text",
+			Args:      []any{testPropertyValueA1},
+		})
+		require.NoError(t, err, "couldn't search users by SubjectID with query")
+		require.Len(t, subjects, 1, "expected 1 user matching both SubjectID and query")
+		require.Equal(t, int64(1), count, "expected count 1")
+		require.Equal(t, users[0].Id, subjects[0].Id, "expected the specific user")
+	})
+
+	t.Run("Search users by SubjectID with non-matching query filter", func(t *testing.T) {
+		// Test SubjectID with a query that doesn't match that user
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			SubjectID: users[0].Id,
+			Query:     "Attributes ->> '" + testPropertyA + "' = $1::text",
+			Args:      []any{"non_matching_value"},
+		})
+		require.NoError(t, err, "couldn't search users by SubjectID with non-matching query")
+		require.Len(t, subjects, 0, "expected 0 users when query doesn't match SubjectID")
+		require.Equal(t, int64(0), count, "expected count 0")
+	})
+
+	// Regression test: a top-level OR in the CEL-derived query (e.g. produced
+	// by "has any of [a, b]") used to bleed past the AND-joined SubjectID
+	// clause because of SQL operator precedence (AND binds tighter than OR).
+	// The expression must be wrapped in parentheses before it is added to
+	// the WHERE clause; otherwise the SubjectID filter is silently bypassed
+	// for the left-hand side of the OR. See ValidateExpressionAgainstRequester
+	// callers (channel-admin "Test access rule" self-exclusion check).
+	t.Run("Search users by SubjectID with top-level OR query does not bypass SubjectID filter", func(t *testing.T) {
+		// users[0] (u1) has property_a = value_a1
+		// users[1] (u2) has property_a = value_a2
+		// users[2] (u3) has property_a = value_a1
+		// The OR query matches all three; SubjectID must restrict the
+		// result to a single user.
+		query := "Attributes ->> '" + testPropertyA + "' = $1::text OR Attributes ->> '" + testPropertyA + "' = $2::text"
+
+		for _, u := range users {
+			subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+				Query:     query,
+				Args:      []any{testPropertyValueA1, testPropertyValueA2},
+				SubjectID: u.Id,
+				Limit:     1,
+			})
+			require.NoError(t, err, "couldn't search users by SubjectID with top-level OR query")
+			require.Len(t, subjects, 1, "expected exactly the requested SubjectID to be returned (subject_id=%s)", u.Id)
+			require.Equal(t, u.Id, subjects[0].Id, "expected SubjectID filter to be honored despite top-level OR (subject_id=%s)", u.Id)
+			require.Equal(t, int64(1), count, "expected count 1 when filtering by SubjectID with top-level OR query (subject_id=%s)", u.Id)
+		}
+	})
+
+	// Regression test: same root cause as the SubjectID test above, but for
+	// the implicit Users.DeleteAt = 0 filter. A top-level OR in the
+	// CEL-derived query must not bleed past the AND-joined DeleteAt clause
+	// and surface soft-deleted users.
+	t.Run("Search users with top-level OR query does not surface soft-deleted users", func(t *testing.T) {
+		// Soft-delete users[0]; revert at end of subtest.
+		u := users[0]
+		originalDeleteAt := u.DeleteAt
+		u.DeleteAt = model.GetMillis()
+		_, err := ss.User().Update(rctx, u, true)
+		require.NoError(t, err, "couldn't soft-delete user")
+		t.Cleanup(func() {
+			u.DeleteAt = originalDeleteAt
+			_, cErr := ss.User().Update(rctx, u, true)
+			require.NoError(t, cErr, "couldn't restore user")
+		})
+
+		// users[0] (soft-deleted) and users[2] both have property_a = value_a1.
+		// users[1] has property_a = value_a2. The OR query matches all three.
+		// AllowInactive defaults to false, so users[0] must be excluded.
+		query := "Attributes ->> '" + testPropertyA + "' = $1::text OR Attributes ->> '" + testPropertyA + "' = $2::text"
+		subjects, count, err := ss.Attributes().SearchUsers(rctx, model.SubjectSearchOptions{
+			Query: query,
+			Args:  []any{testPropertyValueA1, testPropertyValueA2},
+		})
+		require.NoError(t, err, "couldn't search users with top-level OR query")
+		require.Len(t, subjects, 2, "expected 2 active users (soft-deleted users[0] excluded)")
+		require.Equal(t, int64(2), count, "expected count 2 active users")
+		for _, s := range subjects {
+			require.NotEqual(t, u.Id, s.Id, "soft-deleted user must not be surfaced by top-level OR query")
+		}
+	})
+}

server/channels/store/storetest/audit_store.go

@@ -0,0 +1,52 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestAuditStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("", func(t *testing.T) { testAuditStore(t, rctx, ss) })
+}
+
+func testAuditStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	audit := &model.Audit{UserId: model.NewId(), IpAddress: "ipaddress", Action: "Action"}
+	require.NoError(t, ss.Audit().Save(audit))
+	time.Sleep(100 * time.Millisecond)
+	require.NoError(t, ss.Audit().Save(audit))
+	time.Sleep(100 * time.Millisecond)
+	require.NoError(t, ss.Audit().Save(audit))
+	time.Sleep(100 * time.Millisecond)
+	audit.ExtraInfo = "extra"
+	time.Sleep(100 * time.Millisecond)
+	require.NoError(t, ss.Audit().Save(audit))
+
+	time.Sleep(100 * time.Millisecond)
+
+	audits, err := ss.Audit().Get(audit.UserId, 0, 100)
+	require.NoError(t, err)
+
+	assert.Len(t, audits, 4)
+
+	assert.Equal(t, "extra", audits[0].ExtraInfo)
+
+	audits, err = ss.Audit().Get("missing", 0, 100)
+	require.NoError(t, err)
+	assert.Empty(t, audits)
+
+	audits, err = ss.Audit().Get("", 0, 100)
+	require.NoError(t, err)
+	require.Len(t, audits, 4, "Failed to save and retrieve 4 audit logs")
+
+	require.NoError(t, ss.Audit().PermanentDeleteByUser(audit.UserId))
+}

server/channels/store/storetest/autotranslation.go

@@ -0,0 +1,448 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestAutoTranslationStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("IsUserEnabled", func(t *testing.T) { testAutoTranslationIsUserEnabled(t, rctx, ss) })
+	t.Run("GetUserLanguage", func(t *testing.T) { testAutoTranslationGetUserLanguage(t, rctx, ss) })
+	t.Run("GetActiveDestinationLanguages", func(t *testing.T) { testAutoTranslationGetActiveDestinationLanguages(t, rctx, ss) })
+	t.Run("GetAllForObject", func(t *testing.T) { testAutoTranslationGetAllForObject(t, ss) })
+}
+
+func testAutoTranslationIsUserEnabled(t *testing.T, rctx request.CTX, ss store.Store) {
+	// Setup: Create team, channel, and user
+	team := &model.Team{
+		DisplayName: "Test Team",
+		Name:        "test-team-" + model.NewId(),
+		Email:       "test@example.com",
+		Type:        model.TeamOpen,
+	}
+	team, err := ss.Team().Save(team)
+	require.NoError(t, err)
+
+	channel := &model.Channel{
+		TeamId:      team.Id,
+		DisplayName: "Test Channel",
+		Name:        "test-channel-" + model.NewId(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, nErr := ss.Channel().Save(rctx, channel, 999)
+	require.NoError(t, nErr)
+
+	user := &model.User{
+		Email:    "test@example.com",
+		Username: "testuser" + model.NewId(),
+		Locale:   "en",
+	}
+	user, nErr = ss.User().Save(rctx, user)
+	require.NoError(t, nErr)
+
+	defer func() {
+		_ = ss.Team().PermanentDelete(team.Id)
+		_ = ss.Channel().PermanentDelete(rctx, channel.Id)
+		_ = ss.User().PermanentDelete(rctx, user.Id)
+	}()
+
+	// Add user to channel
+	member := &model.ChannelMember{
+		ChannelId:   channel.Id,
+		UserId:      user.Id,
+		NotifyProps: model.GetDefaultChannelNotifyProps(),
+	}
+	_, nErr = ss.Channel().SaveMember(rctx, member)
+	require.NoError(t, nErr)
+
+	t.Run("returns false when channel is disabled", func(t *testing.T) {
+		// Channel autotranslation is disabled by default
+		enabled, err := ss.AutoTranslation().IsUserEnabled(user.Id, channel.Id)
+		require.NoError(t, err)
+		assert.False(t, enabled)
+	})
+
+	t.Run("returns false when channel enabled but user disabled", func(t *testing.T) {
+		// Enable channel autotranslation
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		// Disable user autotranslation (AutoTranslationDisabled = true means disabled)
+		member.AutoTranslationDisabled = true
+		_, nErr = ss.Channel().UpdateMember(rctx, member)
+		require.NoError(t, nErr)
+
+		enabled, getUserEnabledErr := ss.AutoTranslation().IsUserEnabled(user.Id, channel.Id)
+		require.NoError(t, getUserEnabledErr)
+		assert.False(t, enabled)
+	})
+
+	t.Run("returns true when both channel and user enabled", func(t *testing.T) {
+		// Enable channel autotranslation
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		// Enable user autotranslation
+		member.AutoTranslationDisabled = false
+		_, nErr = ss.Channel().UpdateMember(rctx, member)
+		require.NoError(t, nErr)
+
+		// Verify both are enabled
+		enabled, getUserEnabledErr := ss.AutoTranslation().IsUserEnabled(user.Id, channel.Id)
+		require.NoError(t, getUserEnabledErr)
+		assert.True(t, enabled)
+	})
+
+	t.Run("returns false after disabling user", func(t *testing.T) {
+		// Ensure channel is enabled
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		// Disable user autotranslation
+		member.AutoTranslationDisabled = true
+		_, nErr = ss.Channel().UpdateMember(rctx, member)
+		require.NoError(t, nErr)
+
+		// Verify user is disabled
+		enabled, nErr := ss.AutoTranslation().IsUserEnabled(user.Id, channel.Id)
+		require.NoError(t, nErr)
+		assert.False(t, enabled)
+	})
+
+	t.Run("returns false for non-existent user or channel", func(t *testing.T) {
+		enabled, nErr := ss.AutoTranslation().IsUserEnabled("nonexistent", channel.Id)
+		require.NoError(t, nErr)
+		assert.False(t, enabled)
+	})
+}
+
+func testAutoTranslationGetUserLanguage(t *testing.T, rctx request.CTX, ss store.Store) {
+	// Setup: Create team, channel, and users with different locales
+	team := &model.Team{
+		DisplayName: "Test Team",
+		Name:        "test-team-" + model.NewId(),
+		Email:       "test@example.com",
+		Type:        model.TeamOpen,
+	}
+	team, err := ss.Team().Save(team)
+	require.NoError(t, err)
+
+	channel := &model.Channel{
+		TeamId:      team.Id,
+		DisplayName: "Test Channel",
+		Name:        "test-channel-" + model.NewId(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, nErr := ss.Channel().Save(rctx, channel, 999)
+	require.NoError(t, nErr)
+
+	userEN := &model.User{
+		Email:    "test-en@example.com",
+		Username: "testuser-en-" + model.NewId(),
+		Locale:   "en",
+	}
+	userEN, nErr = ss.User().Save(rctx, userEN)
+	require.NoError(t, nErr)
+
+	userES := &model.User{
+		Email:    "test-es@example.com",
+		Username: "testuser-es-" + model.NewId(),
+		Locale:   "es",
+	}
+	userES, nErr = ss.User().Save(rctx, userES)
+	require.NoError(t, nErr)
+
+	defer func() {
+		_ = ss.Team().PermanentDelete(team.Id)
+		_ = ss.Channel().PermanentDelete(rctx, channel.Id)
+		_ = ss.User().PermanentDelete(rctx, userEN.Id)
+		_ = ss.User().PermanentDelete(rctx, userES.Id)
+	}()
+
+	members := make(map[string]*model.ChannelMember)
+	// Add users to channel
+	for _, user := range []*model.User{userEN, userES} {
+		member := &model.ChannelMember{
+			ChannelId:   channel.Id,
+			UserId:      user.Id,
+			NotifyProps: model.GetDefaultChannelNotifyProps(),
+		}
+		_, nErr = ss.Channel().SaveMember(rctx, member)
+		require.NoError(t, nErr)
+		members[user.Id] = member
+	}
+
+	t.Run("returns empty when channel disabled", func(t *testing.T) {
+		locale, appErr := ss.AutoTranslation().GetUserLanguage(userEN.Id, channel.Id)
+		require.NoError(t, appErr)
+		assert.Empty(t, locale)
+	})
+
+	t.Run("returns empty when channel enabled but user disabled", func(t *testing.T) {
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		// Disable user autotranslation (AutoTranslationDisabled = true means disabled)
+		members[userEN.Id].AutoTranslationDisabled = true
+		_, nErr = ss.Channel().UpdateMember(rctx, members[userEN.Id])
+		require.NoError(t, nErr)
+
+		locale, getLocaleErr := ss.AutoTranslation().GetUserLanguage(userEN.Id, channel.Id)
+		require.NoError(t, getLocaleErr)
+		assert.Empty(t, locale)
+	})
+
+	t.Run("returns user locale when both enabled", func(t *testing.T) {
+		// Enable channel
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		// Enable user (set AutoTranslationDisabled = false)
+		members[userEN.Id].AutoTranslationDisabled = false
+		_, nErr = ss.Channel().UpdateMember(rctx, members[userEN.Id])
+		require.NoError(t, nErr)
+
+		// Get language
+		locale, getLocaleErr := ss.AutoTranslation().GetUserLanguage(userEN.Id, channel.Id)
+		require.NoError(t, getLocaleErr)
+		assert.Equal(t, "en", locale)
+	})
+
+	t.Run("returns correct locale for different users", func(t *testing.T) {
+		// Enable channel
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		// Enable both users (set AutoTranslationDisabled = false)
+		members[userEN.Id].AutoTranslationDisabled = false
+		_, nErr = ss.Channel().UpdateMember(rctx, members[userEN.Id])
+		require.NoError(t, nErr)
+		members[userES.Id].AutoTranslationDisabled = false
+		_, nErr = ss.Channel().UpdateMember(rctx, members[userES.Id])
+		require.NoError(t, nErr)
+
+		// Verify English user
+		locale, nErr := ss.AutoTranslation().GetUserLanguage(userEN.Id, channel.Id)
+		require.NoError(t, nErr)
+		assert.Equal(t, "en", locale)
+
+		// Verify Spanish user
+		locale, nErr = ss.AutoTranslation().GetUserLanguage(userES.Id, channel.Id)
+		require.NoError(t, nErr)
+		assert.Equal(t, "es", locale)
+	})
+}
+
+func testAutoTranslationGetActiveDestinationLanguages(t *testing.T, rctx request.CTX, ss store.Store) {
+	// Setup: Create team, channel, and users with different locales
+	team := &model.Team{
+		DisplayName: "Test Team",
+		Name:        "test-team-" + model.NewId(),
+		Email:       "test@example.com",
+		Type:        model.TeamOpen,
+	}
+	team, err := ss.Team().Save(team)
+	require.NoError(t, err)
+
+	channel := &model.Channel{
+		TeamId:      team.Id,
+		DisplayName: "Test Channel",
+		Name:        "test-channel-" + model.NewId(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, nErr := ss.Channel().Save(rctx, channel, 999)
+	require.NoError(t, nErr)
+
+	defer func() {
+		_ = ss.Team().PermanentDelete(team.Id)
+		_ = ss.Channel().PermanentDelete(rctx, channel.Id)
+	}()
+
+	// Create users with different locales
+	users := make([]*model.User, 0)
+	locales := []string{"en", "es", "fr", "de", "en"} // Note: duplicate "en"
+
+	for i, locale := range locales {
+		user := &model.User{
+			Email:    model.NewId() + "@example.com",
+			Username: "testuser-" + model.NewId(),
+			Locale:   locale,
+		}
+		user, nErr = ss.User().Save(rctx, user)
+		require.NoError(t, nErr)
+		defer func() {
+			_ = ss.User().PermanentDelete(rctx, user.Id)
+		}()
+		users = append(users, user)
+
+		// Add user to channel
+		member := &model.ChannelMember{
+			ChannelId:   channel.Id,
+			UserId:      user.Id,
+			NotifyProps: model.GetDefaultChannelNotifyProps(),
+		}
+		if i >= 4 { // Disable autotranslation for 5th user only
+			member.AutoTranslationDisabled = true
+		}
+		_, nErr = ss.Channel().SaveMember(rctx, member)
+		require.NoError(t, nErr)
+	}
+
+	t.Run("returns empty when channel disabled", func(t *testing.T) {
+		languages, appErr := ss.AutoTranslation().GetActiveDestinationLanguages(channel.Id, "", nil)
+		require.NoError(t, appErr)
+		assert.Empty(t, languages)
+	})
+
+	t.Run("returns all enabled user languages", func(t *testing.T) {
+		// Enable channel
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		languages, appErr := ss.AutoTranslation().GetActiveDestinationLanguages(channel.Id, "", nil)
+		require.NoError(t, appErr)
+
+		// Should return en, es, fr, de (4 unique languages, 5th user is disabled)
+		assert.Len(t, languages, 4)
+		assert.Contains(t, languages, "en")
+		assert.Contains(t, languages, "es")
+		assert.Contains(t, languages, "fr")
+		assert.Contains(t, languages, "de")
+	})
+
+	t.Run("excludes specified user", func(t *testing.T) {
+		// Enable channel
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		// Exclude Spanish user
+		languages, appErr := ss.AutoTranslation().GetActiveDestinationLanguages(channel.Id, users[1].Id, nil)
+		require.NoError(t, appErr)
+
+		// Should return en, fr, de (excluded es)
+		assert.Len(t, languages, 3)
+		assert.Contains(t, languages, "en")
+		assert.NotContains(t, languages, "es")
+		assert.Contains(t, languages, "fr")
+		assert.Contains(t, languages, "de")
+	})
+
+	t.Run("filters to specific users", func(t *testing.T) {
+		// Enable channel
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		// Filter to only first two users (en, es)
+		filterIDs := []string{users[0].Id, users[1].Id}
+		languages, appErr := ss.AutoTranslation().GetActiveDestinationLanguages(channel.Id, "", filterIDs)
+		require.NoError(t, appErr)
+
+		// Should return only en, es
+		assert.Len(t, languages, 2)
+		assert.Contains(t, languages, "en")
+		assert.Contains(t, languages, "es")
+	})
+
+	t.Run("filters and excludes user", func(t *testing.T) {
+		// Enable channel
+		channel.AutoTranslation = true
+		channel, nErr = ss.Channel().Update(rctx, channel)
+		require.NoError(t, nErr)
+
+		// Filter to first two users but exclude the first one
+		filterIDs := []string{users[0].Id, users[1].Id}
+		languages, appErr := ss.AutoTranslation().GetActiveDestinationLanguages(channel.Id, users[0].Id, filterIDs)
+		require.NoError(t, appErr)
+
+		// Should return only es
+		assert.Len(t, languages, 1)
+		assert.Contains(t, languages, "es")
+	})
+}
+
+func testAutoTranslationGetAllForObject(t *testing.T, ss store.Store) {
+	objectID := model.NewId()
+	objectType := model.TranslationObjectTypePost
+
+	t.Run("returns empty for nonexistent object", func(t *testing.T) {
+		results, err := ss.AutoTranslation().GetAllForObject(objectType, model.NewId())
+		require.NoError(t, err)
+		assert.Empty(t, results)
+	})
+
+	t.Run("returns all translations for an object", func(t *testing.T) {
+		// Save translations in two languages
+		err := ss.AutoTranslation().Save(&model.Translation{
+			ObjectID:   objectID,
+			ObjectType: objectType,
+			Lang:       "es",
+			Provider:   "test",
+			Type:       model.TranslationTypeString,
+			Text:       "hola",
+			State:      model.TranslationStateReady,
+		})
+		require.NoError(t, err)
+
+		err = ss.AutoTranslation().Save(&model.Translation{
+			ObjectID:   objectID,
+			ObjectType: objectType,
+			Lang:       "fr",
+			Provider:   "test",
+			Type:       model.TranslationTypeString,
+			Text:       "bonjour",
+			State:      model.TranslationStateReady,
+		})
+		require.NoError(t, err)
+
+		results, err := ss.AutoTranslation().GetAllForObject(objectType, objectID)
+		require.NoError(t, err)
+		require.Len(t, results, 2)
+
+		langToText := make(map[string]string)
+		for _, tr := range results {
+			assert.Equal(t, objectID, tr.ObjectID)
+			assert.Equal(t, objectType, tr.ObjectType)
+			langToText[tr.Lang] = tr.Text
+		}
+		assert.Equal(t, "hola", langToText["es"])
+		assert.Equal(t, "bonjour", langToText["fr"])
+	})
+
+	t.Run("does not return translations for other objects", func(t *testing.T) {
+		otherID := model.NewId()
+		err := ss.AutoTranslation().Save(&model.Translation{
+			ObjectID:   otherID,
+			ObjectType: objectType,
+			Lang:       "de",
+			Provider:   "test",
+			Type:       model.TranslationTypeString,
+			Text:       "hallo",
+			State:      model.TranslationStateReady,
+		})
+		require.NoError(t, err)
+
+		results, err := ss.AutoTranslation().GetAllForObject(objectType, objectID)
+		require.NoError(t, err)
+		for _, tr := range results {
+			assert.Equal(t, objectID, tr.ObjectID)
+		}
+	})
+}

server/channels/store/storetest/bot_store.go

@@ -0,0 +1,593 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func makeBotWithUser(t *testing.T, rctx request.CTX, ss store.Store, bot *model.Bot) (*model.Bot, *model.User) {
+	user, err := ss.User().Save(rctx, model.UserFromBot(bot))
+	require.NoError(t, err)
+
+	bot.UserId = user.Id
+	bot, nErr := ss.Bot().Save(bot)
+	require.NoError(t, nErr)
+
+	return bot, user
+}
+
+func TestBotStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("Get", func(t *testing.T) { testBotStoreGet(t, rctx, ss, s) })
+	t.Run("GetByUsername", func(t *testing.T) { testBotStoreGetByUsername(t, rctx, ss) })
+	t.Run("GetAll", func(t *testing.T) { testBotStoreGetAll(t, rctx, ss, s) })
+	t.Run("GetAllAfter", func(t *testing.T) { testBotStoreGetAllAfter(t, rctx, ss) })
+	t.Run("Save", func(t *testing.T) { testBotStoreSave(t, rctx, ss) })
+	t.Run("Update", func(t *testing.T) { testBotStoreUpdate(t, rctx, ss) })
+	t.Run("PermanentDelete", func(t *testing.T) { testBotStorePermanentDelete(t, rctx, ss) })
+}
+
+func testBotStoreGet(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	deletedBot, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:       "deleted_bot",
+		Description:    "A deleted bot",
+		OwnerId:        model.NewId(),
+		LastIconUpdate: model.GetMillis(),
+	})
+	deletedBot.DeleteAt = 1
+	deletedBot, err := ss.Bot().Update(deletedBot)
+	require.NoError(t, err)
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(deletedBot.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, deletedBot.UserId)) }()
+
+	permanentlyDeletedBot, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:       "permanently_deleted_bot",
+		Description:    "A permanently deleted bot",
+		OwnerId:        model.NewId(),
+		LastIconUpdate: model.GetMillis(),
+		DeleteAt:       0,
+	})
+	require.NoError(t, ss.Bot().PermanentDelete(permanentlyDeletedBot.UserId))
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, permanentlyDeletedBot.UserId)) }()
+
+	b1, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:       "b1",
+		Description:    "The first bot",
+		OwnerId:        model.NewId(),
+		LastIconUpdate: model.GetMillis(),
+	})
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b1.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, b1.UserId)) }()
+
+	b2, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:       "b2",
+		Description:    "The second bot",
+		OwnerId:        model.NewId(),
+		LastIconUpdate: 0,
+	})
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b2.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, b2.UserId)) }()
+
+	// Artificially set b2.LastIconUpdate to NULL to verify handling of same.
+	_, sqlErr := s.GetMaster().Exec("UPDATE Bots SET LastIconUpdate = NULL WHERE UserId = '" + b2.UserId + "'")
+	require.NoError(t, sqlErr)
+
+	t.Run("get non-existent bot", func(t *testing.T) {
+		_, err := ss.Bot().Get("unknown", false)
+		require.Error(t, err)
+		var nfErr *store.ErrNotFound
+		require.True(t, errors.As(err, &nfErr))
+	})
+
+	t.Run("get deleted bot", func(t *testing.T) {
+		_, err := ss.Bot().Get(deletedBot.UserId, false)
+		require.Error(t, err)
+		var nfErr *store.ErrNotFound
+		require.True(t, errors.As(err, &nfErr))
+	})
+
+	t.Run("get deleted bot, include deleted", func(t *testing.T) {
+		bot, err := ss.Bot().Get(deletedBot.UserId, true)
+		require.NoError(t, err)
+		require.Equal(t, deletedBot, bot)
+	})
+
+	t.Run("get permanently deleted bot", func(t *testing.T) {
+		_, err := ss.Bot().Get(permanentlyDeletedBot.UserId, false)
+		require.Error(t, err)
+		var nfErr *store.ErrNotFound
+		require.True(t, errors.As(err, &nfErr))
+	})
+
+	t.Run("get bot 1", func(t *testing.T) {
+		bot, err := ss.Bot().Get(b1.UserId, false)
+		require.NoError(t, err)
+		require.Equal(t, b1, bot)
+	})
+
+	t.Run("get bot 2", func(t *testing.T) {
+		bot, err := ss.Bot().Get(b2.UserId, false)
+		require.NoError(t, err)
+		require.Equal(t, b2, bot)
+	})
+}
+
+func testBotStoreGetAll(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	OwnerID1 := model.NewId()
+	OwnerID2 := model.NewId()
+
+	deletedBot, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:       "deleted_bot",
+		Description:    "A deleted bot",
+		OwnerId:        OwnerID1,
+		LastIconUpdate: model.GetMillis(),
+	})
+	deletedBot.DeleteAt = 1
+	deletedBot, err := ss.Bot().Update(deletedBot)
+	require.NoError(t, err)
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(deletedBot.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, deletedBot.UserId)) }()
+
+	permanentlyDeletedBot, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:       "permanently_deleted_bot",
+		Description:    "A permanently deleted bot",
+		OwnerId:        OwnerID1,
+		LastIconUpdate: model.GetMillis(),
+		DeleteAt:       0,
+	})
+	require.NoError(t, ss.Bot().PermanentDelete(permanentlyDeletedBot.UserId))
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, permanentlyDeletedBot.UserId)) }()
+
+	b1, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:       "b1",
+		Description:    "The first bot",
+		OwnerId:        OwnerID1,
+		LastIconUpdate: model.GetMillis(),
+	})
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b1.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, b1.UserId)) }()
+
+	b2, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:       "b2",
+		Description:    "The second bot",
+		OwnerId:        OwnerID1,
+		LastIconUpdate: 0,
+	})
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b2.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, b2.UserId)) }()
+
+	// Artificially set b2.LastIconUpdate to NULL to verify handling of same.
+	_, sqlErr := s.GetMaster().Exec("UPDATE Bots SET LastIconUpdate = NULL WHERE UserId = '" + b2.UserId + "'")
+	require.NoError(t, sqlErr)
+
+	t.Run("get original bots", func(t *testing.T) {
+		bot, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			b1,
+			b2,
+		}, bot)
+	})
+
+	b3, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:    "b3",
+		Description: "The third bot",
+		OwnerId:     OwnerID1,
+	})
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b3.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, b3.UserId)) }()
+
+	b4, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:    "b4",
+		Description: "The fourth bot",
+		OwnerId:     OwnerID2,
+	})
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b4.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, b4.UserId)) }()
+
+	deletedUser := model.User{
+		Email:    MakeEmail(),
+		Username: model.NewUsername(),
+	}
+	_, err1 := ss.User().Save(rctx, &deletedUser)
+	require.NoError(t, err1, "couldn't save user")
+
+	deletedUser.DeleteAt = model.GetMillis()
+	_, err2 := ss.User().Update(rctx, &deletedUser, true)
+	require.NoError(t, err2, "couldn't delete user")
+
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, deletedUser.Id)) }()
+	ob5, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username:    "ob5",
+		Description: "Orphaned bot 5",
+		OwnerId:     deletedUser.Id,
+	})
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(ob5.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, ob5.UserId)) }()
+
+	t.Run("get newly created bot stoo", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			b1,
+			b2,
+			b3,
+			b4,
+			ob5,
+		}, bots)
+	})
+
+	t.Run("get orphaned", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, OnlyOrphaned: true})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			ob5,
+		}, bots)
+	})
+
+	t.Run("get page=0, per_page=2", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 2})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			b1,
+			b2,
+		}, bots)
+	})
+
+	t.Run("get page=1, limit=2", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 1, PerPage: 2})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			b3,
+			b4,
+		}, bots)
+	})
+
+	t.Run("get page=5, perpage=1000", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 5, PerPage: 1000})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{}, bots)
+	})
+
+	t.Run("get offset=0, limit=2, include deleted", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 2, IncludeDeleted: true})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			deletedBot,
+			b1,
+		}, bots)
+	})
+
+	t.Run("get offset=2, limit=2, include deleted", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 1, PerPage: 2, IncludeDeleted: true})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			b2,
+			b3,
+		}, bots)
+	})
+
+	t.Run("get offset=0, limit=10, creator id 1", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, OwnerId: OwnerID1})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			b1,
+			b2,
+			b3,
+		}, bots)
+	})
+
+	t.Run("get offset=0, limit=10, creator id 2", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, OwnerId: OwnerID2})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			b4,
+		}, bots)
+	})
+
+	t.Run("get offset=0, limit=10, include deleted, creator id 1", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, IncludeDeleted: true, OwnerId: OwnerID1})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			deletedBot,
+			b1,
+			b2,
+			b3,
+		}, bots)
+	})
+
+	t.Run("get offset=0, limit=10, include deleted, creator id 2", func(t *testing.T) {
+		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, IncludeDeleted: true, OwnerId: OwnerID2})
+		require.NoError(t, err)
+		require.Equal(t, []*model.Bot{
+			b4,
+		}, bots)
+	})
+}
+
+func testBotStoreSave(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("invalid bot", func(t *testing.T) {
+		bot := &model.Bot{
+			UserId:      model.NewId(),
+			Username:    "invalid bot",
+			Description: "description",
+		}
+
+		_, err := ss.Bot().Save(bot)
+		require.Error(t, err)
+		var appErr *model.AppError
+		require.True(t, errors.As(err, &appErr))
+		// require.Equal(t, "model.bot.is_valid.username.app_error", err.Id)
+	})
+
+	t.Run("normal bot", func(t *testing.T) {
+		bot := &model.Bot{
+			Username:    "normal_bot",
+			Description: "description",
+			OwnerId:     model.NewId(),
+		}
+
+		user, err := ss.User().Save(rctx, model.UserFromBot(bot))
+		require.NoError(t, err)
+		defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, user.Id)) }()
+		bot.UserId = user.Id
+
+		returnedNewBot, nErr := ss.Bot().Save(bot)
+		require.NoError(t, nErr)
+		defer func() { require.NoError(t, ss.Bot().PermanentDelete(bot.UserId)) }()
+
+		// Verify the returned bot matches the saved bot, modulo expected changes
+		require.NotEqual(t, 0, returnedNewBot.CreateAt)
+		require.NotEqual(t, 0, returnedNewBot.UpdateAt)
+		require.Equal(t, returnedNewBot.CreateAt, returnedNewBot.UpdateAt)
+		bot.UserId = returnedNewBot.UserId
+		bot.CreateAt = returnedNewBot.CreateAt
+		bot.UpdateAt = returnedNewBot.UpdateAt
+		bot.DeleteAt = 0
+		require.Equal(t, bot, returnedNewBot)
+
+		// Verify the actual bot in the database matches the saved bot.
+		actualNewBot, nErr := ss.Bot().Get(bot.UserId, false)
+		require.NoError(t, nErr)
+		require.Equal(t, bot, actualNewBot)
+	})
+}
+
+func testBotStoreUpdate(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("invalid bot should fail to update", func(t *testing.T) {
+		existingBot, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+			Username: "existing_bot",
+			OwnerId:  model.NewId(),
+		})
+		defer func() { require.NoError(t, ss.Bot().PermanentDelete(existingBot.UserId)) }()
+		defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, existingBot.UserId)) }()
+
+		bot := existingBot.Clone()
+		bot.Username = "invalid username"
+		_, err := ss.Bot().Update(bot)
+		require.Error(t, err)
+		var appErr *model.AppError
+		require.True(t, errors.As(err, &appErr))
+		require.Equal(t, "model.bot.is_valid.username.app_error", appErr.Id)
+	})
+
+	t.Run("existing bot should update", func(t *testing.T) {
+		existingBot, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+			Username: "existing_bot",
+			OwnerId:  model.NewId(),
+		})
+		defer func() { require.NoError(t, ss.Bot().PermanentDelete(existingBot.UserId)) }()
+		defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, existingBot.UserId)) }()
+
+		bot := existingBot.Clone()
+		bot.OwnerId = model.NewId()
+		bot.Description = "updated description"
+		bot.CreateAt = 999999       // Ignored
+		bot.UpdateAt = 999999       // Ignored
+		bot.LastIconUpdate = 100000 // Allowed
+		bot.DeleteAt = 100000       // Allowed
+
+		returnedBot, err := ss.Bot().Update(bot)
+		require.NoError(t, err)
+
+		// Verify the returned bot matches the updated bot, modulo expected timestamp changes
+		require.Equal(t, existingBot.CreateAt, returnedBot.CreateAt)
+		require.NotEqual(t, bot.UpdateAt, returnedBot.UpdateAt, "update should have advanced UpdateAt")
+		require.True(t, returnedBot.UpdateAt > bot.UpdateAt, "update should have advanced UpdateAt")
+		require.NotEqual(t, 99999, returnedBot.UpdateAt, "should have ignored user-provided UpdateAt")
+		require.Equal(t, bot.LastIconUpdate, returnedBot.LastIconUpdate, "should have marked icon as updated")
+		require.Equal(t, bot.DeleteAt, returnedBot.DeleteAt, "should have marked bot as deleted")
+		bot.CreateAt = returnedBot.CreateAt
+		bot.UpdateAt = returnedBot.UpdateAt
+
+		// Verify the actual (now deleted) bot in the database
+		actualBot, err := ss.Bot().Get(bot.UserId, true)
+		require.NoError(t, err)
+		require.Equal(t, bot, actualBot)
+	})
+
+	t.Run("deleted bot should update, restoring", func(t *testing.T) {
+		existingBot, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+			Username: "existing_bot",
+			OwnerId:  model.NewId(),
+		})
+		defer func() { require.NoError(t, ss.Bot().PermanentDelete(existingBot.UserId)) }()
+		defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, existingBot.UserId)) }()
+
+		existingBot.DeleteAt = 100000
+		existingBot, err := ss.Bot().Update(existingBot)
+		require.NoError(t, err)
+
+		bot := existingBot.Clone()
+		bot.DeleteAt = 0
+
+		returnedBot, err := ss.Bot().Update(bot)
+		require.NoError(t, err)
+
+		// Verify the returned bot matches the updated bot, modulo expected timestamp changes
+		require.EqualValues(t, 0, returnedBot.DeleteAt)
+		bot.UpdateAt = returnedBot.UpdateAt
+
+		// Verify the actual bot in the database
+		actualBot, err := ss.Bot().Get(bot.UserId, false)
+		require.NoError(t, err)
+		require.Equal(t, bot, actualBot)
+	})
+}
+
+func testBotStorePermanentDelete(t *testing.T, rctx request.CTX, ss store.Store) {
+	b1, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username: "b1",
+		OwnerId:  model.NewId(),
+	})
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b1.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, b1.UserId)) }()
+
+	b2, _ := makeBotWithUser(t, rctx, ss, &model.Bot{
+		Username: "b2",
+		OwnerId:  model.NewId(),
+	})
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b2.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, b2.UserId)) }()
+
+	t.Run("permanently delete a non-existent bot", func(t *testing.T) {
+		err := ss.Bot().PermanentDelete("unknown")
+		require.NoError(t, err)
+	})
+
+	t.Run("permanently delete bot", func(t *testing.T) {
+		err := ss.Bot().PermanentDelete(b1.UserId)
+		require.NoError(t, err)
+
+		_, err = ss.Bot().Get(b1.UserId, false)
+		require.Error(t, err)
+		var nfErr *store.ErrNotFound
+		require.True(t, errors.As(err, &nfErr))
+	})
+}
+
+func testBotStoreGetAllAfter(t *testing.T, rctx request.CTX, ss store.Store) {
+	bot1 := &model.Bot{
+		Username:    "bot_1",
+		Description: "description",
+		OwnerId:     model.NewId(),
+	}
+
+	user1, err := ss.User().Save(rctx, model.UserFromBot(bot1))
+	require.NoError(t, err)
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, user1.Id)) }()
+	bot1.UserId = user1.Id
+
+	returnedNewBot1, nErr := ss.Bot().Save(bot1)
+	require.NoError(t, nErr)
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(bot1.UserId)) }()
+
+	bot2 := &model.Bot{
+		Username:    "bot_2",
+		Description: "description",
+		OwnerId:     model.NewId(),
+	}
+
+	user2, err := ss.User().Save(rctx, model.UserFromBot(bot2))
+	require.NoError(t, err)
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, user2.Id)) }()
+	bot2.UserId = user2.Id
+
+	returnedNewBot2, nErr := ss.Bot().Save(bot2)
+	require.NoError(t, nErr)
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(bot2.UserId)) }()
+
+	expected := []*model.Bot{returnedNewBot1, returnedNewBot2}
+	if strings.Compare(returnedNewBot2.UserId, returnedNewBot1.UserId) < 0 {
+		expected = []*model.Bot{returnedNewBot2, returnedNewBot1}
+	}
+
+	t.Run("get after lowest possible id", func(t *testing.T) {
+		actual, err := ss.Bot().GetAllAfter(10000, strings.Repeat("0", 26))
+		require.NoError(t, err)
+
+		assert.Equal(t, expected, actual)
+	})
+
+	t.Run("get after first user", func(t *testing.T) {
+		actual, err := ss.Bot().GetAllAfter(10000, expected[0].UserId)
+		require.NoError(t, err)
+
+		assert.Equal(t, []*model.Bot{expected[1]}, actual)
+	})
+
+	t.Run("get after second user", func(t *testing.T) {
+		actual, err := ss.Bot().GetAllAfter(10000, expected[1].UserId)
+		require.NoError(t, err)
+
+		assert.Equal(t, []*model.Bot{}, actual)
+	})
+}
+
+func testBotStoreGetByUsername(t *testing.T, rctx request.CTX, ss store.Store) {
+	bot1 := &model.Bot{
+		Username:    "bot_1",
+		Description: "description",
+		OwnerId:     model.NewId(),
+	}
+
+	user1, err := ss.User().Save(rctx, model.UserFromBot(bot1))
+	require.NoError(t, err)
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, user1.Id)) }()
+	bot1.UserId = user1.Id
+
+	returnedNewBot1, nErr := ss.Bot().Save(bot1)
+	require.NoError(t, nErr)
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(bot1.UserId)) }()
+
+	bot2 := &model.Bot{
+		Username:    "bot_2",
+		Description: "description",
+		OwnerId:     model.NewId(),
+	}
+
+	user2, err := ss.User().Save(rctx, model.UserFromBot(bot2))
+	require.NoError(t, err)
+	defer func() { require.NoError(t, ss.User().PermanentDelete(rctx, user2.Id)) }()
+	bot2.UserId = user2.Id
+
+	returnedNewBot2, nErr := ss.Bot().Save(bot2)
+	require.NoError(t, nErr)
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(bot2.UserId)) }()
+
+	t.Run("get bot1 by username", func(t *testing.T) {
+		result, err := ss.Bot().GetByUsername(returnedNewBot1.Username)
+		require.NoError(t, err)
+		assert.Equal(t, returnedNewBot1, result)
+	})
+
+	t.Run("get bot2 by username", func(t *testing.T) {
+		result, err := ss.Bot().GetByUsername(returnedNewBot2.Username)
+		require.NoError(t, err)
+		assert.Equal(t, returnedNewBot2, result)
+	})
+
+	t.Run("get by empty username", func(t *testing.T) {
+		_, err := ss.Bot().GetByUsername("")
+		require.Error(t, err)
+		var nfErr *store.ErrNotFound
+		require.True(t, errors.As(err, &nfErr))
+	})
+
+	t.Run("get by unknown", func(t *testing.T) {
+		_, err := ss.Bot().GetByUsername("unknown")
+		require.Error(t, err)
+		var nfErr *store.ErrNotFound
+		require.True(t, errors.As(err, &nfErr))
+	})
+}

server/channels/store/storetest/channel_bookmark.go

@@ -0,0 +1,613 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func find_bookmark(slice []*model.ChannelBookmarkWithFileInfo, id string) *model.ChannelBookmarkWithFileInfo {
+	for _, element := range slice {
+		if element.Id == id {
+			return element
+		}
+	}
+	return nil
+}
+
+func TestChannelBookmarkStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("SaveChannelBookmark", func(t *testing.T) { testSaveChannelBookmark(t, rctx, ss) })
+	t.Run("UpdateChannelBookmark", func(t *testing.T) { testUpdateChannelBookmark(t, rctx, ss) })
+	t.Run("UpdateSortOrderChannelBookmark", func(t *testing.T) { testUpdateSortOrderChannelBookmark(t, rctx, ss) })
+	t.Run("DeleteChannelBookmark", func(t *testing.T) { testDeleteChannelBookmark(t, rctx, ss) })
+	t.Run("GetChannelBookmark", func(t *testing.T) { testGetChannelBookmark(t, rctx, ss) })
+	t.Run("BoardBookmarkSaveAndGet", func(t *testing.T) { testBoardBookmarkSaveAndGet(t, rctx, ss, s) })
+}
+
+func testSaveChannelBookmark(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	otherChannelID := model.NewId()
+	userID := model.NewId()
+
+	createAt := time.Now().Add(-1 * time.Minute)
+	deleteAt := createAt.Add(1 * time.Second)
+
+	bookmark1 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Link bookmark test",
+		LinkUrl:     "https://mattermost.com",
+		Type:        model.ChannelBookmarkLink,
+		Emoji:       ":smile:",
+	}
+
+	file := &model.FileInfo{
+		Id:              model.NewId(),
+		ChannelId:       channelID,
+		CreatorId:       model.BookmarkFileOwner,
+		Path:            "somepath",
+		ThumbnailPath:   "thumbpath",
+		PreviewPath:     "prevPath",
+		Name:            "test file",
+		Extension:       "png",
+		MimeType:        "images/png",
+		Size:            873182,
+		Width:           3076,
+		Height:          2200,
+		HasPreviewImage: true,
+	}
+
+	bookmark2 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "file bookmark test",
+		FileId:      file.Id,
+		Type:        model.ChannelBookmarkFile,
+		Emoji:       ":smile:",
+	}
+
+	bookmark3 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "file already attached",
+		FileId:      file.Id,
+		Type:        model.ChannelBookmarkFile,
+		Emoji:       ":smile:",
+	}
+
+	file2 := &model.FileInfo{
+		Id:              model.NewId(),
+		ChannelId:       channelID,
+		CreatorId:       userID,
+		Path:            "somepath",
+		ThumbnailPath:   "thumbpath",
+		PreviewPath:     "prevPath",
+		Name:            "test file",
+		Extension:       "png",
+		MimeType:        "images/png",
+		Size:            873182,
+		Width:           3076,
+		Height:          2200,
+		HasPreviewImage: true,
+	}
+
+	bookmark4 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "file already attached to a post",
+		FileId:      file2.Id,
+		Type:        model.ChannelBookmarkFile,
+		Emoji:       ":smile:",
+	}
+
+	deletedFile := &model.FileInfo{
+		Id:              model.NewId(),
+		ChannelId:       channelID,
+		CreatorId:       model.BookmarkFileOwner,
+		Path:            "somepath",
+		ThumbnailPath:   "thumbpath",
+		PreviewPath:     "prevPath",
+		Name:            "test file",
+		Extension:       "png",
+		MimeType:        "images/png",
+		Size:            873182,
+		Width:           3076,
+		Height:          2200,
+		HasPreviewImage: true,
+		CreateAt:        createAt.UnixMilli(),
+		UpdateAt:        createAt.UnixMilli(),
+		DeleteAt:        deleteAt.UnixMilli(),
+	}
+
+	bookmarkFileDeleted := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "file deleted",
+		FileId:      deletedFile.Id,
+		Type:        model.ChannelBookmarkFile,
+		Emoji:       ":smile:",
+	}
+
+	// another channel
+	anotherChannelFile := &model.FileInfo{
+		Id:              model.NewId(),
+		ChannelId:       otherChannelID,
+		CreatorId:       model.BookmarkFileOwner,
+		Path:            "somepath",
+		ThumbnailPath:   "thumbpath",
+		PreviewPath:     "prevPath",
+		Name:            "test file",
+		Extension:       "png",
+		MimeType:        "images/png",
+		Size:            873182,
+		Width:           3076,
+		Height:          2200,
+		HasPreviewImage: true,
+	}
+
+	bookmarkFileAnotherChannel := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "file another channel",
+		FileId:      anotherChannelFile.Id,
+		Type:        model.ChannelBookmarkFile,
+		Emoji:       ":smile:",
+	}
+
+	_, err := ss.FileInfo().Save(rctx, file)
+	require.NoError(t, err)
+	defer ss.FileInfo().PermanentDelete(rctx, file.Id)
+
+	_, err = ss.FileInfo().Save(rctx, file2)
+	require.NoError(t, err)
+	defer ss.FileInfo().PermanentDelete(rctx, file2.Id)
+
+	err = ss.FileInfo().AttachToPost(rctx, file2.Id, model.NewId(), channelID, userID)
+	require.NoError(t, err)
+
+	_, err = ss.FileInfo().Save(rctx, deletedFile)
+	require.NoError(t, err)
+	defer ss.FileInfo().PermanentDelete(rctx, deletedFile.Id)
+
+	_, err = ss.FileInfo().Save(rctx, anotherChannelFile)
+	require.NoError(t, err)
+	defer ss.FileInfo().PermanentDelete(rctx, anotherChannelFile.Id)
+
+	t.Run("save bookmarks", func(t *testing.T) {
+		bookmarkResp, err := ss.ChannelBookmark().Save(bookmark1.Clone(), true)
+		assert.NoError(t, err)
+
+		assert.NotEmpty(t, bookmarkResp.Id)
+		assert.Equal(t, bookmark1.ChannelId, bookmarkResp.ChannelId)
+		assert.Nil(t, bookmarkResp.FileInfo)
+
+		bookmarkResp, err = ss.ChannelBookmark().Save(bookmark2.Clone(), true)
+		assert.NoError(t, err)
+
+		assert.NotEmpty(t, bookmarkResp.Id)
+		assert.Equal(t, bookmark2.ChannelId, bookmarkResp.ChannelId)
+		assert.NotNil(t, bookmarkResp.FileInfo)
+
+		bookmarks, err := ss.ChannelBookmark().GetBookmarksForChannelSince(channelID, 0)
+		assert.NoError(t, err)
+		assert.Len(t, bookmarks, 2)
+
+		_, err = ss.ChannelBookmark().Save(bookmark3.Clone(), true)
+		assert.Error(t, err) // Error as the file is attached to a bookmark
+
+		_, err = ss.ChannelBookmark().Save(bookmark4.Clone(), true)
+		assert.Error(t, err) // Error as the file is attached to a post
+
+		_, err = ss.ChannelBookmark().Save(bookmarkFileDeleted.Clone(), true)
+		assert.Error(t, err) // Error as the file is deleted
+
+		_, err = ss.ChannelBookmark().Save(bookmarkFileAnotherChannel.Clone(), true)
+		assert.Error(t, err) // Error as the file is from another channel
+	})
+}
+
+func testUpdateChannelBookmark(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	userID := model.NewId()
+
+	bookmark1 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Link bookmark test",
+		LinkUrl:     "https://mattermost.com",
+		Type:        model.ChannelBookmarkLink,
+	}
+
+	t.Run("update bookmark", func(t *testing.T) {
+		bookmarkResp, err := ss.ChannelBookmark().Save(bookmark1.Clone(), true)
+		assert.NoError(t, err)
+
+		now := model.GetMillis()
+		bookmark2 := bookmarkResp.ChannelBookmark.Clone()
+		bookmark2.DisplayName = "Updated display name"
+		bookmark2.Emoji = ":smile:"
+		bookmark2.LinkUrl = "https://mattermost.com/about"
+
+		time.Sleep(time.Millisecond * 250)
+
+		err = ss.ChannelBookmark().Update(bookmark2.Clone())
+		assert.NoError(t, err)
+
+		bookmarks, err := ss.ChannelBookmark().GetBookmarksForChannelSince(channelID, now)
+		assert.NoError(t, err)
+		assert.Len(t, bookmarks, 1)
+
+		b := find_bookmark(bookmarks, bookmark2.Id)
+		assert.NotNil(t, b)
+		assert.Equal(t, b.DisplayName, bookmark2.DisplayName)
+		assert.Equal(t, b.Type, model.ChannelBookmarkLink)
+		assert.NotEmpty(t, b.Emoji)
+		assert.Equal(t, b.CreateAt, bookmark2.CreateAt)
+		assert.Greater(t, b.UpdateAt, bookmark2.UpdateAt)
+
+		err = ss.ChannelBookmark().Update(bookmark1.Clone())
+		assert.Error(t, err)
+
+		bookmark3 := bookmark2.Clone()
+		bookmark3.Type = model.ChannelBookmarkFile
+		err = ss.ChannelBookmark().Update(bookmark3)
+		assert.Error(t, err)
+	})
+}
+
+func testUpdateSortOrderChannelBookmark(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	userID := model.NewId()
+
+	bookmark0 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Bookmark 0",
+		LinkUrl:     "https://mattermost.com",
+		Type:        model.ChannelBookmarkLink,
+		Emoji:       ":smile:",
+	}
+
+	file := &model.FileInfo{
+		Id:              model.NewId(),
+		ChannelId:       channelID,
+		CreatorId:       model.BookmarkFileOwner,
+		Path:            "somepath",
+		ThumbnailPath:   "thumbpath",
+		PreviewPath:     "prevPath",
+		Name:            "test file",
+		Extension:       "png",
+		MimeType:        "images/png",
+		Size:            873182,
+		Width:           3076,
+		Height:          2200,
+		HasPreviewImage: true,
+	}
+
+	bookmark1 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Bookmark 1",
+		FileId:      file.Id,
+		Type:        model.ChannelBookmarkFile,
+		Emoji:       ":smile:",
+	}
+
+	_, err := ss.FileInfo().Save(rctx, file)
+	require.NoError(t, err)
+	defer ss.FileInfo().PermanentDelete(rctx, file.Id)
+
+	bookmark2 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Bookmark 2",
+		LinkUrl:     "https://mattermost.com",
+		Type:        model.ChannelBookmarkLink,
+	}
+
+	bookmark3 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Bookmark 3",
+		LinkUrl:     "https://mattermost.com",
+		Type:        model.ChannelBookmarkLink,
+	}
+
+	bookmark4 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Bookmark 4",
+		LinkUrl:     "https://mattermost.com",
+		Type:        model.ChannelBookmarkLink,
+	}
+
+	bookmarkResp, err := ss.ChannelBookmark().Save(bookmark0.Clone(), true)
+	assert.NoError(t, err)
+	bookmark0 = bookmarkResp.ChannelBookmark.Clone()
+
+	assert.NotEmpty(t, bookmarkResp.Id)
+	assert.Equal(t, bookmark0.ChannelId, bookmarkResp.ChannelId)
+	assert.Nil(t, bookmarkResp.FileInfo)
+
+	bookmarkResp, err = ss.ChannelBookmark().Save(bookmark1.Clone(), true)
+	assert.NoError(t, err)
+	bookmark1 = bookmarkResp.ChannelBookmark.Clone()
+
+	bookmarkResp, err = ss.ChannelBookmark().Save(bookmark2.Clone(), true)
+	assert.NoError(t, err)
+	bookmark2 = bookmarkResp.ChannelBookmark.Clone()
+
+	bookmarkResp, err = ss.ChannelBookmark().Save(bookmark3.Clone(), true)
+	assert.NoError(t, err)
+	bookmark3 = bookmarkResp.ChannelBookmark.Clone()
+
+	bookmarkResp, err = ss.ChannelBookmark().Save(bookmark4.Clone(), true)
+	assert.NoError(t, err)
+	bookmark4 = bookmarkResp.ChannelBookmark.Clone()
+
+	t.Run("change order of bookmarks first to last", func(t *testing.T) {
+		bookmarks, sortError := ss.ChannelBookmark().UpdateSortOrder(bookmark0.Id, channelID, 4)
+		assert.NoError(t, sortError)
+
+		assert.Equal(t, find_bookmark(bookmarks, bookmark1.Id).SortOrder, int64(0))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark2.Id).SortOrder, int64(1))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark3.Id).SortOrder, int64(2))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark4.Id).SortOrder, int64(3))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark0.Id).SortOrder, int64(4))
+	})
+
+	t.Run("change order of bookmarks last to first", func(t *testing.T) {
+		bookmarks, sortError := ss.ChannelBookmark().UpdateSortOrder(bookmark0.Id, channelID, 0)
+		assert.NoError(t, sortError)
+
+		assert.Equal(t, find_bookmark(bookmarks, bookmark0.Id).SortOrder, int64(0))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark1.Id).SortOrder, int64(1))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark2.Id).SortOrder, int64(2))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark3.Id).SortOrder, int64(3))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark4.Id).SortOrder, int64(4))
+	})
+
+	t.Run("change order of bookmarks first to third", func(t *testing.T) {
+		bookmarks, sortError := ss.ChannelBookmark().UpdateSortOrder(bookmark0.Id, channelID, 2)
+		assert.NoError(t, sortError)
+
+		assert.Equal(t, find_bookmark(bookmarks, bookmark1.Id).SortOrder, int64(0))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark2.Id).SortOrder, int64(1))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark0.Id).SortOrder, int64(2))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark3.Id).SortOrder, int64(3))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark4.Id).SortOrder, int64(4))
+
+		// now reset order
+		ss.ChannelBookmark().UpdateSortOrder(bookmark0.Id, channelID, 0)
+	})
+
+	t.Run("change order of bookmarks second to third", func(t *testing.T) {
+		bookmarks, sortError := ss.ChannelBookmark().UpdateSortOrder(bookmark1.Id, channelID, 2)
+		assert.NoError(t, sortError)
+
+		assert.Equal(t, find_bookmark(bookmarks, bookmark0.Id).SortOrder, int64(0))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark2.Id).SortOrder, int64(1))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark1.Id).SortOrder, int64(2))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark3.Id).SortOrder, int64(3))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark4.Id).SortOrder, int64(4))
+	})
+
+	t.Run("change order of bookmarks third to second", func(t *testing.T) {
+		bookmarks, sortError := ss.ChannelBookmark().UpdateSortOrder(bookmark1.Id, channelID, 1)
+		assert.NoError(t, sortError)
+
+		assert.Equal(t, find_bookmark(bookmarks, bookmark0.Id).SortOrder, int64(0))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark1.Id).SortOrder, int64(1))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark2.Id).SortOrder, int64(2))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark3.Id).SortOrder, int64(3))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark4.Id).SortOrder, int64(4))
+	})
+
+	t.Run("change order of bookmarks last to previous last", func(t *testing.T) {
+		bookmarks, sortError := ss.ChannelBookmark().UpdateSortOrder(bookmark4.Id, channelID, 3)
+		assert.NoError(t, sortError)
+
+		assert.Equal(t, find_bookmark(bookmarks, bookmark0.Id).SortOrder, int64(0))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark1.Id).SortOrder, int64(1))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark2.Id).SortOrder, int64(2))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark4.Id).SortOrder, int64(3))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark3.Id).SortOrder, int64(4))
+	})
+
+	t.Run("change order of bookmarks last to second", func(t *testing.T) {
+		bookmarks, sortError := ss.ChannelBookmark().UpdateSortOrder(bookmark3.Id, channelID, 1)
+		assert.NoError(t, sortError)
+
+		assert.Equal(t, find_bookmark(bookmarks, bookmark0.Id).SortOrder, int64(0))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark3.Id).SortOrder, int64(1))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark1.Id).SortOrder, int64(2))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark2.Id).SortOrder, int64(3))
+		assert.Equal(t, find_bookmark(bookmarks, bookmark4.Id).SortOrder, int64(4))
+	})
+
+	t.Run("change order of bookmarks error when new index is out of bounds", func(t *testing.T) {
+		var iiErr *store.ErrInvalidInput
+		_, err = ss.ChannelBookmark().UpdateSortOrder(bookmark3.Id, channelID, -1)
+		assert.Error(t, err)
+		assert.ErrorAs(t, err, &iiErr)
+		_, err = ss.ChannelBookmark().UpdateSortOrder(bookmark3.Id, channelID, 5)
+		assert.Error(t, err)
+		assert.ErrorAs(t, err, &iiErr)
+	})
+
+	t.Run("change order of bookmarks error when bookmark not found", func(t *testing.T) {
+		_, err = ss.ChannelBookmark().UpdateSortOrder(model.NewId(), channelID, 0)
+		assert.Error(t, err)
+		var nfErr *store.ErrNotFound
+		assert.ErrorAs(t, err, &nfErr)
+	})
+}
+
+func testDeleteChannelBookmark(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	userID := model.NewId()
+
+	bookmark1 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Link bookmark test",
+		LinkUrl:     "https://mattermost.com",
+		Type:        model.ChannelBookmarkLink,
+		Emoji:       ":smile:",
+	}
+
+	file := &model.FileInfo{
+		Id:              model.NewId(),
+		ChannelId:       channelID,
+		CreatorId:       model.BookmarkFileOwner,
+		Path:            "somepath",
+		ThumbnailPath:   "thumbpath",
+		PreviewPath:     "prevPath",
+		Name:            "test file",
+		Extension:       "png",
+		MimeType:        "images/png",
+		Size:            873182,
+		Width:           3076,
+		Height:          2200,
+		HasPreviewImage: true,
+	}
+
+	bookmark2 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "file bookmark test",
+		FileId:      file.Id,
+		Type:        model.ChannelBookmarkFile,
+		Emoji:       ":smile:",
+	}
+
+	_, err := ss.FileInfo().Save(rctx, file)
+	require.NoError(t, err)
+	defer ss.FileInfo().PermanentDelete(rctx, file.Id)
+
+	t.Run("delete bookmark", func(t *testing.T) {
+		now := model.GetMillis()
+		bookmarkResp, err := ss.ChannelBookmark().Save(bookmark1.Clone(), true)
+		assert.NoError(t, err)
+		bookmark1 = bookmarkResp.ChannelBookmark.Clone()
+
+		assert.NotEmpty(t, bookmarkResp.Id)
+		assert.Equal(t, bookmark1.ChannelId, bookmarkResp.ChannelId)
+		assert.Nil(t, bookmarkResp.FileInfo)
+
+		bookmarkResp, err = ss.ChannelBookmark().Save(bookmark2.Clone(), true)
+		assert.NoError(t, err)
+		bookmark2 = bookmarkResp.ChannelBookmark.Clone()
+
+		err = ss.ChannelBookmark().Delete(bookmark2.Id, true)
+		assert.NoError(t, err)
+
+		_, err = ss.FileInfo().Get(file.Id)
+		assert.Error(t, err)
+		var nfErr *store.ErrNotFound
+		assert.ErrorAs(t, err, &nfErr)
+
+		bookmarks, err := ss.ChannelBookmark().GetBookmarksForChannelSince(channelID, now)
+		assert.NoError(t, err)
+		assert.Len(t, bookmarks, 2) // we have two as the deleted record also gets returned for sync'ing purposes
+
+		b := find_bookmark(bookmarks, bookmark2.Id)
+		assert.NotNil(t, b)
+		assert.Equal(t, bookmarks[0].Type, model.ChannelBookmarkLink)
+	})
+}
+
+func testGetChannelBookmark(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	userID := model.NewId()
+
+	bookmark1 := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Link bookmark test",
+		LinkUrl:     "https://mattermost.com",
+		Type:        model.ChannelBookmarkLink,
+		Emoji:       ":smile:",
+	}
+
+	t.Run("get bookmark", func(t *testing.T) {
+		bookmarkResp, err := ss.ChannelBookmark().Save(bookmark1.Clone(), true)
+		assert.NoError(t, err)
+		bookmark1 = bookmarkResp.ChannelBookmark.Clone()
+
+		bookmarkResp, err = ss.ChannelBookmark().Get(bookmark1.Id, false)
+		assert.NoError(t, err)
+
+		assert.NotEmpty(t, bookmarkResp.Id)
+		assert.Equal(t, bookmark1.ChannelId, bookmarkResp.ChannelId)
+		assert.Nil(t, bookmarkResp.FileInfo)
+
+		err = ss.ChannelBookmark().Delete(bookmark1.Id, true)
+		assert.NoError(t, err)
+
+		bookmarkResp, err = ss.ChannelBookmark().Get(bookmark1.Id, false)
+		assert.Error(t, err)
+		assert.Nil(t, bookmarkResp)
+
+		bookmarkResp, err = ss.ChannelBookmark().Get(bookmark1.Id, true)
+		assert.NoError(t, err)
+		assert.NotNil(t, bookmarkResp)
+	})
+}
+
+func testBoardBookmarkSaveAndGet(t *testing.T, _ request.CTX, ss store.Store, s SqlStore) {
+	t.Helper()
+
+	channelID := model.NewId()
+	userID := model.NewId()
+	boardChannelID := model.NewId()
+	linkPath := "/team/boards/" + boardChannelID
+
+	bookmark := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Engineering Roadmap",
+		LinkUrl:     linkPath,
+		Type:        model.ChannelBookmarkBoard,
+		TargetId:    boardChannelID,
+	}
+
+	saved, err := ss.ChannelBookmark().Save(bookmark, true)
+	require.NoError(t, err)
+	require.NotNil(t, saved)
+	assert.Equal(t, model.ChannelBookmarkBoard, saved.Type)
+	assert.Equal(t, boardChannelID, saved.TargetId)
+	assert.Equal(t, linkPath, saved.LinkUrl)
+
+	loaded, err := ss.ChannelBookmark().Get(saved.Id, false)
+	require.NoError(t, err)
+	assert.Equal(t, model.ChannelBookmarkBoard, loaded.Type)
+	assert.Equal(t, boardChannelID, loaded.TargetId)
+	assert.Equal(t, linkPath, loaded.LinkUrl)
+
+	linkBookmark := &model.ChannelBookmark{
+		ChannelId:   channelID,
+		OwnerId:     userID,
+		DisplayName: "Plain link",
+		LinkUrl:     "https://example.com",
+		Type:        model.ChannelBookmarkLink,
+	}
+	linkSaved, err := ss.ChannelBookmark().Save(linkBookmark, true)
+	require.NoError(t, err)
+
+	var count int
+	err = s.GetMaster().Get(&count,
+		"SELECT COUNT(*) FROM channelbookmarks WHERE id = ? AND targetid IS NULL",
+		linkSaved.Id)
+	require.NoError(t, err)
+	assert.Equal(t, 1, count, "link bookmarks must persist SQL NULL for targetid")
+}

server/channels/store/storetest/channel_guard_store.go

@@ -0,0 +1,141 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestChannelGuardStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("SaveAndGetForChannel", func(t *testing.T) { testChannelGuardSaveAndGetForChannel(t, rctx, ss) })
+	t.Run("SaveIdempotentSamePlugin", func(t *testing.T) { testChannelGuardSaveIdempotentSamePlugin(t, rctx, ss) })
+	t.Run("SaveTwoPluginsSameChannel", func(t *testing.T) { testChannelGuardSaveTwoPluginsSameChannel(t, rctx, ss) })
+	t.Run("Delete", func(t *testing.T) { testChannelGuardDelete(t, rctx, ss) })
+	t.Run("DeleteRowsAffected", func(t *testing.T) { testChannelGuardDeleteRowsAffected(t, rctx, ss) })
+	t.Run("GetAll", func(t *testing.T) { testChannelGuardGetAll(t, rctx, ss) })
+}
+
+func testChannelGuardSaveAndGetForChannel(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	pluginID := "com.example.plugin-a"
+
+	guard := &store.ChannelGuard{
+		ChannelId: channelID,
+		PluginId:  pluginID,
+		CreatedAt: 1000,
+	}
+
+	err := ss.ChannelGuard().Save(rctx, guard)
+	require.NoError(t, err)
+
+	got, err := ss.ChannelGuard().GetForChannel(rctx, channelID)
+	require.NoError(t, err)
+	require.Len(t, got, 1)
+	assert.Equal(t, channelID, got[0].ChannelId)
+	assert.Equal(t, pluginID, got[0].PluginId)
+	assert.Equal(t, int64(1000), got[0].CreatedAt)
+}
+
+func testChannelGuardSaveIdempotentSamePlugin(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	pluginID := "com.example.plugin-a"
+
+	first := &store.ChannelGuard{ChannelId: channelID, PluginId: pluginID, CreatedAt: 1000}
+	require.NoError(t, ss.ChannelGuard().Save(rctx, first))
+
+	second := &store.ChannelGuard{ChannelId: channelID, PluginId: pluginID, CreatedAt: 2000}
+	require.NoError(t, ss.ChannelGuard().Save(rctx, second))
+
+	got, err := ss.ChannelGuard().GetForChannel(rctx, channelID)
+	require.NoError(t, err)
+	require.Len(t, got, 1, "second save should be a no-op (DO NOTHING)")
+	assert.Equal(t, int64(1000), got[0].CreatedAt, "original CreatedAt should be preserved")
+}
+
+func testChannelGuardSaveTwoPluginsSameChannel(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	pluginA := "com.example.plugin-a"
+	pluginB := "com.example.plugin-b"
+
+	require.NoError(t, ss.ChannelGuard().Save(rctx, &store.ChannelGuard{ChannelId: channelID, PluginId: pluginA, CreatedAt: 1000}))
+	require.NoError(t, ss.ChannelGuard().Save(rctx, &store.ChannelGuard{ChannelId: channelID, PluginId: pluginB, CreatedAt: 2000}))
+
+	got, err := ss.ChannelGuard().GetForChannel(rctx, channelID)
+	require.NoError(t, err)
+	require.Len(t, got, 2)
+
+	pluginIDs := []string{got[0].PluginId, got[1].PluginId}
+	assert.Contains(t, pluginIDs, pluginA)
+	assert.Contains(t, pluginIDs, pluginB)
+}
+
+func testChannelGuardDelete(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	pluginA := "com.example.plugin-a"
+	pluginB := "com.example.plugin-b"
+
+	require.NoError(t, ss.ChannelGuard().Save(rctx, &store.ChannelGuard{ChannelId: channelID, PluginId: pluginA, CreatedAt: 1000}))
+	require.NoError(t, ss.ChannelGuard().Save(rctx, &store.ChannelGuard{ChannelId: channelID, PluginId: pluginB, CreatedAt: 2000}))
+
+	n, err := ss.ChannelGuard().Delete(rctx, channelID, pluginA)
+	require.NoError(t, err)
+	assert.Equal(t, int64(1), n, "expected 1 row deleted")
+
+	got, err := ss.ChannelGuard().GetForChannel(rctx, channelID)
+	require.NoError(t, err)
+	require.Len(t, got, 1, "only plugin-A's row should be deleted")
+	assert.Equal(t, pluginB, got[0].PluginId)
+
+	// Deleting an already-removed (channel, plugin) pair is a no-op, not an error.
+	n, err = ss.ChannelGuard().Delete(rctx, channelID, pluginA)
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), n, "expected 0 rows deleted for already-removed row")
+}
+
+func testChannelGuardDeleteRowsAffected(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+	pluginA := "com.example.plugin-a"
+	pluginB := "com.example.plugin-b"
+
+	require.NoError(t, ss.ChannelGuard().Save(rctx, &store.ChannelGuard{ChannelId: channelID, PluginId: pluginA, CreatedAt: 1000}))
+
+	// Cross-plugin delete: pluginB has no claim on the channel; returns (0, nil).
+	n, err := ss.ChannelGuard().Delete(rctx, channelID, pluginB)
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), n, "cross-plugin delete must return 0 rows affected")
+
+	// pluginA's row must be untouched.
+	got, err := ss.ChannelGuard().GetForChannel(rctx, channelID)
+	require.NoError(t, err)
+	require.Len(t, got, 1, "pluginA row must remain after cross-plugin delete")
+	assert.Equal(t, pluginA, got[0].PluginId)
+}
+
+func testChannelGuardGetAll(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelA := model.NewId()
+	channelB := model.NewId()
+	pluginA := "com.example.plugin-a-" + model.NewId()
+	pluginB := "com.example.plugin-b-" + model.NewId()
+
+	require.NoError(t, ss.ChannelGuard().Save(rctx, &store.ChannelGuard{ChannelId: channelA, PluginId: pluginA, CreatedAt: 1000}))
+	require.NoError(t, ss.ChannelGuard().Save(rctx, &store.ChannelGuard{ChannelId: channelA, PluginId: pluginB, CreatedAt: 1100}))
+	require.NoError(t, ss.ChannelGuard().Save(rctx, &store.ChannelGuard{ChannelId: channelB, PluginId: pluginA, CreatedAt: 1200}))
+
+	all, err := ss.ChannelGuard().GetAll(rctx)
+	require.NoError(t, err)
+
+	count := 0
+	for _, g := range all {
+		if g.PluginId == pluginA || g.PluginId == pluginB {
+			count++
+		}
+	}
+	assert.Equal(t, 3, count, "expected 3 rows from this test fixture")
+}

server/channels/store/storetest/channel_join_request_store.go

@@ -0,0 +1,264 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestChannelJoinRequestStore(t *testing.T, _ request.CTX, ss store.Store) {
+	t.Run("Save inserts a pending row", testChannelJoinRequestSave(ss))
+	t.Run("Save rejects duplicate pending row", testChannelJoinRequestSaveDuplicatePending(ss))
+	t.Run("Save allows another pending row after withdrawal", testChannelJoinRequestSaveAfterWithdraw(ss))
+	t.Run("Get returns NotFound for unknown id", testChannelJoinRequestGetNotFound(ss))
+	t.Run("GetPendingForChannelAndUser only returns pending rows", testChannelJoinRequestGetPending(ss))
+	t.Run("GetForChannel paginates and filters by status", testChannelJoinRequestGetForChannel(ss))
+	t.Run("GetForUser paginates and filters by status", testChannelJoinRequestGetForUser(ss))
+	t.Run("Update transitions status and stores reviewer", testChannelJoinRequestUpdate(ss))
+	t.Run("CountPending only counts pending rows", testChannelJoinRequestCountPending(ss))
+}
+
+func newPendingRequest(channelId, userId string) *model.ChannelJoinRequest {
+	return &model.ChannelJoinRequest{
+		ChannelId: channelId,
+		UserId:    userId,
+		Message:   "please let me in",
+		Status:    model.ChannelJoinRequestStatusPending,
+	}
+}
+
+func testChannelJoinRequestSave(ss store.Store) func(*testing.T) {
+	return func(t *testing.T) {
+		channelId := model.NewId()
+		userId := model.NewId()
+
+		req, err := ss.ChannelJoinRequest().Save(newPendingRequest(channelId, userId))
+		require.NoError(t, err)
+		require.NotEmpty(t, req.Id)
+		assert.Equal(t, channelId, req.ChannelId)
+		assert.Equal(t, userId, req.UserId)
+		assert.Equal(t, model.ChannelJoinRequestStatusPending, req.Status)
+		assert.NotZero(t, req.CreateAt)
+		assert.Equal(t, req.CreateAt, req.UpdateAt)
+
+		fetched, err := ss.ChannelJoinRequest().Get(req.Id)
+		require.NoError(t, err)
+		assert.Equal(t, req.Id, fetched.Id)
+		assert.Equal(t, req.Message, fetched.Message)
+		assert.Equal(t, req.Status, fetched.Status)
+	}
+}
+
+func testChannelJoinRequestSaveDuplicatePending(ss store.Store) func(*testing.T) {
+	return func(t *testing.T) {
+		channelId := model.NewId()
+		userId := model.NewId()
+
+		_, err := ss.ChannelJoinRequest().Save(newPendingRequest(channelId, userId))
+		require.NoError(t, err)
+
+		_, err = ss.ChannelJoinRequest().Save(newPendingRequest(channelId, userId))
+		require.Error(t, err)
+		var conflict *store.ErrConflict
+		assert.ErrorAs(t, err, &conflict, "duplicate pending row must surface store.ErrConflict")
+	}
+}
+
+func testChannelJoinRequestSaveAfterWithdraw(ss store.Store) func(*testing.T) {
+	return func(t *testing.T) {
+		channelId := model.NewId()
+		userId := model.NewId()
+
+		first, err := ss.ChannelJoinRequest().Save(newPendingRequest(channelId, userId))
+		require.NoError(t, err)
+
+		first.Status = model.ChannelJoinRequestStatusWithdrawn
+		_, err = ss.ChannelJoinRequest().Update(first)
+		require.NoError(t, err)
+
+		// Allow the millisecond-resolution UpdateAt to advance.
+		time.Sleep(2 * time.Millisecond)
+
+		second, err := ss.ChannelJoinRequest().Save(newPendingRequest(channelId, userId))
+		require.NoError(t, err, "a new pending row must be insertable once the previous one is no longer pending")
+		assert.NotEqual(t, first.Id, second.Id)
+	}
+}
+
+func testChannelJoinRequestGetNotFound(ss store.Store) func(*testing.T) {
+	return func(t *testing.T) {
+		_, err := ss.ChannelJoinRequest().Get(model.NewId())
+		require.Error(t, err)
+		var nf *store.ErrNotFound
+		assert.ErrorAs(t, err, &nf)
+	}
+}
+
+func testChannelJoinRequestGetPending(ss store.Store) func(*testing.T) {
+	return func(t *testing.T) {
+		channelId := model.NewId()
+		userId := model.NewId()
+
+		_, err := ss.ChannelJoinRequest().GetPendingForChannelAndUser(channelId, userId)
+		require.Error(t, err, "must return NotFound when no row exists")
+
+		_, err = ss.ChannelJoinRequest().Save(newPendingRequest(channelId, userId))
+		require.NoError(t, err)
+
+		got, err := ss.ChannelJoinRequest().GetPendingForChannelAndUser(channelId, userId)
+		require.NoError(t, err)
+		assert.Equal(t, channelId, got.ChannelId)
+		assert.Equal(t, userId, got.UserId)
+		assert.Equal(t, model.ChannelJoinRequestStatusPending, got.Status)
+
+		got.Status = model.ChannelJoinRequestStatusWithdrawn
+		_, err = ss.ChannelJoinRequest().Update(got)
+		require.NoError(t, err)
+
+		_, err = ss.ChannelJoinRequest().GetPendingForChannelAndUser(channelId, userId)
+		require.Error(t, err, "withdrawn row must not be considered pending")
+	}
+}
+
+func testChannelJoinRequestGetForChannel(ss store.Store) func(*testing.T) {
+	return func(t *testing.T) {
+		channelId := model.NewId()
+
+		// Three pending requests across distinct users + one denied row for the
+		// same channel so we can prove the status filter actually filters.
+		for range 3 {
+			_, err := ss.ChannelJoinRequest().Save(newPendingRequest(channelId, model.NewId()))
+			require.NoError(t, err)
+			time.Sleep(2 * time.Millisecond)
+		}
+
+		denied := newPendingRequest(channelId, model.NewId())
+		saved, err := ss.ChannelJoinRequest().Save(denied)
+		require.NoError(t, err)
+		saved.Status = model.ChannelJoinRequestStatusDenied
+		saved.ReviewedBy = model.NewId()
+		saved.ReviewedAt = model.GetMillis()
+		saved.DenialReason = "policy mismatch"
+		_, err = ss.ChannelJoinRequest().Update(saved)
+		require.NoError(t, err)
+
+		rows, total, err := ss.ChannelJoinRequest().GetForChannel(channelId, model.GetChannelJoinRequestsOpts{PerPage: 10})
+		require.NoError(t, err)
+		assert.Len(t, rows, 3)
+		assert.Equal(t, int64(3), total)
+		for i := 1; i < len(rows); i++ {
+			assert.GreaterOrEqual(t, rows[i-1].CreateAt, rows[i].CreateAt, "list should be newest first")
+		}
+
+		rows, total, err = ss.ChannelJoinRequest().GetForChannel(channelId, model.GetChannelJoinRequestsOpts{Status: model.ChannelJoinRequestStatusDenied, PerPage: 10})
+		require.NoError(t, err)
+		assert.Equal(t, int64(1), total)
+		require.Len(t, rows, 1)
+		assert.Equal(t, "policy mismatch", rows[0].DenialReason)
+
+		rows, total, err = ss.ChannelJoinRequest().GetForChannel(channelId, model.GetChannelJoinRequestsOpts{PerPage: 2, Page: 0})
+		require.NoError(t, err)
+		assert.Len(t, rows, 2)
+		assert.Equal(t, int64(3), total, "TotalCount must not be truncated by paging")
+	}
+}
+
+func testChannelJoinRequestGetForUser(ss store.Store) func(*testing.T) {
+	return func(t *testing.T) {
+		userId := model.NewId()
+
+		for range 2 {
+			_, err := ss.ChannelJoinRequest().Save(newPendingRequest(model.NewId(), userId))
+			require.NoError(t, err)
+			time.Sleep(2 * time.Millisecond)
+		}
+
+		denied := newPendingRequest(model.NewId(), userId)
+		saved, err := ss.ChannelJoinRequest().Save(denied)
+		require.NoError(t, err)
+		saved.Status = model.ChannelJoinRequestStatusDenied
+		saved.ReviewedBy = model.NewId()
+		saved.ReviewedAt = model.GetMillis()
+		_, err = ss.ChannelJoinRequest().Update(saved)
+		require.NoError(t, err)
+
+		rows, total, err := ss.ChannelJoinRequest().GetForUser(userId, model.GetChannelJoinRequestsOpts{PerPage: 10})
+		require.NoError(t, err)
+		assert.Len(t, rows, 2)
+		assert.Equal(t, int64(2), total)
+
+		rows, total, err = ss.ChannelJoinRequest().GetForUser(userId, model.GetChannelJoinRequestsOpts{Status: model.ChannelJoinRequestStatusDenied, PerPage: 10})
+		require.NoError(t, err)
+		assert.Equal(t, int64(1), total)
+		assert.Len(t, rows, 1)
+	}
+}
+
+func testChannelJoinRequestUpdate(ss store.Store) func(*testing.T) {
+	return func(t *testing.T) {
+		req, err := ss.ChannelJoinRequest().Save(newPendingRequest(model.NewId(), model.NewId()))
+		require.NoError(t, err)
+		originalUpdateAt := req.UpdateAt
+
+		reviewerId := model.NewId()
+		reviewedAt := model.GetMillis() + 1
+		req.Status = model.ChannelJoinRequestStatusApproved
+		req.ReviewedBy = reviewerId
+		req.ReviewedAt = reviewedAt
+
+		// Allow UpdateAt to advance.
+		time.Sleep(2 * time.Millisecond)
+		updated, err := ss.ChannelJoinRequest().Update(req)
+		require.NoError(t, err)
+		assert.Equal(t, model.ChannelJoinRequestStatusApproved, updated.Status)
+		assert.Equal(t, reviewerId, updated.ReviewedBy)
+		assert.Equal(t, reviewedAt, updated.ReviewedAt)
+		assert.Greater(t, updated.UpdateAt, originalUpdateAt)
+
+		fetched, err := ss.ChannelJoinRequest().Get(req.Id)
+		require.NoError(t, err)
+		assert.Equal(t, model.ChannelJoinRequestStatusApproved, fetched.Status)
+		assert.Equal(t, reviewerId, fetched.ReviewedBy)
+	}
+}
+
+func testChannelJoinRequestCountPending(ss store.Store) func(*testing.T) {
+	return func(t *testing.T) {
+		channelId := model.NewId()
+
+		count, err := ss.ChannelJoinRequest().CountPending(channelId)
+		require.NoError(t, err)
+		assert.Equal(t, int64(0), count)
+
+		for range 4 {
+			_, err = ss.ChannelJoinRequest().Save(newPendingRequest(channelId, model.NewId()))
+			require.NoError(t, err)
+		}
+
+		count, err = ss.ChannelJoinRequest().CountPending(channelId)
+		require.NoError(t, err)
+		assert.Equal(t, int64(4), count)
+
+		// Withdraw one — count should drop by 1.
+		reqs, _, err := ss.ChannelJoinRequest().GetForChannel(channelId, model.GetChannelJoinRequestsOpts{PerPage: 10})
+		require.NoError(t, err)
+		require.NotEmpty(t, reqs)
+		first := reqs[0]
+		first.Status = model.ChannelJoinRequestStatusWithdrawn
+		_, err = ss.ChannelJoinRequest().Update(first)
+		require.NoError(t, err)
+
+		count, err = ss.ChannelJoinRequest().CountPending(channelId)
+		require.NoError(t, err)
+		assert.Equal(t, int64(3), count)
+	}
+}

server/channels/store/storetest/channel_member_history_store.go

@@ -0,0 +1,877 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"math"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestChannelMemberHistoryStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("TestLogJoinEvent", func(t *testing.T) { testLogJoinEvent(t, rctx, ss) })
+	t.Run("TestLogLeaveEvent", func(t *testing.T) { testLogLeaveEvent(t, rctx, ss) })
+	t.Run("TestGetEverMembersInChannel", func(t *testing.T) { testGetEverMembersInChannel(t, rctx, ss) })
+	t.Run("TestGetUsersInChannelAtChannelMemberHistory", func(t *testing.T) { testGetUsersInChannelAtChannelMemberHistory(t, rctx, ss) })
+	t.Run("TestGetUsersInChannelAtChannelMembers", func(t *testing.T) { testGetUsersInChannelAtChannelMembers(t, rctx, ss) })
+	t.Run("TestGetChannelsWithActivityDuring", func(t *testing.T) { testGetChannelsWithActivityDuring(t, rctx, ss) })
+	t.Run("TestPermanentDeleteBatch", func(t *testing.T) { testPermanentDeleteBatch(t, rctx, ss) })
+	t.Run("TestPermanentDeleteBatchForRetentionPolicies", func(t *testing.T) { testPermanentDeleteBatchForRetentionPolicies(t, rctx, ss) })
+	t.Run("TestGetChannelsLeftSince", func(t *testing.T) { testGetChannelsLeftSince(t, rctx, ss) })
+	t.Run("TestDeleteOrphanedRows", func(t *testing.T) { testDeleteOrphanedRows(t, rctx, ss) })
+	t.Run("TestGetMembershipChanges", func(t *testing.T) { testGetMembershipChanges(t, rctx, ss) })
+}
+
+func testGetEverMembersInChannel(t *testing.T, rctx request.CTX, ss store.Store) {
+	channel := &model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Display " + model.NewId(),
+		Name:        NewTestID(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, err := ss.Channel().Save(rctx, channel, -1)
+	require.NoError(t, err)
+
+	otherChannel := &model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Display " + model.NewId(),
+		Name:        NewTestID(),
+		Type:        model.ChannelTypeOpen,
+	}
+	otherChannel, err = ss.Channel().Save(rctx, otherChannel, -1)
+	require.NoError(t, err)
+
+	newUser := func() string {
+		user := &model.User{
+			Email:    MakeEmail(),
+			Nickname: model.NewId(),
+			Username: model.NewUsername(),
+		}
+		created, saveErr := ss.User().Save(rctx, user)
+		require.NoError(t, saveErr)
+		return created.Id
+	}
+
+	user1 := newUser()
+	user2 := newUser()
+	user3 := newUser()
+	user4 := newUser()
+	nonMember := newUser()
+	wrongChannelOnly := newUser()
+
+	// Keep this deterministic and above the legacy 1000ms timestamps used
+	// in fallback-path tests so it does not affect hasDataAtOrBefore logic.
+	const baseTime int64 = 1700000000000
+	// user1 has historical rows (joined, left, and rejoined) and should be returned once.
+	require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(user1, channel.Id, baseTime))
+	require.NoError(t, ss.ChannelMemberHistory().LogLeaveEvent(rctx, user1, channel.Id, baseTime+100))
+	require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(user1, channel.Id, baseTime+200))
+	// other users are simple joins.
+	require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(user2, channel.Id, baseTime))
+	require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(user3, channel.Id, baseTime))
+	require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(user4, channel.Id, baseTime))
+	// user on a different channel only should not be returned.
+	require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(wrongChannelOnly, otherChannel.Id, baseTime))
+
+	// Empty candidates should return no rows.
+	results, err := ss.ChannelMemberHistory().GetEverMembersInChannel(channel.Id, nil)
+	require.NoError(t, err)
+	require.Empty(t, results)
+
+	// Filter to known candidates in this channel and ensure each user appears once.
+	candidates := []string{user1, user2, user3, user4, nonMember, wrongChannelOnly}
+	allResults, err := ss.ChannelMemberHistory().GetEverMembersInChannel(channel.Id, candidates)
+	require.NoError(t, err)
+	assert.ElementsMatch(t, []string{user1, user2, user3, user4}, allResults)
+}
+
+func testLogJoinEvent(t *testing.T, rctx request.CTX, ss store.Store) {
+	// create a test channel
+	ch := model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Display " + model.NewId(),
+		Name:        NewTestID(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, err := ss.Channel().Save(rctx, &ch, -1)
+	require.NoError(t, err)
+
+	// and a test user
+	user := model.User{
+		Email:    MakeEmail(),
+		Nickname: model.NewId(),
+		Username: model.NewUsername(),
+	}
+	userPtr, err := ss.User().Save(rctx, &user)
+	require.NoError(t, err)
+	user = *userPtr
+
+	// log a join event
+	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, model.GetMillis())
+	assert.NoError(t, err)
+}
+
+func testLogLeaveEvent(t *testing.T, rctx request.CTX, ss store.Store) {
+	// create a test channel
+	ch := model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Display " + model.NewId(),
+		Name:        NewTestID(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, err := ss.Channel().Save(rctx, &ch, -1)
+	require.NoError(t, err)
+
+	// and a test user
+	user := model.User{
+		Email:    MakeEmail(),
+		Nickname: model.NewId(),
+		Username: model.NewUsername(),
+	}
+	userPtr, err := ss.User().Save(rctx, &user)
+	require.NoError(t, err)
+	user = *userPtr
+
+	// log a join event, followed by a leave event
+	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, model.GetMillis())
+	assert.NoError(t, err)
+
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, user.Id, channel.Id, model.GetMillis())
+	assert.NoError(t, err)
+}
+
+func testGetChannelsWithActivityDuring(t *testing.T, rctx request.CTX, ss store.Store) {
+	// Need to wait to make sure channels and posts have nothing in them for this test.
+	time.Sleep(101 * time.Millisecond)
+
+	// create three test channels
+	ch1 := &model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Display " + model.NewId(),
+		Name:        model.NewId(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel1, err := ss.Channel().Save(rctx, ch1, -1)
+	require.NoError(t, err)
+
+	// channel2 will have no activity until case 6 (shouldn't show up until then)
+	ch2 := &model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Display " + model.NewId(),
+		Name:        model.NewId(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel2, err := ss.Channel().Save(rctx, ch2, -1)
+	require.NoError(t, err)
+
+	// and two test users
+	user1 := model.User{
+		Email:    MakeEmail(),
+		Nickname: model.NewId(),
+		Username: model.NewUsername(),
+	}
+	userPtr, err := ss.User().Save(rctx, &user1)
+	require.NoError(t, err)
+	user1 = *userPtr
+
+	user2 := model.User{
+		Email:    MakeEmail(),
+		Nickname: model.NewId(),
+		Username: model.NewUsername(),
+	}
+	userPtr, err = ss.User().Save(rctx, &user2)
+	require.NoError(t, err)
+	user2 = *userPtr
+
+	now := model.GetMillis()
+	originalNow := now
+
+	// user2 joins channel2 before test
+	err = ss.ChannelMemberHistory().LogJoinEvent(user2.Id, channel2.Id, now-2000)
+	require.NoError(t, err)
+
+	// case 7: assert no activity for time period before channel activity
+	channelIds, err := ss.ChannelMemberHistory().GetChannelsWithActivityDuring(originalNow-100, originalNow)
+	require.NoError(t, err)
+	assert.Empty(t, channelIds)
+
+	// case 1: user1 was in channel before period, doesn't show activity
+	err = ss.ChannelMemberHistory().LogJoinEvent(user1.Id, channel1.Id, now-1100)
+	require.NoError(t, err)
+
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now, now+1000)
+	require.NoError(t, err)
+	assert.Empty(t, channelIds)
+
+	// case 2: user1 leaves, shows activity
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, user1.Id, channel1.Id, now+1)
+	require.NoError(t, err)
+
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now, now+1000)
+	require.NoError(t, err)
+	assert.Equal(t, channelIds, []string{channel1.Id})
+
+	// case 3: user1 joins, shows activity
+	err = ss.ChannelMemberHistory().LogJoinEvent(user1.Id, channel1.Id, now+2)
+	require.NoError(t, err)
+
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now+2, now+1000)
+	require.NoError(t, err)
+	assert.Equal(t, channelIds, []string{channel1.Id})
+
+	// case 4: new post shows activity
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now+3, now+1000)
+	require.NoError(t, err)
+	assert.Empty(t, channelIds)
+
+	post := &model.Post{
+		ChannelId: channel1.Id,
+		Message:   "root post",
+		UserId:    user1.Id,
+		CreateAt:  now + 4,
+		UpdateAt:  now + 4,
+	}
+	post, err = ss.Post().Save(rctx, post)
+	require.NoError(t, err)
+
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now+3, now+1000)
+	require.NoError(t, err)
+	assert.Equal(t, channelIds, []string{channel1.Id})
+
+	// case 5: update shows activity
+	// need to wait because update uses getMillis
+	time.Sleep(10 * time.Millisecond)
+	now = model.GetMillis()
+
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now-1, now+1000)
+	require.NoError(t, err)
+	assert.Empty(t, channelIds)
+
+	newPost := post.Clone()
+	newPost.Message = "edited message"
+	_, err = ss.Post().Update(rctx, newPost, post)
+	require.NoError(t, err)
+
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now-1, now+1000)
+	require.NoError(t, err)
+	assert.Equal(t, channelIds, []string{channel1.Id})
+
+	// case 6: get both activity from posts and from join/leave;
+	//  - also, sql deduplicates two channel1 results (from post and channel history tables)
+	time.Sleep(1 * time.Millisecond)
+	now = model.GetMillis()
+
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now, now+1000)
+	require.NoError(t, err)
+	assert.Empty(t, channelIds)
+
+	post2 := &model.Post{
+		ChannelId: channel1.Id,
+		Message:   "root post",
+		UserId:    user1.Id,
+		CreateAt:  now + 11,
+		UpdateAt:  now + 11,
+	}
+	_, err = ss.Post().Save(rctx, post2)
+	require.NoError(t, err)
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, user1.Id, channel1.Id, now+12)
+	require.NoError(t, err)
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, user2.Id, channel2.Id, now+13)
+	require.NoError(t, err)
+
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now+10, now+1000)
+	require.NoError(t, err)
+	assert.ElementsMatch(t, channelIds, []string{channel1.Id, channel2.Id})
+
+	// case 7: still no activity for period before tests
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(originalNow-100, originalNow)
+	require.NoError(t, err)
+	assert.Empty(t, channelIds)
+
+	// case 8: no activity for period after tests
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(now+100, now+1000)
+	require.NoError(t, err)
+	assert.Empty(t, channelIds)
+}
+
+func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, rctx request.CTX, ss store.Store) {
+	// create a test channel
+	ch := &model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Display " + model.NewId(),
+		Name:        NewTestID(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, err := ss.Channel().Save(rctx, ch, -1)
+	require.NoError(t, err)
+
+	// and a test user
+	user := model.User{
+		Email:    MakeEmail(),
+		Nickname: model.NewId(),
+		Username: model.NewUsername(),
+	}
+	userPtr, err := ss.User().Save(rctx, &user)
+	require.NoError(t, err)
+	user = *userPtr
+
+	// the user was previously in the channel a long time ago, before the export period starts
+	// the existence of this record makes it look like the MessageExport feature has been active for awhile, and prevents
+	// us from looking in the ChannelMembers table for data that isn't found in the ChannelMemberHistory table
+	leaveTime := model.GetMillis() - 20000
+	joinTime := leaveTime - 10000
+	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, joinTime)
+	require.NoError(t, err)
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, user.Id, channel.Id, leaveTime)
+	require.NoError(t, err)
+
+	// log a join event
+	leaveTime = model.GetMillis()
+	joinTime = leaveTime - 10000
+	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, joinTime)
+	require.NoError(t, err)
+
+	// case 1: user joins and leaves the channel before the export period begins
+	channelMembers, err := ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-500, joinTime-100, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Empty(t, channelMembers)
+
+	// case 2: user joins the channel after the export period begins, but has not yet left the channel when the export period ends
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-100, joinTime+500, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, joinTime, channelMembers[0].JoinTime)
+	assert.Nil(t, channelMembers[0].LeaveTime)
+
+	// case 3: user joins the channel before the export period begins, but has not yet left the channel when the export period ends
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+100, joinTime+500, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, joinTime, channelMembers[0].JoinTime)
+	assert.Nil(t, channelMembers[0].LeaveTime)
+
+	// add a leave time for the user
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, user.Id, channel.Id, leaveTime)
+	require.NoError(t, err)
+
+	// case 4: user joins the channel before the export period begins, but has not yet left the channel when the export period ends
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+100, leaveTime-100, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, joinTime, channelMembers[0].JoinTime)
+	assert.Equal(t, leaveTime, *channelMembers[0].LeaveTime)
+
+	// case 5: user joins the channel after the export period begins, and leaves the channel before the export period ends
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-100, leaveTime+100, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, joinTime, channelMembers[0].JoinTime)
+	assert.Equal(t, leaveTime, *channelMembers[0].LeaveTime)
+
+	// case 6: user has joined and left the channel long before the export period begins
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(leaveTime+100, leaveTime+200, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Empty(t, channelMembers)
+}
+
+func testGetUsersInChannelAtChannelMembers(t *testing.T, rctx request.CTX, ss store.Store) {
+	// create a test channel
+	channel := &model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Display " + model.NewId(),
+		Name:        NewTestID(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, err := ss.Channel().Save(rctx, channel, -1)
+	require.NoError(t, err)
+
+	// and a test user
+	user := model.User{
+		Email:    MakeEmail(),
+		Nickname: model.NewId(),
+		Username: model.NewUsername(),
+	}
+	userPtr, err := ss.User().Save(rctx, &user)
+	require.NoError(t, err)
+	user = *userPtr
+
+	// clear any existing ChannelMemberHistory data that might interfere with our test
+	tableDataTruncated := false
+	for !tableDataTruncated {
+		var count int64
+		count, _, err = ss.ChannelMemberHistory().PermanentDeleteBatchForRetentionPolicies(model.RetentionPolicyBatchConfigs{
+			Now:                 0,
+			GlobalPolicyEndTime: model.GetMillis(),
+			Limit:               1000,
+		}, model.RetentionPolicyCursor{})
+		require.NoError(t, err, "Failed to truncate ChannelMemberHistory contents")
+		tableDataTruncated = count == int64(0)
+	}
+
+	// in this test, we're pretending that Message Export was not activated during the export period, so there's no data
+	// available in the ChannelMemberHistory table. Instead, we'll fall back to the ChannelMembers table for a rough approximation
+	joinTime := int64(1000)
+	leaveTime := joinTime + 5000
+	_, err = ss.Channel().SaveMember(rctx, &model.ChannelMember{
+		ChannelId:   channel.Id,
+		UserId:      user.Id,
+		NotifyProps: model.GetDefaultChannelNotifyProps(),
+	})
+	require.NoError(t, err)
+
+	// in every single case, the user will be included in the export, because ChannelMembers says they were in the channel at some point in
+	// the past, even though the time that they were actually in the channel doesn't necessarily overlap with the export period
+
+	// case 1: user joins and leaves the channel before the export period begins
+	channelMembers, err := ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-500, joinTime-100, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, joinTime-500, channelMembers[0].JoinTime)
+	assert.Equal(t, joinTime-100, *channelMembers[0].LeaveTime)
+
+	// case 2: user joins the channel after the export period begins, but has not yet left the channel when the export period ends
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-100, joinTime+500, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, joinTime-100, channelMembers[0].JoinTime)
+	assert.Equal(t, joinTime+500, *channelMembers[0].LeaveTime)
+
+	// case 3: user joins the channel before the export period begins, but has not yet left the channel when the export period ends
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+100, joinTime+500, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, joinTime+100, channelMembers[0].JoinTime)
+	assert.Equal(t, joinTime+500, *channelMembers[0].LeaveTime)
+
+	// case 4: user joins the channel before the export period begins, but has not yet left the channel when the export period ends
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+100, leaveTime-100, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, joinTime+100, channelMembers[0].JoinTime)
+	assert.Equal(t, leaveTime-100, *channelMembers[0].LeaveTime)
+
+	// case 5: user joins the channel after the export period begins, and leaves the channel before the export period ends
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-100, leaveTime+100, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, joinTime-100, channelMembers[0].JoinTime)
+	assert.Equal(t, leaveTime+100, *channelMembers[0].LeaveTime)
+
+	// case 6: user has joined and left the channel long before the export period begins
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(leaveTime+100, leaveTime+200, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
+	assert.Equal(t, user.Id, channelMembers[0].UserId)
+	assert.Equal(t, user.Email, channelMembers[0].UserEmail)
+	assert.Equal(t, user.Username, channelMembers[0].Username)
+	assert.Equal(t, leaveTime+100, channelMembers[0].JoinTime)
+	assert.Equal(t, leaveTime+200, *channelMembers[0].LeaveTime)
+}
+
+func testPermanentDeleteBatch(t *testing.T, rctx request.CTX, ss store.Store) {
+	// create a test channel
+	channel := &model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Display " + model.NewId(),
+		Name:        NewTestID(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, err := ss.Channel().Save(rctx, channel, -1)
+	require.NoError(t, err)
+
+	// and two test users
+	user := model.User{
+		Email:    MakeEmail(),
+		Nickname: model.NewId(),
+		Username: model.NewUsername(),
+	}
+	userPtr, err := ss.User().Save(rctx, &user)
+	require.NoError(t, err)
+	user = *userPtr
+
+	user2 := model.User{
+		Email:    MakeEmail(),
+		Nickname: model.NewId(),
+		Username: model.NewUsername(),
+	}
+	user2Ptr, err := ss.User().Save(rctx, &user2)
+	require.NoError(t, err)
+	user2 = *user2Ptr
+
+	// user1 joins and leaves the channel
+	leaveTime := model.GetMillis()
+	joinTime := leaveTime - 10000
+	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, joinTime)
+	require.NoError(t, err)
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, user.Id, channel.Id, leaveTime)
+	require.NoError(t, err)
+
+	// user2 joins the channel but never leaves
+	err = ss.ChannelMemberHistory().LogJoinEvent(user2.Id, channel.Id, joinTime)
+	require.NoError(t, err)
+
+	// in between the join time and the leave time, both users were members of the channel
+	channelMembers, err := ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+10, leaveTime-10, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 2)
+
+	// the permanent delete should delete at least one record
+	rowsDeleted, _, err := ss.ChannelMemberHistory().PermanentDeleteBatchForRetentionPolicies(model.RetentionPolicyBatchConfigs{
+		Now:                 0,
+		GlobalPolicyEndTime: leaveTime + 1,
+		Limit:               math.MaxInt64,
+	}, model.RetentionPolicyCursor{})
+	require.NoError(t, err)
+	assert.NotEqual(t, int64(0), rowsDeleted)
+
+	// after the delete, there should be one less member in the channel
+	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+10, leaveTime-10, []string{channel.Id})
+	require.NoError(t, err)
+	assert.Len(t, channelMembers, 1)
+	assert.Equal(t, user2.Id, channelMembers[0].UserId)
+}
+
+func testPermanentDeleteBatchForRetentionPolicies(t *testing.T, rctx request.CTX, ss store.Store) {
+	const limit = 1000
+	team, err := ss.Team().Save(&model.Team{
+		DisplayName: "DisplayName",
+		Name:        "team" + model.NewId(),
+		Email:       MakeEmail(),
+		Type:        model.TeamOpen,
+	})
+	require.NoError(t, err)
+	channel, err := ss.Channel().Save(rctx, &model.Channel{
+		TeamId:      team.Id,
+		DisplayName: "DisplayName",
+		Name:        "channel" + model.NewId(),
+		Type:        model.ChannelTypeOpen,
+	}, -1)
+	require.NoError(t, err)
+	userID := model.NewId()
+
+	joinTime := int64(1000)
+	leaveTime := int64(1500)
+	err = ss.ChannelMemberHistory().LogJoinEvent(userID, channel.Id, joinTime)
+	require.NoError(t, err)
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, userID, channel.Id, leaveTime)
+	require.NoError(t, err)
+
+	channelPolicy, err := ss.RetentionPolicy().Save(&model.RetentionPolicyWithTeamAndChannelIDs{
+		RetentionPolicy: model.RetentionPolicy{
+			DisplayName:      "DisplayName",
+			PostDurationDays: new(int64(30)),
+		},
+		ChannelIDs: []string{channel.Id},
+	})
+	require.NoError(t, err)
+
+	nowMillis := leaveTime + *channelPolicy.PostDurationDays*model.DayInMilliseconds + 1
+	_, _, err = ss.ChannelMemberHistory().PermanentDeleteBatchForRetentionPolicies(model.RetentionPolicyBatchConfigs{
+		Now:                 nowMillis,
+		GlobalPolicyEndTime: 0,
+		Limit:               limit,
+	}, model.RetentionPolicyCursor{})
+	require.NoError(t, err)
+	result, err := ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime, leaveTime, []string{channel.Id})
+	require.NoError(t, err)
+	require.Empty(t, result, "history should have been deleted by channel policy")
+	rows, err := ss.RetentionPolicy().GetIdsForDeletionByTableName("ChannelMemberHistory", 1000)
+	require.NoError(t, err)
+	require.Equal(t, 0, len(rows))
+}
+
+func testGetChannelsLeftSince(t *testing.T, rctx request.CTX, ss store.Store) {
+	team, err := ss.Team().Save(&model.Team{
+		DisplayName: "DisplayName",
+		Name:        "team" + model.NewId(),
+		Email:       MakeEmail(),
+		Type:        model.TeamOpen,
+	})
+	require.NoError(t, err)
+	channel, err := ss.Channel().Save(rctx, &model.Channel{
+		TeamId:      team.Id,
+		DisplayName: "DisplayName",
+		Name:        "channel" + model.NewId(),
+		Type:        model.ChannelTypeOpen,
+	}, -1)
+	require.NoError(t, err)
+
+	userID := model.NewId()
+
+	joinTime := int64(1000)
+	err = ss.ChannelMemberHistory().LogJoinEvent(userID, channel.Id, joinTime)
+	require.NoError(t, err)
+
+	// has not left
+	ids, err := ss.ChannelMemberHistory().GetChannelsLeftSince(userID, joinTime)
+	require.NoError(t, err)
+	assert.Empty(t, ids)
+
+	// left
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, userID, channel.Id, joinTime+100)
+	require.NoError(t, err)
+	ids, err = ss.ChannelMemberHistory().GetChannelsLeftSince(userID, joinTime+100)
+	require.NoError(t, err)
+	assert.Equal(t, []string{channel.Id}, ids)
+	ids, err = ss.ChannelMemberHistory().GetChannelsLeftSince(userID, joinTime+200)
+	require.NoError(t, err)
+	assert.Empty(t, ids)
+
+	// joined and left again.
+	err = ss.ChannelMemberHistory().LogJoinEvent(userID, channel.Id, joinTime+200)
+	require.NoError(t, err)
+	err = ss.ChannelMemberHistory().LogLeaveEvent(rctx, userID, channel.Id, joinTime+300)
+	require.NoError(t, err)
+	// should be same for both time stamps
+	ids, err = ss.ChannelMemberHistory().GetChannelsLeftSince(userID, joinTime+100)
+	require.NoError(t, err)
+	assert.Equal(t, []string{channel.Id}, ids)
+	ids, err = ss.ChannelMemberHistory().GetChannelsLeftSince(userID, joinTime+300)
+	require.NoError(t, err)
+	assert.Equal(t, []string{channel.Id}, ids)
+}
+
+func testDeleteOrphanedRows(t *testing.T, rctx request.CTX, ss store.Store) {
+	// Create a channel
+	channelToKeep := &model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "Channel to keep",
+		Name:        model.NewId(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channelToKeep, err := ss.Channel().Save(rctx, channelToKeep, -1)
+	require.NoError(t, err)
+
+	// Create a user
+	user := model.User{
+		Email:    MakeEmail(),
+		Nickname: model.NewId(),
+		Username: model.NewUsername(),
+	}
+	userPtr, err := ss.User().Save(rctx, &user)
+	require.NoError(t, err)
+	user = *userPtr
+
+	// Add user to channel (via channel member history)
+	joinTime := model.GetMillis()
+	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channelToKeep.Id, joinTime)
+	require.NoError(t, err)
+
+	// Create multiple orphaned channel member history entries
+	// We'll use an ID that doesn't exist in the Channels table
+	nonExistentChannelId := model.NewId()
+
+	// Create 3 orphaned entries
+	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, nonExistentChannelId, joinTime)
+	require.NoError(t, err)
+
+	err = ss.ChannelMemberHistory().LogJoinEvent(model.NewId(), nonExistentChannelId, joinTime+100)
+	require.NoError(t, err)
+
+	err = ss.ChannelMemberHistory().LogJoinEvent(model.NewId(), nonExistentChannelId, joinTime+200)
+	require.NoError(t, err)
+
+	// Verify the data is setup correctly
+	channelIds, err := ss.ChannelMemberHistory().GetChannelsWithActivityDuring(joinTime-100, joinTime+300)
+	require.NoError(t, err)
+	assert.Contains(t, channelIds, channelToKeep.Id, "Channel to keep should still have history")
+	assert.Contains(t, channelIds, nonExistentChannelId, "Orphaned channel should still have history")
+
+	// Test with limit of 0 (should delete nothing)
+	deletedCount, err := ss.ChannelMemberHistory().DeleteOrphanedRows(0)
+	require.NoError(t, err)
+	require.Equal(t, int64(0), deletedCount, "Should delete nothing with limit of 0")
+
+	// Verify the data is unchanged
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(joinTime-100, joinTime+300)
+	require.NoError(t, err)
+	assert.Contains(t, channelIds, channelToKeep.Id, "Channel to keep should still have history")
+	assert.Contains(t, channelIds, nonExistentChannelId, "Orphaned channel should still have history")
+
+	// Test limit parameter by deleting only 2 of the 3 orphaned rows
+	deletedCount, err = ss.ChannelMemberHistory().DeleteOrphanedRows(2)
+	require.NoError(t, err)
+	require.Equal(t, int64(2), deletedCount, "Should have deleted exactly 2 orphaned rows due to limit")
+
+	// Delete the remaining orphaned row
+	deletedCount, err = ss.ChannelMemberHistory().DeleteOrphanedRows(100)
+	require.NoError(t, err)
+	require.Equal(t, int64(1), deletedCount, "Should have deleted the remaining orphaned row")
+
+	// Verify the orphaned entries are removed and valid entries remain
+	channelIds, err = ss.ChannelMemberHistory().GetChannelsWithActivityDuring(joinTime-100, joinTime+300)
+	require.NoError(t, err)
+	assert.Contains(t, channelIds, channelToKeep.Id, "Channel to keep should still have history")
+	assert.NotContains(t, channelIds, nonExistentChannelId, "Orphaned channel should not have history")
+
+	// Calling it again should delete nothing since orphans are gone
+	deletedCount, err = ss.ChannelMemberHistory().DeleteOrphanedRows(100)
+	require.NoError(t, err)
+	require.Equal(t, int64(0), deletedCount, "No rows should be deleted when no orphans exist")
+}
+
+func testGetMembershipChanges(t *testing.T, rctx request.CTX, ss store.Store) {
+	ch := model.Channel{
+		TeamId:      model.NewId(),
+		DisplayName: "GetMembershipChanges",
+		Name:        NewTestID(),
+		Type:        model.ChannelTypeOpen,
+	}
+	channel, nErr := ss.Channel().Save(rctx, &ch, 100)
+	require.NoError(t, nErr)
+
+	user1 := model.NewId()
+	user2 := model.NewId()
+	user3 := model.NewId()
+
+	// Set up timeline:
+	// t=1000: user1 joins
+	// t=2000: user2 joins
+	// t=3000: user3 joins
+	// t=4000: user1 leaves
+	// t=5000: user2 leaves
+	require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(user1, channel.Id, 1000))
+	require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(user2, channel.Id, 2000))
+	require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(user3, channel.Id, 3000))
+	require.NoError(t, ss.ChannelMemberHistory().LogLeaveEvent(rctx, user1, channel.Id, 4000))
+	require.NoError(t, ss.ChannelMemberHistory().LogLeaveEvent(rctx, user2, channel.Id, 5000))
+
+	t.Run("returns all events since timestamp zero", func(t *testing.T) {
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(channel.Id, 0, 100)
+		require.NoError(t, err)
+		assert.Len(t, results, 3, "should return all 3 users' history rows")
+	})
+
+	t.Run("filters by since timestamp - joins only", func(t *testing.T) {
+		// since=2500: user3 joined at 3000 (>=2500), user1 left at 4000 (>=2500), user2 left at 5000 (>=2500)
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(channel.Id, 2500, 100)
+		require.NoError(t, err)
+		assert.Len(t, results, 3, "user3 join>=2500, user1 leave>=2500, user2 leave>=2500")
+	})
+
+	t.Run("inclusive boundary includes events at exact cursor timestamp", func(t *testing.T) {
+		// since=3000: user3 joined at exactly 3000, should be included (GtOrEq)
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(channel.Id, 3000, 100)
+		require.NoError(t, err)
+		userIDs := make(map[string]bool)
+		for _, r := range results {
+			userIDs[r.UserId] = true
+		}
+		assert.True(t, userIDs[user3], "user3 joined at exactly since=3000, should be included")
+		assert.True(t, userIDs[user1], "user1 left at 4000 >= 3000")
+		assert.True(t, userIDs[user2], "user2 left at 5000 >= 3000")
+	})
+
+	t.Run("filters by since timestamp - leaves only", func(t *testing.T) {
+		// since=3500: user1 left at 4000, user2 left at 5000; user3 joined at 3000 (not > 3500)
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(channel.Id, 3500, 100)
+		require.NoError(t, err)
+		assert.Len(t, results, 2, "only user1 and user2 have events after 3500")
+	})
+
+	t.Run("respects limit parameter", func(t *testing.T) {
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(channel.Id, 0, 2)
+		require.NoError(t, err)
+		assert.Len(t, results, 2, "should respect limit of 2")
+	})
+
+	t.Run("returns empty for unknown channel", func(t *testing.T) {
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(model.NewId(), 0, 100)
+		require.NoError(t, err)
+		assert.Empty(t, results)
+	})
+
+	t.Run("returns empty when since is beyond all events", func(t *testing.T) {
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(channel.Id, 999999, 100)
+		require.NoError(t, err)
+		assert.Empty(t, results)
+	})
+
+	t.Run("results are ordered by greatest event time ascending", func(t *testing.T) {
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(channel.Id, 0, 100)
+		require.NoError(t, err)
+		require.Len(t, results, 3)
+
+		// Effective event times: user1=max(1000,4000)=4000, user2=max(2000,5000)=5000, user3=max(3000,0)=3000
+		// Sorted ASC: user3(3000), user1(4000), user2(5000)
+		assert.Equal(t, user3, results[0].UserId, "user3 should be first (effective time 3000)")
+		assert.Equal(t, user1, results[1].UserId, "user1 should be second (effective time 4000)")
+		assert.Equal(t, user2, results[2].UserId, "user2 should be third (effective time 5000)")
+	})
+
+	t.Run("null LeaveTime handled correctly", func(t *testing.T) {
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(channel.Id, 0, 100)
+		require.NoError(t, err)
+
+		for _, r := range results {
+			if r.UserId == user3 {
+				assert.Nil(t, r.LeaveTime, "user3 should have nil LeaveTime")
+			}
+			if r.UserId == user1 {
+				require.NotNil(t, r.LeaveTime)
+				assert.Equal(t, int64(4000), *r.LeaveTime)
+			}
+		}
+	})
+
+	t.Run("join-leave-rejoin cycle returns latest row", func(t *testing.T) {
+		// user1 rejoins at t=6000
+		require.NoError(t, ss.ChannelMemberHistory().LogJoinEvent(user1, channel.Id, 6000))
+
+		// since=0 should now return 4 rows (user1 has 2 history rows, user2 has 1, user3 has 1)
+		results, err := ss.ChannelMemberHistory().GetMembershipChanges(channel.Id, 0, 100)
+		require.NoError(t, err)
+		assert.Len(t, results, 4, "user1 now has 2 history rows")
+
+		// The rejoined row (JoinTime=6000, LeaveTime=nil) should be the last one
+		lastResult := results[len(results)-1]
+		assert.Equal(t, user1, lastResult.UserId)
+		assert.Equal(t, int64(6000), lastResult.JoinTime)
+		assert.Nil(t, lastResult.LeaveTime, "rejoin should have nil LeaveTime")
+	})
+}

server/channels/store/storetest/cluster_discovery_store.go

@@ -0,0 +1,157 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestClusterDiscoveryStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("", func(t *testing.T) { testClusterDiscoveryStore(t, rctx, ss) })
+	t.Run("Delete", func(t *testing.T) { testClusterDiscoveryStoreDelete(t, rctx, ss) })
+	t.Run("LastPing", func(t *testing.T) { testClusterDiscoveryStoreLastPing(t, rctx, ss) })
+	t.Run("Exists", func(t *testing.T) { testClusterDiscoveryStoreExists(t, rctx, ss) })
+	t.Run("ClusterDiscoveryGetStore", func(t *testing.T) { testClusterDiscoveryGetStore(t, rctx, ss) })
+}
+
+func testClusterDiscoveryStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	discovery := &model.ClusterDiscovery{
+		ClusterName: "cluster_name",
+		Hostname:    "hostname" + model.NewId(),
+		Type:        "test_test",
+	}
+
+	err := ss.ClusterDiscovery().Save(discovery)
+	require.NoError(t, err)
+
+	err = ss.ClusterDiscovery().Cleanup()
+	require.NoError(t, err)
+}
+
+func testClusterDiscoveryStoreDelete(t *testing.T, rctx request.CTX, ss store.Store) {
+	discovery := &model.ClusterDiscovery{
+		ClusterName: "cluster_name",
+		Hostname:    "hostname" + model.NewId(),
+		Type:        "test_test",
+	}
+
+	err := ss.ClusterDiscovery().Save(discovery)
+	require.NoError(t, err)
+
+	_, err = ss.ClusterDiscovery().Delete(discovery)
+	require.NoError(t, err)
+}
+
+func testClusterDiscoveryStoreLastPing(t *testing.T, rctx request.CTX, ss store.Store) {
+	discovery := &model.ClusterDiscovery{
+		ClusterName: "cluster_name_lastPing",
+		Hostname:    "hostname" + model.NewId(),
+		Type:        "test_test_lastPing" + model.NewId(),
+	}
+
+	err := ss.ClusterDiscovery().Save(discovery)
+	require.NoError(t, err)
+
+	err = ss.ClusterDiscovery().SetLastPingAt(discovery)
+	require.NoError(t, err)
+
+	ttime := model.GetMillis()
+
+	time.Sleep(1 * time.Second)
+
+	err = ss.ClusterDiscovery().SetLastPingAt(discovery)
+	require.NoError(t, err)
+
+	list, err := ss.ClusterDiscovery().GetAll(discovery.Type, "cluster_name_lastPing")
+	require.NoError(t, err)
+	assert.Len(t, list, 1)
+
+	require.Less(t, int64(500), list[0].LastPingAt-ttime)
+
+	discovery2 := &model.ClusterDiscovery{
+		ClusterName: "cluster_name_missing",
+		Hostname:    "hostname" + model.NewId(),
+		Type:        "test_test_missing",
+	}
+
+	err = ss.ClusterDiscovery().SetLastPingAt(discovery2)
+	require.NoError(t, err)
+}
+
+func testClusterDiscoveryStoreExists(t *testing.T, rctx request.CTX, ss store.Store) {
+	discovery := &model.ClusterDiscovery{
+		ClusterName: "cluster_name_Exists",
+		Hostname:    "hostname" + model.NewId(),
+		Type:        "test_test_Exists" + model.NewId(),
+	}
+
+	err := ss.ClusterDiscovery().Save(discovery)
+	require.NoError(t, err)
+
+	val, err := ss.ClusterDiscovery().Exists(discovery)
+	require.NoError(t, err)
+	assert.True(t, val)
+
+	discovery.ClusterName = "cluster_name_Exists2"
+
+	val, err = ss.ClusterDiscovery().Exists(discovery)
+	require.NoError(t, err)
+	assert.False(t, val)
+}
+
+func testClusterDiscoveryGetStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	testType1 := model.NewId()
+
+	discovery1 := &model.ClusterDiscovery{
+		ClusterName: "cluster_name",
+		Hostname:    "hostname1",
+		Type:        testType1,
+	}
+	require.NoError(t, ss.ClusterDiscovery().Save(discovery1))
+
+	discovery2 := &model.ClusterDiscovery{
+		ClusterName: "cluster_name",
+		Hostname:    "hostname2",
+		Type:        testType1,
+	}
+	require.NoError(t, ss.ClusterDiscovery().Save(discovery2))
+
+	discovery3 := &model.ClusterDiscovery{
+		ClusterName: "cluster_name",
+		Hostname:    "hostname3",
+		Type:        testType1,
+		CreateAt:    1,
+		LastPingAt:  1,
+	}
+	require.NoError(t, ss.ClusterDiscovery().Save(discovery3))
+
+	testType2 := model.NewId()
+
+	discovery4 := &model.ClusterDiscovery{
+		ClusterName: "cluster_name",
+		Hostname:    "hostname1",
+		Type:        testType2,
+	}
+	require.NoError(t, ss.ClusterDiscovery().Save(discovery4))
+
+	list, err := ss.ClusterDiscovery().GetAll(testType1, "cluster_name")
+	require.NoError(t, err)
+	assert.Len(t, list, 2)
+
+	list, err = ss.ClusterDiscovery().GetAll(testType2, "cluster_name")
+	require.NoError(t, err)
+	assert.Len(t, list, 1)
+
+	list, err = ss.ClusterDiscovery().GetAll(model.NewId(), "cluster_name")
+	require.NoError(t, err)
+	assert.Empty(t, list)
+}

server/channels/store/storetest/command_store.go

@@ -0,0 +1,233 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestCommandStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("Save", func(t *testing.T) { testCommandStoreSave(t, rctx, ss) })
+	t.Run("Get", func(t *testing.T) { testCommandStoreGet(t, rctx, ss) })
+	t.Run("GetByTeam", func(t *testing.T) { testCommandStoreGetByTeam(t, rctx, ss) })
+	t.Run("GetByTrigger", func(t *testing.T) { testCommandStoreGetByTrigger(t, rctx, ss) })
+	t.Run("Delete", func(t *testing.T) { testCommandStoreDelete(t, rctx, ss) })
+	t.Run("DeleteByTeam", func(t *testing.T) { testCommandStoreDeleteByTeam(t, rctx, ss) })
+	t.Run("DeleteByUser", func(t *testing.T) { testCommandStoreDeleteByUser(t, rctx, ss) })
+	t.Run("Update", func(t *testing.T) { testCommandStoreUpdate(t, rctx, ss) })
+	t.Run("CommandCount", func(t *testing.T) { testCommandCount(t, rctx, ss) })
+}
+
+func testCommandStoreSave(t *testing.T, rctx request.CTX, ss store.Store) {
+	o1 := model.Command{}
+	o1.CreatorId = model.NewId()
+	o1.Method = model.CommandMethodPost
+	o1.TeamId = model.NewId()
+	o1.URL = "http://nowhere.com/"
+	o1.Trigger = "trigger"
+
+	_, nErr := ss.Command().Save(&o1)
+	require.NoError(t, nErr)
+
+	_, err := ss.Command().Save(&o1)
+	require.Error(t, err, "shouldn't be able to update from save")
+}
+
+func testCommandStoreGet(t *testing.T, rctx request.CTX, ss store.Store) {
+	o1 := &model.Command{}
+	o1.CreatorId = model.NewId()
+	o1.Method = model.CommandMethodPost
+	o1.TeamId = model.NewId()
+	o1.URL = "http://nowhere.com/"
+	o1.Trigger = "trigger"
+
+	o1, nErr := ss.Command().Save(o1)
+	require.NoError(t, nErr)
+
+	r1, nErr := ss.Command().Get(o1.Id)
+	require.NoError(t, nErr)
+	require.Equal(t, r1.CreateAt, o1.CreateAt, "invalid returned command")
+
+	_, err := ss.Command().Get("123")
+	require.Error(t, err)
+	var nfErr *store.ErrNotFound
+	require.True(t, errors.As(err, &nfErr))
+}
+
+func testCommandStoreGetByTeam(t *testing.T, rctx request.CTX, ss store.Store) {
+	o1 := &model.Command{}
+	o1.CreatorId = model.NewId()
+	o1.Method = model.CommandMethodPost
+	o1.TeamId = model.NewId()
+	o1.URL = "http://nowhere.com/"
+	o1.Trigger = "trigger"
+
+	o1, nErr := ss.Command().Save(o1)
+	require.NoError(t, nErr)
+
+	r1, nErr := ss.Command().GetByTeam(o1.TeamId)
+	require.NoError(t, nErr)
+	require.NotEmpty(t, r1, "no command returned")
+	require.Equal(t, r1[0].CreateAt, o1.CreateAt, "invalid returned command")
+
+	result, nErr := ss.Command().GetByTeam("123")
+	require.NoError(t, nErr)
+	require.Empty(t, result, "no commands should have returned")
+}
+
+func testCommandStoreGetByTrigger(t *testing.T, rctx request.CTX, ss store.Store) {
+	o1 := &model.Command{}
+	o1.CreatorId = model.NewId()
+	o1.Method = model.CommandMethodPost
+	o1.TeamId = model.NewId()
+	o1.URL = "http://nowhere.com/"
+	o1.Trigger = "trigger1"
+
+	o2 := &model.Command{}
+	o2.CreatorId = model.NewId()
+	o2.Method = model.CommandMethodPost
+	o2.TeamId = model.NewId()
+	o2.URL = "http://nowhere.com/"
+	o2.Trigger = "trigger1"
+
+	o1, nErr := ss.Command().Save(o1)
+	require.NoError(t, nErr)
+
+	_, nErr = ss.Command().Save(o2)
+	require.NoError(t, nErr)
+
+	var r1 *model.Command
+	r1, nErr = ss.Command().GetByTrigger(o1.TeamId, o1.Trigger)
+	require.NoError(t, nErr)
+	require.Equal(t, r1.Id, o1.Id, "invalid returned command")
+
+	nErr = ss.Command().Delete(o1.Id, model.GetMillis())
+	require.NoError(t, nErr)
+
+	_, err := ss.Command().GetByTrigger(o1.TeamId, o1.Trigger)
+	require.Error(t, err)
+	var nfErr *store.ErrNotFound
+	require.True(t, errors.As(err, &nfErr))
+}
+
+func testCommandStoreDelete(t *testing.T, rctx request.CTX, ss store.Store) {
+	o1 := &model.Command{}
+	o1.CreatorId = model.NewId()
+	o1.Method = model.CommandMethodPost
+	o1.TeamId = model.NewId()
+	o1.URL = "http://nowhere.com/"
+	o1.Trigger = "trigger"
+
+	o1, nErr := ss.Command().Save(o1)
+	require.NoError(t, nErr)
+
+	r1, nErr := ss.Command().Get(o1.Id)
+	require.NoError(t, nErr)
+	require.Equal(t, r1.CreateAt, o1.CreateAt, "invalid returned command")
+
+	nErr = ss.Command().Delete(o1.Id, model.GetMillis())
+	require.NoError(t, nErr)
+
+	_, err := ss.Command().Get(o1.Id)
+	require.Error(t, err)
+	var nfErr *store.ErrNotFound
+	require.True(t, errors.As(err, &nfErr))
+}
+
+func testCommandStoreDeleteByTeam(t *testing.T, rctx request.CTX, ss store.Store) {
+	o1 := &model.Command{}
+	o1.CreatorId = model.NewId()
+	o1.Method = model.CommandMethodPost
+	o1.TeamId = model.NewId()
+	o1.URL = "http://nowhere.com/"
+	o1.Trigger = "trigger"
+
+	o1, nErr := ss.Command().Save(o1)
+	require.NoError(t, nErr)
+
+	r1, nErr := ss.Command().Get(o1.Id)
+	require.NoError(t, nErr)
+	require.Equal(t, r1.CreateAt, o1.CreateAt, "invalid returned command")
+
+	nErr = ss.Command().PermanentDeleteByTeam(o1.TeamId)
+	require.NoError(t, nErr)
+
+	_, err := ss.Command().Get(o1.Id)
+	require.Error(t, err)
+	var nfErr *store.ErrNotFound
+	require.True(t, errors.As(err, &nfErr))
+}
+
+func testCommandStoreDeleteByUser(t *testing.T, rctx request.CTX, ss store.Store) {
+	o1 := &model.Command{}
+	o1.CreatorId = model.NewId()
+	o1.Method = model.CommandMethodPost
+	o1.TeamId = model.NewId()
+	o1.URL = "http://nowhere.com/"
+	o1.Trigger = "trigger"
+
+	o1, nErr := ss.Command().Save(o1)
+	require.NoError(t, nErr)
+
+	r1, nErr := ss.Command().Get(o1.Id)
+	require.NoError(t, nErr)
+	require.Equal(t, r1.CreateAt, o1.CreateAt, "invalid returned command")
+
+	nErr = ss.Command().PermanentDeleteByUser(o1.CreatorId)
+	require.NoError(t, nErr)
+
+	_, err := ss.Command().Get(o1.Id)
+	require.Error(t, err)
+	var nfErr *store.ErrNotFound
+	require.True(t, errors.As(err, &nfErr))
+}
+
+func testCommandStoreUpdate(t *testing.T, rctx request.CTX, ss store.Store) {
+	o1 := &model.Command{}
+	o1.CreatorId = model.NewId()
+	o1.Method = model.CommandMethodPost
+	o1.TeamId = model.NewId()
+	o1.URL = "http://nowhere.com/"
+	o1.Trigger = "trigger"
+
+	o1, nErr := ss.Command().Save(o1)
+	require.NoError(t, nErr)
+
+	o1.Token = model.NewId()
+
+	_, nErr = ss.Command().Update(o1)
+	require.NoError(t, nErr)
+
+	o1.URL = "junk"
+
+	_, err := ss.Command().Update(o1)
+	require.Error(t, err)
+}
+
+func testCommandCount(t *testing.T, rctx request.CTX, ss store.Store) {
+	o1 := &model.Command{}
+	o1.CreatorId = model.NewId()
+	o1.Method = model.CommandMethodPost
+	o1.TeamId = model.NewId()
+	o1.URL = "http://nowhere.com/"
+	o1.Trigger = "trigger"
+
+	o1, nErr := ss.Command().Save(o1)
+	require.NoError(t, nErr)
+
+	r1, nErr := ss.Command().AnalyticsCommandCount("")
+	require.NoError(t, nErr)
+	require.NotZero(t, r1, "should be at least 1 command")
+
+	r2, nErr := ss.Command().AnalyticsCommandCount(o1.TeamId)
+	require.NoError(t, nErr)
+	require.Equal(t, r2, int64(1), "should be 1 command")
+}

server/channels/store/storetest/command_webhook_store.go

@@ -0,0 +1,68 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestCommandWebhookStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("", func(t *testing.T) { testCommandWebhookStore(t, rctx, ss) })
+}
+
+func testCommandWebhookStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	cws := ss.CommandWebhook()
+
+	h1 := &model.CommandWebhook{}
+	h1.CommandId = model.NewId()
+	h1.UserId = model.NewId()
+	h1.ChannelId = model.NewId()
+	h1, err := cws.Save(h1)
+	require.NoError(t, err)
+
+	var r1 *model.CommandWebhook
+	r1, nErr := cws.Get(h1.Id)
+	require.NoError(t, nErr)
+	assert.Equal(t, *r1, *h1, "invalid returned webhook")
+
+	_, nErr = cws.Get("123")
+	var nfErr *store.ErrNotFound
+	require.True(t, errors.As(nErr, &nfErr), "Should have set the status as not found for missing id")
+
+	h2 := &model.CommandWebhook{}
+	h2.CreateAt = model.GetMillis() - 2*model.CommandWebhookLifetime
+	h2.CommandId = model.NewId()
+	h2.UserId = model.NewId()
+	h2.ChannelId = model.NewId()
+	h2, err = cws.Save(h2)
+	require.NoError(t, err)
+
+	_, nErr = cws.Get(h2.Id)
+	require.Error(t, nErr, "Should have set the status as not found for expired webhook")
+	require.True(t, errors.As(nErr, &nfErr), "Should have set the status as not found for expired webhook")
+
+	cws.Cleanup()
+
+	_, nErr = cws.Get(h1.Id)
+	require.NoError(t, nErr, "Should have no error getting unexpired webhook")
+
+	_, nErr = cws.Get(h2.Id)
+	require.True(t, errors.As(nErr, &nfErr), "Should have set the status as not found for expired webhook")
+
+	nErr = cws.TryUse(h1.Id, 1)
+	require.NoError(t, nErr, "Should be able to use webhook once")
+
+	nErr = cws.TryUse(h1.Id, 1)
+	require.Error(t, nErr, "Should be able to use webhook once")
+	var invErr *store.ErrInvalidInput
+	require.True(t, errors.As(nErr, &invErr), "Should be able to use webhook once")
+}

server/channels/store/storetest/content_flagging_store.go

@@ -0,0 +1,335 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestContentFlaggingStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("SaveReviewerSettings", func(t *testing.T) { testSaveReviewerSettings(t, rctx, ss, s) })
+	t.Run("GetReviewerSettings", func(t *testing.T) { testGetReviewerSettings(t, rctx, ss, s) })
+	t.Run("SaveAndGetReviewerSettings", func(t *testing.T) { testSaveAndGetReviewerSettings(t, rctx, ss, s) })
+}
+
+func testSaveReviewerSettings(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("save empty settings", func(t *testing.T) {
+		ss.ContentFlagging().ClearCaches()
+
+		commonReviewers := []string{}
+		teamSettings := map[string]*model.TeamReviewerSetting{}
+
+		reviewerSettings := model.ReviewerIDsSettings{
+			CommonReviewerIds:    commonReviewers,
+			TeamReviewersSetting: teamSettings,
+		}
+
+		err := ss.ContentFlagging().SaveReviewerSettings(reviewerSettings)
+		assert.NoError(t, err)
+
+		// Verify settings were saved (should be empty)
+		settings, err := ss.ContentFlagging().GetReviewerSettings()
+		assert.NoError(t, err)
+		assert.Equal(t, 0, len(settings.CommonReviewerIds))
+		assert.Equal(t, 0, len(settings.TeamReviewersSetting))
+	})
+
+	t.Run("save common reviewers only", func(t *testing.T) {
+		ss.ContentFlagging().ClearCaches()
+
+		userId1 := model.NewId()
+		userId2 := model.NewId()
+		commonReviewers := []string{userId1, userId2}
+		teamSettings := map[string]*model.TeamReviewerSetting{}
+
+		reviewerSettings := model.ReviewerIDsSettings{
+			CommonReviewerIds:    commonReviewers,
+			TeamReviewersSetting: teamSettings,
+		}
+
+		err := ss.ContentFlagging().SaveReviewerSettings(reviewerSettings)
+		assert.NoError(t, err)
+
+		// Verify settings were saved
+		settings, err := ss.ContentFlagging().GetReviewerSettings()
+		assert.NoError(t, err)
+		assert.NotNil(t, settings.CommonReviewerIds)
+		assert.Equal(t, 2, len(settings.CommonReviewerIds))
+		assert.Contains(t, settings.CommonReviewerIds, userId1)
+		assert.Contains(t, settings.CommonReviewerIds, userId2)
+	})
+
+	t.Run("save team settings only", func(t *testing.T) {
+		ss.ContentFlagging().ClearCaches()
+
+		teamId1 := model.NewId()
+		teamId2 := model.NewId()
+		enabled1 := true
+		enabled2 := false
+
+		commonReviewers := []string{}
+		teamSettings := map[string]*model.TeamReviewerSetting{
+			teamId1: {
+				Enabled:     &enabled1,
+				ReviewerIds: []string{},
+			},
+			teamId2: {
+				Enabled:     &enabled2,
+				ReviewerIds: []string{},
+			},
+		}
+
+		reviewerSettings := model.ReviewerIDsSettings{
+			CommonReviewerIds:    commonReviewers,
+			TeamReviewersSetting: teamSettings,
+		}
+
+		err := ss.ContentFlagging().SaveReviewerSettings(reviewerSettings)
+		assert.NoError(t, err)
+
+		// Verify settings were saved
+		settings, err := ss.ContentFlagging().GetReviewerSettings()
+		assert.NoError(t, err)
+		assert.NotNil(t, settings.TeamReviewersSetting)
+		assert.Equal(t, 2, len(settings.TeamReviewersSetting))
+
+		teamSetting1, exists := (settings.TeamReviewersSetting)[teamId1]
+		assert.True(t, exists)
+		assert.NotNil(t, teamSetting1.Enabled)
+		assert.True(t, *teamSetting1.Enabled)
+
+		teamSetting2, exists := (settings.TeamReviewersSetting)[teamId2]
+		assert.True(t, exists)
+		assert.NotNil(t, teamSetting2.Enabled)
+		assert.False(t, *teamSetting2.Enabled)
+	})
+
+	t.Run("save team reviewers", func(t *testing.T) {
+		ss.ContentFlagging().ClearCaches()
+
+		teamId := model.NewId()
+		userId1 := model.NewId()
+		userId2 := model.NewId()
+		enabled := true
+
+		commonReviewers := []string{}
+		teamSettings := map[string]*model.TeamReviewerSetting{
+			teamId: {
+				Enabled:     &enabled,
+				ReviewerIds: []string{userId1, userId2},
+			},
+		}
+
+		reviewerSettings := model.ReviewerIDsSettings{
+			CommonReviewerIds:    commonReviewers,
+			TeamReviewersSetting: teamSettings,
+		}
+
+		err := ss.ContentFlagging().SaveReviewerSettings(reviewerSettings)
+		assert.NoError(t, err)
+
+		// Verify settings were saved
+		settings, err := ss.ContentFlagging().GetReviewerSettings()
+		assert.NoError(t, err)
+		assert.NotNil(t, settings.TeamReviewersSetting)
+
+		teamSetting, exists := settings.TeamReviewersSetting[teamId]
+		assert.True(t, exists)
+		assert.NotNil(t, teamSetting.ReviewerIds)
+		assert.Equal(t, 2, len(teamSetting.ReviewerIds))
+		assert.Contains(t, teamSetting.ReviewerIds, userId1)
+		assert.Contains(t, teamSetting.ReviewerIds, userId2)
+	})
+
+	t.Run("update existing settings", func(t *testing.T) {
+		ss.ContentFlagging().ClearCaches()
+
+		// First save some initial settings
+		userId1 := model.NewId()
+		teamId1 := model.NewId()
+		enabled1 := true
+
+		commonReviewers := []string{userId1}
+		teamSettings := map[string]*model.TeamReviewerSetting{
+			teamId1: {
+				Enabled:     &enabled1,
+				ReviewerIds: []string{userId1},
+			},
+		}
+
+		reviewerSettings := model.ReviewerIDsSettings{
+			CommonReviewerIds:    commonReviewers,
+			TeamReviewersSetting: teamSettings,
+		}
+
+		err := ss.ContentFlagging().SaveReviewerSettings(reviewerSettings)
+		assert.NoError(t, err)
+
+		// Now update with different settings
+		userId2 := model.NewId()
+		userId3 := model.NewId()
+		teamId2 := model.NewId()
+		enabled2 := false
+
+		newCommonReviewers := []string{userId2, userId3}
+		newTeamSettings := map[string]*model.TeamReviewerSetting{
+			teamId2: {
+				Enabled:     &enabled2,
+				ReviewerIds: []string{userId2},
+			},
+		}
+
+		newReviewerSettings := model.ReviewerIDsSettings{
+			CommonReviewerIds:    newCommonReviewers,
+			TeamReviewersSetting: newTeamSettings,
+		}
+
+		err = ss.ContentFlagging().SaveReviewerSettings(newReviewerSettings)
+		assert.NoError(t, err)
+
+		// Verify old settings were replaced
+		settings, err := ss.ContentFlagging().GetReviewerSettings()
+		assert.NoError(t, err)
+
+		// Common reviewers should be updated
+		assert.NotNil(t, settings.CommonReviewerIds)
+		assert.Equal(t, 2, len(settings.CommonReviewerIds))
+		assert.Contains(t, settings.CommonReviewerIds, userId2)
+		assert.Contains(t, settings.CommonReviewerIds, userId3)
+		assert.NotContains(t, settings.CommonReviewerIds, userId1)
+
+		// Team settings should be updated
+		assert.NotNil(t, settings.TeamReviewersSetting)
+		assert.Equal(t, 1, len(settings.TeamReviewersSetting))
+
+		_, exists := (settings.TeamReviewersSetting)[teamId1]
+		assert.False(t, exists) // Old team should be gone
+
+		teamSetting2, exists := (settings.TeamReviewersSetting)[teamId2]
+		assert.True(t, exists)
+		assert.NotNil(t, teamSetting2.Enabled)
+		assert.False(t, *teamSetting2.Enabled)
+	})
+}
+
+func testGetReviewerSettings(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("get empty settings", func(t *testing.T) {
+		ss.ContentFlagging().ClearCaches()
+
+		// Clear any existing settings first
+		emptyCommonReviewers := []string{}
+		emptyTeamSettings := map[string]*model.TeamReviewerSetting{}
+
+		reviewerSettings := model.ReviewerIDsSettings{
+			CommonReviewerIds:    emptyCommonReviewers,
+			TeamReviewersSetting: emptyTeamSettings,
+		}
+
+		err := ss.ContentFlagging().SaveReviewerSettings(reviewerSettings)
+		assert.NoError(t, err)
+
+		settings, err := ss.ContentFlagging().GetReviewerSettings()
+		assert.NoError(t, err)
+		assert.NotNil(t, settings)
+		assert.Equal(t, 0, len(settings.CommonReviewerIds))
+		assert.Equal(t, 0, len(settings.TeamReviewersSetting))
+	})
+}
+
+func testSaveAndGetReviewerSettings(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("comprehensive save and get", func(t *testing.T) {
+		ss.ContentFlagging().ClearCaches()
+
+		// Create comprehensive test data
+		commonUserId1 := model.NewId()
+		commonUserId2 := model.NewId()
+		commonUserId3 := model.NewId()
+
+		teamId1 := model.NewId()
+		teamId2 := model.NewId()
+		teamId3 := model.NewId()
+
+		teamUserId1 := model.NewId()
+		teamUserId2 := model.NewId()
+		teamUserId3 := model.NewId()
+
+		enabled1 := true
+		enabled2 := false
+		enabled3 := true
+
+		commonReviewers := []string{commonUserId1, commonUserId2, commonUserId3}
+		teamSettings := map[string]*model.TeamReviewerSetting{
+			teamId1: {
+				Enabled:     &enabled1,
+				ReviewerIds: []string{teamUserId1, teamUserId2},
+			},
+			teamId2: {
+				Enabled:     &enabled2,
+				ReviewerIds: []string{teamUserId3},
+			},
+			teamId3: {
+				Enabled:     &enabled3,
+				ReviewerIds: []string{}, // Empty reviewers list
+			},
+		}
+
+		reviewerSettings := model.ReviewerIDsSettings{
+			CommonReviewerIds:    commonReviewers,
+			TeamReviewersSetting: teamSettings,
+		}
+
+		// Save the settings
+		err := ss.ContentFlagging().SaveReviewerSettings(reviewerSettings)
+		assert.NoError(t, err)
+
+		// Get the settings back
+		retrievedSettings, err := ss.ContentFlagging().GetReviewerSettings()
+		assert.NoError(t, err)
+		require.NotNil(t, retrievedSettings)
+
+		// Verify common reviewers
+		assert.NotNil(t, retrievedSettings.CommonReviewerIds)
+		assert.Equal(t, 3, len(retrievedSettings.CommonReviewerIds))
+		assert.Contains(t, retrievedSettings.CommonReviewerIds, commonUserId1)
+		assert.Contains(t, retrievedSettings.CommonReviewerIds, commonUserId2)
+		assert.Contains(t, retrievedSettings.CommonReviewerIds, commonUserId3)
+
+		// Verify team settings
+		assert.NotNil(t, retrievedSettings.TeamReviewersSetting)
+		assert.Equal(t, 3, len(retrievedSettings.TeamReviewersSetting))
+
+		// Verify team 1
+		team1Setting, exists := (retrievedSettings.TeamReviewersSetting)[teamId1]
+		assert.True(t, exists)
+		assert.NotNil(t, team1Setting.Enabled)
+		assert.True(t, *team1Setting.Enabled)
+		assert.NotNil(t, team1Setting.ReviewerIds)
+		assert.Equal(t, 2, len(team1Setting.ReviewerIds))
+		assert.Contains(t, team1Setting.ReviewerIds, teamUserId1)
+		assert.Contains(t, team1Setting.ReviewerIds, teamUserId2)
+
+		// Verify team 2
+		team2Setting, exists := (retrievedSettings.TeamReviewersSetting)[teamId2]
+		assert.True(t, exists)
+		assert.NotNil(t, team2Setting.Enabled)
+		assert.False(t, *team2Setting.Enabled)
+		assert.NotNil(t, team2Setting.ReviewerIds)
+		assert.Equal(t, 1, len(team2Setting.ReviewerIds))
+		assert.Contains(t, team2Setting.ReviewerIds, teamUserId3)
+
+		// Verify team 3
+		team3Setting, exists := (retrievedSettings.TeamReviewersSetting)[teamId3]
+		assert.True(t, exists)
+		assert.NotNil(t, team3Setting.Enabled)
+		assert.True(t, *team3Setting.Enabled)
+		assert.NotNil(t, team3Setting.ReviewerIds)
+		assert.Equal(t, 0, len(team3Setting.ReviewerIds))
+	})
+}

server/channels/store/storetest/delivery_tracking_store.go

@@ -0,0 +1,177 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestDeliveryTrackingStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("SaveAndGet", func(t *testing.T) { testDeliveryTrackingSaveAndGet(t, rctx, ss) })
+	t.Run("SaveReplaces", func(t *testing.T) { testDeliveryTrackingSaveReplaces(t, rctx, ss) })
+	t.Run("SaveEmptyClears", func(t *testing.T) { testDeliveryTrackingSaveEmptyClears(t, rctx, ss) })
+	t.Run("SaveDeduplicates", func(t *testing.T) { testDeliveryTrackingSaveDeduplicates(t, rctx, ss) })
+	t.Run("SaveDropsEmptyIDs", func(t *testing.T) { testDeliveryTrackingSaveDropsEmptyIDs(t, rctx, ss) })
+	t.Run("GetOnEmptyTable", func(t *testing.T) { testDeliveryTrackingGetOnEmptyTable(t, rctx, ss) })
+	t.Run("IsChannelTracked", func(t *testing.T) { testDeliveryTrackingIsChannelTracked(t, rctx, ss) })
+	t.Run("IsChannelTrackable", func(t *testing.T) { testDeliveryTrackingIsChannelTrackable(t, rctx, ss) })
+}
+
+func testDeliveryTrackingIsChannelTracked(t *testing.T, rctx request.CTX, ss store.Store) {
+	tracked := model.NewId()
+	untracked := model.NewId()
+
+	require.NoError(t, ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, []string{tracked}))
+
+	isTracked, err := ss.DeliveryTracking().IsChannelTracked(rctx, tracked)
+	require.NoError(t, err)
+	assert.True(t, isTracked)
+
+	isTracked, err = ss.DeliveryTracking().IsChannelTracked(rctx, untracked)
+	require.NoError(t, err)
+	assert.False(t, isTracked)
+
+	require.NoError(t, ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, []string{}))
+
+	isTracked, err = ss.DeliveryTracking().IsChannelTracked(rctx, tracked)
+	require.NoError(t, err)
+	assert.False(t, isTracked, "clearing the list must untrack the channel")
+}
+
+func testDeliveryTrackingIsChannelTrackable(t *testing.T, rctx request.CTX, ss store.Store) {
+	saveChannel := func(channelType model.ChannelType) *model.Channel {
+		channel, err := ss.Channel().Save(rctx, &model.Channel{
+			TeamId:      model.NewId(),
+			DisplayName: "test",
+			Name:        model.NewId(),
+			Type:        channelType,
+		}, -1)
+		require.NoError(t, err)
+		return channel
+	}
+
+	for _, tc := range []struct {
+		name        string
+		channelType model.ChannelType
+		expected    bool
+	}{
+		{"open", model.ChannelTypeOpen, true},
+		{"private", model.ChannelTypePrivate, true},
+		{"group", model.ChannelTypeGroup, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			channel := saveChannel(tc.channelType)
+
+			trackable, err := ss.DeliveryTracking().IsChannelTrackable(rctx, channel.Id)
+			require.NoError(t, err)
+			assert.Equal(t, tc.expected, trackable)
+		})
+	}
+
+	t.Run("direct", func(t *testing.T) {
+		u1 := &model.User{Email: MakeEmail(), Nickname: model.NewId()}
+		_, err := ss.User().Save(rctx, u1)
+		require.NoError(t, err)
+
+		u2 := &model.User{Email: MakeEmail(), Nickname: model.NewId()}
+		_, err = ss.User().Save(rctx, u2)
+		require.NoError(t, err)
+
+		dm := &model.Channel{
+			DisplayName: "dm",
+			Name:        model.GetDMNameFromIds(u1.Id, u2.Id),
+			Type:        model.ChannelTypeDirect,
+		}
+		m1 := &model.ChannelMember{UserId: u1.Id, NotifyProps: model.GetDefaultChannelNotifyProps()}
+		m2 := &model.ChannelMember{UserId: u2.Id, NotifyProps: model.GetDefaultChannelNotifyProps()}
+
+		dm, nErr := ss.Channel().SaveDirectChannel(rctx, dm, m1, m2)
+		require.NoError(t, nErr)
+
+		trackable, err := ss.DeliveryTracking().IsChannelTrackable(rctx, dm.Id)
+		require.NoError(t, err)
+		assert.False(t, trackable)
+	})
+
+	t.Run("unknown channel", func(t *testing.T) {
+		trackable, err := ss.DeliveryTracking().IsChannelTrackable(rctx, model.NewId())
+		require.NoError(t, err)
+		assert.False(t, trackable)
+	})
+}
+
+func testDeliveryTrackingSaveAndGet(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID1 := model.NewId()
+	channelID2 := model.NewId()
+
+	err := ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, []string{channelID1, channelID2})
+	require.NoError(t, err)
+
+	stored, err := ss.DeliveryTracking().GetTrackedChannelIDs(rctx)
+	require.NoError(t, err)
+	assert.ElementsMatch(t, []string{channelID1, channelID2}, stored)
+}
+
+func testDeliveryTrackingSaveReplaces(t *testing.T, rctx request.CTX, ss store.Store) {
+	original := []string{model.NewId(), model.NewId()}
+	replacement := []string{model.NewId()}
+
+	require.NoError(t, ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, original))
+	require.NoError(t, ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, replacement))
+
+	stored, err := ss.DeliveryTracking().GetTrackedChannelIDs(rctx)
+	require.NoError(t, err)
+	assert.ElementsMatch(t, replacement, stored, "save should replace the stored set, not append to it")
+}
+
+func testDeliveryTrackingSaveEmptyClears(t *testing.T, rctx request.CTX, ss store.Store) {
+	require.NoError(t, ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, []string{model.NewId()}))
+	require.NoError(t, ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, []string{}))
+
+	stored, err := ss.DeliveryTracking().GetTrackedChannelIDs(rctx)
+	require.NoError(t, err)
+	assert.Empty(t, stored)
+}
+
+func testDeliveryTrackingSaveDeduplicates(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+
+	// The table has a unique constraint on ChannelId, so a duplicated input must not
+	// blow up the insert.
+	err := ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, []string{channelID, channelID})
+	require.NoError(t, err)
+
+	stored, err := ss.DeliveryTracking().GetTrackedChannelIDs(rctx)
+	require.NoError(t, err)
+	assert.Equal(t, []string{channelID}, stored)
+}
+
+func testDeliveryTrackingSaveDropsEmptyIDs(t *testing.T, rctx request.CTX, ss store.Store) {
+	channelID := model.NewId()
+
+	err := ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, []string{channelID, "", ""})
+	require.NoError(t, err)
+
+	stored, err := ss.DeliveryTracking().GetTrackedChannelIDs(rctx)
+	require.NoError(t, err)
+	assert.Equal(t, []string{channelID}, stored)
+}
+
+func testDeliveryTrackingGetOnEmptyTable(t *testing.T, rctx request.CTX, ss store.Store) {
+	require.NoError(t, ss.DeliveryTracking().SaveTrackedChannelIDs(rctx, []string{}))
+
+	stored, err := ss.DeliveryTracking().GetTrackedChannelIDs(rctx)
+	require.NoError(t, err)
+
+	// Non-nil so the REST layer serializes an empty array rather than null.
+	require.NotNil(t, stored)
+	assert.Empty(t, stored)
+}

server/channels/store/storetest/desktop_tokens_store.go

@@ -0,0 +1,111 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDesktopTokensStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("GetUserId", func(t *testing.T) { testGetUserID(t, rctx, ss) })
+	t.Run("Insert", func(t *testing.T) { testInsert(t, rctx, ss) })
+	t.Run("Delete", func(t *testing.T) { testDeleteToken(t, rctx, ss) })
+	t.Run("DeleteByUserId", func(t *testing.T) { testDeleteByUserID(t, rctx, ss) })
+	t.Run("DeleteOlderThan", func(t *testing.T) { testDeleteOlderThan(t, rctx, ss) })
+}
+
+func testGetUserID(t *testing.T, rctx request.CTX, ss store.Store) {
+	err := ss.DesktopTokens().Insert("token_with_id", 1000, "user_id")
+	require.NoError(t, err)
+
+	t.Run("get user id", func(t *testing.T) {
+		userID, err := ss.DesktopTokens().GetUserId("token_with_id", 1000)
+		assert.NoError(t, err)
+		assert.Equal(t, "user_id", *userID)
+	})
+
+	t.Run("get user id - expired", func(t *testing.T) {
+		userID, err := ss.DesktopTokens().GetUserId("token_with_id", 10000)
+		assert.Error(t, err)
+		assert.IsType(t, &store.ErrNotFound{}, err)
+		assert.Nil(t, userID)
+	})
+}
+
+func testInsert(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("insert", func(t *testing.T) {
+		err := ss.DesktopTokens().Insert("token", 1000, "user_id")
+		assert.NoError(t, err)
+	})
+
+	t.Run("insert - token too long", func(t *testing.T) {
+		err := ss.DesktopTokens().Insert(
+			"this token is way way way WAAAAAAAAAAAAAY WAAAAAAAAAAAAAY WAAAAAAAAAAAAAY TOO LONG",
+			1000,
+			"user_id",
+		)
+		assert.Error(t, err)
+	})
+}
+
+func testDeleteToken(t *testing.T, rctx request.CTX, ss store.Store) {
+	err := ss.DesktopTokens().Insert("deleteable_token", 3000, "user_id")
+	require.NoError(t, err)
+
+	t.Run("delete", func(t *testing.T) {
+		userID, err := ss.DesktopTokens().GetUserId("deleteable_token", 3000)
+		assert.NoError(t, err)
+		assert.Equal(t, "user_id", *userID)
+
+		err = ss.DesktopTokens().Delete("deleteable_token")
+		assert.NoError(t, err)
+
+		_, err = ss.DesktopTokens().GetUserId("deleteable_token", 3000)
+		assert.Error(t, err)
+	})
+}
+
+func testDeleteByUserID(t *testing.T, rctx request.CTX, ss store.Store) {
+	err := ss.DesktopTokens().Insert("deleteable_token_2", 4000, "deleteable_user_id")
+	require.NoError(t, err)
+
+	t.Run("delete by user id", func(t *testing.T) {
+		userID, err := ss.DesktopTokens().GetUserId("deleteable_token_2", 3000)
+		assert.NoError(t, err)
+		assert.Equal(t, "deleteable_user_id", *userID)
+
+		err = ss.DesktopTokens().DeleteByUserId("deleteable_user_id")
+		assert.NoError(t, err)
+
+		_, err = ss.DesktopTokens().GetUserId("deleteable_token_2", 3000)
+		assert.Error(t, err)
+	})
+}
+
+func testDeleteOlderThan(t *testing.T, rctx request.CTX, ss store.Store) {
+	err := ss.DesktopTokens().Insert("deleteable_token_old", 1000, "deleteable_user_id")
+	require.NoError(t, err)
+	err = ss.DesktopTokens().Insert("deleteable_token_new", 5000, "deleteable_user_id")
+	require.NoError(t, err)
+
+	t.Run("delete older than", func(t *testing.T) {
+		_, err := ss.DesktopTokens().GetUserId("deleteable_token_old", 1000)
+		assert.NoError(t, err)
+		_, err = ss.DesktopTokens().GetUserId("deleteable_token_new", 5000)
+		assert.NoError(t, err)
+
+		err = ss.DesktopTokens().DeleteOlderThan(2000)
+		assert.NoError(t, err)
+
+		_, err = ss.DesktopTokens().GetUserId("deleteable_token_old", 1000)
+		assert.Error(t, err)
+		_, err = ss.DesktopTokens().GetUserId("deleteable_token_new", 5000)
+		assert.NoError(t, err)
+	})
+}

server/channels/store/storetest/emoji_store.go

@@ -0,0 +1,304 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+	"time"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEmojiStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("EmojiSaveDelete", func(t *testing.T) { testEmojiSaveDelete(t, rctx, ss) })
+	t.Run("EmojiGet", func(t *testing.T) { testEmojiGet(t, rctx, ss) })
+	t.Run("EmojiGetByName", func(t *testing.T) { testEmojiGetByName(t, rctx, ss) })
+	t.Run("EmojiGetMultipleByName", func(t *testing.T) { testEmojiGetMultipleByName(t, rctx, ss) })
+	t.Run("EmojiGetList", func(t *testing.T) { testEmojiGetList(t, rctx, ss) })
+	t.Run("EmojiSearch", func(t *testing.T) { testEmojiSearch(t, rctx, ss) })
+}
+
+func testEmojiSaveDelete(t *testing.T, rctx request.CTX, ss store.Store) {
+	emoji1 := &model.Emoji{
+		CreatorId: model.NewId(),
+		Name:      model.NewId(),
+	}
+
+	_, err := ss.Emoji().Save(emoji1)
+	require.NoError(t, err)
+
+	assert.Len(t, emoji1.Id, 26, "should've set id for emoji")
+
+	emoji2 := model.Emoji{
+		CreatorId: model.NewId(),
+		Name:      emoji1.Name,
+	}
+	_, err = ss.Emoji().Save(&emoji2)
+	require.Error(t, err, "shouldn't be able to save emoji with duplicate name")
+
+	err = ss.Emoji().Delete(emoji1, time.Now().Unix())
+	require.NoError(t, err)
+
+	_, err = ss.Emoji().Save(&emoji2)
+	require.NoError(t, err, "should be able to save emoji with duplicate name now that original has been deleted")
+
+	err = ss.Emoji().Delete(&emoji2, time.Now().Unix()+1)
+	require.NoError(t, err)
+}
+
+func testEmojiGet(t *testing.T, rctx request.CTX, ss store.Store) {
+	emojis := []model.Emoji{
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+	}
+
+	for i, emoji := range emojis {
+		data, err := ss.Emoji().Save(&emoji)
+		require.NoError(t, err)
+		emojis[i] = *data
+	}
+	defer func() {
+		for _, emoji := range emojis {
+			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
+			require.NoError(t, err)
+		}
+	}()
+
+	for _, emoji := range emojis {
+		_, err := ss.Emoji().Get(rctx, emoji.Id, false)
+		require.NoErrorf(t, err, "failed to get emoji with id %v", emoji.Id)
+	}
+
+	for _, emoji := range emojis {
+		_, err := ss.Emoji().Get(rctx, emoji.Id, true)
+		require.NoErrorf(t, err, "failed to get emoji with id %v", emoji.Id)
+	}
+}
+
+func testEmojiGetByName(t *testing.T, rctx request.CTX, ss store.Store) {
+	emojis := []model.Emoji{
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+	}
+
+	for i, emoji := range emojis {
+		data, err := ss.Emoji().Save(&emoji)
+		require.NoError(t, err)
+		emojis[i] = *data
+	}
+	defer func() {
+		for _, emoji := range emojis {
+			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
+			require.NoError(t, err)
+		}
+	}()
+
+	for _, emoji := range emojis {
+		_, err := ss.Emoji().GetByName(rctx, emoji.Name, true)
+		require.NoErrorf(t, err, "failed to get emoji with name %v", emoji.Name)
+	}
+}
+
+func testEmojiGetMultipleByName(t *testing.T, rctx request.CTX, ss store.Store) {
+	emojis := []model.Emoji{
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+	}
+
+	for i, emoji := range emojis {
+		data, err := ss.Emoji().Save(&emoji)
+		require.NoError(t, err)
+		emojis[i] = *data
+	}
+	defer func() {
+		for _, emoji := range emojis {
+			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
+			require.NoError(t, err)
+		}
+	}()
+
+	t.Run("one emoji", func(t *testing.T) {
+		received, err := ss.Emoji().GetMultipleByName(rctx, []string{emojis[0].Name})
+		require.NoError(t, err, "could not get emoji")
+		require.Len(t, received, 1, "got incorrect emoji")
+		require.Equal(t, *received[0], emojis[0], "got incorrect emoji")
+	})
+
+	t.Run("multiple emojis", func(t *testing.T) {
+		received, err := ss.Emoji().GetMultipleByName(rctx, []string{emojis[0].Name, emojis[1].Name, emojis[2].Name})
+		require.NoError(t, err, "could not get emojis")
+		require.Len(t, received, 3, "got incorrect emojis")
+	})
+
+	t.Run("one nonexistent emoji", func(t *testing.T) {
+		received, err := ss.Emoji().GetMultipleByName(rctx, []string{"ab"})
+		require.NoError(t, err, "could not get emoji", err)
+		require.Empty(t, received, "got incorrect emoji")
+	})
+
+	t.Run("multiple emojis with nonexistent names", func(t *testing.T) {
+		received, err := ss.Emoji().GetMultipleByName(rctx, []string{emojis[0].Name, emojis[1].Name, emojis[2].Name, "abcd", "1234"})
+		require.NoError(t, err, "could not get emojis")
+		require.Len(t, received, 3, "got incorrect emojis")
+	})
+}
+
+func testEmojiGetList(t *testing.T, rctx request.CTX, ss store.Store) {
+	emojis := []model.Emoji{
+		{
+			CreatorId: model.NewId(),
+			Name:      "00000000000000000000000000a" + model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      "00000000000000000000000000b" + model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      "00000000000000000000000000c" + model.NewId(),
+		},
+	}
+
+	for i, emoji := range emojis {
+		data, err := ss.Emoji().Save(&emoji)
+		require.NoError(t, err)
+		emojis[i] = *data
+	}
+	defer func() {
+		for _, emoji := range emojis {
+			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
+			require.NoError(t, err)
+		}
+	}()
+
+	result, err := ss.Emoji().GetList(0, 100, "")
+	require.NoError(t, err)
+
+	for _, emoji := range emojis {
+		found := false
+
+		for _, savedEmoji := range result {
+			if emoji.Id == savedEmoji.Id {
+				found = true
+				break
+			}
+		}
+
+		require.Truef(t, found, "failed to get emoji with id %v", emoji.Id)
+	}
+
+	remojis, err := ss.Emoji().GetList(0, 3, model.EmojiSortByName)
+	assert.NoError(t, err)
+	assert.Equal(t, 3, len(remojis))
+	assert.Equal(t, emojis[0].Name, remojis[0].Name)
+	assert.Equal(t, emojis[1].Name, remojis[1].Name)
+	assert.Equal(t, emojis[2].Name, remojis[2].Name)
+
+	remojis, err = ss.Emoji().GetList(1, 2, model.EmojiSortByName)
+	assert.NoError(t, err)
+	assert.Equal(t, 2, len(remojis))
+	assert.Equal(t, emojis[1].Name, remojis[0].Name)
+	assert.Equal(t, emojis[2].Name, remojis[1].Name)
+}
+
+func testEmojiSearch(t *testing.T, rctx request.CTX, ss store.Store) {
+	emojis := []model.Emoji{
+		{
+			CreatorId: model.NewId(),
+			Name:      "blargh_" + model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId() + "_blargh",
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId() + "_blargh_" + model.NewId(),
+		},
+		{
+			CreatorId: model.NewId(),
+			Name:      model.NewId(),
+		},
+	}
+
+	for i, emoji := range emojis {
+		data, err := ss.Emoji().Save(&emoji)
+		require.NoError(t, err)
+		emojis[i] = *data
+	}
+	defer func() {
+		for _, emoji := range emojis {
+			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
+			require.NoError(t, err)
+		}
+	}()
+
+	shouldFind := []bool{true, false, false, false}
+
+	result, err := ss.Emoji().Search("blargh", true, 100)
+	require.NoError(t, err)
+	for i, emoji := range emojis {
+		found := false
+
+		for _, savedEmoji := range result {
+			if emoji.Id == savedEmoji.Id {
+				found = true
+				break
+			}
+		}
+
+		assert.Equal(t, shouldFind[i], found, emoji.Name)
+	}
+
+	shouldFind = []bool{true, true, true, false}
+	result, err = ss.Emoji().Search("blargh", false, 100)
+	require.NoError(t, err)
+	for i, emoji := range emojis {
+		found := false
+
+		for _, savedEmoji := range result {
+			if emoji.Id == savedEmoji.Id {
+				found = true
+				break
+			}
+		}
+
+		assert.Equal(t, shouldFind[i], found, emoji.Name)
+	}
+}

server/channels/store/storetest/license_store.go

@@ -0,0 +1,53 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestLicenseStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("Save", func(t *testing.T) { testLicenseStoreSave(t, rctx, ss) })
+	t.Run("Get", func(t *testing.T) { testLicenseStoreGet(t, rctx, ss) })
+}
+
+func testLicenseStoreSave(t *testing.T, rctx request.CTX, ss store.Store) {
+	l1 := model.LicenseRecord{}
+	l1.Id = model.NewId()
+	l1.Bytes = "junk"
+
+	err := ss.License().Save(&l1)
+	require.NoError(t, err, "couldn't save license record")
+
+	err = ss.License().Save(&l1)
+	require.NoError(t, err, "shouldn't fail on trying to save existing license record")
+
+	l1.Id = ""
+
+	err = ss.License().Save(&l1)
+	require.Error(t, err, "should fail on invalid license")
+}
+
+func testLicenseStoreGet(t *testing.T, rctx request.CTX, ss store.Store) {
+	l1 := model.LicenseRecord{}
+	l1.Id = model.NewId()
+	l1.Bytes = "junk"
+
+	err := ss.License().Save(&l1)
+	require.NoError(t, err)
+
+	record, err := ss.License().Get(rctx, l1.Id)
+	require.NoError(t, err, "couldn't get license")
+
+	require.Equal(t, record.Bytes, l1.Bytes, "license bytes didn't match")
+
+	_, err = ss.License().Get(rctx, "missing")
+	require.Error(t, err, "should fail on get license")
+}

server/channels/store/storetest/link_metadata_store.go

@@ -0,0 +1,298 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/dyatlov/go-opengraph/opengraph"
+	"github.com/dyatlov/go-opengraph/opengraph/types/image"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+// These tests are ran on the same store instance, so this provides easier unique, valid timestamps
+var linkMetadataTimestamp int64 = 1546300800000
+
+func getNextLinkMetadataTimestamp() int64 {
+	linkMetadataTimestamp += int64(time.Hour) / (1000 * 1000)
+	return linkMetadataTimestamp
+}
+
+func TestLinkMetadataStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("Save", func(t *testing.T) { testLinkMetadataStoreSave(t, rctx, ss) })
+	t.Run("Get", func(t *testing.T) { testLinkMetadataStoreGet(t, rctx, ss) })
+	t.Run("Types", func(t *testing.T) { testLinkMetadataStoreTypes(t, rctx, ss) })
+	t.Run("HashCollisionHandling", func(t *testing.T) { testLinkMetadataStoreHashCollisionHandling(t, rctx, ss) })
+}
+
+func testLinkMetadataStoreSave(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("should save item", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeImage,
+			Data:      &model.PostImage{},
+		}
+
+		linkMetadata, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+		assert.Equal(t, *metadata, *linkMetadata)
+	})
+
+	t.Run("should fail to save invalid item", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "",
+			Timestamp: 0,
+			Type:      "garbage",
+			Data:      nil,
+		}
+
+		_, err := ss.LinkMetadata().Save(metadata)
+
+		assert.Error(t, err)
+	})
+
+	t.Run("should save with duplicate URL and different timestamp", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeImage,
+			Data:      &model.PostImage{},
+		}
+
+		_, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+
+		metadata.Timestamp = getNextLinkMetadataTimestamp()
+
+		linkMetadata, err := ss.LinkMetadata().Save(metadata)
+
+		require.NoError(t, err)
+		assert.Equal(t, *metadata, *linkMetadata)
+	})
+
+	t.Run("should save with duplicate timestamp and different URL", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeImage,
+			Data:      &model.PostImage{},
+		}
+
+		_, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+
+		metadata.URL = "http://example.com/another/page"
+
+		linkMetadata, err := ss.LinkMetadata().Save(metadata)
+
+		require.NoError(t, err)
+		assert.Equal(t, *metadata, *linkMetadata)
+	})
+
+	t.Run("should save data with duplicate URL and timestamp", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeImage,
+			Data:      &model.PostImage{},
+		}
+
+		linkMetadata, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+		assert.Equal(t, &model.PostImage{}, linkMetadata.Data)
+
+		newData := &model.PostImage{Height: 10, Width: 20}
+		metadata.Data = newData
+
+		linkMetadata, err = ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+		assert.Equal(t, newData, linkMetadata.Data)
+
+		// Should return the original result, not the duplicate one
+		linkMetadata, err = ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
+		require.NoError(t, err)
+		assert.Equal(t, newData, linkMetadata.Data)
+	})
+}
+
+func testLinkMetadataStoreGet(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("should get value", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeImage,
+			Data:      &model.PostImage{},
+		}
+
+		_, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+
+		linkMetadata, err := ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
+
+		require.NoError(t, err)
+		require.IsType(t, metadata, linkMetadata)
+		assert.Equal(t, *metadata, *linkMetadata)
+	})
+
+	t.Run("should return not found with incorrect URL", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeImage,
+			Data:      &model.PostImage{},
+		}
+
+		_, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+
+		_, err = ss.LinkMetadata().Get("http://example.com/another_page", metadata.Timestamp)
+
+		require.Error(t, err)
+		var nfErr *store.ErrNotFound
+		assert.True(t, errors.As(err, &nfErr))
+	})
+
+	t.Run("should return not found with incorrect timestamp", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeImage,
+			Data:      &model.PostImage{},
+		}
+
+		_, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+
+		_, err = ss.LinkMetadata().Get(metadata.URL, getNextLinkMetadataTimestamp())
+
+		require.Error(t, err)
+		var nfErr *store.ErrNotFound
+		assert.True(t, errors.As(err, &nfErr))
+	})
+}
+
+func testLinkMetadataStoreTypes(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("should save and get image metadata", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeImage,
+			Data: &model.PostImage{
+				Width:  123,
+				Height: 456,
+			},
+		}
+
+		received, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+
+		require.IsType(t, &model.PostImage{}, received.Data)
+		assert.Equal(t, *(metadata.Data.(*model.PostImage)), *(received.Data.(*model.PostImage)))
+
+		received, err = ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
+		require.NoError(t, err)
+
+		require.IsType(t, &model.PostImage{}, received.Data)
+		assert.Equal(t, *(metadata.Data.(*model.PostImage)), *(received.Data.(*model.PostImage)))
+	})
+
+	t.Run("should save and get opengraph data", func(t *testing.T) {
+		og := &opengraph.OpenGraph{
+			URL: "http://example.com",
+			Images: []*image.Image{
+				{
+					URL: "http://example.com/image.png",
+				},
+			},
+		}
+
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeOpengraph,
+			Data:      og,
+		}
+
+		received, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+
+		require.IsType(t, &opengraph.OpenGraph{}, received.Data)
+		assert.Equal(t, *(metadata.Data.(*opengraph.OpenGraph)), *(received.Data.(*opengraph.OpenGraph)))
+
+		received, err = ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
+		require.NoError(t, err)
+
+		require.IsType(t, &opengraph.OpenGraph{}, received.Data)
+		assert.Equal(t, *(metadata.Data.(*opengraph.OpenGraph)), *(received.Data.(*opengraph.OpenGraph)))
+	})
+
+	t.Run("should save and get nil", func(t *testing.T) {
+		metadata := &model.LinkMetadata{
+			URL:       "http://example.com",
+			Timestamp: getNextLinkMetadataTimestamp(),
+			Type:      model.LinkMetadataTypeNone,
+			Data:      nil,
+		}
+
+		received, err := ss.LinkMetadata().Save(metadata)
+		require.NoError(t, err)
+		assert.Nil(t, received.Data)
+
+		received, err = ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
+		require.NoError(t, err)
+
+		require.Nil(t, received.Data)
+	})
+}
+
+func testLinkMetadataStoreHashCollisionHandling(t *testing.T, rctx request.CTX, ss store.Store) {
+	testTimestamp := int64(1640995200000) // 2022-01-01 00:00:00 UTC
+	url1 := "http://test.com/w4xg6hpvomau9j5iz371"
+	url2 := "http://collision.comupio5zw28x1m36c"
+
+	hash1 := model.GenerateLinkMetadataHash(url1, testTimestamp)
+	hash2 := model.GenerateLinkMetadataHash(url2, testTimestamp)
+	assert.Equal(t, hash1, hash2, "URLs should have colliding hashes")
+
+	metadata1 := &model.LinkMetadata{
+		URL:       url1,
+		Timestamp: testTimestamp,
+		Type:      model.LinkMetadataTypeOpengraph,
+		Data:      &opengraph.OpenGraph{Title: "First URL Title"},
+	}
+	_, err := ss.LinkMetadata().Save(metadata1)
+	require.NoError(t, err)
+
+	retrieved, err := ss.LinkMetadata().Get(url1, testTimestamp)
+	require.NoError(t, err)
+	assert.Equal(t, url1, retrieved.URL)
+	assert.Equal(t, "First URL Title", retrieved.Data.(*opengraph.OpenGraph).Title)
+
+	metadata2 := &model.LinkMetadata{
+		URL:       url2,
+		Timestamp: testTimestamp,
+		Type:      model.LinkMetadataTypeOpengraph,
+		Data:      &opengraph.OpenGraph{Title: "Second URL Title"},
+	}
+	_, err = ss.LinkMetadata().Save(metadata2)
+	require.NoError(t, err)
+
+	retrieved, err = ss.LinkMetadata().Get(url2, testTimestamp)
+	require.NoError(t, err)
+	assert.Equal(t, url2, retrieved.URL)
+	assert.Equal(t, "Second URL Title", retrieved.Data.(*opengraph.OpenGraph).Title)
+
+	_, err = ss.LinkMetadata().Get(url1, testTimestamp)
+	require.Error(t, err)
+	var nfErr *store.ErrNotFound
+	assert.True(t, errors.As(err, &nfErr))
+}

server/channels/store/storetest/mocks/AccessControlPolicyStore.go

@@ -0,0 +1,333 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// AccessControlPolicyStore is an autogenerated mock type for the AccessControlPolicyStore type
+type AccessControlPolicyStore struct {
+	mock.Mock
+}
+
+// ClearEtagCache provides a mock function with no fields
+func (_m *AccessControlPolicyStore) ClearEtagCache() {
+	_m.Called()
+}
+
+// Delete provides a mock function with given fields: rctx, id
+func (_m *AccessControlPolicyStore) Delete(rctx request.CTX, id string) error {
+	ret := _m.Called(rctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
+		r0 = rf(rctx, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: rctx, id
+func (_m *AccessControlPolicyStore) Get(rctx request.CTX, id string) (*model.AccessControlPolicy, error) {
+	ret := _m.Called(rctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.AccessControlPolicy
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.AccessControlPolicy, error)); ok {
+		return rf(rctx, id)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.AccessControlPolicy); ok {
+		r0 = rf(rctx, id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AccessControlPolicy)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetActionsForPolicies provides a mock function with given fields: rctx, policyIDs
+func (_m *AccessControlPolicyStore) GetActionsForPolicies(rctx request.CTX, policyIDs []string) (map[string]map[string]bool, error) {
+	ret := _m.Called(rctx, policyIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetActionsForPolicies")
+	}
+
+	var r0 map[string]map[string]bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, []string) (map[string]map[string]bool, error)); ok {
+		return rf(rctx, policyIDs)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, []string) map[string]map[string]bool); ok {
+		r0 = rf(rctx, policyIDs)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]map[string]bool)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, []string) error); ok {
+		r1 = rf(rctx, policyIDs)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetActionsForPolicy provides a mock function with given fields: rctx, policyID
+func (_m *AccessControlPolicyStore) GetActionsForPolicy(rctx request.CTX, policyID string) (map[string]bool, error) {
+	ret := _m.Called(rctx, policyID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetActionsForPolicy")
+	}
+
+	var r0 map[string]bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (map[string]bool, error)); ok {
+		return rf(rctx, policyID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) map[string]bool); ok {
+		r0 = rf(rctx, policyID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]bool)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, policyID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetEtagEpoch provides a mock function with given fields: rctx, channelID
+func (_m *AccessControlPolicyStore) GetEtagEpoch(rctx request.CTX, channelID string) (string, error) {
+	ret := _m.Called(rctx, channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetEtagEpoch")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (string, error)); ok {
+		return rf(rctx, channelID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) string); ok {
+		r0 = rf(rctx, channelID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPoliciesByFieldID provides a mock function with given fields: rctx, fieldID
+func (_m *AccessControlPolicyStore) GetPoliciesByFieldID(rctx request.CTX, fieldID string) ([]*model.AccessControlPolicy, error) {
+	ret := _m.Called(rctx, fieldID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPoliciesByFieldID")
+	}
+
+	var r0 []*model.AccessControlPolicy
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) ([]*model.AccessControlPolicy, error)); ok {
+		return rf(rctx, fieldID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) []*model.AccessControlPolicy); ok {
+		r0 = rf(rctx, fieldID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.AccessControlPolicy)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, fieldID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InvalidateEtagForChannel provides a mock function with given fields: channelID
+func (_m *AccessControlPolicyStore) InvalidateEtagForChannel(channelID string) {
+	_m.Called(channelID)
+}
+
+// Save provides a mock function with given fields: rctx, policy
+func (_m *AccessControlPolicyStore) Save(rctx request.CTX, policy *model.AccessControlPolicy) (*model.AccessControlPolicy, error) {
+	ret := _m.Called(rctx, policy)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.AccessControlPolicy
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.AccessControlPolicy) (*model.AccessControlPolicy, error)); ok {
+		return rf(rctx, policy)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.AccessControlPolicy) *model.AccessControlPolicy); ok {
+		r0 = rf(rctx, policy)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AccessControlPolicy)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.AccessControlPolicy) error); ok {
+		r1 = rf(rctx, policy)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SearchPolicies provides a mock function with given fields: rctx, opts
+func (_m *AccessControlPolicyStore) SearchPolicies(rctx request.CTX, opts model.AccessControlPolicySearch) ([]*model.AccessControlPolicy, int64, error) {
+	ret := _m.Called(rctx, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SearchPolicies")
+	}
+
+	var r0 []*model.AccessControlPolicy
+	var r1 int64
+	var r2 error
+	if rf, ok := ret.Get(0).(func(request.CTX, model.AccessControlPolicySearch) ([]*model.AccessControlPolicy, int64, error)); ok {
+		return rf(rctx, opts)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, model.AccessControlPolicySearch) []*model.AccessControlPolicy); ok {
+		r0 = rf(rctx, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.AccessControlPolicy)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, model.AccessControlPolicySearch) int64); ok {
+		r1 = rf(rctx, opts)
+	} else {
+		r1 = ret.Get(1).(int64)
+	}
+
+	if rf, ok := ret.Get(2).(func(request.CTX, model.AccessControlPolicySearch) error); ok {
+		r2 = rf(rctx, opts)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// SetActiveStatus provides a mock function with given fields: rctx, id, active
+func (_m *AccessControlPolicyStore) SetActiveStatus(rctx request.CTX, id string, active bool) (*model.AccessControlPolicy, error) {
+	ret := _m.Called(rctx, id, active)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetActiveStatus")
+	}
+
+	var r0 *model.AccessControlPolicy
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, bool) (*model.AccessControlPolicy, error)); ok {
+		return rf(rctx, id, active)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, bool) *model.AccessControlPolicy); ok {
+		r0 = rf(rctx, id, active)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AccessControlPolicy)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, bool) error); ok {
+		r1 = rf(rctx, id, active)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SetActiveStatusMultiple provides a mock function with given fields: rctx, list
+func (_m *AccessControlPolicyStore) SetActiveStatusMultiple(rctx request.CTX, list []model.AccessControlPolicyActiveUpdate) ([]*model.AccessControlPolicy, error) {
+	ret := _m.Called(rctx, list)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetActiveStatusMultiple")
+	}
+
+	var r0 []*model.AccessControlPolicy
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, []model.AccessControlPolicyActiveUpdate) ([]*model.AccessControlPolicy, error)); ok {
+		return rf(rctx, list)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, []model.AccessControlPolicyActiveUpdate) []*model.AccessControlPolicy); ok {
+		r0 = rf(rctx, list)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.AccessControlPolicy)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, []model.AccessControlPolicyActiveUpdate) error); ok {
+		r1 = rf(rctx, list)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewAccessControlPolicyStore creates a new instance of AccessControlPolicyStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewAccessControlPolicyStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *AccessControlPolicyStore {
+	mock := &AccessControlPolicyStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/AttributesStore.go

@@ -0,0 +1,213 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// AttributesStore is an autogenerated mock type for the AttributesStore type
+type AttributesStore struct {
+	mock.Mock
+}
+
+// ClearUserPropertyValuesEpochCache provides a mock function with no fields
+func (_m *AttributesStore) ClearUserPropertyValuesEpochCache() {
+	_m.Called()
+}
+
+// GetChannelMembersToRemove provides a mock function with given fields: rctx, channelID, opts
+func (_m *AttributesStore) GetChannelMembersToRemove(rctx request.CTX, channelID string, opts model.SubjectSearchOptions) ([]*model.ChannelMember, error) {
+	ret := _m.Called(rctx, channelID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetChannelMembersToRemove")
+	}
+
+	var r0 []*model.ChannelMember
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, model.SubjectSearchOptions) ([]*model.ChannelMember, error)); ok {
+		return rf(rctx, channelID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, model.SubjectSearchOptions) []*model.ChannelMember); ok {
+		r0 = rf(rctx, channelID, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ChannelMember)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, model.SubjectSearchOptions) error); ok {
+		r1 = rf(rctx, channelID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetSubject provides a mock function with given fields: rctx, ID, groupID, objectType
+func (_m *AttributesStore) GetSubject(rctx request.CTX, ID string, groupID string, objectType string) (*model.Subject, error) {
+	ret := _m.Called(rctx, ID, groupID, objectType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSubject")
+	}
+
+	var r0 *model.Subject
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, string) (*model.Subject, error)); ok {
+		return rf(rctx, ID, groupID, objectType)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, string) *model.Subject); ok {
+		r0 = rf(rctx, ID, groupID, objectType)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Subject)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string, string) error); ok {
+		r1 = rf(rctx, ID, groupID, objectType)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTeamMembersToRemove provides a mock function with given fields: rctx, teamID, opts
+func (_m *AttributesStore) GetTeamMembersToRemove(rctx request.CTX, teamID string, opts model.SubjectSearchOptions) ([]*model.TeamMember, error) {
+	ret := _m.Called(rctx, teamID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTeamMembersToRemove")
+	}
+
+	var r0 []*model.TeamMember
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, model.SubjectSearchOptions) ([]*model.TeamMember, error)); ok {
+		return rf(rctx, teamID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, model.SubjectSearchOptions) []*model.TeamMember); ok {
+		r0 = rf(rctx, teamID, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.TeamMember)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, model.SubjectSearchOptions) error); ok {
+		r1 = rf(rctx, teamID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUserPropertyValuesEpoch provides a mock function with given fields: rctx, userID
+func (_m *AttributesStore) GetUserPropertyValuesEpoch(rctx request.CTX, userID string) (string, error) {
+	ret := _m.Called(rctx, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUserPropertyValuesEpoch")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (string, error)); ok {
+		return rf(rctx, userID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) string); ok {
+		r0 = rf(rctx, userID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InvalidateUserPropertyValuesEpoch provides a mock function with given fields: userID
+func (_m *AttributesStore) InvalidateUserPropertyValuesEpoch(userID string) {
+	_m.Called(userID)
+}
+
+// RefreshAttributes provides a mock function with no fields
+func (_m *AttributesStore) RefreshAttributes() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for RefreshAttributes")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SearchUsers provides a mock function with given fields: rctx, opts
+func (_m *AttributesStore) SearchUsers(rctx request.CTX, opts model.SubjectSearchOptions) ([]*model.User, int64, error) {
+	ret := _m.Called(rctx, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SearchUsers")
+	}
+
+	var r0 []*model.User
+	var r1 int64
+	var r2 error
+	if rf, ok := ret.Get(0).(func(request.CTX, model.SubjectSearchOptions) ([]*model.User, int64, error)); ok {
+		return rf(rctx, opts)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, model.SubjectSearchOptions) []*model.User); ok {
+		r0 = rf(rctx, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.User)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, model.SubjectSearchOptions) int64); ok {
+		r1 = rf(rctx, opts)
+	} else {
+		r1 = ret.Get(1).(int64)
+	}
+
+	if rf, ok := ret.Get(2).(func(request.CTX, model.SubjectSearchOptions) error); ok {
+		r2 = rf(rctx, opts)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// NewAttributesStore creates a new instance of AttributesStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewAttributesStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *AttributesStore {
+	mock := &AttributesStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/AuditStore.go

@@ -0,0 +1,95 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// AuditStore is an autogenerated mock type for the AuditStore type
+type AuditStore struct {
+	mock.Mock
+}
+
+// Get provides a mock function with given fields: userID, offset, limit
+func (_m *AuditStore) Get(userID string, offset int, limit int) (model.Audits, error) {
+	ret := _m.Called(userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 model.Audits
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) (model.Audits, error)); ok {
+		return rf(userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) model.Audits); ok {
+		r0 = rf(userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(model.Audits)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteByUser provides a mock function with given fields: userID
+func (_m *AuditStore) PermanentDeleteByUser(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: audit
+func (_m *AuditStore) Save(audit *model.Audit) error {
+	ret := _m.Called(audit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Audit) error); ok {
+		r0 = rf(audit)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewAuditStore creates a new instance of AuditStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewAuditStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *AuditStore {
+	mock := &AuditStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/AutoTranslationStore.go

@@ -0,0 +1,331 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// AutoTranslationStore is an autogenerated mock type for the AutoTranslationStore type
+type AutoTranslationStore struct {
+	mock.Mock
+}
+
+// ClearCaches provides a mock function with no fields
+func (_m *AutoTranslationStore) ClearCaches() {
+	_m.Called()
+}
+
+// Get provides a mock function with given fields: objectType, objectID, dstLang
+func (_m *AutoTranslationStore) Get(objectType string, objectID string, dstLang string) (*model.Translation, error) {
+	ret := _m.Called(objectType, objectID, dstLang)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Translation
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, string) (*model.Translation, error)); ok {
+		return rf(objectType, objectID, dstLang)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, string) *model.Translation); ok {
+		r0 = rf(objectType, objectID, dstLang)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Translation)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
+		r1 = rf(objectType, objectID, dstLang)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetActiveDestinationLanguages provides a mock function with given fields: channelID, excludeUserID, filterUserIDs
+func (_m *AutoTranslationStore) GetActiveDestinationLanguages(channelID string, excludeUserID string, filterUserIDs []string) ([]string, error) {
+	ret := _m.Called(channelID, excludeUserID, filterUserIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetActiveDestinationLanguages")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, []string) ([]string, error)); ok {
+		return rf(channelID, excludeUserID, filterUserIDs)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, []string) []string); ok {
+		r0 = rf(channelID, excludeUserID, filterUserIDs)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, []string) error); ok {
+		r1 = rf(channelID, excludeUserID, filterUserIDs)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllForObject provides a mock function with given fields: objectType, objectID
+func (_m *AutoTranslationStore) GetAllForObject(objectType string, objectID string) ([]*model.Translation, error) {
+	ret := _m.Called(objectType, objectID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllForObject")
+	}
+
+	var r0 []*model.Translation
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) ([]*model.Translation, error)); ok {
+		return rf(objectType, objectID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) []*model.Translation); ok {
+		r0 = rf(objectType, objectID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Translation)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(objectType, objectID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetBatch provides a mock function with given fields: objectType, objectIDs, dstLang
+func (_m *AutoTranslationStore) GetBatch(objectType string, objectIDs []string, dstLang string) (map[string]*model.Translation, error) {
+	ret := _m.Called(objectType, objectIDs, dstLang)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetBatch")
+	}
+
+	var r0 map[string]*model.Translation
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, []string, string) (map[string]*model.Translation, error)); ok {
+		return rf(objectType, objectIDs, dstLang)
+	}
+	if rf, ok := ret.Get(0).(func(string, []string, string) map[string]*model.Translation); ok {
+		r0 = rf(objectType, objectIDs, dstLang)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]*model.Translation)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, []string, string) error); ok {
+		r1 = rf(objectType, objectIDs, dstLang)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByStateOlderThan provides a mock function with given fields: state, olderThanMillis, limit
+func (_m *AutoTranslationStore) GetByStateOlderThan(state model.TranslationState, olderThanMillis int64, limit int) ([]*model.Translation, error) {
+	ret := _m.Called(state, olderThanMillis, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByStateOlderThan")
+	}
+
+	var r0 []*model.Translation
+	var r1 error
+	if rf, ok := ret.Get(0).(func(model.TranslationState, int64, int) ([]*model.Translation, error)); ok {
+		return rf(state, olderThanMillis, limit)
+	}
+	if rf, ok := ret.Get(0).(func(model.TranslationState, int64, int) []*model.Translation); ok {
+		r0 = rf(state, olderThanMillis, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Translation)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(model.TranslationState, int64, int) error); ok {
+		r1 = rf(state, olderThanMillis, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetLatestPostUpdateAtForChannel provides a mock function with given fields: channelID
+func (_m *AutoTranslationStore) GetLatestPostUpdateAtForChannel(channelID string) (int64, error) {
+	ret := _m.Called(channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLatestPostUpdateAtForChannel")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(channelID)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(channelID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTranslationsSinceForChannel provides a mock function with given fields: channelID, dstLang, since
+func (_m *AutoTranslationStore) GetTranslationsSinceForChannel(channelID string, dstLang string, since int64) (map[string]*model.Translation, error) {
+	ret := _m.Called(channelID, dstLang, since)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTranslationsSinceForChannel")
+	}
+
+	var r0 map[string]*model.Translation
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, int64) (map[string]*model.Translation, error)); ok {
+		return rf(channelID, dstLang, since)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, int64) map[string]*model.Translation); ok {
+		r0 = rf(channelID, dstLang, since)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]*model.Translation)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, int64) error); ok {
+		r1 = rf(channelID, dstLang, since)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUserLanguage provides a mock function with given fields: userID, channelID
+func (_m *AutoTranslationStore) GetUserLanguage(userID string, channelID string) (string, error) {
+	ret := _m.Called(userID, channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUserLanguage")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (string, error)); ok {
+		return rf(userID, channelID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) string); ok {
+		r0 = rf(userID, channelID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(userID, channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InvalidatePostTranslationEtag provides a mock function with given fields: channelID
+func (_m *AutoTranslationStore) InvalidatePostTranslationEtag(channelID string) {
+	_m.Called(channelID)
+}
+
+// InvalidateUserAutoTranslation provides a mock function with given fields: userID, channelID
+func (_m *AutoTranslationStore) InvalidateUserAutoTranslation(userID string, channelID string) {
+	_m.Called(userID, channelID)
+}
+
+// InvalidateUserLocaleCache provides a mock function with given fields: userID
+func (_m *AutoTranslationStore) InvalidateUserLocaleCache(userID string) {
+	_m.Called(userID)
+}
+
+// IsUserEnabled provides a mock function with given fields: userID, channelID
+func (_m *AutoTranslationStore) IsUserEnabled(userID string, channelID string) (bool, error) {
+	ret := _m.Called(userID, channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IsUserEnabled")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (bool, error)); ok {
+		return rf(userID, channelID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) bool); ok {
+		r0 = rf(userID, channelID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(userID, channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: translation
+func (_m *AutoTranslationStore) Save(translation *model.Translation) error {
+	ret := _m.Called(translation)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Translation) error); ok {
+		r0 = rf(translation)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewAutoTranslationStore creates a new instance of AutoTranslationStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewAutoTranslationStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *AutoTranslationStore {
+	mock := &AutoTranslationStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/BotStore.go

@@ -0,0 +1,227 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// BotStore is an autogenerated mock type for the BotStore type
+type BotStore struct {
+	mock.Mock
+}
+
+// Get provides a mock function with given fields: userID, includeDeleted
+func (_m *BotStore) Get(userID string, includeDeleted bool) (*model.Bot, error) {
+	ret := _m.Called(userID, includeDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Bot
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool) (*model.Bot, error)); ok {
+		return rf(userID, includeDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool) *model.Bot); ok {
+		r0 = rf(userID, includeDeleted)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Bot)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(userID, includeDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with given fields: options
+func (_m *BotStore) GetAll(options *model.BotGetOptions) ([]*model.Bot, error) {
+	ret := _m.Called(options)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 []*model.Bot
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.BotGetOptions) ([]*model.Bot, error)); ok {
+		return rf(options)
+	}
+	if rf, ok := ret.Get(0).(func(*model.BotGetOptions) []*model.Bot); ok {
+		r0 = rf(options)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Bot)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.BotGetOptions) error); ok {
+		r1 = rf(options)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllAfter provides a mock function with given fields: limit, afterId
+func (_m *BotStore) GetAllAfter(limit int, afterId string) ([]*model.Bot, error) {
+	ret := _m.Called(limit, afterId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllAfter")
+	}
+
+	var r0 []*model.Bot
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, string) ([]*model.Bot, error)); ok {
+		return rf(limit, afterId)
+	}
+	if rf, ok := ret.Get(0).(func(int, string) []*model.Bot); ok {
+		r0 = rf(limit, afterId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Bot)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, string) error); ok {
+		r1 = rf(limit, afterId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByUsername provides a mock function with given fields: username
+func (_m *BotStore) GetByUsername(username string) (*model.Bot, error) {
+	ret := _m.Called(username)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByUsername")
+	}
+
+	var r0 *model.Bot
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Bot, error)); ok {
+		return rf(username)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Bot); ok {
+		r0 = rf(username)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Bot)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(username)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDelete provides a mock function with given fields: userID
+func (_m *BotStore) PermanentDelete(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: bot
+func (_m *BotStore) Save(bot *model.Bot) (*model.Bot, error) {
+	ret := _m.Called(bot)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.Bot
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Bot) (*model.Bot, error)); ok {
+		return rf(bot)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Bot) *model.Bot); ok {
+		r0 = rf(bot)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Bot)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Bot) error); ok {
+		r1 = rf(bot)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: bot
+func (_m *BotStore) Update(bot *model.Bot) (*model.Bot, error) {
+	ret := _m.Called(bot)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 *model.Bot
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Bot) (*model.Bot, error)); ok {
+		return rf(bot)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Bot) *model.Bot); ok {
+		r0 = rf(bot)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Bot)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Bot) error); ok {
+		r1 = rf(bot)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewBotStore creates a new instance of BotStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewBotStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *BotStore {
+	mock := &BotStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ChannelBookmarkStore.go

@@ -0,0 +1,203 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ChannelBookmarkStore is an autogenerated mock type for the ChannelBookmarkStore type
+type ChannelBookmarkStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: bookmarkID, deleteFile
+func (_m *ChannelBookmarkStore) Delete(bookmarkID string, deleteFile bool) error {
+	ret := _m.Called(bookmarkID, deleteFile)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, bool) error); ok {
+		r0 = rf(bookmarkID, deleteFile)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ErrorIfBookmarkFileInfoAlreadyAttached provides a mock function with given fields: fileID, channelID
+func (_m *ChannelBookmarkStore) ErrorIfBookmarkFileInfoAlreadyAttached(fileID string, channelID string) error {
+	ret := _m.Called(fileID, channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ErrorIfBookmarkFileInfoAlreadyAttached")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(fileID, channelID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: Id, includeDeleted
+func (_m *ChannelBookmarkStore) Get(Id string, includeDeleted bool) (*model.ChannelBookmarkWithFileInfo, error) {
+	ret := _m.Called(Id, includeDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.ChannelBookmarkWithFileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool) (*model.ChannelBookmarkWithFileInfo, error)); ok {
+		return rf(Id, includeDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool) *model.ChannelBookmarkWithFileInfo); ok {
+		r0 = rf(Id, includeDeleted)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelBookmarkWithFileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(Id, includeDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetBookmarksForChannelSince provides a mock function with given fields: channelID, since
+func (_m *ChannelBookmarkStore) GetBookmarksForChannelSince(channelID string, since int64) ([]*model.ChannelBookmarkWithFileInfo, error) {
+	ret := _m.Called(channelID, since)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetBookmarksForChannelSince")
+	}
+
+	var r0 []*model.ChannelBookmarkWithFileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64) ([]*model.ChannelBookmarkWithFileInfo, error)); ok {
+		return rf(channelID, since)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64) []*model.ChannelBookmarkWithFileInfo); ok {
+		r0 = rf(channelID, since)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ChannelBookmarkWithFileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64) error); ok {
+		r1 = rf(channelID, since)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: bookmark, increaseSortOrder
+func (_m *ChannelBookmarkStore) Save(bookmark *model.ChannelBookmark, increaseSortOrder bool) (*model.ChannelBookmarkWithFileInfo, error) {
+	ret := _m.Called(bookmark, increaseSortOrder)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.ChannelBookmarkWithFileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ChannelBookmark, bool) (*model.ChannelBookmarkWithFileInfo, error)); ok {
+		return rf(bookmark, increaseSortOrder)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ChannelBookmark, bool) *model.ChannelBookmarkWithFileInfo); ok {
+		r0 = rf(bookmark, increaseSortOrder)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelBookmarkWithFileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ChannelBookmark, bool) error); ok {
+		r1 = rf(bookmark, increaseSortOrder)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: bookmark
+func (_m *ChannelBookmarkStore) Update(bookmark *model.ChannelBookmark) error {
+	ret := _m.Called(bookmark)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.ChannelBookmark) error); ok {
+		r0 = rf(bookmark)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateSortOrder provides a mock function with given fields: bookmarkID, channelID, newIndex
+func (_m *ChannelBookmarkStore) UpdateSortOrder(bookmarkID string, channelID string, newIndex int64) ([]*model.ChannelBookmarkWithFileInfo, error) {
+	ret := _m.Called(bookmarkID, channelID, newIndex)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateSortOrder")
+	}
+
+	var r0 []*model.ChannelBookmarkWithFileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, int64) ([]*model.ChannelBookmarkWithFileInfo, error)); ok {
+		return rf(bookmarkID, channelID, newIndex)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, int64) []*model.ChannelBookmarkWithFileInfo); ok {
+		r0 = rf(bookmarkID, channelID, newIndex)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ChannelBookmarkWithFileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, int64) error); ok {
+		r1 = rf(bookmarkID, channelID, newIndex)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewChannelBookmarkStore creates a new instance of ChannelBookmarkStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewChannelBookmarkStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ChannelBookmarkStore {
+	mock := &ChannelBookmarkStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ChannelGuardStore.go

@@ -0,0 +1,136 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	store "github.com/mattermost/mattermost/server/v8/channels/store"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ChannelGuardStore is an autogenerated mock type for the ChannelGuardStore type
+type ChannelGuardStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: rctx, channelID, pluginID
+func (_m *ChannelGuardStore) Delete(rctx request.CTX, channelID string, pluginID string) (int64, error) {
+	ret := _m.Called(rctx, channelID, pluginID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) (int64, error)); ok {
+		return rf(rctx, channelID, pluginID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) int64); ok {
+		r0 = rf(rctx, channelID, pluginID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string) error); ok {
+		r1 = rf(rctx, channelID, pluginID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with given fields: rctx
+func (_m *ChannelGuardStore) GetAll(rctx request.CTX) ([]*store.ChannelGuard, error) {
+	ret := _m.Called(rctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 []*store.ChannelGuard
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX) ([]*store.ChannelGuard, error)); ok {
+		return rf(rctx)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX) []*store.ChannelGuard); ok {
+		r0 = rf(rctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*store.ChannelGuard)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX) error); ok {
+		r1 = rf(rctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForChannel provides a mock function with given fields: rctx, channelID
+func (_m *ChannelGuardStore) GetForChannel(rctx request.CTX, channelID string) ([]*store.ChannelGuard, error) {
+	ret := _m.Called(rctx, channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForChannel")
+	}
+
+	var r0 []*store.ChannelGuard
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) ([]*store.ChannelGuard, error)); ok {
+		return rf(rctx, channelID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) []*store.ChannelGuard); ok {
+		r0 = rf(rctx, channelID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*store.ChannelGuard)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: rctx, guard
+func (_m *ChannelGuardStore) Save(rctx request.CTX, guard *store.ChannelGuard) error {
+	ret := _m.Called(rctx, guard)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *store.ChannelGuard) error); ok {
+		r0 = rf(rctx, guard)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewChannelGuardStore creates a new instance of ChannelGuardStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewChannelGuardStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ChannelGuardStore {
+	mock := &ChannelGuardStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ChannelJoinRequestStore.go

@@ -0,0 +1,251 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ChannelJoinRequestStore is an autogenerated mock type for the ChannelJoinRequestStore type
+type ChannelJoinRequestStore struct {
+	mock.Mock
+}
+
+// CountPending provides a mock function with given fields: channelId
+func (_m *ChannelJoinRequestStore) CountPending(channelId string) (int64, error) {
+	ret := _m.Called(channelId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountPending")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(channelId)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(channelId)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(channelId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: id
+func (_m *ChannelJoinRequestStore) Get(id string) (*model.ChannelJoinRequest, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.ChannelJoinRequest
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.ChannelJoinRequest, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.ChannelJoinRequest); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelJoinRequest)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForChannel provides a mock function with given fields: channelId, opts
+func (_m *ChannelJoinRequestStore) GetForChannel(channelId string, opts model.GetChannelJoinRequestsOpts) ([]*model.ChannelJoinRequest, int64, error) {
+	ret := _m.Called(channelId, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForChannel")
+	}
+
+	var r0 []*model.ChannelJoinRequest
+	var r1 int64
+	var r2 error
+	if rf, ok := ret.Get(0).(func(string, model.GetChannelJoinRequestsOpts) ([]*model.ChannelJoinRequest, int64, error)); ok {
+		return rf(channelId, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, model.GetChannelJoinRequestsOpts) []*model.ChannelJoinRequest); ok {
+		r0 = rf(channelId, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ChannelJoinRequest)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, model.GetChannelJoinRequestsOpts) int64); ok {
+		r1 = rf(channelId, opts)
+	} else {
+		r1 = ret.Get(1).(int64)
+	}
+
+	if rf, ok := ret.Get(2).(func(string, model.GetChannelJoinRequestsOpts) error); ok {
+		r2 = rf(channelId, opts)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// GetForUser provides a mock function with given fields: userId, opts
+func (_m *ChannelJoinRequestStore) GetForUser(userId string, opts model.GetChannelJoinRequestsOpts) ([]*model.ChannelJoinRequest, int64, error) {
+	ret := _m.Called(userId, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForUser")
+	}
+
+	var r0 []*model.ChannelJoinRequest
+	var r1 int64
+	var r2 error
+	if rf, ok := ret.Get(0).(func(string, model.GetChannelJoinRequestsOpts) ([]*model.ChannelJoinRequest, int64, error)); ok {
+		return rf(userId, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, model.GetChannelJoinRequestsOpts) []*model.ChannelJoinRequest); ok {
+		r0 = rf(userId, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ChannelJoinRequest)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, model.GetChannelJoinRequestsOpts) int64); ok {
+		r1 = rf(userId, opts)
+	} else {
+		r1 = ret.Get(1).(int64)
+	}
+
+	if rf, ok := ret.Get(2).(func(string, model.GetChannelJoinRequestsOpts) error); ok {
+		r2 = rf(userId, opts)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// GetPendingForChannelAndUser provides a mock function with given fields: channelId, userId
+func (_m *ChannelJoinRequestStore) GetPendingForChannelAndUser(channelId string, userId string) (*model.ChannelJoinRequest, error) {
+	ret := _m.Called(channelId, userId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPendingForChannelAndUser")
+	}
+
+	var r0 *model.ChannelJoinRequest
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.ChannelJoinRequest, error)); ok {
+		return rf(channelId, userId)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.ChannelJoinRequest); ok {
+		r0 = rf(channelId, userId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelJoinRequest)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(channelId, userId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: req
+func (_m *ChannelJoinRequestStore) Save(req *model.ChannelJoinRequest) (*model.ChannelJoinRequest, error) {
+	ret := _m.Called(req)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.ChannelJoinRequest
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ChannelJoinRequest) (*model.ChannelJoinRequest, error)); ok {
+		return rf(req)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ChannelJoinRequest) *model.ChannelJoinRequest); ok {
+		r0 = rf(req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelJoinRequest)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ChannelJoinRequest) error); ok {
+		r1 = rf(req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: req
+func (_m *ChannelJoinRequestStore) Update(req *model.ChannelJoinRequest) (*model.ChannelJoinRequest, error) {
+	ret := _m.Called(req)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 *model.ChannelJoinRequest
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ChannelJoinRequest) (*model.ChannelJoinRequest, error)); ok {
+		return rf(req)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ChannelJoinRequest) *model.ChannelJoinRequest); ok {
+		r0 = rf(req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelJoinRequest)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ChannelJoinRequest) error); ok {
+		r1 = rf(req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewChannelJoinRequestStore creates a new instance of ChannelJoinRequestStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewChannelJoinRequestStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ChannelJoinRequestStore {
+	mock := &ChannelJoinRequestStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ChannelMemberHistoryStore.go

@@ -0,0 +1,307 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ChannelMemberHistoryStore is an autogenerated mock type for the ChannelMemberHistoryStore type
+type ChannelMemberHistoryStore struct {
+	mock.Mock
+}
+
+// DeleteOrphanedRows provides a mock function with given fields: limit
+func (_m *ChannelMemberHistoryStore) DeleteOrphanedRows(limit int) (int64, error) {
+	ret := _m.Called(limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteOrphanedRows")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int) (int64, error)); ok {
+		return rf(limit)
+	}
+	if rf, ok := ret.Get(0).(func(int) int64); ok {
+		r0 = rf(limit)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int) error); ok {
+		r1 = rf(limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChannelsLeftSince provides a mock function with given fields: userID, since
+func (_m *ChannelMemberHistoryStore) GetChannelsLeftSince(userID string, since int64) ([]string, error) {
+	ret := _m.Called(userID, since)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetChannelsLeftSince")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64) ([]string, error)); ok {
+		return rf(userID, since)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64) []string); ok {
+		r0 = rf(userID, since)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64) error); ok {
+		r1 = rf(userID, since)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChannelsWithActivityDuring provides a mock function with given fields: startTime, endTime
+func (_m *ChannelMemberHistoryStore) GetChannelsWithActivityDuring(startTime int64, endTime int64) ([]string, error) {
+	ret := _m.Called(startTime, endTime)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetChannelsWithActivityDuring")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, int64) ([]string, error)); ok {
+		return rf(startTime, endTime)
+	}
+	if rf, ok := ret.Get(0).(func(int64, int64) []string); ok {
+		r0 = rf(startTime, endTime)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
+		r1 = rf(startTime, endTime)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetEverMembersInChannel provides a mock function with given fields: channelID, userIDs
+func (_m *ChannelMemberHistoryStore) GetEverMembersInChannel(channelID string, userIDs []string) ([]string, error) {
+	ret := _m.Called(channelID, userIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetEverMembersInChannel")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, []string) ([]string, error)); ok {
+		return rf(channelID, userIDs)
+	}
+	if rf, ok := ret.Get(0).(func(string, []string) []string); ok {
+		r0 = rf(channelID, userIDs)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, []string) error); ok {
+		r1 = rf(channelID, userIDs)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMembershipChanges provides a mock function with given fields: channelID, since, limit
+func (_m *ChannelMemberHistoryStore) GetMembershipChanges(channelID string, since int64, limit int) ([]*model.ChannelMemberHistory, error) {
+	ret := _m.Called(channelID, since, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetMembershipChanges")
+	}
+
+	var r0 []*model.ChannelMemberHistory
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64, int) ([]*model.ChannelMemberHistory, error)); ok {
+		return rf(channelID, since, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64, int) []*model.ChannelMemberHistory); ok {
+		r0 = rf(channelID, since, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ChannelMemberHistory)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64, int) error); ok {
+		r1 = rf(channelID, since, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUsersInChannelDuring provides a mock function with given fields: startTime, endTime, channelID
+func (_m *ChannelMemberHistoryStore) GetUsersInChannelDuring(startTime int64, endTime int64, channelID []string) ([]*model.ChannelMemberHistoryResult, error) {
+	ret := _m.Called(startTime, endTime, channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUsersInChannelDuring")
+	}
+
+	var r0 []*model.ChannelMemberHistoryResult
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, int64, []string) ([]*model.ChannelMemberHistoryResult, error)); ok {
+		return rf(startTime, endTime, channelID)
+	}
+	if rf, ok := ret.Get(0).(func(int64, int64, []string) []*model.ChannelMemberHistoryResult); ok {
+		r0 = rf(startTime, endTime, channelID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ChannelMemberHistoryResult)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, int64, []string) error); ok {
+		r1 = rf(startTime, endTime, channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// LogJoinEvent provides a mock function with given fields: userID, channelID, joinTime
+func (_m *ChannelMemberHistoryStore) LogJoinEvent(userID string, channelID string, joinTime int64) error {
+	ret := _m.Called(userID, channelID, joinTime)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LogJoinEvent")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, int64) error); ok {
+		r0 = rf(userID, channelID, joinTime)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// LogLeaveEvent provides a mock function with given fields: rctx, userID, channelID, leaveTime
+func (_m *ChannelMemberHistoryStore) LogLeaveEvent(rctx request.CTX, userID string, channelID string, leaveTime int64) error {
+	ret := _m.Called(rctx, userID, channelID, leaveTime)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LogLeaveEvent")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, int64) error); ok {
+		r0 = rf(rctx, userID, channelID, leaveTime)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PermanentDeleteBatch provides a mock function with given fields: endTime, limit
+func (_m *ChannelMemberHistoryStore) PermanentDeleteBatch(endTime int64, limit int64) (int64, error) {
+	ret := _m.Called(endTime, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteBatch")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, int64) (int64, error)); ok {
+		return rf(endTime, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int64, int64) int64); ok {
+		r0 = rf(endTime, limit)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
+		r1 = rf(endTime, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteBatchForRetentionPolicies provides a mock function with given fields: retentionPolicyBatchConfigs, cursor
+func (_m *ChannelMemberHistoryStore) PermanentDeleteBatchForRetentionPolicies(retentionPolicyBatchConfigs model.RetentionPolicyBatchConfigs, cursor model.RetentionPolicyCursor) (int64, model.RetentionPolicyCursor, error) {
+	ret := _m.Called(retentionPolicyBatchConfigs, cursor)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteBatchForRetentionPolicies")
+	}
+
+	var r0 int64
+	var r1 model.RetentionPolicyCursor
+	var r2 error
+	if rf, ok := ret.Get(0).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) (int64, model.RetentionPolicyCursor, error)); ok {
+		return rf(retentionPolicyBatchConfigs, cursor)
+	}
+	if rf, ok := ret.Get(0).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) int64); ok {
+		r0 = rf(retentionPolicyBatchConfigs, cursor)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) model.RetentionPolicyCursor); ok {
+		r1 = rf(retentionPolicyBatchConfigs, cursor)
+	} else {
+		r1 = ret.Get(1).(model.RetentionPolicyCursor)
+	}
+
+	if rf, ok := ret.Get(2).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) error); ok {
+		r2 = rf(retentionPolicyBatchConfigs, cursor)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// NewChannelMemberHistoryStore creates a new instance of ChannelMemberHistoryStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewChannelMemberHistoryStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ChannelMemberHistoryStore {
+	mock := &ChannelMemberHistoryStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ClusterDiscoveryStore.go

@@ -0,0 +1,169 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ClusterDiscoveryStore is an autogenerated mock type for the ClusterDiscoveryStore type
+type ClusterDiscoveryStore struct {
+	mock.Mock
+}
+
+// Cleanup provides a mock function with no fields
+func (_m *ClusterDiscoveryStore) Cleanup() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Cleanup")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Delete provides a mock function with given fields: discovery
+func (_m *ClusterDiscoveryStore) Delete(discovery *model.ClusterDiscovery) (bool, error) {
+	ret := _m.Called(discovery)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) (bool, error)); ok {
+		return rf(discovery)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) bool); ok {
+		r0 = rf(discovery)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ClusterDiscovery) error); ok {
+		r1 = rf(discovery)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Exists provides a mock function with given fields: discovery
+func (_m *ClusterDiscoveryStore) Exists(discovery *model.ClusterDiscovery) (bool, error) {
+	ret := _m.Called(discovery)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Exists")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) (bool, error)); ok {
+		return rf(discovery)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) bool); ok {
+		r0 = rf(discovery)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ClusterDiscovery) error); ok {
+		r1 = rf(discovery)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with given fields: discoveryType, clusterName
+func (_m *ClusterDiscoveryStore) GetAll(discoveryType string, clusterName string) ([]*model.ClusterDiscovery, error) {
+	ret := _m.Called(discoveryType, clusterName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 []*model.ClusterDiscovery
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) ([]*model.ClusterDiscovery, error)); ok {
+		return rf(discoveryType, clusterName)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) []*model.ClusterDiscovery); ok {
+		r0 = rf(discoveryType, clusterName)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ClusterDiscovery)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(discoveryType, clusterName)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: discovery
+func (_m *ClusterDiscoveryStore) Save(discovery *model.ClusterDiscovery) error {
+	ret := _m.Called(discovery)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) error); ok {
+		r0 = rf(discovery)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SetLastPingAt provides a mock function with given fields: discovery
+func (_m *ClusterDiscoveryStore) SetLastPingAt(discovery *model.ClusterDiscovery) error {
+	ret := _m.Called(discovery)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetLastPingAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) error); ok {
+		r0 = rf(discovery)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewClusterDiscoveryStore creates a new instance of ClusterDiscoveryStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewClusterDiscoveryStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ClusterDiscoveryStore {
+	mock := &ClusterDiscoveryStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/CommandStore.go

@@ -0,0 +1,261 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// CommandStore is an autogenerated mock type for the CommandStore type
+type CommandStore struct {
+	mock.Mock
+}
+
+// AnalyticsCommandCount provides a mock function with given fields: teamID
+func (_m *CommandStore) AnalyticsCommandCount(teamID string) (int64, error) {
+	ret := _m.Called(teamID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AnalyticsCommandCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(teamID)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(teamID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(teamID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: commandID, timestamp
+func (_m *CommandStore) Delete(commandID string, timestamp int64) error {
+	ret := _m.Called(commandID, timestamp)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(commandID, timestamp)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: id
+func (_m *CommandStore) Get(id string) (*model.Command, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Command
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Command, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Command); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Command)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByTeam provides a mock function with given fields: teamID
+func (_m *CommandStore) GetByTeam(teamID string) ([]*model.Command, error) {
+	ret := _m.Called(teamID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByTeam")
+	}
+
+	var r0 []*model.Command
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.Command, error)); ok {
+		return rf(teamID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.Command); ok {
+		r0 = rf(teamID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Command)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(teamID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByTrigger provides a mock function with given fields: teamID, trigger
+func (_m *CommandStore) GetByTrigger(teamID string, trigger string) (*model.Command, error) {
+	ret := _m.Called(teamID, trigger)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByTrigger")
+	}
+
+	var r0 *model.Command
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.Command, error)); ok {
+		return rf(teamID, trigger)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.Command); ok {
+		r0 = rf(teamID, trigger)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Command)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(teamID, trigger)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteByTeam provides a mock function with given fields: teamID
+func (_m *CommandStore) PermanentDeleteByTeam(teamID string) error {
+	ret := _m.Called(teamID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteByTeam")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(teamID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PermanentDeleteByUser provides a mock function with given fields: userID
+func (_m *CommandStore) PermanentDeleteByUser(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: webhook
+func (_m *CommandStore) Save(webhook *model.Command) (*model.Command, error) {
+	ret := _m.Called(webhook)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.Command
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Command) (*model.Command, error)); ok {
+		return rf(webhook)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Command) *model.Command); ok {
+		r0 = rf(webhook)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Command)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Command) error); ok {
+		r1 = rf(webhook)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: hook
+func (_m *CommandStore) Update(hook *model.Command) (*model.Command, error) {
+	ret := _m.Called(hook)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 *model.Command
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Command) (*model.Command, error)); ok {
+		return rf(hook)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Command) *model.Command); ok {
+		r0 = rf(hook)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Command)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Command) error); ok {
+		r1 = rf(hook)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewCommandStore creates a new instance of CommandStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewCommandStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *CommandStore {
+	mock := &CommandStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/CommandWebhookStore.go

@@ -0,0 +1,112 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// CommandWebhookStore is an autogenerated mock type for the CommandWebhookStore type
+type CommandWebhookStore struct {
+	mock.Mock
+}
+
+// Cleanup provides a mock function with no fields
+func (_m *CommandWebhookStore) Cleanup() {
+	_m.Called()
+}
+
+// Get provides a mock function with given fields: id
+func (_m *CommandWebhookStore) Get(id string) (*model.CommandWebhook, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.CommandWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.CommandWebhook, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.CommandWebhook); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.CommandWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: webhook
+func (_m *CommandWebhookStore) Save(webhook *model.CommandWebhook) (*model.CommandWebhook, error) {
+	ret := _m.Called(webhook)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.CommandWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.CommandWebhook) (*model.CommandWebhook, error)); ok {
+		return rf(webhook)
+	}
+	if rf, ok := ret.Get(0).(func(*model.CommandWebhook) *model.CommandWebhook); ok {
+		r0 = rf(webhook)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.CommandWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.CommandWebhook) error); ok {
+		r1 = rf(webhook)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// TryUse provides a mock function with given fields: id, limit
+func (_m *CommandWebhookStore) TryUse(id string, limit int) error {
+	ret := _m.Called(id, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for TryUse")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int) error); ok {
+		r0 = rf(id, limit)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewCommandWebhookStore creates a new instance of CommandWebhookStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewCommandWebhookStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *CommandWebhookStore {
+	mock := &CommandWebhookStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ComplianceStore.go

@@ -0,0 +1,224 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ComplianceStore is an autogenerated mock type for the ComplianceStore type
+type ComplianceStore struct {
+	mock.Mock
+}
+
+// ComplianceExport provides a mock function with given fields: compliance, cursor, limit
+func (_m *ComplianceStore) ComplianceExport(compliance *model.Compliance, cursor model.ComplianceExportCursor, limit int) ([]*model.CompliancePost, model.ComplianceExportCursor, error) {
+	ret := _m.Called(compliance, cursor, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ComplianceExport")
+	}
+
+	var r0 []*model.CompliancePost
+	var r1 model.ComplianceExportCursor
+	var r2 error
+	if rf, ok := ret.Get(0).(func(*model.Compliance, model.ComplianceExportCursor, int) ([]*model.CompliancePost, model.ComplianceExportCursor, error)); ok {
+		return rf(compliance, cursor, limit)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Compliance, model.ComplianceExportCursor, int) []*model.CompliancePost); ok {
+		r0 = rf(compliance, cursor, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.CompliancePost)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Compliance, model.ComplianceExportCursor, int) model.ComplianceExportCursor); ok {
+		r1 = rf(compliance, cursor, limit)
+	} else {
+		r1 = ret.Get(1).(model.ComplianceExportCursor)
+	}
+
+	if rf, ok := ret.Get(2).(func(*model.Compliance, model.ComplianceExportCursor, int) error); ok {
+		r2 = rf(compliance, cursor, limit)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// Get provides a mock function with given fields: id
+func (_m *ComplianceStore) Get(id string) (*model.Compliance, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Compliance
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Compliance, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Compliance); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Compliance)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with given fields: offset, limit
+func (_m *ComplianceStore) GetAll(offset int, limit int) (model.Compliances, error) {
+	ret := _m.Called(offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 model.Compliances
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int) (model.Compliances, error)); ok {
+		return rf(offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int, int) model.Compliances); ok {
+		r0 = rf(offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(model.Compliances)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
+		r1 = rf(offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MessageExport provides a mock function with given fields: rctx, cursor, limit
+func (_m *ComplianceStore) MessageExport(rctx request.CTX, cursor model.MessageExportCursor, limit int) ([]*model.MessageExport, model.MessageExportCursor, error) {
+	ret := _m.Called(rctx, cursor, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MessageExport")
+	}
+
+	var r0 []*model.MessageExport
+	var r1 model.MessageExportCursor
+	var r2 error
+	if rf, ok := ret.Get(0).(func(request.CTX, model.MessageExportCursor, int) ([]*model.MessageExport, model.MessageExportCursor, error)); ok {
+		return rf(rctx, cursor, limit)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, model.MessageExportCursor, int) []*model.MessageExport); ok {
+		r0 = rf(rctx, cursor, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.MessageExport)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, model.MessageExportCursor, int) model.MessageExportCursor); ok {
+		r1 = rf(rctx, cursor, limit)
+	} else {
+		r1 = ret.Get(1).(model.MessageExportCursor)
+	}
+
+	if rf, ok := ret.Get(2).(func(request.CTX, model.MessageExportCursor, int) error); ok {
+		r2 = rf(rctx, cursor, limit)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// Save provides a mock function with given fields: compliance
+func (_m *ComplianceStore) Save(compliance *model.Compliance) (*model.Compliance, error) {
+	ret := _m.Called(compliance)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.Compliance
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Compliance) (*model.Compliance, error)); ok {
+		return rf(compliance)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Compliance) *model.Compliance); ok {
+		r0 = rf(compliance)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Compliance)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Compliance) error); ok {
+		r1 = rf(compliance)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: compliance
+func (_m *ComplianceStore) Update(compliance *model.Compliance) (*model.Compliance, error) {
+	ret := _m.Called(compliance)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 *model.Compliance
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Compliance) (*model.Compliance, error)); ok {
+		return rf(compliance)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Compliance) *model.Compliance); ok {
+		r0 = rf(compliance)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Compliance)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Compliance) error); ok {
+		r1 = rf(compliance)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewComplianceStore creates a new instance of ComplianceStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewComplianceStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ComplianceStore {
+	mock := &ComplianceStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ContentFlaggingStore.go

@@ -0,0 +1,82 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ContentFlaggingStore is an autogenerated mock type for the ContentFlaggingStore type
+type ContentFlaggingStore struct {
+	mock.Mock
+}
+
+// ClearCaches provides a mock function with no fields
+func (_m *ContentFlaggingStore) ClearCaches() {
+	_m.Called()
+}
+
+// GetReviewerSettings provides a mock function with no fields
+func (_m *ContentFlaggingStore) GetReviewerSettings() (*model.ReviewerIDsSettings, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetReviewerSettings")
+	}
+
+	var r0 *model.ReviewerIDsSettings
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (*model.ReviewerIDsSettings, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() *model.ReviewerIDsSettings); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ReviewerIDsSettings)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveReviewerSettings provides a mock function with given fields: reviewerSettings
+func (_m *ContentFlaggingStore) SaveReviewerSettings(reviewerSettings model.ReviewerIDsSettings) error {
+	ret := _m.Called(reviewerSettings)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveReviewerSettings")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(model.ReviewerIDsSettings) error); ok {
+		r0 = rf(reviewerSettings)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewContentFlaggingStore creates a new instance of ContentFlaggingStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewContentFlaggingStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ContentFlaggingStore {
+	mock := &ContentFlaggingStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/DeliveryTrackingStore.go

@@ -0,0 +1,138 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// DeliveryTrackingStore is an autogenerated mock type for the DeliveryTrackingStore type
+type DeliveryTrackingStore struct {
+	mock.Mock
+}
+
+// ClearCaches provides a mock function with no fields
+func (_m *DeliveryTrackingStore) ClearCaches() {
+	_m.Called()
+}
+
+// GetTrackedChannelIDs provides a mock function with given fields: rctx
+func (_m *DeliveryTrackingStore) GetTrackedChannelIDs(rctx request.CTX) ([]string, error) {
+	ret := _m.Called(rctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTrackedChannelIDs")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX) ([]string, error)); ok {
+		return rf(rctx)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX) []string); ok {
+		r0 = rf(rctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX) error); ok {
+		r1 = rf(rctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// IsChannelTrackable provides a mock function with given fields: rctx, channelID
+func (_m *DeliveryTrackingStore) IsChannelTrackable(rctx request.CTX, channelID string) (bool, error) {
+	ret := _m.Called(rctx, channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IsChannelTrackable")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (bool, error)); ok {
+		return rf(rctx, channelID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) bool); ok {
+		r0 = rf(rctx, channelID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// IsChannelTracked provides a mock function with given fields: rctx, channelID
+func (_m *DeliveryTrackingStore) IsChannelTracked(rctx request.CTX, channelID string) (bool, error) {
+	ret := _m.Called(rctx, channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IsChannelTracked")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (bool, error)); ok {
+		return rf(rctx, channelID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) bool); ok {
+		r0 = rf(rctx, channelID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveTrackedChannelIDs provides a mock function with given fields: rctx, channelIDs
+func (_m *DeliveryTrackingStore) SaveTrackedChannelIDs(rctx request.CTX, channelIDs []string) error {
+	ret := _m.Called(rctx, channelIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveTrackedChannelIDs")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, []string) error); ok {
+		r0 = rf(rctx, channelIDs)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewDeliveryTrackingStore creates a new instance of DeliveryTrackingStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewDeliveryTrackingStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *DeliveryTrackingStore {
+	mock := &DeliveryTrackingStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/DesktopTokensStore.go

@@ -0,0 +1,128 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import mock "github.com/stretchr/testify/mock"
+
+// DesktopTokensStore is an autogenerated mock type for the DesktopTokensStore type
+type DesktopTokensStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: token
+func (_m *DesktopTokensStore) Delete(token string) error {
+	ret := _m.Called(token)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(token)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteByUserId provides a mock function with given fields: userID
+func (_m *DesktopTokensStore) DeleteByUserId(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteByUserId")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteOlderThan provides a mock function with given fields: minCreatedAt
+func (_m *DesktopTokensStore) DeleteOlderThan(minCreatedAt int64) error {
+	ret := _m.Called(minCreatedAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteOlderThan")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int64) error); ok {
+		r0 = rf(minCreatedAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetUserId provides a mock function with given fields: token, minCreatedAt
+func (_m *DesktopTokensStore) GetUserId(token string, minCreatedAt int64) (*string, error) {
+	ret := _m.Called(token, minCreatedAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUserId")
+	}
+
+	var r0 *string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64) (*string, error)); ok {
+		return rf(token, minCreatedAt)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64) *string); ok {
+		r0 = rf(token, minCreatedAt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64) error); ok {
+		r1 = rf(token, minCreatedAt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Insert provides a mock function with given fields: token, createAt, userID
+func (_m *DesktopTokensStore) Insert(token string, createAt int64, userID string) error {
+	ret := _m.Called(token, createAt, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Insert")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64, string) error); ok {
+		r0 = rf(token, createAt, userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewDesktopTokensStore creates a new instance of DesktopTokensStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewDesktopTokensStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *DesktopTokensStore {
+	mock := &DesktopTokensStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/DraftStore.go

@@ -0,0 +1,244 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// DraftStore is an autogenerated mock type for the DraftStore type
+type DraftStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: userID, channelID, rootID
+func (_m *DraftStore) Delete(userID string, channelID string, rootID string) error {
+	ret := _m.Called(userID, channelID, rootID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, string) error); ok {
+		r0 = rf(userID, channelID, rootID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteDraftsAssociatedWithPost provides a mock function with given fields: channelID, rootID
+func (_m *DraftStore) DeleteDraftsAssociatedWithPost(channelID string, rootID string) error {
+	ret := _m.Called(channelID, rootID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteDraftsAssociatedWithPost")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(channelID, rootID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteEmptyDraftsByCreateAtAndUserId provides a mock function with given fields: createAt, userID
+func (_m *DraftStore) DeleteEmptyDraftsByCreateAtAndUserId(createAt int64, userID string) error {
+	ret := _m.Called(createAt, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteEmptyDraftsByCreateAtAndUserId")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int64, string) error); ok {
+		r0 = rf(createAt, userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteOrphanDraftsByCreateAtAndUserId provides a mock function with given fields: createAt, userID
+func (_m *DraftStore) DeleteOrphanDraftsByCreateAtAndUserId(createAt int64, userID string) error {
+	ret := _m.Called(createAt, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteOrphanDraftsByCreateAtAndUserId")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int64, string) error); ok {
+		r0 = rf(createAt, userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: userID, channelID, rootID, includeDeleted
+func (_m *DraftStore) Get(userID string, channelID string, rootID string, includeDeleted bool) (*model.Draft, error) {
+	ret := _m.Called(userID, channelID, rootID, includeDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Draft
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, string, bool) (*model.Draft, error)); ok {
+		return rf(userID, channelID, rootID, includeDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, string, bool) *model.Draft); ok {
+		r0 = rf(userID, channelID, rootID, includeDeleted)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Draft)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, string, bool) error); ok {
+		r1 = rf(userID, channelID, rootID, includeDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetDraftsForUser provides a mock function with given fields: userID, teamID
+func (_m *DraftStore) GetDraftsForUser(userID string, teamID string) ([]*model.Draft, error) {
+	ret := _m.Called(userID, teamID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDraftsForUser")
+	}
+
+	var r0 []*model.Draft
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) ([]*model.Draft, error)); ok {
+		return rf(userID, teamID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) []*model.Draft); ok {
+		r0 = rf(userID, teamID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Draft)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(userID, teamID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration provides a mock function with given fields: createAt, userID
+func (_m *DraftStore) GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt int64, userID string) (int64, string, error) {
+	ret := _m.Called(createAt, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration")
+	}
+
+	var r0 int64
+	var r1 string
+	var r2 error
+	if rf, ok := ret.Get(0).(func(int64, string) (int64, string, error)); ok {
+		return rf(createAt, userID)
+	}
+	if rf, ok := ret.Get(0).(func(int64, string) int64); ok {
+		r0 = rf(createAt, userID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, string) string); ok {
+		r1 = rf(createAt, userID)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	if rf, ok := ret.Get(2).(func(int64, string) error); ok {
+		r2 = rf(createAt, userID)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// PermanentDeleteByUser provides a mock function with given fields: userId
+func (_m *DraftStore) PermanentDeleteByUser(userId string) error {
+	ret := _m.Called(userId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userId)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Upsert provides a mock function with given fields: d
+func (_m *DraftStore) Upsert(d *model.Draft) (*model.Draft, error) {
+	ret := _m.Called(d)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Upsert")
+	}
+
+	var r0 *model.Draft
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Draft) (*model.Draft, error)); ok {
+		return rf(d)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Draft) *model.Draft); ok {
+		r0 = rf(d)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Draft)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Draft) error); ok {
+		r1 = rf(d)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewDraftStore creates a new instance of DraftStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewDraftStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *DraftStore {
+	mock := &DraftStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/EmojiStore.go

@@ -0,0 +1,228 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// EmojiStore is an autogenerated mock type for the EmojiStore type
+type EmojiStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: emoji, timestamp
+func (_m *EmojiStore) Delete(emoji *model.Emoji, timestamp int64) error {
+	ret := _m.Called(emoji, timestamp)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Emoji, int64) error); ok {
+		r0 = rf(emoji, timestamp)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: rctx, id, allowFromCache
+func (_m *EmojiStore) Get(rctx request.CTX, id string, allowFromCache bool) (*model.Emoji, error) {
+	ret := _m.Called(rctx, id, allowFromCache)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Emoji
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, bool) (*model.Emoji, error)); ok {
+		return rf(rctx, id, allowFromCache)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, bool) *model.Emoji); ok {
+		r0 = rf(rctx, id, allowFromCache)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Emoji)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, bool) error); ok {
+		r1 = rf(rctx, id, allowFromCache)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByName provides a mock function with given fields: rctx, name, allowFromCache
+func (_m *EmojiStore) GetByName(rctx request.CTX, name string, allowFromCache bool) (*model.Emoji, error) {
+	ret := _m.Called(rctx, name, allowFromCache)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByName")
+	}
+
+	var r0 *model.Emoji
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, bool) (*model.Emoji, error)); ok {
+		return rf(rctx, name, allowFromCache)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, bool) *model.Emoji); ok {
+		r0 = rf(rctx, name, allowFromCache)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Emoji)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, bool) error); ok {
+		r1 = rf(rctx, name, allowFromCache)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetList provides a mock function with given fields: offset, limit, sort
+func (_m *EmojiStore) GetList(offset int, limit int, sort string) ([]*model.Emoji, error) {
+	ret := _m.Called(offset, limit, sort)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetList")
+	}
+
+	var r0 []*model.Emoji
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int, string) ([]*model.Emoji, error)); ok {
+		return rf(offset, limit, sort)
+	}
+	if rf, ok := ret.Get(0).(func(int, int, string) []*model.Emoji); ok {
+		r0 = rf(offset, limit, sort)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Emoji)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int, string) error); ok {
+		r1 = rf(offset, limit, sort)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMultipleByName provides a mock function with given fields: rctx, names
+func (_m *EmojiStore) GetMultipleByName(rctx request.CTX, names []string) ([]*model.Emoji, error) {
+	ret := _m.Called(rctx, names)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetMultipleByName")
+	}
+
+	var r0 []*model.Emoji
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, []string) ([]*model.Emoji, error)); ok {
+		return rf(rctx, names)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, []string) []*model.Emoji); ok {
+		r0 = rf(rctx, names)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Emoji)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, []string) error); ok {
+		r1 = rf(rctx, names)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: emoji
+func (_m *EmojiStore) Save(emoji *model.Emoji) (*model.Emoji, error) {
+	ret := _m.Called(emoji)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.Emoji
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Emoji) (*model.Emoji, error)); ok {
+		return rf(emoji)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Emoji) *model.Emoji); ok {
+		r0 = rf(emoji)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Emoji)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Emoji) error); ok {
+		r1 = rf(emoji)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Search provides a mock function with given fields: name, prefixOnly, limit
+func (_m *EmojiStore) Search(name string, prefixOnly bool, limit int) ([]*model.Emoji, error) {
+	ret := _m.Called(name, prefixOnly, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Search")
+	}
+
+	var r0 []*model.Emoji
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool, int) ([]*model.Emoji, error)); ok {
+		return rf(name, prefixOnly, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool, int) []*model.Emoji); ok {
+		r0 = rf(name, prefixOnly, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Emoji)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool, int) error); ok {
+		r1 = rf(name, prefixOnly, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewEmojiStore creates a new instance of EmojiStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewEmojiStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *EmojiStore {
+	mock := &EmojiStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/FileInfoStore.go

@@ -0,0 +1,664 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// FileInfoStore is an autogenerated mock type for the FileInfoStore type
+type FileInfoStore struct {
+	mock.Mock
+}
+
+// AttachToPost provides a mock function with given fields: rctx, fileID, postID, channelID, creatorID
+func (_m *FileInfoStore) AttachToPost(rctx request.CTX, fileID string, postID string, channelID string, creatorID string) error {
+	ret := _m.Called(rctx, fileID, postID, channelID, creatorID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AttachToPost")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, string, string) error); ok {
+		r0 = rf(rctx, fileID, postID, channelID, creatorID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ClearCaches provides a mock function with no fields
+func (_m *FileInfoStore) ClearCaches() {
+	_m.Called()
+}
+
+// CountAll provides a mock function with no fields
+func (_m *FileInfoStore) CountAll() (int64, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountAll")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeleteForPost provides a mock function with given fields: rctx, postID
+func (_m *FileInfoStore) DeleteForPost(rctx request.CTX, postID string) (string, error) {
+	ret := _m.Called(rctx, postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteForPost")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (string, error)); ok {
+		return rf(rctx, postID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) string); ok {
+		r0 = rf(rctx, postID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeleteForPostByIds provides a mock function with given fields: rctx, postId, fileIDs
+func (_m *FileInfoStore) DeleteForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	ret := _m.Called(rctx, postId, fileIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteForPostByIds")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, []string) error); ok {
+		r0 = rf(rctx, postId, fileIDs)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: id
+func (_m *FileInfoStore) Get(id string) (*model.FileInfo, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.FileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.FileInfo, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.FileInfo); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByIds provides a mock function with given fields: ids, includeDeleted, allowFromCache, readFromMaster
+func (_m *FileInfoStore) GetByIds(ids []string, includeDeleted bool, allowFromCache bool, readFromMaster bool) ([]*model.FileInfo, error) {
+	ret := _m.Called(ids, includeDeleted, allowFromCache, readFromMaster)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByIds")
+	}
+
+	var r0 []*model.FileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string, bool, bool, bool) ([]*model.FileInfo, error)); ok {
+		return rf(ids, includeDeleted, allowFromCache, readFromMaster)
+	}
+	if rf, ok := ret.Get(0).(func([]string, bool, bool, bool) []*model.FileInfo); ok {
+		r0 = rf(ids, includeDeleted, allowFromCache, readFromMaster)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]string, bool, bool, bool) error); ok {
+		r1 = rf(ids, includeDeleted, allowFromCache, readFromMaster)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByPath provides a mock function with given fields: path
+func (_m *FileInfoStore) GetByPath(path string) (*model.FileInfo, error) {
+	ret := _m.Called(path)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByPath")
+	}
+
+	var r0 *model.FileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.FileInfo, error)); ok {
+		return rf(path)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.FileInfo); ok {
+		r0 = rf(path)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(path)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetFilesBatchForIndexing provides a mock function with given fields: startTime, startFileID, includeDeleted, limit
+func (_m *FileInfoStore) GetFilesBatchForIndexing(startTime int64, startFileID string, includeDeleted bool, limit int) ([]*model.FileForIndexing, error) {
+	ret := _m.Called(startTime, startFileID, includeDeleted, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetFilesBatchForIndexing")
+	}
+
+	var r0 []*model.FileForIndexing
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, string, bool, int) ([]*model.FileForIndexing, error)); ok {
+		return rf(startTime, startFileID, includeDeleted, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int64, string, bool, int) []*model.FileForIndexing); ok {
+		r0 = rf(startTime, startFileID, includeDeleted, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.FileForIndexing)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, string, bool, int) error); ok {
+		r1 = rf(startTime, startFileID, includeDeleted, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPost provides a mock function with given fields: postID, readFromMaster, includeDeleted, allowFromCache
+func (_m *FileInfoStore) GetForPost(postID string, readFromMaster bool, includeDeleted bool, allowFromCache bool) ([]*model.FileInfo, error) {
+	ret := _m.Called(postID, readFromMaster, includeDeleted, allowFromCache)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForPost")
+	}
+
+	var r0 []*model.FileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool, bool, bool) ([]*model.FileInfo, error)); ok {
+		return rf(postID, readFromMaster, includeDeleted, allowFromCache)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool, bool, bool) []*model.FileInfo); ok {
+		r0 = rf(postID, readFromMaster, includeDeleted, allowFromCache)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool, bool, bool) error); ok {
+		r1 = rf(postID, readFromMaster, includeDeleted, allowFromCache)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForUser provides a mock function with given fields: userID
+func (_m *FileInfoStore) GetForUser(userID string) ([]*model.FileInfo, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForUser")
+	}
+
+	var r0 []*model.FileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.FileInfo, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.FileInfo); ok {
+		r0 = rf(userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetFromMaster provides a mock function with given fields: id
+func (_m *FileInfoStore) GetFromMaster(id string) (*model.FileInfo, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetFromMaster")
+	}
+
+	var r0 *model.FileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.FileInfo, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.FileInfo); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetStorageUsage provides a mock function with given fields: allowFromCache, includeDeleted
+func (_m *FileInfoStore) GetStorageUsage(allowFromCache bool, includeDeleted bool) (int64, error) {
+	ret := _m.Called(allowFromCache, includeDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetStorageUsage")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(bool, bool) (int64, error)); ok {
+		return rf(allowFromCache, includeDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(bool, bool) int64); ok {
+		r0 = rf(allowFromCache, includeDeleted)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(bool, bool) error); ok {
+		r1 = rf(allowFromCache, includeDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUptoNSizeFileTime provides a mock function with given fields: n
+func (_m *FileInfoStore) GetUptoNSizeFileTime(n int64) (int64, error) {
+	ret := _m.Called(n)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUptoNSizeFileTime")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (int64, error)); ok {
+		return rf(n)
+	}
+	if rf, ok := ret.Get(0).(func(int64) int64); ok {
+		r0 = rf(n)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(n)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetWithOptions provides a mock function with given fields: page, perPage, opt
+func (_m *FileInfoStore) GetWithOptions(page int, perPage int, opt *model.GetFileInfosOptions) ([]*model.FileInfo, error) {
+	ret := _m.Called(page, perPage, opt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetWithOptions")
+	}
+
+	var r0 []*model.FileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int, *model.GetFileInfosOptions) ([]*model.FileInfo, error)); ok {
+		return rf(page, perPage, opt)
+	}
+	if rf, ok := ret.Get(0).(func(int, int, *model.GetFileInfosOptions) []*model.FileInfo); ok {
+		r0 = rf(page, perPage, opt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int, *model.GetFileInfosOptions) error); ok {
+		r1 = rf(page, perPage, opt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InvalidateFileInfosForPostCache provides a mock function with given fields: postID, deleted
+func (_m *FileInfoStore) InvalidateFileInfosForPostCache(postID string, deleted bool) {
+	_m.Called(postID, deleted)
+}
+
+// PermanentDelete provides a mock function with given fields: rctx, fileID
+func (_m *FileInfoStore) PermanentDelete(rctx request.CTX, fileID string) error {
+	ret := _m.Called(rctx, fileID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
+		r0 = rf(rctx, fileID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PermanentDeleteBatch provides a mock function with given fields: rctx, endTime, limit
+func (_m *FileInfoStore) PermanentDeleteBatch(rctx request.CTX, endTime int64, limit int64) (int64, error) {
+	ret := _m.Called(rctx, endTime, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteBatch")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, int64, int64) (int64, error)); ok {
+		return rf(rctx, endTime, limit)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, int64, int64) int64); ok {
+		r0 = rf(rctx, endTime, limit)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, int64, int64) error); ok {
+		r1 = rf(rctx, endTime, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteByUser provides a mock function with given fields: rctx, userID
+func (_m *FileInfoStore) PermanentDeleteByUser(rctx request.CTX, userID string) (int64, error) {
+	ret := _m.Called(rctx, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteByUser")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (int64, error)); ok {
+		return rf(rctx, userID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) int64); ok {
+		r0 = rf(rctx, userID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteForPost provides a mock function with given fields: rctx, postID
+func (_m *FileInfoStore) PermanentDeleteForPost(rctx request.CTX, postID string) error {
+	ret := _m.Called(rctx, postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteForPost")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
+		r0 = rf(rctx, postID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RefreshFileStats provides a mock function with no fields
+func (_m *FileInfoStore) RefreshFileStats() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for RefreshFileStats")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RestoreForPostByIds provides a mock function with given fields: rctx, postId, fileIDs
+func (_m *FileInfoStore) RestoreForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	ret := _m.Called(rctx, postId, fileIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RestoreForPostByIds")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, []string) error); ok {
+		r0 = rf(rctx, postId, fileIDs)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: rctx, info
+func (_m *FileInfoStore) Save(rctx request.CTX, info *model.FileInfo) (*model.FileInfo, error) {
+	ret := _m.Called(rctx, info)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.FileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.FileInfo) (*model.FileInfo, error)); ok {
+		return rf(rctx, info)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.FileInfo) *model.FileInfo); ok {
+		r0 = rf(rctx, info)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.FileInfo) error); ok {
+		r1 = rf(rctx, info)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Search provides a mock function with given fields: rctx, paramsList, userID, teamID, page, perPage
+func (_m *FileInfoStore) Search(rctx request.CTX, paramsList []*model.SearchParams, userID string, teamID string, page int, perPage int) (*model.FileInfoList, error) {
+	ret := _m.Called(rctx, paramsList, userID, teamID, page, perPage)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Search")
+	}
+
+	var r0 *model.FileInfoList
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, []*model.SearchParams, string, string, int, int) (*model.FileInfoList, error)); ok {
+		return rf(rctx, paramsList, userID, teamID, page, perPage)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, []*model.SearchParams, string, string, int, int) *model.FileInfoList); ok {
+		r0 = rf(rctx, paramsList, userID, teamID, page, perPage)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.FileInfoList)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, []*model.SearchParams, string, string, int, int) error); ok {
+		r1 = rf(rctx, paramsList, userID, teamID, page, perPage)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SetContent provides a mock function with given fields: rctx, fileID, content
+func (_m *FileInfoStore) SetContent(rctx request.CTX, fileID string, content string) error {
+	ret := _m.Called(rctx, fileID, content)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetContent")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) error); ok {
+		r0 = rf(rctx, fileID, content)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Upsert provides a mock function with given fields: rctx, info
+func (_m *FileInfoStore) Upsert(rctx request.CTX, info *model.FileInfo) (*model.FileInfo, error) {
+	ret := _m.Called(rctx, info)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Upsert")
+	}
+
+	var r0 *model.FileInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.FileInfo) (*model.FileInfo, error)); ok {
+		return rf(rctx, info)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.FileInfo) *model.FileInfo); ok {
+		r0 = rf(rctx, info)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.FileInfo) error); ok {
+		r1 = rf(rctx, info)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewFileInfoStore creates a new instance of FileInfoStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewFileInfoStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *FileInfoStore {
+	mock := &FileInfoStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/JobStore.go

@@ -0,0 +1,591 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// JobStore is an autogenerated mock type for the JobStore type
+type JobStore struct {
+	mock.Mock
+}
+
+// Cleanup provides a mock function with given fields: expiryTime, batchSize
+func (_m *JobStore) Cleanup(expiryTime int64, batchSize int) error {
+	ret := _m.Called(expiryTime, batchSize)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Cleanup")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int64, int) error); ok {
+		r0 = rf(expiryTime, batchSize)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Delete provides a mock function with given fields: id
+func (_m *JobStore) Delete(id string) (string, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (string, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) string); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: rctx, id
+func (_m *JobStore) Get(rctx request.CTX, id string) (*model.Job, error) {
+	ret := _m.Called(rctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.Job, error)); ok {
+		return rf(rctx, id)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.Job); ok {
+		r0 = rf(rctx, id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllByStatus provides a mock function with given fields: rctx, status
+func (_m *JobStore) GetAllByStatus(rctx request.CTX, status string) ([]*model.Job, error) {
+	ret := _m.Called(rctx, status)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllByStatus")
+	}
+
+	var r0 []*model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) ([]*model.Job, error)); ok {
+		return rf(rctx, status)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) []*model.Job); ok {
+		r0 = rf(rctx, status)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, status)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllByType provides a mock function with given fields: rctx, jobType
+func (_m *JobStore) GetAllByType(rctx request.CTX, jobType string) ([]*model.Job, error) {
+	ret := _m.Called(rctx, jobType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllByType")
+	}
+
+	var r0 []*model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) ([]*model.Job, error)); ok {
+		return rf(rctx, jobType)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) []*model.Job); ok {
+		r0 = rf(rctx, jobType)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, jobType)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllByTypeAndStatus provides a mock function with given fields: rctx, jobType, status
+func (_m *JobStore) GetAllByTypeAndStatus(rctx request.CTX, jobType string, status string) ([]*model.Job, error) {
+	ret := _m.Called(rctx, jobType, status)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllByTypeAndStatus")
+	}
+
+	var r0 []*model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) ([]*model.Job, error)); ok {
+		return rf(rctx, jobType, status)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) []*model.Job); ok {
+		r0 = rf(rctx, jobType, status)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string) error); ok {
+		r1 = rf(rctx, jobType, status)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllByTypePage provides a mock function with given fields: rctx, jobType, offset, limit
+func (_m *JobStore) GetAllByTypePage(rctx request.CTX, jobType string, offset int, limit int) ([]*model.Job, error) {
+	ret := _m.Called(rctx, jobType, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllByTypePage")
+	}
+
+	var r0 []*model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, int, int) ([]*model.Job, error)); ok {
+		return rf(rctx, jobType, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, int, int) []*model.Job); ok {
+		r0 = rf(rctx, jobType, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, int, int) error); ok {
+		r1 = rf(rctx, jobType, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllByTypesAndStatusesPage provides a mock function with given fields: rctx, jobType, status, offset, limit
+func (_m *JobStore) GetAllByTypesAndStatusesPage(rctx request.CTX, jobType []string, status []string, offset int, limit int) ([]*model.Job, error) {
+	ret := _m.Called(rctx, jobType, status, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllByTypesAndStatusesPage")
+	}
+
+	var r0 []*model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, []string, []string, int, int) ([]*model.Job, error)); ok {
+		return rf(rctx, jobType, status, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, []string, []string, int, int) []*model.Job); ok {
+		r0 = rf(rctx, jobType, status, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, []string, []string, int, int) error); ok {
+		r1 = rf(rctx, jobType, status, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllByTypesPage provides a mock function with given fields: rctx, jobTypes, offset, limit
+func (_m *JobStore) GetAllByTypesPage(rctx request.CTX, jobTypes []string, offset int, limit int) ([]*model.Job, error) {
+	ret := _m.Called(rctx, jobTypes, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllByTypesPage")
+	}
+
+	var r0 []*model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, []string, int, int) ([]*model.Job, error)); ok {
+		return rf(rctx, jobTypes, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, []string, int, int) []*model.Job); ok {
+		r0 = rf(rctx, jobTypes, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, []string, int, int) error); ok {
+		r1 = rf(rctx, jobTypes, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByTypeAndData provides a mock function with given fields: rctx, jobType, data, useMaster, statuses
+func (_m *JobStore) GetByTypeAndData(rctx request.CTX, jobType string, data map[string]string, useMaster bool, statuses ...string) ([]*model.Job, error) {
+	_va := make([]interface{}, len(statuses))
+	for _i := range statuses {
+		_va[_i] = statuses[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, rctx, jobType, data, useMaster)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByTypeAndData")
+	}
+
+	var r0 []*model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, map[string]string, bool, ...string) ([]*model.Job, error)); ok {
+		return rf(rctx, jobType, data, useMaster, statuses...)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, map[string]string, bool, ...string) []*model.Job); ok {
+		r0 = rf(rctx, jobType, data, useMaster, statuses...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, map[string]string, bool, ...string) error); ok {
+		r1 = rf(rctx, jobType, data, useMaster, statuses...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetCountByStatusAndType provides a mock function with given fields: status, jobType
+func (_m *JobStore) GetCountByStatusAndType(status string, jobType string) (int64, error) {
+	ret := _m.Called(status, jobType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetCountByStatusAndType")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (int64, error)); ok {
+		return rf(status, jobType)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) int64); ok {
+		r0 = rf(status, jobType)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(status, jobType)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetNewestJobByStatusAndType provides a mock function with given fields: status, jobType
+func (_m *JobStore) GetNewestJobByStatusAndType(status string, jobType string) (*model.Job, error) {
+	ret := _m.Called(status, jobType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetNewestJobByStatusAndType")
+	}
+
+	var r0 *model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.Job, error)); ok {
+		return rf(status, jobType)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.Job); ok {
+		r0 = rf(status, jobType)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(status, jobType)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetNewestJobByStatusesAndType provides a mock function with given fields: statuses, jobType
+func (_m *JobStore) GetNewestJobByStatusesAndType(statuses []string, jobType string) (*model.Job, error) {
+	ret := _m.Called(statuses, jobType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetNewestJobByStatusesAndType")
+	}
+
+	var r0 *model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string, string) (*model.Job, error)); ok {
+		return rf(statuses, jobType)
+	}
+	if rf, ok := ret.Get(0).(func([]string, string) *model.Job); ok {
+		r0 = rf(statuses, jobType)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]string, string) error); ok {
+		r1 = rf(statuses, jobType)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: job
+func (_m *JobStore) Save(job *model.Job) (*model.Job, error) {
+	ret := _m.Called(job)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Job) (*model.Job, error)); ok {
+		return rf(job)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Job) *model.Job); ok {
+		r0 = rf(job)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Job) error); ok {
+		r1 = rf(job)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveOnce provides a mock function with given fields: job
+func (_m *JobStore) SaveOnce(job *model.Job) (*model.Job, error) {
+	ret := _m.Called(job)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveOnce")
+	}
+
+	var r0 *model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Job) (*model.Job, error)); ok {
+		return rf(job)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Job) *model.Job); ok {
+		r0 = rf(job)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Job) error); ok {
+		r1 = rf(job)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveOnceByTypeAndData provides a mock function with given fields: job, data
+func (_m *JobStore) SaveOnceByTypeAndData(job *model.Job, data map[string]string) (*model.Job, error) {
+	ret := _m.Called(job, data)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveOnceByTypeAndData")
+	}
+
+	var r0 *model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Job, map[string]string) (*model.Job, error)); ok {
+		return rf(job, data)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Job, map[string]string) *model.Job); ok {
+		r0 = rf(job, data)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Job, map[string]string) error); ok {
+		r1 = rf(job, data)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateOptimistically provides a mock function with given fields: job, currentStatus
+func (_m *JobStore) UpdateOptimistically(job *model.Job, currentStatus string) (*model.Job, error) {
+	ret := _m.Called(job, currentStatus)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateOptimistically")
+	}
+
+	var r0 *model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Job, string) (*model.Job, error)); ok {
+		return rf(job, currentStatus)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Job, string) *model.Job); ok {
+		r0 = rf(job, currentStatus)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Job, string) error); ok {
+		r1 = rf(job, currentStatus)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateStatus provides a mock function with given fields: id, status
+func (_m *JobStore) UpdateStatus(id string, status string) (*model.Job, error) {
+	ret := _m.Called(id, status)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateStatus")
+	}
+
+	var r0 *model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.Job, error)); ok {
+		return rf(id, status)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.Job); ok {
+		r0 = rf(id, status)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(id, status)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateStatusOptimistically provides a mock function with given fields: id, currentStatus, newStatus
+func (_m *JobStore) UpdateStatusOptimistically(id string, currentStatus string, newStatus string) (*model.Job, error) {
+	ret := _m.Called(id, currentStatus, newStatus)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateStatusOptimistically")
+	}
+
+	var r0 *model.Job
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, string) (*model.Job, error)); ok {
+		return rf(id, currentStatus, newStatus)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, string) *model.Job); ok {
+		r0 = rf(id, currentStatus, newStatus)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Job)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
+		r1 = rf(id, currentStatus, newStatus)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewJobStore creates a new instance of JobStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewJobStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *JobStore {
+	mock := &JobStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/LicenseStore.go

@@ -0,0 +1,108 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// LicenseStore is an autogenerated mock type for the LicenseStore type
+type LicenseStore struct {
+	mock.Mock
+}
+
+// Get provides a mock function with given fields: rctx, id
+func (_m *LicenseStore) Get(rctx request.CTX, id string) (*model.LicenseRecord, error) {
+	ret := _m.Called(rctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.LicenseRecord
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.LicenseRecord, error)); ok {
+		return rf(rctx, id)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.LicenseRecord); ok {
+		r0 = rf(rctx, id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.LicenseRecord)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with no fields
+func (_m *LicenseStore) GetAll() ([]*model.LicenseRecord, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 []*model.LicenseRecord
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.LicenseRecord, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.LicenseRecord); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.LicenseRecord)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: license
+func (_m *LicenseStore) Save(license *model.LicenseRecord) error {
+	ret := _m.Called(license)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.LicenseRecord) error); ok {
+		r0 = rf(license)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewLicenseStore creates a new instance of LicenseStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewLicenseStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *LicenseStore {
+	mock := &LicenseStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/LinkMetadataStore.go

@@ -0,0 +1,89 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// LinkMetadataStore is an autogenerated mock type for the LinkMetadataStore type
+type LinkMetadataStore struct {
+	mock.Mock
+}
+
+// Get provides a mock function with given fields: url, timestamp
+func (_m *LinkMetadataStore) Get(url string, timestamp int64) (*model.LinkMetadata, error) {
+	ret := _m.Called(url, timestamp)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.LinkMetadata
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64) (*model.LinkMetadata, error)); ok {
+		return rf(url, timestamp)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64) *model.LinkMetadata); ok {
+		r0 = rf(url, timestamp)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.LinkMetadata)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64) error); ok {
+		r1 = rf(url, timestamp)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: linkMetadata
+func (_m *LinkMetadataStore) Save(linkMetadata *model.LinkMetadata) (*model.LinkMetadata, error) {
+	ret := _m.Called(linkMetadata)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.LinkMetadata
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.LinkMetadata) (*model.LinkMetadata, error)); ok {
+		return rf(linkMetadata)
+	}
+	if rf, ok := ret.Get(0).(func(*model.LinkMetadata) *model.LinkMetadata); ok {
+		r0 = rf(linkMetadata)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.LinkMetadata)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.LinkMetadata) error); ok {
+		r1 = rf(linkMetadata)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewLinkMetadataStore creates a new instance of LinkMetadataStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewLinkMetadataStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *LinkMetadataStore {
+	mock := &LinkMetadataStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/NotifyAdminStore.go

@@ -0,0 +1,155 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NotifyAdminStore is an autogenerated mock type for the NotifyAdminStore type
+type NotifyAdminStore struct {
+	mock.Mock
+}
+
+// DeleteBefore provides a mock function with given fields: trial, now
+func (_m *NotifyAdminStore) DeleteBefore(trial bool, now int64) error {
+	ret := _m.Called(trial, now)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteBefore")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(bool, int64) error); ok {
+		r0 = rf(trial, now)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: trial
+func (_m *NotifyAdminStore) Get(trial bool) ([]*model.NotifyAdminData, error) {
+	ret := _m.Called(trial)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 []*model.NotifyAdminData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(bool) ([]*model.NotifyAdminData, error)); ok {
+		return rf(trial)
+	}
+	if rf, ok := ret.Get(0).(func(bool) []*model.NotifyAdminData); ok {
+		r0 = rf(trial)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.NotifyAdminData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(bool) error); ok {
+		r1 = rf(trial)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetDataByUserIdAndFeature provides a mock function with given fields: userID, feature
+func (_m *NotifyAdminStore) GetDataByUserIdAndFeature(userID string, feature model.MattermostFeature) ([]*model.NotifyAdminData, error) {
+	ret := _m.Called(userID, feature)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDataByUserIdAndFeature")
+	}
+
+	var r0 []*model.NotifyAdminData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, model.MattermostFeature) ([]*model.NotifyAdminData, error)); ok {
+		return rf(userID, feature)
+	}
+	if rf, ok := ret.Get(0).(func(string, model.MattermostFeature) []*model.NotifyAdminData); ok {
+		r0 = rf(userID, feature)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.NotifyAdminData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, model.MattermostFeature) error); ok {
+		r1 = rf(userID, feature)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: data
+func (_m *NotifyAdminStore) Save(data *model.NotifyAdminData) (*model.NotifyAdminData, error) {
+	ret := _m.Called(data)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.NotifyAdminData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.NotifyAdminData) (*model.NotifyAdminData, error)); ok {
+		return rf(data)
+	}
+	if rf, ok := ret.Get(0).(func(*model.NotifyAdminData) *model.NotifyAdminData); ok {
+		r0 = rf(data)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.NotifyAdminData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.NotifyAdminData) error); ok {
+		r1 = rf(data)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: userID, requiredPlan, requiredFeature, now
+func (_m *NotifyAdminStore) Update(userID string, requiredPlan string, requiredFeature model.MattermostFeature, now int64) error {
+	ret := _m.Called(userID, requiredPlan, requiredFeature, now)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, model.MattermostFeature, int64) error); ok {
+		r0 = rf(userID, requiredPlan, requiredFeature, now)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewNotifyAdminStore creates a new instance of NotifyAdminStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewNotifyAdminStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *NotifyAdminStore {
+	mock := &NotifyAdminStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/OAuthStore.go

@@ -0,0 +1,575 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// OAuthStore is an autogenerated mock type for the OAuthStore type
+type OAuthStore struct {
+	mock.Mock
+}
+
+// DeleteApp provides a mock function with given fields: id
+func (_m *OAuthStore) DeleteApp(id string) error {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteApp")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetAccessData provides a mock function with given fields: token
+func (_m *OAuthStore) GetAccessData(token string) (*model.AccessData, error) {
+	ret := _m.Called(token)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAccessData")
+	}
+
+	var r0 *model.AccessData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.AccessData, error)); ok {
+		return rf(token)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.AccessData); ok {
+		r0 = rf(token)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AccessData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(token)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAccessDataByRefreshToken provides a mock function with given fields: token
+func (_m *OAuthStore) GetAccessDataByRefreshToken(token string) (*model.AccessData, error) {
+	ret := _m.Called(token)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAccessDataByRefreshToken")
+	}
+
+	var r0 *model.AccessData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.AccessData, error)); ok {
+		return rf(token)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.AccessData); ok {
+		r0 = rf(token)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AccessData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(token)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAccessDataByUserForApp provides a mock function with given fields: userID, clientID
+func (_m *OAuthStore) GetAccessDataByUserForApp(userID string, clientID string) ([]*model.AccessData, error) {
+	ret := _m.Called(userID, clientID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAccessDataByUserForApp")
+	}
+
+	var r0 []*model.AccessData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) ([]*model.AccessData, error)); ok {
+		return rf(userID, clientID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) []*model.AccessData); ok {
+		r0 = rf(userID, clientID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.AccessData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(userID, clientID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetApp provides a mock function with given fields: id
+func (_m *OAuthStore) GetApp(id string) (*model.OAuthApp, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetApp")
+	}
+
+	var r0 *model.OAuthApp
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.OAuthApp, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.OAuthApp); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.OAuthApp)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAppByUser provides a mock function with given fields: userID, offset, limit
+func (_m *OAuthStore) GetAppByUser(userID string, offset int, limit int) ([]*model.OAuthApp, error) {
+	ret := _m.Called(userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAppByUser")
+	}
+
+	var r0 []*model.OAuthApp
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.OAuthApp, error)); ok {
+		return rf(userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.OAuthApp); ok {
+		r0 = rf(userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OAuthApp)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetApps provides a mock function with given fields: offset, limit
+func (_m *OAuthStore) GetApps(offset int, limit int) ([]*model.OAuthApp, error) {
+	ret := _m.Called(offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetApps")
+	}
+
+	var r0 []*model.OAuthApp
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int) ([]*model.OAuthApp, error)); ok {
+		return rf(offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int, int) []*model.OAuthApp); ok {
+		r0 = rf(offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OAuthApp)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
+		r1 = rf(offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAuthData provides a mock function with given fields: code
+func (_m *OAuthStore) GetAuthData(code string) (*model.AuthData, error) {
+	ret := _m.Called(code)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAuthData")
+	}
+
+	var r0 *model.AuthData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.AuthData, error)); ok {
+		return rf(code)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.AuthData); ok {
+		r0 = rf(code)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AuthData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(code)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAuthorizedApps provides a mock function with given fields: userID, offset, limit
+func (_m *OAuthStore) GetAuthorizedApps(userID string, offset int, limit int) ([]*model.OAuthApp, error) {
+	ret := _m.Called(userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAuthorizedApps")
+	}
+
+	var r0 []*model.OAuthApp
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.OAuthApp, error)); ok {
+		return rf(userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.OAuthApp); ok {
+		r0 = rf(userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OAuthApp)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetPreviousAccessData provides a mock function with given fields: userID, clientID
+func (_m *OAuthStore) GetPreviousAccessData(userID string, clientID string) (*model.AccessData, error) {
+	ret := _m.Called(userID, clientID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPreviousAccessData")
+	}
+
+	var r0 *model.AccessData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.AccessData, error)); ok {
+		return rf(userID, clientID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.AccessData); ok {
+		r0 = rf(userID, clientID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AccessData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(userID, clientID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteAuthDataByUser provides a mock function with given fields: userID
+func (_m *OAuthStore) PermanentDeleteAuthDataByUser(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteAuthDataByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RemoveAccessData provides a mock function with given fields: token
+func (_m *OAuthStore) RemoveAccessData(token string) error {
+	ret := _m.Called(token)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveAccessData")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(token)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RemoveAllAccessData provides a mock function with no fields
+func (_m *OAuthStore) RemoveAllAccessData() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveAllAccessData")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RemoveAuthData provides a mock function with given fields: code
+func (_m *OAuthStore) RemoveAuthData(code string) error {
+	ret := _m.Called(code)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveAuthData")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(code)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RemoveAuthDataByClientId provides a mock function with given fields: clientID, userID
+func (_m *OAuthStore) RemoveAuthDataByClientId(clientID string, userID string) error {
+	ret := _m.Called(clientID, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveAuthDataByClientId")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(clientID, userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RemoveAuthDataByUserId provides a mock function with given fields: userID
+func (_m *OAuthStore) RemoveAuthDataByUserId(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveAuthDataByUserId")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SaveAccessData provides a mock function with given fields: accessData
+func (_m *OAuthStore) SaveAccessData(accessData *model.AccessData) (*model.AccessData, error) {
+	ret := _m.Called(accessData)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveAccessData")
+	}
+
+	var r0 *model.AccessData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.AccessData) (*model.AccessData, error)); ok {
+		return rf(accessData)
+	}
+	if rf, ok := ret.Get(0).(func(*model.AccessData) *model.AccessData); ok {
+		r0 = rf(accessData)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AccessData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.AccessData) error); ok {
+		r1 = rf(accessData)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveApp provides a mock function with given fields: app
+func (_m *OAuthStore) SaveApp(app *model.OAuthApp) (*model.OAuthApp, error) {
+	ret := _m.Called(app)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveApp")
+	}
+
+	var r0 *model.OAuthApp
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.OAuthApp) (*model.OAuthApp, error)); ok {
+		return rf(app)
+	}
+	if rf, ok := ret.Get(0).(func(*model.OAuthApp) *model.OAuthApp); ok {
+		r0 = rf(app)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.OAuthApp)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.OAuthApp) error); ok {
+		r1 = rf(app)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveAuthData provides a mock function with given fields: authData
+func (_m *OAuthStore) SaveAuthData(authData *model.AuthData) (*model.AuthData, error) {
+	ret := _m.Called(authData)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveAuthData")
+	}
+
+	var r0 *model.AuthData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.AuthData) (*model.AuthData, error)); ok {
+		return rf(authData)
+	}
+	if rf, ok := ret.Get(0).(func(*model.AuthData) *model.AuthData); ok {
+		r0 = rf(authData)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AuthData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.AuthData) error); ok {
+		r1 = rf(authData)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateAccessData provides a mock function with given fields: accessData
+func (_m *OAuthStore) UpdateAccessData(accessData *model.AccessData) (*model.AccessData, error) {
+	ret := _m.Called(accessData)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateAccessData")
+	}
+
+	var r0 *model.AccessData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.AccessData) (*model.AccessData, error)); ok {
+		return rf(accessData)
+	}
+	if rf, ok := ret.Get(0).(func(*model.AccessData) *model.AccessData); ok {
+		r0 = rf(accessData)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AccessData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.AccessData) error); ok {
+		r1 = rf(accessData)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateApp provides a mock function with given fields: app
+func (_m *OAuthStore) UpdateApp(app *model.OAuthApp) (*model.OAuthApp, error) {
+	ret := _m.Called(app)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateApp")
+	}
+
+	var r0 *model.OAuthApp
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.OAuthApp) (*model.OAuthApp, error)); ok {
+		return rf(app)
+	}
+	if rf, ok := ret.Get(0).(func(*model.OAuthApp) *model.OAuthApp); ok {
+		r0 = rf(app)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.OAuthApp)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.OAuthApp) error); ok {
+		r1 = rf(app)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewOAuthStore creates a new instance of OAuthStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewOAuthStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *OAuthStore {
+	mock := &OAuthStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/OutgoingOAuthConnectionStore.go

@@ -0,0 +1,168 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// OutgoingOAuthConnectionStore is an autogenerated mock type for the OutgoingOAuthConnectionStore type
+type OutgoingOAuthConnectionStore struct {
+	mock.Mock
+}
+
+// DeleteConnection provides a mock function with given fields: rctx, id
+func (_m *OutgoingOAuthConnectionStore) DeleteConnection(rctx request.CTX, id string) error {
+	ret := _m.Called(rctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteConnection")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
+		r0 = rf(rctx, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetConnection provides a mock function with given fields: rctx, id
+func (_m *OutgoingOAuthConnectionStore) GetConnection(rctx request.CTX, id string) (*model.OutgoingOAuthConnection, error) {
+	ret := _m.Called(rctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetConnection")
+	}
+
+	var r0 *model.OutgoingOAuthConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.OutgoingOAuthConnection, error)); ok {
+		return rf(rctx, id)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.OutgoingOAuthConnection); ok {
+		r0 = rf(rctx, id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.OutgoingOAuthConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetConnections provides a mock function with given fields: rctx, filters
+func (_m *OutgoingOAuthConnectionStore) GetConnections(rctx request.CTX, filters model.OutgoingOAuthConnectionGetConnectionsFilter) ([]*model.OutgoingOAuthConnection, error) {
+	ret := _m.Called(rctx, filters)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetConnections")
+	}
+
+	var r0 []*model.OutgoingOAuthConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, model.OutgoingOAuthConnectionGetConnectionsFilter) ([]*model.OutgoingOAuthConnection, error)); ok {
+		return rf(rctx, filters)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, model.OutgoingOAuthConnectionGetConnectionsFilter) []*model.OutgoingOAuthConnection); ok {
+		r0 = rf(rctx, filters)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OutgoingOAuthConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, model.OutgoingOAuthConnectionGetConnectionsFilter) error); ok {
+		r1 = rf(rctx, filters)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveConnection provides a mock function with given fields: rctx, conn
+func (_m *OutgoingOAuthConnectionStore) SaveConnection(rctx request.CTX, conn *model.OutgoingOAuthConnection) (*model.OutgoingOAuthConnection, error) {
+	ret := _m.Called(rctx, conn)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveConnection")
+	}
+
+	var r0 *model.OutgoingOAuthConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.OutgoingOAuthConnection) (*model.OutgoingOAuthConnection, error)); ok {
+		return rf(rctx, conn)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.OutgoingOAuthConnection) *model.OutgoingOAuthConnection); ok {
+		r0 = rf(rctx, conn)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.OutgoingOAuthConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.OutgoingOAuthConnection) error); ok {
+		r1 = rf(rctx, conn)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateConnection provides a mock function with given fields: rctx, conn
+func (_m *OutgoingOAuthConnectionStore) UpdateConnection(rctx request.CTX, conn *model.OutgoingOAuthConnection) (*model.OutgoingOAuthConnection, error) {
+	ret := _m.Called(rctx, conn)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateConnection")
+	}
+
+	var r0 *model.OutgoingOAuthConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.OutgoingOAuthConnection) (*model.OutgoingOAuthConnection, error)); ok {
+		return rf(rctx, conn)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.OutgoingOAuthConnection) *model.OutgoingOAuthConnection); ok {
+		r0 = rf(rctx, conn)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.OutgoingOAuthConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.OutgoingOAuthConnection) error); ok {
+		r1 = rf(rctx, conn)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewOutgoingOAuthConnectionStore creates a new instance of OutgoingOAuthConnectionStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewOutgoingOAuthConnectionStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *OutgoingOAuthConnectionStore {
+	mock := &OutgoingOAuthConnectionStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/PluginStore.go

@@ -0,0 +1,257 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// PluginStore is an autogenerated mock type for the PluginStore type
+type PluginStore struct {
+	mock.Mock
+}
+
+// CompareAndDelete provides a mock function with given fields: keyVal, oldValue
+func (_m *PluginStore) CompareAndDelete(keyVal *model.PluginKeyValue, oldValue []byte) (bool, error) {
+	ret := _m.Called(keyVal, oldValue)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CompareAndDelete")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.PluginKeyValue, []byte) (bool, error)); ok {
+		return rf(keyVal, oldValue)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PluginKeyValue, []byte) bool); ok {
+		r0 = rf(keyVal, oldValue)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PluginKeyValue, []byte) error); ok {
+		r1 = rf(keyVal, oldValue)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CompareAndSet provides a mock function with given fields: keyVal, oldValue
+func (_m *PluginStore) CompareAndSet(keyVal *model.PluginKeyValue, oldValue []byte) (bool, error) {
+	ret := _m.Called(keyVal, oldValue)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CompareAndSet")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.PluginKeyValue, []byte) (bool, error)); ok {
+		return rf(keyVal, oldValue)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PluginKeyValue, []byte) bool); ok {
+		r0 = rf(keyVal, oldValue)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PluginKeyValue, []byte) error); ok {
+		r1 = rf(keyVal, oldValue)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: pluginID, key
+func (_m *PluginStore) Delete(pluginID string, key string) error {
+	ret := _m.Called(pluginID, key)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(pluginID, key)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteAllExpired provides a mock function with no fields
+func (_m *PluginStore) DeleteAllExpired() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteAllExpired")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteAllForPlugin provides a mock function with given fields: PluginID
+func (_m *PluginStore) DeleteAllForPlugin(PluginID string) error {
+	ret := _m.Called(PluginID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteAllForPlugin")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(PluginID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: pluginID, key
+func (_m *PluginStore) Get(pluginID string, key string) (*model.PluginKeyValue, error) {
+	ret := _m.Called(pluginID, key)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.PluginKeyValue
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.PluginKeyValue, error)); ok {
+		return rf(pluginID, key)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.PluginKeyValue); ok {
+		r0 = rf(pluginID, key)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PluginKeyValue)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(pluginID, key)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// List provides a mock function with given fields: pluginID, page, perPage
+func (_m *PluginStore) List(pluginID string, page int, perPage int) ([]string, error) {
+	ret := _m.Called(pluginID, page, perPage)
+
+	if len(ret) == 0 {
+		panic("no return value specified for List")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]string, error)); ok {
+		return rf(pluginID, page, perPage)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []string); ok {
+		r0 = rf(pluginID, page, perPage)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(pluginID, page, perPage)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveOrUpdate provides a mock function with given fields: keyVal
+func (_m *PluginStore) SaveOrUpdate(keyVal *model.PluginKeyValue) (*model.PluginKeyValue, error) {
+	ret := _m.Called(keyVal)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveOrUpdate")
+	}
+
+	var r0 *model.PluginKeyValue
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.PluginKeyValue) (*model.PluginKeyValue, error)); ok {
+		return rf(keyVal)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PluginKeyValue) *model.PluginKeyValue); ok {
+		r0 = rf(keyVal)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PluginKeyValue)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PluginKeyValue) error); ok {
+		r1 = rf(keyVal)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SetWithOptions provides a mock function with given fields: pluginID, key, value, options
+func (_m *PluginStore) SetWithOptions(pluginID string, key string, value []byte, options model.PluginKVSetOptions) (bool, error) {
+	ret := _m.Called(pluginID, key, value, options)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetWithOptions")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, []byte, model.PluginKVSetOptions) (bool, error)); ok {
+		return rf(pluginID, key, value, options)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, []byte, model.PluginKVSetOptions) bool); ok {
+		r0 = rf(pluginID, key, value, options)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, []byte, model.PluginKVSetOptions) error); ok {
+		r1 = rf(pluginID, key, value, options)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewPluginStore creates a new instance of PluginStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPluginStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PluginStore {
+	mock := &PluginStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/PostAcknowledgementStore.go

@@ -0,0 +1,293 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// PostAcknowledgementStore is an autogenerated mock type for the PostAcknowledgementStore type
+type PostAcknowledgementStore struct {
+	mock.Mock
+}
+
+// BatchDelete provides a mock function with given fields: acknowledgements
+func (_m *PostAcknowledgementStore) BatchDelete(acknowledgements []*model.PostAcknowledgement) error {
+	ret := _m.Called(acknowledgements)
+
+	if len(ret) == 0 {
+		panic("no return value specified for BatchDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func([]*model.PostAcknowledgement) error); ok {
+		r0 = rf(acknowledgements)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// BatchSave provides a mock function with given fields: acknowledgements
+func (_m *PostAcknowledgementStore) BatchSave(acknowledgements []*model.PostAcknowledgement) ([]*model.PostAcknowledgement, error) {
+	ret := _m.Called(acknowledgements)
+
+	if len(ret) == 0 {
+		panic("no return value specified for BatchSave")
+	}
+
+	var r0 []*model.PostAcknowledgement
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]*model.PostAcknowledgement) ([]*model.PostAcknowledgement, error)); ok {
+		return rf(acknowledgements)
+	}
+	if rf, ok := ret.Get(0).(func([]*model.PostAcknowledgement) []*model.PostAcknowledgement); ok {
+		r0 = rf(acknowledgements)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PostAcknowledgement)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]*model.PostAcknowledgement) error); ok {
+		r1 = rf(acknowledgements)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: acknowledgement
+func (_m *PostAcknowledgementStore) Delete(acknowledgement *model.PostAcknowledgement) error {
+	ret := _m.Called(acknowledgement)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.PostAcknowledgement) error); ok {
+		r0 = rf(acknowledgement)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteAllForPost provides a mock function with given fields: postID
+func (_m *PostAcknowledgementStore) DeleteAllForPost(postID string) error {
+	ret := _m.Called(postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteAllForPost")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(postID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: postID, userID
+func (_m *PostAcknowledgementStore) Get(postID string, userID string) (*model.PostAcknowledgement, error) {
+	ret := _m.Called(postID, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.PostAcknowledgement
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.PostAcknowledgement, error)); ok {
+		return rf(postID, userID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.PostAcknowledgement); ok {
+		r0 = rf(postID, userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PostAcknowledgement)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(postID, userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPost provides a mock function with given fields: postID
+func (_m *PostAcknowledgementStore) GetForPost(postID string) ([]*model.PostAcknowledgement, error) {
+	ret := _m.Called(postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForPost")
+	}
+
+	var r0 []*model.PostAcknowledgement
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.PostAcknowledgement, error)); ok {
+		return rf(postID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.PostAcknowledgement); ok {
+		r0 = rf(postID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PostAcknowledgement)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPostSince provides a mock function with given fields: postID, since, excludeRemoteID, inclDeleted
+func (_m *PostAcknowledgementStore) GetForPostSince(postID string, since int64, excludeRemoteID string, inclDeleted bool) ([]*model.PostAcknowledgement, error) {
+	ret := _m.Called(postID, since, excludeRemoteID, inclDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForPostSince")
+	}
+
+	var r0 []*model.PostAcknowledgement
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64, string, bool) ([]*model.PostAcknowledgement, error)); ok {
+		return rf(postID, since, excludeRemoteID, inclDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64, string, bool) []*model.PostAcknowledgement); ok {
+		r0 = rf(postID, since, excludeRemoteID, inclDeleted)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PostAcknowledgement)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64, string, bool) error); ok {
+		r1 = rf(postID, since, excludeRemoteID, inclDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPosts provides a mock function with given fields: postIds
+func (_m *PostAcknowledgementStore) GetForPosts(postIds []string) ([]*model.PostAcknowledgement, error) {
+	ret := _m.Called(postIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForPosts")
+	}
+
+	var r0 []*model.PostAcknowledgement
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string) ([]*model.PostAcknowledgement, error)); ok {
+		return rf(postIds)
+	}
+	if rf, ok := ret.Get(0).(func([]string) []*model.PostAcknowledgement); ok {
+		r0 = rf(postIds)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PostAcknowledgement)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]string) error); ok {
+		r1 = rf(postIds)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetSingle provides a mock function with given fields: userID, postID, remoteID
+func (_m *PostAcknowledgementStore) GetSingle(userID string, postID string, remoteID string) (*model.PostAcknowledgement, error) {
+	ret := _m.Called(userID, postID, remoteID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSingle")
+	}
+
+	var r0 *model.PostAcknowledgement
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, string) (*model.PostAcknowledgement, error)); ok {
+		return rf(userID, postID, remoteID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, string) *model.PostAcknowledgement); ok {
+		r0 = rf(userID, postID, remoteID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PostAcknowledgement)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
+		r1 = rf(userID, postID, remoteID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveWithModel provides a mock function with given fields: acknowledgement
+func (_m *PostAcknowledgementStore) SaveWithModel(acknowledgement *model.PostAcknowledgement) (*model.PostAcknowledgement, error) {
+	ret := _m.Called(acknowledgement)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveWithModel")
+	}
+
+	var r0 *model.PostAcknowledgement
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.PostAcknowledgement) (*model.PostAcknowledgement, error)); ok {
+		return rf(acknowledgement)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PostAcknowledgement) *model.PostAcknowledgement); ok {
+		r0 = rf(acknowledgement)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PostAcknowledgement)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PostAcknowledgement) error); ok {
+		r1 = rf(acknowledgement)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewPostAcknowledgementStore creates a new instance of PostAcknowledgementStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPostAcknowledgementStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PostAcknowledgementStore {
+	mock := &PostAcknowledgementStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/PostPersistentNotificationStore.go

@@ -0,0 +1,179 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// PostPersistentNotificationStore is an autogenerated mock type for the PostPersistentNotificationStore type
+type PostPersistentNotificationStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: postIds
+func (_m *PostPersistentNotificationStore) Delete(postIds []string) error {
+	ret := _m.Called(postIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func([]string) error); ok {
+		r0 = rf(postIds)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteByChannel provides a mock function with given fields: channelIds
+func (_m *PostPersistentNotificationStore) DeleteByChannel(channelIds []string) error {
+	ret := _m.Called(channelIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteByChannel")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func([]string) error); ok {
+		r0 = rf(channelIds)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteByTeam provides a mock function with given fields: teamIds
+func (_m *PostPersistentNotificationStore) DeleteByTeam(teamIds []string) error {
+	ret := _m.Called(teamIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteByTeam")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func([]string) error); ok {
+		r0 = rf(teamIds)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteExpired provides a mock function with given fields: maxSentCount
+func (_m *PostPersistentNotificationStore) DeleteExpired(maxSentCount int16) error {
+	ret := _m.Called(maxSentCount)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteExpired")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int16) error); ok {
+		r0 = rf(maxSentCount)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: params
+func (_m *PostPersistentNotificationStore) Get(params model.GetPersistentNotificationsPostsParams) ([]*model.PostPersistentNotifications, error) {
+	ret := _m.Called(params)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 []*model.PostPersistentNotifications
+	var r1 error
+	if rf, ok := ret.Get(0).(func(model.GetPersistentNotificationsPostsParams) ([]*model.PostPersistentNotifications, error)); ok {
+		return rf(params)
+	}
+	if rf, ok := ret.Get(0).(func(model.GetPersistentNotificationsPostsParams) []*model.PostPersistentNotifications); ok {
+		r0 = rf(params)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PostPersistentNotifications)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(model.GetPersistentNotificationsPostsParams) error); ok {
+		r1 = rf(params)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetSingle provides a mock function with given fields: postID
+func (_m *PostPersistentNotificationStore) GetSingle(postID string) (*model.PostPersistentNotifications, error) {
+	ret := _m.Called(postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSingle")
+	}
+
+	var r0 *model.PostPersistentNotifications
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.PostPersistentNotifications, error)); ok {
+		return rf(postID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.PostPersistentNotifications); ok {
+		r0 = rf(postID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PostPersistentNotifications)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateLastActivity provides a mock function with given fields: postIds
+func (_m *PostPersistentNotificationStore) UpdateLastActivity(postIds []string) error {
+	ret := _m.Called(postIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateLastActivity")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func([]string) error); ok {
+		r0 = rf(postIds)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewPostPersistentNotificationStore creates a new instance of PostPersistentNotificationStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPostPersistentNotificationStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PostPersistentNotificationStore {
+	mock := &PostPersistentNotificationStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/PostPriorityStore.go

@@ -0,0 +1,168 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// PostPriorityStore is an autogenerated mock type for the PostPriorityStore type
+type PostPriorityStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: postID
+func (_m *PostPriorityStore) Delete(postID string) error {
+	ret := _m.Called(postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(postID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetForPost provides a mock function with given fields: postID
+func (_m *PostPriorityStore) GetForPost(postID string) (*model.PostPriority, error) {
+	ret := _m.Called(postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForPost")
+	}
+
+	var r0 *model.PostPriority
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.PostPriority, error)); ok {
+		return rf(postID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.PostPriority); ok {
+		r0 = rf(postID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PostPriority)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPostWithContext provides a mock function with given fields: rctx, postID
+func (_m *PostPriorityStore) GetForPostWithContext(rctx request.CTX, postID string) (*model.PostPriority, error) {
+	ret := _m.Called(rctx, postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForPostWithContext")
+	}
+
+	var r0 *model.PostPriority
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.PostPriority, error)); ok {
+		return rf(rctx, postID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.PostPriority); ok {
+		r0 = rf(rctx, postID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PostPriority)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPosts provides a mock function with given fields: ids
+func (_m *PostPriorityStore) GetForPosts(ids []string) ([]*model.PostPriority, error) {
+	ret := _m.Called(ids)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForPosts")
+	}
+
+	var r0 []*model.PostPriority
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string) ([]*model.PostPriority, error)); ok {
+		return rf(ids)
+	}
+	if rf, ok := ret.Get(0).(func([]string) []*model.PostPriority); ok {
+		r0 = rf(ids)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PostPriority)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]string) error); ok {
+		r1 = rf(ids)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: priority
+func (_m *PostPriorityStore) Save(priority *model.PostPriority) (*model.PostPriority, error) {
+	ret := _m.Called(priority)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.PostPriority
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.PostPriority) (*model.PostPriority, error)); ok {
+		return rf(priority)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PostPriority) *model.PostPriority); ok {
+		r0 = rf(priority)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PostPriority)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PostPriority) error); ok {
+		r1 = rf(priority)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewPostPriorityStore creates a new instance of PostPriorityStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPostPriorityStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PostPriorityStore {
+	mock := &PostPriorityStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/PreferenceStore.go

@@ -0,0 +1,323 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// PreferenceStore is an autogenerated mock type for the PreferenceStore type
+type PreferenceStore struct {
+	mock.Mock
+}
+
+// CleanupFlagsBatch provides a mock function with given fields: limit
+func (_m *PreferenceStore) CleanupFlagsBatch(limit int64) (int64, error) {
+	ret := _m.Called(limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CleanupFlagsBatch")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (int64, error)); ok {
+		return rf(limit)
+	}
+	if rf, ok := ret.Get(0).(func(int64) int64); ok {
+		r0 = rf(limit)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: userID, category, name
+func (_m *PreferenceStore) Delete(userID string, category string, name string) error {
+	ret := _m.Called(userID, category, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, string) error); ok {
+		r0 = rf(userID, category, name)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteCategory provides a mock function with given fields: userID, category
+func (_m *PreferenceStore) DeleteCategory(userID string, category string) error {
+	ret := _m.Called(userID, category)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteCategory")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(userID, category)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteCategoryAndName provides a mock function with given fields: category, name
+func (_m *PreferenceStore) DeleteCategoryAndName(category string, name string) error {
+	ret := _m.Called(category, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteCategoryAndName")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(category, name)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteInvalidVisibleDmsGms provides a mock function with no fields
+func (_m *PreferenceStore) DeleteInvalidVisibleDmsGms() (int64, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteInvalidVisibleDmsGms")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeleteOrphanedRows provides a mock function with given fields: limit
+func (_m *PreferenceStore) DeleteOrphanedRows(limit int) (int64, error) {
+	ret := _m.Called(limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteOrphanedRows")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int) (int64, error)); ok {
+		return rf(limit)
+	}
+	if rf, ok := ret.Get(0).(func(int) int64); ok {
+		r0 = rf(limit)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int) error); ok {
+		r1 = rf(limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: userID, category, name
+func (_m *PreferenceStore) Get(userID string, category string, name string) (*model.Preference, error) {
+	ret := _m.Called(userID, category, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Preference
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, string) (*model.Preference, error)); ok {
+		return rf(userID, category, name)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, string) *model.Preference); ok {
+		r0 = rf(userID, category, name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Preference)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
+		r1 = rf(userID, category, name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with given fields: userID
+func (_m *PreferenceStore) GetAll(userID string) (model.Preferences, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 model.Preferences
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (model.Preferences, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) model.Preferences); ok {
+		r0 = rf(userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(model.Preferences)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetCategory provides a mock function with given fields: userID, category
+func (_m *PreferenceStore) GetCategory(userID string, category string) (model.Preferences, error) {
+	ret := _m.Called(userID, category)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetCategory")
+	}
+
+	var r0 model.Preferences
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (model.Preferences, error)); ok {
+		return rf(userID, category)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) model.Preferences); ok {
+		r0 = rf(userID, category)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(model.Preferences)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(userID, category)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetCategoryAndName provides a mock function with given fields: category, name
+func (_m *PreferenceStore) GetCategoryAndName(category string, name string) (model.Preferences, error) {
+	ret := _m.Called(category, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetCategoryAndName")
+	}
+
+	var r0 model.Preferences
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (model.Preferences, error)); ok {
+		return rf(category, name)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) model.Preferences); ok {
+		r0 = rf(category, name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(model.Preferences)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(category, name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteByUser provides a mock function with given fields: userID
+func (_m *PreferenceStore) PermanentDeleteByUser(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: preferences
+func (_m *PreferenceStore) Save(preferences model.Preferences) error {
+	ret := _m.Called(preferences)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(model.Preferences) error); ok {
+		r0 = rf(preferences)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewPreferenceStore creates a new instance of PreferenceStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPreferenceStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PreferenceStore {
+	mock := &PreferenceStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ProductNoticesStore.go

@@ -0,0 +1,113 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ProductNoticesStore is an autogenerated mock type for the ProductNoticesStore type
+type ProductNoticesStore struct {
+	mock.Mock
+}
+
+// Clear provides a mock function with given fields: notices
+func (_m *ProductNoticesStore) Clear(notices []string) error {
+	ret := _m.Called(notices)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Clear")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func([]string) error); ok {
+		r0 = rf(notices)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ClearOldNotices provides a mock function with given fields: currentNotices
+func (_m *ProductNoticesStore) ClearOldNotices(currentNotices model.ProductNotices) error {
+	ret := _m.Called(currentNotices)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClearOldNotices")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(model.ProductNotices) error); ok {
+		r0 = rf(currentNotices)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetViews provides a mock function with given fields: userID
+func (_m *ProductNoticesStore) GetViews(userID string) ([]model.ProductNoticeViewState, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetViews")
+	}
+
+	var r0 []model.ProductNoticeViewState
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]model.ProductNoticeViewState, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []model.ProductNoticeViewState); ok {
+		r0 = rf(userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]model.ProductNoticeViewState)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// View provides a mock function with given fields: userID, notices
+func (_m *ProductNoticesStore) View(userID string, notices []string) error {
+	ret := _m.Called(userID, notices)
+
+	if len(ret) == 0 {
+		panic("no return value specified for View")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []string) error); ok {
+		r0 = rf(userID, notices)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewProductNoticesStore creates a new instance of ProductNoticesStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewProductNoticesStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ProductNoticesStore {
+	mock := &ProductNoticesStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/PropertyFieldStore.go

@@ -0,0 +1,428 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// PropertyFieldStore is an autogenerated mock type for the PropertyFieldStore type
+type PropertyFieldStore struct {
+	mock.Mock
+}
+
+// CheckPropertyNameConflict provides a mock function with given fields: field, excludeID
+func (_m *PropertyFieldStore) CheckPropertyNameConflict(field *model.PropertyField, excludeID string) (model.PropertyFieldTargetLevel, error) {
+	ret := _m.Called(field, excludeID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CheckPropertyNameConflict")
+	}
+
+	var r0 model.PropertyFieldTargetLevel
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.PropertyField, string) (model.PropertyFieldTargetLevel, error)); ok {
+		return rf(field, excludeID)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PropertyField, string) model.PropertyFieldTargetLevel); ok {
+		r0 = rf(field, excludeID)
+	} else {
+		r0 = ret.Get(0).(model.PropertyFieldTargetLevel)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PropertyField, string) error); ok {
+		r1 = rf(field, excludeID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CountForGroup provides a mock function with given fields: groupID, includeDeleted
+func (_m *PropertyFieldStore) CountForGroup(groupID string, includeDeleted bool) (int64, error) {
+	ret := _m.Called(groupID, includeDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountForGroup")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool) (int64, error)); ok {
+		return rf(groupID, includeDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool) int64); ok {
+		r0 = rf(groupID, includeDeleted)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(groupID, includeDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CountForGroupObjectType provides a mock function with given fields: groupID, objectType, includeDeleted
+func (_m *PropertyFieldStore) CountForGroupObjectType(groupID string, objectType string, includeDeleted bool) (int64, error) {
+	ret := _m.Called(groupID, objectType, includeDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountForGroupObjectType")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, bool) (int64, error)); ok {
+		return rf(groupID, objectType, includeDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, bool) int64); ok {
+		r0 = rf(groupID, objectType, includeDeleted)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, bool) error); ok {
+		r1 = rf(groupID, objectType, includeDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CountForTarget provides a mock function with given fields: groupID, targetType, targetID, includeDeleted
+func (_m *PropertyFieldStore) CountForTarget(groupID string, targetType string, targetID string, includeDeleted bool) (int64, error) {
+	ret := _m.Called(groupID, targetType, targetID, includeDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountForTarget")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, string, bool) (int64, error)); ok {
+		return rf(groupID, targetType, targetID, includeDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, string, bool) int64); ok {
+		r0 = rf(groupID, targetType, targetID, includeDeleted)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, string, bool) error); ok {
+		r1 = rf(groupID, targetType, targetID, includeDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CountLinkedFields provides a mock function with given fields: fieldID
+func (_m *PropertyFieldStore) CountLinkedFields(fieldID string) (int64, error) {
+	ret := _m.Called(fieldID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountLinkedFields")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(fieldID)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(fieldID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(fieldID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Create provides a mock function with given fields: field
+func (_m *PropertyFieldStore) Create(field *model.PropertyField) (*model.PropertyField, error) {
+	ret := _m.Called(field)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Create")
+	}
+
+	var r0 *model.PropertyField
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.PropertyField) (*model.PropertyField, error)); ok {
+		return rf(field)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PropertyField) *model.PropertyField); ok {
+		r0 = rf(field)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PropertyField)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PropertyField) error); ok {
+		r1 = rf(field)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: groupID, id
+func (_m *PropertyFieldStore) Delete(groupID string, id string) error {
+	ret := _m.Called(groupID, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(groupID, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: rctx, groupID, id
+func (_m *PropertyFieldStore) Get(rctx request.CTX, groupID string, id string) (*model.PropertyField, error) {
+	ret := _m.Called(rctx, groupID, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.PropertyField
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) (*model.PropertyField, error)); ok {
+		return rf(rctx, groupID, id)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) *model.PropertyField); ok {
+		r0 = rf(rctx, groupID, id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PropertyField)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string) error); ok {
+		r1 = rf(rctx, groupID, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetFieldByName provides a mock function with given fields: rctx, groupID, targetID, name
+func (_m *PropertyFieldStore) GetFieldByName(rctx request.CTX, groupID string, targetID string, name string) (*model.PropertyField, error) {
+	ret := _m.Called(rctx, groupID, targetID, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetFieldByName")
+	}
+
+	var r0 *model.PropertyField
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, string) (*model.PropertyField, error)); ok {
+		return rf(rctx, groupID, targetID, name)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, string) *model.PropertyField); ok {
+		r0 = rf(rctx, groupID, targetID, name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PropertyField)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string, string) error); ok {
+		r1 = rf(rctx, groupID, targetID, name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetFieldByNameForObjectType provides a mock function with given fields: rctx, groupID, targetID, objectType, name
+func (_m *PropertyFieldStore) GetFieldByNameForObjectType(rctx request.CTX, groupID string, targetID string, objectType string, name string) (*model.PropertyField, error) {
+	ret := _m.Called(rctx, groupID, targetID, objectType, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetFieldByNameForObjectType")
+	}
+
+	var r0 *model.PropertyField
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, string, string) (*model.PropertyField, error)); ok {
+		return rf(rctx, groupID, targetID, objectType, name)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, string, string) *model.PropertyField); ok {
+		r0 = rf(rctx, groupID, targetID, objectType, name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PropertyField)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string, string, string) error); ok {
+		r1 = rf(rctx, groupID, targetID, objectType, name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForGroup provides a mock function with given fields: rctx, groupID
+func (_m *PropertyFieldStore) GetForGroup(rctx request.CTX, groupID string) ([]*model.PropertyField, error) {
+	ret := _m.Called(rctx, groupID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForGroup")
+	}
+
+	var r0 []*model.PropertyField
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) ([]*model.PropertyField, error)); ok {
+		return rf(rctx, groupID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) []*model.PropertyField); ok {
+		r0 = rf(rctx, groupID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PropertyField)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, groupID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMany provides a mock function with given fields: rctx, groupID, ids
+func (_m *PropertyFieldStore) GetMany(rctx request.CTX, groupID string, ids []string) ([]*model.PropertyField, error) {
+	ret := _m.Called(rctx, groupID, ids)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetMany")
+	}
+
+	var r0 []*model.PropertyField
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, []string) ([]*model.PropertyField, error)); ok {
+		return rf(rctx, groupID, ids)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, []string) []*model.PropertyField); ok {
+		r0 = rf(rctx, groupID, ids)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PropertyField)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, []string) error); ok {
+		r1 = rf(rctx, groupID, ids)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SearchPropertyFields provides a mock function with given fields: opts
+func (_m *PropertyFieldStore) SearchPropertyFields(opts model.PropertyFieldSearchOpts) ([]*model.PropertyField, error) {
+	ret := _m.Called(opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SearchPropertyFields")
+	}
+
+	var r0 []*model.PropertyField
+	var r1 error
+	if rf, ok := ret.Get(0).(func(model.PropertyFieldSearchOpts) ([]*model.PropertyField, error)); ok {
+		return rf(opts)
+	}
+	if rf, ok := ret.Get(0).(func(model.PropertyFieldSearchOpts) []*model.PropertyField); ok {
+		r0 = rf(opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PropertyField)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(model.PropertyFieldSearchOpts) error); ok {
+		r1 = rf(opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: groupID, fields, expectedUpdateAts
+func (_m *PropertyFieldStore) Update(groupID string, fields []*model.PropertyField, expectedUpdateAts map[string]int64) ([]*model.PropertyField, error) {
+	ret := _m.Called(groupID, fields, expectedUpdateAts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 []*model.PropertyField
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, []*model.PropertyField, map[string]int64) ([]*model.PropertyField, error)); ok {
+		return rf(groupID, fields, expectedUpdateAts)
+	}
+	if rf, ok := ret.Get(0).(func(string, []*model.PropertyField, map[string]int64) []*model.PropertyField); ok {
+		r0 = rf(groupID, fields, expectedUpdateAts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PropertyField)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, []*model.PropertyField, map[string]int64) error); ok {
+		r1 = rf(groupID, fields, expectedUpdateAts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewPropertyFieldStore creates a new instance of PropertyFieldStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPropertyFieldStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PropertyFieldStore {
+	mock := &PropertyFieldStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/PropertyGroupStore.go

@@ -0,0 +1,137 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// PropertyGroupStore is an autogenerated mock type for the PropertyGroupStore type
+type PropertyGroupStore struct {
+	mock.Mock
+}
+
+// Get provides a mock function with given fields: name
+func (_m *PropertyGroupStore) Get(name string) (*model.PropertyGroup, error) {
+	ret := _m.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.PropertyGroup
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.PropertyGroup, error)); ok {
+		return rf(name)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.PropertyGroup); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PropertyGroup)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByID provides a mock function with given fields: id
+func (_m *PropertyGroupStore) GetByID(id string) (*model.PropertyGroup, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByID")
+	}
+
+	var r0 *model.PropertyGroup
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.PropertyGroup, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.PropertyGroup); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PropertyGroup)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// IncrementVersion provides a mock function with given fields: name
+func (_m *PropertyGroupStore) IncrementVersion(name string) error {
+	ret := _m.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IncrementVersion")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(name)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Register provides a mock function with given fields: group
+func (_m *PropertyGroupStore) Register(group *model.PropertyGroup) (*model.PropertyGroup, error) {
+	ret := _m.Called(group)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Register")
+	}
+
+	var r0 *model.PropertyGroup
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.PropertyGroup) (*model.PropertyGroup, error)); ok {
+		return rf(group)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PropertyGroup) *model.PropertyGroup); ok {
+		r0 = rf(group)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PropertyGroup)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PropertyGroup) error); ok {
+		r1 = rf(group)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewPropertyGroupStore creates a new instance of PropertyGroupStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPropertyGroupStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PropertyGroupStore {
+	mock := &PropertyGroupStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/PropertyValueStore.go

@@ -0,0 +1,293 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// PropertyValueStore is an autogenerated mock type for the PropertyValueStore type
+type PropertyValueStore struct {
+	mock.Mock
+}
+
+// Create provides a mock function with given fields: value
+func (_m *PropertyValueStore) Create(value *model.PropertyValue) (*model.PropertyValue, error) {
+	ret := _m.Called(value)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Create")
+	}
+
+	var r0 *model.PropertyValue
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.PropertyValue) (*model.PropertyValue, error)); ok {
+		return rf(value)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PropertyValue) *model.PropertyValue); ok {
+		r0 = rf(value)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PropertyValue)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PropertyValue) error); ok {
+		r1 = rf(value)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CreateMany provides a mock function with given fields: values
+func (_m *PropertyValueStore) CreateMany(values []*model.PropertyValue) ([]*model.PropertyValue, error) {
+	ret := _m.Called(values)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateMany")
+	}
+
+	var r0 []*model.PropertyValue
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]*model.PropertyValue) ([]*model.PropertyValue, error)); ok {
+		return rf(values)
+	}
+	if rf, ok := ret.Get(0).(func([]*model.PropertyValue) []*model.PropertyValue); ok {
+		r0 = rf(values)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PropertyValue)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]*model.PropertyValue) error); ok {
+		r1 = rf(values)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: groupID, id
+func (_m *PropertyValueStore) Delete(groupID string, id string) error {
+	ret := _m.Called(groupID, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(groupID, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteForField provides a mock function with given fields: groupID, fieldID
+func (_m *PropertyValueStore) DeleteForField(groupID string, fieldID string) error {
+	ret := _m.Called(groupID, fieldID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteForField")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(groupID, fieldID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteForTarget provides a mock function with given fields: groupID, targetType, targetID
+func (_m *PropertyValueStore) DeleteForTarget(groupID string, targetType string, targetID string) error {
+	ret := _m.Called(groupID, targetType, targetID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteForTarget")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, string) error); ok {
+		r0 = rf(groupID, targetType, targetID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: groupID, id
+func (_m *PropertyValueStore) Get(groupID string, id string) (*model.PropertyValue, error) {
+	ret := _m.Called(groupID, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.PropertyValue
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.PropertyValue, error)); ok {
+		return rf(groupID, id)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.PropertyValue); ok {
+		r0 = rf(groupID, id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PropertyValue)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(groupID, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMany provides a mock function with given fields: groupID, ids
+func (_m *PropertyValueStore) GetMany(groupID string, ids []string) ([]*model.PropertyValue, error) {
+	ret := _m.Called(groupID, ids)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetMany")
+	}
+
+	var r0 []*model.PropertyValue
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, []string) ([]*model.PropertyValue, error)); ok {
+		return rf(groupID, ids)
+	}
+	if rf, ok := ret.Get(0).(func(string, []string) []*model.PropertyValue); ok {
+		r0 = rf(groupID, ids)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PropertyValue)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, []string) error); ok {
+		r1 = rf(groupID, ids)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SearchPropertyValues provides a mock function with given fields: opts
+func (_m *PropertyValueStore) SearchPropertyValues(opts model.PropertyValueSearchOpts) ([]*model.PropertyValue, error) {
+	ret := _m.Called(opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SearchPropertyValues")
+	}
+
+	var r0 []*model.PropertyValue
+	var r1 error
+	if rf, ok := ret.Get(0).(func(model.PropertyValueSearchOpts) ([]*model.PropertyValue, error)); ok {
+		return rf(opts)
+	}
+	if rf, ok := ret.Get(0).(func(model.PropertyValueSearchOpts) []*model.PropertyValue); ok {
+		r0 = rf(opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PropertyValue)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(model.PropertyValueSearchOpts) error); ok {
+		r1 = rf(opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: groupID, values
+func (_m *PropertyValueStore) Update(groupID string, values []*model.PropertyValue) ([]*model.PropertyValue, error) {
+	ret := _m.Called(groupID, values)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 []*model.PropertyValue
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, []*model.PropertyValue) ([]*model.PropertyValue, error)); ok {
+		return rf(groupID, values)
+	}
+	if rf, ok := ret.Get(0).(func(string, []*model.PropertyValue) []*model.PropertyValue); ok {
+		r0 = rf(groupID, values)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PropertyValue)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, []*model.PropertyValue) error); ok {
+		r1 = rf(groupID, values)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Upsert provides a mock function with given fields: values
+func (_m *PropertyValueStore) Upsert(values []*model.PropertyValue) ([]*model.PropertyValue, error) {
+	ret := _m.Called(values)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Upsert")
+	}
+
+	var r0 []*model.PropertyValue
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]*model.PropertyValue) ([]*model.PropertyValue, error)); ok {
+		return rf(values)
+	}
+	if rf, ok := ret.Get(0).(func([]*model.PropertyValue) []*model.PropertyValue); ok {
+		r0 = rf(values)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PropertyValue)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]*model.PropertyValue) error); ok {
+		r1 = rf(values)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewPropertyValueStore creates a new instance of PropertyValueStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPropertyValueStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PropertyValueStore {
+	mock := &PropertyValueStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ReactionStore.go

@@ -0,0 +1,328 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ReactionStore is an autogenerated mock type for the ReactionStore type
+type ReactionStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: reaction
+func (_m *ReactionStore) Delete(reaction *model.Reaction) (*model.Reaction, error) {
+	ret := _m.Called(reaction)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 *model.Reaction
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Reaction) (*model.Reaction, error)); ok {
+		return rf(reaction)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Reaction) *model.Reaction); ok {
+		r0 = rf(reaction)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Reaction)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Reaction) error); ok {
+		r1 = rf(reaction)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeleteAllWithEmojiName provides a mock function with given fields: rctx, emojiName
+func (_m *ReactionStore) DeleteAllWithEmojiName(rctx request.CTX, emojiName string) error {
+	ret := _m.Called(rctx, emojiName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteAllWithEmojiName")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
+		r0 = rf(rctx, emojiName)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteOrphanedRowsByIds provides a mock function with given fields: r
+func (_m *ReactionStore) DeleteOrphanedRowsByIds(r *model.RetentionIdsForDeletion) (int64, error) {
+	ret := _m.Called(r)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteOrphanedRowsByIds")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.RetentionIdsForDeletion) (int64, error)); ok {
+		return rf(r)
+	}
+	if rf, ok := ret.Get(0).(func(*model.RetentionIdsForDeletion) int64); ok {
+		r0 = rf(r)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.RetentionIdsForDeletion) error); ok {
+		r1 = rf(r)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ExistsOnPost provides a mock function with given fields: postID, emojiName
+func (_m *ReactionStore) ExistsOnPost(postID string, emojiName string) (bool, error) {
+	ret := _m.Called(postID, emojiName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ExistsOnPost")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (bool, error)); ok {
+		return rf(postID, emojiName)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) bool); ok {
+		r0 = rf(postID, emojiName)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(postID, emojiName)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPost provides a mock function with given fields: postID, allowFromCache
+func (_m *ReactionStore) GetForPost(postID string, allowFromCache bool) ([]*model.Reaction, error) {
+	ret := _m.Called(postID, allowFromCache)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForPost")
+	}
+
+	var r0 []*model.Reaction
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool) ([]*model.Reaction, error)); ok {
+		return rf(postID, allowFromCache)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool) []*model.Reaction); ok {
+		r0 = rf(postID, allowFromCache)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Reaction)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(postID, allowFromCache)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPostSince provides a mock function with given fields: postID, since, excludeRemoteID, inclDeleted
+func (_m *ReactionStore) GetForPostSince(postID string, since int64, excludeRemoteID string, inclDeleted bool) ([]*model.Reaction, error) {
+	ret := _m.Called(postID, since, excludeRemoteID, inclDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForPostSince")
+	}
+
+	var r0 []*model.Reaction
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64, string, bool) ([]*model.Reaction, error)); ok {
+		return rf(postID, since, excludeRemoteID, inclDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64, string, bool) []*model.Reaction); ok {
+		r0 = rf(postID, since, excludeRemoteID, inclDeleted)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Reaction)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64, string, bool) error); ok {
+		r1 = rf(postID, since, excludeRemoteID, inclDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetSingle provides a mock function with given fields: userID, postID, remoteID, emojiName
+func (_m *ReactionStore) GetSingle(userID string, postID string, remoteID string, emojiName string) (*model.Reaction, error) {
+	ret := _m.Called(userID, postID, remoteID, emojiName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSingle")
+	}
+
+	var r0 *model.Reaction
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, string, string) (*model.Reaction, error)); ok {
+		return rf(userID, postID, remoteID, emojiName)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, string, string) *model.Reaction); ok {
+		r0 = rf(userID, postID, remoteID, emojiName)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Reaction)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, string, string) error); ok {
+		r1 = rf(userID, postID, remoteID, emojiName)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUniqueCountForPost provides a mock function with given fields: postID
+func (_m *ReactionStore) GetUniqueCountForPost(postID string) (int, error) {
+	ret := _m.Called(postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUniqueCountForPost")
+	}
+
+	var r0 int
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int, error)); ok {
+		return rf(postID)
+	}
+	if rf, ok := ret.Get(0).(func(string) int); ok {
+		r0 = rf(postID)
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteBatch provides a mock function with given fields: endTime, limit
+func (_m *ReactionStore) PermanentDeleteBatch(endTime int64, limit int64) (int64, error) {
+	ret := _m.Called(endTime, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteBatch")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, int64) (int64, error)); ok {
+		return rf(endTime, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int64, int64) int64); ok {
+		r0 = rf(endTime, limit)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
+		r1 = rf(endTime, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteByUser provides a mock function with given fields: rctx, userID
+func (_m *ReactionStore) PermanentDeleteByUser(rctx request.CTX, userID string) error {
+	ret := _m.Called(rctx, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
+		r0 = rf(rctx, userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: reaction
+func (_m *ReactionStore) Save(reaction *model.Reaction) (*model.Reaction, error) {
+	ret := _m.Called(reaction)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.Reaction
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Reaction) (*model.Reaction, error)); ok {
+		return rf(reaction)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Reaction) *model.Reaction); ok {
+		r0 = rf(reaction)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Reaction)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Reaction) error); ok {
+		r1 = rf(reaction)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewReactionStore creates a new instance of ReactionStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewReactionStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ReactionStore {
+	mock := &ReactionStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ReadReceiptStore.go

@@ -0,0 +1,247 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ReadReceiptStore is an autogenerated mock type for the ReadReceiptStore type
+type ReadReceiptStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: rctx, postID, userID
+func (_m *ReadReceiptStore) Delete(rctx request.CTX, postID string, userID string) error {
+	ret := _m.Called(rctx, postID, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) error); ok {
+		r0 = rf(rctx, postID, userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteByPost provides a mock function with given fields: rctx, postID
+func (_m *ReadReceiptStore) DeleteByPost(rctx request.CTX, postID string) error {
+	ret := _m.Called(rctx, postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteByPost")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
+		r0 = rf(rctx, postID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: rctx, postID, userID
+func (_m *ReadReceiptStore) Get(rctx request.CTX, postID string, userID string) (*model.ReadReceipt, error) {
+	ret := _m.Called(rctx, postID, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.ReadReceipt
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) (*model.ReadReceipt, error)); ok {
+		return rf(rctx, postID, userID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) *model.ReadReceipt); ok {
+		r0 = rf(rctx, postID, userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ReadReceipt)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string) error); ok {
+		r1 = rf(rctx, postID, userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByPost provides a mock function with given fields: rctx, postID
+func (_m *ReadReceiptStore) GetByPost(rctx request.CTX, postID string) ([]*model.ReadReceipt, error) {
+	ret := _m.Called(rctx, postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByPost")
+	}
+
+	var r0 []*model.ReadReceipt
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) ([]*model.ReadReceipt, error)); ok {
+		return rf(rctx, postID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) []*model.ReadReceipt); ok {
+		r0 = rf(rctx, postID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ReadReceipt)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetReadCountForPost provides a mock function with given fields: rctx, postID
+func (_m *ReadReceiptStore) GetReadCountForPost(rctx request.CTX, postID string) (int64, error) {
+	ret := _m.Called(rctx, postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetReadCountForPost")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (int64, error)); ok {
+		return rf(rctx, postID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) int64); ok {
+		r0 = rf(rctx, postID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUnreadCountForPost provides a mock function with given fields: rctx, post
+func (_m *ReadReceiptStore) GetUnreadCountForPost(rctx request.CTX, post *model.Post) (int64, error) {
+	ret := _m.Called(rctx, post)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUnreadCountForPost")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.Post) (int64, error)); ok {
+		return rf(rctx, post)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.Post) int64); ok {
+		r0 = rf(rctx, post)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.Post) error); ok {
+		r1 = rf(rctx, post)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InvalidateReadReceiptForPostsCache provides a mock function with given fields: postID
+func (_m *ReadReceiptStore) InvalidateReadReceiptForPostsCache(postID string) {
+	_m.Called(postID)
+}
+
+// Save provides a mock function with given fields: rctx, receipt
+func (_m *ReadReceiptStore) Save(rctx request.CTX, receipt *model.ReadReceipt) (*model.ReadReceipt, error) {
+	ret := _m.Called(rctx, receipt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.ReadReceipt
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ReadReceipt) (*model.ReadReceipt, error)); ok {
+		return rf(rctx, receipt)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ReadReceipt) *model.ReadReceipt); ok {
+		r0 = rf(rctx, receipt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ReadReceipt)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.ReadReceipt) error); ok {
+		r1 = rf(rctx, receipt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: rctx, receipt
+func (_m *ReadReceiptStore) Update(rctx request.CTX, receipt *model.ReadReceipt) (*model.ReadReceipt, error) {
+	ret := _m.Called(rctx, receipt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 *model.ReadReceipt
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ReadReceipt) (*model.ReadReceipt, error)); ok {
+		return rf(rctx, receipt)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ReadReceipt) *model.ReadReceipt); ok {
+		r0 = rf(rctx, receipt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ReadReceipt)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.ReadReceipt) error); ok {
+		r1 = rf(rctx, receipt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewReadReceiptStore creates a new instance of ReadReceiptStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewReadReceiptStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ReadReceiptStore {
+	mock := &ReadReceiptStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ReadReceiptsStore.go

@@ -0,0 +1,108 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ReadReceiptsStore is an autogenerated mock type for the ReadReceiptsStore type
+type ReadReceiptsStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: rctx, postID, userID
+func (_m *ReadReceiptsStore) Delete(rctx request.CTX, postID string, userID string) error {
+	ret := _m.Called(rctx, postID, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) error); ok {
+		r0 = rf(rctx, postID, userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: rctx, postID, userID
+func (_m *ReadReceiptsStore) Get(rctx request.CTX, postID string, userID string) (*model.ReadReceipt, error) {
+	ret := _m.Called(rctx, postID, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.ReadReceipt
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) (*model.ReadReceipt, error)); ok {
+		return rf(rctx, postID, userID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) *model.ReadReceipt); ok {
+		r0 = rf(rctx, postID, userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ReadReceipt)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string) error); ok {
+		r1 = rf(rctx, postID, userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: rctx, receipt
+func (_m *ReadReceiptsStore) Save(rctx request.CTX, receipt *model.ReadReceipt) (*model.ReadReceipt, error) {
+	ret := _m.Called(rctx, receipt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.ReadReceipt
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ReadReceipt) (*model.ReadReceipt, error)); ok {
+		return rf(rctx, receipt)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ReadReceipt) *model.ReadReceipt); ok {
+		r0 = rf(rctx, receipt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ReadReceipt)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.ReadReceipt) error); ok {
+		r1 = rf(rctx, receipt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewReadReceiptsStore creates a new instance of ReadReceiptsStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewReadReceiptsStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ReadReceiptsStore {
+	mock := &ReadReceiptsStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/RecapStore.go

@@ -0,0 +1,433 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// RecapStore is an autogenerated mock type for the RecapStore type
+type RecapStore struct {
+	mock.Mock
+}
+
+// CountForUserSince provides a mock function with given fields: userId, since
+func (_m *RecapStore) CountForUserSince(userId string, since int64) (int64, error) {
+	ret := _m.Called(userId, since)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountForUserSince")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64) (int64, error)); ok {
+		return rf(userId, since)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64) int64); ok {
+		r0 = rf(userId, since)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64) error); ok {
+		r1 = rf(userId, since)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeleteRecap provides a mock function with given fields: id
+func (_m *RecapStore) DeleteRecap(id string) error {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteRecap")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteRecapChannels provides a mock function with given fields: recapId
+func (_m *RecapStore) DeleteRecapChannels(recapId string) error {
+	ret := _m.Called(recapId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteRecapChannels")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(recapId)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetLastCompletedManualRecap provides a mock function with given fields: userId
+func (_m *RecapStore) GetLastCompletedManualRecap(userId string) (*model.Recap, error) {
+	ret := _m.Called(userId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLastCompletedManualRecap")
+	}
+
+	var r0 *model.Recap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Recap, error)); ok {
+		return rf(userId)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Recap); ok {
+		r0 = rf(userId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Recap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRecap provides a mock function with given fields: id
+func (_m *RecapStore) GetRecap(id string) (*model.Recap, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRecap")
+	}
+
+	var r0 *model.Recap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Recap, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Recap); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Recap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRecapChannelsByRecapId provides a mock function with given fields: recapId
+func (_m *RecapStore) GetRecapChannelsByRecapId(recapId string) ([]*model.RecapChannel, error) {
+	ret := _m.Called(recapId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRecapChannelsByRecapId")
+	}
+
+	var r0 []*model.RecapChannel
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.RecapChannel, error)); ok {
+		return rf(recapId)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.RecapChannel); ok {
+		r0 = rf(recapId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.RecapChannel)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(recapId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRecapsForUser provides a mock function with given fields: userId, page, perPage
+func (_m *RecapStore) GetRecapsForUser(userId string, page int, perPage int) ([]*model.Recap, error) {
+	ret := _m.Called(userId, page, perPage)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRecapsForUser")
+	}
+
+	var r0 []*model.Recap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.Recap, error)); ok {
+		return rf(userId, page, perPage)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.Recap); ok {
+		r0 = rf(userId, page, perPage)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Recap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userId, page, perPage)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MarkRecapAsRead provides a mock function with given fields: id
+func (_m *RecapStore) MarkRecapAsRead(id string) error {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkRecapAsRead")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MarkRecapSkipped provides a mock function with given fields: id, reason
+func (_m *RecapStore) MarkRecapSkipped(id string, reason string) error {
+	ret := _m.Called(id, reason)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkRecapSkipped")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(id, reason)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MarkRecapsAsViewed provides a mock function with given fields: userId, statuses
+func (_m *RecapStore) MarkRecapsAsViewed(userId string, statuses []string) ([]string, error) {
+	ret := _m.Called(userId, statuses)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkRecapsAsViewed")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, []string) ([]string, error)); ok {
+		return rf(userId, statuses)
+	}
+	if rf, ok := ret.Get(0).(func(string, []string) []string); ok {
+		r0 = rf(userId, statuses)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, []string) error); ok {
+		r1 = rf(userId, statuses)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveRecap provides a mock function with given fields: recap
+func (_m *RecapStore) SaveRecap(recap *model.Recap) (*model.Recap, error) {
+	ret := _m.Called(recap)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveRecap")
+	}
+
+	var r0 *model.Recap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Recap) (*model.Recap, error)); ok {
+		return rf(recap)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Recap) *model.Recap); ok {
+		r0 = rf(recap)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Recap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Recap) error); ok {
+		r1 = rf(recap)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveRecapChannel provides a mock function with given fields: recapChannel
+func (_m *RecapStore) SaveRecapChannel(recapChannel *model.RecapChannel) error {
+	ret := _m.Called(recapChannel)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveRecapChannel")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.RecapChannel) error); ok {
+		r0 = rf(recapChannel)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SaveRecapIfUnderDailyLimit provides a mock function with given fields: recap, since, limit
+func (_m *RecapStore) SaveRecapIfUnderDailyLimit(recap *model.Recap, since int64, limit int) (*model.Recap, error) {
+	ret := _m.Called(recap, since, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveRecapIfUnderDailyLimit")
+	}
+
+	var r0 *model.Recap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Recap, int64, int) (*model.Recap, error)); ok {
+		return rf(recap, since, limit)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Recap, int64, int) *model.Recap); ok {
+		r0 = rf(recap, since, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Recap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Recap, int64, int) error); ok {
+		r1 = rf(recap, since, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SumTotalMessageCountForUserSince provides a mock function with given fields: userId, since
+func (_m *RecapStore) SumTotalMessageCountForUserSince(userId string, since int64) (int64, error) {
+	ret := _m.Called(userId, since)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SumTotalMessageCountForUserSince")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int64) (int64, error)); ok {
+		return rf(userId, since)
+	}
+	if rf, ok := ret.Get(0).(func(string, int64) int64); ok {
+		r0 = rf(userId, since)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int64) error); ok {
+		r1 = rf(userId, since)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateRecap provides a mock function with given fields: recap
+func (_m *RecapStore) UpdateRecap(recap *model.Recap) (*model.Recap, error) {
+	ret := _m.Called(recap)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateRecap")
+	}
+
+	var r0 *model.Recap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Recap) (*model.Recap, error)); ok {
+		return rf(recap)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Recap) *model.Recap); ok {
+		r0 = rf(recap)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Recap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Recap) error); ok {
+		r1 = rf(recap)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateRecapStatus provides a mock function with given fields: id, status
+func (_m *RecapStore) UpdateRecapStatus(id string, status string) error {
+	ret := _m.Called(id, status)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateRecapStatus")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(id, status)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewRecapStore creates a new instance of RecapStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewRecapStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *RecapStore {
+	mock := &RecapStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/RemoteClusterStore.go

@@ -0,0 +1,333 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// RemoteClusterStore is an autogenerated mock type for the RemoteClusterStore type
+type RemoteClusterStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: remoteClusterID
+func (_m *RemoteClusterStore) Delete(remoteClusterID string) (bool, error) {
+	ret := _m.Called(remoteClusterID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return rf(remoteClusterID)
+	}
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(remoteClusterID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(remoteClusterID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: remoteClusterID, includeDeleted
+func (_m *RemoteClusterStore) Get(remoteClusterID string, includeDeleted bool) (*model.RemoteCluster, error) {
+	ret := _m.Called(remoteClusterID, includeDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.RemoteCluster
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool) (*model.RemoteCluster, error)); ok {
+		return rf(remoteClusterID, includeDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool) *model.RemoteCluster); ok {
+		r0 = rf(remoteClusterID, includeDeleted)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RemoteCluster)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(remoteClusterID, includeDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with given fields: offset, limit, filter
+func (_m *RemoteClusterStore) GetAll(offset int, limit int, filter model.RemoteClusterQueryFilter) ([]*model.RemoteCluster, error) {
+	ret := _m.Called(offset, limit, filter)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 []*model.RemoteCluster
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int, model.RemoteClusterQueryFilter) ([]*model.RemoteCluster, error)); ok {
+		return rf(offset, limit, filter)
+	}
+	if rf, ok := ret.Get(0).(func(int, int, model.RemoteClusterQueryFilter) []*model.RemoteCluster); ok {
+		r0 = rf(offset, limit, filter)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.RemoteCluster)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int, model.RemoteClusterQueryFilter) error); ok {
+		r1 = rf(offset, limit, filter)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllByPluginID provides a mock function with given fields: pluginID
+func (_m *RemoteClusterStore) GetAllByPluginID(pluginID string) ([]*model.RemoteCluster, error) {
+	ret := _m.Called(pluginID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllByPluginID")
+	}
+
+	var r0 []*model.RemoteCluster
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.RemoteCluster, error)); ok {
+		return rf(pluginID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.RemoteCluster); ok {
+		r0 = rf(pluginID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.RemoteCluster)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(pluginID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByPluginID provides a mock function with given fields: pluginID
+func (_m *RemoteClusterStore) GetByPluginID(pluginID string) (*model.RemoteCluster, error) {
+	ret := _m.Called(pluginID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByPluginID")
+	}
+
+	var r0 *model.RemoteCluster
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.RemoteCluster, error)); ok {
+		return rf(pluginID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.RemoteCluster); ok {
+		r0 = rf(pluginID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RemoteCluster)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(pluginID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetBySiteURL provides a mock function with given fields: siteURL
+func (_m *RemoteClusterStore) GetBySiteURL(siteURL string) (*model.RemoteCluster, error) {
+	ret := _m.Called(siteURL)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetBySiteURL")
+	}
+
+	var r0 *model.RemoteCluster
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.RemoteCluster, error)); ok {
+		return rf(siteURL)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.RemoteCluster); ok {
+		r0 = rf(siteURL)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RemoteCluster)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(siteURL)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: rc
+func (_m *RemoteClusterStore) Save(rc *model.RemoteCluster) (*model.RemoteCluster, error) {
+	ret := _m.Called(rc)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.RemoteCluster
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.RemoteCluster) (*model.RemoteCluster, error)); ok {
+		return rf(rc)
+	}
+	if rf, ok := ret.Get(0).(func(*model.RemoteCluster) *model.RemoteCluster); ok {
+		r0 = rf(rc)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RemoteCluster)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.RemoteCluster) error); ok {
+		r1 = rf(rc)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SetLastPingAt provides a mock function with given fields: remoteClusterID
+func (_m *RemoteClusterStore) SetLastPingAt(remoteClusterID string) error {
+	ret := _m.Called(remoteClusterID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetLastPingAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(remoteClusterID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Update provides a mock function with given fields: rc
+func (_m *RemoteClusterStore) Update(rc *model.RemoteCluster) (*model.RemoteCluster, error) {
+	ret := _m.Called(rc)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 *model.RemoteCluster
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.RemoteCluster) (*model.RemoteCluster, error)); ok {
+		return rf(rc)
+	}
+	if rf, ok := ret.Get(0).(func(*model.RemoteCluster) *model.RemoteCluster); ok {
+		r0 = rf(rc)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RemoteCluster)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.RemoteCluster) error); ok {
+		r1 = rf(rc)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateLastGlobalUserSyncAt provides a mock function with given fields: remoteID, syncAt
+func (_m *RemoteClusterStore) UpdateLastGlobalUserSyncAt(remoteID string, syncAt int64) error {
+	ret := _m.Called(remoteID, syncAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateLastGlobalUserSyncAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(remoteID, syncAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateTopics provides a mock function with given fields: remoteClusterID, topics
+func (_m *RemoteClusterStore) UpdateTopics(remoteClusterID string, topics string) (*model.RemoteCluster, error) {
+	ret := _m.Called(remoteClusterID, topics)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateTopics")
+	}
+
+	var r0 *model.RemoteCluster
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.RemoteCluster, error)); ok {
+		return rf(remoteClusterID, topics)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.RemoteCluster); ok {
+		r0 = rf(remoteClusterID, topics)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RemoteCluster)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(remoteClusterID, topics)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewRemoteClusterStore creates a new instance of RemoteClusterStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewRemoteClusterStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *RemoteClusterStore {
+	mock := &RemoteClusterStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/RetentionPolicyStore.go

@@ -0,0 +1,557 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// RetentionPolicyStore is an autogenerated mock type for the RetentionPolicyStore type
+type RetentionPolicyStore struct {
+	mock.Mock
+}
+
+// AddChannels provides a mock function with given fields: policyID, channelIds
+func (_m *RetentionPolicyStore) AddChannels(policyID string, channelIds []string) error {
+	ret := _m.Called(policyID, channelIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddChannels")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []string) error); ok {
+		r0 = rf(policyID, channelIds)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// AddTeams provides a mock function with given fields: policyID, teamIds
+func (_m *RetentionPolicyStore) AddTeams(policyID string, teamIds []string) error {
+	ret := _m.Called(policyID, teamIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddTeams")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []string) error); ok {
+		r0 = rf(policyID, teamIds)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Delete provides a mock function with given fields: id
+func (_m *RetentionPolicyStore) Delete(id string) error {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteOrphanedRows provides a mock function with given fields: limit
+func (_m *RetentionPolicyStore) DeleteOrphanedRows(limit int) (int64, error) {
+	ret := _m.Called(limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteOrphanedRows")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int) (int64, error)); ok {
+		return rf(limit)
+	}
+	if rf, ok := ret.Get(0).(func(int) int64); ok {
+		r0 = rf(limit)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int) error); ok {
+		r1 = rf(limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: id
+func (_m *RetentionPolicyStore) Get(id string) (*model.RetentionPolicyWithTeamAndChannelCounts, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.RetentionPolicyWithTeamAndChannelCounts
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.RetentionPolicyWithTeamAndChannelCounts, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.RetentionPolicyWithTeamAndChannelCounts); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RetentionPolicyWithTeamAndChannelCounts)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with given fields: offset, limit
+func (_m *RetentionPolicyStore) GetAll(offset int, limit int) ([]*model.RetentionPolicyWithTeamAndChannelCounts, error) {
+	ret := _m.Called(offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 []*model.RetentionPolicyWithTeamAndChannelCounts
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int) ([]*model.RetentionPolicyWithTeamAndChannelCounts, error)); ok {
+		return rf(offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int, int) []*model.RetentionPolicyWithTeamAndChannelCounts); ok {
+		r0 = rf(offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.RetentionPolicyWithTeamAndChannelCounts)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
+		r1 = rf(offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChannelPoliciesCountForUser provides a mock function with given fields: userID
+func (_m *RetentionPolicyStore) GetChannelPoliciesCountForUser(userID string) (int64, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetChannelPoliciesCountForUser")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChannelPoliciesForUser provides a mock function with given fields: userID, offset, limit
+func (_m *RetentionPolicyStore) GetChannelPoliciesForUser(userID string, offset int, limit int) ([]*model.RetentionPolicyForChannel, error) {
+	ret := _m.Called(userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetChannelPoliciesForUser")
+	}
+
+	var r0 []*model.RetentionPolicyForChannel
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.RetentionPolicyForChannel, error)); ok {
+		return rf(userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.RetentionPolicyForChannel); ok {
+		r0 = rf(userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.RetentionPolicyForChannel)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChannels provides a mock function with given fields: policyID, offset, limit
+func (_m *RetentionPolicyStore) GetChannels(policyID string, offset int, limit int) (model.ChannelListWithTeamData, error) {
+	ret := _m.Called(policyID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetChannels")
+	}
+
+	var r0 model.ChannelListWithTeamData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) (model.ChannelListWithTeamData, error)); ok {
+		return rf(policyID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) model.ChannelListWithTeamData); ok {
+		r0 = rf(policyID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(model.ChannelListWithTeamData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(policyID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChannelsCount provides a mock function with given fields: policyID
+func (_m *RetentionPolicyStore) GetChannelsCount(policyID string) (int64, error) {
+	ret := _m.Called(policyID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetChannelsCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(policyID)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(policyID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(policyID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetCount provides a mock function with no fields
+func (_m *RetentionPolicyStore) GetCount() (int64, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetIdsForDeletionByTableName provides a mock function with given fields: tableName, limit
+func (_m *RetentionPolicyStore) GetIdsForDeletionByTableName(tableName string, limit int) ([]*model.RetentionIdsForDeletion, error) {
+	ret := _m.Called(tableName, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetIdsForDeletionByTableName")
+	}
+
+	var r0 []*model.RetentionIdsForDeletion
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int) ([]*model.RetentionIdsForDeletion, error)); ok {
+		return rf(tableName, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int) []*model.RetentionIdsForDeletion); ok {
+		r0 = rf(tableName, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.RetentionIdsForDeletion)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int) error); ok {
+		r1 = rf(tableName, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTeamPoliciesCountForUser provides a mock function with given fields: userID
+func (_m *RetentionPolicyStore) GetTeamPoliciesCountForUser(userID string) (int64, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTeamPoliciesCountForUser")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTeamPoliciesForUser provides a mock function with given fields: userID, offset, limit
+func (_m *RetentionPolicyStore) GetTeamPoliciesForUser(userID string, offset int, limit int) ([]*model.RetentionPolicyForTeam, error) {
+	ret := _m.Called(userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTeamPoliciesForUser")
+	}
+
+	var r0 []*model.RetentionPolicyForTeam
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.RetentionPolicyForTeam, error)); ok {
+		return rf(userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.RetentionPolicyForTeam); ok {
+		r0 = rf(userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.RetentionPolicyForTeam)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTeams provides a mock function with given fields: policyID, offset, limit
+func (_m *RetentionPolicyStore) GetTeams(policyID string, offset int, limit int) ([]*model.Team, error) {
+	ret := _m.Called(policyID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTeams")
+	}
+
+	var r0 []*model.Team
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.Team, error)); ok {
+		return rf(policyID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.Team); ok {
+		r0 = rf(policyID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Team)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(policyID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTeamsCount provides a mock function with given fields: policyID
+func (_m *RetentionPolicyStore) GetTeamsCount(policyID string) (int64, error) {
+	ret := _m.Called(policyID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTeamsCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(policyID)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(policyID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(policyID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Patch provides a mock function with given fields: patch
+func (_m *RetentionPolicyStore) Patch(patch *model.RetentionPolicyWithTeamAndChannelIDs) (*model.RetentionPolicyWithTeamAndChannelCounts, error) {
+	ret := _m.Called(patch)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Patch")
+	}
+
+	var r0 *model.RetentionPolicyWithTeamAndChannelCounts
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.RetentionPolicyWithTeamAndChannelIDs) (*model.RetentionPolicyWithTeamAndChannelCounts, error)); ok {
+		return rf(patch)
+	}
+	if rf, ok := ret.Get(0).(func(*model.RetentionPolicyWithTeamAndChannelIDs) *model.RetentionPolicyWithTeamAndChannelCounts); ok {
+		r0 = rf(patch)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RetentionPolicyWithTeamAndChannelCounts)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.RetentionPolicyWithTeamAndChannelIDs) error); ok {
+		r1 = rf(patch)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RemoveChannels provides a mock function with given fields: policyID, channelIds
+func (_m *RetentionPolicyStore) RemoveChannels(policyID string, channelIds []string) error {
+	ret := _m.Called(policyID, channelIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveChannels")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []string) error); ok {
+		r0 = rf(policyID, channelIds)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RemoveTeams provides a mock function with given fields: policyID, teamIds
+func (_m *RetentionPolicyStore) RemoveTeams(policyID string, teamIds []string) error {
+	ret := _m.Called(policyID, teamIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveTeams")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []string) error); ok {
+		r0 = rf(policyID, teamIds)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: policy
+func (_m *RetentionPolicyStore) Save(policy *model.RetentionPolicyWithTeamAndChannelIDs) (*model.RetentionPolicyWithTeamAndChannelCounts, error) {
+	ret := _m.Called(policy)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.RetentionPolicyWithTeamAndChannelCounts
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.RetentionPolicyWithTeamAndChannelIDs) (*model.RetentionPolicyWithTeamAndChannelCounts, error)); ok {
+		return rf(policy)
+	}
+	if rf, ok := ret.Get(0).(func(*model.RetentionPolicyWithTeamAndChannelIDs) *model.RetentionPolicyWithTeamAndChannelCounts); ok {
+		r0 = rf(policy)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RetentionPolicyWithTeamAndChannelCounts)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.RetentionPolicyWithTeamAndChannelIDs) error); ok {
+		r1 = rf(policy)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewRetentionPolicyStore creates a new instance of RetentionPolicyStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewRetentionPolicyStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *RetentionPolicyStore {
+	mock := &RetentionPolicyStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/RoleStore.go

@@ -0,0 +1,348 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// RoleStore is an autogenerated mock type for the RoleStore type
+type RoleStore struct {
+	mock.Mock
+}
+
+// AllChannelSchemeRoles provides a mock function with no fields
+func (_m *RoleStore) AllChannelSchemeRoles() ([]*model.Role, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for AllChannelSchemeRoles")
+	}
+
+	var r0 []*model.Role
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.Role, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.Role); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Role)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ChannelHigherScopedPermissions provides a mock function with given fields: roleNames
+func (_m *RoleStore) ChannelHigherScopedPermissions(roleNames []string) (map[string]*model.RolePermissions, error) {
+	ret := _m.Called(roleNames)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ChannelHigherScopedPermissions")
+	}
+
+	var r0 map[string]*model.RolePermissions
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string) (map[string]*model.RolePermissions, error)); ok {
+		return rf(roleNames)
+	}
+	if rf, ok := ret.Get(0).(func([]string) map[string]*model.RolePermissions); ok {
+		r0 = rf(roleNames)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]*model.RolePermissions)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]string) error); ok {
+		r1 = rf(roleNames)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ChannelRolesUnderTeamRole provides a mock function with given fields: roleName
+func (_m *RoleStore) ChannelRolesUnderTeamRole(roleName string) ([]*model.Role, error) {
+	ret := _m.Called(roleName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ChannelRolesUnderTeamRole")
+	}
+
+	var r0 []*model.Role
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.Role, error)); ok {
+		return rf(roleName)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.Role); ok {
+		r0 = rf(roleName)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Role)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(roleName)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: roleID
+func (_m *RoleStore) Delete(roleID string) (*model.Role, error) {
+	ret := _m.Called(roleID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 *model.Role
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Role, error)); ok {
+		return rf(roleID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Role); ok {
+		r0 = rf(roleID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Role)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(roleID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: roleID
+func (_m *RoleStore) Get(roleID string) (*model.Role, error) {
+	ret := _m.Called(roleID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Role
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Role, error)); ok {
+		return rf(roleID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Role); ok {
+		r0 = rf(roleID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Role)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(roleID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with no fields
+func (_m *RoleStore) GetAll() ([]*model.Role, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 []*model.Role
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.Role, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.Role); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Role)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByName provides a mock function with given fields: rctx, name
+func (_m *RoleStore) GetByName(rctx request.CTX, name string) (*model.Role, error) {
+	ret := _m.Called(rctx, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByName")
+	}
+
+	var r0 *model.Role
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.Role, error)); ok {
+		return rf(rctx, name)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.Role); ok {
+		r0 = rf(rctx, name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Role)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByNames provides a mock function with given fields: names
+func (_m *RoleStore) GetByNames(names []string) ([]*model.Role, error) {
+	ret := _m.Called(names)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByNames")
+	}
+
+	var r0 []*model.Role
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string) ([]*model.Role, error)); ok {
+		return rf(names)
+	}
+	if rf, ok := ret.Get(0).(func([]string) []*model.Role); ok {
+		r0 = rf(names)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Role)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]string) error); ok {
+		r1 = rf(names)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteAll provides a mock function with no fields
+func (_m *RoleStore) PermanentDeleteAll() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteAll")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: role
+func (_m *RoleStore) Save(role *model.Role) (*model.Role, error) {
+	ret := _m.Called(role)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.Role
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Role) (*model.Role, error)); ok {
+		return rf(role)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Role) *model.Role); ok {
+		r0 = rf(role)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Role)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Role) error); ok {
+		r1 = rf(role)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SavePreservingUnknownPermissions provides a mock function with given fields: role
+func (_m *RoleStore) SavePreservingUnknownPermissions(role *model.Role) (*model.Role, error) {
+	ret := _m.Called(role)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SavePreservingUnknownPermissions")
+	}
+
+	var r0 *model.Role
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Role) (*model.Role, error)); ok {
+		return rf(role)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Role) *model.Role); ok {
+		r0 = rf(role)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Role)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Role) error); ok {
+		r1 = rf(role)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewRoleStore creates a new instance of RoleStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewRoleStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *RoleStore {
+	mock := &RoleStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ScheduledPostStore.go

@@ -0,0 +1,258 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ScheduledPostStore is an autogenerated mock type for the ScheduledPostStore type
+type ScheduledPostStore struct {
+	mock.Mock
+}
+
+// CreateScheduledPost provides a mock function with given fields: rctx, scheduledPost
+func (_m *ScheduledPostStore) CreateScheduledPost(rctx request.CTX, scheduledPost *model.ScheduledPost) (*model.ScheduledPost, error) {
+	ret := _m.Called(rctx, scheduledPost)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateScheduledPost")
+	}
+
+	var r0 *model.ScheduledPost
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ScheduledPost) (*model.ScheduledPost, error)); ok {
+		return rf(rctx, scheduledPost)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ScheduledPost) *model.ScheduledPost); ok {
+		r0 = rf(rctx, scheduledPost)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ScheduledPost)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.ScheduledPost) error); ok {
+		r1 = rf(rctx, scheduledPost)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: rctx, scheduledPostId
+func (_m *ScheduledPostStore) Get(rctx request.CTX, scheduledPostId string) (*model.ScheduledPost, error) {
+	ret := _m.Called(rctx, scheduledPostId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.ScheduledPost
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.ScheduledPost, error)); ok {
+		return rf(rctx, scheduledPostId)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.ScheduledPost); ok {
+		r0 = rf(rctx, scheduledPostId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ScheduledPost)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, scheduledPostId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMaxMessageSize provides a mock function with no fields
+func (_m *ScheduledPostStore) GetMaxMessageSize() int {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetMaxMessageSize")
+	}
+
+	var r0 int
+	if rf, ok := ret.Get(0).(func() int); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+
+	return r0
+}
+
+// GetPendingScheduledPosts provides a mock function with given fields: rctx, beforeTime, afterTime, lastScheduledPostId, perPage
+func (_m *ScheduledPostStore) GetPendingScheduledPosts(rctx request.CTX, beforeTime int64, afterTime int64, lastScheduledPostId string, perPage uint64) ([]*model.ScheduledPost, error) {
+	ret := _m.Called(rctx, beforeTime, afterTime, lastScheduledPostId, perPage)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPendingScheduledPosts")
+	}
+
+	var r0 []*model.ScheduledPost
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, int64, int64, string, uint64) ([]*model.ScheduledPost, error)); ok {
+		return rf(rctx, beforeTime, afterTime, lastScheduledPostId, perPage)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, int64, int64, string, uint64) []*model.ScheduledPost); ok {
+		r0 = rf(rctx, beforeTime, afterTime, lastScheduledPostId, perPage)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ScheduledPost)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, int64, int64, string, uint64) error); ok {
+		r1 = rf(rctx, beforeTime, afterTime, lastScheduledPostId, perPage)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetScheduledPostsForUser provides a mock function with given fields: rctx, userId, teamId
+func (_m *ScheduledPostStore) GetScheduledPostsForUser(rctx request.CTX, userId string, teamId string) ([]*model.ScheduledPost, error) {
+	ret := _m.Called(rctx, userId, teamId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetScheduledPostsForUser")
+	}
+
+	var r0 []*model.ScheduledPost
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) ([]*model.ScheduledPost, error)); ok {
+		return rf(rctx, userId, teamId)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string) []*model.ScheduledPost); ok {
+		r0 = rf(rctx, userId, teamId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ScheduledPost)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string) error); ok {
+		r1 = rf(rctx, userId, teamId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteByUser provides a mock function with given fields: userId
+func (_m *ScheduledPostStore) PermanentDeleteByUser(userId string) error {
+	ret := _m.Called(userId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userId)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PermanentlyDeleteScheduledPosts provides a mock function with given fields: scheduledPostIDs
+func (_m *ScheduledPostStore) PermanentlyDeleteScheduledPosts(scheduledPostIDs []string) error {
+	ret := _m.Called(scheduledPostIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentlyDeleteScheduledPosts")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func([]string) error); ok {
+		r0 = rf(scheduledPostIDs)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateOldScheduledPosts provides a mock function with given fields: rctx, beforeTime
+func (_m *ScheduledPostStore) UpdateOldScheduledPosts(rctx request.CTX, beforeTime int64) error {
+	ret := _m.Called(rctx, beforeTime)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateOldScheduledPosts")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, int64) error); ok {
+		r0 = rf(rctx, beforeTime)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateRecurringScheduledPosts provides a mock function with given fields: rctx, scheduledPosts
+func (_m *ScheduledPostStore) UpdateRecurringScheduledPosts(rctx request.CTX, scheduledPosts []*model.ScheduledPost) error {
+	ret := _m.Called(rctx, scheduledPosts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateRecurringScheduledPosts")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, []*model.ScheduledPost) error); ok {
+		r0 = rf(rctx, scheduledPosts)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdatedScheduledPost provides a mock function with given fields: rctx, scheduledPost
+func (_m *ScheduledPostStore) UpdatedScheduledPost(rctx request.CTX, scheduledPost *model.ScheduledPost) error {
+	ret := _m.Called(rctx, scheduledPost)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdatedScheduledPost")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ScheduledPost) error); ok {
+		r0 = rf(rctx, scheduledPost)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewScheduledPostStore creates a new instance of ScheduledPostStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewScheduledPostStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ScheduledPostStore {
+	mock := &ScheduledPostStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ScheduledRecapStore.go

@@ -0,0 +1,309 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ScheduledRecapStore is an autogenerated mock type for the ScheduledRecapStore type
+type ScheduledRecapStore struct {
+	mock.Mock
+}
+
+// CountForUser provides a mock function with given fields: userId
+func (_m *ScheduledRecapStore) CountForUser(userId string) (int64, error) {
+	ret := _m.Called(userId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountForUser")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(userId)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(userId)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: id
+func (_m *ScheduledRecapStore) Delete(id string) error {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: id
+func (_m *ScheduledRecapStore) Get(id string) (*model.ScheduledRecap, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.ScheduledRecap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.ScheduledRecap, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.ScheduledRecap); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ScheduledRecap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetDueBefore provides a mock function with given fields: timestamp, limit
+func (_m *ScheduledRecapStore) GetDueBefore(timestamp int64, limit int) ([]*model.ScheduledRecap, error) {
+	ret := _m.Called(timestamp, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDueBefore")
+	}
+
+	var r0 []*model.ScheduledRecap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, int) ([]*model.ScheduledRecap, error)); ok {
+		return rf(timestamp, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int64, int) []*model.ScheduledRecap); ok {
+		r0 = rf(timestamp, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ScheduledRecap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, int) error); ok {
+		r1 = rf(timestamp, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForUser provides a mock function with given fields: userId, page, perPage
+func (_m *ScheduledRecapStore) GetForUser(userId string, page int, perPage int) ([]*model.ScheduledRecap, error) {
+	ret := _m.Called(userId, page, perPage)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForUser")
+	}
+
+	var r0 []*model.ScheduledRecap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.ScheduledRecap, error)); ok {
+		return rf(userId, page, perPage)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.ScheduledRecap); ok {
+		r0 = rf(userId, page, perPage)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ScheduledRecap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userId, page, perPage)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MarkExecuted provides a mock function with given fields: id, lastRunAt, nextRunAt
+func (_m *ScheduledRecapStore) MarkExecuted(id string, lastRunAt int64, nextRunAt int64) error {
+	ret := _m.Called(id, lastRunAt, nextRunAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkExecuted")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64, int64) error); ok {
+		r0 = rf(id, lastRunAt, nextRunAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: scheduledRecap
+func (_m *ScheduledRecapStore) Save(scheduledRecap *model.ScheduledRecap) (*model.ScheduledRecap, error) {
+	ret := _m.Called(scheduledRecap)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.ScheduledRecap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ScheduledRecap) (*model.ScheduledRecap, error)); ok {
+		return rf(scheduledRecap)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ScheduledRecap) *model.ScheduledRecap); ok {
+		r0 = rf(scheduledRecap)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ScheduledRecap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ScheduledRecap) error); ok {
+		r1 = rf(scheduledRecap)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveIfUnderLimit provides a mock function with given fields: scheduledRecap, limit
+func (_m *ScheduledRecapStore) SaveIfUnderLimit(scheduledRecap *model.ScheduledRecap, limit int) (*model.ScheduledRecap, error) {
+	ret := _m.Called(scheduledRecap, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveIfUnderLimit")
+	}
+
+	var r0 *model.ScheduledRecap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ScheduledRecap, int) (*model.ScheduledRecap, error)); ok {
+		return rf(scheduledRecap, limit)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ScheduledRecap, int) *model.ScheduledRecap); ok {
+		r0 = rf(scheduledRecap, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ScheduledRecap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ScheduledRecap, int) error); ok {
+		r1 = rf(scheduledRecap, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SetEnabled provides a mock function with given fields: id, enabled
+func (_m *ScheduledRecapStore) SetEnabled(id string, enabled bool) error {
+	ret := _m.Called(id, enabled)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetEnabled")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, bool) error); ok {
+		r0 = rf(id, enabled)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Update provides a mock function with given fields: scheduledRecap
+func (_m *ScheduledRecapStore) Update(scheduledRecap *model.ScheduledRecap) (*model.ScheduledRecap, error) {
+	ret := _m.Called(scheduledRecap)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 *model.ScheduledRecap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ScheduledRecap) (*model.ScheduledRecap, error)); ok {
+		return rf(scheduledRecap)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ScheduledRecap) *model.ScheduledRecap); ok {
+		r0 = rf(scheduledRecap)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ScheduledRecap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ScheduledRecap) error); ok {
+		r1 = rf(scheduledRecap)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateNextRunAt provides a mock function with given fields: id, nextRunAt
+func (_m *ScheduledRecapStore) UpdateNextRunAt(id string, nextRunAt int64) error {
+	ret := _m.Called(id, nextRunAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateNextRunAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(id, nextRunAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewScheduledRecapStore creates a new instance of ScheduledRecapStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewScheduledRecapStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ScheduledRecapStore {
+	mock := &ScheduledRecapStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/SchemeStore.go

@@ -0,0 +1,253 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// SchemeStore is an autogenerated mock type for the SchemeStore type
+type SchemeStore struct {
+	mock.Mock
+}
+
+// CountByScope provides a mock function with given fields: scope
+func (_m *SchemeStore) CountByScope(scope string) (int64, error) {
+	ret := _m.Called(scope)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountByScope")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(scope)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(scope)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(scope)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CountWithoutPermission provides a mock function with given fields: scope, permissionID, roleScope, roleType
+func (_m *SchemeStore) CountWithoutPermission(scope string, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, error) {
+	ret := _m.Called(scope, permissionID, roleScope, roleType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountWithoutPermission")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, model.RoleScope, model.RoleType) (int64, error)); ok {
+		return rf(scope, permissionID, roleScope, roleType)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, model.RoleScope, model.RoleType) int64); ok {
+		r0 = rf(scope, permissionID, roleScope, roleType)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, model.RoleScope, model.RoleType) error); ok {
+		r1 = rf(scope, permissionID, roleScope, roleType)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: schemeID
+func (_m *SchemeStore) Delete(schemeID string) (*model.Scheme, error) {
+	ret := _m.Called(schemeID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 *model.Scheme
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Scheme, error)); ok {
+		return rf(schemeID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Scheme); ok {
+		r0 = rf(schemeID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Scheme)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(schemeID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: schemeID
+func (_m *SchemeStore) Get(schemeID string) (*model.Scheme, error) {
+	ret := _m.Called(schemeID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Scheme
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Scheme, error)); ok {
+		return rf(schemeID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Scheme); ok {
+		r0 = rf(schemeID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Scheme)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(schemeID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllPage provides a mock function with given fields: scope, offset, limit
+func (_m *SchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, error) {
+	ret := _m.Called(scope, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllPage")
+	}
+
+	var r0 []*model.Scheme
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.Scheme, error)); ok {
+		return rf(scope, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.Scheme); ok {
+		r0 = rf(scope, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Scheme)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(scope, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByName provides a mock function with given fields: schemeName
+func (_m *SchemeStore) GetByName(schemeName string) (*model.Scheme, error) {
+	ret := _m.Called(schemeName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByName")
+	}
+
+	var r0 *model.Scheme
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Scheme, error)); ok {
+		return rf(schemeName)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Scheme); ok {
+		r0 = rf(schemeName)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Scheme)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(schemeName)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteAll provides a mock function with no fields
+func (_m *SchemeStore) PermanentDeleteAll() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteAll")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: scheme
+func (_m *SchemeStore) Save(scheme *model.Scheme) (*model.Scheme, error) {
+	ret := _m.Called(scheme)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.Scheme
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Scheme) (*model.Scheme, error)); ok {
+		return rf(scheme)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Scheme) *model.Scheme); ok {
+		r0 = rf(scheme)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Scheme)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Scheme) error); ok {
+		r1 = rf(scheme)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewSchemeStore creates a new instance of SchemeStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSchemeStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SchemeStore {
+	mock := &SchemeStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/SessionAttributeStore.go

@@ -0,0 +1,119 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import mock "github.com/stretchr/testify/mock"
+
+// SessionAttributeStore is an autogenerated mock type for the SessionAttributeStore type
+type SessionAttributeStore struct {
+	mock.Mock
+}
+
+// Clear provides a mock function with no fields
+func (_m *SessionAttributeStore) Clear() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Clear")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: sessionID
+func (_m *SessionAttributeStore) Get(sessionID string) (map[string]interface{}, map[string]int64, error) {
+	ret := _m.Called(sessionID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 map[string]interface{}
+	var r1 map[string]int64
+	var r2 error
+	if rf, ok := ret.Get(0).(func(string) (map[string]interface{}, map[string]int64, error)); ok {
+		return rf(sessionID)
+	}
+	if rf, ok := ret.Get(0).(func(string) map[string]interface{}); ok {
+		r0 = rf(sessionID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]interface{})
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) map[string]int64); ok {
+		r1 = rf(sessionID)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(map[string]int64)
+		}
+	}
+
+	if rf, ok := ret.Get(2).(func(string) error); ok {
+		r2 = rf(sessionID)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// Invalidate provides a mock function with given fields: sessionID
+func (_m *SessionAttributeStore) Invalidate(sessionID string) error {
+	ret := _m.Called(sessionID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Invalidate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(sessionID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Refresh provides a mock function with given fields: sessionID, attrs, updatedAt
+func (_m *SessionAttributeStore) Refresh(sessionID string, attrs map[string]interface{}, updatedAt int64) error {
+	ret := _m.Called(sessionID, attrs, updatedAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Refresh")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, map[string]interface{}, int64) error); ok {
+		r0 = rf(sessionID, attrs, updatedAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewSessionAttributeStore creates a new instance of SessionAttributeStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSessionAttributeStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SessionAttributeStore {
+	mock := &SessionAttributeStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/SessionStore.go

@@ -0,0 +1,488 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// SessionStore is an autogenerated mock type for the SessionStore type
+type SessionStore struct {
+	mock.Mock
+}
+
+// AnalyticsSessionCount provides a mock function with no fields
+func (_m *SessionStore) AnalyticsSessionCount() (int64, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for AnalyticsSessionCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Cleanup provides a mock function with given fields: expiryTime, batchSize
+func (_m *SessionStore) Cleanup(expiryTime int64, batchSize int64) error {
+	ret := _m.Called(expiryTime, batchSize)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Cleanup")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int64, int64) error); ok {
+		r0 = rf(expiryTime, batchSize)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: rctx, sessionIDOrToken
+func (_m *SessionStore) Get(rctx request.CTX, sessionIDOrToken string) (*model.Session, error) {
+	ret := _m.Called(rctx, sessionIDOrToken)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Session
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.Session, error)); ok {
+		return rf(rctx, sessionIDOrToken)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.Session); ok {
+		r0 = rf(rctx, sessionIDOrToken)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Session)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, sessionIDOrToken)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllSessionsWithActiveDeviceIds provides a mock function with no fields
+func (_m *SessionStore) GetAllSessionsWithActiveDeviceIds() ([]*model.Session, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllSessionsWithActiveDeviceIds")
+	}
+
+	var r0 []*model.Session
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.Session, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.Session); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Session)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetLRUSessions provides a mock function with given fields: rctx, userID, limit, offset
+func (_m *SessionStore) GetLRUSessions(rctx request.CTX, userID string, limit uint64, offset uint64) ([]*model.Session, error) {
+	ret := _m.Called(rctx, userID, limit, offset)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLRUSessions")
+	}
+
+	var r0 []*model.Session
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, uint64, uint64) ([]*model.Session, error)); ok {
+		return rf(rctx, userID, limit, offset)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, uint64, uint64) []*model.Session); ok {
+		r0 = rf(rctx, userID, limit, offset)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Session)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, uint64, uint64) error); ok {
+		r1 = rf(rctx, userID, limit, offset)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMobileSessionMetadata provides a mock function with no fields
+func (_m *SessionStore) GetMobileSessionMetadata() ([]*model.MobileSessionMetadata, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetMobileSessionMetadata")
+	}
+
+	var r0 []*model.MobileSessionMetadata
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.MobileSessionMetadata, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.MobileSessionMetadata); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.MobileSessionMetadata)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetSessions provides a mock function with given fields: rctx, userID
+func (_m *SessionStore) GetSessions(rctx request.CTX, userID string) ([]*model.Session, error) {
+	ret := _m.Called(rctx, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSessions")
+	}
+
+	var r0 []*model.Session
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) ([]*model.Session, error)); ok {
+		return rf(rctx, userID)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) []*model.Session); ok {
+		r0 = rf(rctx, userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Session)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetSessionsExpired provides a mock function with given fields: thresholdMillis, mobileOnly, unnotifiedOnly
+func (_m *SessionStore) GetSessionsExpired(thresholdMillis int64, mobileOnly bool, unnotifiedOnly bool) ([]*model.Session, error) {
+	ret := _m.Called(thresholdMillis, mobileOnly, unnotifiedOnly)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSessionsExpired")
+	}
+
+	var r0 []*model.Session
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, bool, bool) ([]*model.Session, error)); ok {
+		return rf(thresholdMillis, mobileOnly, unnotifiedOnly)
+	}
+	if rf, ok := ret.Get(0).(func(int64, bool, bool) []*model.Session); ok {
+		r0 = rf(thresholdMillis, mobileOnly, unnotifiedOnly)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Session)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, bool, bool) error); ok {
+		r1 = rf(thresholdMillis, mobileOnly, unnotifiedOnly)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetSessionsWithActiveDeviceIds provides a mock function with given fields: userID
+func (_m *SessionStore) GetSessionsWithActiveDeviceIds(userID string) ([]*model.Session, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSessionsWithActiveDeviceIds")
+	}
+
+	var r0 []*model.Session
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.Session, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.Session); ok {
+		r0 = rf(userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Session)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteSessionsByUser provides a mock function with given fields: teamID
+func (_m *SessionStore) PermanentDeleteSessionsByUser(teamID string) error {
+	ret := _m.Called(teamID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteSessionsByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(teamID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Remove provides a mock function with given fields: sessionIDOrToken
+func (_m *SessionStore) Remove(sessionIDOrToken string) error {
+	ret := _m.Called(sessionIDOrToken)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Remove")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(sessionIDOrToken)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RemoveAllSessions provides a mock function with no fields
+func (_m *SessionStore) RemoveAllSessions() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveAllSessions")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: rctx, session
+func (_m *SessionStore) Save(rctx request.CTX, session *model.Session) (*model.Session, error) {
+	ret := _m.Called(rctx, session)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.Session
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.Session) (*model.Session, error)); ok {
+		return rf(rctx, session)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.Session) *model.Session); ok {
+		r0 = rf(rctx, session)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Session)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.Session) error); ok {
+		r1 = rf(rctx, session)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateDeviceId provides a mock function with given fields: id, deviceId, voIPDeviceId, expiresAt
+func (_m *SessionStore) UpdateDeviceId(id string, deviceId string, voIPDeviceId string, expiresAt int64) error {
+	ret := _m.Called(id, deviceId, voIPDeviceId, expiresAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateDeviceId")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, string, int64) error); ok {
+		r0 = rf(id, deviceId, voIPDeviceId, expiresAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateExpiredNotify provides a mock function with given fields: sessionid, notified
+func (_m *SessionStore) UpdateExpiredNotify(sessionid string, notified bool) error {
+	ret := _m.Called(sessionid, notified)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateExpiredNotify")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, bool) error); ok {
+		r0 = rf(sessionid, notified)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateExpiresAt provides a mock function with given fields: sessionID, timestamp
+func (_m *SessionStore) UpdateExpiresAt(sessionID string, timestamp int64) error {
+	ret := _m.Called(sessionID, timestamp)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateExpiresAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(sessionID, timestamp)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateLastActivityAt provides a mock function with given fields: sessionID, timestamp
+func (_m *SessionStore) UpdateLastActivityAt(sessionID string, timestamp int64) error {
+	ret := _m.Called(sessionID, timestamp)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateLastActivityAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(sessionID, timestamp)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateProps provides a mock function with given fields: session
+func (_m *SessionStore) UpdateProps(session *model.Session) error {
+	ret := _m.Called(session)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateProps")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Session) error); ok {
+		r0 = rf(session)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateRoles provides a mock function with given fields: userID, roles
+func (_m *SessionStore) UpdateRoles(userID string, roles string) (string, error) {
+	ret := _m.Called(userID, roles)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateRoles")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (string, error)); ok {
+		return rf(userID, roles)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) string); ok {
+		r0 = rf(userID, roles)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(userID, roles)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewSessionStore creates a new instance of SessionStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSessionStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SessionStore {
+	mock := &SessionStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/SharedChannelStore.go

@@ -0,0 +1,779 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// SharedChannelStore is an autogenerated mock type for the SharedChannelStore type
+type SharedChannelStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: channelID
+func (_m *SharedChannelStore) Delete(channelID string) (bool, error) {
+	ret := _m.Called(channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return rf(channelID)
+	}
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(channelID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeleteRemote provides a mock function with given fields: remoteID
+func (_m *SharedChannelStore) DeleteRemote(remoteID string) (bool, error) {
+	ret := _m.Called(remoteID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteRemote")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return rf(remoteID)
+	}
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(remoteID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(remoteID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: channelID
+func (_m *SharedChannelStore) Get(channelID string) (*model.SharedChannel, error) {
+	ret := _m.Called(channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.SharedChannel
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.SharedChannel, error)); ok {
+		return rf(channelID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.SharedChannel); ok {
+		r0 = rf(channelID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannel)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with given fields: offset, limit, opts
+func (_m *SharedChannelStore) GetAll(offset int, limit int, opts model.SharedChannelFilterOpts) ([]*model.SharedChannel, error) {
+	ret := _m.Called(offset, limit, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 []*model.SharedChannel
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int, model.SharedChannelFilterOpts) ([]*model.SharedChannel, error)); ok {
+		return rf(offset, limit, opts)
+	}
+	if rf, ok := ret.Get(0).(func(int, int, model.SharedChannelFilterOpts) []*model.SharedChannel); ok {
+		r0 = rf(offset, limit, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.SharedChannel)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int, model.SharedChannelFilterOpts) error); ok {
+		r1 = rf(offset, limit, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAllCount provides a mock function with given fields: opts
+func (_m *SharedChannelStore) GetAllCount(opts model.SharedChannelFilterOpts) (int64, error) {
+	ret := _m.Called(opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(model.SharedChannelFilterOpts) (int64, error)); ok {
+		return rf(opts)
+	}
+	if rf, ok := ret.Get(0).(func(model.SharedChannelFilterOpts) int64); ok {
+		r0 = rf(opts)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(model.SharedChannelFilterOpts) error); ok {
+		r1 = rf(opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAttachment provides a mock function with given fields: fileID, remoteID
+func (_m *SharedChannelStore) GetAttachment(fileID string, remoteID string) (*model.SharedChannelAttachment, error) {
+	ret := _m.Called(fileID, remoteID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAttachment")
+	}
+
+	var r0 *model.SharedChannelAttachment
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.SharedChannelAttachment, error)); ok {
+		return rf(fileID, remoteID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.SharedChannelAttachment); ok {
+		r0 = rf(fileID, remoteID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannelAttachment)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(fileID, remoteID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRemote provides a mock function with given fields: id
+func (_m *SharedChannelStore) GetRemote(id string) (*model.SharedChannelRemote, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRemote")
+	}
+
+	var r0 *model.SharedChannelRemote
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.SharedChannelRemote, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.SharedChannelRemote); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannelRemote)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRemoteByIds provides a mock function with given fields: channelID, remoteID
+func (_m *SharedChannelStore) GetRemoteByIds(channelID string, remoteID string) (*model.SharedChannelRemote, error) {
+	ret := _m.Called(channelID, remoteID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRemoteByIds")
+	}
+
+	var r0 *model.SharedChannelRemote
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.SharedChannelRemote, error)); ok {
+		return rf(channelID, remoteID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.SharedChannelRemote); ok {
+		r0 = rf(channelID, remoteID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannelRemote)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(channelID, remoteID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRemoteForUser provides a mock function with given fields: remoteID, userID, includeDeleted
+func (_m *SharedChannelStore) GetRemoteForUser(remoteID string, userID string, includeDeleted bool) (*model.RemoteCluster, error) {
+	ret := _m.Called(remoteID, userID, includeDeleted)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRemoteForUser")
+	}
+
+	var r0 *model.RemoteCluster
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, bool) (*model.RemoteCluster, error)); ok {
+		return rf(remoteID, userID, includeDeleted)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, bool) *model.RemoteCluster); ok {
+		r0 = rf(remoteID, userID, includeDeleted)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.RemoteCluster)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, bool) error); ok {
+		r1 = rf(remoteID, userID, includeDeleted)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRemotes provides a mock function with given fields: offset, limit, opts
+func (_m *SharedChannelStore) GetRemotes(offset int, limit int, opts model.SharedChannelRemoteFilterOpts) ([]*model.SharedChannelRemote, error) {
+	ret := _m.Called(offset, limit, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRemotes")
+	}
+
+	var r0 []*model.SharedChannelRemote
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int, model.SharedChannelRemoteFilterOpts) ([]*model.SharedChannelRemote, error)); ok {
+		return rf(offset, limit, opts)
+	}
+	if rf, ok := ret.Get(0).(func(int, int, model.SharedChannelRemoteFilterOpts) []*model.SharedChannelRemote); ok {
+		r0 = rf(offset, limit, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.SharedChannelRemote)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int, model.SharedChannelRemoteFilterOpts) error); ok {
+		r1 = rf(offset, limit, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRemotesStatus provides a mock function with given fields: channelID
+func (_m *SharedChannelStore) GetRemotesStatus(channelID string) ([]*model.SharedChannelRemoteStatus, error) {
+	ret := _m.Called(channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRemotesStatus")
+	}
+
+	var r0 []*model.SharedChannelRemoteStatus
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.SharedChannelRemoteStatus, error)); ok {
+		return rf(channelID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.SharedChannelRemoteStatus); ok {
+		r0 = rf(channelID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.SharedChannelRemoteStatus)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetSingleUser provides a mock function with given fields: userID, channelID, remoteID
+func (_m *SharedChannelStore) GetSingleUser(userID string, channelID string, remoteID string) (*model.SharedChannelUser, error) {
+	ret := _m.Called(userID, channelID, remoteID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSingleUser")
+	}
+
+	var r0 *model.SharedChannelUser
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, string) (*model.SharedChannelUser, error)); ok {
+		return rf(userID, channelID, remoteID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, string) *model.SharedChannelUser); ok {
+		r0 = rf(userID, channelID, remoteID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannelUser)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
+		r1 = rf(userID, channelID, remoteID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUsersForSync provides a mock function with given fields: filter
+func (_m *SharedChannelStore) GetUsersForSync(filter model.GetUsersForSyncFilter) ([]*model.User, error) {
+	ret := _m.Called(filter)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUsersForSync")
+	}
+
+	var r0 []*model.User
+	var r1 error
+	if rf, ok := ret.Get(0).(func(model.GetUsersForSyncFilter) ([]*model.User, error)); ok {
+		return rf(filter)
+	}
+	if rf, ok := ret.Get(0).(func(model.GetUsersForSyncFilter) []*model.User); ok {
+		r0 = rf(filter)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.User)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(model.GetUsersForSyncFilter) error); ok {
+		r1 = rf(filter)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetUsersForUser provides a mock function with given fields: userID
+func (_m *SharedChannelStore) GetUsersForUser(userID string) ([]*model.SharedChannelUser, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUsersForUser")
+	}
+
+	var r0 []*model.SharedChannelUser
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.SharedChannelUser, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.SharedChannelUser); ok {
+		r0 = rf(userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.SharedChannelUser)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// HasChannel provides a mock function with given fields: channelID
+func (_m *SharedChannelStore) HasChannel(channelID string) (bool, error) {
+	ret := _m.Called(channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for HasChannel")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return rf(channelID)
+	}
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(channelID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// HasRemote provides a mock function with given fields: channelID, remoteID
+func (_m *SharedChannelStore) HasRemote(channelID string, remoteID string) (bool, error) {
+	ret := _m.Called(channelID, remoteID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for HasRemote")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (bool, error)); ok {
+		return rf(channelID, remoteID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) bool); ok {
+		r0 = rf(channelID, remoteID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(channelID, remoteID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: sc
+func (_m *SharedChannelStore) Save(sc *model.SharedChannel) (*model.SharedChannel, error) {
+	ret := _m.Called(sc)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.SharedChannel
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.SharedChannel) (*model.SharedChannel, error)); ok {
+		return rf(sc)
+	}
+	if rf, ok := ret.Get(0).(func(*model.SharedChannel) *model.SharedChannel); ok {
+		r0 = rf(sc)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannel)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.SharedChannel) error); ok {
+		r1 = rf(sc)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveAttachment provides a mock function with given fields: remote
+func (_m *SharedChannelStore) SaveAttachment(remote *model.SharedChannelAttachment) (*model.SharedChannelAttachment, error) {
+	ret := _m.Called(remote)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveAttachment")
+	}
+
+	var r0 *model.SharedChannelAttachment
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelAttachment) (*model.SharedChannelAttachment, error)); ok {
+		return rf(remote)
+	}
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelAttachment) *model.SharedChannelAttachment); ok {
+		r0 = rf(remote)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannelAttachment)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.SharedChannelAttachment) error); ok {
+		r1 = rf(remote)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveRemote provides a mock function with given fields: remote
+func (_m *SharedChannelStore) SaveRemote(remote *model.SharedChannelRemote) (*model.SharedChannelRemote, error) {
+	ret := _m.Called(remote)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveRemote")
+	}
+
+	var r0 *model.SharedChannelRemote
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelRemote) (*model.SharedChannelRemote, error)); ok {
+		return rf(remote)
+	}
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelRemote) *model.SharedChannelRemote); ok {
+		r0 = rf(remote)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannelRemote)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.SharedChannelRemote) error); ok {
+		r1 = rf(remote)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveUser provides a mock function with given fields: remote
+func (_m *SharedChannelStore) SaveUser(remote *model.SharedChannelUser) (*model.SharedChannelUser, error) {
+	ret := _m.Called(remote)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveUser")
+	}
+
+	var r0 *model.SharedChannelUser
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelUser) (*model.SharedChannelUser, error)); ok {
+		return rf(remote)
+	}
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelUser) *model.SharedChannelUser); ok {
+		r0 = rf(remote)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannelUser)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.SharedChannelUser) error); ok {
+		r1 = rf(remote)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: sc
+func (_m *SharedChannelStore) Update(sc *model.SharedChannel) (*model.SharedChannel, error) {
+	ret := _m.Called(sc)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 *model.SharedChannel
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.SharedChannel) (*model.SharedChannel, error)); ok {
+		return rf(sc)
+	}
+	if rf, ok := ret.Get(0).(func(*model.SharedChannel) *model.SharedChannel); ok {
+		r0 = rf(sc)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannel)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.SharedChannel) error); ok {
+		r1 = rf(sc)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateAttachmentLastSyncAt provides a mock function with given fields: id, syncTime
+func (_m *SharedChannelStore) UpdateAttachmentLastSyncAt(id string, syncTime int64) error {
+	ret := _m.Called(id, syncTime)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateAttachmentLastSyncAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(id, syncTime)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateRemote provides a mock function with given fields: remote
+func (_m *SharedChannelStore) UpdateRemote(remote *model.SharedChannelRemote) (*model.SharedChannelRemote, error) {
+	ret := _m.Called(remote)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateRemote")
+	}
+
+	var r0 *model.SharedChannelRemote
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelRemote) (*model.SharedChannelRemote, error)); ok {
+		return rf(remote)
+	}
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelRemote) *model.SharedChannelRemote); ok {
+		r0 = rf(remote)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.SharedChannelRemote)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.SharedChannelRemote) error); ok {
+		r1 = rf(remote)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateRemoteCursor provides a mock function with given fields: id, cursor
+func (_m *SharedChannelStore) UpdateRemoteCursor(id string, cursor model.GetPostsSinceForSyncCursor) error {
+	ret := _m.Called(id, cursor)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateRemoteCursor")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, model.GetPostsSinceForSyncCursor) error); ok {
+		r0 = rf(id, cursor)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateRemoteMembershipCursor provides a mock function with given fields: id, syncTime
+func (_m *SharedChannelStore) UpdateRemoteMembershipCursor(id string, syncTime int64) error {
+	ret := _m.Called(id, syncTime)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateRemoteMembershipCursor")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(id, syncTime)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateUserLastSyncAt provides a mock function with given fields: userID, channelID, remoteID
+func (_m *SharedChannelStore) UpdateUserLastSyncAt(userID string, channelID string, remoteID string) error {
+	ret := _m.Called(userID, channelID, remoteID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateUserLastSyncAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, string) error); ok {
+		r0 = rf(userID, channelID, remoteID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpsertAttachment provides a mock function with given fields: remote
+func (_m *SharedChannelStore) UpsertAttachment(remote *model.SharedChannelAttachment) (string, error) {
+	ret := _m.Called(remote)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpsertAttachment")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelAttachment) (string, error)); ok {
+		return rf(remote)
+	}
+	if rf, ok := ret.Get(0).(func(*model.SharedChannelAttachment) string); ok {
+		r0 = rf(remote)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.SharedChannelAttachment) error); ok {
+		r1 = rf(remote)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewSharedChannelStore creates a new instance of SharedChannelStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSharedChannelStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SharedChannelStore {
+	mock := &SharedChannelStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/StatusStore.go

@@ -0,0 +1,219 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// StatusStore is an autogenerated mock type for the StatusStore type
+type StatusStore struct {
+	mock.Mock
+}
+
+// Get provides a mock function with given fields: userID
+func (_m *StatusStore) Get(userID string) (*model.Status, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Status, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Status); ok {
+		r0 = rf(userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByIds provides a mock function with given fields: userIds
+func (_m *StatusStore) GetByIds(userIds []string) ([]*model.Status, error) {
+	ret := _m.Called(userIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByIds")
+	}
+
+	var r0 []*model.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string) ([]*model.Status, error)); ok {
+		return rf(userIds)
+	}
+	if rf, ok := ret.Get(0).(func([]string) []*model.Status); ok {
+		r0 = rf(userIds)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]string) error); ok {
+		r1 = rf(userIds)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTotalActiveUsersCount provides a mock function with no fields
+func (_m *StatusStore) GetTotalActiveUsersCount() (int64, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTotalActiveUsersCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ResetAll provides a mock function with no fields
+func (_m *StatusStore) ResetAll() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for ResetAll")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SaveOrUpdate provides a mock function with given fields: status
+func (_m *StatusStore) SaveOrUpdate(status *model.Status) error {
+	ret := _m.Called(status)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveOrUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Status) error); ok {
+		r0 = rf(status)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SaveOrUpdateMany provides a mock function with given fields: statuses
+func (_m *StatusStore) SaveOrUpdateMany(statuses map[string]*model.Status) error {
+	ret := _m.Called(statuses)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveOrUpdateMany")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(map[string]*model.Status) error); ok {
+		r0 = rf(statuses)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateExpiredDNDStatuses provides a mock function with no fields
+func (_m *StatusStore) UpdateExpiredDNDStatuses() ([]*model.Status, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateExpiredDNDStatuses")
+	}
+
+	var r0 []*model.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]*model.Status, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []*model.Status); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateLastActivityAt provides a mock function with given fields: userID, lastActivityAt
+func (_m *StatusStore) UpdateLastActivityAt(userID string, lastActivityAt int64) error {
+	ret := _m.Called(userID, lastActivityAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateLastActivityAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(userID, lastActivityAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewStatusStore creates a new instance of StatusStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewStatusStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *StatusStore {
+	mock := &StatusStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/SystemStore.go

@@ -0,0 +1,264 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// SystemStore is an autogenerated mock type for the SystemStore type
+type SystemStore struct {
+	mock.Mock
+}
+
+// Get provides a mock function with no fields
+func (_m *SystemStore) Get() (model.StringMap, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 model.StringMap
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (model.StringMap, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() model.StringMap); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(model.StringMap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByName provides a mock function with given fields: name
+func (_m *SystemStore) GetByName(name string) (*model.System, error) {
+	ret := _m.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByName")
+	}
+
+	var r0 *model.System
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.System, error)); ok {
+		return rf(name)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.System); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.System)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByNameWithContext provides a mock function with given fields: rctx, name
+func (_m *SystemStore) GetByNameWithContext(rctx request.CTX, name string) (*model.System, error) {
+	ret := _m.Called(rctx, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByNameWithContext")
+	}
+
+	var r0 *model.System
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.System, error)); ok {
+		return rf(rctx, name)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.System); ok {
+		r0 = rf(rctx, name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.System)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetWithContext provides a mock function with given fields: rctx
+func (_m *SystemStore) GetWithContext(rctx request.CTX) (model.StringMap, error) {
+	ret := _m.Called(rctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetWithContext")
+	}
+
+	var r0 model.StringMap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX) (model.StringMap, error)); ok {
+		return rf(rctx)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX) model.StringMap); ok {
+		r0 = rf(rctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(model.StringMap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX) error); ok {
+		r1 = rf(rctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InsertIfExists provides a mock function with given fields: system
+func (_m *SystemStore) InsertIfExists(system *model.System) (*model.System, error) {
+	ret := _m.Called(system)
+
+	if len(ret) == 0 {
+		panic("no return value specified for InsertIfExists")
+	}
+
+	var r0 *model.System
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.System) (*model.System, error)); ok {
+		return rf(system)
+	}
+	if rf, ok := ret.Get(0).(func(*model.System) *model.System); ok {
+		r0 = rf(system)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.System)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.System) error); ok {
+		r1 = rf(system)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PermanentDeleteByName provides a mock function with given fields: name
+func (_m *SystemStore) PermanentDeleteByName(name string) (*model.System, error) {
+	ret := _m.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteByName")
+	}
+
+	var r0 *model.System
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.System, error)); ok {
+		return rf(name)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.System); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.System)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: system
+func (_m *SystemStore) Save(system *model.System) error {
+	ret := _m.Called(system)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.System) error); ok {
+		r0 = rf(system)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SaveOrUpdate provides a mock function with given fields: system
+func (_m *SystemStore) SaveOrUpdate(system *model.System) error {
+	ret := _m.Called(system)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveOrUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.System) error); ok {
+		r0 = rf(system)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Update provides a mock function with given fields: system
+func (_m *SystemStore) Update(system *model.System) error {
+	ret := _m.Called(system)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.System) error); ok {
+		r0 = rf(system)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewSystemStore creates a new instance of SystemStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSystemStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SystemStore {
+	mock := &SystemStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/TemporaryPostStore.go

@@ -0,0 +1,143 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// TemporaryPostStore is an autogenerated mock type for the TemporaryPostStore type
+type TemporaryPostStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: rctx, id
+func (_m *TemporaryPostStore) Delete(rctx request.CTX, id string) error {
+	ret := _m.Called(rctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
+		r0 = rf(rctx, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: rctx, id, allowFromCache
+func (_m *TemporaryPostStore) Get(rctx request.CTX, id string, allowFromCache bool) (*model.TemporaryPost, error) {
+	ret := _m.Called(rctx, id, allowFromCache)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.TemporaryPost
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, bool) (*model.TemporaryPost, error)); ok {
+		return rf(rctx, id, allowFromCache)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, bool) *model.TemporaryPost); ok {
+		r0 = rf(rctx, id, allowFromCache)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.TemporaryPost)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, bool) error); ok {
+		r1 = rf(rctx, id, allowFromCache)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetExpiredPosts provides a mock function with given fields: rctx, lastPostId, limit
+func (_m *TemporaryPostStore) GetExpiredPosts(rctx request.CTX, lastPostId string, limit uint64) ([]string, error) {
+	ret := _m.Called(rctx, lastPostId, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetExpiredPosts")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, uint64) ([]string, error)); ok {
+		return rf(rctx, lastPostId, limit)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, uint64) []string); ok {
+		r0 = rf(rctx, lastPostId, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, uint64) error); ok {
+		r1 = rf(rctx, lastPostId, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InvalidateTemporaryPost provides a mock function with given fields: id
+func (_m *TemporaryPostStore) InvalidateTemporaryPost(id string) {
+	_m.Called(id)
+}
+
+// Save provides a mock function with given fields: rctx, post
+func (_m *TemporaryPostStore) Save(rctx request.CTX, post *model.TemporaryPost) (*model.TemporaryPost, error) {
+	ret := _m.Called(rctx, post)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.TemporaryPost
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.TemporaryPost) (*model.TemporaryPost, error)); ok {
+		return rf(rctx, post)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.TemporaryPost) *model.TemporaryPost); ok {
+		r0 = rf(rctx, post)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.TemporaryPost)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.TemporaryPost) error); ok {
+		r1 = rf(rctx, post)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewTemporaryPostStore creates a new instance of TemporaryPostStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewTemporaryPostStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *TemporaryPostStore {
+	mock := &TemporaryPostStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/TermsOfServiceStore.go

@@ -0,0 +1,119 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// TermsOfServiceStore is an autogenerated mock type for the TermsOfServiceStore type
+type TermsOfServiceStore struct {
+	mock.Mock
+}
+
+// Get provides a mock function with given fields: id, allowFromCache
+func (_m *TermsOfServiceStore) Get(id string, allowFromCache bool) (*model.TermsOfService, error) {
+	ret := _m.Called(id, allowFromCache)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.TermsOfService
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool) (*model.TermsOfService, error)); ok {
+		return rf(id, allowFromCache)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool) *model.TermsOfService); ok {
+		r0 = rf(id, allowFromCache)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.TermsOfService)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(id, allowFromCache)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetLatest provides a mock function with given fields: allowFromCache
+func (_m *TermsOfServiceStore) GetLatest(allowFromCache bool) (*model.TermsOfService, error) {
+	ret := _m.Called(allowFromCache)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLatest")
+	}
+
+	var r0 *model.TermsOfService
+	var r1 error
+	if rf, ok := ret.Get(0).(func(bool) (*model.TermsOfService, error)); ok {
+		return rf(allowFromCache)
+	}
+	if rf, ok := ret.Get(0).(func(bool) *model.TermsOfService); ok {
+		r0 = rf(allowFromCache)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.TermsOfService)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(bool) error); ok {
+		r1 = rf(allowFromCache)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: termsOfService
+func (_m *TermsOfServiceStore) Save(termsOfService *model.TermsOfService) (*model.TermsOfService, error) {
+	ret := _m.Called(termsOfService)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.TermsOfService
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.TermsOfService) (*model.TermsOfService, error)); ok {
+		return rf(termsOfService)
+	}
+	if rf, ok := ret.Get(0).(func(*model.TermsOfService) *model.TermsOfService); ok {
+		r0 = rf(termsOfService)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.TermsOfService)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.TermsOfService) error); ok {
+		r1 = rf(termsOfService)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewTermsOfServiceStore creates a new instance of TermsOfServiceStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewTermsOfServiceStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *TermsOfServiceStore {
+	mock := &TermsOfServiceStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ThreadStore.go

@@ -0,0 +1,755 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	store "github.com/mattermost/mattermost/server/v8/channels/store"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ThreadStore is an autogenerated mock type for the ThreadStore type
+type ThreadStore struct {
+	mock.Mock
+}
+
+// DeleteMembershipForUser provides a mock function with given fields: userID, postID
+func (_m *ThreadStore) DeleteMembershipForUser(userID string, postID string) error {
+	ret := _m.Called(userID, postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteMembershipForUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(userID, postID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteMembershipsForChannel provides a mock function with given fields: userID, channelID
+func (_m *ThreadStore) DeleteMembershipsForChannel(userID string, channelID string) error {
+	ret := _m.Called(userID, channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteMembershipsForChannel")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(userID, channelID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteOrphanedRows provides a mock function with given fields: limit
+func (_m *ThreadStore) DeleteOrphanedRows(limit int) (int64, error) {
+	ret := _m.Called(limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteOrphanedRows")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int) (int64, error)); ok {
+		return rf(limit)
+	}
+	if rf, ok := ret.Get(0).(func(int) int64); ok {
+		r0 = rf(limit)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int) error); ok {
+		r1 = rf(limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: id
+func (_m *ThreadStore) Get(id string) (*model.Thread, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.Thread
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Thread, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Thread); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Thread)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMembershipForUser provides a mock function with given fields: userID, postID
+func (_m *ThreadStore) GetMembershipForUser(userID string, postID string) (*model.ThreadMembership, error) {
+	ret := _m.Called(userID, postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetMembershipForUser")
+	}
+
+	var r0 *model.ThreadMembership
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.ThreadMembership, error)); ok {
+		return rf(userID, postID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.ThreadMembership); ok {
+		r0 = rf(userID, postID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ThreadMembership)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(userID, postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMembershipsForUser provides a mock function with given fields: userID, teamID
+func (_m *ThreadStore) GetMembershipsForUser(userID string, teamID string) ([]*model.ThreadMembership, error) {
+	ret := _m.Called(userID, teamID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetMembershipsForUser")
+	}
+
+	var r0 []*model.ThreadMembership
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) ([]*model.ThreadMembership, error)); ok {
+		return rf(userID, teamID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) []*model.ThreadMembership); ok {
+		r0 = rf(userID, teamID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ThreadMembership)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(userID, teamID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTeamsUnreadForUser provides a mock function with given fields: userID, teamIDs, includeUrgentMentionCount
+func (_m *ThreadStore) GetTeamsUnreadForUser(userID string, teamIDs []string, includeUrgentMentionCount bool) (map[string]*model.TeamUnread, error) {
+	ret := _m.Called(userID, teamIDs, includeUrgentMentionCount)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTeamsUnreadForUser")
+	}
+
+	var r0 map[string]*model.TeamUnread
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, []string, bool) (map[string]*model.TeamUnread, error)); ok {
+		return rf(userID, teamIDs, includeUrgentMentionCount)
+	}
+	if rf, ok := ret.Get(0).(func(string, []string, bool) map[string]*model.TeamUnread); ok {
+		r0 = rf(userID, teamIDs, includeUrgentMentionCount)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]*model.TeamUnread)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, []string, bool) error); ok {
+		r1 = rf(userID, teamIDs, includeUrgentMentionCount)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetThreadFollowers provides a mock function with given fields: threadID, fetchOnlyActive
+func (_m *ThreadStore) GetThreadFollowers(threadID string, fetchOnlyActive bool) ([]string, error) {
+	ret := _m.Called(threadID, fetchOnlyActive)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetThreadFollowers")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool) ([]string, error)); ok {
+		return rf(threadID, fetchOnlyActive)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool) []string); ok {
+		r0 = rf(threadID, fetchOnlyActive)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(threadID, fetchOnlyActive)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetThreadForUser provides a mock function with given fields: rctx, threadMembership, extended, postPriorityIsEnabled
+func (_m *ThreadStore) GetThreadForUser(rctx request.CTX, threadMembership *model.ThreadMembership, extended bool, postPriorityIsEnabled bool) (*model.ThreadResponse, error) {
+	ret := _m.Called(rctx, threadMembership, extended, postPriorityIsEnabled)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetThreadForUser")
+	}
+
+	var r0 *model.ThreadResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ThreadMembership, bool, bool) (*model.ThreadResponse, error)); ok {
+		return rf(rctx, threadMembership, extended, postPriorityIsEnabled)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, *model.ThreadMembership, bool, bool) *model.ThreadResponse); ok {
+		r0 = rf(rctx, threadMembership, extended, postPriorityIsEnabled)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ThreadResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, *model.ThreadMembership, bool, bool) error); ok {
+		r1 = rf(rctx, threadMembership, extended, postPriorityIsEnabled)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetThreadMembershipsForExport provides a mock function with given fields: postID
+func (_m *ThreadStore) GetThreadMembershipsForExport(postID string) ([]*model.ThreadMembershipForExport, error) {
+	ret := _m.Called(postID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetThreadMembershipsForExport")
+	}
+
+	var r0 []*model.ThreadMembershipForExport
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.ThreadMembershipForExport, error)); ok {
+		return rf(postID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.ThreadMembershipForExport); ok {
+		r0 = rf(postID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ThreadMembershipForExport)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetThreadUnreadReplyCount provides a mock function with given fields: threadMembership
+func (_m *ThreadStore) GetThreadUnreadReplyCount(threadMembership *model.ThreadMembership) (int64, error) {
+	ret := _m.Called(threadMembership)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetThreadUnreadReplyCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ThreadMembership) (int64, error)); ok {
+		return rf(threadMembership)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ThreadMembership) int64); ok {
+		r0 = rf(threadMembership)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ThreadMembership) error); ok {
+		r1 = rf(threadMembership)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetThreadsForUser provides a mock function with given fields: rctx, userID, teamID, opts
+func (_m *ThreadStore) GetThreadsForUser(rctx request.CTX, userID string, teamID string, opts model.GetUserThreadsOpts) ([]*model.ThreadResponse, error) {
+	ret := _m.Called(rctx, userID, teamID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetThreadsForUser")
+	}
+
+	var r0 []*model.ThreadResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, model.GetUserThreadsOpts) ([]*model.ThreadResponse, error)); ok {
+		return rf(rctx, userID, teamID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string, string, model.GetUserThreadsOpts) []*model.ThreadResponse); ok {
+		r0 = rf(rctx, userID, teamID, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ThreadResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string, string, model.GetUserThreadsOpts) error); ok {
+		r1 = rf(rctx, userID, teamID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTotalThreads provides a mock function with given fields: userID, teamID, opts
+func (_m *ThreadStore) GetTotalThreads(userID string, teamID string, opts model.GetUserThreadsOpts) (int64, error) {
+	ret := _m.Called(userID, teamID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTotalThreads")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, model.GetUserThreadsOpts) (int64, error)); ok {
+		return rf(userID, teamID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, model.GetUserThreadsOpts) int64); ok {
+		r0 = rf(userID, teamID, opts)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, model.GetUserThreadsOpts) error); ok {
+		r1 = rf(userID, teamID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTotalUnreadMentions provides a mock function with given fields: userID, teamID, opts
+func (_m *ThreadStore) GetTotalUnreadMentions(userID string, teamID string, opts model.GetUserThreadsOpts) (int64, error) {
+	ret := _m.Called(userID, teamID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTotalUnreadMentions")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, model.GetUserThreadsOpts) (int64, error)); ok {
+		return rf(userID, teamID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, model.GetUserThreadsOpts) int64); ok {
+		r0 = rf(userID, teamID, opts)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, model.GetUserThreadsOpts) error); ok {
+		r1 = rf(userID, teamID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTotalUnreadThreads provides a mock function with given fields: userID, teamID, opts
+func (_m *ThreadStore) GetTotalUnreadThreads(userID string, teamID string, opts model.GetUserThreadsOpts) (int64, error) {
+	ret := _m.Called(userID, teamID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTotalUnreadThreads")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, model.GetUserThreadsOpts) (int64, error)); ok {
+		return rf(userID, teamID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, model.GetUserThreadsOpts) int64); ok {
+		r0 = rf(userID, teamID, opts)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, model.GetUserThreadsOpts) error); ok {
+		r1 = rf(userID, teamID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTotalUnreadUrgentMentions provides a mock function with given fields: userID, teamID, opts
+func (_m *ThreadStore) GetTotalUnreadUrgentMentions(userID string, teamID string, opts model.GetUserThreadsOpts) (int64, error) {
+	ret := _m.Called(userID, teamID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTotalUnreadUrgentMentions")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, model.GetUserThreadsOpts) (int64, error)); ok {
+		return rf(userID, teamID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, model.GetUserThreadsOpts) int64); ok {
+		r0 = rf(userID, teamID, opts)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, model.GetUserThreadsOpts) error); ok {
+		r1 = rf(userID, teamID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MaintainMembership provides a mock function with given fields: userID, postID, opts
+func (_m *ThreadStore) MaintainMembership(userID string, postID string, opts store.ThreadMembershipOpts) (*model.ThreadMembership, error) {
+	ret := _m.Called(userID, postID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MaintainMembership")
+	}
+
+	var r0 *model.ThreadMembership
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, store.ThreadMembershipOpts) (*model.ThreadMembership, error)); ok {
+		return rf(userID, postID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, store.ThreadMembershipOpts) *model.ThreadMembership); ok {
+		r0 = rf(userID, postID, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ThreadMembership)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, store.ThreadMembershipOpts) error); ok {
+		r1 = rf(userID, postID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MaintainMultipleFromImport provides a mock function with given fields: memberships
+func (_m *ThreadStore) MaintainMultipleFromImport(memberships []*model.ThreadMembership) ([]*model.ThreadMembership, error) {
+	ret := _m.Called(memberships)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MaintainMultipleFromImport")
+	}
+
+	var r0 []*model.ThreadMembership
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]*model.ThreadMembership) ([]*model.ThreadMembership, error)); ok {
+		return rf(memberships)
+	}
+	if rf, ok := ret.Get(0).(func([]*model.ThreadMembership) []*model.ThreadMembership); ok {
+		r0 = rf(memberships)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ThreadMembership)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]*model.ThreadMembership) error); ok {
+		r1 = rf(memberships)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MarkAllAsRead provides a mock function with given fields: userID, threadIds
+func (_m *ThreadStore) MarkAllAsRead(userID string, threadIds []string) error {
+	ret := _m.Called(userID, threadIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkAllAsRead")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []string) error); ok {
+		r0 = rf(userID, threadIds)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MarkAllAsReadByChannels provides a mock function with given fields: userID, channelIDs
+func (_m *ThreadStore) MarkAllAsReadByChannels(userID string, channelIDs []string) error {
+	ret := _m.Called(userID, channelIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkAllAsReadByChannels")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []string) error); ok {
+		r0 = rf(userID, channelIDs)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MarkAllAsReadByTeam provides a mock function with given fields: userID, teamID
+func (_m *ThreadStore) MarkAllAsReadByTeam(userID string, teamID string) error {
+	ret := _m.Called(userID, teamID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkAllAsReadByTeam")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(userID, teamID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MarkAsRead provides a mock function with given fields: userID, threadID, timestamp
+func (_m *ThreadStore) MarkAsRead(userID string, threadID string, timestamp int64) error {
+	ret := _m.Called(userID, threadID, timestamp)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarkAsRead")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, int64) error); ok {
+		r0 = rf(userID, threadID, timestamp)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PermanentDeleteBatchForRetentionPolicies provides a mock function with given fields: retentionPolicyBatchConfigs, cursor
+func (_m *ThreadStore) PermanentDeleteBatchForRetentionPolicies(retentionPolicyBatchConfigs model.RetentionPolicyBatchConfigs, cursor model.RetentionPolicyCursor) (int64, model.RetentionPolicyCursor, error) {
+	ret := _m.Called(retentionPolicyBatchConfigs, cursor)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteBatchForRetentionPolicies")
+	}
+
+	var r0 int64
+	var r1 model.RetentionPolicyCursor
+	var r2 error
+	if rf, ok := ret.Get(0).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) (int64, model.RetentionPolicyCursor, error)); ok {
+		return rf(retentionPolicyBatchConfigs, cursor)
+	}
+	if rf, ok := ret.Get(0).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) int64); ok {
+		r0 = rf(retentionPolicyBatchConfigs, cursor)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) model.RetentionPolicyCursor); ok {
+		r1 = rf(retentionPolicyBatchConfigs, cursor)
+	} else {
+		r1 = ret.Get(1).(model.RetentionPolicyCursor)
+	}
+
+	if rf, ok := ret.Get(2).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) error); ok {
+		r2 = rf(retentionPolicyBatchConfigs, cursor)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// PermanentDeleteBatchThreadMembershipsForRetentionPolicies provides a mock function with given fields: retentionPolicyBatchConfigs, cursor
+func (_m *ThreadStore) PermanentDeleteBatchThreadMembershipsForRetentionPolicies(retentionPolicyBatchConfigs model.RetentionPolicyBatchConfigs, cursor model.RetentionPolicyCursor) (int64, model.RetentionPolicyCursor, error) {
+	ret := _m.Called(retentionPolicyBatchConfigs, cursor)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteBatchThreadMembershipsForRetentionPolicies")
+	}
+
+	var r0 int64
+	var r1 model.RetentionPolicyCursor
+	var r2 error
+	if rf, ok := ret.Get(0).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) (int64, model.RetentionPolicyCursor, error)); ok {
+		return rf(retentionPolicyBatchConfigs, cursor)
+	}
+	if rf, ok := ret.Get(0).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) int64); ok {
+		r0 = rf(retentionPolicyBatchConfigs, cursor)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) model.RetentionPolicyCursor); ok {
+		r1 = rf(retentionPolicyBatchConfigs, cursor)
+	} else {
+		r1 = ret.Get(1).(model.RetentionPolicyCursor)
+	}
+
+	if rf, ok := ret.Get(2).(func(model.RetentionPolicyBatchConfigs, model.RetentionPolicyCursor) error); ok {
+		r2 = rf(retentionPolicyBatchConfigs, cursor)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// SaveMultipleMemberships provides a mock function with given fields: memberships
+func (_m *ThreadStore) SaveMultipleMemberships(memberships []*model.ThreadMembership) ([]*model.ThreadMembership, error) {
+	ret := _m.Called(memberships)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveMultipleMemberships")
+	}
+
+	var r0 []*model.ThreadMembership
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]*model.ThreadMembership) ([]*model.ThreadMembership, error)); ok {
+		return rf(memberships)
+	}
+	if rf, ok := ret.Get(0).(func([]*model.ThreadMembership) []*model.ThreadMembership); ok {
+		r0 = rf(memberships)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.ThreadMembership)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]*model.ThreadMembership) error); ok {
+		r1 = rf(memberships)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateMembership provides a mock function with given fields: membership
+func (_m *ThreadStore) UpdateMembership(membership *model.ThreadMembership) (*model.ThreadMembership, error) {
+	ret := _m.Called(membership)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateMembership")
+	}
+
+	var r0 *model.ThreadMembership
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.ThreadMembership) (*model.ThreadMembership, error)); ok {
+		return rf(membership)
+	}
+	if rf, ok := ret.Get(0).(func(*model.ThreadMembership) *model.ThreadMembership); ok {
+		r0 = rf(membership)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ThreadMembership)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.ThreadMembership) error); ok {
+		r1 = rf(membership)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateTeamIdForChannelThreads provides a mock function with given fields: channelId, teamId
+func (_m *ThreadStore) UpdateTeamIdForChannelThreads(channelId string, teamId string) error {
+	ret := _m.Called(channelId, teamId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateTeamIdForChannelThreads")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(channelId, teamId)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewThreadStore creates a new instance of ThreadStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewThreadStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ThreadStore {
+	mock := &ThreadStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/TokenStore.go

@@ -0,0 +1,208 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// TokenStore is an autogenerated mock type for the TokenStore type
+type TokenStore struct {
+	mock.Mock
+}
+
+// Cleanup provides a mock function with given fields: expiryTime
+func (_m *TokenStore) Cleanup(expiryTime int64) {
+	_m.Called(expiryTime)
+}
+
+// ConsumeOnce provides a mock function with given fields: tokenType, tokenStr
+func (_m *TokenStore) ConsumeOnce(tokenType string, tokenStr string) (*model.Token, error) {
+	ret := _m.Called(tokenType, tokenStr)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConsumeOnce")
+	}
+
+	var r0 *model.Token
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.Token, error)); ok {
+		return rf(tokenType, tokenStr)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.Token); ok {
+		r0 = rf(tokenType, tokenStr)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Token)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(tokenType, tokenStr)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: token
+func (_m *TokenStore) Delete(token string) error {
+	ret := _m.Called(token)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(token)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetAllTokensByType provides a mock function with given fields: tokenType
+func (_m *TokenStore) GetAllTokensByType(tokenType string) ([]*model.Token, error) {
+	ret := _m.Called(tokenType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllTokensByType")
+	}
+
+	var r0 []*model.Token
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.Token, error)); ok {
+		return rf(tokenType)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.Token); ok {
+		r0 = rf(tokenType)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Token)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(tokenType)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByToken provides a mock function with given fields: token
+func (_m *TokenStore) GetByToken(token string) (*model.Token, error) {
+	ret := _m.Called(token)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByToken")
+	}
+
+	var r0 *model.Token
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.Token, error)); ok {
+		return rf(token)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.Token); ok {
+		r0 = rf(token)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Token)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(token)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetTokenByTypeAndEmail provides a mock function with given fields: tokenType, email
+func (_m *TokenStore) GetTokenByTypeAndEmail(tokenType string, email string) (*model.Token, error) {
+	ret := _m.Called(tokenType, email)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTokenByTypeAndEmail")
+	}
+
+	var r0 *model.Token
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*model.Token, error)); ok {
+		return rf(tokenType, email)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *model.Token); ok {
+		r0 = rf(tokenType, email)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Token)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(tokenType, email)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RemoveAllTokensByType provides a mock function with given fields: tokenType
+func (_m *TokenStore) RemoveAllTokensByType(tokenType string) error {
+	ret := _m.Called(tokenType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveAllTokensByType")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(tokenType)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Save provides a mock function with given fields: recovery
+func (_m *TokenStore) Save(recovery *model.Token) error {
+	ret := _m.Called(recovery)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Token) error); ok {
+		r0 = rf(recovery)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewTokenStore creates a new instance of TokenStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewTokenStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *TokenStore {
+	mock := &TokenStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/UploadSessionStore.go

@@ -0,0 +1,156 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	request "github.com/mattermost/mattermost/server/public/shared/request"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// UploadSessionStore is an autogenerated mock type for the UploadSessionStore type
+type UploadSessionStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: id
+func (_m *UploadSessionStore) Delete(id string) error {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: rctx, id
+func (_m *UploadSessionStore) Get(rctx request.CTX, id string) (*model.UploadSession, error) {
+	ret := _m.Called(rctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.UploadSession
+	var r1 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string) (*model.UploadSession, error)); ok {
+		return rf(rctx, id)
+	}
+	if rf, ok := ret.Get(0).(func(request.CTX, string) *model.UploadSession); ok {
+		r0 = rf(rctx, id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.UploadSession)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(request.CTX, string) error); ok {
+		r1 = rf(rctx, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForUser provides a mock function with given fields: userID
+func (_m *UploadSessionStore) GetForUser(userID string) ([]*model.UploadSession, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForUser")
+	}
+
+	var r0 []*model.UploadSession
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.UploadSession, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.UploadSession); ok {
+		r0 = rf(userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.UploadSession)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: session
+func (_m *UploadSessionStore) Save(session *model.UploadSession) (*model.UploadSession, error) {
+	ret := _m.Called(session)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.UploadSession
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.UploadSession) (*model.UploadSession, error)); ok {
+		return rf(session)
+	}
+	if rf, ok := ret.Get(0).(func(*model.UploadSession) *model.UploadSession); ok {
+		r0 = rf(session)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.UploadSession)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.UploadSession) error); ok {
+		r1 = rf(session)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: session
+func (_m *UploadSessionStore) Update(session *model.UploadSession) error {
+	ret := _m.Called(session)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.UploadSession) error); ok {
+		r0 = rf(session)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewUploadSessionStore creates a new instance of UploadSessionStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewUploadSessionStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *UploadSessionStore {
+	mock := &UploadSessionStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/UserAccessTokenStore.go

@@ -0,0 +1,463 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// UserAccessTokenStore is an autogenerated mock type for the UserAccessTokenStore type
+type UserAccessTokenStore struct {
+	mock.Mock
+}
+
+// CountNonCompliantExpiry provides a mock function with given fields: maxExpiresAt
+func (_m *UserAccessTokenStore) CountNonCompliantExpiry(maxExpiresAt int64) (int64, error) {
+	ret := _m.Called(maxExpiresAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountNonCompliantExpiry")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64) (int64, error)); ok {
+		return rf(maxExpiresAt)
+	}
+	if rf, ok := ret.Get(0).(func(int64) int64); ok {
+		r0 = rf(maxExpiresAt)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int64) error); ok {
+		r1 = rf(maxExpiresAt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: tokenID
+func (_m *UserAccessTokenStore) Delete(tokenID string) error {
+	ret := _m.Called(tokenID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(tokenID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteAllForUser provides a mock function with given fields: userID
+func (_m *UserAccessTokenStore) DeleteAllForUser(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteAllForUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteByIds provides a mock function with given fields: tokenIDs
+func (_m *UserAccessTokenStore) DeleteByIds(tokenIDs []string) (int64, error) {
+	ret := _m.Called(tokenIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteByIds")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string) (int64, error)); ok {
+		return rf(tokenIDs)
+	}
+	if rf, ok := ret.Get(0).(func([]string) int64); ok {
+		r0 = rf(tokenIDs)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func([]string) error); ok {
+		r1 = rf(tokenIDs)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeleteNonCompliantExpiry provides a mock function with given fields: maxExpiresAt, limit
+func (_m *UserAccessTokenStore) DeleteNonCompliantExpiry(maxExpiresAt int64, limit int) ([]string, error) {
+	ret := _m.Called(maxExpiresAt, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteNonCompliantExpiry")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, int) ([]string, error)); ok {
+		return rf(maxExpiresAt, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int64, int) []string); ok {
+		r0 = rf(maxExpiresAt, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, int) error); ok {
+		r1 = rf(maxExpiresAt, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Get provides a mock function with given fields: tokenID
+func (_m *UserAccessTokenStore) Get(tokenID string) (*model.UserAccessToken, error) {
+	ret := _m.Called(tokenID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.UserAccessToken
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.UserAccessToken, error)); ok {
+		return rf(tokenID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.UserAccessToken); ok {
+		r0 = rf(tokenID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.UserAccessToken)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(tokenID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetAll provides a mock function with given fields: offset, limit
+func (_m *UserAccessTokenStore) GetAll(offset int, limit int) ([]*model.UserAccessToken, error) {
+	ret := _m.Called(offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAll")
+	}
+
+	var r0 []*model.UserAccessToken
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int) ([]*model.UserAccessToken, error)); ok {
+		return rf(offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int, int) []*model.UserAccessToken); ok {
+		r0 = rf(offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.UserAccessToken)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
+		r1 = rf(offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByToken provides a mock function with given fields: tokenString
+func (_m *UserAccessTokenStore) GetByToken(tokenString string) (*model.UserAccessToken, error) {
+	ret := _m.Called(tokenString)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByToken")
+	}
+
+	var r0 *model.UserAccessToken
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.UserAccessToken, error)); ok {
+		return rf(tokenString)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.UserAccessToken); ok {
+		r0 = rf(tokenString)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.UserAccessToken)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(tokenString)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetByUser provides a mock function with given fields: userID, page, perPage
+func (_m *UserAccessTokenStore) GetByUser(userID string, page int, perPage int) ([]*model.UserAccessToken, error) {
+	ret := _m.Called(userID, page, perPage)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByUser")
+	}
+
+	var r0 []*model.UserAccessToken
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.UserAccessToken, error)); ok {
+		return rf(userID, page, perPage)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.UserAccessToken); ok {
+		r0 = rf(userID, page, perPage)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.UserAccessToken)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userID, page, perPage)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetExpiredBefore provides a mock function with given fields: cutoff, limit
+func (_m *UserAccessTokenStore) GetExpiredBefore(cutoff int64, limit int) ([]*model.UserAccessToken, error) {
+	ret := _m.Called(cutoff, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetExpiredBefore")
+	}
+
+	var r0 []*model.UserAccessToken
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, int) ([]*model.UserAccessToken, error)); ok {
+		return rf(cutoff, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int64, int) []*model.UserAccessToken); ok {
+		r0 = rf(cutoff, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.UserAccessToken)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, int) error); ok {
+		r1 = rf(cutoff, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetExpiringTokens provides a mock function with given fields: now, thresholds, limit
+func (_m *UserAccessTokenStore) GetExpiringTokens(now int64, thresholds []int, limit int) ([]*model.UserAccessToken, error) {
+	ret := _m.Called(now, thresholds, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetExpiringTokens")
+	}
+
+	var r0 []*model.UserAccessToken
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, []int, int) ([]*model.UserAccessToken, error)); ok {
+		return rf(now, thresholds, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int64, []int, int) []*model.UserAccessToken); ok {
+		r0 = rf(now, thresholds, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.UserAccessToken)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, []int, int) error); ok {
+		r1 = rf(now, thresholds, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: token
+func (_m *UserAccessTokenStore) Save(token *model.UserAccessToken) (*model.UserAccessToken, error) {
+	ret := _m.Called(token)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.UserAccessToken
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.UserAccessToken) (*model.UserAccessToken, error)); ok {
+		return rf(token)
+	}
+	if rf, ok := ret.Get(0).(func(*model.UserAccessToken) *model.UserAccessToken); ok {
+		r0 = rf(token)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.UserAccessToken)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.UserAccessToken) error); ok {
+		r1 = rf(token)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Search provides a mock function with given fields: term
+func (_m *UserAccessTokenStore) Search(term string) ([]*model.UserAccessToken, error) {
+	ret := _m.Called(term)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Search")
+	}
+
+	var r0 []*model.UserAccessToken
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.UserAccessToken, error)); ok {
+		return rf(term)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.UserAccessToken); ok {
+		r0 = rf(term)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.UserAccessToken)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(term)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateLastNotifiedAt provides a mock function with given fields: tokenID, notifiedAt
+func (_m *UserAccessTokenStore) UpdateLastNotifiedAt(tokenID string, notifiedAt int64) error {
+	ret := _m.Called(tokenID, notifiedAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateLastNotifiedAt")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(tokenID, notifiedAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateTokenDisable provides a mock function with given fields: tokenID
+func (_m *UserAccessTokenStore) UpdateTokenDisable(tokenID string) error {
+	ret := _m.Called(tokenID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateTokenDisable")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(tokenID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateTokenEnable provides a mock function with given fields: tokenID
+func (_m *UserAccessTokenStore) UpdateTokenEnable(tokenID string) error {
+	ret := _m.Called(tokenID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateTokenEnable")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(tokenID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateTokenRotate provides a mock function with given fields: tokenID, newToken, expiresAt
+func (_m *UserAccessTokenStore) UpdateTokenRotate(tokenID string, newToken string, expiresAt int64) error {
+	ret := _m.Called(tokenID, newToken, expiresAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateTokenRotate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, int64) error); ok {
+		r0 = rf(tokenID, newToken, expiresAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewUserAccessTokenStore creates a new instance of UserAccessTokenStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewUserAccessTokenStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *UserAccessTokenStore {
+	mock := &UserAccessTokenStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/UserTermsOfServiceStore.go

@@ -0,0 +1,107 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// UserTermsOfServiceStore is an autogenerated mock type for the UserTermsOfServiceStore type
+type UserTermsOfServiceStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: userID, termsOfServiceID
+func (_m *UserTermsOfServiceStore) Delete(userID string, termsOfServiceID string) error {
+	ret := _m.Called(userID, termsOfServiceID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(userID, termsOfServiceID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetByUser provides a mock function with given fields: userID
+func (_m *UserTermsOfServiceStore) GetByUser(userID string) (*model.UserTermsOfService, error) {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetByUser")
+	}
+
+	var r0 *model.UserTermsOfService
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.UserTermsOfService, error)); ok {
+		return rf(userID)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.UserTermsOfService); ok {
+		r0 = rf(userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.UserTermsOfService)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: userTermsOfService
+func (_m *UserTermsOfServiceStore) Save(userTermsOfService *model.UserTermsOfService) (*model.UserTermsOfService, error) {
+	ret := _m.Called(userTermsOfService)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.UserTermsOfService
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.UserTermsOfService) (*model.UserTermsOfService, error)); ok {
+		return rf(userTermsOfService)
+	}
+	if rf, ok := ret.Get(0).(func(*model.UserTermsOfService) *model.UserTermsOfService); ok {
+		r0 = rf(userTermsOfService)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.UserTermsOfService)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.UserTermsOfService) error); ok {
+		r1 = rf(userTermsOfService)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewUserTermsOfServiceStore creates a new instance of UserTermsOfServiceStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewUserTermsOfServiceStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *UserTermsOfServiceStore {
+	mock := &UserTermsOfServiceStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/ViewStore.go

@@ -0,0 +1,225 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// ViewStore is an autogenerated mock type for the ViewStore type
+type ViewStore struct {
+	mock.Mock
+}
+
+// CountForChannel provides a mock function with given fields: channelID, opts
+func (_m *ViewStore) CountForChannel(channelID string, opts model.ViewQueryOpts) (int64, error) {
+	ret := _m.Called(channelID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CountForChannel")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, model.ViewQueryOpts) (int64, error)); ok {
+		return rf(channelID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, model.ViewQueryOpts) int64); ok {
+		r0 = rf(channelID, opts)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, model.ViewQueryOpts) error); ok {
+		r1 = rf(channelID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Delete provides a mock function with given fields: viewID, deleteAt
+func (_m *ViewStore) Delete(viewID string, deleteAt int64) error {
+	ret := _m.Called(viewID, deleteAt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(viewID, deleteAt)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: id
+func (_m *ViewStore) Get(id string) (*model.View, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Get")
+	}
+
+	var r0 *model.View
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.View, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.View); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.View)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForChannel provides a mock function with given fields: channelID, opts
+func (_m *ViewStore) GetForChannel(channelID string, opts model.ViewQueryOpts) ([]*model.View, error) {
+	ret := _m.Called(channelID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetForChannel")
+	}
+
+	var r0 []*model.View
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, model.ViewQueryOpts) ([]*model.View, error)); ok {
+		return rf(channelID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, model.ViewQueryOpts) []*model.View); ok {
+		r0 = rf(channelID, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.View)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, model.ViewQueryOpts) error); ok {
+		r1 = rf(channelID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: view
+func (_m *ViewStore) Save(view *model.View) (*model.View, error) {
+	ret := _m.Called(view)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 *model.View
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.View) (*model.View, error)); ok {
+		return rf(view)
+	}
+	if rf, ok := ret.Get(0).(func(*model.View) *model.View); ok {
+		r0 = rf(view)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.View)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.View) error); ok {
+		r1 = rf(view)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: view
+func (_m *ViewStore) Update(view *model.View) (*model.View, error) {
+	ret := _m.Called(view)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 *model.View
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.View) (*model.View, error)); ok {
+		return rf(view)
+	}
+	if rf, ok := ret.Get(0).(func(*model.View) *model.View); ok {
+		r0 = rf(view)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.View)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.View) error); ok {
+		r1 = rf(view)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateSortOrder provides a mock function with given fields: viewID, channelID, newIndex
+func (_m *ViewStore) UpdateSortOrder(viewID string, channelID string, newIndex int64) ([]*model.View, error) {
+	ret := _m.Called(viewID, channelID, newIndex)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateSortOrder")
+	}
+
+	var r0 []*model.View
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, int64) ([]*model.View, error)); ok {
+		return rf(viewID, channelID, newIndex)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, int64) []*model.View); ok {
+		r0 = rf(viewID, channelID, newIndex)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.View)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, int64) error); ok {
+		r1 = rf(viewID, channelID, newIndex)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewViewStore creates a new instance of ViewStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewViewStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ViewStore {
+	mock := &ViewStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/mocks/WebhookStore.go

@@ -0,0 +1,731 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// WebhookStore is an autogenerated mock type for the WebhookStore type
+type WebhookStore struct {
+	mock.Mock
+}
+
+// AnalyticsIncomingCount provides a mock function with given fields: teamID, userID
+func (_m *WebhookStore) AnalyticsIncomingCount(teamID string, userID string) (int64, error) {
+	ret := _m.Called(teamID, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AnalyticsIncomingCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (int64, error)); ok {
+		return rf(teamID, userID)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) int64); ok {
+		r0 = rf(teamID, userID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(teamID, userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// AnalyticsOutgoingCount provides a mock function with given fields: teamID
+func (_m *WebhookStore) AnalyticsOutgoingCount(teamID string) (int64, error) {
+	ret := _m.Called(teamID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AnalyticsOutgoingCount")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return rf(teamID)
+	}
+	if rf, ok := ret.Get(0).(func(string) int64); ok {
+		r0 = rf(teamID)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(teamID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ClearCaches provides a mock function with no fields
+func (_m *WebhookStore) ClearCaches() {
+	_m.Called()
+}
+
+// DeleteIncoming provides a mock function with given fields: webhookID, timestamp
+func (_m *WebhookStore) DeleteIncoming(webhookID string, timestamp int64) error {
+	ret := _m.Called(webhookID, timestamp)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteIncoming")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(webhookID, timestamp)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteOutgoing provides a mock function with given fields: webhookID, timestamp
+func (_m *WebhookStore) DeleteOutgoing(webhookID string, timestamp int64) error {
+	ret := _m.Called(webhookID, timestamp)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteOutgoing")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(webhookID, timestamp)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetIncoming provides a mock function with given fields: id, allowFromCache
+func (_m *WebhookStore) GetIncoming(id string, allowFromCache bool) (*model.IncomingWebhook, error) {
+	ret := _m.Called(id, allowFromCache)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetIncoming")
+	}
+
+	var r0 *model.IncomingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, bool) (*model.IncomingWebhook, error)); ok {
+		return rf(id, allowFromCache)
+	}
+	if rf, ok := ret.Get(0).(func(string, bool) *model.IncomingWebhook); ok {
+		r0 = rf(id, allowFromCache)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.IncomingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(id, allowFromCache)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetIncomingByChannel provides a mock function with given fields: channelID
+func (_m *WebhookStore) GetIncomingByChannel(channelID string) ([]*model.IncomingWebhook, error) {
+	ret := _m.Called(channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetIncomingByChannel")
+	}
+
+	var r0 []*model.IncomingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*model.IncomingWebhook, error)); ok {
+		return rf(channelID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*model.IncomingWebhook); ok {
+		r0 = rf(channelID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.IncomingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(channelID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetIncomingByTeam provides a mock function with given fields: teamID, offset, limit
+func (_m *WebhookStore) GetIncomingByTeam(teamID string, offset int, limit int) ([]*model.IncomingWebhook, error) {
+	ret := _m.Called(teamID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetIncomingByTeam")
+	}
+
+	var r0 []*model.IncomingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.IncomingWebhook, error)); ok {
+		return rf(teamID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.IncomingWebhook); ok {
+		r0 = rf(teamID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.IncomingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(teamID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetIncomingByTeamByUser provides a mock function with given fields: teamID, userID, offset, limit
+func (_m *WebhookStore) GetIncomingByTeamByUser(teamID string, userID string, offset int, limit int) ([]*model.IncomingWebhook, error) {
+	ret := _m.Called(teamID, userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetIncomingByTeamByUser")
+	}
+
+	var r0 []*model.IncomingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, int, int) ([]*model.IncomingWebhook, error)); ok {
+		return rf(teamID, userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, int, int) []*model.IncomingWebhook); ok {
+		r0 = rf(teamID, userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.IncomingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, int, int) error); ok {
+		r1 = rf(teamID, userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetIncomingList provides a mock function with given fields: offset, limit
+func (_m *WebhookStore) GetIncomingList(offset int, limit int) ([]*model.IncomingWebhook, error) {
+	ret := _m.Called(offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetIncomingList")
+	}
+
+	var r0 []*model.IncomingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int) ([]*model.IncomingWebhook, error)); ok {
+		return rf(offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int, int) []*model.IncomingWebhook); ok {
+		r0 = rf(offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.IncomingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
+		r1 = rf(offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetIncomingListByUser provides a mock function with given fields: userID, offset, limit
+func (_m *WebhookStore) GetIncomingListByUser(userID string, offset int, limit int) ([]*model.IncomingWebhook, error) {
+	ret := _m.Called(userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetIncomingListByUser")
+	}
+
+	var r0 []*model.IncomingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.IncomingWebhook, error)); ok {
+		return rf(userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.IncomingWebhook); ok {
+		r0 = rf(userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.IncomingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetOutgoing provides a mock function with given fields: id
+func (_m *WebhookStore) GetOutgoing(id string) (*model.OutgoingWebhook, error) {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOutgoing")
+	}
+
+	var r0 *model.OutgoingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*model.OutgoingWebhook, error)); ok {
+		return rf(id)
+	}
+	if rf, ok := ret.Get(0).(func(string) *model.OutgoingWebhook); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.OutgoingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetOutgoingByChannel provides a mock function with given fields: channelID, offset, limit
+func (_m *WebhookStore) GetOutgoingByChannel(channelID string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
+	ret := _m.Called(channelID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOutgoingByChannel")
+	}
+
+	var r0 []*model.OutgoingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.OutgoingWebhook, error)); ok {
+		return rf(channelID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.OutgoingWebhook); ok {
+		r0 = rf(channelID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OutgoingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(channelID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetOutgoingByChannelByUser provides a mock function with given fields: channelID, userID, offset, limit
+func (_m *WebhookStore) GetOutgoingByChannelByUser(channelID string, userID string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
+	ret := _m.Called(channelID, userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOutgoingByChannelByUser")
+	}
+
+	var r0 []*model.OutgoingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, int, int) ([]*model.OutgoingWebhook, error)); ok {
+		return rf(channelID, userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, int, int) []*model.OutgoingWebhook); ok {
+		r0 = rf(channelID, userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OutgoingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, int, int) error); ok {
+		r1 = rf(channelID, userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetOutgoingByTeam provides a mock function with given fields: teamID, offset, limit
+func (_m *WebhookStore) GetOutgoingByTeam(teamID string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
+	ret := _m.Called(teamID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOutgoingByTeam")
+	}
+
+	var r0 []*model.OutgoingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.OutgoingWebhook, error)); ok {
+		return rf(teamID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.OutgoingWebhook); ok {
+		r0 = rf(teamID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OutgoingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(teamID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetOutgoingByTeamByUser provides a mock function with given fields: teamID, userID, offset, limit
+func (_m *WebhookStore) GetOutgoingByTeamByUser(teamID string, userID string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
+	ret := _m.Called(teamID, userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOutgoingByTeamByUser")
+	}
+
+	var r0 []*model.OutgoingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, int, int) ([]*model.OutgoingWebhook, error)); ok {
+		return rf(teamID, userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, int, int) []*model.OutgoingWebhook); ok {
+		r0 = rf(teamID, userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OutgoingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, int, int) error); ok {
+		r1 = rf(teamID, userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetOutgoingList provides a mock function with given fields: offset, limit
+func (_m *WebhookStore) GetOutgoingList(offset int, limit int) ([]*model.OutgoingWebhook, error) {
+	ret := _m.Called(offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOutgoingList")
+	}
+
+	var r0 []*model.OutgoingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int) ([]*model.OutgoingWebhook, error)); ok {
+		return rf(offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(int, int) []*model.OutgoingWebhook); ok {
+		r0 = rf(offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OutgoingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
+		r1 = rf(offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetOutgoingListByUser provides a mock function with given fields: userID, offset, limit
+func (_m *WebhookStore) GetOutgoingListByUser(userID string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
+	ret := _m.Called(userID, offset, limit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOutgoingListByUser")
+	}
+
+	var r0 []*model.OutgoingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, int, int) ([]*model.OutgoingWebhook, error)); ok {
+		return rf(userID, offset, limit)
+	}
+	if rf, ok := ret.Get(0).(func(string, int, int) []*model.OutgoingWebhook); ok {
+		r0 = rf(userID, offset, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.OutgoingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
+		r1 = rf(userID, offset, limit)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InvalidateWebhookCache provides a mock function with given fields: webhook
+func (_m *WebhookStore) InvalidateWebhookCache(webhook string) {
+	_m.Called(webhook)
+}
+
+// PermanentDeleteIncomingByChannel provides a mock function with given fields: channelID
+func (_m *WebhookStore) PermanentDeleteIncomingByChannel(channelID string) error {
+	ret := _m.Called(channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteIncomingByChannel")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(channelID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PermanentDeleteIncomingByUser provides a mock function with given fields: userID
+func (_m *WebhookStore) PermanentDeleteIncomingByUser(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteIncomingByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PermanentDeleteOutgoingByChannel provides a mock function with given fields: channelID
+func (_m *WebhookStore) PermanentDeleteOutgoingByChannel(channelID string) error {
+	ret := _m.Called(channelID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteOutgoingByChannel")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(channelID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// PermanentDeleteOutgoingByUser provides a mock function with given fields: userID
+func (_m *WebhookStore) PermanentDeleteOutgoingByUser(userID string) error {
+	ret := _m.Called(userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PermanentDeleteOutgoingByUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(userID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SaveIncoming provides a mock function with given fields: webhook
+func (_m *WebhookStore) SaveIncoming(webhook *model.IncomingWebhook) (*model.IncomingWebhook, error) {
+	ret := _m.Called(webhook)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveIncoming")
+	}
+
+	var r0 *model.IncomingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.IncomingWebhook) (*model.IncomingWebhook, error)); ok {
+		return rf(webhook)
+	}
+	if rf, ok := ret.Get(0).(func(*model.IncomingWebhook) *model.IncomingWebhook); ok {
+		r0 = rf(webhook)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.IncomingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.IncomingWebhook) error); ok {
+		r1 = rf(webhook)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SaveOutgoing provides a mock function with given fields: webhook
+func (_m *WebhookStore) SaveOutgoing(webhook *model.OutgoingWebhook) (*model.OutgoingWebhook, error) {
+	ret := _m.Called(webhook)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveOutgoing")
+	}
+
+	var r0 *model.OutgoingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.OutgoingWebhook) (*model.OutgoingWebhook, error)); ok {
+		return rf(webhook)
+	}
+	if rf, ok := ret.Get(0).(func(*model.OutgoingWebhook) *model.OutgoingWebhook); ok {
+		r0 = rf(webhook)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.OutgoingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.OutgoingWebhook) error); ok {
+		r1 = rf(webhook)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateIncoming provides a mock function with given fields: webhook
+func (_m *WebhookStore) UpdateIncoming(webhook *model.IncomingWebhook) (*model.IncomingWebhook, error) {
+	ret := _m.Called(webhook)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateIncoming")
+	}
+
+	var r0 *model.IncomingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.IncomingWebhook) (*model.IncomingWebhook, error)); ok {
+		return rf(webhook)
+	}
+	if rf, ok := ret.Get(0).(func(*model.IncomingWebhook) *model.IncomingWebhook); ok {
+		r0 = rf(webhook)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.IncomingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.IncomingWebhook) error); ok {
+		r1 = rf(webhook)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateIncomingLastUsed provides a mock function with given fields: webhookID, lastUsed
+func (_m *WebhookStore) UpdateIncomingLastUsed(webhookID string, lastUsed int64) error {
+	ret := _m.Called(webhookID, lastUsed)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateIncomingLastUsed")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, int64) error); ok {
+		r0 = rf(webhookID, lastUsed)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateOutgoing provides a mock function with given fields: hook
+func (_m *WebhookStore) UpdateOutgoing(hook *model.OutgoingWebhook) (*model.OutgoingWebhook, error) {
+	ret := _m.Called(hook)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateOutgoing")
+	}
+
+	var r0 *model.OutgoingWebhook
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.OutgoingWebhook) (*model.OutgoingWebhook, error)); ok {
+		return rf(hook)
+	}
+	if rf, ok := ret.Get(0).(func(*model.OutgoingWebhook) *model.OutgoingWebhook); ok {
+		r0 = rf(hook)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.OutgoingWebhook)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.OutgoingWebhook) error); ok {
+		r1 = rf(hook)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewWebhookStore creates a new instance of WebhookStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewWebhookStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *WebhookStore {
+	mock := &WebhookStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/channels/store/storetest/notify_admin_store.go

@@ -0,0 +1,222 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"database/sql"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+const PluginIDJenkins = "jenkins"
+
+func TestNotifyAdminStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("Save", func(t *testing.T) { testNotifyAdminStoreSave(t, rctx, ss) })
+	t.Run("testGetDataByUserIdAndFeature", func(t *testing.T) { testGetDataByUserIDAndFeature(t, rctx, ss) })
+	t.Run("testGet", func(t *testing.T) { testGet(t, rctx, ss) })
+	t.Run("testDeleteBefore", func(t *testing.T) { testDeleteBefore(t, rctx, ss) })
+	t.Run("testUpdate", func(t *testing.T) { testUpdate(t, rctx, ss) })
+}
+
+func tearDown(t *testing.T, rctx request.CTX, ss store.Store) {
+	err := ss.NotifyAdmin().DeleteBefore(true, model.GetMillis()+model.GetMillis())
+	require.NoError(t, err)
+
+	err = ss.NotifyAdmin().DeleteBefore(false, model.GetMillis()+model.GetMillis())
+	require.NoError(t, err)
+}
+
+func testNotifyAdminStoreSave(t *testing.T, rctx request.CTX, ss store.Store) {
+	d1 := &model.NotifyAdminData{
+		UserId:          model.NewId(),
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: model.PaidFeatureAllProfessionalfeatures,
+	}
+
+	_, err := ss.NotifyAdmin().Save(d1)
+	require.NoError(t, err)
+
+	// unknow plan error
+	d2 := &model.NotifyAdminData{
+		UserId:          model.NewId(),
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: "Unknown feature",
+	}
+
+	_, err = ss.NotifyAdmin().Save(d2)
+	require.Error(t, err)
+
+	// unknown feature error
+	d3 := &model.NotifyAdminData{
+		UserId:          model.NewId(),
+		RequiredPlan:    "Unknown plan",
+		RequiredFeature: model.PaidFeatureAllProfessionalfeatures,
+	}
+	_, err = ss.NotifyAdmin().Save(d3)
+	require.Error(t, err)
+
+	// same user requesting same feature error
+	singleUserID := model.NewId()
+	d5 := &model.NotifyAdminData{
+		UserId:          singleUserID,
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: model.PaidFeatureAllProfessionalfeatures,
+	}
+	_, err = ss.NotifyAdmin().Save(d5)
+	require.NoError(t, err)
+
+	d6 := &model.NotifyAdminData{
+		UserId:          singleUserID,
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: model.PaidFeatureAllProfessionalfeatures,
+	}
+	_, err = ss.NotifyAdmin().Save(d6)
+	require.Error(t, err)
+
+	tearDown(t, rctx, ss)
+}
+
+func testGet(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+	d1 := &model.NotifyAdminData{
+		UserId:          userID1,
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: model.PaidFeatureAllProfessionalfeatures,
+	}
+
+	_, err := ss.NotifyAdmin().Save(d1)
+	require.NoError(t, err)
+
+	d1Trial := &model.NotifyAdminData{
+		UserId:          userID1,
+		RequiredPlan:    model.LicenseShortSkuEnterprise,
+		RequiredFeature: model.PaidFeatureAllEnterprisefeatures,
+		Trial:           true,
+	}
+	_, err = ss.NotifyAdmin().Save(d1Trial)
+	require.NoError(t, err)
+
+	d1Trial2 := &model.NotifyAdminData{
+		UserId:          model.NewId(),
+		RequiredPlan:    model.LicenseShortSkuEnterprise,
+		RequiredFeature: model.PaidFeatureAllEnterprisefeatures,
+		Trial:           true,
+	}
+	_, err = ss.NotifyAdmin().Save(d1Trial2)
+	require.NoError(t, err)
+
+	upgradeRequests, err := ss.NotifyAdmin().Get(false)
+	require.NoError(t, err)
+	require.Equal(t, len(upgradeRequests), 1)
+
+	trialRequests, err := ss.NotifyAdmin().Get(true)
+	require.NoError(t, err)
+	require.Equal(t, len(trialRequests), 2)
+
+	tearDown(t, rctx, ss)
+}
+
+func testGetDataByUserIDAndFeature(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+	d1 := &model.NotifyAdminData{
+		UserId:          userID1,
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: model.PaidFeatureAllProfessionalfeatures,
+	}
+
+	_, err := ss.NotifyAdmin().Save(d1)
+	require.NoError(t, err)
+
+	userID2 := model.NewId()
+	d2 := &model.NotifyAdminData{
+		UserId:          userID2,
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: model.PaidFeatureCustomUsergroups,
+	}
+
+	_, err = ss.NotifyAdmin().Save(d2)
+	require.NoError(t, err)
+
+	user1Request, err := ss.NotifyAdmin().GetDataByUserIdAndFeature(userID1, model.PaidFeatureAllProfessionalfeatures)
+	require.NoError(t, err)
+	require.Equal(t, len(user1Request), 1)
+	require.Equal(t, user1Request[0].RequiredFeature, model.PaidFeatureAllProfessionalfeatures)
+
+	tearDown(t, rctx, ss)
+}
+
+func testUpdate(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+	d1 := &model.NotifyAdminData{
+		UserId:          userID1,
+		RequiredPlan:    PluginIDJenkins,
+		RequiredFeature: model.PluginFeature,
+	}
+	_, err := ss.NotifyAdmin().Save(d1)
+	require.NoError(t, err)
+
+	err = ss.NotifyAdmin().Update(d1.UserId, d1.RequiredPlan, d1.RequiredFeature, 100)
+	require.NoError(t, err)
+
+	userRequest, err := ss.NotifyAdmin().GetDataByUserIdAndFeature(d1.UserId, d1.RequiredFeature)
+	require.NoError(t, err)
+
+	require.Equal(t, len(userRequest), 1)
+	require.Equal(t, userRequest[0].SentAt, sql.NullInt64{Int64: 100, Valid: true})
+
+	tearDown(t, rctx, ss)
+}
+
+func testDeleteBefore(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+	d1 := &model.NotifyAdminData{
+		UserId:          userID1,
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: model.PaidFeatureAllProfessionalfeatures,
+	}
+
+	_, err := ss.NotifyAdmin().Save(d1)
+	require.NoError(t, err)
+
+	d1Trial := &model.NotifyAdminData{
+		UserId:          userID1,
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: model.PaidFeatureAllEnterprisefeatures,
+		Trial:           true,
+	}
+	_, err = ss.NotifyAdmin().Save(d1Trial)
+	require.NoError(t, err)
+
+	d1Trial2 := &model.NotifyAdminData{
+		UserId:          model.NewId(),
+		RequiredPlan:    model.LicenseShortSkuProfessional,
+		RequiredFeature: model.PaidFeatureAllEnterprisefeatures,
+		Trial:           true,
+	}
+	_, err = ss.NotifyAdmin().Save(d1Trial2)
+	require.NoError(t, err)
+
+	err = ss.NotifyAdmin().DeleteBefore(false, model.GetMillis()+model.GetMillis()) // delete all upgrade requests
+	require.NoError(t, err)
+
+	upgradeRequests, err := ss.NotifyAdmin().Get(false)
+	require.NoError(t, err)
+	require.Equal(t, len(upgradeRequests), 0)
+
+	trialRequests, err := ss.NotifyAdmin().Get(true)
+	require.NoError(t, err)
+	require.Equal(t, len(trialRequests), 2) // trial requests should still exist
+
+	err = ss.NotifyAdmin().DeleteBefore(true, model.GetMillis()+model.GetMillis()) // delete all trial requests
+	require.NoError(t, err)
+
+	trialRequests, err = ss.NotifyAdmin().Get(false)
+	require.NoError(t, err)
+	require.Equal(t, len(trialRequests), 0)
+}

server/channels/store/storetest/oauth_store.go

@@ -0,0 +1,398 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestOAuthStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("SaveApp", func(t *testing.T) { testOAuthStoreSaveApp(t, rctx, ss) })
+	t.Run("GetApp", func(t *testing.T) { testOAuthStoreGetApp(t, rctx, ss) })
+	t.Run("UpdateApp", func(t *testing.T) { testOAuthStoreUpdateApp(t, rctx, ss) })
+	t.Run("SaveAccessData", func(t *testing.T) { testOAuthStoreSaveAccessData(t, rctx, ss) })
+	t.Run("OAuthUpdateAccessData", func(t *testing.T) { testOAuthUpdateAccessData(t, rctx, ss) })
+	t.Run("GetAccessData", func(t *testing.T) { testOAuthStoreGetAccessData(t, rctx, ss) })
+	t.Run("RemoveAccessData", func(t *testing.T) { testOAuthStoreRemoveAccessData(t, rctx, ss) })
+	t.Run("RemoveAllAccessData", func(t *testing.T) { testOAuthStoreRemoveAllAccessData(t, rctx, ss) })
+	t.Run("SaveAuthData", func(t *testing.T) { testOAuthStoreSaveAuthData(t, rctx, ss) })
+	t.Run("GetAuthData", func(t *testing.T) { testOAuthStoreGetAuthData(t, rctx, ss) })
+	t.Run("RemoveAuthData", func(t *testing.T) { testOAuthStoreRemoveAuthData(t, rctx, ss) })
+	t.Run("RemoveAuthDataByUser", func(t *testing.T) { testOAuthStoreRemoveAuthDataByUser(t, rctx, ss) })
+	t.Run("OAuthGetAuthorizedApps", func(t *testing.T) { testOAuthGetAuthorizedApps(t, rctx, ss) })
+	t.Run("OAuthGetAccessDataByUserForApp", func(t *testing.T) { testOAuthGetAccessDataByUserForApp(t, rctx, ss) })
+	t.Run("DeleteApp", func(t *testing.T) { testOAuthStoreDeleteApp(t, rctx, ss) })
+}
+
+func testOAuthStoreSaveApp(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.OAuthApp{}
+	a1.CreatorId = model.NewId()
+	a1.CallbackUrls = []string{"https://nowhere.com"}
+	a1.Homepage = "https://nowhere.com"
+
+	// Try to save an app that already has an Id
+	a1.Id = model.NewId()
+	_, err := ss.OAuth().SaveApp(&a1)
+	require.Error(t, err, "Should have failed, cannot add an OAuth app cannot be save with an Id, it has to be updated")
+
+	// Try to save an Invalid App
+	a1.Id = ""
+	_, err = ss.OAuth().SaveApp(&a1)
+	require.Error(t, err, "Should have failed, app should be invalid cause it doesn' have a name set")
+
+	a1.Name = "TestApp" + model.NewId() // Valid name
+	a1.MattermostAppID = "a very, very, very, very, very, very, very long id"
+	_, err = ss.OAuth().SaveApp(&a1)
+	require.Error(t, err, "Should have failed, app should be invalid cause the MattermostAppID is to long")
+
+	// Save the app
+	a1.Id = ""
+	a1.MattermostAppID = "some small id" // Valid id
+	_, err = ss.OAuth().SaveApp(&a1)
+	require.NoError(t, err)
+}
+
+func testOAuthStoreGetApp(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.OAuthApp{}
+	a1.CreatorId = model.NewId()
+	a1.Name = "TestApp" + model.NewId()
+	a1.CallbackUrls = []string{"https://nowhere.com"}
+	a1.Homepage = "https://nowhere.com"
+	_, err := ss.OAuth().SaveApp(&a1)
+	require.NoError(t, err)
+
+	// Lets try to get and app that does not exists
+	_, err = ss.OAuth().GetApp("fake0123456789abcderfgret1")
+	require.Error(t, err, "Should have failed. App does not exists")
+
+	_, err = ss.OAuth().GetApp(a1.Id)
+	require.NoError(t, err)
+
+	// Lets try and get the app from a user that hasn't created any apps
+	apps, err := ss.OAuth().GetAppByUser("fake0123456789abcderfgret1", 0, 1000)
+	require.NoError(t, err)
+	assert.Empty(t, apps, "Should have failed. Fake user hasn't created any apps")
+
+	_, err = ss.OAuth().GetAppByUser(a1.CreatorId, 0, 1000)
+	require.NoError(t, err)
+
+	_, err = ss.OAuth().GetApps(0, 1000)
+	require.NoError(t, err)
+}
+
+func testOAuthStoreUpdateApp(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.OAuthApp{}
+	a1.CreatorId = model.NewId()
+	a1.Name = "TestApp" + model.NewId()
+	a1.CallbackUrls = []string{"https://nowhere.com"}
+	a1.Homepage = "https://nowhere.com"
+	_, err := ss.OAuth().SaveApp(&a1)
+	require.NoError(t, err)
+
+	// temporarily save the created app id
+	id := a1.Id
+
+	a1.CreateAt = 1
+	a1.ClientSecret = "pwd"
+	a1.CreatorId = "12345678901234567890123456"
+
+	// Lets update the app by removing the name
+	a1.Name = ""
+	_, err = ss.OAuth().UpdateApp(&a1)
+	require.Error(t, err, "Should have failed. App name is not set")
+
+	// Lets not find the app that we are trying to update
+	a1.Id = "fake0123456789abcderfgret1"
+	a1.Name = "NewName"
+	_, err = ss.OAuth().UpdateApp(&a1)
+	require.Error(t, err, "Should have failed. Not able to find the app")
+
+	a1.Id = id
+	ua, err := ss.OAuth().UpdateApp(&a1)
+	require.NoError(t, err)
+	require.Equal(t, ua.Name, "NewName", "name did not update")
+	require.NotEqual(t, ua.CreateAt, 1, "create at should not have updated")
+	require.NotEqual(t, ua.CreatorId, "12345678901234567890123456", "creator id should not have updated")
+}
+
+func testOAuthStoreSaveAccessData(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.AccessData{}
+	a1.ClientId = model.NewId()
+	a1.UserId = model.NewId()
+
+	// Lets try and save an incomplete access data
+	_, err := ss.OAuth().SaveAccessData(&a1)
+	require.Error(t, err, "Should have failed. Access data needs the token")
+
+	a1.Token = model.NewId()
+	a1.RefreshToken = model.NewId()
+	a1.RedirectUri = "http://example.com"
+
+	_, err = ss.OAuth().SaveAccessData(&a1)
+	require.NoError(t, err)
+}
+
+func testOAuthUpdateAccessData(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.AccessData{}
+	a1.ClientId = model.NewId()
+	a1.UserId = model.NewId()
+	a1.Token = model.NewId()
+	a1.RefreshToken = model.NewId()
+	a1.ExpiresAt = model.GetMillis()
+	a1.RedirectUri = "http://example.com"
+	_, err := ss.OAuth().SaveAccessData(&a1)
+	require.NoError(t, err)
+
+	//Try to update to invalid Refresh Token
+	refreshToken := a1.RefreshToken
+	a1.RefreshToken = model.NewId() + "123"
+	_, err = ss.OAuth().UpdateAccessData(&a1)
+	require.Error(t, err, "Should have failed with invalid token")
+
+	//Try to update to invalid RedirectUri
+	a1.RefreshToken = model.NewId()
+	a1.RedirectUri = ""
+	_, err = ss.OAuth().UpdateAccessData(&a1)
+	require.Error(t, err, "Should have failed with invalid Redirect URI")
+
+	// Should update fine
+	a1.RedirectUri = "http://example.com"
+	ra1, err := ss.OAuth().UpdateAccessData(&a1)
+	require.NoError(t, err)
+	require.NotEqual(t, ra1.RefreshToken, refreshToken, "refresh tokens didn't match")
+}
+
+func testOAuthStoreGetAccessData(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.AccessData{}
+	a1.ClientId = model.NewId()
+	a1.UserId = model.NewId()
+	a1.Token = model.NewId()
+	a1.RefreshToken = model.NewId()
+	a1.ExpiresAt = model.GetMillis()
+	a1.RedirectUri = "http://example.com"
+	_, err := ss.OAuth().SaveAccessData(&a1)
+	require.NoError(t, err)
+
+	_, err = ss.OAuth().GetAccessData("invalidToken")
+	require.Error(t, err, "Should have failed. There is no data with an invalid token")
+
+	ra1, err := ss.OAuth().GetAccessData(a1.Token)
+	require.NoError(t, err)
+	assert.Equal(t, a1.Token, ra1.Token, "tokens didn't match")
+
+	_, err = ss.OAuth().GetPreviousAccessData(a1.UserId, a1.ClientId)
+	require.NoError(t, err)
+
+	_, err = ss.OAuth().GetPreviousAccessData("user", "junk")
+	require.NoError(t, err)
+
+	// Try to get the Access data using an invalid refresh token
+	_, err = ss.OAuth().GetAccessDataByRefreshToken(a1.Token)
+	require.Error(t, err, "Should have failed. There is no data with an invalid token")
+
+	// Get the Access Data using the refresh token
+	ra1, err = ss.OAuth().GetAccessDataByRefreshToken(a1.RefreshToken)
+	require.NoError(t, err)
+	assert.Equal(t, a1.RefreshToken, ra1.RefreshToken, "tokens didn't match")
+}
+
+func testOAuthStoreRemoveAccessData(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.AccessData{}
+	a1.ClientId = model.NewId()
+	a1.UserId = model.NewId()
+	a1.Token = model.NewId()
+	a1.RefreshToken = model.NewId()
+	a1.RedirectUri = "http://example.com"
+	_, err := ss.OAuth().SaveAccessData(&a1)
+	require.NoError(t, err)
+
+	err = ss.OAuth().RemoveAccessData(a1.Token)
+	require.NoError(t, err)
+
+	result, _ := ss.OAuth().GetPreviousAccessData(a1.UserId, a1.ClientId)
+	require.Nil(t, result, "did not delete access token")
+}
+
+func testOAuthStoreRemoveAllAccessData(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.AccessData{}
+	a1.ClientId = model.NewId()
+	a1.UserId = model.NewId()
+	a1.Token = model.NewId()
+	a1.RefreshToken = model.NewId()
+	a1.RedirectUri = "http://example.com"
+	_, err := ss.OAuth().SaveAccessData(&a1)
+	require.NoError(t, err)
+
+	err = ss.OAuth().RemoveAllAccessData()
+	require.NoError(t, err)
+
+	result, _ := ss.OAuth().GetPreviousAccessData(a1.UserId, a1.ClientId)
+	require.Nil(t, result, "did not delete access token")
+}
+
+func testOAuthStoreSaveAuthData(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.AuthData{}
+	a1.ClientId = model.NewId()
+	a1.UserId = model.NewId()
+	a1.Code = model.NewId()
+	a1.RedirectUri = "http://example.com"
+	_, err := ss.OAuth().SaveAuthData(&a1)
+	require.NoError(t, err)
+}
+
+func testOAuthStoreGetAuthData(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.AuthData{}
+	a1.ClientId = model.NewId()
+	a1.UserId = model.NewId()
+	a1.Code = model.NewId()
+	a1.RedirectUri = "http://example.com"
+	_, err := ss.OAuth().SaveAuthData(&a1)
+	require.NoError(t, err)
+
+	_, err = ss.OAuth().GetAuthData(a1.Code)
+	require.NoError(t, err)
+}
+
+func testOAuthStoreRemoveAuthData(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.AuthData{}
+	a1.ClientId = model.NewId()
+	a1.UserId = model.NewId()
+	a1.Code = model.NewId()
+	a1.RedirectUri = "http://example.com"
+	_, err := ss.OAuth().SaveAuthData(&a1)
+	require.NoError(t, err)
+
+	err = ss.OAuth().RemoveAuthData(a1.Code)
+	require.NoError(t, err)
+
+	_, err = ss.OAuth().GetAuthData(a1.Code)
+	require.Error(t, err, "should have errored - auth code removed")
+}
+
+func testOAuthStoreRemoveAuthDataByUser(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.AuthData{}
+	a1.ClientId = model.NewId()
+	a1.UserId = model.NewId()
+	a1.Code = model.NewId()
+	a1.RedirectUri = "http://example.com"
+	_, err := ss.OAuth().SaveAuthData(&a1)
+	require.NoError(t, err)
+
+	err = ss.OAuth().PermanentDeleteAuthDataByUser(a1.UserId)
+	require.NoError(t, err)
+}
+
+func testOAuthGetAuthorizedApps(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.OAuthApp{}
+	a1.CreatorId = model.NewId()
+	a1.Name = "TestApp" + model.NewId()
+	a1.CallbackUrls = []string{"https://nowhere.com"}
+	a1.Homepage = "https://nowhere.com"
+	_, err := ss.OAuth().SaveApp(&a1)
+	require.NoError(t, err)
+
+	// Lets try and get an Authorized app for a user who hasn't authorized it
+	apps, err := ss.OAuth().GetAuthorizedApps("fake0123456789abcderfgret1", 0, 1000)
+	require.NoError(t, err)
+	assert.Empty(t, apps, "Should have failed. Fake user hasn't authorized the app")
+
+	// allow the app
+	p := model.Preference{}
+	p.UserId = a1.CreatorId
+	p.Category = model.PreferenceCategoryAuthorizedOAuthApp
+	p.Name = a1.Id
+	p.Value = "true"
+	nErr := ss.Preference().Save(model.Preferences{p})
+	require.NoError(t, nErr)
+
+	apps, err = ss.OAuth().GetAuthorizedApps(a1.CreatorId, 0, 1000)
+	require.NoError(t, err)
+	assert.NotEqual(t, len(apps), 0, "It should have return apps")
+}
+
+func testOAuthGetAccessDataByUserForApp(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.OAuthApp{}
+	a1.CreatorId = model.NewId()
+	a1.Name = "TestApp" + model.NewId()
+	a1.CallbackUrls = []string{"https://nowhere.com"}
+	a1.Homepage = "https://nowhere.com"
+	_, err := ss.OAuth().SaveApp(&a1)
+	require.NoError(t, err)
+
+	// allow the app
+	p := model.Preference{}
+	p.UserId = a1.CreatorId
+	p.Category = model.PreferenceCategoryAuthorizedOAuthApp
+	p.Name = a1.Id
+	p.Value = "true"
+	nErr := ss.Preference().Save(model.Preferences{p})
+	require.NoError(t, nErr)
+
+	apps, err := ss.OAuth().GetAuthorizedApps(a1.CreatorId, 0, 1000)
+	require.NoError(t, err)
+	assert.NotEqual(t, len(apps), 0, "It should have return apps")
+
+	// save the token
+	ad1 := model.AccessData{}
+	ad1.ClientId = a1.Id
+	ad1.UserId = a1.CreatorId
+	ad1.Token = model.NewId()
+	ad1.RefreshToken = model.NewId()
+	ad1.RedirectUri = "http://example.com"
+
+	_, err = ss.OAuth().SaveAccessData(&ad1)
+	require.NoError(t, err)
+
+	accessData, err := ss.OAuth().GetAccessDataByUserForApp(a1.CreatorId, a1.Id)
+	require.NoError(t, err)
+	assert.NotEqual(t, len(accessData), 0, "It should have return access data")
+}
+
+func testOAuthStoreDeleteApp(t *testing.T, rctx request.CTX, ss store.Store) {
+	a1 := model.OAuthApp{}
+	a1.CreatorId = model.NewId()
+	a1.Name = "TestApp" + model.NewId()
+	a1.CallbackUrls = []string{"https://nowhere.com"}
+	a1.Homepage = "https://nowhere.com"
+	_, err := ss.OAuth().SaveApp(&a1)
+	require.NoError(t, err)
+
+	// delete a non-existent app
+	err = ss.OAuth().DeleteApp("fakeclientId")
+	require.NoError(t, err)
+
+	s1 := &model.Session{}
+	s1.UserId = model.NewId()
+	s1.Token = model.NewId()
+	s1.IsOAuth = true
+
+	s1, nErr := ss.Session().Save(rctx, s1)
+	require.NoError(t, nErr)
+
+	ad1 := model.AccessData{}
+	ad1.ClientId = a1.Id
+	ad1.UserId = a1.CreatorId
+	ad1.Token = s1.Token
+	ad1.RefreshToken = model.NewId()
+	ad1.RedirectUri = "http://example.com"
+
+	_, err = ss.OAuth().SaveAccessData(&ad1)
+	require.NoError(t, err)
+
+	err = ss.OAuth().DeleteApp(a1.Id)
+	require.NoError(t, err)
+
+	_, nErr = ss.Session().Get(rctx, s1.Token)
+	require.Error(t, nErr, "should error - session should be deleted")
+
+	_, err = ss.OAuth().GetAccessData(s1.Token)
+	require.Error(t, err, "should error - access data should be deleted")
+}

server/channels/store/storetest/outgoing_oauth_connection.go

@@ -0,0 +1,413 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"cmp"
+	"slices"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func newValidOutgoingOAuthConnection() *model.OutgoingOAuthConnection {
+	return &model.OutgoingOAuthConnection{
+		CreatorId:     model.NewId(),
+		Name:          "Test Connection",
+		ClientId:      model.NewId(),
+		ClientSecret:  model.NewId(),
+		OAuthTokenURL: "https://nowhere.com/oauth/token",
+		GrantType:     model.OutgoingOAuthConnectionGrantTypeClientCredentials,
+		Audiences:     []string{"https://nowhere.com"},
+	}
+}
+
+func cleanupOutgoingOAuthConnections(t *testing.T, ss store.Store) func() {
+	return func() {
+		// Delete all outgoing connections
+		connections, err := ss.OutgoingOAuthConnection().GetConnections(request.TestContext(t), model.OutgoingOAuthConnectionGetConnectionsFilter{
+			Limit: 100,
+		})
+		require.NoError(t, err)
+		for _, conn := range connections {
+			err := ss.OutgoingOAuthConnection().DeleteConnection(request.TestContext(t), conn.Id)
+			require.NoError(t, err)
+		}
+	}
+}
+
+func TestOutgoingOAuthConnectionStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("SaveConnection", func(t *testing.T) {
+		t.Cleanup(cleanupOutgoingOAuthConnections(t, ss))
+		testSaveOutgoingOAuthConnection(t, ss)
+	})
+	t.Run("UpdateConnection", func(t *testing.T) {
+		t.Cleanup(cleanupOutgoingOAuthConnections(t, ss))
+		testUpdateOutgoingOAuthConnection(t, ss)
+	})
+	t.Run("GetConnection", func(t *testing.T) {
+		t.Cleanup(cleanupOutgoingOAuthConnections(t, ss))
+		testGetOutgoingOAuthConnection(t, ss)
+	})
+	t.Run("GetConnectionsByAudience", func(t *testing.T) {
+		t.Cleanup(cleanupOutgoingOAuthConnections(t, ss))
+		testGetOutgoingOAuthConnectionByAudience(t, ss)
+	})
+	t.Run("GetConnections", func(t *testing.T) {
+		t.Cleanup(cleanupOutgoingOAuthConnections(t, ss))
+		testGetOutgoingOAuthConnections(t, ss)
+	})
+	t.Run("DeleteConnection", func(t *testing.T) {
+		t.Cleanup(cleanupOutgoingOAuthConnections(t, ss))
+		testDeleteOutgoingOAuthConnection(t, ss)
+	})
+}
+
+func testSaveOutgoingOAuthConnection(t *testing.T, ss store.Store) {
+	c := request.TestContext(t)
+
+	t.Run("save/get", func(t *testing.T) {
+		// Define test data
+		connection := newValidOutgoingOAuthConnection()
+
+		// Save the connection
+		_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+		require.NoError(t, err)
+
+		// Retrieve the connection
+		storeConn, err := ss.OutgoingOAuthConnection().GetConnection(c, connection.Id)
+		require.NoError(t, err)
+		require.Equal(t, connection, storeConn)
+	})
+
+	t.Run("save without id should fail", func(t *testing.T) {
+		connection := &model.OutgoingOAuthConnection{
+			Id: model.NewId(),
+		}
+
+		_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+		require.Error(t, err)
+	})
+
+	t.Run("save with incorrect grant type should fail", func(t *testing.T) {
+		connection := newValidOutgoingOAuthConnection()
+		connection.GrantType = "incorrect"
+
+		_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+		require.Error(t, err)
+	})
+}
+
+func testUpdateOutgoingOAuthConnection(t *testing.T, ss store.Store) {
+	c := request.TestContext(t)
+
+	t.Run("update/get", func(t *testing.T) {
+		// Define test data
+		connection := newValidOutgoingOAuthConnection()
+
+		// Save the connection
+		_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+		require.NoError(t, err)
+
+		// Update the connection
+		connection.Name = "Updated Name"
+		_, err = ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+		require.NoError(t, err)
+
+		// Retrieve the connection
+		storeConn, err := ss.OutgoingOAuthConnection().GetConnection(c, connection.Id)
+		require.NoError(t, err)
+		require.Equal(t, connection, storeConn)
+	})
+
+	t.Run("update non-existing", func(t *testing.T) {
+		connection := newValidOutgoingOAuthConnection()
+		connection.Id = model.NewId()
+
+		_, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+		require.Error(t, err)
+	})
+
+	t.Run("update without id should fail", func(t *testing.T) {
+		connection := &model.OutgoingOAuthConnection{
+			Id: model.NewId(),
+		}
+
+		_, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+		require.Error(t, err)
+	})
+
+	t.Run("update should update all fields", func(t *testing.T) {
+		// Define test data
+		connection := newValidOutgoingOAuthConnection()
+
+		// Save the connection
+		_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+		require.NoError(t, err)
+
+		// Update the connection
+		connection.Name = "Updated Name"
+		connection.ClientId = "Updated ClientId"
+		connection.ClientSecret = "Updated ClientSecret"
+		connection.OAuthTokenURL = "https://nowhere.com/updated"
+		// connection.GrantType = "client_credentials" // ignoring since we only allow one for now
+		connection.Audiences = []string{"https://nowhere.com/updated"}
+		_, err = ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+		require.NoError(t, err)
+
+		// Retrieve the connection
+		storeConn, err := ss.OutgoingOAuthConnection().GetConnection(c, connection.Id)
+		require.NoError(t, err)
+		require.Equal(t, connection, storeConn)
+	})
+
+	t.Run("patch", func(t *testing.T) {
+		t.Run("name", func(t *testing.T) {
+			connection := newValidOutgoingOAuthConnection()
+			_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+			require.NoError(t, err)
+
+			connection.Name = "Updated Name"
+
+			updated, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+			require.NoError(t, err)
+			require.Equal(t, connection, updated)
+		})
+
+		t.Run("client id", func(t *testing.T) {
+			connection := newValidOutgoingOAuthConnection()
+			_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+			require.NoError(t, err)
+
+			connection.ClientId = "Updated ClientId"
+
+			updated, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+			require.NoError(t, err)
+			require.Equal(t, connection, updated)
+		})
+
+		t.Run("client secret", func(t *testing.T) {
+			connection := newValidOutgoingOAuthConnection()
+			_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+			require.NoError(t, err)
+
+			connection.ClientSecret = "Updated ClientSecret"
+
+			updated, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+			require.NoError(t, err)
+			require.Equal(t, connection, updated)
+		})
+
+		t.Run("oauth token url", func(t *testing.T) {
+			connection := newValidOutgoingOAuthConnection()
+			_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+			require.NoError(t, err)
+
+			connection.OAuthTokenURL = "https://nowhere.com/updated"
+
+			updated, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+			require.NoError(t, err)
+			require.Equal(t, connection, updated)
+		})
+
+		t.Run("grant type", func(t *testing.T) {
+			connection := newValidOutgoingOAuthConnection()
+			_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+			require.NoError(t, err)
+
+			connection.GrantType = model.OutgoingOAuthConnectionGrantTypeClientCredentials
+
+			updated, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+			require.NoError(t, err)
+			require.Equal(t, connection, updated)
+		})
+
+		t.Run("audiences", func(t *testing.T) {
+			connection := newValidOutgoingOAuthConnection()
+			_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+			require.NoError(t, err)
+
+			connection.Audiences = model.StringArray{"https://nowhere.com/updated"}
+
+			updated, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+			require.NoError(t, err)
+			require.Equal(t, connection, updated)
+		})
+
+		t.Run("credentials username", func(t *testing.T) {
+			connection := newValidOutgoingOAuthConnection()
+			_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+			require.NoError(t, err)
+
+			username := "updated username"
+			connection.CredentialsUsername = &username
+
+			updated, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+			require.NoError(t, err)
+			require.Equal(t, connection, updated)
+		})
+
+		t.Run("credentials password", func(t *testing.T) {
+			connection := newValidOutgoingOAuthConnection()
+			_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+			require.NoError(t, err)
+
+			password := "updated password"
+			connection.CredentialsPassword = &password
+
+			updated, err := ss.OutgoingOAuthConnection().UpdateConnection(c, connection)
+			require.NoError(t, err)
+			require.Equal(t, connection, updated)
+		})
+	})
+}
+
+func testGetOutgoingOAuthConnection(t *testing.T, ss store.Store) {
+	c := request.TestContext(t)
+
+	t.Run("get non-existing", func(t *testing.T) {
+		nonExistingID := model.NewId()
+		var expected *store.ErrNotFound
+		_, err := ss.OutgoingOAuthConnection().GetConnection(c, nonExistingID)
+		require.ErrorAs(t, err, &expected)
+	})
+}
+
+func runAudienceTests(t *testing.T, ss store.Store, connection *model.OutgoingOAuthConnection) {
+	c := request.TestContext(t)
+
+	t.Run("find by host only", func(t *testing.T) {
+		conn, err := ss.OutgoingOAuthConnection().GetConnections(c, model.OutgoingOAuthConnectionGetConnectionsFilter{Audience: "knowhere.com"})
+		require.NoError(t, err)
+		require.Len(t, conn, 1)
+		require.Equal(t, []*model.OutgoingOAuthConnection{connection}, conn)
+	})
+
+	t.Run("find by host and path", func(t *testing.T) {
+		conn, err := ss.OutgoingOAuthConnection().GetConnections(c, model.OutgoingOAuthConnectionGetConnectionsFilter{Audience: "knowhere.com/audience"})
+		require.NoError(t, err)
+		require.Len(t, conn, 1)
+		require.Equal(t, []*model.OutgoingOAuthConnection{connection}, conn)
+	})
+
+	t.Run("find by full url", func(t *testing.T) {
+		conn, err := ss.OutgoingOAuthConnection().GetConnections(c, model.OutgoingOAuthConnectionGetConnectionsFilter{Audience: "https://knowhere.com/audience"})
+		require.NoError(t, err)
+		require.Len(t, conn, 1)
+		require.Equal(t, []*model.OutgoingOAuthConnection{connection}, conn)
+	})
+
+	t.Run("non-existent", func(t *testing.T) {
+		conn, err := ss.OutgoingOAuthConnection().GetConnections(c, model.OutgoingOAuthConnectionGetConnectionsFilter{Audience: "https://mattermost.com"})
+		require.NoError(t, err)
+		require.Empty(t, conn)
+	})
+}
+
+func testGetOutgoingOAuthConnectionByAudience(t *testing.T, ss store.Store) {
+	t.Run("get non-existing", func(t *testing.T) {
+		c := request.TestContext(t)
+
+		nonExistingID := model.NewId()
+		var expected *store.ErrNotFound
+		_, err := ss.OutgoingOAuthConnection().GetConnection(c, nonExistingID)
+		require.ErrorAs(t, err, &expected)
+	})
+
+	t.Run("get existing (single audience)", func(t *testing.T) {
+		t.Cleanup(cleanupOutgoingOAuthConnections(t, ss))
+		c := request.TestContext(t)
+
+		connection := newValidOutgoingOAuthConnection()
+		connection.Audiences = []string{"https://knowhere.com/audience"}
+		var err error
+		connection, err = ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+		require.NoError(t, err)
+
+		runAudienceTests(t, ss, connection)
+	})
+
+	t.Run("get existing (multiple audiences)", func(t *testing.T) {
+		t.Cleanup(cleanupOutgoingOAuthConnections(t, ss))
+		c := request.TestContext(t)
+
+		connection := newValidOutgoingOAuthConnection()
+		connection.Audiences = []string{"https://knowhere.com/audience", "https://example.com"}
+		var err error
+		connection, err = ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+		require.NoError(t, err)
+
+		runAudienceTests(t, ss, connection)
+	})
+}
+
+func testGetOutgoingOAuthConnections(t *testing.T, ss store.Store) {
+	c := request.TestContext(t)
+
+	// Define test data
+	connection1 := newValidOutgoingOAuthConnection()
+	connection2 := newValidOutgoingOAuthConnection()
+	connection3 := newValidOutgoingOAuthConnection()
+
+	// Save the connections
+	connection1, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection1)
+	require.NoError(t, err)
+	connection2, err = ss.OutgoingOAuthConnection().SaveConnection(c, connection2)
+	require.NoError(t, err)
+	connection3, err = ss.OutgoingOAuthConnection().SaveConnection(c, connection3)
+	require.NoError(t, err)
+
+	connections := []*model.OutgoingOAuthConnection{connection1, connection2, connection3}
+	slices.SortFunc(connections, func(a, b *model.OutgoingOAuthConnection) int {
+		return cmp.Compare(a.Id, b.Id)
+	})
+
+	t.Run("get all", func(t *testing.T) {
+		// Retrieve the connections
+		conns, err := ss.OutgoingOAuthConnection().GetConnections(c, model.OutgoingOAuthConnectionGetConnectionsFilter{Limit: 3})
+		require.NoError(t, err)
+		require.Len(t, conns, 3)
+	})
+
+	t.Run("get connections using pagination", func(t *testing.T) {
+		// Retrieve the first page
+		conns, err := ss.OutgoingOAuthConnection().GetConnections(c, model.OutgoingOAuthConnectionGetConnectionsFilter{Limit: 1})
+		require.NoError(t, err)
+		require.Len(t, conns, 1)
+		require.Equal(t, connections[0].Id, conns[0].Id, "should return the first connection")
+
+		// Retrieve the second page
+		conns, err = ss.OutgoingOAuthConnection().GetConnections(c, model.OutgoingOAuthConnectionGetConnectionsFilter{OffsetId: connections[0].Id})
+		require.NoError(t, err)
+		require.Len(t, conns, 2)
+		require.Equal(t, connections[1].Id, conns[0].Id, "should return the second connection")
+		require.Equal(t, connections[2].Id, conns[1].Id, "should return the third connection")
+	})
+}
+
+func testDeleteOutgoingOAuthConnection(t *testing.T, ss store.Store) {
+	c := request.TestContext(t)
+
+	t.Run("delete", func(t *testing.T) {
+		// Define test data
+		connection := newValidOutgoingOAuthConnection()
+
+		// Save the connection
+		_, err := ss.OutgoingOAuthConnection().SaveConnection(c, connection)
+		require.NoError(t, err)
+
+		// Delete the connection
+		err = ss.OutgoingOAuthConnection().DeleteConnection(c, connection.Id)
+		require.NoError(t, err)
+
+		// Retrieve the connection
+		_, err = ss.OutgoingOAuthConnection().GetConnection(c, connection.Id)
+		var expected *store.ErrNotFound
+		require.ErrorAs(t, err, &expected)
+	})
+}

server/channels/store/storetest/post_acknowledgements_store.go

@@ -0,0 +1,582 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestPostAcknowledgementsStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("Save", func(t *testing.T) { testPostAcknowledgementsStoreSave(t, rctx, ss) })
+	t.Run("GetForPost", func(t *testing.T) { testPostAcknowledgementsStoreGetForPost(t, rctx, ss) })
+	t.Run("GetForPosts", func(t *testing.T) { testPostAcknowledgementsStoreGetForPosts(t, rctx, ss) })
+	t.Run("BatchSave", func(t *testing.T) { testPostAcknowledgementsStoreBatchSave(t, rctx, ss) })
+	t.Run("BatchDelete", func(t *testing.T) { testPostAcknowledgementsStoreBatchDelete(t, rctx, ss) })
+	t.Run("DeleteAllForPost", func(t *testing.T) { testPostAcknowledgementsStoreDeleteAllForPost(t, rctx, ss) })
+}
+
+func testPostAcknowledgementsStoreSave(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestID()
+	p1.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                new("important"),
+			RequestedAck:            new(true),
+			PersistentNotifications: new(false),
+		},
+	}
+	post, err := ss.Post().Save(rctx, &p1)
+	require.NoError(t, err)
+
+	t.Run("consecutive saves should just update the acknowledged at", func(t *testing.T) {
+		ack := &model.PostAcknowledgement{PostId: post.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		_, err := ss.PostAcknowledgement().SaveWithModel(ack)
+		require.NoError(t, err)
+
+		ack = &model.PostAcknowledgement{PostId: post.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		_, err = ss.PostAcknowledgement().SaveWithModel(ack)
+		require.NoError(t, err)
+
+		ack1 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		ack1, err = ss.PostAcknowledgement().SaveWithModel(ack1)
+		require.NoError(t, err)
+
+		acknowledgements, err := ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack1})
+	})
+
+	t.Run("saving should update the update at of the post", func(t *testing.T) {
+		oldUpdateAt := post.UpdateAt
+		ack := &model.PostAcknowledgement{PostId: post.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		_, err := ss.PostAcknowledgement().SaveWithModel(ack)
+		require.NoError(t, err)
+
+		post, err = ss.Post().GetSingle(rctx, post.Id, false)
+		require.NoError(t, err)
+		require.Greater(t, post.UpdateAt, oldUpdateAt)
+	})
+}
+
+func testPostAcknowledgementsStoreGetForPost(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+	userID2 := model.NewId()
+	userID3 := model.NewId()
+
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestID()
+	p1.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                new("important"),
+			RequestedAck:            new(true),
+			PersistentNotifications: new(false),
+		},
+	}
+	_, err := ss.Post().Save(rctx, &p1)
+	require.NoError(t, err)
+
+	t.Run("get acknowledgements for post", func(t *testing.T) {
+		ack1 := &model.PostAcknowledgement{PostId: p1.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: p1.ChannelId}
+		ack1, err := ss.PostAcknowledgement().SaveWithModel(ack1)
+		require.NoError(t, err)
+		ack2 := &model.PostAcknowledgement{PostId: p1.Id, UserId: userID2, AcknowledgedAt: 0, ChannelId: p1.ChannelId}
+		ack2, err = ss.PostAcknowledgement().SaveWithModel(ack2)
+		require.NoError(t, err)
+		ack3 := &model.PostAcknowledgement{PostId: p1.Id, UserId: userID3, AcknowledgedAt: 0, ChannelId: p1.ChannelId}
+		ack3, err = ss.PostAcknowledgement().SaveWithModel(ack3)
+		require.NoError(t, err)
+
+		acknowledgements, err := ss.PostAcknowledgement().GetForPost(p1.Id)
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack1, ack2, ack3})
+
+		err = ss.PostAcknowledgement().Delete(ack1)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPost(p1.Id)
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack2, ack3})
+
+		err = ss.PostAcknowledgement().Delete(ack2)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPost(p1.Id)
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack3})
+
+		err = ss.PostAcknowledgement().Delete(ack3)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPost(p1.Id)
+		require.NoError(t, err)
+		require.Empty(t, acknowledgements)
+	})
+}
+
+func testPostAcknowledgementsStoreGetForPosts(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+	userID2 := model.NewId()
+	userID3 := model.NewId()
+
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestID()
+	p1.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                new("important"),
+			RequestedAck:            new(true),
+			PersistentNotifications: new(false),
+		},
+	}
+	p2 := model.Post{}
+	p2.ChannelId = model.NewId()
+	p2.UserId = model.NewId()
+	p2.Message = NewTestID()
+	p2.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                new(""),
+			RequestedAck:            new(true),
+			PersistentNotifications: new(false),
+		},
+	}
+	_, errIdx, err := ss.Post().SaveMultiple(rctx, []*model.Post{&p1, &p2})
+	require.NoError(t, err)
+	require.Equal(t, -1, errIdx)
+
+	t.Run("get acknowledgements for post", func(t *testing.T) {
+		ack1 := &model.PostAcknowledgement{PostId: p1.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: p1.ChannelId}
+		ack1, err := ss.PostAcknowledgement().SaveWithModel(ack1)
+		require.NoError(t, err)
+		ack2 := &model.PostAcknowledgement{PostId: p1.Id, UserId: userID2, AcknowledgedAt: 0, ChannelId: p1.ChannelId}
+		ack2, err = ss.PostAcknowledgement().SaveWithModel(ack2)
+		require.NoError(t, err)
+		ack3 := &model.PostAcknowledgement{PostId: p2.Id, UserId: userID2, AcknowledgedAt: 0, ChannelId: p2.ChannelId}
+		ack3, err = ss.PostAcknowledgement().SaveWithModel(ack3)
+		require.NoError(t, err)
+		ack4 := &model.PostAcknowledgement{PostId: p2.Id, UserId: userID3, AcknowledgedAt: 0, ChannelId: p2.ChannelId}
+		ack4, err = ss.PostAcknowledgement().SaveWithModel(ack4)
+		require.NoError(t, err)
+
+		acknowledgements, err := ss.PostAcknowledgement().GetForPosts([]string{p1.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack1, ack2})
+
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack3, ack4})
+
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack1, ack2, ack3, ack4})
+
+		err = ss.PostAcknowledgement().Delete(ack1)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack2, ack3, ack4})
+
+		err = ss.PostAcknowledgement().Delete(ack2)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack3, ack4})
+
+		err = ss.PostAcknowledgement().Delete(ack3)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack4})
+
+		err = ss.PostAcknowledgement().Delete(ack4)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.Empty(t, acknowledgements)
+	})
+}
+
+func testPostAcknowledgementsStoreBatchSave(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+	userID2 := model.NewId()
+	userID3 := model.NewId()
+
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestID()
+	post, err := ss.Post().Save(rctx, &p1)
+	require.NoError(t, err)
+
+	t.Run("batch save acknowledgements for a post", func(t *testing.T) {
+		// Create a batch of acknowledgements
+		acks := []*model.PostAcknowledgement{
+			{
+				PostId:         post.Id,
+				UserId:         userID1,
+				AcknowledgedAt: model.GetMillis(),
+			},
+			{
+				PostId:         post.Id,
+				UserId:         userID2,
+				AcknowledgedAt: model.GetMillis(),
+			},
+			{
+				PostId:         post.Id,
+				UserId:         userID3,
+				AcknowledgedAt: model.GetMillis(),
+			},
+		}
+
+		// Save the batch
+		savedAcks, err := ss.PostAcknowledgement().BatchSave(acks)
+		require.NoError(t, err)
+		require.Len(t, savedAcks, 3)
+
+		// Verify all were saved correctly
+		retrievedAcks, err := ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, err)
+		require.Len(t, retrievedAcks, 3)
+
+		// Verify all users are in the saved acknowledgements
+		userIDMap := make(map[string]bool)
+		for _, ack := range retrievedAcks {
+			userIDMap[ack.UserId] = true
+			require.Equal(t, post.Id, ack.PostId)
+			require.Greater(t, ack.AcknowledgedAt, int64(0))
+		}
+
+		require.True(t, userIDMap[userID1])
+		require.True(t, userIDMap[userID2])
+		require.True(t, userIDMap[userID3])
+	})
+
+	t.Run("batch save empty list of acknowledgements", func(t *testing.T) {
+		// Create an empty batch of acknowledgements
+		acks := []*model.PostAcknowledgement{}
+
+		// Save the empty batch
+		savedAcks, err := ss.PostAcknowledgement().BatchSave(acks)
+		require.NoError(t, err)
+		require.Empty(t, savedAcks)
+	})
+
+	t.Run("batch save should update existing acknowledgements", func(t *testing.T) {
+		// First, delete all existing acknowledgements
+		acks, err := ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, err)
+
+		for _, ack := range acks {
+			err = ss.PostAcknowledgement().Delete(ack)
+			require.NoError(t, err)
+		}
+
+		// Create initial acknowledgement
+		ack := &model.PostAcknowledgement{PostId: post.Id, UserId: userID1, AcknowledgedAt: model.GetMillis(), ChannelId: post.ChannelId}
+		ack, err = ss.PostAcknowledgement().SaveWithModel(ack)
+		require.NoError(t, err)
+
+		initialAckTime := ack.AcknowledgedAt
+
+		// Create a batch with updated timestamp
+		newTimestamp := model.GetMillis() + 1000
+		updatedAcks := []*model.PostAcknowledgement{
+			{
+				PostId:         post.Id,
+				UserId:         userID1,
+				AcknowledgedAt: newTimestamp,
+			},
+		}
+
+		// Batch save should update the existing acknowledgement
+		savedAcks, err := ss.PostAcknowledgement().BatchSave(updatedAcks)
+		require.NoError(t, err)
+		require.Len(t, savedAcks, 1)
+		require.Equal(t, newTimestamp, savedAcks[0].AcknowledgedAt)
+		require.Greater(t, savedAcks[0].AcknowledgedAt, initialAckTime)
+
+		// Verify the acknowledgement was updated
+		retrievedAcks, err := ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, err)
+		require.Len(t, retrievedAcks, 1)
+		require.Equal(t, newTimestamp, retrievedAcks[0].AcknowledgedAt)
+	})
+
+	t.Run("batch save should update post's update_at", func(t *testing.T) {
+		// First, check the current post update timestamp
+		currentPost, err := ss.Post().GetSingle(rctx, post.Id, false)
+		require.NoError(t, err)
+		oldUpdateAt := currentPost.UpdateAt
+
+		// Create a batch of new acknowledgements
+		acks := []*model.PostAcknowledgement{
+			{
+				PostId:         post.Id,
+				UserId:         model.NewId(),
+				AcknowledgedAt: model.GetMillis(),
+			},
+		}
+
+		// Save the batch
+		_, err = ss.PostAcknowledgement().BatchSave(acks)
+		require.NoError(t, err)
+
+		// Verify post's update_at was updated
+		updatedPost, err := ss.Post().GetSingle(rctx, post.Id, false)
+		require.NoError(t, err)
+		require.Greater(t, updatedPost.UpdateAt, oldUpdateAt)
+	})
+}
+
+func testPostAcknowledgementsStoreBatchDelete(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+	userID2 := model.NewId()
+	userID3 := model.NewId()
+
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestID()
+	post, err := ss.Post().Save(rctx, &p1)
+	require.NoError(t, err)
+
+	t.Run("batch delete all acknowledgements for a post", func(t *testing.T) {
+		// Create multiple acknowledgements
+		ack1 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		ack1, err = ss.PostAcknowledgement().SaveWithModel(ack1)
+		require.NoError(t, err)
+		ack2 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID2, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		ack2, err = ss.PostAcknowledgement().SaveWithModel(ack2)
+		require.NoError(t, err)
+		ack3 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID3, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		ack3, err = ss.PostAcknowledgement().SaveWithModel(ack3)
+		require.NoError(t, err)
+
+		// Verify acknowledgements were created
+		acks, pErr := ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, pErr)
+		require.Len(t, acks, 3)
+
+		// Delete all acknowledgements in batch
+		err = ss.PostAcknowledgement().BatchDelete([]*model.PostAcknowledgement{ack1, ack2, ack3})
+		require.NoError(t, err)
+
+		// Verify all acknowledgements were deleted
+		acks, err = ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, err)
+		require.Empty(t, acks)
+	})
+
+	t.Run("batch delete should update post's update_at", func(t *testing.T) {
+		// Create acknowledgements
+		ack1 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		ack1, err = ss.PostAcknowledgement().SaveWithModel(ack1)
+		require.NoError(t, err)
+		ack2 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID2, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		ack2, err = ss.PostAcknowledgement().SaveWithModel(ack2)
+		require.NoError(t, err)
+
+		// Get current post update timestamp
+		currentPost, err := ss.Post().GetSingle(rctx, post.Id, false)
+		require.NoError(t, err)
+		oldUpdateAt := currentPost.UpdateAt
+
+		// Delete acknowledgements in batch
+		err = ss.PostAcknowledgement().BatchDelete([]*model.PostAcknowledgement{ack1, ack2})
+		require.NoError(t, err)
+
+		// Verify post's update_at was updated
+		updatedPost, err := ss.Post().GetSingle(rctx, post.Id, false)
+		require.NoError(t, err)
+		require.Greater(t, updatedPost.UpdateAt, oldUpdateAt)
+	})
+
+	t.Run("batch delete with empty list should not error", func(t *testing.T) {
+		// Delete with empty list should not error
+		err := ss.PostAcknowledgement().BatchDelete([]*model.PostAcknowledgement{})
+		require.NoError(t, err)
+	})
+
+	t.Run("batch delete with non-existent acknowledgements should not error", func(t *testing.T) {
+		// Create non-existent acknowledgements
+		nonExistentAck := &model.PostAcknowledgement{
+			PostId:         model.NewId(),
+			UserId:         model.NewId(),
+			AcknowledgedAt: model.GetMillis(),
+		}
+
+		// Delete non-existent acknowledgement should not error
+		err := ss.PostAcknowledgement().BatchDelete([]*model.PostAcknowledgement{nonExistentAck})
+		require.NoError(t, err)
+	})
+}
+
+func testPostAcknowledgementsStoreDeleteAllForPost(t *testing.T, rctx request.CTX, ss store.Store) {
+	userID1 := model.NewId()
+	userID2 := model.NewId()
+	userID3 := model.NewId()
+
+	t.Run("should permanently delete all acknowledgements for a post", func(t *testing.T) {
+		p1 := model.Post{}
+		p1.ChannelId = model.NewId()
+		p1.UserId = model.NewId()
+		p1.Message = NewTestID()
+		p1.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                new("important"),
+				RequestedAck:            new(true),
+				PersistentNotifications: new(false),
+			},
+		}
+		post, err := ss.Post().Save(rctx, &p1)
+		require.NoError(t, err)
+
+		// Create multiple acknowledgements
+		ack1 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		_, err = ss.PostAcknowledgement().SaveWithModel(ack1)
+		require.NoError(t, err)
+		ack2 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID2, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		_, err = ss.PostAcknowledgement().SaveWithModel(ack2)
+		require.NoError(t, err)
+		ack3 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID3, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		_, err = ss.PostAcknowledgement().SaveWithModel(ack3)
+		require.NoError(t, err)
+
+		// Verify acknowledgements were created
+		acks, err := ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, err)
+		require.Len(t, acks, 3)
+
+		// Delete all acknowledgements for the post
+		err = ss.PostAcknowledgement().DeleteAllForPost(post.Id)
+		require.NoError(t, err)
+
+		// Verify all acknowledgements were permanently deleted
+		acks, err = ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, err)
+		require.Empty(t, acks)
+
+		// Verify they are truly deleted and not just soft-deleted (AcknowledgedAt = 0)
+		// by checking GetForPostSince with inclDeleted = true
+		acksWithDeleted, err := ss.PostAcknowledgement().GetForPostSince(post.Id, 0, "", true)
+		require.NoError(t, err)
+		require.Empty(t, acksWithDeleted, "Acknowledgements should be permanently deleted, not soft-deleted")
+	})
+
+	t.Run("should only delete acknowledgements for the specified post", func(t *testing.T) {
+		// Create two posts
+		p1 := model.Post{}
+		p1.ChannelId = model.NewId()
+		p1.UserId = model.NewId()
+		p1.Message = NewTestID()
+		post1, err := ss.Post().Save(rctx, &p1)
+		require.NoError(t, err)
+
+		p2 := model.Post{}
+		p2.ChannelId = model.NewId()
+		p2.UserId = model.NewId()
+		p2.Message = NewTestID()
+		post2, err := ss.Post().Save(rctx, &p2)
+		require.NoError(t, err)
+
+		// Create acknowledgements for both posts
+		ack1 := &model.PostAcknowledgement{PostId: post1.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post1.ChannelId}
+		_, err = ss.PostAcknowledgement().SaveWithModel(ack1)
+		require.NoError(t, err)
+		ack2 := &model.PostAcknowledgement{PostId: post1.Id, UserId: userID2, AcknowledgedAt: 0, ChannelId: post1.ChannelId}
+		_, err = ss.PostAcknowledgement().SaveWithModel(ack2)
+		require.NoError(t, err)
+		ack3 := &model.PostAcknowledgement{PostId: post2.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post2.ChannelId}
+		ack3, err = ss.PostAcknowledgement().SaveWithModel(ack3)
+		require.NoError(t, err)
+		ack4 := &model.PostAcknowledgement{PostId: post2.Id, UserId: userID2, AcknowledgedAt: 0, ChannelId: post2.ChannelId}
+		ack4, err = ss.PostAcknowledgement().SaveWithModel(ack4)
+		require.NoError(t, err)
+
+		// Delete all acknowledgements for post1 only
+		err = ss.PostAcknowledgement().DeleteAllForPost(post1.Id)
+		require.NoError(t, err)
+
+		// Verify post1 acknowledgements are deleted
+		acks1, err := ss.PostAcknowledgement().GetForPost(post1.Id)
+		require.NoError(t, err)
+		require.Empty(t, acks1)
+
+		// Verify post2 acknowledgements are still present
+		acks2, err := ss.PostAcknowledgement().GetForPost(post2.Id)
+		require.NoError(t, err)
+		require.Len(t, acks2, 2)
+		require.ElementsMatch(t, acks2, []*model.PostAcknowledgement{ack3, ack4})
+	})
+
+	t.Run("should not error when deleting from post with no acknowledgements", func(t *testing.T) {
+		p1 := model.Post{}
+		p1.ChannelId = model.NewId()
+		p1.UserId = model.NewId()
+		p1.Message = NewTestID()
+		post, err := ss.Post().Save(rctx, &p1)
+		require.NoError(t, err)
+
+		// Verify no acknowledgements exist
+		acks, err := ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, err)
+		require.Empty(t, acks)
+
+		// Delete should not error
+		err = ss.PostAcknowledgement().DeleteAllForPost(post.Id)
+		require.NoError(t, err)
+	})
+
+	t.Run("should not error when deleting from non-existent post", func(t *testing.T) {
+		nonExistentPostId := model.NewId()
+
+		// Delete should not error even for non-existent post
+		err := ss.PostAcknowledgement().DeleteAllForPost(nonExistentPostId)
+		require.NoError(t, err)
+	})
+
+	t.Run("should delete both active and soft-deleted acknowledgements", func(t *testing.T) {
+		p1 := model.Post{}
+		p1.ChannelId = model.NewId()
+		p1.UserId = model.NewId()
+		p1.Message = NewTestID()
+		post, err := ss.Post().Save(rctx, &p1)
+		require.NoError(t, err)
+
+		// Create active acknowledgement
+		ack1 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID1, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		_, err = ss.PostAcknowledgement().SaveWithModel(ack1)
+		require.NoError(t, err)
+
+		// Create another acknowledgement and soft-delete it
+		ack2 := &model.PostAcknowledgement{PostId: post.Id, UserId: userID2, AcknowledgedAt: 0, ChannelId: post.ChannelId}
+		ack2, err = ss.PostAcknowledgement().SaveWithModel(ack2)
+		require.NoError(t, err)
+		err = ss.PostAcknowledgement().Delete(ack2) // Soft delete sets AcknowledgedAt to 0
+		require.NoError(t, err)
+
+		// Verify we have active acknowledgements
+		activeAcks, err := ss.PostAcknowledgement().GetForPost(post.Id)
+		require.NoError(t, err)
+		require.Len(t, activeAcks, 1)
+
+		// Delete all acknowledgements for the post
+		err = ss.PostAcknowledgement().DeleteAllForPost(post.Id)
+		require.NoError(t, err)
+
+		// Verify all acknowledgements (including soft-deleted) are permanently deleted
+		acksWithDeleted, err := ss.PostAcknowledgement().GetForPostSince(post.Id, 0, "", true)
+		require.NoError(t, err)
+		require.Empty(t, acksWithDeleted, "All acknowledgements including soft-deleted should be permanently deleted")
+	})
+}

server/channels/store/storetest/post_persistent_notification_store.go

@@ -0,0 +1,453 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+	"time"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPostPersistentNotificationStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("Get", func(t *testing.T) { testPostPersistentNotificationStoreGet(t, rctx, ss) })
+	t.Run("Delete", func(t *testing.T) { testPostPersistentNotificationStoreDelete(t, rctx, ss) })
+	t.Run("UpdateLastSentAt", func(t *testing.T) { testPostPersistentNotificationStoreUpdateLastSentAt(t, rctx, ss) })
+}
+
+func testPostPersistentNotificationStoreGet(t *testing.T, rctx request.CTX, ss store.Store) {
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestID()
+	p1.CreateAt = 10
+	p1.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                new("important"),
+			RequestedAck:            new(false),
+			PersistentNotifications: new(true),
+		},
+	}
+
+	p2 := model.Post{}
+	p2.ChannelId = p1.ChannelId
+	p2.UserId = model.NewId()
+	p2.Message = NewTestID()
+	p2.CreateAt = 20
+	p2.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                model.NewPointer(model.PostPriorityUrgent),
+			RequestedAck:            new(true),
+			PersistentNotifications: new(true),
+		},
+	}
+
+	// Invalid - Has no Priority
+	p3 := model.Post{}
+	p3.ChannelId = p1.ChannelId
+	p3.UserId = model.NewId()
+	p3.Message = NewTestID()
+	p3.CreateAt = 30
+
+	// Invalid - Notification is false
+	p4 := model.Post{}
+	p4.ChannelId = p1.ChannelId
+	p4.UserId = model.NewId()
+	p4.Message = NewTestID()
+	p4.CreateAt = 40
+	p4.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                model.NewPointer(model.PostPriorityUrgent),
+			RequestedAck:            new(false),
+			PersistentNotifications: new(false),
+		},
+	}
+
+	p5 := model.Post{}
+	p5.ChannelId = p1.ChannelId
+	p5.UserId = model.NewId()
+	p5.Message = NewTestID()
+	p5.CreateAt = 50
+	p5.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                model.NewPointer(model.PostPriorityUrgent),
+			RequestedAck:            new(false),
+			PersistentNotifications: new(true),
+		},
+	}
+
+	_, errIdx, err := ss.Post().SaveMultiple(rctx, []*model.Post{&p1, &p2, &p3, &p4, &p5})
+	require.NoError(t, err)
+	require.Equal(t, -1, errIdx)
+
+	defer ss.Post().PermanentDeleteByChannel(rctx, p1.ChannelId)
+	defer ss.PostPersistentNotification().Delete([]string{p1.Id, p2.Id, p3.Id, p4.Id, p5.Id})
+
+	t.Run("Get Single", func(t *testing.T) {
+		pn, err := ss.PostPersistentNotification().GetSingle(p1.Id)
+		require.NoError(t, err)
+		assert.Equal(t, p1.Id, pn.PostId)
+
+		pn, err = ss.PostPersistentNotification().GetSingle(p2.Id)
+		require.NoError(t, err)
+		assert.Equal(t, p2.Id, pn.PostId)
+
+		pn, err = ss.PostPersistentNotification().GetSingle(p5.Id)
+		require.NoError(t, err)
+		assert.Equal(t, p5.Id, pn.PostId)
+
+		pn, err = ss.PostPersistentNotification().GetSingle(p3.Id)
+		require.Error(t, err)
+		require.Zero(t, pn)
+
+		pn, err = ss.PostPersistentNotification().GetSingle(p4.Id)
+		require.Error(t, err)
+		require.Zero(t, pn)
+	})
+
+	t.Run("Get all before MaxTime", func(t *testing.T) {
+		validIDs := []string{p1.Id, p2.Id, p5.Id}
+		getIDs := func(posts []*model.PostPersistentNotifications) (ids []string) {
+			for _, p := range posts {
+				ids = append(ids, p.PostId)
+			}
+			return
+		}
+
+		// p5 is filtered by maxTime
+		pn, err := ss.PostPersistentNotification().Get(model.GetPersistentNotificationsPostsParams{
+			MaxTime:      45,
+			MaxSentCount: 60,
+			PerPage:      20,
+		})
+		require.NoError(t, err)
+		require.Len(t, pn, 2)
+		assert.Contains(t, getIDs(pn), p1.Id)
+		assert.Contains(t, getIDs(pn), p2.Id)
+
+		// nothing is filtered out
+		pn, err = ss.PostPersistentNotification().Get(model.GetPersistentNotificationsPostsParams{
+			MaxTime:      100,
+			MaxSentCount: 60,
+			PerPage:      20,
+		})
+		require.NoError(t, err)
+		require.Len(t, pn, 3)
+		assert.ElementsMatch(t, validIDs, getIDs(pn))
+	})
+}
+
+func testPostPersistentNotificationStoreUpdateLastSentAt(t *testing.T, rctx request.CTX, ss store.Store) {
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestID()
+	p1.CreateAt = 10
+	p1.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                new("important"),
+			RequestedAck:            new(false),
+			PersistentNotifications: new(true),
+		},
+	}
+
+	_, errIdx, err := ss.Post().SaveMultiple(rctx, []*model.Post{&p1})
+	require.NoError(t, err)
+	require.Equal(t, -1, errIdx)
+
+	defer ss.Post().PermanentDeleteByChannel(rctx, p1.ChannelId)
+	defer ss.PostPersistentNotification().Delete([]string{p1.Id})
+
+	// Update from 0 value
+	now := model.GetTimeForMillis(model.GetMillis())
+	delta := 2 * time.Second
+	err = ss.PostPersistentNotification().UpdateLastActivity([]string{p1.Id})
+	require.NoError(t, err)
+
+	pn, err := ss.PostPersistentNotification().Get(model.GetPersistentNotificationsPostsParams{
+		MaxTime:      model.GetMillisForTime(now.Add(delta)),
+		MaxSentCount: 60,
+	})
+	require.NoError(t, err)
+	require.Len(t, pn, 1)
+	assert.WithinDuration(t, now, model.GetTimeForMillis(pn[0].LastSentAt), delta)
+
+	time.Sleep(time.Second)
+
+	// Update from non-zero value
+	now = model.GetTimeForMillis(model.GetMillis())
+	delta = 2 * time.Second
+	err = ss.PostPersistentNotification().UpdateLastActivity([]string{p1.Id})
+	require.NoError(t, err)
+
+	pn, err = ss.PostPersistentNotification().Get(model.GetPersistentNotificationsPostsParams{
+		MaxTime:      model.GetMillisForTime(now.Add(delta)),
+		MaxSentCount: 60,
+	})
+	require.NoError(t, err)
+	require.Len(t, pn, 1)
+	assert.WithinDuration(t, now, model.GetTimeForMillis(pn[0].LastSentAt), delta)
+}
+
+func testPostPersistentNotificationStoreDelete(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("Delete", func(t *testing.T) {
+		p1 := model.Post{}
+		p1.ChannelId = model.NewId()
+		p1.UserId = model.NewId()
+		p1.Message = NewTestID()
+		p1.CreateAt = 10
+		p1.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                new("important"),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p2 := model.Post{}
+		p2.ChannelId = p1.ChannelId
+		p2.UserId = model.NewId()
+		p2.Message = NewTestID()
+		p2.CreateAt = 20
+		p2.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                model.NewPointer(model.PostPriorityUrgent),
+				RequestedAck:            new(true),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p3 := model.Post{}
+		p3.ChannelId = p1.ChannelId
+		p3.UserId = model.NewId()
+		p3.Message = NewTestID()
+		p3.CreateAt = 30
+		p3.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                model.NewPointer(model.PostPriorityUrgent),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		_, errIdx, err := ss.Post().SaveMultiple(rctx, []*model.Post{&p1, &p2, &p3})
+		require.NoError(t, err)
+		require.Equal(t, -1, errIdx)
+
+		defer ss.Post().PermanentDeleteByChannel(rctx, p1.ChannelId)
+		defer ss.PostPersistentNotification().Delete([]string{p1.Id, p2.Id, p3.Id})
+
+		err = ss.PostPersistentNotification().Delete([]string{p1.Id, p3.Id})
+		require.NoError(t, err)
+
+		pn, err := ss.PostPersistentNotification().Get(model.GetPersistentNotificationsPostsParams{
+			MaxTime:      100,
+			MaxSentCount: 6,
+			PerPage:      20,
+		})
+		require.NoError(t, err)
+		require.Len(t, pn, 1)
+		assert.Equal(t, p2.Id, pn[0].PostId)
+	})
+
+	t.Run("Delete By Channel", func(t *testing.T) {
+		p1 := model.Post{}
+		p1.ChannelId = model.NewId()
+		p1.UserId = model.NewId()
+		p1.Message = NewTestID()
+		p1.CreateAt = 10
+		p1.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                new("important"),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p2 := model.Post{}
+		p2.ChannelId = p1.ChannelId
+		p2.UserId = model.NewId()
+		p2.Message = NewTestID()
+		p2.CreateAt = 20
+		p2.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                model.NewPointer(model.PostPriorityUrgent),
+				RequestedAck:            new(true),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p3 := model.Post{}
+		p3.ChannelId = p1.ChannelId
+		p3.UserId = model.NewId()
+		p3.Message = NewTestID()
+		p3.CreateAt = 30
+		p3.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                model.NewPointer(model.PostPriorityUrgent),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p4 := model.Post{}
+		p4.ChannelId = model.NewId()
+		p4.UserId = model.NewId()
+		p4.Message = NewTestID()
+		p4.CreateAt = 40
+		p4.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                new("important"),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p5 := model.Post{}
+		p5.ChannelId = p4.ChannelId
+		p5.UserId = model.NewId()
+		p5.Message = NewTestID()
+		p5.CreateAt = 50
+		p5.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                new("important"),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		_, errIdx, err := ss.Post().SaveMultiple(rctx, []*model.Post{&p1, &p2, &p3, &p4, &p5})
+		require.NoError(t, err)
+		require.Equal(t, -1, errIdx)
+
+		defer ss.Post().PermanentDeleteByChannel(rctx, p1.ChannelId)
+		defer ss.Post().PermanentDeleteByChannel(rctx, p4.ChannelId)
+		defer ss.PostPersistentNotification().Delete([]string{p1.Id, p2.Id, p3.Id, p4.Id, p5.Id})
+
+		err = ss.PostPersistentNotification().DeleteByChannel([]string{p1.ChannelId})
+		require.NoError(t, err)
+
+		pn, err := ss.PostPersistentNotification().Get(model.GetPersistentNotificationsPostsParams{
+			MaxTime:      100,
+			MaxSentCount: 6,
+			PerPage:      20,
+		})
+		require.NoError(t, err)
+		require.Len(t, pn, 2)
+		assert.ElementsMatch(t, []string{p4.Id, p5.Id}, []string{pn[0].PostId, pn[1].PostId})
+	})
+
+	t.Run("Delete By Team", func(t *testing.T) {
+		t1 := &model.Team{DisplayName: "t1", Name: NewTestID(), Email: MakeEmail(), Type: model.TeamOpen}
+		_, err := ss.Team().Save(t1)
+		require.NoError(t, err)
+		t2 := &model.Team{DisplayName: "t2", Name: NewTestID(), Email: MakeEmail(), Type: model.TeamOpen}
+		_, err = ss.Team().Save(t2)
+		require.NoError(t, err)
+
+		c1 := &model.Channel{TeamId: t1.Id, Name: model.NewId(), DisplayName: "c1", Type: model.ChannelTypeOpen}
+		_, err = ss.Channel().Save(rctx, c1, -1)
+		require.NoError(t, err)
+		c2 := &model.Channel{TeamId: t1.Id, Name: model.NewId(), DisplayName: "c2", Type: model.ChannelTypeOpen}
+		_, err = ss.Channel().Save(rctx, c2, -1)
+		require.NoError(t, err)
+		c3 := &model.Channel{TeamId: t2.Id, Name: model.NewId(), DisplayName: "c1", Type: model.ChannelTypeOpen}
+		_, err = ss.Channel().Save(rctx, c3, -1)
+		require.NoError(t, err)
+
+		p1 := model.Post{}
+		p1.ChannelId = c1.Id
+		p1.UserId = model.NewId()
+		p1.Message = NewTestID()
+		p1.CreateAt = 10
+		p1.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                new("important"),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p2 := model.Post{}
+		p2.ChannelId = p1.ChannelId
+		p2.UserId = model.NewId()
+		p2.Message = NewTestID()
+		p2.CreateAt = 20
+		p2.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                model.NewPointer(model.PostPriorityUrgent),
+				RequestedAck:            new(true),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p3 := model.Post{}
+		p3.ChannelId = c2.Id
+		p3.UserId = model.NewId()
+		p3.Message = NewTestID()
+		p3.CreateAt = 30
+		p3.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                model.NewPointer(model.PostPriorityUrgent),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p4 := model.Post{}
+		p4.ChannelId = c3.Id
+		p4.UserId = model.NewId()
+		p4.Message = NewTestID()
+		p4.CreateAt = 40
+		p4.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                new("important"),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p5 := model.Post{}
+		p5.ChannelId = p4.ChannelId
+		p5.UserId = model.NewId()
+		p5.Message = NewTestID()
+		p5.CreateAt = 50
+		p5.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                new("important"),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		_, errIdx, err := ss.Post().SaveMultiple(rctx, []*model.Post{&p1, &p2, &p3, &p4, &p5})
+		require.NoError(t, err)
+		require.Equal(t, -1, errIdx)
+
+		defer ss.Post().PermanentDeleteByChannel(rctx, c1.Id)
+		defer ss.Post().PermanentDeleteByChannel(rctx, c2.Id)
+		defer ss.Post().PermanentDeleteByChannel(rctx, c3.Id)
+		defer ss.Channel().PermanentDeleteByTeam(t1.Id)
+		defer ss.Channel().PermanentDeleteByTeam(t2.Id)
+		defer ss.Team().PermanentDelete(t1.Id)
+		defer ss.Team().PermanentDelete(t2.Id)
+		defer ss.PostPersistentNotification().Delete([]string{p1.Id, p2.Id, p3.Id, p4.Id, p5.Id})
+
+		err = ss.PostPersistentNotification().DeleteByTeam([]string{t1.Id})
+		require.NoError(t, err)
+
+		pn, err := ss.PostPersistentNotification().Get(model.GetPersistentNotificationsPostsParams{
+			MaxTime:      100,
+			MaxSentCount: 6,
+			PerPage:      20,
+		})
+		require.NoError(t, err)
+		require.Len(t, pn, 2)
+		assert.ElementsMatch(t, []string{p4.Id, p5.Id}, []string{pn[0].PostId, pn[1].PostId})
+	})
+}

server/channels/store/storetest/post_priority_store.go

@@ -0,0 +1,73 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"database/sql"
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestPostPriorityStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("GetForPost", func(t *testing.T) { testPostPriorityStoreGetForPost(t, rctx, ss) })
+}
+
+func testPostPriorityStoreGetForPost(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("Save post priority when in post's metadata", func(t *testing.T) {
+		p1 := model.Post{}
+		p1.ChannelId = model.NewId()
+		p1.UserId = model.NewId()
+		p1.Message = NewTestID()
+		p1.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                new("important"),
+				RequestedAck:            new(true),
+				PersistentNotifications: new(false),
+			},
+		}
+
+		p2 := model.Post{}
+		p2.ChannelId = model.NewId()
+		p2.UserId = model.NewId()
+		p2.Message = NewTestID()
+		p2.Metadata = &model.PostMetadata{
+			Priority: &model.PostPriority{
+				Priority:                model.NewPointer(model.PostPriorityUrgent),
+				RequestedAck:            new(false),
+				PersistentNotifications: new(true),
+			},
+		}
+
+		p3 := model.Post{}
+		p3.ChannelId = model.NewId()
+		p3.UserId = model.NewId()
+		p3.Message = NewTestID()
+
+		_, errIdx, err := ss.Post().SaveMultiple(rctx, []*model.Post{&p1, &p2, &p3})
+		require.NoError(t, err)
+		require.Equal(t, -1, errIdx)
+
+		pp1, err := ss.PostPriority().GetForPost(p1.Id)
+		require.NoError(t, err)
+		assert.Equal(t, "important", *pp1.Priority)
+		assert.Equal(t, true, *pp1.RequestedAck)
+		assert.Equal(t, false, *pp1.PersistentNotifications)
+
+		pp2, err := ss.PostPriority().GetForPost(p2.Id)
+		require.NoError(t, err)
+		assert.Equal(t, model.PostPriorityUrgent, *pp2.Priority)
+		assert.Equal(t, false, *pp2.RequestedAck)
+		assert.Equal(t, true, *pp2.PersistentNotifications)
+
+		_, err = ss.PostPriority().GetForPost(p3.Id)
+		assert.True(t, errors.Is(err, sql.ErrNoRows))
+	})
+}

server/channels/store/storetest/preference_store.go

@@ -0,0 +1,645 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestPreferenceStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
+	t.Run("PreferenceSave", func(t *testing.T) { testPreferenceSave(t, rctx, ss) })
+	t.Run("PreferenceGet", func(t *testing.T) { testPreferenceGet(t, rctx, ss) })
+	t.Run("PreferenceGetCategory", func(t *testing.T) { testPreferenceGetCategory(t, rctx, ss) })
+	t.Run("PreferenceGetCategoryAndName", func(t *testing.T) { testPreferenceGetCategoryAndName(t, rctx, ss) })
+	t.Run("PreferenceGetAll", func(t *testing.T) { testPreferenceGetAll(t, rctx, ss) })
+	t.Run("PreferenceDeleteByUser", func(t *testing.T) { testPreferenceDeleteByUser(t, rctx, ss) })
+	t.Run("PreferenceDelete", func(t *testing.T) { testPreferenceDelete(t, rctx, ss) })
+	t.Run("PreferenceDeleteCategory", func(t *testing.T) { testPreferenceDeleteCategory(t, rctx, ss) })
+	t.Run("PreferenceDeleteCategoryAndName", func(t *testing.T) { testPreferenceDeleteCategoryAndName(t, rctx, ss) })
+	t.Run("PreferenceDeleteOrphanedRows", func(t *testing.T) { testPreferenceDeleteOrphanedRows(t, rctx, ss) })
+	t.Run("PreferenceCleanupFlagsBatch", func(t *testing.T) { testPreferenceCleanupFlagsBatch(t, rctx, ss) })
+	t.Run("PreferenceDeleteInvalidVisibleDmsGms", func(t *testing.T) { testDeleteInvalidVisibleDmsGms(t, rctx, ss, s) })
+}
+
+func testPreferenceSave(t *testing.T, _ request.CTX, ss store.Store) {
+	id := model.NewId()
+
+	preferences := model.Preferences{
+		{
+			UserId:   id,
+			Category: model.PreferenceCategoryDirectChannelShow,
+			Name:     model.NewId(),
+			Value:    "value1a",
+		},
+		{
+			UserId:   id,
+			Category: model.PreferenceCategoryDirectChannelShow,
+			Name:     model.NewId(),
+			Value:    "value1b",
+		},
+	}
+	err := ss.Preference().Save(preferences)
+	require.NoError(t, err, "saving preference returned error")
+
+	for _, preference := range preferences {
+		data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
+		require.Equal(t, data, &preference, "got incorrect preference after first Save")
+	}
+
+	preferences[0].Value = "value2a"
+	preferences[1].Value = "value2b"
+	err = ss.Preference().Save(preferences)
+	require.NoError(t, err, "saving preference returned error")
+
+	for _, preference := range preferences {
+		data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
+		require.Equal(t, data, &preference, "got incorrect preference after second Save")
+	}
+}
+
+func testPreferenceGet(t *testing.T, _ request.CTX, ss store.Store) {
+	userId := model.NewId()
+	category := model.PreferenceCategoryDirectChannelShow
+	name := model.NewId()
+
+	preferences := model.Preferences{
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     name,
+		},
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     model.NewId(),
+		},
+		{
+			UserId:   userId,
+			Category: model.NewId(),
+			Name:     name,
+		},
+		{
+			UserId:   model.NewId(),
+			Category: category,
+			Name:     name,
+		},
+	}
+
+	err := ss.Preference().Save(preferences)
+	require.NoError(t, err)
+
+	data, err := ss.Preference().Get(userId, category, name)
+	require.NoError(t, err)
+	require.Equal(t, &preferences[0], data, "got incorrect preference")
+
+	// make sure getting a missing preference fails
+	_, err = ss.Preference().Get(model.NewId(), model.NewId(), model.NewId())
+	require.Error(t, err, "no error on getting a missing preference")
+}
+
+func testPreferenceGetCategoryAndName(t *testing.T, _ request.CTX, ss store.Store) {
+	userId := model.NewId()
+	category := model.PreferenceCategoryGroupChannelShow
+	name := model.NewId()
+
+	preferences := model.Preferences{
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     name,
+			Value:    "user1",
+		},
+		// same category/name, different user
+		{
+			UserId:   model.NewId(),
+			Category: category,
+			Name:     name,
+			Value:    "otherUser",
+		},
+		// same user/name, different category
+		{
+			UserId:   userId,
+			Category: model.NewId(),
+			Name:     name,
+			Value:    "",
+		},
+		// same user/category, different name
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     model.NewId(),
+			Value:    "",
+		},
+	}
+
+	err := ss.Preference().Save(preferences)
+	require.NoError(t, err)
+
+	actualPreferences, err := ss.Preference().GetCategoryAndName(category, name)
+	require.NoError(t, err)
+	assert.Equal(t, 2, len(actualPreferences), "got the wrong number of preferences")
+
+	for _, preference := range preferences {
+		// Preferences with empty values aren't expected.
+		if preference.Value == "" {
+			continue
+		}
+
+		found := false
+		for _, actualPreference := range actualPreferences {
+			if actualPreference == preference {
+				found = true
+			}
+		}
+
+		assert.True(t, found, "didnt find preference with value %s", preference.Value)
+	}
+
+	// make sure getting a missing preference category and name doesn't fail
+	actualPreferences, err = ss.Preference().GetCategoryAndName(model.NewId(), model.NewId())
+	require.NoError(t, err)
+	require.Equal(t, 0, len(actualPreferences), "shouldn't have got any preferences")
+}
+
+func testPreferenceGetCategory(t *testing.T, _ request.CTX, ss store.Store) {
+	userId := model.NewId()
+	category := model.PreferenceCategoryDirectChannelShow
+	name := model.NewId()
+
+	preferences := model.Preferences{
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     name,
+		},
+		// same user/category, different name
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     model.NewId(),
+		},
+		// same user/name, different category
+		{
+			UserId:   userId,
+			Category: model.NewId(),
+			Name:     name,
+		},
+		// same name/category, different user
+		{
+			UserId:   model.NewId(),
+			Category: category,
+			Name:     name,
+		},
+	}
+
+	err := ss.Preference().Save(preferences)
+	require.NoError(t, err)
+
+	preferencesByCategory, err := ss.Preference().GetCategory(userId, category)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(preferencesByCategory), "got the wrong number of preferences")
+	require.True(
+		t,
+		((preferencesByCategory[0] == preferences[0] && preferencesByCategory[1] == preferences[1]) || (preferencesByCategory[0] == preferences[1] && preferencesByCategory[1] == preferences[0])),
+		"got incorrect preferences",
+	)
+
+	// make sure getting a missing preference category doesn't fail
+	preferencesByCategory, err = ss.Preference().GetCategory(model.NewId(), model.NewId())
+	require.NoError(t, err)
+	require.Equal(t, 0, len(preferencesByCategory), "shouldn't have got any preferences")
+}
+
+func testPreferenceGetAll(t *testing.T, _ request.CTX, ss store.Store) {
+	userId := model.NewId()
+	category := model.PreferenceCategoryDirectChannelShow
+	name := model.NewId()
+
+	preferences := model.Preferences{
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     name,
+		},
+		// same user/category, different name
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     model.NewId(),
+		},
+		// same user/name, different category
+		{
+			UserId:   userId,
+			Category: model.NewId(),
+			Name:     name,
+		},
+		// same name/category, different user
+		{
+			UserId:   model.NewId(),
+			Category: category,
+			Name:     name,
+		},
+	}
+
+	err := ss.Preference().Save(preferences)
+	require.NoError(t, err)
+
+	result, err := ss.Preference().GetAll(userId)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(result), "got the wrong number of preferences")
+
+	for i := range 3 {
+		assert.Falsef(t, result[0] != preferences[i] && result[1] != preferences[i] && result[2] != preferences[i], "got incorrect preferences")
+	}
+}
+
+func testPreferenceDeleteByUser(t *testing.T, _ request.CTX, ss store.Store) {
+	userId := model.NewId()
+	category := model.PreferenceCategoryDirectChannelShow
+	name := model.NewId()
+
+	preferences := model.Preferences{
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     name,
+		},
+		// same user/category, different name
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     model.NewId(),
+		},
+		// same user/name, different category
+		{
+			UserId:   userId,
+			Category: model.NewId(),
+			Name:     name,
+		},
+		// same name/category, different user
+		{
+			UserId:   model.NewId(),
+			Category: category,
+			Name:     name,
+		},
+	}
+
+	err := ss.Preference().Save(preferences)
+	require.NoError(t, err)
+
+	err = ss.Preference().PermanentDeleteByUser(userId)
+	require.NoError(t, err)
+}
+
+func testPreferenceDelete(t *testing.T, _ request.CTX, ss store.Store) {
+	preference := model.Preference{
+		UserId:   model.NewId(),
+		Category: model.PreferenceCategoryDirectChannelShow,
+		Name:     model.NewId(),
+		Value:    "value1a",
+	}
+
+	err := ss.Preference().Save(model.Preferences{preference})
+	require.NoError(t, err)
+
+	preferences, err := ss.Preference().GetAll(preference.UserId)
+	require.NoError(t, err)
+	assert.Len(t, preferences, 1, "should've returned 1 preference")
+
+	err = ss.Preference().Delete(preference.UserId, preference.Category, preference.Name)
+	require.NoError(t, err)
+	preferences, err = ss.Preference().GetAll(preference.UserId)
+	require.NoError(t, err)
+	assert.Empty(t, preferences, "should've returned no preferences")
+}
+
+func testPreferenceDeleteCategory(t *testing.T, _ request.CTX, ss store.Store) {
+	category := model.NewId()
+	userId := model.NewId()
+
+	preference1 := model.Preference{
+		UserId:   userId,
+		Category: category,
+		Name:     model.NewId(),
+		Value:    "value1a",
+	}
+
+	preference2 := model.Preference{
+		UserId:   userId,
+		Category: category,
+		Name:     model.NewId(),
+		Value:    "value1a",
+	}
+
+	err := ss.Preference().Save(model.Preferences{preference1, preference2})
+	require.NoError(t, err)
+
+	preferences, err := ss.Preference().GetAll(userId)
+	require.NoError(t, err)
+	assert.Len(t, preferences, 2, "should've returned 2 preferences")
+
+	err = ss.Preference().DeleteCategory(userId, category)
+	require.NoError(t, err)
+
+	preferences, err = ss.Preference().GetAll(userId)
+	require.NoError(t, err)
+	assert.Empty(t, preferences, "should've returned no preferences")
+}
+
+func testPreferenceDeleteCategoryAndName(t *testing.T, _ request.CTX, ss store.Store) {
+	category := model.NewId()
+	name := model.NewId()
+	userId := model.NewId()
+	userId2 := model.NewId()
+
+	preference1 := model.Preference{
+		UserId:   userId,
+		Category: category,
+		Name:     name,
+		Value:    "value1a",
+	}
+
+	preference2 := model.Preference{
+		UserId:   userId2,
+		Category: category,
+		Name:     name,
+		Value:    "value1a",
+	}
+
+	err := ss.Preference().Save(model.Preferences{preference1, preference2})
+	require.NoError(t, err)
+
+	preferences, err := ss.Preference().GetAll(userId)
+	require.NoError(t, err)
+	assert.Len(t, preferences, 1, "should've returned 1 preference")
+
+	preferences, err = ss.Preference().GetAll(userId2)
+	require.NoError(t, err)
+	assert.Len(t, preferences, 1, "should've returned 1 preference")
+
+	err = ss.Preference().DeleteCategoryAndName(category, name)
+	require.NoError(t, err)
+
+	preferences, err = ss.Preference().GetAll(userId)
+	require.NoError(t, err)
+	assert.Empty(t, preferences, "should've returned no preference")
+
+	preferences, err = ss.Preference().GetAll(userId2)
+	require.NoError(t, err)
+	assert.Empty(t, preferences, "should've returned no preference")
+}
+
+func testPreferenceDeleteOrphanedRows(t *testing.T, rctx request.CTX, ss store.Store) {
+	const limit = 1000
+	team, err := ss.Team().Save(&model.Team{
+		DisplayName: "DisplayName",
+		Name:        "team" + model.NewId(),
+		Email:       MakeEmail(),
+		Type:        model.TeamOpen,
+	})
+	require.NoError(t, err)
+	channel, err := ss.Channel().Save(rctx, &model.Channel{
+		TeamId:      team.Id,
+		DisplayName: "DisplayName",
+		Name:        "channel" + model.NewId(),
+		Type:        model.ChannelTypeOpen,
+	}, -1)
+	require.NoError(t, err)
+	category := model.PreferenceCategoryFlaggedPost
+	userId := model.NewId()
+
+	olderPost, err := ss.Post().Save(rctx, &model.Post{
+		ChannelId: channel.Id,
+		UserId:    userId,
+		Message:   "message",
+		CreateAt:  1000,
+	})
+	require.NoError(t, err)
+	newerPost, err := ss.Post().Save(rctx, &model.Post{
+		ChannelId: channel.Id,
+		UserId:    userId,
+		Message:   "message",
+		CreateAt:  3000,
+	})
+	require.NoError(t, err)
+
+	preference1 := model.Preference{
+		UserId:   userId,
+		Category: category,
+		Name:     olderPost.Id,
+		Value:    "true",
+	}
+
+	preference2 := model.Preference{
+		UserId:   userId,
+		Category: category,
+		Name:     newerPost.Id,
+		Value:    "true",
+	}
+
+	nErr := ss.Preference().Save(model.Preferences{preference1, preference2})
+	require.NoError(t, nErr)
+
+	_, _, nErr = ss.Post().PermanentDeleteBatchForRetentionPolicies(model.RetentionPolicyBatchConfigs{
+		Now:                 0,
+		GlobalPolicyEndTime: 2000,
+		Limit:               limit,
+	}, model.RetentionPolicyCursor{})
+	assert.NoError(t, nErr)
+
+	rows, err := ss.RetentionPolicy().GetIdsForDeletionByTableName("Posts", 1000)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(rows))
+
+	// Clean up retention ids table
+	deleted, err := ss.Reaction().DeleteOrphanedRowsByIds(rows[0])
+	require.NoError(t, err)
+	require.Equal(t, int64(0), deleted)
+
+	_, nErr = ss.Preference().DeleteOrphanedRows(limit)
+	assert.NoError(t, nErr)
+
+	_, nErr = ss.Preference().Get(userId, category, preference1.Name)
+	assert.Error(t, nErr, "older preference should have been deleted")
+
+	_, nErr = ss.Preference().Get(userId, category, preference2.Name)
+	assert.NoError(t, nErr, "newer preference should not have been deleted")
+}
+
+func testPreferenceCleanupFlagsBatch(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("Normal cleanup case", func(t *testing.T) {
+		const limit = 100
+		team, err := ss.Team().Save(&model.Team{
+			DisplayName: "DisplayName",
+			Name:        "team" + model.NewId(),
+			Email:       MakeEmail(),
+			Type:        model.TeamOpen,
+		})
+		require.NoError(t, err)
+		channel, err := ss.Channel().Save(rctx, &model.Channel{
+			TeamId:      team.Id,
+			DisplayName: "DisplayName",
+			Name:        "channel" + model.NewId(),
+			Type:        model.ChannelTypeOpen,
+		}, -1)
+		require.NoError(t, err)
+		category := model.PreferenceCategoryFlaggedPost
+		userId := model.NewId()
+
+		// Create two posts: one to delete, one to keep
+		olderPost, err := ss.Post().Save(rctx, &model.Post{
+			ChannelId: channel.Id,
+			UserId:    userId,
+			Message:   "message",
+			CreateAt:  1000,
+		})
+		require.NoError(t, err)
+		newerPost, err := ss.Post().Save(rctx, &model.Post{
+			ChannelId: channel.Id,
+			UserId:    userId,
+			Message:   "message",
+			CreateAt:  3000,
+		})
+		require.NoError(t, err)
+
+		// Create a third post ID that doesn't exist in the Posts table
+		nonExistentPostId := model.NewId()
+
+		// Create preferences flagging all three posts
+		preferences := model.Preferences{
+			{
+				UserId:   userId,
+				Category: category,
+				Name:     olderPost.Id,
+				Value:    "true",
+			},
+			{
+				UserId:   userId,
+				Category: category,
+				Name:     newerPost.Id,
+				Value:    "true",
+			},
+			{
+				UserId:   userId,
+				Category: category,
+				Name:     nonExistentPostId,
+				Value:    "true",
+			},
+		}
+
+		err = ss.Preference().Save(preferences)
+		require.NoError(t, err)
+
+		// Instead of just deleting (soft delete), we'll permanently delete the post
+		// to create a truly orphaned preference
+		err = ss.Post().PermanentDelete(rctx, olderPost.Id)
+		require.NoError(t, err)
+
+		// Verify we have 3 preferences before cleanup
+		prefs, err := ss.Preference().GetCategory(userId, category)
+		require.NoError(t, err)
+		require.Equal(t, 3, len(prefs))
+
+		// Run CleanupFlagsBatch to remove orphaned preferences
+		rowsDeleted, err := ss.Preference().CleanupFlagsBatch(limit)
+		require.NoError(t, err)
+		require.Equal(t, int64(2), rowsDeleted, "should have deleted 2 preferences (one with permanently deleted post and one with non-existent post)")
+
+		// Check that only the preference for the existing post remains
+		prefs, err = ss.Preference().GetCategory(userId, category)
+		require.NoError(t, err)
+		require.Equal(t, 1, len(prefs), "should only have 1 preference left")
+		require.Equal(t, newerPost.Id, prefs[0].Name, "remaining preference should be for the undeleted post")
+	})
+
+	t.Run("Invalid limit case", func(t *testing.T) {
+		// Test with a negative limit which should return an error
+		rowsDeleted, err := ss.Preference().CleanupFlagsBatch(-1)
+		require.Error(t, err, "Expected error for negative limit")
+		require.Equal(t, int64(0), rowsDeleted, "Should not delete any rows when limit is negative")
+		require.Contains(t, err.Error(), "negative limit", "Error message should mention negative limit")
+	})
+}
+
+func testDeleteInvalidVisibleDmsGms(t *testing.T, _ request.CTX, ss store.Store, s SqlStore) {
+	userId1 := model.NewId()
+	userId2 := model.NewId()
+	userId3 := model.NewId()
+	userId4 := model.NewId()
+	category := model.PreferenceCategorySidebarSettings
+	name := model.PreferenceLimitVisibleDmsGms
+
+	preferences := model.Preferences{
+		{
+			UserId:   userId1,
+			Category: category,
+			Name:     name,
+			Value:    "10000",
+		},
+		{
+			UserId:   userId2,
+			Category: category,
+			Name:     name,
+			Value:    "40",
+		},
+		{
+			UserId:   userId3,
+			Category: category,
+			Name:     name,
+			Value:    "invalid",
+		},
+		{
+			UserId:   model.NewId(),
+			Category: category,
+			Name:     name,
+			Value:    "-10",
+		},
+		{
+			UserId:   model.NewId(),
+			Category: category,
+			Name:     name,
+			Value:    "0",
+		},
+		{
+			UserId:   model.NewId(),
+			Category: category,
+			Name:     name,
+			Value:    "00000",
+		},
+		{
+			UserId:   userId4,
+			Category: category,
+			Name:     name,
+			Value:    "20",
+		},
+	}
+
+	// Can't insert with Save methods because the values are invalid
+	_, execerr := s.GetMaster().NamedExec(`
+		INSERT INTO
+		    Preferences(UserId, Category, Name, Value)
+		VALUES
+		    (:UserId, :Category, :Name, :Value);
+	`, preferences)
+	require.NoError(t, execerr)
+
+	count, err := ss.Preference().DeleteInvalidVisibleDmsGms()
+	require.NoError(t, err)
+	assert.Equal(t, int64(5), count)
+
+	preference, err := ss.Preference().Get(userId2, category, name)
+	require.NoError(t, err)
+	require.Equal(t, &preferences[1], preference)
+
+	preference, err = ss.Preference().Get(userId4, category, name)
+	require.NoError(t, err)
+	require.Equal(t, &preferences[6], preference)
+}

server/channels/store/storetest/product_notices_store.go

@@ -0,0 +1,80 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+func TestProductNoticesStore(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("TestAddViewed", func(t *testing.T) { testAddViewed(t, rctx, ss) })
+	t.Run("TestUpdateViewed", func(t *testing.T) { testUpdateViewed(t, rctx, ss) })
+	t.Run("TestClearOld", func(t *testing.T) { testClearOld(t, rctx, ss) })
+}
+
+func testAddViewed(t *testing.T, rctx request.CTX, ss store.Store) {
+	notices := []string{"noticeA", "noticeB"}
+	defer ss.ProductNotices().Clear(notices)
+
+	err := ss.ProductNotices().View("testuser", notices)
+	require.NoError(t, err)
+	err = ss.ProductNotices().View("testuser2", notices)
+	require.NoError(t, err)
+
+	res, err := ss.ProductNotices().GetViews("testuser")
+	require.NoError(t, err)
+	require.Len(t, res, 2)
+}
+
+func testUpdateViewed(t *testing.T, rctx request.CTX, ss store.Store) {
+	noticesA := []string{"noticeA", "noticeB"}
+	noticesB := []string{"noticeB", "noticeC"}
+	defer ss.ProductNotices().Clear(noticesA)
+	defer ss.ProductNotices().Clear(noticesB)
+	// mark two notices
+	err := ss.ProductNotices().View("testuser", noticesA)
+	require.NoError(t, err)
+	// mark one old and one new
+	err = ss.ProductNotices().View("testuser", noticesB)
+	require.NoError(t, err)
+
+	res, err := ss.ProductNotices().GetViews("testuser")
+	require.NoError(t, err)
+	require.Len(t, res, 3)
+
+	// make sure that one B has two views
+	require.Equal(t, res[0].Viewed, int32(1))
+	require.Equal(t, res[1].Viewed, int32(2))
+	require.Equal(t, res[2].Viewed, int32(1))
+
+	// make sure that B's timestamp was updated
+	require.GreaterOrEqual(t, res[1].Timestamp, res[0].Timestamp)
+}
+
+func testClearOld(t *testing.T, rctx request.CTX, ss store.Store) {
+	noticesA := []string{"noticeA", "noticeB"}
+	defer ss.ProductNotices().Clear(noticesA)
+	// mark two notices
+	err := ss.ProductNotices().View("testuser", noticesA)
+	require.NoError(t, err)
+
+	err = ss.ProductNotices().ClearOldNotices(model.ProductNotices{
+		{
+			ID: "noticeA",
+		},
+		{
+			ID: "noticeC",
+		},
+	})
+	require.NoError(t, err)
+	res, err := ss.ProductNotices().GetViews("testuser")
+	require.NoError(t, err)
+	require.Len(t, res, 1)
+}