gugus
bb402d4ccc
Some checks failed
Backend Tests / Static Checks (push) Has been cancelled
Backend Tests / Tests (other) (push) Has been cancelled
Backend Tests / Tests (plugin) (push) Has been cancelled
Backend Tests / Tests (server) (push) Has been cancelled
Backend Tests / Tests (store) (push) Has been cancelled
Build Canary Image / build-frontend (push) Has been cancelled
Build Canary Image / build-push (linux/amd64) (push) Has been cancelled
Build Canary Image / build-push (linux/arm64) (push) Has been cancelled
Build Canary Image / merge (push) Has been cancelled
Frontend Tests / Lint (push) Has been cancelled
Frontend Tests / Build (push) Has been cancelled
Proto Linter / Lint Protos (push) Has been cancelled
370 lines
14 KiB
Go
370 lines
14 KiB
Go
package test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"slices"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
|
|
apiv1 "github.com/usememos/memos/proto/gen/api/v1"
|
|
)
|
|
|
|
func TestListMemos(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create userOne
|
|
userOne, err := ts.CreateRegularUser(ctx, "test-user-1")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, userOne)
|
|
|
|
// Create userOne context
|
|
userOneCtx := ts.CreateUserContext(ctx, userOne.ID)
|
|
|
|
// Create userTwo
|
|
userTwo, err := ts.CreateRegularUser(ctx, "test-user-2")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, userTwo)
|
|
|
|
// Create userTwo context
|
|
userTwoCtx := ts.CreateUserContext(ctx, userTwo.ID)
|
|
|
|
// Create attachmentOne by userOne
|
|
attachmentOne, err := ts.Service.CreateAttachment(userOneCtx, &apiv1.CreateAttachmentRequest{
|
|
Attachment: &apiv1.Attachment{
|
|
Name: "",
|
|
Filename: "hello.txt",
|
|
Size: 5,
|
|
Type: "text/plain",
|
|
Content: []byte{
|
|
104, 101, 108, 108, 111,
|
|
},
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, attachmentOne)
|
|
|
|
// Create attachmentTwo by userOne
|
|
attachmentTwo, err := ts.Service.CreateAttachment(userOneCtx, &apiv1.CreateAttachmentRequest{
|
|
Attachment: &apiv1.Attachment{
|
|
Name: "",
|
|
Filename: "world.txt",
|
|
Size: 5,
|
|
Type: "text/plain",
|
|
Content: []byte{
|
|
119, 111, 114, 108, 100,
|
|
},
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, attachmentTwo)
|
|
|
|
// Create memoOne with two attachments by userOne
|
|
memoOne, err := ts.Service.CreateMemo(userOneCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "Hellooo, any words after this sentence won't be in the snippet. This is the next sentence. And I also have two attachments.",
|
|
Visibility: apiv1.Visibility_PROTECTED,
|
|
Attachments: []*apiv1.Attachment{
|
|
&apiv1.Attachment{
|
|
Name: attachmentOne.Name,
|
|
},
|
|
&apiv1.Attachment{
|
|
Name: attachmentTwo.Name,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memoOne)
|
|
|
|
// Create memoTwo by userTwo referencing memoOne
|
|
memoTwo, err := ts.Service.CreateMemo(userTwoCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "This is a memo reminding you to check the attachment attached to memoOne. I have referenced the memo below.⬇️",
|
|
Visibility: apiv1.Visibility_PROTECTED,
|
|
Relations: []*apiv1.MemoRelation{
|
|
&apiv1.MemoRelation{
|
|
RelatedMemo: &apiv1.MemoRelation_Memo{
|
|
Name: memoOne.Name,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memoTwo)
|
|
|
|
// Create memoThree by userOne
|
|
memoThree, err := ts.Service.CreateMemo(userOneCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "This is a very popular memo. I have 2 reactions!",
|
|
Visibility: apiv1.Visibility_PROTECTED,
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memoThree)
|
|
|
|
// Create reaction from userOne on memoThree
|
|
reactionOne, err := ts.Service.UpsertMemoReaction(userOneCtx, &apiv1.UpsertMemoReactionRequest{
|
|
Name: memoThree.Name,
|
|
Reaction: &apiv1.Reaction{
|
|
ContentId: memoThree.Name,
|
|
ReactionType: "❤️",
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, reactionOne)
|
|
|
|
// Create reaction from userTwo on memoThree
|
|
reactionTwo, err := ts.Service.UpsertMemoReaction(userTwoCtx, &apiv1.UpsertMemoReactionRequest{
|
|
Name: memoThree.Name,
|
|
Reaction: &apiv1.Reaction{
|
|
ContentId: memoThree.Name,
|
|
ReactionType: "👍",
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, reactionTwo)
|
|
|
|
memos, err := ts.Service.ListMemos(userOneCtx, &apiv1.ListMemosRequest{PageSize: 10})
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memos)
|
|
require.Equal(t, 3, len(memos.Memos))
|
|
|
|
// ///////////////
|
|
// VERIFY MEMO ONE
|
|
// ///////////////
|
|
memoOneResIdx := slices.IndexFunc(memos.Memos, func(m *apiv1.Memo) bool { return m.GetName() == memoOne.GetName() })
|
|
require.NotEqual(t, memoOneResIdx, -1)
|
|
|
|
memoOneRes := memos.Memos[memoOneResIdx]
|
|
require.NotNil(t, memoOneRes)
|
|
|
|
require.Equal(t, fmt.Sprintf("users/%d", userOne.ID), memoOneRes.GetCreator())
|
|
require.Equal(t, apiv1.Visibility_PROTECTED, memoOneRes.GetVisibility())
|
|
require.Equal(t, memoOne.Content, memoOneRes.GetContent())
|
|
require.Equal(t, memoOne.Content[:64]+"...", memoOneRes.GetSnippet(), "memoOne's content is snipped past the 64 char limit")
|
|
require.Len(t, memoOneRes.Attachments, 2)
|
|
require.Len(t, memoOneRes.Relations, 1)
|
|
require.Empty(t, memoOneRes.Reactions)
|
|
|
|
// verify memoOne's attachments
|
|
// attachment one
|
|
attachmentOneResIdx := slices.IndexFunc(memoOneRes.Attachments, func(a *apiv1.Attachment) bool { return a.GetName() == attachmentOne.GetName() })
|
|
require.NotEqual(t, attachmentOneResIdx, -1)
|
|
|
|
attachmentOneRes := memoOneRes.Attachments[attachmentOneResIdx]
|
|
require.NotNil(t, attachmentOneRes)
|
|
|
|
require.Equal(t, attachmentOne.GetName(), attachmentOneRes.GetName())
|
|
require.Equal(t, attachmentOne.GetContent(), attachmentOneRes.GetContent())
|
|
|
|
// attachment two
|
|
attachmentTwoResIdx := slices.IndexFunc(memoOneRes.Attachments, func(a *apiv1.Attachment) bool { return a.GetName() == attachmentTwo.GetName() })
|
|
require.NotEqual(t, attachmentTwoResIdx, -1)
|
|
|
|
attachmentTwoRes := memoOneRes.Attachments[attachmentTwoResIdx]
|
|
require.NotNil(t, attachmentTwoRes)
|
|
require.Equal(t, attachmentTwo.GetName(), attachmentTwoRes.GetName())
|
|
|
|
require.Equal(t, attachmentTwo.GetName(), attachmentTwoRes.GetName())
|
|
require.Equal(t, attachmentTwo.GetContent(), attachmentTwoRes.GetContent())
|
|
|
|
// verify memoOne's relations
|
|
require.Len(t, memoOneRes.Relations, 1)
|
|
memoOneExpectedRelation := &apiv1.MemoRelation{
|
|
Memo: &apiv1.MemoRelation_Memo{Name: memoTwo.GetName()},
|
|
RelatedMemo: &apiv1.MemoRelation_Memo{Name: memoOne.GetName()},
|
|
}
|
|
require.Equal(t, memoOneExpectedRelation.Memo.GetName(), memoOneRes.Relations[0].Memo.GetName())
|
|
require.Equal(t, memoOneExpectedRelation.RelatedMemo.GetName(), memoOneRes.Relations[0].RelatedMemo.GetName())
|
|
|
|
// ///////////////
|
|
// VERIFY MEMO TWO
|
|
// ///////////////
|
|
memoTwoResIdx := slices.IndexFunc(memos.Memos, func(m *apiv1.Memo) bool { return m.GetName() == memoTwo.GetName() })
|
|
require.NotEqual(t, memoTwoResIdx, -1)
|
|
|
|
memoTwoRes := memos.Memos[memoTwoResIdx]
|
|
require.NotNil(t, memoTwoRes)
|
|
|
|
require.Equal(t, fmt.Sprintf("users/%d", userTwo.ID), memoTwoRes.GetCreator())
|
|
require.Equal(t, apiv1.Visibility_PROTECTED, memoTwoRes.GetVisibility())
|
|
require.Equal(t, memoTwo.Content, memoTwoRes.GetContent())
|
|
require.Empty(t, memoTwoRes.Attachments)
|
|
require.Len(t, memoTwoRes.Relations, 1)
|
|
require.Empty(t, memoTwoRes.Reactions)
|
|
|
|
// verify memoTwo's relations
|
|
require.Len(t, memoTwoRes.Relations, 1)
|
|
memoTwoExpectedRelation := &apiv1.MemoRelation{
|
|
Memo: &apiv1.MemoRelation_Memo{Name: memoTwo.GetName()},
|
|
RelatedMemo: &apiv1.MemoRelation_Memo{Name: memoOne.GetName()},
|
|
}
|
|
require.Equal(t, memoTwoExpectedRelation.Memo.GetName(), memoTwoRes.Relations[0].Memo.GetName())
|
|
require.Equal(t, memoTwoExpectedRelation.RelatedMemo.GetName(), memoTwoRes.Relations[0].RelatedMemo.GetName())
|
|
|
|
// ///////////////
|
|
// VERIFY MEMO THREE
|
|
// ///////////////
|
|
memoThreeResIdx := slices.IndexFunc(memos.Memos, func(m *apiv1.Memo) bool { return m.GetName() == memoThree.GetName() })
|
|
require.NotEqual(t, memoThreeResIdx, -1)
|
|
|
|
memoThreeRes := memos.Memos[memoThreeResIdx]
|
|
require.NotNil(t, memoThreeRes)
|
|
|
|
require.Equal(t, fmt.Sprintf("users/%d", userOne.ID), memoThreeRes.GetCreator())
|
|
require.Equal(t, apiv1.Visibility_PROTECTED, memoThreeRes.GetVisibility())
|
|
require.Equal(t, memoThree.Content, memoThreeRes.GetContent())
|
|
require.Empty(t, memoThreeRes.Attachments)
|
|
require.Empty(t, memoThreeRes.Relations)
|
|
require.Len(t, memoThreeRes.Reactions, 2)
|
|
|
|
// verify memoThree's reactions
|
|
require.Len(t, memoThreeRes.Reactions, 2)
|
|
// userOne's reaction
|
|
userOneReactionIdx := slices.IndexFunc(memoThreeRes.Reactions, func(r *apiv1.Reaction) bool { return r.GetCreator() == fmt.Sprintf("users/%d", userOne.ID) })
|
|
require.NotEqual(t, userOneReactionIdx, -1)
|
|
|
|
userOneReaction := memoThreeRes.Reactions[userOneReactionIdx]
|
|
require.NotNil(t, userOneReaction)
|
|
require.Equal(t, "❤️", userOneReaction.ReactionType)
|
|
|
|
// userTwo's reaction
|
|
userTwoReactionIdx := slices.IndexFunc(memoThreeRes.Reactions, func(r *apiv1.Reaction) bool { return r.GetCreator() == fmt.Sprintf("users/%d", userTwo.ID) })
|
|
require.NotEqual(t, userTwoReactionIdx, -1)
|
|
|
|
userTwoReaction := memoThreeRes.Reactions[userTwoReactionIdx]
|
|
require.NotNil(t, userTwoReaction)
|
|
require.Equal(t, "👍", userTwoReaction.ReactionType)
|
|
}
|
|
|
|
// TestCreateMemoWithCustomTimestamps tests that custom timestamps can be set when creating memos and comments.
|
|
// This addresses issue #5483: https://github.com/usememos/memos/issues/5483
|
|
func TestCreateMemoWithCustomTimestamps(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create a test user
|
|
user, err := ts.CreateRegularUser(ctx, "test-user-timestamps")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, user)
|
|
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// Define custom timestamps (January 1, 2020)
|
|
customCreateTime := time.Date(2020, 1, 1, 12, 0, 0, 0, time.UTC)
|
|
customUpdateTime := time.Date(2020, 1, 2, 12, 0, 0, 0, time.UTC)
|
|
customDisplayTime := time.Date(2020, 1, 3, 12, 0, 0, 0, time.UTC)
|
|
|
|
// Test 1: Create a memo with custom create_time
|
|
memoWithCreateTime, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "This memo has a custom creation time",
|
|
Visibility: apiv1.Visibility_PRIVATE,
|
|
CreateTime: timestamppb.New(customCreateTime),
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memoWithCreateTime)
|
|
require.Equal(t, customCreateTime.Unix(), memoWithCreateTime.CreateTime.AsTime().Unix(), "create_time should match the custom timestamp")
|
|
|
|
// Test 2: Create a memo with custom update_time
|
|
memoWithUpdateTime, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "This memo has a custom update time",
|
|
Visibility: apiv1.Visibility_PRIVATE,
|
|
UpdateTime: timestamppb.New(customUpdateTime),
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memoWithUpdateTime)
|
|
require.Equal(t, customUpdateTime.Unix(), memoWithUpdateTime.UpdateTime.AsTime().Unix(), "update_time should match the custom timestamp")
|
|
|
|
// Test 3: Create a memo with custom display_time
|
|
// Note: display_time is computed from either created_ts or updated_ts based on instance setting
|
|
// Since DisplayWithUpdateTime defaults to false, display_time maps to created_ts
|
|
memoWithDisplayTime, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "This memo has a custom display time",
|
|
Visibility: apiv1.Visibility_PRIVATE,
|
|
DisplayTime: timestamppb.New(customDisplayTime),
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memoWithDisplayTime)
|
|
// Since DisplayWithUpdateTime is false by default, display_time sets created_ts
|
|
require.Equal(t, customDisplayTime.Unix(), memoWithDisplayTime.DisplayTime.AsTime().Unix(), "display_time should match the custom timestamp")
|
|
require.Equal(t, customDisplayTime.Unix(), memoWithDisplayTime.CreateTime.AsTime().Unix(), "create_time should also match since display_time maps to created_ts")
|
|
|
|
// Test 4: Create a memo with all custom timestamps
|
|
// When both display_time and create_time are provided, create_time takes precedence
|
|
memoWithAllTimestamps, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "This memo has all custom timestamps",
|
|
Visibility: apiv1.Visibility_PRIVATE,
|
|
CreateTime: timestamppb.New(customCreateTime),
|
|
UpdateTime: timestamppb.New(customUpdateTime),
|
|
DisplayTime: timestamppb.New(customDisplayTime),
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memoWithAllTimestamps)
|
|
require.Equal(t, customCreateTime.Unix(), memoWithAllTimestamps.CreateTime.AsTime().Unix(), "create_time should match the custom timestamp")
|
|
require.Equal(t, customUpdateTime.Unix(), memoWithAllTimestamps.UpdateTime.AsTime().Unix(), "update_time should match the custom timestamp")
|
|
// display_time is computed from created_ts when DisplayWithUpdateTime is false
|
|
require.Equal(t, customCreateTime.Unix(), memoWithAllTimestamps.DisplayTime.AsTime().Unix(), "display_time should be derived from create_time")
|
|
|
|
// Test 5: Create a comment (memo relation) with custom timestamps
|
|
parentMemo, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "This is the parent memo",
|
|
Visibility: apiv1.Visibility_PRIVATE,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, parentMemo)
|
|
|
|
customCommentCreateTime := time.Date(2021, 6, 15, 10, 30, 0, 0, time.UTC)
|
|
comment, err := ts.Service.CreateMemoComment(userCtx, &apiv1.CreateMemoCommentRequest{
|
|
Name: parentMemo.Name,
|
|
Comment: &apiv1.Memo{
|
|
Content: "This is a comment with custom create time",
|
|
Visibility: apiv1.Visibility_PRIVATE,
|
|
CreateTime: timestamppb.New(customCommentCreateTime),
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, comment)
|
|
require.Equal(t, customCommentCreateTime.Unix(), comment.CreateTime.AsTime().Unix(), "comment create_time should match the custom timestamp")
|
|
|
|
// Test 6: Verify that memos without custom timestamps still get auto-generated ones
|
|
memoWithoutTimestamps, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "This memo has auto-generated timestamps",
|
|
Visibility: apiv1.Visibility_PRIVATE,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memoWithoutTimestamps)
|
|
require.NotNil(t, memoWithoutTimestamps.CreateTime, "create_time should be auto-generated")
|
|
require.NotNil(t, memoWithoutTimestamps.UpdateTime, "update_time should be auto-generated")
|
|
require.True(t, time.Now().Unix()-memoWithoutTimestamps.CreateTime.AsTime().Unix() < 5, "create_time should be recent (within 5 seconds)")
|
|
}
|