Skip to content

armgit / memos

Public Imported from GitHub
0

Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.

15.3 KB
Raw Blame
package test

import (
	"context"
	"fmt"
	"testing"

	"github.com/stretchr/testify/require"

	storepb "github.com/usememos/memos/proto/gen/store"
	"github.com/usememos/memos/store"
)

func TestDeleteUserIsIdempotent(t *testing.T) {
	ctx := context.Background()
	ts := NewTestingStore(ctx, t)
	defer ts.Close()

	user, err := createTestingUserWithRole(ctx, ts, "delete-idempotent", store.RoleUser)
	require.NoError(t, err)
	first, err := ts.DeleteUser(ctx, &store.DeleteUser{ID: user.ID})
	require.NoError(t, err)
	require.NotNil(t, first)
	second, err := ts.DeleteUser(ctx, &store.DeleteUser{ID: user.ID})
	require.NoError(t, err)
	require.NotNil(t, second)
	require.Empty(t, second.UserSettingKeys)
}

func TestDeleteUserBatchBoundariesAndRollback(t *testing.T) {
	for _, count := range []int{499, 500, 501, 1001} {
		t.Run(fmt.Sprint(count), func(t *testing.T) {
			ctx := context.Background()
			ts := NewTestingStore(ctx, t)
			defer ts.Close()
			owner, err := createTestingUserWithRole(ctx, ts, "batch-owner", store.RoleUser)
			require.NoError(t, err)
			peer, err := createTestingUserWithRole(ctx, ts, "batch-peer", store.RoleUser)
			require.NoError(t, err)
			keepMemo, err := ts.CreateMemo(ctx, &store.Memo{UID: "keep-memo", CreatorID: peer.ID, Content: "keep", Visibility: store.Public})
			require.NoError(t, err)
			keepMemo, err = ts.GetMemo(ctx, &store.FindMemo{ID: &keepMemo.ID})
			require.NoError(t, err)
			keepAttachment, err := ts.CreateAttachment(ctx, &store.Attachment{UID: "keep-attachment", CreatorID: peer.ID,
				MemoID: &keepMemo.ID, Filename: "keep.txt", Type: "text/plain", Blob: []byte("keep")})
			require.NoError(t, err)
			keepInbox, err := ts.CreateInbox(ctx, &store.Inbox{SenderID: peer.ID, ReceiverID: peer.ID, Status: store.UNREAD,
				Message: &storepb.InboxMessage{Type: storepb.InboxMessage_MEMO_MENTION}})
			require.NoError(t, err)
			keepShare, err := ts.CreateMemoShare(ctx, &store.MemoShare{UID: "keep-share", MemoID: keepMemo.ID, CreatorID: peer.ID})
			require.NoError(t, err)
			keepReaction, err := ts.UpsertReaction(ctx, &store.Reaction{CreatorID: peer.ID, MemoID: keepMemo.ID, ReactionType: "keep"})
			require.NoError(t, err)
			attachmentIDs := make([]int32, 0, count)
			for i := range count {
				uid := fmt.Sprintf("batch-%d", i)
				memo, err := ts.CreateMemo(ctx, &store.Memo{UID: uid, CreatorID: owner.ID, Content: uid, Visibility: store.Public})
				require.NoError(t, err)
				creatorID := owner.ID
				if i%2 == 0 {
					creatorID = peer.ID
				}
				attachment, err := ts.CreateAttachment(ctx, &store.Attachment{UID: uid, CreatorID: creatorID, MemoID: &memo.ID,
					Filename: uid + ".txt", Type: "text/plain", Blob: []byte(uid), Reference: uid})
				require.NoError(t, err)
				attachmentIDs = append(attachmentIDs, attachment.ID)
				_, err = ts.UpsertReaction(ctx, &store.Reaction{CreatorID: peer.ID, MemoID: memo.ID, ReactionType: "thumbs-up"})
				require.NoError(t, err)
				_, err = ts.CreateMemoShare(ctx, &store.MemoShare{UID: uid, MemoID: memo.ID, CreatorID: peer.ID})
				require.NoError(t, err)
				_, err = ts.CreateInbox(ctx, &store.Inbox{SenderID: owner.ID, ReceiverID: peer.ID, Status: store.UNREAD,
					Message: &storepb.InboxMessage{Type: storepb.InboxMessage_MEMO_MENTION}})
				require.NoError(t, err)
				// Exercise both incoming and outgoing relation cleanup across every batch.
				_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: memo.ID, RelatedMemoID: keepMemo.ID, Type: store.MemoRelationReference})
				require.NoError(t, err)
				_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: keepMemo.ID, RelatedMemoID: memo.ID, Type: store.MemoRelationReference})
				require.NoError(t, err)
			}
			_, err = ts.UpsertUserSetting(ctx, &storepb.UserSetting{UserId: owner.ID, Key: storepb.UserSetting_GENERAL,
				Value: &storepb.UserSetting_General{General: &storepb.GeneralUserSetting{Locale: "en"}}})
			require.NoError(t, err)
			_, err = ts.CreateUserIdentity(ctx, &store.UserIdentity{UserID: owner.ID, Provider: "test", ExternUID: "batch-owner"})
			require.NoError(t, err)
			// Prime facade caches before forcing a failure after every delete statement.
			_, err = ts.GetUser(ctx, &store.FindUser{ID: &owner.ID})
			require.NoError(t, err)
			_, err = ts.GetUserSetting(ctx, &store.FindUserSetting{UserID: &owner.ID, Key: storepb.UserSetting_GENERAL})
			require.NoError(t, err)
			if count > 500 {
				before := snapshotUserDeletion(t, ts)
				result, err := ts.DeleteUser(store.WithDeleteUserFailpoint(ctx, store.DeleteUserFailpointBeforeCommit), &store.DeleteUser{ID: owner.ID})
				require.ErrorContains(t, err, "delete user failpoint before commit")
				require.Nil(t, result, "failed deletion must not expose resources for physical cleanup")
				require.Equal(t, before, snapshotUserDeletion(t, ts), "all batches and related tables must roll back")
				cachedUser, err := ts.GetUser(ctx, &store.FindUser{ID: &owner.ID})
				require.NoError(t, err)
				require.NotNil(t, cachedUser)
				cachedSetting, err := ts.GetUserSetting(ctx, &store.FindUserSetting{UserID: &owner.ID, Key: storepb.UserSetting_GENERAL})
				require.NoError(t, err)
				require.Equal(t, "en", cachedSetting.GetGeneral().GetLocale())
			}
			result, err := ts.DeleteUser(ctx, &store.DeleteUser{ID: owner.ID})
			require.NoError(t, err)
			require.ElementsMatch(t, []storepb.UserSetting_Key{storepb.UserSetting_GENERAL}, result.UserSettingKeys)
			var deletedIDs []int32
			for _, attachment := range result.Attachments {
				deletedIDs = append(deletedIDs, attachment.ID)
				require.Equal(t, attachment.UID, attachment.Reference)
			}
			require.ElementsMatch(t, attachmentIDs, deletedIDs, "each attachment must be returned exactly once, even if both owner and memo match")
			after := snapshotUserDeletion(t, ts)
			require.Len(t, after.users, 1)
			require.Equal(t, peer.ID, after.users[0].ID)
			require.Equal(t, []*store.Memo{keepMemo}, after.memos)
			require.Len(t, after.attachments, 1)
			require.Equal(t, keepAttachment.ID, after.attachments[0].ID)
			require.Equal(t, []byte("keep"), after.attachments[0].Blob)
			require.Equal(t, []*store.MemoShare{keepShare}, after.shares)
			require.Equal(t, []*store.Reaction{keepReaction}, after.reactions)
			require.Len(t, after.inboxes, 1)
			require.Equal(t, keepInbox.ID, after.inboxes[0].ID)
			require.Empty(t, after.relations)
			require.Empty(t, after.settings)
			require.Empty(t, after.identities)
			cachedUser, err := ts.GetUser(ctx, &store.FindUser{ID: &owner.ID})
			require.NoError(t, err)
			require.Nil(t, cachedUser)
			cachedSetting, err := ts.GetUserSetting(ctx, &store.FindUserSetting{UserID: &owner.ID, Key: storepb.UserSetting_GENERAL})
			require.NoError(t, err)
			require.Nil(t, cachedSetting)
		})
	}
}

