mirror of
https://github.com/hanzoai/team.git
synced 2026-09-30 01:57:35 +00:00
Jesse HallamandGitHub
b9d3f89544
* MM-69340: fix NULL Type scan error in Draft.Get() draftSliceColumns() returned "Type" bare; rows created before the v11.3 migration have Type = NULL, causing a scan error when the single- row Get() path tried to read them into a non-nullable Go string. Apply the same COALESCE(Type, '') fix that already existed in GetDraftsForUser(), and add a regression test that inserts a NULL-Type row and asserts Get() succeeds with Type == "". * fix: apply COALESCE only in Get(), not in Upsert columns draftSliceColumns() is used by Upsert's INSERT column list, where COALESCE is not valid syntax. Add draftSelectColumns() which swaps in COALESCE(Type, '') AS Type for the SELECT path only.
1119 lines
35 KiB
Go
1119 lines
35 KiB
Go
// 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 TestDraftStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStore) {
|
|
t.Run("SaveDraft", func(t *testing.T) { testSaveDraft(t, rctx, ss) })
|
|
t.Run("UpdateDraft", func(t *testing.T) { testUpdateDraft(t, rctx, ss) })
|
|
t.Run("DeleteDraft", func(t *testing.T) { testDeleteDraft(t, rctx, ss) })
|
|
t.Run("DeleteDraftsAssociatedWithPost", func(t *testing.T) { testDeleteDraftsAssociatedWithPost(t, rctx, ss) })
|
|
t.Run("GetDraft", func(t *testing.T) { testGetDraft(t, rctx, ss) })
|
|
t.Run("GetDraftsForUser", func(t *testing.T) { testGetDraftsForUser(t, rctx, ss) })
|
|
t.Run("GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration", func(t *testing.T) { testGetLastCreateAtAndUserIDValuesForEmptyDraftsMigration(t, rctx, ss) })
|
|
t.Run("DeleteEmptyDraftsByCreateAtAndUserId", func(t *testing.T) { testDeleteEmptyDraftsByCreateAtAndUserID(t, rctx, ss) })
|
|
t.Run("DeleteOrphanDraftsByCreateAtAndUserId", func(t *testing.T) { testDeleteOrphanDraftsByCreateAtAndUserID(t, rctx, ss) })
|
|
t.Run("PermanentDeleteByUser", func(t *testing.T) { testPermanentDeleteDraftsByUser(t, rctx, ss) })
|
|
}
|
|
|
|
func testSaveDraft(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
user := &model.User{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
channel := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
channel2 := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
member1 := &model.ChannelMember{
|
|
ChannelId: channel.Id,
|
|
UserId: user.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
|
|
member2 := &model.ChannelMember{
|
|
ChannelId: channel2.Id,
|
|
UserId: user.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
|
|
_, err := ss.Channel().SaveMember(rctx, member1)
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Channel().SaveMember(rctx, member2)
|
|
require.NoError(t, err)
|
|
|
|
draft1 := &model.Draft{
|
|
CreateAt: 00001,
|
|
UpdateAt: 00001,
|
|
UserId: user.Id,
|
|
ChannelId: channel.Id,
|
|
Message: "draft1",
|
|
}
|
|
|
|
draft2 := &model.Draft{
|
|
CreateAt: 00005,
|
|
UpdateAt: 00005,
|
|
UserId: user.Id,
|
|
ChannelId: channel2.Id,
|
|
Message: "draft2",
|
|
}
|
|
|
|
t.Run("save drafts", func(t *testing.T) {
|
|
draftResp, err := ss.Draft().Upsert(draft1)
|
|
assert.NoError(t, err)
|
|
|
|
assert.Equal(t, draft1.Message, draftResp.Message)
|
|
assert.Equal(t, draft1.ChannelId, draftResp.ChannelId)
|
|
|
|
draftResp, err = ss.Draft().Upsert(draft2)
|
|
assert.NoError(t, err)
|
|
|
|
assert.Equal(t, draft2.Message, draftResp.Message)
|
|
assert.Equal(t, draft2.ChannelId, draftResp.ChannelId)
|
|
|
|
drafts, err := ss.Draft().GetDraftsForUser(user.Id, "")
|
|
assert.NoError(t, err)
|
|
assert.Len(t, drafts, 2)
|
|
})
|
|
}
|
|
|
|
func testUpdateDraft(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
user := &model.User{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
channel := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
member := &model.ChannelMember{
|
|
ChannelId: channel.Id,
|
|
UserId: user.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
|
|
_, err := ss.Channel().SaveMember(rctx, member)
|
|
require.NoError(t, err)
|
|
|
|
t.Run("update drafts", func(t *testing.T) {
|
|
draft := &model.Draft{
|
|
UserId: user.Id,
|
|
ChannelId: channel.Id,
|
|
Message: "draft",
|
|
}
|
|
_, err := ss.Draft().Upsert(draft)
|
|
assert.NoError(t, err)
|
|
|
|
drafts, err := ss.Draft().GetDraftsForUser(user.Id, "")
|
|
assert.NoError(t, err)
|
|
assert.Len(t, drafts, 1)
|
|
draft1 := drafts[0]
|
|
|
|
assert.Greater(t, draft1.CreateAt, int64(0))
|
|
assert.Equal(t, draft1.UpdateAt, draft1.CreateAt)
|
|
assert.Equal(t, channel.Id, draft1.ChannelId)
|
|
assert.Equal(t, "draft", draft1.Message)
|
|
|
|
updatedDraft := &model.Draft{
|
|
UserId: user.Id,
|
|
ChannelId: channel.Id,
|
|
Message: "updatedDraft",
|
|
}
|
|
_, err = ss.Draft().Upsert(updatedDraft)
|
|
assert.NoError(t, err)
|
|
|
|
drafts, err = ss.Draft().GetDraftsForUser(user.Id, "")
|
|
assert.NoError(t, err)
|
|
assert.Len(t, drafts, 1)
|
|
draft2 := drafts[0]
|
|
|
|
assert.Greater(t, draft2.CreateAt, int64(0))
|
|
assert.Equal(t, "updatedDraft", draft2.Message)
|
|
assert.Equal(t, channel.Id, draft2.ChannelId)
|
|
assert.Equal(t, draft1.CreateAt, draft2.CreateAt)
|
|
})
|
|
}
|
|
|
|
func testDeleteDraft(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
user := &model.User{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
channel := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
channel2 := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
member1 := &model.ChannelMember{
|
|
ChannelId: channel.Id,
|
|
UserId: user.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
|
|
member2 := &model.ChannelMember{
|
|
ChannelId: channel2.Id,
|
|
UserId: user.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
|
|
_, err := ss.Channel().SaveMember(rctx, member1)
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Channel().SaveMember(rctx, member2)
|
|
require.NoError(t, err)
|
|
|
|
draft1 := &model.Draft{
|
|
CreateAt: 00001,
|
|
UpdateAt: 00001,
|
|
UserId: user.Id,
|
|
ChannelId: channel.Id,
|
|
Message: "draft1",
|
|
}
|
|
|
|
draft2 := &model.Draft{
|
|
CreateAt: 00005,
|
|
UpdateAt: 00005,
|
|
UserId: user.Id,
|
|
ChannelId: channel2.Id,
|
|
Message: "draft2",
|
|
}
|
|
|
|
_, err = ss.Draft().Upsert(draft1)
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Draft().Upsert(draft2)
|
|
require.NoError(t, err)
|
|
|
|
t.Run("delete drafts", func(t *testing.T) {
|
|
err := ss.Draft().Delete(user.Id, channel.Id, "")
|
|
assert.NoError(t, err)
|
|
|
|
err = ss.Draft().Delete(user.Id, channel2.Id, "")
|
|
assert.NoError(t, err)
|
|
|
|
_, err = ss.Draft().Get(user.Id, channel.Id, "", false)
|
|
require.Error(t, err)
|
|
assert.IsType(t, &store.ErrNotFound{}, err)
|
|
|
|
_, err = ss.Draft().Get(user.Id, channel2.Id, "", false)
|
|
assert.Error(t, err)
|
|
assert.IsType(t, &store.ErrNotFound{}, err)
|
|
})
|
|
}
|
|
|
|
func testPermanentDeleteDraftsByUser(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
t.Run("should delete all drafts for a given user", func(t *testing.T) {
|
|
userId := model.NewId()
|
|
channel1Id := model.NewId()
|
|
channel2Id := model.NewId()
|
|
|
|
member1 := &model.ChannelMember{
|
|
ChannelId: channel1Id,
|
|
UserId: userId,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
|
|
member2 := &model.ChannelMember{
|
|
ChannelId: channel2Id,
|
|
UserId: userId,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
|
|
_, err := ss.Channel().SaveMember(rctx, member1)
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Channel().SaveMember(rctx, member2)
|
|
require.NoError(t, err)
|
|
|
|
draft1 := &model.Draft{
|
|
CreateAt: model.GetMillis(),
|
|
UpdateAt: model.GetMillis(),
|
|
UserId: userId,
|
|
ChannelId: channel1Id,
|
|
Message: "draft1",
|
|
}
|
|
|
|
draft2 := &model.Draft{
|
|
CreateAt: model.GetMillis(),
|
|
UpdateAt: model.GetMillis(),
|
|
UserId: userId,
|
|
ChannelId: channel2Id,
|
|
Message: "draft2",
|
|
}
|
|
|
|
_, err = ss.Draft().Upsert(draft1)
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Draft().Upsert(draft2)
|
|
require.NoError(t, err)
|
|
|
|
draftsResp, err := ss.Draft().GetDraftsForUser(userId, "")
|
|
assert.NoError(t, err)
|
|
assert.Len(t, draftsResp, 2)
|
|
|
|
// Delete draft for the user
|
|
err = ss.Draft().PermanentDeleteByUser(userId)
|
|
assert.NoError(t, err)
|
|
|
|
// Verify that no drafts exist for the user
|
|
draftsResp, err = ss.Draft().GetDraftsForUser(userId, "")
|
|
assert.NoError(t, err)
|
|
assert.Len(t, draftsResp, 0)
|
|
})
|
|
|
|
t.Run("should not fail if no drafts exist for the user", func(t *testing.T) {
|
|
userId := model.NewId()
|
|
|
|
// Attempt to delete drafts for a user with no drafts
|
|
err := ss.Draft().PermanentDeleteByUser(userId)
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
t.Run("should handle empty user id", func(t *testing.T) {
|
|
err := ss.Draft().PermanentDeleteByUser("")
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
t.Run("should handle non-existing user id", func(t *testing.T) {
|
|
nonExistingUserId := model.NewId()
|
|
err := ss.Draft().PermanentDeleteByUser(nonExistingUserId)
|
|
assert.NoError(t, err)
|
|
})
|
|
}
|
|
|
|
func testGetDraft(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
user := &model.User{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
channel := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
channel2 := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
member1 := &model.ChannelMember{
|
|
ChannelId: channel.Id,
|
|
UserId: user.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
|
|
member2 := &model.ChannelMember{
|
|
ChannelId: channel2.Id,
|
|
UserId: user.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
|
|
_, err := ss.Channel().SaveMember(rctx, member1)
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Channel().SaveMember(rctx, member2)
|
|
require.NoError(t, err)
|
|
|
|
draft1 := &model.Draft{
|
|
CreateAt: 00001,
|
|
UpdateAt: 00001,
|
|
UserId: user.Id,
|
|
ChannelId: channel.Id,
|
|
Message: "draft1",
|
|
}
|
|
|
|
draft2 := &model.Draft{
|
|
CreateAt: 00005,
|
|
UpdateAt: 00005,
|
|
UserId: user.Id,
|
|
ChannelId: channel2.Id,
|
|
Message: "draft2",
|
|
}
|
|
|
|
_, err = ss.Draft().Upsert(draft1)
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Draft().Upsert(draft2)
|
|
require.NoError(t, err)
|
|
|
|
t.Run("get drafts", func(t *testing.T) {
|
|
draftResp, err := ss.Draft().Get(user.Id, channel.Id, "", false)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, draft1.Message, draftResp.Message)
|
|
assert.Equal(t, draft1.ChannelId, draftResp.ChannelId)
|
|
|
|
draftResp, err = ss.Draft().Get(user.Id, channel2.Id, "", false)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, draft2.Message, draftResp.Message)
|
|
assert.Equal(t, draft2.ChannelId, draftResp.ChannelId)
|
|
})
|
|
|
|
t.Run("get draft with NULL type", func(t *testing.T) {
|
|
_, err := ss.GetInternalMasterDB().Exec(
|
|
"UPDATE Drafts SET Type = NULL WHERE UserId = $1 AND ChannelId = $2",
|
|
user.Id, channel.Id,
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
draftResp, err := ss.Draft().Get(user.Id, channel.Id, "", false)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "", draftResp.Type)
|
|
})
|
|
}
|
|
|
|
func testGetDraftsForUser(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
user := &model.User{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
newDraftForUser := func(t *testing.T, user *model.User) *model.Draft {
|
|
t.Helper()
|
|
|
|
channel := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
member := &model.ChannelMember{
|
|
ChannelId: channel.Id,
|
|
UserId: user.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
}
|
|
_, err := ss.Channel().SaveMember(rctx, member)
|
|
require.NoError(t, err)
|
|
|
|
draft := &model.Draft{
|
|
UserId: user.Id,
|
|
ChannelId: channel.Id,
|
|
Message: "draft post",
|
|
}
|
|
insertedDraft, err := ss.Draft().Upsert(draft)
|
|
require.NoError(t, err)
|
|
|
|
return insertedDraft
|
|
}
|
|
|
|
t.Run("get drafts", func(t *testing.T) {
|
|
t.Cleanup(func() { clearDrafts(t, rctx, ss) })
|
|
|
|
draft1 := newDraftForUser(t, user)
|
|
draft2 := newDraftForUser(t, user)
|
|
|
|
draftResp, err := ss.Draft().GetDraftsForUser(user.Id, "")
|
|
assert.NoError(t, err)
|
|
assert.Len(t, draftResp, 2)
|
|
|
|
assert.ElementsMatch(t, []*model.Draft{draft1, draft2}, draftResp)
|
|
})
|
|
|
|
t.Run("get drafts with Type NULL", func(t *testing.T) {
|
|
t.Cleanup(func() { clearDrafts(t, rctx, ss) })
|
|
|
|
draft := newDraftForUser(t, user)
|
|
|
|
// Draft().Upsert() correctly handles empty types, so we need to
|
|
// manually set Type to NULL
|
|
query := "UPDATE Drafts SET Type = NULL WHERE UserId = $1"
|
|
_, err := ss.GetInternalMasterDB().Exec(query, user.Id)
|
|
require.NoError(t, err)
|
|
|
|
draftResp, err := ss.Draft().GetDraftsForUser(user.Id, "")
|
|
assert.NoError(t, err)
|
|
assert.Len(t, draftResp, 1)
|
|
|
|
assert.ElementsMatch(t, []*model.Draft{draft}, draftResp)
|
|
|
|
clearDrafts(t, rctx, ss)
|
|
})
|
|
}
|
|
|
|
func clearDrafts(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
t.Helper()
|
|
|
|
_, err := ss.GetInternalMasterDB().Exec("DELETE FROM Drafts")
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func makeDrafts(t *testing.T, ss store.Store, count int, message string) {
|
|
t.Helper()
|
|
|
|
var delay time.Duration
|
|
if count > 100 {
|
|
// When creating more than one page of drafts, improve the odds we get
|
|
// some results with different CreateAt timetsamps.
|
|
delay = 5 * time.Millisecond
|
|
}
|
|
|
|
for i := 1; i <= count; i++ {
|
|
_, err := ss.Draft().Upsert(&model.Draft{
|
|
CreateAt: model.GetMillis(),
|
|
UpdateAt: model.GetMillis(),
|
|
UserId: model.NewId(),
|
|
ChannelId: model.NewId(),
|
|
Message: message,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
if delay > 0 {
|
|
time.Sleep(delay)
|
|
}
|
|
}
|
|
}
|
|
|
|
func countDrafts(t *testing.T, rctx request.CTX, ss store.Store) int {
|
|
t.Helper()
|
|
|
|
var count int
|
|
err := ss.GetInternalMasterDB().QueryRow("SELECT COUNT(*) FROM Drafts").Scan(&count)
|
|
require.NoError(t, err)
|
|
|
|
return count
|
|
}
|
|
|
|
func countDraftPages(t *testing.T, rctx request.CTX, ss store.Store) int {
|
|
t.Helper()
|
|
|
|
pages := 0
|
|
createAt := int64(0)
|
|
userID := ""
|
|
|
|
for {
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
|
|
if nextCreateAt == 0 && nextUserID == "" {
|
|
break
|
|
}
|
|
|
|
// Ensure we're always making progress.
|
|
if nextCreateAt == createAt {
|
|
require.Greater(t, nextUserID, userID)
|
|
} else {
|
|
require.Greater(t, nextCreateAt, createAt)
|
|
}
|
|
|
|
pages++
|
|
createAt = nextCreateAt
|
|
userID = nextUserID
|
|
}
|
|
|
|
return pages
|
|
}
|
|
|
|
func clearPosts(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
t.Helper()
|
|
|
|
_, err := ss.GetInternalMasterDB().Exec("DELETE FROM Posts")
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func makeDraftsWithNonDeletedPosts(t *testing.T, rctx request.CTX, ss store.Store, count int, message string) {
|
|
t.Helper()
|
|
|
|
for i := 1; i <= count; i++ {
|
|
post, err := ss.Post().Save(rctx, &model.Post{
|
|
CreateAt: model.GetMillis(),
|
|
UpdateAt: model.GetMillis(),
|
|
UserId: model.NewId(),
|
|
ChannelId: model.NewId(),
|
|
Message: message,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Draft().Upsert(&model.Draft{
|
|
CreateAt: model.GetMillis(),
|
|
UpdateAt: model.GetMillis(),
|
|
UserId: post.UserId,
|
|
ChannelId: post.ChannelId,
|
|
RootId: post.Id,
|
|
Message: message,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
if i%100 == 0 {
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
|
|
func makeDraftsWithDeletedPosts(t *testing.T, rctx request.CTX, ss store.Store, count int, message string) {
|
|
t.Helper()
|
|
|
|
for i := 1; i <= count; i++ {
|
|
post, err := ss.Post().Save(rctx, &model.Post{
|
|
CreateAt: model.GetMillis(),
|
|
UpdateAt: model.GetMillis(),
|
|
DeleteAt: model.GetMillis(),
|
|
UserId: model.NewId(),
|
|
ChannelId: model.NewId(),
|
|
Message: message,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Draft().Upsert(&model.Draft{
|
|
CreateAt: model.GetMillis(),
|
|
UpdateAt: model.GetMillis(),
|
|
UserId: post.UserId,
|
|
ChannelId: post.ChannelId,
|
|
RootId: post.Id,
|
|
Message: message,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
if i%100 == 0 {
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
|
|
func testGetLastCreateAtAndUserIDValuesForEmptyDraftsMigration(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
t.Run("no drafts", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
|
|
createAt, userID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(0, "")
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, createAt)
|
|
assert.Equal(t, "", userID)
|
|
|
|
assert.Equal(t, 0, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
})
|
|
|
|
t.Run("single page", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
|
|
makeDrafts(t, ss, 100, model.NewRandomString(16))
|
|
assert.Equal(t, 1, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
})
|
|
|
|
t.Run("multiple pages", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
|
|
makeDrafts(t, ss, 300, model.NewRandomString(16))
|
|
assert.Equal(t, 3, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
})
|
|
}
|
|
|
|
func testDeleteEmptyDraftsByCreateAtAndUserID(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
t.Run("nil parameters", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
|
|
err := ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(0, "")
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("delete single page, all empty", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
makeDrafts(t, ss, 100, "")
|
|
|
|
createAt, userID := int64(0), ""
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 0, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
|
|
t.Run("delete multiple pages, all empty", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
makeDrafts(t, ss, 300, "")
|
|
|
|
createAt, userID := int64(0), ""
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 2, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 1, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 0, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
|
|
t.Run("delete multiple pages, some empty", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
makeDrafts(t, ss, 50, "")
|
|
makeDrafts(t, ss, 50, "message")
|
|
makeDrafts(t, ss, 50, "")
|
|
makeDrafts(t, ss, 50, "message")
|
|
makeDrafts(t, ss, 50, "")
|
|
makeDrafts(t, ss, 50, "message")
|
|
makeDrafts(t, ss, 50, "")
|
|
makeDrafts(t, ss, 50, "message")
|
|
makeDrafts(t, ss, 50, "message")
|
|
makeDrafts(t, ss, 50, "message")
|
|
|
|
// Verify initially 5 pages
|
|
assert.Equal(t, 5, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
createAt, userID := int64(0), ""
|
|
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Only deleted 50, so still 5 pages
|
|
assert.Equal(t, 5, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Now deleted 100, so down to 4 pages
|
|
assert.Equal(t, 4, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Only deleted 150 now, so still 4 pages
|
|
assert.Equal(t, 4, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Now deleted all 200 empty messages, so down to 3 pages
|
|
assert.Equal(t, 3, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
// Keep going through all pages to verify nothing else gets deleted.
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteEmptyDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Verify we're done iterating
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
}
|
|
|
|
func testDeleteOrphanDraftsByCreateAtAndUserID(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
t.Run("nil parameters", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
clearPosts(t, rctx, ss)
|
|
|
|
err := ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(0, "")
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("delete single page, drafts with no post", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
clearPosts(t, rctx, ss)
|
|
|
|
makeDrafts(t, ss, 100, "Okay")
|
|
|
|
createAt, userID := int64(0), ""
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 0, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
|
|
t.Run("delete multiple pages, drafts with no post", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
clearPosts(t, rctx, ss)
|
|
|
|
makeDrafts(t, ss, 300, "Okay")
|
|
|
|
createAt, userID := int64(0), ""
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 2, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 1, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 0, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
|
|
t.Run("delete single page, drafts with deleted post", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
clearPosts(t, rctx, ss)
|
|
|
|
makeDraftsWithDeletedPosts(t, rctx, ss, 100, "Okay")
|
|
|
|
createAt, userID := int64(0), ""
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 0, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
|
|
t.Run("delete multiple pages, drafts with deleted post", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
clearPosts(t, rctx, ss)
|
|
|
|
makeDraftsWithDeletedPosts(t, rctx, ss, 300, "Okay")
|
|
|
|
createAt, userID := int64(0), ""
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 2, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 1, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 0, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
|
|
t.Run("delete single page, drafts with non deleted post", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
clearPosts(t, rctx, ss)
|
|
|
|
makeDraftsWithNonDeletedPosts(t, rctx, ss, 100, "Okay")
|
|
|
|
createAt, userID := int64(0), ""
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 100, countDrafts(t, rctx, ss), "incorrect number of drafts")
|
|
assert.Equal(t, 1, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
|
|
t.Run("delete multiple pages, drafts with non deleted post", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
clearPosts(t, rctx, ss)
|
|
|
|
makeDraftsWithNonDeletedPosts(t, rctx, ss, 300, "Okay")
|
|
|
|
createAt, userID := int64(0), ""
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 300, countDrafts(t, rctx, ss), "incorrect number of drafts")
|
|
assert.Equal(t, 3, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 300, countDrafts(t, rctx, ss), "incorrect number of drafts")
|
|
assert.Equal(t, 3, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
assert.Equal(t, 300, countDrafts(t, rctx, ss), "incorrect number of drafts")
|
|
assert.Equal(t, 3, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
|
|
// This test is a bit more complicated, but it's the most realistic scenario and covers all the remaining cases
|
|
t.Run("delete multiple pages, some drafts with deleted post, some with non deleted post, and some with no post", func(t *testing.T) {
|
|
clearDrafts(t, rctx, ss)
|
|
clearPosts(t, rctx, ss)
|
|
|
|
// 50 drafts will be deleted from this page
|
|
makeDrafts(t, ss, 50, "Yup")
|
|
makeDraftsWithNonDeletedPosts(t, rctx, ss, 50, "Okay")
|
|
|
|
// 100 drafts will be deleted from this page
|
|
makeDrafts(t, ss, 50, "Yup")
|
|
makeDraftsWithDeletedPosts(t, rctx, ss, 50, "Okay")
|
|
|
|
// 50 drafts will be deleted from this page
|
|
makeDraftsWithDeletedPosts(t, rctx, ss, 50, "Okay")
|
|
makeDraftsWithNonDeletedPosts(t, rctx, ss, 50, "Okay")
|
|
|
|
// 70 drafts will be deleted from this page
|
|
makeDrafts(t, ss, 40, "Yup")
|
|
makeDraftsWithDeletedPosts(t, rctx, ss, 30, "Okay")
|
|
makeDraftsWithNonDeletedPosts(t, rctx, ss, 30, "Okay")
|
|
|
|
// No drafts will be deleted from this page
|
|
makeDraftsWithNonDeletedPosts(t, rctx, ss, 100, "Okay")
|
|
|
|
// Verify initially 5 pages with 500 drafts
|
|
assert.Equal(t, 5, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
assert.Equal(t, 500, countDrafts(t, rctx, ss), "incorrect number of drafts")
|
|
|
|
createAt, userID := int64(0), ""
|
|
|
|
nextCreateAt, nextUserID, err := ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Only deleted 50, so still 5 pages
|
|
assert.Equal(t, 5, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
assert.Equal(t, 450, countDrafts(t, rctx, ss), "incorrect number of drafts")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Now deleted 150, so down to 4 pages
|
|
assert.Equal(t, 4, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
assert.Equal(t, 350, countDrafts(t, rctx, ss), "incorrect number of drafts")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Now deleted 200 now, so down to 3 pages
|
|
assert.Equal(t, 3, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
assert.Equal(t, 300, countDrafts(t, rctx, ss), "incorrect number of drafts")
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Now deleted 270 empty messages, so still 3 pages
|
|
assert.Equal(t, 3, countDraftPages(t, rctx, ss), "incorrect number of pages")
|
|
assert.Equal(t, 230, countDrafts(t, rctx, ss), "incorrect number of drafts")
|
|
|
|
// Keep going through all pages to verify nothing else gets deleted.
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
err = ss.Draft().DeleteOrphanDraftsByCreateAtAndUserId(createAt, userID)
|
|
require.NoError(t, err)
|
|
createAt, userID = nextCreateAt, nextUserID
|
|
|
|
// Verify we're done iterating
|
|
|
|
nextCreateAt, nextUserID, err = ss.Draft().GetLastCreateAtAndUserIdValuesForEmptyDraftsMigration(createAt, userID)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 0, nextCreateAt, "should have finished iterating through drafts")
|
|
assert.Equal(t, "", nextUserID, "should have finished iterating through drafts")
|
|
})
|
|
}
|
|
|
|
func testDeleteDraftsAssociatedWithPost(t *testing.T, rctx request.CTX, ss store.Store) {
|
|
user1 := &model.User{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
user2 := &model.User{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
channel1 := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
channel2 := &model.Channel{
|
|
Id: model.NewId(),
|
|
}
|
|
|
|
_, err := ss.Channel().SaveMember(rctx, &model.ChannelMember{
|
|
ChannelId: channel1.Id,
|
|
UserId: user1.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Channel().SaveMember(rctx, &model.ChannelMember{
|
|
ChannelId: channel2.Id,
|
|
UserId: user2.Id,
|
|
NotifyProps: model.GetDefaultChannelNotifyProps(),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
post1, err := ss.Post().Save(rctx, &model.Post{
|
|
UserId: user1.Id,
|
|
ChannelId: channel1.Id,
|
|
Message: "post1",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
post2, err := ss.Post().Save(rctx, &model.Post{
|
|
UserId: user2.Id,
|
|
ChannelId: channel2.Id,
|
|
Message: "post2",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Draft().Upsert(&model.Draft{
|
|
UserId: user1.Id,
|
|
ChannelId: channel1.Id,
|
|
RootId: post1.Id,
|
|
Message: "draft1",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Draft().Upsert(&model.Draft{
|
|
UserId: user2.Id,
|
|
ChannelId: channel1.Id,
|
|
RootId: post1.Id,
|
|
Message: "draft2",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
draft3, err := ss.Draft().Upsert(&model.Draft{
|
|
UserId: user1.Id,
|
|
ChannelId: channel2.Id,
|
|
RootId: post2.Id,
|
|
Message: "draft3",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
draft4, err := ss.Draft().Upsert(&model.Draft{
|
|
UserId: user2.Id,
|
|
ChannelId: channel2.Id,
|
|
RootId: post2.Id,
|
|
Message: "draft4",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
t.Run("delete drafts associated with post", func(t *testing.T) {
|
|
err = ss.Draft().DeleteDraftsAssociatedWithPost(channel1.Id, post1.Id)
|
|
require.NoError(t, err)
|
|
|
|
_, err = ss.Draft().Get(user1.Id, channel1.Id, post1.Id, false)
|
|
require.Error(t, err)
|
|
assert.IsType(t, &store.ErrNotFound{}, err)
|
|
|
|
_, err = ss.Draft().Get(user2.Id, channel1.Id, post1.Id, false)
|
|
require.Error(t, err)
|
|
assert.IsType(t, &store.ErrNotFound{}, err)
|
|
|
|
draft, err := ss.Draft().Get(user1.Id, channel2.Id, post2.Id, false)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, draft3.Message, draft.Message)
|
|
|
|
draft, err = ss.Draft().Get(user2.Id, channel2.Id, post2.Id, false)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, draft4.Message, draft.Message)
|
|
})
|
|
}
|