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

server/channels/app/scheduled_post_job_test.go

@@ -0,0 +1,772 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/i18n"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcessScheduledPosts(t *testing.T) {
+	mainHelper.Parallel(t)
+	t.Run("base case - happy path", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		scheduledAt := model.GetMillis() + 1000
+		scheduledPost1 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is a scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost1)
+		assert.NoError(t, err)
+
+		scheduledPost2 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is second scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err = th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost2)
+		assert.NoError(t, err)
+
+		time.Sleep(1 * time.Second)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		scheduledPosts, err := th.App.Srv().Store().ScheduledPost().GetScheduledPostsForUser(th.Context, th.BasicUser.Id, th.BasicChannel.TeamId)
+		assert.NoError(t, err)
+		assert.Len(t, scheduledPosts, 0)
+	})
+
+	t.Run("advances weekly recurring scheduled post instead of deleting", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		scheduledAt := model.GetMillis() - 1000
+		scheduledPost := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "weekly recurring scheduled post",
+			},
+			ScheduledAt:    scheduledAt,
+			RepeatType:     model.ScheduledPostRepeatTypeWeekly,
+			RepeatTimezone: "UTC",
+		}
+		created, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost)
+		assert.NoError(t, err)
+		require.NotNil(t, created)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		updated, err := th.Server.Store().ScheduledPost().Get(th.Context, created.Id)
+		assert.NoError(t, err)
+		require.NotNil(t, updated)
+		assert.Equal(t, model.ScheduledPostRepeatTypeWeekly, updated.RepeatType)
+		assert.Equal(t, "UTC", updated.RepeatTimezone)
+		assert.Empty(t, updated.ErrorCode)
+		assert.Zero(t, updated.ProcessedAt)
+
+		const weekMs = int64(7 * 24 * 60 * 60 * 1000)
+		assert.InDelta(t, scheduledAt+weekMs, updated.ScheduledAt, float64(60*1000))
+	})
+
+	t.Run("advances multiple weekly recurring scheduled posts", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		scheduledAt := model.GetMillis() - 1000
+		firstScheduledPost := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "first weekly recurring scheduled post",
+			},
+			ScheduledAt:    scheduledAt,
+			RepeatType:     model.ScheduledPostRepeatTypeWeekly,
+			RepeatTimezone: "UTC",
+		}
+		firstCreated, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, firstScheduledPost)
+		require.NoError(t, err)
+		require.NotNil(t, firstCreated)
+
+		secondScheduledPost := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "second weekly recurring scheduled post",
+			},
+			ScheduledAt:    scheduledAt,
+			RepeatType:     model.ScheduledPostRepeatTypeWeekly,
+			RepeatTimezone: "UTC",
+		}
+		secondCreated, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, secondScheduledPost)
+		require.NoError(t, err)
+		require.NotNil(t, secondCreated)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		firstUpdated, err := th.Server.Store().ScheduledPost().Get(th.Context, firstCreated.Id)
+		require.NoError(t, err)
+		require.NotNil(t, firstUpdated)
+		assert.Equal(t, model.ScheduledPostRepeatTypeWeekly, firstUpdated.RepeatType)
+		assert.Empty(t, firstUpdated.ErrorCode)
+		assert.Zero(t, firstUpdated.ProcessedAt)
+		assert.Greater(t, firstUpdated.ScheduledAt, scheduledAt)
+
+		secondUpdated, err := th.Server.Store().ScheduledPost().Get(th.Context, secondCreated.Id)
+		require.NoError(t, err)
+		require.NotNil(t, secondUpdated)
+		assert.Equal(t, model.ScheduledPostRepeatTypeWeekly, secondUpdated.RepeatType)
+		assert.Empty(t, secondUpdated.ErrorCode)
+		assert.Zero(t, secondUpdated.ProcessedAt)
+		assert.Greater(t, secondUpdated.ScheduledAt, scheduledAt)
+	})
+
+	t.Run("advances overdue weekly recurring scheduled post older than one day", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		scheduledAt := model.GetMillis() - (48 * 60 * 60 * 1000)
+		scheduledPost := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "overdue weekly recurring scheduled post",
+			},
+			ScheduledAt:    scheduledAt,
+			RepeatType:     model.ScheduledPostRepeatTypeWeekly,
+			RepeatTimezone: "UTC",
+		}
+		created, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost)
+		assert.NoError(t, err)
+		require.NotNil(t, created)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		updated, err := th.Server.Store().ScheduledPost().Get(th.Context, created.Id)
+		assert.NoError(t, err)
+		require.NotNil(t, updated)
+		assert.Equal(t, model.ScheduledPostRepeatTypeWeekly, updated.RepeatType)
+		assert.Equal(t, "UTC", updated.RepeatTimezone)
+		assert.Empty(t, updated.ErrorCode)
+		assert.Zero(t, updated.ProcessedAt)
+		assert.Greater(t, updated.ScheduledAt, model.GetMillis())
+	})
+
+	t.Run("permanently deletes recurring and one-shot posts when the channel no longer exists", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		scheduledAt := model.GetMillis() - 1000
+		deletedChannelId := model.NewId()
+
+		recurringScheduledPost := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: deletedChannelId,
+				Message:   "recurring scheduled post for a channel that no longer exists",
+			},
+			ScheduledAt:    scheduledAt,
+			RepeatType:     model.ScheduledPostRepeatTypeWeekly,
+			RepeatTimezone: "UTC",
+		}
+		recurringCreated, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, recurringScheduledPost)
+		require.NoError(t, err)
+
+		oneShotScheduledPost := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: deletedChannelId,
+				Message:   "one-shot scheduled post for a channel that no longer exists",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		oneShotCreated, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, oneShotScheduledPost)
+		require.NoError(t, err)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		// Both rows must be permanently deleted: the series ends rather than advancing,
+		// erroring, or being silently reposted on later runs.
+		_, err = th.Server.Store().ScheduledPost().Get(th.Context, recurringCreated.Id)
+		require.Error(t, err)
+		_, err = th.Server.Store().ScheduledPost().Get(th.Context, oneShotCreated.Id)
+		require.Error(t, err)
+	})
+
+	t.Run("marks overdue one-shot posts even when overdue weekly posts move pagination backward", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		now := model.GetMillis()
+		weeklyScheduledAt := now - (48 * 60 * 60 * 1000)
+		oneShotScheduledAt := now - (36 * 60 * 60 * 1000)
+
+		weeklyScheduledPost := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  now,
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "overdue weekly recurring scheduled post",
+			},
+			ScheduledAt:    weeklyScheduledAt,
+			RepeatType:     model.ScheduledPostRepeatTypeWeekly,
+			RepeatTimezone: "UTC",
+		}
+		weeklyCreated, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, weeklyScheduledPost)
+		assert.NoError(t, err)
+		require.NotNil(t, weeklyCreated)
+
+		oneShotScheduledPost := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  now,
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "overdue one-shot scheduled post",
+			},
+			ScheduledAt: oneShotScheduledAt,
+		}
+		oneShotCreated, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, oneShotScheduledPost)
+		assert.NoError(t, err)
+		require.NotNil(t, oneShotCreated)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		weeklyUpdated, err := th.Server.Store().ScheduledPost().Get(th.Context, weeklyCreated.Id)
+		assert.NoError(t, err)
+		require.NotNil(t, weeklyUpdated)
+		assert.Equal(t, model.ScheduledPostRepeatTypeWeekly, weeklyUpdated.RepeatType)
+		assert.Equal(t, "UTC", weeklyUpdated.RepeatTimezone)
+		assert.Empty(t, weeklyUpdated.ErrorCode)
+		assert.Zero(t, weeklyUpdated.ProcessedAt)
+		assert.Greater(t, weeklyUpdated.ScheduledAt, model.GetMillis())
+
+		oneShotUpdated, err := th.Server.Store().ScheduledPost().Get(th.Context, oneShotCreated.Id)
+		assert.NoError(t, err)
+		require.NotNil(t, oneShotUpdated)
+		assert.Equal(t, model.ScheduledPostErrorUnableToSend, oneShotUpdated.ErrorCode)
+		assert.Greater(t, oneShotUpdated.ProcessedAt, int64(0))
+	})
+
+	t.Run("sets error code for archived channel", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		appErr := th.App.DeleteChannel(th.Context, th.BasicChannel, th.BasicUser.Id)
+		assert.Nil(t, appErr)
+
+		scheduledAt := model.GetMillis() - (5 * 60 * 60 * 1000)
+		scheduledPost1 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is a scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost1)
+		assert.NoError(t, err)
+
+		scheduledPost2 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is second scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err = th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost2)
+		assert.NoError(t, err)
+
+		time.Sleep(1 * time.Second)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		// since the channel ID we set in the above created scheduled posts is of a
+		// non-existing channel, the job should have set the appropriate error code for them in the database
+		scheduledPosts, err := th.App.Srv().Store().ScheduledPost().GetScheduledPostsForUser(th.Context, th.BasicUser.Id, th.BasicChannel.TeamId)
+		assert.NoError(t, err)
+		assert.Len(t, scheduledPosts, 2)
+
+		assert.Equal(t, model.ScheduledPostErrorCodeChannelArchived, scheduledPosts[0].ErrorCode)
+		assert.Greater(t, scheduledPosts[0].ProcessedAt, int64(0))
+
+		assert.Equal(t, model.ScheduledPostErrorCodeChannelArchived, scheduledPosts[1].ErrorCode)
+		assert.Greater(t, scheduledPosts[1].ProcessedAt, int64(0))
+	})
+
+	t.Run("sets error code for archived user", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		scheduledAt := model.GetMillis() + 1000
+		scheduledPost1 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is a scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost1)
+		assert.NoError(t, err)
+
+		scheduledPost2 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is second scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err = th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost2)
+		assert.NoError(t, err)
+
+		_, appErr := th.App.UpdateActive(th.Context, th.BasicUser, false)
+		assert.Nil(t, appErr)
+
+		defer func() {
+			_, _ = th.App.UpdateActive(th.Context, th.BasicUser, true)
+		}()
+
+		time.Sleep(1 * time.Second)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		scheduledPosts, err := th.App.Srv().Store().ScheduledPost().GetScheduledPostsForUser(th.Context, th.BasicUser.Id, th.BasicChannel.TeamId)
+		assert.NoError(t, err)
+		assert.Len(t, scheduledPosts, 2)
+
+		assert.Equal(t, model.ScheduledPostErrorCodeUserDeleted, scheduledPosts[0].ErrorCode)
+		assert.Greater(t, scheduledPosts[0].ProcessedAt, int64(0))
+
+		assert.Equal(t, model.ScheduledPostErrorCodeUserDeleted, scheduledPosts[1].ErrorCode)
+		assert.Greater(t, scheduledPosts[1].ProcessedAt, int64(0))
+	})
+
+	t.Run("sets error code when user is not a channel member", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		scheduledAt := model.GetMillis() + 1000
+		scheduledPost1 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is a scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost1)
+		assert.NoError(t, err)
+
+		scheduledPost2 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is second scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err = th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost2)
+		assert.NoError(t, err)
+
+		appErr := th.App.LeaveChannel(th.Context, th.BasicChannel.Id, th.BasicUser.Id)
+		assert.Nil(t, appErr)
+
+		defer func() {
+			_ = th.App.JoinChannel(th.Context, th.BasicChannel, th.BasicUser.Id)
+		}()
+
+		time.Sleep(1 * time.Second)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		scheduledPosts, err := th.App.Srv().Store().ScheduledPost().GetScheduledPostsForUser(th.Context, th.BasicUser.Id, th.BasicChannel.TeamId)
+		assert.NoError(t, err)
+		assert.Len(t, scheduledPosts, 2)
+
+		assert.Equal(t, model.ScheduledPostErrorCodeNoChannelPermission, scheduledPosts[0].ErrorCode)
+		assert.Greater(t, scheduledPosts[0].ProcessedAt, int64(0))
+
+		assert.Equal(t, model.ScheduledPostErrorCodeNoChannelPermission, scheduledPosts[1].ErrorCode)
+		assert.Greater(t, scheduledPosts[1].ProcessedAt, int64(0))
+	})
+
+	t.Run("sets error code when user is not a team member", func(t *testing.T) {
+		th := Setup(t).InitBasic(t)
+
+		th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+		scheduledAt := model.GetMillis() + 1000
+		scheduledPost1 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is a scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost1)
+		assert.NoError(t, err)
+
+		scheduledPost2 := &model.ScheduledPost{
+			Draft: model.Draft{
+				CreateAt:  model.GetMillis(),
+				UserId:    th.BasicUser.Id,
+				ChannelId: th.BasicChannel.Id,
+				Message:   "this is second scheduled post",
+			},
+			ScheduledAt: scheduledAt,
+		}
+		_, err = th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost2)
+		assert.NoError(t, err)
+
+		appErr := th.App.RemoveUserFromTeam(th.Context, th.BasicTeam.Id, th.BasicUser.Id, th.BasicUser.Id)
+		assert.Nil(t, appErr)
+
+		defer func() {
+			_, _, _ = th.App.AddUserToTeam(th.Context, th.BasicTeam.Id, th.BasicUser.Id, th.BasicUser.Id)
+		}()
+
+		time.Sleep(1 * time.Second)
+
+		th.App.ProcessScheduledPosts(th.Context)
+
+		scheduledPosts, err := th.App.Srv().Store().ScheduledPost().GetScheduledPostsForUser(th.Context, th.BasicUser.Id, th.BasicChannel.TeamId)
+		assert.NoError(t, err)
+		assert.Len(t, scheduledPosts, 2)
+
+		assert.Equal(t, model.ScheduledPostErrorCodeNoChannelPermission, scheduledPosts[0].ErrorCode)
+		assert.Greater(t, scheduledPosts[0].ProcessedAt, int64(0))
+
+		assert.Equal(t, model.ScheduledPostErrorCodeNoChannelPermission, scheduledPosts[1].ErrorCode)
+		assert.Greater(t, scheduledPosts[1].ProcessedAt, int64(0))
+	})
+}
+
+func TestProcessScheduledPostsWithSystemPostType(t *testing.T) {
+	mainHelper.Parallel(t)
+
+	testCases := []struct {
+		name      string
+		postType  string
+		published bool
+		// errorCode is the code the job must record when the post is not published. Reserved
+		// system types are rejected up front (ScheduledPostErrorInvalidPost), while case- and
+		// whitespace-based near-misses slip past that check but still fail post validation on
+		// publish (ScheduledPostErrorUnknownError). Empty when the post is expected to publish.
+		errorCode      string
+		repeatType     string
+		repeatTimezone string
+	}{
+		{
+			name:      "generic system post type",
+			postType:  model.PostTypeSystemGeneric,
+			published: false,
+			errorCode: model.ScheduledPostErrorInvalidPost,
+		},
+		{
+			name:           "recurring weekly system post type",
+			postType:       model.PostTypeSystemGeneric,
+			published:      false,
+			errorCode:      model.ScheduledPostErrorInvalidPost,
+			repeatType:     model.ScheduledPostRepeatTypeWeekly,
+			repeatTimezone: "UTC",
+		},
+		{
+			name:      "structured system post type",
+			postType:  model.PostTypeAddToTeam,
+			published: false,
+			errorCode: model.ScheduledPostErrorInvalidPost,
+		},
+		{
+			name:      "bare reserved prefix",
+			postType:  model.PostSystemMessagePrefix,
+			published: false,
+			errorCode: model.ScheduledPostErrorInvalidPost,
+		},
+		{
+			name:      "reserved system type with trailing whitespace",
+			postType:  model.PostTypeSystemGeneric + " ",
+			published: false,
+			errorCode: model.ScheduledPostErrorInvalidPost,
+		},
+		{
+			name:      "reserved prefix with different casing",
+			postType:  "System_generic",
+			published: false,
+			errorCode: model.ScheduledPostErrorUnknownError,
+		},
+		{
+			name:      "reserved prefix behind leading whitespace",
+			postType:  "  " + model.PostTypeSystemGeneric,
+			published: false,
+			errorCode: model.ScheduledPostErrorUnknownError,
+		},
+		{
+			name:      "default post type",
+			postType:  model.PostTypeDefault,
+			published: true,
+		},
+		{
+			name:      "attachment post type",
+			postType:  model.PostTypeMessageAttachment,
+			published: true,
+		},
+		{
+			name:      "custom type containing but not starting with the reserved prefix",
+			postType:  model.PostCustomTypePrefix + model.PostTypeSystemGeneric,
+			published: true,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			th := Setup(t).InitBasic(t)
+
+			th.App.Srv().SetLicense(getLicWithSkuShortName(model.LicenseShortSkuProfessional))
+
+			message := "scheduled post: " + testCase.name
+			scheduledAt := model.GetMillis() - 1000
+			scheduledPost := &model.ScheduledPost{
+				Draft: model.Draft{
+					CreateAt:  model.GetMillis(),
+					UserId:    th.BasicUser.Id,
+					ChannelId: th.BasicChannel.Id,
+					Message:   message,
+					Type:      testCase.postType,
+				},
+				ScheduledAt:    scheduledAt,
+				RepeatType:     testCase.repeatType,
+				RepeatTimezone: testCase.repeatTimezone,
+			}
+			created, err := th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, scheduledPost)
+			require.NoError(t, err)
+			require.NotNil(t, created)
+
+			th.App.ProcessScheduledPosts(th.Context)
+
+			publishedPost := findPublishedPostByMessage(t, th, th.BasicChannel.Id, message)
+
+			if testCase.published {
+				require.NotNil(t, publishedPost, "scheduled post should have been published")
+				assert.Equal(t, testCase.postType, publishedPost.Type)
+				assert.False(t, publishedPost.IsSystemMessage(), "a published scheduled post must never be treated as a system message")
+				return
+			}
+
+			assert.Nil(t, publishedPost, "a scheduled post with a reserved system post type must not be published")
+
+			updated, err := th.Server.Store().ScheduledPost().Get(th.Context, created.Id)
+			if assert.NoError(t, err, "the scheduled post should have been kept with an error code instead of being published") {
+				assert.Equal(t, testCase.errorCode, updated.ErrorCode)
+				if testCase.repeatType != "" {
+					assert.Equal(t, created.ScheduledAt, updated.ScheduledAt, "a series that could not send must not advance to its next occurrence")
+				}
+			}
+
+			// A second job run must not resurrect the post and publish it later.
+			th.App.ProcessScheduledPosts(th.Context)
+			assert.Nil(t, findPublishedPostByMessage(t, th, th.BasicChannel.Id, message), "a scheduled post with a reserved system post type must not publish on a later job run")
+		})
+	}
+}
+
+// findPublishedPostByMessage returns the published post carrying the given message, or nil.
+// Scheduled posts are matched by message because the channel also contains membership system
+// messages created by InitBasic.
+func findPublishedPostByMessage(t *testing.T, th *TestHelper, channelID, message string) *model.Post {
+	t.Helper()
+
+	posts, appErr := th.App.GetPosts(th.Context, channelID, 0, 200)
+	require.Nil(t, appErr)
+
+	for _, post := range posts.Posts {
+		if post.Message == message {
+			return post
+		}
+	}
+
+	return nil
+}
+
+func TestHandleFailedScheduledPosts(t *testing.T) {
+	mainHelper.Parallel(t)
+	th := Setup(t).InitBasic(t)
+
+	t.Run("should handle failed scheduled posts correctly and notify users about failure via system-bot", func(t *testing.T) {
+		rctx := th.Context
+		var err error
+		var appErr *model.AppError
+		var systemBot *model.Bot
+
+		systemBot, appErr = th.App.GetSystemBot(rctx)
+		assert.True(t, appErr == nil)
+		assert.NotNil(t, systemBot)
+
+		user1 := th.BasicUser
+		user2 := th.BasicUser2
+
+		channel1 := th.BasicChannel
+		channel2 := th.CreateChannel(t, th.BasicTeam)
+
+		// Create failed scheduled posts: 1 for user1 and 2 for user2
+		failedScheduledPosts := []*model.ScheduledPost{
+			{
+				Id: model.NewId(),
+				Draft: model.Draft{
+					CreateAt:  model.GetMillis(),
+					UserId:    user1.Id,
+					ChannelId: channel1.Id,
+					Message:   "Failed scheduled post for user 1",
+				},
+				ErrorCode: model.ScheduledPostErrorUnknownError,
+			},
+			{
+				Id: model.NewId(),
+				Draft: model.Draft{
+					CreateAt:  model.GetMillis(),
+					UserId:    user2.Id,
+					ChannelId: channel1.Id,
+					Message:   "Failed scheduled post 1 for user 2",
+				},
+				ErrorCode: model.ScheduledPostErrorCodeNoChannelPermission,
+			},
+			{
+				Id: model.NewId(),
+				Draft: model.Draft{
+					CreateAt:  model.GetMillis(),
+					UserId:    user2.Id,
+					ChannelId: channel2.Id,
+					Message:   "Failed scheduled post 2 for user 2",
+				},
+				ErrorCode: model.ScheduledPostErrorNoChannelMember,
+			},
+		}
+
+		// Save the failed scheduled posts in the store
+		for _, sp := range failedScheduledPosts {
+			_, err = th.Server.Store().ScheduledPost().CreateScheduledPost(th.Context, sp)
+			assert.NoError(t, err)
+		}
+
+		// Mock WebSocket channels for both of the two users
+		messagesUser1, closeWSUser1 := connectFakeWebSocket(t, th, user1.Id, "", []model.WebsocketEventType{model.WebsocketScheduledPostUpdated})
+		defer closeWSUser1()
+
+		messagesUser2, closeWSUser2 := connectFakeWebSocket(t, th, user2.Id, "", []model.WebsocketEventType{model.WebsocketScheduledPostUpdated})
+		defer closeWSUser2()
+
+		th.App.handleFailedScheduledPosts(rctx, failedScheduledPosts)
+
+		// Validate that the WebSocket events for both users are sent and received correctly
+		for i := range failedScheduledPosts {
+			var received *model.WebSocketEvent
+			select {
+			case received = <-messagesUser1:
+				if received.GetBroadcast().UserId == user1.Id {
+					assert.Equal(t, model.WebsocketScheduledPostUpdated, received.EventType())
+				}
+			case received = <-messagesUser2:
+				if received.GetBroadcast().UserId == user2.Id {
+					assert.Equal(t, model.WebsocketScheduledPostUpdated, received.EventType())
+				}
+			case <-time.After(3 * time.Second):
+				t.Errorf("Timeout while waiting for a WebSocket event for scheduled post %d", i+1)
+			}
+		}
+
+		// Helper function to check notifications for a specific user
+		checkUserNotification := func(user *model.User) {
+			// Wait time for notifications to be sent (adding 5 secs because it is run in a separate goroutine)
+			timeout := 5 * time.Second
+			begin := time.Now()
+			channel, appErr := th.App.GetOrCreateDirectChannel(rctx, user.Id, systemBot.UserId)
+			assert.True(t, appErr == nil)
+
+			var posts *model.PostList
+			// wait for the notification to be sent into the channel.
+			// idea is to get the channel and try to find posts, if not, wait 100ms and try again until timeout or there is posts length
+			for {
+				if time.Since(begin) > timeout {
+					break
+				}
+				posts, appErr = th.App.GetPosts(th.Context, channel.Id, 0, 10)
+				assert.True(t, appErr == nil)
+				if len(posts.Posts) > 0 {
+					break
+				}
+				time.Sleep(100 * time.Millisecond)
+			}
+			assert.NotEmpty(t, posts.Posts, "Expected notification for user %s to have been sent", user.Id)
+
+			// Collect failed messages for users
+			var userFailedMessages []*model.ScheduledPost
+			for _, sp := range failedScheduledPosts {
+				if sp.UserId == user.Id {
+					userFailedMessages = append(userFailedMessages, sp)
+				}
+			}
+
+			T := i18n.GetUserTranslations(user.Locale)
+			messageHeader := T("app.scheduled_post.failed_messages", map[string]any{
+				"Count": len(userFailedMessages),
+			})
+
+			// Validate the actual content of the notification posted
+			found := false
+			for _, post := range posts.Posts {
+				if post.UserId == systemBot.UserId && strings.HasPrefix(post.Message, messageHeader) {
+					found = true
+					break
+				}
+			}
+
+			assert.True(t, found, "\nNotification post not found for user %s with expected message prefix. \n Expected: %s \n", user.Id, messageHeader)
+		}
+
+		// Check notifications sent for failed messages for both users
+		checkUserNotification(user1)
+		checkUserNotification(user2)
+	})
+}