type userDeletionSnapshot struct {
	users       []*store.User
	memos       []*store.Memo
	attachments []*store.Attachment
	shares      []*store.MemoShare
	reactions   []*store.Reaction
	inboxes     []*store.Inbox
	relations   []*store.MemoRelation
	settings    []*storepb.UserSetting
	identities  []*store.UserIdentity
}

func snapshotUserDeletion(t *testing.T, ts *store.Store) userDeletionSnapshot {
	t.Helper()
	ctx := context.Background()
	var result userDeletionSnapshot
	var err error
	result.users, err = ts.ListUsers(ctx, &store.FindUser{})
	require.NoError(t, err)
	result.memos, err = ts.ListMemos(ctx, &store.FindMemo{})
	require.NoError(t, err)
	result.attachments, err = ts.ListAttachments(ctx, &store.FindAttachment{GetBlob: true, SkipDefaultLimit: true})
	require.NoError(t, err)
	result.shares, err = ts.ListMemoShares(ctx, &store.FindMemoShare{})
	require.NoError(t, err)
	result.reactions, err = ts.ListReactions(ctx, &store.FindReaction{})
	require.NoError(t, err)
	result.inboxes, err = ts.ListInboxes(ctx, &store.FindInbox{})
	require.NoError(t, err)
	result.relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{})
	require.NoError(t, err)
	result.settings, err = ts.ListUserSettings(ctx, &store.FindUserSetting{})
	require.NoError(t, err)
	result.identities, err = ts.ListUserIdentities(ctx, &store.FindUserIdentity{})
	require.NoError(t, err)
	return result
}

