mirror of https://github.com/usememos/memos.git
264 lines
8.7 KiB
Go
264 lines
8.7 KiB
Go
package test
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
apiv1 "github.com/usememos/memos/proto/gen/api/v1"
|
|
v1 "github.com/usememos/memos/server/router/api/v1" //nolint:revive
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
// TestListActivitiesWithDeletedMemos verifies that ListActivities gracefully handles
|
|
// activities that reference deleted memos instead of crashing the entire request.
|
|
func TestListActivitiesWithDeletedMemos(t *testing.T) {
|
|
ctx := context.Background()
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create two users - one to create memo, one to comment
|
|
userOne, err := ts.CreateRegularUser(ctx, "test-user-1")
|
|
require.NoError(t, err)
|
|
userOneCtx := ts.CreateUserContext(ctx, userOne.ID)
|
|
|
|
userTwo, err := ts.CreateRegularUser(ctx, "test-user-2")
|
|
require.NoError(t, err)
|
|
userTwoCtx := ts.CreateUserContext(ctx, userTwo.ID)
|
|
|
|
// Create a memo by userOne
|
|
memo1, err := ts.Service.CreateMemo(userOneCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "Original memo",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memo1)
|
|
|
|
// Create a comment on the memo by userTwo (this will create an activity for userOne)
|
|
comment, err := ts.Service.CreateMemoComment(userTwoCtx, &apiv1.CreateMemoCommentRequest{
|
|
Name: memo1.Name,
|
|
Comment: &apiv1.Memo{
|
|
Content: "This is a comment",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, comment)
|
|
|
|
// Verify activity was created for the comment (check from userOne's perspective - they receive the notification)
|
|
activities, err := ts.Service.ListActivities(userOneCtx, &apiv1.ListActivitiesRequest{})
|
|
require.NoError(t, err)
|
|
initialActivityCount := len(activities.Activities)
|
|
require.Greater(t, initialActivityCount, 0, "Should have at least one activity")
|
|
|
|
// Delete the original memo (this deletes the comment too)
|
|
_, err = ts.Service.DeleteMemo(userOneCtx, &apiv1.DeleteMemoRequest{
|
|
Name: memo1.Name,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// List activities again - should succeed even though the memo is deleted
|
|
activities, err = ts.Service.ListActivities(userOneCtx, &apiv1.ListActivitiesRequest{})
|
|
require.NoError(t, err)
|
|
// Activities list should be empty or not contain the deleted memo activity
|
|
for _, activity := range activities.Activities {
|
|
if activity.Payload != nil && activity.Payload.GetMemoComment() != nil {
|
|
require.NotEqual(t, memo1.Name, activity.Payload.GetMemoComment().Memo,
|
|
"Activity should not reference deleted memo")
|
|
}
|
|
}
|
|
// After deletion, there should be fewer activities
|
|
require.LessOrEqual(t, len(activities.Activities), initialActivityCount-1,
|
|
"Should have filtered out the activity for the deleted memo")
|
|
}
|
|
|
|
// TestGetActivityWithDeletedMemo verifies that GetActivity returns a proper error
|
|
// when trying to fetch an activity that references a deleted memo.
|
|
func TestGetActivityWithDeletedMemo(t *testing.T) {
|
|
ctx := context.Background()
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create two users
|
|
userOne, err := ts.CreateRegularUser(ctx, "test-user-1")
|
|
require.NoError(t, err)
|
|
userOneCtx := ts.CreateUserContext(ctx, userOne.ID)
|
|
|
|
userTwo, err := ts.CreateRegularUser(ctx, "test-user-2")
|
|
require.NoError(t, err)
|
|
userTwoCtx := ts.CreateUserContext(ctx, userTwo.ID)
|
|
|
|
// Create a memo by userOne
|
|
memo1, err := ts.Service.CreateMemo(userOneCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "Original memo",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, memo1)
|
|
|
|
// Create a comment to trigger activity creation by userTwo
|
|
comment, err := ts.Service.CreateMemoComment(userTwoCtx, &apiv1.CreateMemoCommentRequest{
|
|
Name: memo1.Name,
|
|
Comment: &apiv1.Memo{
|
|
Content: "Comment",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, comment)
|
|
|
|
// Get the activity ID by listing activities from userOne's perspective
|
|
activities, err := ts.Service.ListActivities(userOneCtx, &apiv1.ListActivitiesRequest{})
|
|
require.NoError(t, err)
|
|
require.Greater(t, len(activities.Activities), 0)
|
|
|
|
activityName := activities.Activities[0].Name
|
|
|
|
// Delete the memo
|
|
_, err = ts.Service.DeleteMemo(userOneCtx, &apiv1.DeleteMemoRequest{
|
|
Name: memo1.Name,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Try to get the specific activity - should return NotFound error
|
|
_, err = ts.Service.GetActivity(userOneCtx, &apiv1.GetActivityRequest{
|
|
Name: activityName,
|
|
})
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "activity references deleted content")
|
|
}
|
|
|
|
// TestActivitiesWithPartiallyDeletedMemos verifies that when some memos are deleted,
|
|
// other valid activities are still returned.
|
|
func TestActivitiesWithPartiallyDeletedMemos(t *testing.T) {
|
|
ctx := context.Background()
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create two users
|
|
userOne, err := ts.CreateRegularUser(ctx, "test-user-1")
|
|
require.NoError(t, err)
|
|
userOneCtx := ts.CreateUserContext(ctx, userOne.ID)
|
|
|
|
userTwo, err := ts.CreateRegularUser(ctx, "test-user-2")
|
|
require.NoError(t, err)
|
|
userTwoCtx := ts.CreateUserContext(ctx, userTwo.ID)
|
|
|
|
// Create two memos by userOne
|
|
memo1, err := ts.Service.CreateMemo(userOneCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "First memo",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memo2, err := ts.Service.CreateMemo(userOneCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "Second memo",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create comments on both by userTwo (creates activities for userOne)
|
|
_, err = ts.Service.CreateMemoComment(userTwoCtx, &apiv1.CreateMemoCommentRequest{
|
|
Name: memo1.Name,
|
|
Comment: &apiv1.Memo{
|
|
Content: "Comment on first",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.Service.CreateMemoComment(userTwoCtx, &apiv1.CreateMemoCommentRequest{
|
|
Name: memo2.Name,
|
|
Comment: &apiv1.Memo{
|
|
Content: "Comment on second",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Should have 2 activities from userOne's perspective
|
|
activities, err := ts.Service.ListActivities(userOneCtx, &apiv1.ListActivitiesRequest{})
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(activities.Activities))
|
|
|
|
// Delete first memo
|
|
_, err = ts.Service.DeleteMemo(userOneCtx, &apiv1.DeleteMemoRequest{
|
|
Name: memo1.Name,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// List activities - should still work and return only the second memo's activity
|
|
activities, err = ts.Service.ListActivities(userOneCtx, &apiv1.ListActivitiesRequest{})
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(activities.Activities), "Should have 1 activity remaining")
|
|
|
|
// Verify the remaining activity relates to a valid memo
|
|
require.NotNil(t, activities.Activities[0].Payload.GetMemoComment())
|
|
require.Contains(t, activities.Activities[0].Payload.GetMemoComment().RelatedMemo, "memos/")
|
|
}
|
|
|
|
// TestActivityStoreDirectDeletion tests the scenario where a memo is deleted directly
|
|
// from the store (simulating database-level deletion or migration).
|
|
func TestActivityStoreDirectDeletion(t *testing.T) {
|
|
ctx := context.Background()
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
user, err := ts.CreateRegularUser(ctx, "test-user")
|
|
require.NoError(t, err)
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// Create a memo
|
|
memo1, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{
|
|
Memo: &apiv1.Memo{
|
|
Content: "Test memo",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create a comment
|
|
comment, err := ts.Service.CreateMemoComment(userCtx, &apiv1.CreateMemoCommentRequest{
|
|
Name: memo1.Name,
|
|
Comment: &apiv1.Memo{
|
|
Content: "Test comment",
|
|
Visibility: apiv1.Visibility_PUBLIC,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Extract memo UID from the comment name
|
|
commentMemoUID, err := v1.ExtractMemoUIDFromName(comment.Name)
|
|
require.NoError(t, err)
|
|
|
|
commentMemo, err := ts.Store.GetMemo(ctx, &store.FindMemo{
|
|
UID: &commentMemoUID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, commentMemo)
|
|
|
|
// Delete the comment memo directly from store (simulating orphaned activity)
|
|
err = ts.Store.DeleteMemo(ctx, &store.DeleteMemo{ID: commentMemo.ID})
|
|
require.NoError(t, err)
|
|
|
|
// List activities should still succeed even with orphaned activity
|
|
activities, err := ts.Service.ListActivities(userCtx, &apiv1.ListActivitiesRequest{})
|
|
require.NoError(t, err)
|
|
// Activities should be empty or not include the orphaned one
|
|
for _, activity := range activities.Activities {
|
|
if activity.Payload != nil && activity.Payload.GetMemoComment() != nil {
|
|
require.NotEqual(t, comment.Name, activity.Payload.GetMemoComment().Memo,
|
|
"Should not return activity with deleted memo")
|
|
}
|
|
}
|
|
}
|