1155 lines
32 KiB
Go
1155 lines
32 KiB
Go
package storetests
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/mattermost/focalboard/server/model"
|
|
"github.com/mattermost/focalboard/server/services/store"
|
|
"github.com/mattermost/focalboard/server/utils"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
const (
|
|
testUserID = "user-id"
|
|
testTeamID = "team-id"
|
|
testBoardID = "board-id"
|
|
)
|
|
|
|
func StoreTestBlocksStore(t *testing.T, setup func(t *testing.T) (store.Store, func())) {
|
|
t.Run("InsertBlock", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testInsertBlock(t, store)
|
|
})
|
|
t.Run("InsertBlocks", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testInsertBlocks(t, store)
|
|
})
|
|
t.Run("PatchBlock", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testPatchBlock(t, store)
|
|
})
|
|
t.Run("PatchBlocks", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testPatchBlocks(t, store)
|
|
})
|
|
t.Run("DeleteBlock", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testDeleteBlock(t, store)
|
|
})
|
|
t.Run("UndeleteBlock", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testUndeleteBlock(t, store)
|
|
})
|
|
t.Run("GetSubTree2", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testGetSubTree2(t, store)
|
|
})
|
|
t.Run("GetBlocks", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testGetBlocks(t, store)
|
|
})
|
|
t.Run("GetBlock", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testGetBlock(t, store)
|
|
})
|
|
t.Run("DuplicateBlock", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testDuplicateBlock(t, store)
|
|
})
|
|
t.Run("GetBlockMetadata", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testGetBlockMetadata(t, store)
|
|
})
|
|
t.Run("UndeleteBlockChildren", func(t *testing.T) {
|
|
store, tearDown := setup(t)
|
|
defer tearDown()
|
|
testUndeleteBlockChildren(t, store)
|
|
})
|
|
}
|
|
|
|
func testInsertBlock(t *testing.T, store store.Store) {
|
|
userID := testUserID
|
|
boardID := testBoardID
|
|
|
|
blocks, errBlocks := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, errBlocks)
|
|
initialCount := len(blocks)
|
|
|
|
t.Run("valid block", func(t *testing.T) {
|
|
block := &model.Block{
|
|
ID: "id-test",
|
|
BoardID: boardID,
|
|
ModifiedBy: userID,
|
|
}
|
|
|
|
err := store.InsertBlock(block, "user-id-1")
|
|
require.NoError(t, err)
|
|
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, initialCount+1)
|
|
})
|
|
|
|
t.Run("invalid rootid", func(t *testing.T) {
|
|
block := &model.Block{
|
|
ID: "id-test",
|
|
BoardID: "",
|
|
ModifiedBy: userID,
|
|
}
|
|
|
|
err := store.InsertBlock(block, "user-id-1")
|
|
require.Error(t, err)
|
|
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, initialCount+1)
|
|
})
|
|
|
|
t.Run("invalid fields data", func(t *testing.T) {
|
|
block := &model.Block{
|
|
ID: "id-test",
|
|
BoardID: "id-test",
|
|
ModifiedBy: userID,
|
|
Fields: map[string]interface{}{"no-serialiable-value": t.Run},
|
|
}
|
|
|
|
err := store.InsertBlock(block, "user-id-1")
|
|
require.Error(t, err)
|
|
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, initialCount+1)
|
|
})
|
|
|
|
t.Run("insert new block", func(t *testing.T) {
|
|
block := &model.Block{
|
|
BoardID: testBoardID,
|
|
}
|
|
|
|
err := store.InsertBlock(block, "user-id-2")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "user-id-2", block.CreatedBy)
|
|
})
|
|
|
|
t.Run("update existing block", func(t *testing.T) {
|
|
block := &model.Block{
|
|
ID: "id-2",
|
|
BoardID: "board-id-1",
|
|
Title: "Old Title",
|
|
}
|
|
|
|
// inserting
|
|
err := store.InsertBlock(block, "user-id-2")
|
|
require.NoError(t, err)
|
|
|
|
// created by populated from user id for new blocks
|
|
require.Equal(t, "user-id-2", block.CreatedBy)
|
|
|
|
// hack to avoid multiple, quick updates to a card
|
|
// violating block_history composite primary key constraint
|
|
time.Sleep(1 * time.Millisecond)
|
|
|
|
// updating
|
|
newBlock := &model.Block{
|
|
ID: "id-2",
|
|
BoardID: "board-id-1",
|
|
CreatedBy: "user-id-3",
|
|
Title: "New Title",
|
|
}
|
|
err = store.InsertBlock(newBlock, "user-id-4")
|
|
require.NoError(t, err)
|
|
// created by is not altered for existing blocks
|
|
require.Equal(t, "user-id-3", newBlock.CreatedBy)
|
|
require.Equal(t, "New Title", newBlock.Title)
|
|
})
|
|
|
|
createdAt, err := time.Parse(time.RFC822, "01 Jan 90 01:00 IST")
|
|
assert.NoError(t, err)
|
|
|
|
updateAt, err := time.Parse(time.RFC822, "02 Jan 90 01:00 IST")
|
|
assert.NoError(t, err)
|
|
|
|
t.Run("data tamper attempt", func(t *testing.T) {
|
|
block := &model.Block{
|
|
ID: "id-10",
|
|
BoardID: "board-id-1",
|
|
Title: "Old Title",
|
|
CreateAt: utils.GetMillisForTime(createdAt),
|
|
UpdateAt: utils.GetMillisForTime(updateAt),
|
|
CreatedBy: "user-id-5",
|
|
ModifiedBy: "user-id-6",
|
|
}
|
|
|
|
// inserting
|
|
err := store.InsertBlock(block, "user-id-1")
|
|
require.NoError(t, err)
|
|
expectedTime := time.Now()
|
|
|
|
retrievedBlock, err := store.GetBlock("id-10")
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, retrievedBlock)
|
|
assert.Equal(t, "board-id-1", retrievedBlock.BoardID)
|
|
assert.Equal(t, "user-id-1", retrievedBlock.CreatedBy)
|
|
assert.Equal(t, "user-id-1", retrievedBlock.ModifiedBy)
|
|
assert.WithinDurationf(t, expectedTime, utils.GetTimeForMillis(retrievedBlock.CreateAt), 1*time.Second, "create time should be current time")
|
|
assert.WithinDurationf(t, expectedTime, utils.GetTimeForMillis(retrievedBlock.UpdateAt), 1*time.Second, "update time should be current time")
|
|
})
|
|
}
|
|
|
|
func testInsertBlocks(t *testing.T, store store.Store) {
|
|
userID := testUserID
|
|
|
|
blocks, errBlocks := store.GetBlocksForBoard("id-test")
|
|
require.NoError(t, errBlocks)
|
|
initialCount := len(blocks)
|
|
|
|
t.Run("invalid block", func(t *testing.T) {
|
|
validBlock := &model.Block{
|
|
ID: "id-test",
|
|
BoardID: "id-test",
|
|
ModifiedBy: userID,
|
|
}
|
|
|
|
invalidBlock := &model.Block{
|
|
ID: "id-test",
|
|
BoardID: "",
|
|
ModifiedBy: userID,
|
|
}
|
|
|
|
newBlocks := []*model.Block{validBlock, invalidBlock}
|
|
|
|
time.Sleep(1 * time.Millisecond)
|
|
err := store.InsertBlocks(newBlocks, "user-id-1")
|
|
require.Error(t, err)
|
|
|
|
blocks, err := store.GetBlocksForBoard("id-test")
|
|
require.NoError(t, err)
|
|
// no blocks should have been inserted
|
|
require.Len(t, blocks, initialCount)
|
|
})
|
|
}
|
|
|
|
func testPatchBlock(t *testing.T, store store.Store) {
|
|
userID := testUserID
|
|
boardID := "board-id-1"
|
|
|
|
block := &model.Block{
|
|
ID: "id-test",
|
|
BoardID: boardID,
|
|
Title: "oldTitle",
|
|
ModifiedBy: userID,
|
|
Fields: map[string]interface{}{"test": "test value", "test2": "test value 2"},
|
|
}
|
|
|
|
err := store.InsertBlock(block, "user-id-1")
|
|
require.NoError(t, err)
|
|
|
|
blocks, errBlocks := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, errBlocks)
|
|
initialCount := len(blocks)
|
|
|
|
t.Run("not existing block id", func(t *testing.T) {
|
|
err := store.PatchBlock("invalid-block-id", &model.BlockPatch{}, "user-id-1")
|
|
var nf *model.ErrNotFound
|
|
require.ErrorAs(t, err, &nf)
|
|
require.True(t, model.IsErrNotFound(err))
|
|
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, initialCount)
|
|
})
|
|
|
|
t.Run("invalid fields data", func(t *testing.T) {
|
|
blockPatch := &model.BlockPatch{
|
|
UpdatedFields: map[string]interface{}{"no-serialiable-value": t.Run},
|
|
}
|
|
|
|
err := store.PatchBlock("id-test", blockPatch, "user-id-1")
|
|
require.Error(t, err)
|
|
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, initialCount)
|
|
})
|
|
|
|
t.Run("update block fields", func(t *testing.T) {
|
|
newTitle := "New title"
|
|
blockPatch := model.BlockPatch{
|
|
Title: &newTitle,
|
|
}
|
|
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
|
|
// inserting
|
|
err := store.PatchBlock("id-test", &blockPatch, "user-id-2")
|
|
require.NoError(t, err)
|
|
|
|
retrievedBlock, err := store.GetBlock("id-test")
|
|
require.NoError(t, err)
|
|
|
|
// created by populated from user id for new blocks
|
|
require.Equal(t, "user-id-2", retrievedBlock.ModifiedBy)
|
|
require.Equal(t, "New title", retrievedBlock.Title)
|
|
})
|
|
|
|
t.Run("update block custom fields", func(t *testing.T) {
|
|
blockPatch := &model.BlockPatch{
|
|
UpdatedFields: map[string]interface{}{"test": "new test value", "test3": "new value"},
|
|
}
|
|
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
|
|
// inserting
|
|
err := store.PatchBlock("id-test", blockPatch, "user-id-2")
|
|
require.NoError(t, err)
|
|
|
|
retrievedBlock, err := store.GetBlock("id-test")
|
|
require.NoError(t, err)
|
|
|
|
// created by populated from user id for new blocks
|
|
require.Equal(t, "user-id-2", retrievedBlock.ModifiedBy)
|
|
require.Equal(t, "new test value", retrievedBlock.Fields["test"])
|
|
require.Equal(t, "test value 2", retrievedBlock.Fields["test2"])
|
|
require.Equal(t, "new value", retrievedBlock.Fields["test3"])
|
|
})
|
|
|
|
t.Run("remove block custom fields", func(t *testing.T) {
|
|
blockPatch := &model.BlockPatch{
|
|
DeletedFields: []string{"test", "test3", "test100"},
|
|
}
|
|
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
|
|
// inserting
|
|
err := store.PatchBlock("id-test", blockPatch, "user-id-2")
|
|
require.NoError(t, err)
|
|
|
|
retrievedBlock, err := store.GetBlock("id-test")
|
|
require.NoError(t, err)
|
|
|
|
// created by populated from user id for new blocks
|
|
require.Equal(t, "user-id-2", retrievedBlock.ModifiedBy)
|
|
require.Equal(t, nil, retrievedBlock.Fields["test"])
|
|
require.Equal(t, "test value 2", retrievedBlock.Fields["test2"])
|
|
require.Equal(t, nil, retrievedBlock.Fields["test3"])
|
|
})
|
|
}
|
|
|
|
func testPatchBlocks(t *testing.T, store store.Store) {
|
|
block := &model.Block{
|
|
ID: "id-test",
|
|
BoardID: "id-test",
|
|
Title: "oldTitle",
|
|
}
|
|
|
|
block2 := &model.Block{
|
|
ID: "id-test2",
|
|
BoardID: "id-test2",
|
|
Title: "oldTitle2",
|
|
}
|
|
|
|
insertBlocks := []*model.Block{block, block2}
|
|
err := store.InsertBlocks(insertBlocks, "user-id-1")
|
|
require.NoError(t, err)
|
|
|
|
t.Run("successful updated existing blocks", func(t *testing.T) {
|
|
title := "updatedTitle"
|
|
blockPatch := model.BlockPatch{
|
|
Title: &title,
|
|
}
|
|
|
|
blockPatch2 := model.BlockPatch{
|
|
Title: &title,
|
|
}
|
|
|
|
blockIds := []string{"id-test", "id-test2"}
|
|
blockPatches := []model.BlockPatch{blockPatch, blockPatch2}
|
|
|
|
time.Sleep(1 * time.Millisecond)
|
|
err := store.PatchBlocks(&model.BlockPatchBatch{BlockIDs: blockIds, BlockPatches: blockPatches}, "user-id-1")
|
|
require.NoError(t, err)
|
|
|
|
retrievedBlock, err := store.GetBlock("id-test")
|
|
require.NoError(t, err)
|
|
require.Equal(t, title, retrievedBlock.Title)
|
|
|
|
retrievedBlock2, err := store.GetBlock("id-test2")
|
|
require.NoError(t, err)
|
|
require.Equal(t, title, retrievedBlock2.Title)
|
|
})
|
|
|
|
t.Run("invalid block id, nothing updated existing blocks", func(t *testing.T) {
|
|
if store.DBType() == model.SqliteDBType {
|
|
t.Skip("No transactions support int sqlite")
|
|
}
|
|
|
|
title := "Another Title"
|
|
blockPatch := model.BlockPatch{
|
|
Title: &title,
|
|
}
|
|
|
|
blockPatch2 := model.BlockPatch{
|
|
Title: &title,
|
|
}
|
|
|
|
blockIds := []string{"id-test", "invalid id"}
|
|
blockPatches := []model.BlockPatch{blockPatch, blockPatch2}
|
|
|
|
time.Sleep(1 * time.Millisecond)
|
|
err := store.PatchBlocks(&model.BlockPatchBatch{BlockIDs: blockIds, BlockPatches: blockPatches}, "user-id-1")
|
|
var nf *model.ErrNotFound
|
|
require.ErrorAs(t, err, &nf)
|
|
|
|
retrievedBlock, err := store.GetBlock("id-test")
|
|
require.NoError(t, err)
|
|
require.NotEqual(t, title, retrievedBlock.Title)
|
|
})
|
|
}
|
|
|
|
var (
|
|
subtreeSampleBlocks = []*model.Block{
|
|
{
|
|
ID: "parent",
|
|
BoardID: testBoardID,
|
|
ModifiedBy: testUserID,
|
|
},
|
|
{
|
|
ID: "child1",
|
|
BoardID: testBoardID,
|
|
ParentID: "parent",
|
|
ModifiedBy: testUserID,
|
|
},
|
|
{
|
|
ID: "child2",
|
|
BoardID: testBoardID,
|
|
ParentID: "parent",
|
|
ModifiedBy: testUserID,
|
|
},
|
|
{
|
|
ID: "grandchild1",
|
|
BoardID: testBoardID,
|
|
ParentID: "child1",
|
|
ModifiedBy: testUserID,
|
|
},
|
|
{
|
|
ID: "grandchild2",
|
|
BoardID: testBoardID,
|
|
ParentID: "child2",
|
|
ModifiedBy: testUserID,
|
|
},
|
|
{
|
|
ID: "greatgrandchild1",
|
|
BoardID: testBoardID,
|
|
ParentID: "grandchild1",
|
|
ModifiedBy: testUserID,
|
|
},
|
|
}
|
|
)
|
|
|
|
func testGetSubTree2(t *testing.T, store store.Store) {
|
|
boardID := testBoardID
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
initialCount := len(blocks)
|
|
|
|
InsertBlocks(t, store, subtreeSampleBlocks, "user-id-1")
|
|
time.Sleep(1 * time.Millisecond)
|
|
defer DeleteBlocks(t, store, subtreeSampleBlocks, "test")
|
|
|
|
blocks, err = store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, initialCount+6)
|
|
|
|
t.Run("from root id", func(t *testing.T) {
|
|
blocks, err = store.GetSubTree2(boardID, "parent", model.QuerySubtreeOptions{})
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 3)
|
|
require.True(t, ContainsBlockWithID(blocks, "parent"))
|
|
require.True(t, ContainsBlockWithID(blocks, "child1"))
|
|
require.True(t, ContainsBlockWithID(blocks, "child2"))
|
|
})
|
|
|
|
t.Run("from child id", func(t *testing.T) {
|
|
blocks, err = store.GetSubTree2(boardID, "child1", model.QuerySubtreeOptions{})
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 2)
|
|
require.True(t, ContainsBlockWithID(blocks, "child1"))
|
|
require.True(t, ContainsBlockWithID(blocks, "grandchild1"))
|
|
})
|
|
|
|
t.Run("from not existing id", func(t *testing.T) {
|
|
blocks, err = store.GetSubTree2(boardID, "not-exists", model.QuerySubtreeOptions{})
|
|
require.NoError(t, err)
|
|
require.Empty(t, blocks)
|
|
})
|
|
}
|
|
|
|
func testDeleteBlock(t *testing.T, store store.Store) {
|
|
userID := testUserID
|
|
boardID := testBoardID
|
|
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
initialCount := len(blocks)
|
|
|
|
blocksToInsert := []*model.Block{
|
|
{
|
|
ID: "block1",
|
|
BoardID: boardID,
|
|
ModifiedBy: userID,
|
|
},
|
|
{
|
|
ID: "block2",
|
|
BoardID: boardID,
|
|
ModifiedBy: userID,
|
|
},
|
|
{
|
|
ID: "block3",
|
|
BoardID: boardID,
|
|
ModifiedBy: userID,
|
|
},
|
|
}
|
|
InsertBlocks(t, store, blocksToInsert, "user-id-1")
|
|
defer DeleteBlocks(t, store, blocksToInsert, "test")
|
|
|
|
blocks, err = store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, initialCount+3)
|
|
|
|
t.Run("existing id", func(t *testing.T) {
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
err := store.DeleteBlock("block1", userID)
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("existing id multiple times", func(t *testing.T) {
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
err := store.DeleteBlock("block1", userID)
|
|
require.NoError(t, err)
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
err = store.DeleteBlock("block1", userID)
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("from not existing id", func(t *testing.T) {
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
err := store.DeleteBlock("not-exists", userID)
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
|
|
func testUndeleteBlock(t *testing.T, store store.Store) {
|
|
boardID := testBoardID
|
|
userID := testUserID
|
|
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
initialCount := len(blocks)
|
|
|
|
blocksToInsert := []*model.Block{
|
|
{
|
|
ID: "block1",
|
|
BoardID: boardID,
|
|
ModifiedBy: userID,
|
|
},
|
|
{
|
|
ID: "block2",
|
|
BoardID: boardID,
|
|
ModifiedBy: userID,
|
|
},
|
|
{
|
|
ID: "block3",
|
|
BoardID: boardID,
|
|
ModifiedBy: userID,
|
|
},
|
|
}
|
|
InsertBlocks(t, store, blocksToInsert, "user-id-1")
|
|
defer DeleteBlocks(t, store, blocksToInsert, "test")
|
|
|
|
blocks, err = store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, initialCount+3)
|
|
|
|
t.Run("existing id", func(t *testing.T) {
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
err := store.DeleteBlock("block1", userID)
|
|
require.NoError(t, err)
|
|
|
|
block, err := store.GetBlock("block1")
|
|
var nf *model.ErrNotFound
|
|
require.ErrorAs(t, err, &nf)
|
|
require.Nil(t, block)
|
|
|
|
time.Sleep(1 * time.Millisecond)
|
|
err = store.UndeleteBlock("block1", userID)
|
|
require.NoError(t, err)
|
|
|
|
block, err = store.GetBlock("block1")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, block)
|
|
})
|
|
|
|
t.Run("existing id multiple times", func(t *testing.T) {
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
err := store.DeleteBlock("block1", userID)
|
|
require.NoError(t, err)
|
|
|
|
block, err := store.GetBlock("block1")
|
|
var nf *model.ErrNotFound
|
|
require.ErrorAs(t, err, &nf)
|
|
require.Nil(t, block)
|
|
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
err = store.UndeleteBlock("block1", userID)
|
|
require.NoError(t, err)
|
|
|
|
block, err = store.GetBlock("block1")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, block)
|
|
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
err = store.UndeleteBlock("block1", userID)
|
|
require.NoError(t, err)
|
|
|
|
block, err = store.GetBlock("block1")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, block)
|
|
})
|
|
|
|
t.Run("from not existing id", func(t *testing.T) {
|
|
// Wait for not colliding the ID+insert_at key
|
|
time.Sleep(1 * time.Millisecond)
|
|
err := store.UndeleteBlock("not-exists", userID)
|
|
require.NoError(t, err)
|
|
|
|
block, err := store.GetBlock("not-exists")
|
|
var nf *model.ErrNotFound
|
|
require.ErrorAs(t, err, &nf)
|
|
require.Nil(t, block)
|
|
})
|
|
}
|
|
|
|
func testGetBlocks(t *testing.T, store store.Store) {
|
|
boardID := testBoardID
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
|
|
blocksToInsert := []*model.Block{
|
|
{
|
|
ID: "block1",
|
|
BoardID: boardID,
|
|
ParentID: "",
|
|
ModifiedBy: testUserID,
|
|
Type: "test",
|
|
},
|
|
{
|
|
ID: "block2",
|
|
BoardID: boardID,
|
|
ParentID: "block1",
|
|
ModifiedBy: testUserID,
|
|
Type: "test",
|
|
},
|
|
{
|
|
ID: "block3",
|
|
BoardID: boardID,
|
|
ParentID: "block1",
|
|
ModifiedBy: testUserID,
|
|
Type: "test",
|
|
},
|
|
{
|
|
ID: "block4",
|
|
BoardID: boardID,
|
|
ParentID: "block1",
|
|
ModifiedBy: testUserID,
|
|
Type: "test2",
|
|
},
|
|
{
|
|
ID: "block5",
|
|
BoardID: boardID,
|
|
ParentID: "block2",
|
|
ModifiedBy: testUserID,
|
|
Type: "test",
|
|
},
|
|
}
|
|
InsertBlocks(t, store, blocksToInsert, "user-id-1")
|
|
defer DeleteBlocks(t, store, blocksToInsert, "test")
|
|
|
|
t.Run("not existing parent", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksWithParentAndType(boardID, "not-exists", "test")
|
|
require.NoError(t, err)
|
|
require.Empty(t, blocks)
|
|
})
|
|
|
|
t.Run("not existing type", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksWithParentAndType(boardID, "block1", "not-existing")
|
|
require.NoError(t, err)
|
|
require.Empty(t, blocks)
|
|
})
|
|
|
|
t.Run("valid parent and type", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksWithParentAndType(boardID, "block1", "test")
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 2)
|
|
})
|
|
|
|
t.Run("not existing parent", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksWithParent(boardID, "not-exists")
|
|
require.NoError(t, err)
|
|
require.Empty(t, blocks)
|
|
})
|
|
|
|
t.Run("valid parent", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksWithParent(boardID, "block1")
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 3)
|
|
})
|
|
|
|
t.Run("not existing type", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksWithType(boardID, "not-exists")
|
|
require.NoError(t, err)
|
|
require.Empty(t, blocks)
|
|
})
|
|
|
|
t.Run("valid type", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksWithType(boardID, "test")
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 4)
|
|
})
|
|
|
|
t.Run("not existing board", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksForBoard("not-exists")
|
|
require.NoError(t, err)
|
|
require.Empty(t, blocks)
|
|
})
|
|
|
|
t.Run("all blocks of the a board", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 5)
|
|
})
|
|
|
|
t.Run("several blocks by ids", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksByIDs([]string{"block2", "block4"})
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 2)
|
|
})
|
|
|
|
t.Run("blocks by ids where some are not found", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksByIDs([]string{"block2", "blockNonexistent"})
|
|
var naf *model.ErrNotAllFound
|
|
require.ErrorAs(t, err, &naf)
|
|
require.True(t, model.IsErrNotFound(err))
|
|
require.Len(t, blocks, 1)
|
|
})
|
|
|
|
t.Run("blocks by ids where none are found", func(t *testing.T) {
|
|
time.Sleep(1 * time.Millisecond)
|
|
blocks, err = store.GetBlocksByIDs([]string{"blockNonexistent1", "blockNonexistent2"})
|
|
var naf *model.ErrNotAllFound
|
|
require.ErrorAs(t, err, &naf)
|
|
require.True(t, model.IsErrNotFound(err))
|
|
require.Empty(t, blocks)
|
|
})
|
|
}
|
|
|
|
func testGetBlock(t *testing.T, store store.Store) {
|
|
t.Run("get a block", func(t *testing.T) {
|
|
block := &model.Block{
|
|
ID: "block-id-10",
|
|
BoardID: "board-id-1",
|
|
ModifiedBy: "user-id-1",
|
|
}
|
|
|
|
err := store.InsertBlock(block, "user-id-1")
|
|
require.NoError(t, err)
|
|
|
|
fetchedBlock, err := store.GetBlock("block-id-10")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, fetchedBlock)
|
|
require.Equal(t, "block-id-10", fetchedBlock.ID)
|
|
require.Equal(t, "board-id-1", fetchedBlock.BoardID)
|
|
require.Equal(t, "user-id-1", fetchedBlock.CreatedBy)
|
|
require.Equal(t, "user-id-1", fetchedBlock.ModifiedBy)
|
|
assert.WithinDurationf(t, time.Now(), utils.GetTimeForMillis(fetchedBlock.CreateAt), 1*time.Second, "create time should be current time")
|
|
assert.WithinDurationf(t, time.Now(), utils.GetTimeForMillis(fetchedBlock.UpdateAt), 1*time.Second, "update time should be current time")
|
|
})
|
|
|
|
t.Run("get a non-existing block", func(t *testing.T) {
|
|
fetchedBlock, err := store.GetBlock("non-existing-id")
|
|
var nf *model.ErrNotFound
|
|
require.ErrorAs(t, err, &nf)
|
|
require.Nil(t, fetchedBlock)
|
|
})
|
|
}
|
|
|
|
func testDuplicateBlock(t *testing.T, store store.Store) {
|
|
blocksToInsert := subtreeSampleBlocks
|
|
blocksToInsert = append(blocksToInsert,
|
|
&model.Block{
|
|
ID: "grandchild1a",
|
|
BoardID: testBoardID,
|
|
ParentID: "child1",
|
|
ModifiedBy: testUserID,
|
|
Type: model.TypeComment,
|
|
},
|
|
&model.Block{
|
|
ID: "grandchild2a",
|
|
BoardID: testBoardID,
|
|
ParentID: "child2",
|
|
ModifiedBy: testUserID,
|
|
Type: model.TypeComment,
|
|
},
|
|
)
|
|
|
|
InsertBlocks(t, store, blocksToInsert, "user-id-1")
|
|
time.Sleep(1 * time.Millisecond)
|
|
defer DeleteBlocks(t, store, subtreeSampleBlocks, "test")
|
|
|
|
t.Run("duplicate existing block as no template", func(t *testing.T) {
|
|
blocks, err := store.DuplicateBlock(testBoardID, "child1", testUserID, false)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 2)
|
|
require.Equal(t, false, blocks[0].Fields["isTemplate"])
|
|
})
|
|
|
|
t.Run("duplicate existing block as template", func(t *testing.T) {
|
|
blocks, err := store.DuplicateBlock(testBoardID, "child1", testUserID, true)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 2)
|
|
require.Equal(t, true, blocks[0].Fields["isTemplate"])
|
|
})
|
|
|
|
t.Run("duplicate not existing block", func(t *testing.T) {
|
|
blocks, err := store.DuplicateBlock(testBoardID, "not-existing-id", testUserID, false)
|
|
require.Error(t, err)
|
|
require.Nil(t, blocks)
|
|
})
|
|
|
|
t.Run("duplicate not existing board", func(t *testing.T) {
|
|
blocks, err := store.DuplicateBlock("not-existing-board", "not-existing-id", testUserID, false)
|
|
require.Error(t, err)
|
|
require.Nil(t, blocks)
|
|
})
|
|
|
|
t.Run("not matching board/block", func(t *testing.T) {
|
|
blocks, err := store.DuplicateBlock("other-id", "child1", testUserID, false)
|
|
require.Error(t, err)
|
|
require.Nil(t, blocks)
|
|
})
|
|
}
|
|
|
|
func testGetBlockMetadata(t *testing.T, store store.Store) {
|
|
boardID := testBoardID
|
|
blocks, err := store.GetBlocksForBoard(boardID)
|
|
require.NoError(t, err)
|
|
|
|
blocksToInsert := []*model.Block{
|
|
{
|
|
ID: "block1",
|
|
BoardID: boardID,
|
|
ParentID: "",
|
|
ModifiedBy: testUserID,
|
|
Type: "test",
|
|
},
|
|
{
|
|
ID: "block2",
|
|
BoardID: boardID,
|
|
ParentID: "block1",
|
|
ModifiedBy: testUserID,
|
|
Type: "test",
|
|
},
|
|
{
|
|
ID: "block3",
|
|
BoardID: boardID,
|
|
ParentID: "block1",
|
|
ModifiedBy: testUserID,
|
|
Type: "test",
|
|
},
|
|
{
|
|
ID: "block4",
|
|
BoardID: boardID,
|
|
ParentID: "block1",
|
|
ModifiedBy: testUserID,
|
|
Type: "test2",
|
|
},
|
|
{
|
|
ID: "block5",
|
|
BoardID: boardID,
|
|
ParentID: "block2",
|
|
ModifiedBy: testUserID,
|
|
Type: "test",
|
|
},
|
|
}
|
|
|
|
for _, v := range blocksToInsert {
|
|
time.Sleep(20 * time.Millisecond)
|
|
subBlocks := []*model.Block{v}
|
|
InsertBlocks(t, store, subBlocks, testUserID)
|
|
}
|
|
defer DeleteBlocks(t, store, blocksToInsert, "test")
|
|
|
|
t.Run("get full block history", func(t *testing.T) {
|
|
opts := model.QueryBlockHistoryOptions{
|
|
Descending: false,
|
|
}
|
|
blocks, err = store.GetBlockHistoryDescendants(boardID, opts)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 5)
|
|
expectedBlock := blocksToInsert[0]
|
|
block := blocks[0]
|
|
|
|
require.Equal(t, expectedBlock.ID, block.ID)
|
|
})
|
|
|
|
t.Run("get full block history descending", func(t *testing.T) {
|
|
opts := model.QueryBlockHistoryOptions{
|
|
Descending: true,
|
|
}
|
|
blocks, err = store.GetBlockHistoryDescendants(boardID, opts)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 5)
|
|
expectedBlock := blocksToInsert[len(blocksToInsert)-1]
|
|
block := blocks[0]
|
|
|
|
require.Equal(t, expectedBlock.ID, block.ID)
|
|
})
|
|
|
|
t.Run("get limited block history", func(t *testing.T) {
|
|
opts := model.QueryBlockHistoryOptions{
|
|
Limit: 3,
|
|
Descending: false,
|
|
}
|
|
blocks, err = store.GetBlockHistoryDescendants(boardID, opts)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 3)
|
|
})
|
|
|
|
t.Run("get first block history", func(t *testing.T) {
|
|
opts := model.QueryBlockHistoryOptions{
|
|
Limit: 1,
|
|
Descending: false,
|
|
}
|
|
blocks, err = store.GetBlockHistoryDescendants(boardID, opts)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 1)
|
|
expectedBlock := blocksToInsert[0]
|
|
block := blocks[0]
|
|
|
|
require.Equal(t, expectedBlock.ID, block.ID)
|
|
})
|
|
|
|
t.Run("get last block history", func(t *testing.T) {
|
|
opts := model.QueryBlockHistoryOptions{
|
|
Limit: 1,
|
|
Descending: true,
|
|
}
|
|
blocks, err = store.GetBlockHistoryDescendants(boardID, opts)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 1)
|
|
expectedBlock := blocksToInsert[len(blocksToInsert)-1]
|
|
block := blocks[0]
|
|
|
|
require.Equal(t, expectedBlock.ID, block.ID)
|
|
})
|
|
|
|
t.Run("get block history after updateAt", func(t *testing.T) {
|
|
rBlock, err2 := store.GetBlock("block3")
|
|
require.NoError(t, err2)
|
|
require.NotZero(t, rBlock.UpdateAt)
|
|
|
|
opts := model.QueryBlockHistoryOptions{
|
|
AfterUpdateAt: rBlock.UpdateAt,
|
|
Descending: false,
|
|
}
|
|
blocks, err = store.GetBlockHistoryDescendants(boardID, opts)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 2)
|
|
expectedBlock := blocksToInsert[3]
|
|
block := blocks[0]
|
|
|
|
require.Equal(t, expectedBlock.ID, block.ID)
|
|
})
|
|
|
|
t.Run("get block history before updateAt", func(t *testing.T) {
|
|
rBlock, err2 := store.GetBlock("block3")
|
|
require.NoError(t, err2)
|
|
require.NotZero(t, rBlock.UpdateAt)
|
|
|
|
opts := model.QueryBlockHistoryOptions{
|
|
BeforeUpdateAt: rBlock.UpdateAt,
|
|
Descending: true,
|
|
}
|
|
blocks, err = store.GetBlockHistoryDescendants(boardID, opts)
|
|
require.NoError(t, err)
|
|
require.Len(t, blocks, 2)
|
|
expectedBlock := blocksToInsert[1]
|
|
block := blocks[0]
|
|
|
|
require.Equal(t, expectedBlock.ID, block.ID)
|
|
})
|
|
|
|
t.Run("get full block history after delete", func(t *testing.T) {
|
|
time.Sleep(20 * time.Millisecond)
|
|
// this will delete `block1` and any other blocks with `block1` as parent.
|
|
err = store.DeleteBlock(blocksToInsert[0].ID, testUserID)
|
|
require.NoError(t, err)
|
|
|
|
opts := model.QueryBlockHistoryOptions{
|
|
Descending: true,
|
|
}
|
|
blocks, err = store.GetBlockHistoryDescendants(boardID, opts)
|
|
require.NoError(t, err)
|
|
// all 5 blocks get a history record for insert, then `block1` gets a record for delete,
|
|
// and all 3 `block1` children get a record for delete. Thus total is 9.
|
|
require.Len(t, blocks, 9)
|
|
})
|
|
|
|
t.Run("get full block history after undelete", func(t *testing.T) {
|
|
time.Sleep(20 * time.Millisecond)
|
|
// this will undelete `block1` and its children
|
|
err = store.UndeleteBlock(blocksToInsert[0].ID, testUserID)
|
|
require.NoError(t, err)
|
|
|
|
opts := model.QueryBlockHistoryOptions{
|
|
Descending: true,
|
|
}
|
|
blocks, err = store.GetBlockHistoryDescendants(boardID, opts)
|
|
require.NoError(t, err)
|
|
// previous test put 9 records in history table. In this test 1 record was added for undeleting
|
|
// `block1` and another 3 for undeleting the children for a total of 13.
|
|
require.Len(t, blocks, 13)
|
|
})
|
|
|
|
t.Run("get block history of a board with no history", func(t *testing.T) {
|
|
opts := model.QueryBlockHistoryOptions{}
|
|
|
|
blocks, err = store.GetBlockHistoryDescendants("nonexistent-board-id", opts)
|
|
require.NoError(t, err)
|
|
require.Empty(t, blocks)
|
|
})
|
|
}
|
|
|
|
func testUndeleteBlockChildren(t *testing.T, store store.Store) {
|
|
boards := createTestBoards(t, store, testUserID, 2)
|
|
boardDelete := boards[0]
|
|
boardKeep := boards[1]
|
|
|
|
// create some blocks to be deleted
|
|
cardsDelete := createTestCards(t, store, testUserID, boardDelete.ID, 3)
|
|
blocksDelete := createTestBlocksForCard(t, store, cardsDelete[0].ID, 5)
|
|
require.Len(t, blocksDelete, 5)
|
|
|
|
// create some blocks to keep
|
|
cardsKeep := createTestCards(t, store, testUserID, boardKeep.ID, 3)
|
|
blocksKeep := createTestBlocksForCard(t, store, cardsKeep[0].ID, 4)
|
|
require.Len(t, blocksKeep, 4)
|
|
|
|
t.Run("undelete block children for card", func(t *testing.T) {
|
|
cardDelete := cardsDelete[0]
|
|
cardKeep := cardsKeep[0]
|
|
|
|
// delete a card
|
|
err := store.DeleteBlock(cardDelete.ID, testUserID)
|
|
require.NoError(t, err)
|
|
|
|
// ensure the card was deleted
|
|
block, err := store.GetBlock(cardDelete.ID)
|
|
require.Error(t, err)
|
|
require.Nil(t, block)
|
|
|
|
// ensure the card children were deleted
|
|
blocks, err := store.GetBlocksWithParentAndType(cardDelete.BoardID, cardDelete.ID, model.TypeText)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, blocks)
|
|
|
|
// ensure the other card children remain.
|
|
blocks, err = store.GetBlocksWithParentAndType(cardKeep.BoardID, cardKeep.ID, model.TypeText)
|
|
require.NoError(t, err)
|
|
assert.Len(t, blocks, len(blocksKeep))
|
|
|
|
// undelete the card
|
|
err = store.UndeleteBlock(cardDelete.ID, testUserID)
|
|
require.NoError(t, err)
|
|
|
|
// ensure the card was restored
|
|
block, err = store.GetBlock(cardDelete.ID)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, block)
|
|
|
|
// ensure the card children were restored
|
|
blocks, err = store.GetBlocksWithParentAndType(cardDelete.BoardID, cardDelete.ID, model.TypeText)
|
|
require.NoError(t, err)
|
|
assert.Len(t, blocks, len(blocksDelete))
|
|
})
|
|
|
|
t.Run("undelete block children for board", func(t *testing.T) {
|
|
// delete the board
|
|
err := store.DeleteBoard(boardDelete.ID, testUserID)
|
|
require.NoError(t, err)
|
|
|
|
// ensure the board was deleted
|
|
board, err := store.GetBoard(boardDelete.ID)
|
|
require.Error(t, err)
|
|
require.Nil(t, board)
|
|
|
|
// ensure all cards and blocks for the board were deleted
|
|
blocks, err := store.GetBlocksForBoard(boardDelete.ID)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, blocks)
|
|
|
|
// ensure the other board's cards and blocks remain.
|
|
blocks, err = store.GetBlocksForBoard(boardKeep.ID)
|
|
require.NoError(t, err)
|
|
assert.Len(t, blocks, len(blocksKeep)+len(cardsKeep))
|
|
|
|
// undelete the board
|
|
err = store.UndeleteBoard(boardDelete.ID, testUserID)
|
|
require.NoError(t, err)
|
|
|
|
// ensure the board was restored
|
|
board, err = store.GetBoard(boardDelete.ID)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, board)
|
|
|
|
// ensure the board's cards and blocks were restored.
|
|
blocks, err = store.GetBlocksForBoard(boardDelete.ID)
|
|
require.NoError(t, err)
|
|
assert.Len(t, blocks, len(blocksDelete)+len(cardsDelete))
|
|
})
|
|
}
|