func TestDeleteUserCleansRelatedData(t *testing.T) {
	t.Parallel()

	ctx := context.Background()
	ts := NewTestingStore(ctx, t)
	defer ts.Close()

	user, err := createTestingUserWithRole(ctx, ts, "test", store.RoleUser)
	require.NoError(t, err)
	peer, err := createTestingUserWithRole(ctx, ts, "delete-peer", store.RoleUser)
	require.NoError(t, err)

	ownMemo, err := ts.CreateMemo(ctx, &store.Memo{
		UID:        "delete-own-memo",
		CreatorID:  user.ID,
		Content:    "owner memo",
		Visibility: store.Public,
	})
	require.NoError(t, err)
	peerMemo, err := ts.CreateMemo(ctx, &store.Memo{
		UID:        "delete-peer-memo",
		CreatorID:  peer.ID,
		Content:    "peer memo",
		Visibility: store.Public,
	})
	require.NoError(t, err)
	peerCommentOnOwnMemo, err := ts.CreateMemoComment(ctx, &store.Memo{
		UID:       "delete-peer-comment",
		CreatorID: peer.ID,
		Content:   "peer comment on owner memo",
	}, ownMemo.ID, peer.ID)
	require.NoError(t, err)
	userCommentOnPeerMemo, err := ts.CreateMemoComment(ctx, &store.Memo{
		UID:       "delete-user-comment",
		CreatorID: user.ID,
		Content:   "owner comment on peer memo",
	}, peerMemo.ID, user.ID)
	require.NoError(t, err)

	ownerAttachment, err := ts.CreateAttachment(ctx, &store.Attachment{
		UID:       "delete-owner-attachment",
		CreatorID: user.ID,
		Filename:  "owner.txt",
		Type:      "text/plain",
		Size:      5,
		Blob:      []byte("owner"),
		MemoID:    &ownMemo.ID,
	})
	require.NoError(t, err)
	peerAttachmentOnDeletedMemo, err := ts.CreateAttachment(ctx, &store.Attachment{
		UID:       "delete-peer-attachment",
		CreatorID: peer.ID,
		Filename:  "peer-on-owner.txt",
		Type:      "text/plain",
		Size:      4,
		Blob:      []byte("peer"),
		MemoID:    &ownMemo.ID,
	})
	require.NoError(t, err)
	peerAttachmentToKeep, err := ts.CreateAttachment(ctx, &store.Attachment{
		UID:       "keep-peer-attachment",
		CreatorID: peer.ID,
		Filename:  "peer.txt",
		Type:      "text/plain",
		Size:      4,
		Blob:      []byte("peer"),
		MemoID:    &peerMemo.ID,
	})
	require.NoError(t, err)

	_, err = ts.UpsertReaction(ctx, &store.Reaction{
		CreatorID:    peer.ID,
		MemoID:       ownMemo.ID,
		ReactionType: "thumbs-up",
	})
	require.NoError(t, err)
	_, err = ts.UpsertReaction(ctx, &store.Reaction{
		CreatorID:    user.ID,
		MemoID:       peerMemo.ID,
		ReactionType: "heart",
	})
	require.NoError(t, err)
	peerReactionToKeep, err := ts.UpsertReaction(ctx, &store.Reaction{
		CreatorID:    peer.ID,
		MemoID:       peerMemo.ID,
		ReactionType: "sparkle",
	})
	require.NoError(t, err)

	_, err = ts.CreateMemoShare(ctx, &store.MemoShare{
		UID:       "delete-owner-share",
		MemoID:    peerMemo.ID,
		CreatorID: user.ID,
	})
	require.NoError(t, err)
	_, err = ts.CreateMemoShare(ctx, &store.MemoShare{
		UID:       "delete-memo-share",
		MemoID:    ownMemo.ID,
		CreatorID: peer.ID,
	})
	require.NoError(t, err)
	peerShareToKeep, err := ts.CreateMemoShare(ctx, &store.MemoShare{
		UID:       "keep-peer-share",
		MemoID:    peerMemo.ID,
		CreatorID: peer.ID,
	})
	require.NoError(t, err)

	_, err = ts.CreateInbox(ctx, &store.Inbox{
		SenderID:   user.ID,
		ReceiverID: peer.ID,
		Status:     store.UNREAD,
		Message:    &storepb.InboxMessage{Type: storepb.InboxMessage_MEMO_MENTION},
	})
	require.NoError(t, err)
	referencingDeletedMemoInbox, err := ts.CreateInbox(ctx, &store.Inbox{
		SenderID:   peer.ID,
		ReceiverID: peer.ID,
		Status:     store.UNREAD,
		Message: &storepb.InboxMessage{
			Type: storepb.InboxMessage_MEMO_COMMENT,
			Payload: &storepb.InboxMessage_MemoComment{
				MemoComment: &storepb.InboxMessage_MemoCommentPayload{
					MemoId: ownMemo.ID,
				},
			},
		},
	})
	require.NoError(t, err)
	inboxToKeep, err := ts.CreateInbox(ctx, &store.Inbox{
		SenderID:   peer.ID,
		ReceiverID: peer.ID,
		Status:     store.UNREAD,
		Message: &storepb.InboxMessage{
			Type: storepb.InboxMessage_MEMO_COMMENT,
			Payload: &storepb.InboxMessage_MemoComment{
				MemoComment: &storepb.InboxMessage_MemoCommentPayload{
					MemoId: peerMemo.ID,
				},
			},
		},
	})
	require.NoError(t, err)

	_, err = ts.CreateUserIdentity(ctx, &store.UserIdentity{
		UserID:    user.ID,
		Provider:  "google",
		ExternUID: "delete-user-sub",
	})
	require.NoError(t, err)
	err = ts.AddUserPersonalAccessToken(ctx, user.ID, &storepb.PersonalAccessTokensUserSetting_PersonalAccessToken{
		TokenId:     "delete-user-pat",
		TokenHash:   "delete-user-pat-hash",
		Description: "delete user pat",
	})
	require.NoError(t, err)

	_, err = ts.DeleteUser(ctx, &store.DeleteUser{ID: user.ID})
	require.NoError(t, err)

	deletedUser, err := ts.GetUser(ctx, &store.FindUser{ID: &user.ID})
	require.NoError(t, err)
	require.Nil(t, deletedUser)
	keptUser, err := ts.GetUser(ctx, &store.FindUser{ID: &peer.ID})
	require.NoError(t, err)
	require.NotNil(t, keptUser)

	for _, memo := range []*store.Memo{ownMemo, userCommentOnPeerMemo} {
		got, getErr := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID})
		require.NoError(t, getErr)
		require.Nil(t, got, memo.UID)
	}
	for _, memo := range []*store.Memo{peerMemo, peerCommentOnOwnMemo} {
		got, getErr := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID})
		require.NoError(t, getErr)
		require.NotNil(t, got, memo.UID)
	}

	for _, attachment := range []*store.Attachment{ownerAttachment, peerAttachmentOnDeletedMemo} {
		got, getErr := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID})
		require.NoError(t, getErr)
		require.Nil(t, got, attachment.UID)
	}
	keptAttachment, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &peerAttachmentToKeep.ID})
	require.NoError(t, err)
	require.NotNil(t, keptAttachment)

	deletedMemoRelations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoIDList: []int32{ownMemo.ID, peerCommentOnOwnMemo.ID, userCommentOnPeerMemo.ID}})
	require.NoError(t, err)
	require.Empty(t, deletedMemoRelations, "relations incident to deleted memos must be removed without deleting the other endpoint")

	keptReactions, err := ts.ListReactions(ctx, &store.FindReaction{MemoID: &peerMemo.ID})
	require.NoError(t, err)
	require.Len(t, keptReactions, 1)
	require.Equal(t, peerReactionToKeep.ID, keptReactions[0].ID)

	deletedOwnerShares, err := ts.ListMemoShares(ctx, &store.FindMemoShare{CreatorID: &user.ID})
	require.NoError(t, err)
	require.Empty(t, deletedOwnerShares)
	keptShare, err := ts.GetMemoShare(ctx, &store.FindMemoShare{ID: &peerShareToKeep.ID})
	require.NoError(t, err)
	require.NotNil(t, keptShare)

	deletedSentInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{SenderID: &user.ID})
	require.NoError(t, err)
	require.Empty(t, deletedSentInboxes)
	deletedReceivedInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{ReceiverID: &user.ID})
	require.NoError(t, err)
	require.Empty(t, deletedReceivedInboxes)
	referencedInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{ID: &referencingDeletedMemoInbox.ID})
	require.NoError(t, err)
	require.Len(t, referencedInboxes, 1, "deleting a referenced memo must not control another user's inbox lifecycle")
	keptInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{ID: &inboxToKeep.ID})
	require.NoError(t, err)
	require.Len(t, keptInboxes, 1)

	identities, err := ts.ListUserIdentities(ctx, &store.FindUserIdentity{UserID: &user.ID})
	require.NoError(t, err)
	require.Empty(t, identities)
	setting, err := ts.GetUserSetting(ctx, &store.FindUserSetting{
		UserID: &user.ID,
		Key:    storepb.UserSetting_PERSONAL_ACCESS_TOKENS,
	})
	require.NoError(t, err)
	require.Nil(t, setting)
}