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.

test(store): expand cross-database edge case coverage

bluedbird7a0586af0d36
diff --git a/store/memo_attachment.go b/store/memo_attachment.go
index 91075db79..690ec4e4b 100644
--- a/store/memo_attachment.go
+++ b/store/memo_attachment.go
@@ -108,7 +108,8 @@ func (s *Store) ApplyMemoMutation(ctx context.Context, mutation *MemoMutation) e
mutation.MemoCreatorID = create.CreatorID
mutation.ExpectedMemoContent = create.Content
}
- if err := validateMemoWritePolicy(mutation.Policy); err != nil {
+ policy := mutation.WritePolicy()
+ if err := validateMemoWritePolicy(policy); err != nil {
return err
}
mutation.RemovedAttachmentIDs = slices.Clone(mutation.RemovedAttachmentIDs)
@@ -124,10 +125,11 @@ func (s *Store) ApplyMemoMutation(ctx context.Context, mutation *MemoMutation) e
removedAttachmentIDs[attachmentID] = struct{}{}
}
for _, binding := range mutation.Bindings {
- if binding != nil {
- if _, removed := removedAttachmentIDs[binding.ID]; removed {
- return errors.New("attachment cannot be both bound and removed")
- }
+ if binding == nil {
+ return errors.New("attachment binding is required")
+ }
+ if _, removed := removedAttachmentIDs[binding.ID]; removed {
+ return errors.New("attachment cannot be both bound and removed")
}
}
for _, attachmentID := range mutation.RequiredAttachmentIDs {
@@ -135,7 +137,7 @@ func (s *Store) ApplyMemoMutation(ctx context.Context, mutation *MemoMutation) e
return errors.New("attachment cannot be both required and removed")
}
}
- if mutation.Policy != nil && mutation.Policy.LifecycleOnly &&
+ if policy != nil && policy.LifecycleOnly &&
(len(mutation.Bindings) != 0 || len(mutation.RemovedAttachmentIDs) != 0 || len(mutation.RequiredAttachmentIDs) != 0 || mutation.ReplaceReferenceRelations) {
return ErrMemoSpaceMembershipRequired
}
diff --git a/store/memo_attachment_test.go b/store/memo_attachment_test.go
new file mode 100644
index 000000000..95b64069d
--- /dev/null
+++ b/store/memo_attachment_test.go
@@ -0,0 +1,160 @@
+package store_test
+
+import (
+ "context"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/usememos/memos/store"
+)
+
+func TestMemoMutationRejectsInvalidInputBeforeWriting(t *testing.T) {
+ creation := func() *store.MemoMutation {
+ return &store.MemoMutation{MemoCreate: &store.Memo{UID: "new-memo", CreatorID: 1, Visibility: store.Private}}
+ }
+ references := func(relations ...*store.MemoRelation) *store.MemoMutation {
+ return &store.MemoMutation{MemoID: 1, MemoCreatorID: 1, ReplaceReferenceRelations: true, ReferenceRelations: relations}
+ }
+ tests := []struct {
+ name string
+ mutation func() *store.MemoMutation
+ message string
+ }{
+ {"nil mutation", func() *store.MemoMutation { return nil }, "memo mutation is required"},
+ {"create and update", func() *store.MemoMutation {
+ m := creation()
+ m.MemoUpdate = &store.UpdateMemo{ID: 1}
+ return m
+ }, "cannot update or remove existing state"},
+ {"create with update policy", func() *store.MemoMutation {
+ m := creation()
+ m.Policy = &store.MemoWritePolicy{ActorUserID: 1}
+ return m
+ }, "cannot update or remove existing state"},
+ {"create and delete attachment", func() *store.MemoMutation {
+ m := creation()
+ m.RemovedAttachmentIDs = []int32{1}
+ return m
+ }, "cannot update or remove existing state"},
+ {"missing creator", func() *store.MemoMutation {
+ m := creation()
+ m.MemoCreate.CreatorID = 0
+ return m
+ }, "requires creator"},
+ {"invalid creation UID", func() *store.MemoMutation {
+ m := creation()
+ m.MemoCreate.UID = "invalid uid"
+ return m
+ }, "invalid uid"},
+ {"invalid creation visibility", func() *store.MemoMutation {
+ m := creation()
+ m.MemoCreate.Visibility = "INVALID"
+ return m
+ }, "invalid visibility"},
+ {"space audience without placement", func() *store.MemoMutation {
+ m := creation()
+ m.MemoCreate.Visibility = store.SpaceAudience
+ return m
+ }, "SPACE visibility requires a space"},
+ {"invalid comment context", func() *store.MemoMutation {
+ m := creation()
+ m.CommentContextMemoID = new(int32(0))
+ return m
+ }, "valid context memo"},
+ {"missing policy actor", func() *store.MemoMutation {
+ return &store.MemoMutation{Policy: &store.MemoWritePolicy{}}
+ }, "write policy requires actor"},
+ {"missing fallback policy actor", func() *store.MemoMutation {
+ return &store.MemoMutation{MemoUpdate: &store.UpdateMemo{ID: 1, Policy: &store.MemoWritePolicy{}}}
+ }, "write policy requires actor"},
+ {"conflicting policy actions", func() *store.MemoMutation {
+ return &store.MemoMutation{Policy: &store.MemoWritePolicy{ActorUserID: 1, LifecycleOnly: true, CreatingShare: true}}
+ }, "conflicting actions"},
+ {"conflicting fallback policy actions", func() *store.MemoMutation {
+ return &store.MemoMutation{MemoUpdate: &store.UpdateMemo{ID: 1, Policy: &store.MemoWritePolicy{
+ ActorUserID: 1, LifecycleOnly: true, CreatingShare: true,
+ }}}
+ }, "conflicting actions"},
+ {"zero removed ID", func() *store.MemoMutation {
+ return &store.MemoMutation{RemovedAttachmentIDs: []int32{0}}
+ }, "IDs must be positive"},
+ {"nil attachment binding", func() *store.MemoMutation {
+ return &store.MemoMutation{Bindings: []*store.MemoAttachmentBinding{nil}}
+ }, "attachment binding is required"},
+ {"negative removed ID", func() *store.MemoMutation {
+ return &store.MemoMutation{RemovedAttachmentIDs: []int32{-1}}
+ }, "IDs must be positive"},
+ {"nonadjacent duplicate removed IDs", func() *store.MemoMutation {
+ return &store.MemoMutation{RemovedAttachmentIDs: []int32{2, 1, 2}}
+ }, "duplicate removed attachment ID"},
+ {"bind and remove same attachment", func() *store.MemoMutation {
+ return &store.MemoMutation{RemovedAttachmentIDs: []int32{1}, Bindings: []*store.MemoAttachmentBinding{{ID: 1}}}
+ }, "both bound and removed"},
+ {"require and remove same attachment", func() *store.MemoMutation {
+ return &store.MemoMutation{RemovedAttachmentIDs: []int32{1}, RequiredAttachmentIDs: []int32{1}}
+ }, "both required and removed"},
+ {"reference without actor", func() *store.MemoMutation {
+ m := references()
+ m.MemoCreatorID = 0
+ return m
+ }, "requires an actor"},
+ {"nil reference", func() *store.MemoMutation { return references(nil) }, "only REFERENCE"},
+ {"invalid reference target", func() *store.MemoMutation {
+ return references(&store.MemoRelation{MemoID: 1, Type: store.MemoRelationReference})
+ }, "only REFERENCE"},
+ {"comment relation replacement", func() *store.MemoMutation {
+ return references(&store.MemoRelation{MemoID: 1, RelatedMemoID: 2, Type: store.MemoRelationComment})
+ }, "only REFERENCE"},
+ {"wrong reference source", func() *store.MemoMutation {
+ return references(&store.MemoRelation{MemoID: 3, RelatedMemoID: 2, Type: store.MemoRelationReference})
+ }, "source does not match"},
+ {"self reference", func() *store.MemoMutation {
+ return references(&store.MemoRelation{MemoID: 1, RelatedMemoID: 1, Type: store.MemoRelationReference})
+ }, "reflexive memo relations"},
+ {"duplicate references", func() *store.MemoMutation {
+ return references(
+ &store.MemoRelation{MemoID: 1, RelatedMemoID: 2, Type: store.MemoRelationReference},
+ &store.MemoRelation{MemoID: 1, RelatedMemoID: 2, Type: store.MemoRelationReference},
+ )
+ }, "duplicate memo reference"},
+ }
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ // No driver is installed: invalid input must fail before database access.
+ s := &store.Store{}
+ require.ErrorContains(t, s.ApplyMemoMutation(context.Background(), tc.mutation()), tc.message)
+ })
+ }
+}
+
+func TestMemoLifecycleMutationRejectsDependentWrites(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ change func(*store.MemoMutation)
+ }{
+ {"bindings", func(m *store.MemoMutation) { m.Bindings = []*store.MemoAttachmentBinding{{ID: 1}} }},
+ {"removals", func(m *store.MemoMutation) { m.RemovedAttachmentIDs = []int32{1} }},
+ {"required attachments", func(m *store.MemoMutation) { m.RequiredAttachmentIDs = []int32{1} }},
+ {"reference replacement", func(m *store.MemoMutation) { m.ReplaceReferenceRelations = true }},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ for _, source := range []string{"mutation policy", "update policy fallback"} {
+ t.Run(source, func(t *testing.T) {
+ mutation := &store.MemoMutation{
+ MemoID: 1, MemoCreatorID: 1,
+ MemoUpdate: &store.UpdateMemo{ID: 1, ClearSpace: true},
+ }
+ policy := &store.MemoWritePolicy{ActorUserID: 1, LifecycleOnly: true}
+ if source == "mutation policy" {
+ mutation.Policy = policy
+ } else {
+ mutation.MemoUpdate.Policy = policy
+ }
+ tc.change(mutation)
+ require.ErrorIs(t, (&store.Store{}).ApplyMemoMutation(context.Background(), mutation), store.ErrMemoSpaceMembershipRequired)
+ })
+ }
+ })
+ }
+}
diff --git a/store/memo_share_test.go b/store/memo_share_test.go
new file mode 100644
index 000000000..00fa78a21
--- /dev/null
+++ b/store/memo_share_test.go
@@ -0,0 +1,36 @@
+package store_test
+
+import (
+ "context"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/usememos/memos/store"
+)
+
+func TestMemoShareRejectsInvalidInputBeforeWriting(t *testing.T) {
+ ts := &store.Store{} // Invalid input must be rejected before using a driver.
+ for _, test := range []struct {
+ name string
+ delete *store.DeleteMemoShare
+ }{
+ {"nil", nil},
+ {"no selector", &store.DeleteMemoShare{}},
+ {"memo only", &store.DeleteMemoShare{MemoID: new(int32(1))}},
+ {"missing actor", &store.DeleteMemoShare{ID: new(int32(1)), MemoID: new(int32(1)), Policy: &store.MemoWritePolicy{}}},
+ {"missing memo", &store.DeleteMemoShare{ID: new(int32(1)), Policy: &store.MemoWritePolicy{ActorUserID: 1}}},
+ {"invalid memo", &store.DeleteMemoShare{ID: new(int32(1)), MemoID: new(int32(0)), Policy: &store.MemoWritePolicy{ActorUserID: 1}}},
+ {"conflicting actions", &store.DeleteMemoShare{ID: new(int32(1)), MemoID: new(int32(1)), Policy: &store.MemoWritePolicy{
+ ActorUserID: 1, LifecycleOnly: true, CreatingShare: true,
+ }}},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ require.Error(t, ts.DeleteMemoShare(context.Background(), test.delete))
+ })
+ }
+ _, err := ts.CreateMemoShare(context.Background(), nil)
+ require.Error(t, err)
+ _, err = ts.CreateMemoShare(context.Background(), &store.MemoShare{Policy: &store.MemoWritePolicy{}})
+ require.Error(t, err)
+}
diff --git a/store/memo_view_icon_test.go b/store/memo_view_icon_test.go
new file mode 100644
index 000000000..8b45c606b
--- /dev/null
+++ b/store/memo_view_icon_test.go
@@ -0,0 +1,35 @@
+package store
+
+import (
+ "strings"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/usememos/memos/proto/gen/store"
+)
+
+func TestValidateMemoViewIcon(t *testing.T) {
+ require.NoError(t, ValidateMemoViewIcon(nil))
+ require.Error(t, ValidateMemoViewIcon(&storepb.MemoViewsUserSetting_MemoView_Icon{}))
+ for _, emoji := range []string{"🌱", "πŸ‘©πŸ½β€πŸŒΎ", "πŸ‡ΈπŸ‡¬", "❀️", "1️⃣"} {
+ require.NoError(t, ValidateMemoViewIcon(&storepb.MemoViewsUserSetting_MemoView_Icon{
+ Value: &storepb.MemoViewsUserSetting_MemoView_Icon_Emoji{Emoji: emoji},
+ }), emoji)
+ }
+ for _, emoji := range []string{"", "leaf", "🌱🌱", " 🌱", "🏻", "\xff"} {
+ require.Error(t, ValidateMemoViewIcon(&storepb.MemoViewsUserSetting_MemoView_Icon{
+ Value: &storepb.MemoViewsUserSetting_MemoView_Icon_Emoji{Emoji: emoji},
+ }), emoji)
+ }
+ for _, name := range []string{"leaf", "book-open", "circle-1", "future-icon", strings.Repeat("a", 128)} {
+ require.NoError(t, ValidateMemoViewIcon(&storepb.MemoViewsUserSetting_MemoView_Icon{
+ Value: &storepb.MemoViewsUserSetting_MemoView_Icon_Lucide{Lucide: name},
+ }), name)
+ }
+ for _, name := range []string{"", "LeafIcon", "book_open", "-leaf", "leaf-", "book--open", "<svg>", strings.Repeat("a", 129)} {
+ require.Error(t, ValidateMemoViewIcon(&storepb.MemoViewsUserSetting_MemoView_Icon{
+ Value: &storepb.MemoViewsUserSetting_MemoView_Icon_Lucide{Lucide: name},
+ }), name)
+ }
+}
diff --git a/store/test/attachment_test.go b/store/test/attachment_test.go
index 22e46dbc3..ac2b46f13 100644
--- a/store/test/attachment_test.go
+++ b/store/test/attachment_test.go
@@ -392,7 +392,7 @@ func TestMemoMutationRollsBackWhenRequiredAttachmentIsMissing(t *testing.T) {
require.Equal(t, memo.ID, *storedRemoved.MemoID)
}
-func TestMemoMutationRollsBackMemoAndRelationsTogether(t *testing.T) {
+func TestMemoMutationRejectsCommentInReferenceReplacement(t *testing.T) {
t.Parallel()
ctx := context.Background()
ts := NewTestingStore(ctx, t)
diff --git a/store/test/delete_rollback_test.go b/store/test/delete_rollback_test.go
new file mode 100644
index 000000000..b6e5b6266
--- /dev/null
+++ b/store/test/delete_rollback_test.go
@@ -0,0 +1,46 @@
+package test
+
+import (
+ "context"
+ "fmt"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/usememos/memos/store"
+)
+
+// rejectStoreDelete injects a real database failure in an isolated test database.
+// Table names are fixed by the tests, never supplied by application input.
+func rejectStoreDelete(t *testing.T, ts *store.Store, table string) func() {
+ t.Helper()
+ var statements []string
+ drop := "DROP TRIGGER reject_store_delete"
+ switch getDriverFromEnv() {
+ case "sqlite":
+ statements = []string{fmt.Sprintf(`CREATE TRIGGER reject_store_delete BEFORE DELETE ON %s
+ BEGIN SELECT RAISE(ABORT, 'store test delete failure'); END`, table)}
+ case "mysql":
+ statements = []string{fmt.Sprintf(`CREATE TRIGGER reject_store_delete BEFORE DELETE ON %s
+ FOR EACH ROW SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'store test delete failure'`, table)}
+ case "postgres":
+ statements = []string{
+ `CREATE FUNCTION reject_store_delete() RETURNS trigger AS $$
+ BEGIN RAISE EXCEPTION 'store test delete failure'; END; $$ LANGUAGE plpgsql`,
+ fmt.Sprintf(`CREATE TRIGGER reject_store_delete BEFORE DELETE ON %s
+ FOR EACH ROW EXECUTE FUNCTION reject_store_delete()`, table),
+ }
+ drop += " ON " + table
+ default:
+ t.Fatalf("unsupported driver: %s", getDriverFromEnv())
+ }
+ for _, statement := range statements {
+ _, err := ts.GetDriver().GetDB().ExecContext(context.Background(), statement)
+ require.NoError(t, err)
+ }
+ return func() {
+ t.Helper()
+ _, err := ts.GetDriver().GetDB().ExecContext(context.Background(), drop)
+ require.NoError(t, err)
+ }
+}
diff --git a/store/test/memo_mutation_test.go b/store/test/memo_mutation_test.go
new file mode 100644
index 000000000..fbc865627
--- /dev/null
+++ b/store/test/memo_mutation_test.go
@@ -0,0 +1,545 @@
+package test
+
+import (
+ "context"
+ "fmt"
+ "sync"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/usememos/memos/proto/gen/store"
+ "github.com/usememos/memos/store"
+)
+
+type memoMutationFixture struct {
+ t *testing.T
+ ctx context.Context
+ store *store.Store
+ owner, peer *store.User
+ memo, target, next *store.Memo
+ added, removed, kept *store.Attachment
+}
+
+func newMemoMutationFixture(t *testing.T) *memoMutationFixture {
+ t.Helper()
+ f := &memoMutationFixture{t: t, ctx: context.Background()}
+ f.store = NewTestingStore(f.ctx, t)
+ t.Cleanup(func() { require.NoError(t, f.store.Close()) })
+ var err error
+ f.owner, err = f.store.CreateUser(f.ctx, &store.User{Username: "mutation-owner", Role: store.RoleUser})
+ require.NoError(t, err)
+ f.peer, err = f.store.CreateUser(f.ctx, &store.User{Username: "mutation-peer", Role: store.RoleUser})
+ require.NoError(t, err)
+ for i, dest := range []**store.Memo{&f.memo, &f.target, &f.next} {
+ uid := []string{"mutation-source", "mutation-target", "mutation-next"}[i]
+ *dest, err = f.store.CreateMemo(f.ctx, &store.Memo{
+ UID: uid, CreatorID: f.owner.ID, Content: uid, Visibility: store.Private,
+ })
+ require.NoError(t, err)
+ }
+ for i, dest := range []**store.Attachment{&f.added, &f.removed, &f.kept} {
+ uid := []string{"mutation-added", "mutation-removed", "mutation-kept"}[i]
+ attachment := &store.Attachment{UID: uid, CreatorID: f.owner.ID, Filename: uid + ".txt", Type: "text/plain", Blob: []byte(uid)}
+ if i > 0 {
+ attachment.MemoID = &f.memo.ID
+ }
+ *dest, err = f.store.CreateAttachment(f.ctx, attachment)
+ require.NoError(t, err)
+ }
+ _, err = f.store.UpsertMemoRelation(f.ctx, &store.MemoRelation{
+ MemoID: f.memo.ID, RelatedMemoID: f.target.ID, Type: store.MemoRelationReference,
+ })
+ require.NoError(t, err)
+ return f
+}
+
+func (f *memoMutationFixture) mutation() *store.MemoMutation {
+ return &store.MemoMutation{
+ MemoID: f.memo.ID, MemoCreatorID: f.owner.ID, ExpectedMemoContent: f.memo.Content,
+ MemoUpdate: &store.UpdateMemo{ID: f.memo.ID, Content: new("updated content")},
+ Bindings: []*store.MemoAttachmentBinding{
+ {ID: f.added.ID, UID: f.added.UID, UpdatedTs: 1600000000},
+ },
+ RemovedAttachmentIDs: []int32{f.removed.ID},
+ RequiredAttachmentIDs: []int32{f.kept.ID, f.added.ID},
+ ReplaceReferenceRelations: true,
+ ReferenceRelations: []*store.MemoRelation{
+ {MemoID: f.memo.ID, RelatedMemoID: f.next.ID, Type: store.MemoRelationReference},
+ },
+ }
+}
+
+type memoMutationState struct {
+ memos []*store.Memo
+ attachments []*store.Attachment
+ relations []*store.MemoRelation
+}
+
+func (f *memoMutationFixture) state() memoMutationState {
+ f.t.Helper()
+ memos, err := f.store.ListMemos(f.ctx, &store.FindMemo{})
+ require.NoError(f.t, err)
+ attachments, err := f.store.ListAttachments(f.ctx, &store.FindAttachment{GetBlob: true, SkipDefaultLimit: true})
+ require.NoError(f.t, err)
+ relations, err := f.store.ListMemoRelations(f.ctx, &store.FindMemoRelation{})
+ require.NoError(f.t, err)
+ return memoMutationState{memos: memos, attachments: attachments, relations: relations}
+}
+
+func TestMemoMutationRevalidatesPreparedState(t *testing.T) {
+ tests := []struct {
+ name string
+ change func(*memoMutationFixture, *store.MemoMutation)
+ message string
+ }{
+ {"memo content changed", func(f *memoMutationFixture, _ *store.MemoMutation) {
+ require.NoError(f.t, f.store.UpdateMemo(f.ctx, &store.UpdateMemo{ID: f.memo.ID, Content: new("concurrent edit")}))
+ }, "memo changed"},
+ {"memo creator mismatch", func(f *memoMutationFixture, m *store.MemoMutation) {
+ m.MemoCreatorID = f.peer.ID
+ m.ReplaceReferenceRelations = false
+ }, "memo changed"},
+ {"memo deleted", func(f *memoMutationFixture, m *store.MemoMutation) {
+ m.ReplaceReferenceRelations = false
+ require.NoError(f.t, f.store.DeleteMemo(f.ctx, &store.DeleteMemo{ID: f.memo.ID}))
+ }, "memo no longer exists"},
+ {"removed attachment deleted", func(f *memoMutationFixture, _ *store.MemoMutation) {
+ require.NoError(f.t, f.store.GetDriver().DeleteAttachment(f.ctx, &store.DeleteAttachment{ID: f.removed.ID}))
+ }, "removed attachment no longer exists"},
+ {"removed attachment moved", func(f *memoMutationFixture, _ *store.MemoMutation) {
+ require.NoError(f.t, f.store.UpdateAttachment(f.ctx, &store.UpdateAttachment{ID: f.removed.ID, MemoID: &f.target.ID}))
+ }, "no longer removable"},
+ {"new binding deleted", func(f *memoMutationFixture, _ *store.MemoMutation) {
+ require.NoError(f.t, f.store.GetDriver().DeleteAttachment(f.ctx, &store.DeleteAttachment{ID: f.added.ID}))
+ }, "no longer exists"},
+ {"new binding taken by another memo", func(f *memoMutationFixture, _ *store.MemoMutation) {
+ require.NoError(f.t, f.store.UpdateAttachment(f.ctx, &store.UpdateAttachment{ID: f.added.ID, MemoID: &f.target.ID}))
+ }, "no longer available"},
+ {"existing binding moved after preparation", func(f *memoMutationFixture, m *store.MemoMutation) {
+ m.Bindings = append(m.Bindings, &store.MemoAttachmentBinding{ID: f.kept.ID, UID: f.kept.UID, WasBoundToMemo: true})
+ require.NoError(f.t, f.store.UpdateAttachment(f.ctx, &store.UpdateAttachment{ID: f.kept.ID, MemoID: &f.target.ID}))
+ }, "no longer bound"},
+ {"claimed existing binding is unbound", func(_ *memoMutationFixture, m *store.MemoMutation) {
+ m.Bindings[0].WasBoundToMemo = true
+ }, "no longer bound"},
+ {"required attachment moved after preparation", func(f *memoMutationFixture, _ *store.MemoMutation) {
+ require.NoError(f.t, f.store.UpdateAttachment(f.ctx, &store.UpdateAttachment{ID: f.kept.ID, MemoID: &f.target.ID}))
+ }, "referenced attachment is no longer bound"},
+ {"reference target deleted", func(f *memoMutationFixture, _ *store.MemoMutation) {
+ require.NoError(f.t, f.store.DeleteMemo(f.ctx, &store.DeleteMemo{ID: f.next.ID}))
+ }, "memo state changed"},
+ }
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ mutation := f.mutation()
+ tc.change(f, mutation)
+ before := f.state()
+ err := f.store.ApplyMemoMutation(f.ctx, mutation)
+ require.ErrorIs(t, err, store.ErrMemoMutationConflict)
+ require.ErrorContains(t, err, tc.message)
+ require.Equal(t, before, f.state(), "rejected mutation must preserve the current database state")
+ })
+ }
+}
+
+func TestMemoMutationRollsBackAfterAttachmentWrites(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ change func(*memoMutationFixture, *store.MemoMutation)
+ }{
+ {"update target mismatch", func(f *memoMutationFixture, m *store.MemoMutation) { m.MemoUpdate.ID = f.target.ID }},
+ {"memo UID uniqueness failure", func(f *memoMutationFixture, m *store.MemoMutation) { m.MemoUpdate.UID = &f.target.UID }},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ mutation := f.mutation()
+ tc.change(f, mutation)
+ before := f.state()
+ // Both failures occur after binding the added attachment and deleting
+ // the removed attachment, so this checks a real transaction rollback.
+ require.Error(t, f.store.ApplyMemoMutation(f.ctx, mutation))
+ require.Equal(t, before, f.state())
+ // A fresh valid write also proves the failed transaction released its locks.
+ require.NoError(t, f.store.ApplyMemoMutation(f.ctx, f.mutation()))
+ })
+ }
+}
+
+func TestMemoMutationRollsBackAfterReferenceInsertFailure(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ first, err := f.store.CreateMemo(f.ctx, &store.Memo{
+ UID: "first-replacement", CreatorID: f.owner.ID, Content: "replacement", Visibility: store.Private,
+ })
+ require.NoError(t, err)
+ // Inject a database error after memo fields, attachment bindings/removals,
+ // and the first replacement reference have already been written.
+ var statements []string
+ drop := "DROP TRIGGER reject_mutation_reference"
+ switch getDriverFromEnv() {
+ case "sqlite":
+ statements = []string{fmt.Sprintf(`CREATE TRIGGER reject_mutation_reference
+ BEFORE INSERT ON memo_relation WHEN NEW.related_memo_id = %d
+ BEGIN SELECT RAISE(ABORT, 'mutation test reference failure'); END`, f.next.ID)}
+ case "mysql":
+ statements = []string{fmt.Sprintf(`CREATE TRIGGER reject_mutation_reference
+ BEFORE INSERT ON memo_relation FOR EACH ROW BEGIN
+ IF NEW.related_memo_id = %d THEN
+ SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'mutation test reference failure';
+ END IF; END`, f.next.ID)}
+ case "postgres":
+ statements = []string{
+ fmt.Sprintf(`CREATE FUNCTION reject_mutation_reference() RETURNS trigger AS $$
+ BEGIN IF NEW.related_memo_id = %d THEN
+ RAISE EXCEPTION 'mutation test reference failure';
+ END IF; RETURN NEW; END; $$ LANGUAGE plpgsql`, f.next.ID),
+ `CREATE TRIGGER reject_mutation_reference BEFORE INSERT ON memo_relation
+ FOR EACH ROW EXECUTE FUNCTION reject_mutation_reference()`,
+ }
+ drop += " ON memo_relation"
+ default:
+ t.Fatalf("unsupported driver: %s", getDriverFromEnv())
+ }
+ for _, statement := range statements {
+ _, err := f.store.GetDriver().GetDB().ExecContext(f.ctx, statement)
+ require.NoError(t, err)
+ }
+ before := f.state()
+ mutation := f.mutation()
+ mutation.ReferenceRelations = append([]*store.MemoRelation{
+ {MemoID: f.memo.ID, RelatedMemoID: first.ID, Type: store.MemoRelationReference},
+ }, mutation.ReferenceRelations...)
+ require.ErrorContains(t, f.store.ApplyMemoMutation(f.ctx, mutation), "mutation test reference failure")
+ require.Equal(t, before, f.state(), "all three tables must roll back, including the deleted original reference")
+ _, err = f.store.GetDriver().GetDB().ExecContext(f.ctx, drop)
+ require.NoError(t, err)
+ require.NoError(t, f.store.ApplyMemoMutation(f.ctx, f.mutation()))
+}
+
+func TestMemoCreationMutationRollsBackCommentAndAttachmentBindings(t *testing.T) {
+ for _, comment := range []bool{false, true} {
+ name := "top level"
+ if comment {
+ name = "comment"
+ }
+ t.Run(name, func(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ foreign, err := f.store.CreateAttachment(f.ctx, &store.Attachment{
+ UID: "foreign-attachment", CreatorID: f.peer.ID, Filename: "foreign.txt", Type: "text/plain",
+ })
+ require.NoError(t, err)
+ before := f.state()
+ created := &store.Memo{UID: "rejected-creation", CreatorID: f.owner.ID, Content: "new", Visibility: store.Private}
+ mutation := &store.MemoMutation{
+ MemoCreate: created,
+ Bindings: []*store.MemoAttachmentBinding{
+ {ID: f.added.ID, UID: f.added.UID, UpdatedTs: 1600000000},
+ {ID: foreign.ID, UID: foreign.UID, UpdatedTs: 1600000000},
+ },
+ ReplaceReferenceRelations: true,
+ ReferenceRelations: []*store.MemoRelation{{RelatedMemoID: f.target.ID, Type: store.MemoRelationReference}},
+ }
+ if comment {
+ mutation.CommentContextMemoID = &f.memo.ID
+ }
+ require.ErrorIs(t, f.store.ApplyMemoMutation(f.ctx, mutation), store.ErrMemoMutationConflict)
+ require.Equal(t, before, f.state())
+ got, err := f.store.GetMemo(f.ctx, &store.FindMemo{UID: &created.UID})
+ require.NoError(t, err)
+ require.Nil(t, got, "failed creation must not leave a memo or orphan COMMENT relation")
+ })
+ }
+}
+
+func TestMemoMutationCanceledContextDoesNotWrite(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ before := f.state()
+ ctx, cancel := context.WithCancel(f.ctx)
+ cancel()
+ require.ErrorIs(t, f.store.ApplyMemoMutation(ctx, f.mutation()), context.Canceled)
+ require.Equal(t, before, f.state())
+ require.NoError(t, f.store.ApplyMemoMutation(f.ctx, f.mutation()))
+}
+
+func TestMemoMutationRejectsNilBindingWithoutPanic(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ before := f.state()
+ mutation := f.mutation()
+ mutation.Bindings = append(mutation.Bindings, nil)
+ var err error
+ require.NotPanics(t, func() { err = f.store.ApplyMemoMutation(f.ctx, mutation) })
+ require.ErrorContains(t, err, "attachment binding is required")
+ require.Equal(t, before, f.state())
+ require.NoError(t, f.store.ApplyMemoMutation(f.ctx, f.mutation()))
+}
+
+func TestMemoMutationConcurrentWritersCommitOnlyOneCompleteChange(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ second, err := f.store.CreateAttachment(f.ctx, &store.Attachment{
+ UID: "second-writer-attachment", CreatorID: f.owner.ID, Filename: "second.txt", Type: "text/plain",
+ })
+ require.NoError(t, err)
+ attachments := []*store.Attachment{f.added, second}
+ targets := []*store.Memo{f.next, f.target}
+ mutations := []*store.MemoMutation{f.mutation(), f.mutation()}
+ for i, m := range mutations {
+ m.MemoUpdate.Content = new(fmt.Sprintf("writer-%d", i))
+ m.Bindings = []*store.MemoAttachmentBinding{{ID: attachments[i].ID, UID: attachments[i].UID, UpdatedTs: 1600000000}}
+ m.RequiredAttachmentIDs = []int32{attachments[i].ID, f.kept.ID}
+ m.ReferenceRelations[0].RelatedMemoID = targets[i].ID
+ }
+ start := make(chan struct{})
+ errs := make([]error, len(mutations))
+ var wg sync.WaitGroup
+ for i, mutation := range mutations {
+ wg.Go(func() {
+ <-start
+ errs[i] = f.store.ApplyMemoMutation(f.ctx, mutation)
+ })
+ }
+ close(start)
+ wg.Wait()
+ winner := -1
+ for i, err := range errs {
+ if err == nil {
+ require.Equal(t, -1, winner, "two writes based on the same content snapshot must not both commit")
+ winner = i
+ }
+ }
+ require.NotEqual(t, -1, winner, "one complete mutation should succeed: %v", errs)
+ got, err := f.store.GetMemo(f.ctx, &store.FindMemo{ID: &f.memo.ID})
+ require.NoError(t, err)
+ require.Equal(t, *mutations[winner].MemoUpdate.Content, got.Content)
+ for i, attachment := range attachments {
+ got, err := f.store.GetAttachment(f.ctx, &store.FindAttachment{ID: &attachment.ID})
+ require.NoError(t, err)
+ if i == winner {
+ require.Equal(t, &f.memo.ID, got.MemoID)
+ } else {
+ require.Nil(t, got.MemoID, "losing writer must not leave its attachment bound")
+ }
+ }
+ removed, err := f.store.GetAttachment(f.ctx, &store.FindAttachment{ID: &f.removed.ID})
+ require.NoError(t, err)
+ require.Nil(t, removed)
+ relations, err := f.store.ListMemoRelations(f.ctx, &store.FindMemoRelation{MemoID: &f.memo.ID})
+ require.NoError(t, err)
+ require.Equal(t, mutations[winner].ReferenceRelations, relations)
+}
+
+func TestMemoMutationRechecksSpaceMembership(t *testing.T) {
+ for _, policyOnUpdate := range []bool{false, true} {
+ name := "mutation policy"
+ if policyOnUpdate {
+ name = "update policy fallback"
+ }
+ t.Run(name, func(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ space, err := f.store.CreateSpace(f.ctx, &store.Space{UID: "mutation-space", Title: "Space"}, f.owner.ID)
+ require.NoError(t, err)
+ _, err = createSpaceMemberForTest(f.ctx, f.store, &store.SpaceMember{
+ SpaceID: space.ID, UserID: f.peer.ID, Role: store.SpaceMemberRoleAdmin,
+ }, f.owner.ID)
+ require.NoError(t, err)
+ require.NoError(t, f.store.UpdateMemo(f.ctx, &store.UpdateMemo{ID: f.memo.ID, SpaceID: &space.ID}))
+ mutation := f.mutation()
+ policy := memoWritePolicy(f.owner.ID, false)
+ if policyOnUpdate {
+ mutation.MemoUpdate.Policy = policy
+ } else {
+ mutation.Policy = policy
+ }
+ require.NoError(t, f.store.DeleteSpaceMember(f.ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: f.owner.ID}, f.peer.ID))
+ before := f.state()
+ require.ErrorIs(t, f.store.ApplyMemoMutation(f.ctx, mutation), store.ErrMemoSpaceMembershipRequired)
+ require.Equal(t, before, f.state())
+ })
+ }
+}
+
+func TestMemoMutationLifecyclePolicyFallbackRejectsDependentWrites(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ space, err := f.store.CreateSpace(f.ctx, &store.Space{UID: "withdrawal-space", Title: "Space"}, f.owner.ID)
+ require.NoError(t, err)
+ require.NoError(t, f.store.UpdateMemo(f.ctx, &store.UpdateMemo{ID: f.memo.ID, SpaceID: &space.ID}))
+ mutation := f.mutation()
+ mutation.MemoUpdate = &store.UpdateMemo{ID: f.memo.ID, ClearSpace: true, Policy: memoWritePolicy(f.owner.ID, true)}
+ before := f.state()
+ require.ErrorIs(t, f.store.ApplyMemoMutation(f.ctx, mutation), store.ErrMemoSpaceMembershipRequired)
+ require.Equal(t, before, f.state())
+}
+
+func TestMemoMutationCommitsAllDependentChanges(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ mutation := f.mutation()
+ mutation.Policy = memoWritePolicy(f.owner.ID, false)
+ mutation.MemoUpdate.UID = new("mutation-renamed")
+ mutation.MemoUpdate.CreatedTs = new(int64(1500000000))
+ mutation.MemoUpdate.UpdatedTs = new(int64(1600000000))
+ mutation.MemoUpdate.Pinned = new(true)
+ mutation.MemoUpdate.Payload = &storepb.MemoPayload{Tags: []string{"updated"}}
+ mutation.Bindings = append(mutation.Bindings, &store.MemoAttachmentBinding{
+ ID: f.kept.ID, UID: f.kept.UID, WasBoundToMemo: true, UpdatedTs: 1600000000,
+ })
+ require.NoError(t, f.store.ApplyMemoMutation(f.ctx, mutation))
+ got, err := f.store.GetMemo(f.ctx, &store.FindMemo{ID: &f.memo.ID})
+ require.NoError(t, err)
+ require.Equal(t, "updated content", got.Content)
+ require.Equal(t, "mutation-renamed", got.UID)
+ require.Equal(t, int64(1500000000), got.CreatedTs)
+ require.Equal(t, int64(1600000000), got.UpdatedTs)
+ require.True(t, got.Pinned)
+ require.Equal(t, []string{"updated"}, got.Payload.Tags)
+ for _, attachment := range []*store.Attachment{f.added, f.kept} {
+ got, err := f.store.GetAttachment(f.ctx, &store.FindAttachment{ID: &attachment.ID, GetBlob: true})
+ require.NoError(t, err)
+ require.Equal(t, &f.memo.ID, got.MemoID)
+ require.Equal(t, int64(1600000000), got.UpdatedTs)
+ require.Equal(t, f.owner.ID, got.CreatorID)
+ require.Equal(t, []byte(attachment.UID), got.Blob)
+ }
+ removed, err := f.store.GetAttachment(f.ctx, &store.FindAttachment{ID: &f.removed.ID})
+ require.NoError(t, err)
+ require.Nil(t, removed)
+ relations, err := f.store.ListMemoRelations(f.ctx, &store.FindMemoRelation{MemoID: &f.memo.ID})
+ require.NoError(t, err)
+ require.Equal(t, mutation.ReferenceRelations, relations)
+}
+
+func TestMemoMutationAttachmentOwnership(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ admin bool
+ thirdUser bool
+ action string
+ allowed bool
+ }{
+ {"author cannot bind another users upload", false, false, "bind", false},
+ {"author cannot delete another users attachment", false, false, "remove", false},
+ {"author can retain legacy foreign binding", false, false, "keep", true},
+ {"admin can bind own upload to another users memo", true, false, "bind", true},
+ {"admin cannot bind unrelated users upload", true, true, "bind", false},
+ {"admin can remove another users bound attachment", true, true, "remove", true},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ actorID := f.owner.ID
+ if tc.admin {
+ _, err := f.store.UpdateUser(f.ctx, &store.UpdateUser{ID: f.peer.ID, Role: new(store.RoleAdmin)})
+ require.NoError(t, err)
+ actorID = f.peer.ID
+ }
+ creatorID := f.peer.ID
+ if tc.thirdUser {
+ third, err := f.store.CreateUser(f.ctx, &store.User{Username: "third-user", Role: store.RoleUser})
+ require.NoError(t, err)
+ creatorID = third.ID
+ }
+ create := &store.Attachment{UID: "foreign-attachment", CreatorID: creatorID, Filename: "foreign.txt", Type: "text/plain"}
+ if tc.action != "bind" {
+ create.MemoID = &f.memo.ID
+ }
+ foreign, err := f.store.CreateAttachment(f.ctx, create)
+ require.NoError(t, err)
+ mutation := f.mutation()
+ mutation.Policy = memoWritePolicy(actorID, false)
+ if tc.action == "remove" {
+ mutation.RemovedAttachmentIDs = append(mutation.RemovedAttachmentIDs, foreign.ID)
+ } else {
+ mutation.Bindings = append(mutation.Bindings, &store.MemoAttachmentBinding{
+ ID: foreign.ID, UID: foreign.UID, WasBoundToMemo: tc.action == "keep", UpdatedTs: 1600000000,
+ })
+ mutation.RequiredAttachmentIDs = append(mutation.RequiredAttachmentIDs, foreign.ID)
+ }
+ before := f.state()
+ err = f.store.ApplyMemoMutation(f.ctx, mutation)
+ if !tc.allowed {
+ require.ErrorIs(t, err, store.ErrMemoMutationConflict)
+ require.Equal(t, before, f.state())
+ return
+ }
+ require.NoError(t, err)
+ got, err := f.store.GetAttachment(f.ctx, &store.FindAttachment{ID: &foreign.ID})
+ require.NoError(t, err)
+ if tc.action == "remove" {
+ require.Nil(t, got)
+ } else {
+ require.Equal(t, creatorID, got.CreatorID, "binding must not transfer ownership")
+ require.Equal(t, &f.memo.ID, got.MemoID)
+ }
+ })
+ }
+}
+
+func TestMemoMutationRechecksActorAndReferenceAudience(t *testing.T) {
+ for _, name := range []string{"actor archived", "administrator demoted", "reference made private"} {
+ t.Run(name, func(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ mutation := f.mutation()
+ mutation.Policy = memoWritePolicy(f.owner.ID, false)
+ switch name {
+ case "actor archived":
+ _, err := f.store.UpdateUser(f.ctx, &store.UpdateUser{ID: f.owner.ID, RowStatus: new(store.Archived)})
+ require.NoError(t, err)
+ case "administrator demoted":
+ _, err := f.store.UpdateUser(f.ctx, &store.UpdateUser{ID: f.peer.ID, Role: new(store.RoleAdmin)})
+ require.NoError(t, err)
+ mutation.Policy = memoWritePolicy(f.peer.ID, false)
+ _, err = f.store.UpdateUser(f.ctx, &store.UpdateUser{ID: f.peer.ID, Role: new(store.RoleUser)})
+ require.NoError(t, err)
+ case "reference made private":
+ target, err := f.store.CreateMemo(f.ctx, &store.Memo{
+ UID: "foreign-reference", CreatorID: f.peer.ID, Content: "shared", Visibility: store.Public,
+ })
+ require.NoError(t, err)
+ mutation.ReferenceRelations[0].RelatedMemoID = target.ID
+ require.NoError(t, f.store.UpdateMemo(f.ctx, &store.UpdateMemo{ID: target.ID, Visibility: new(store.Private)}))
+ default:
+ t.Fatalf("unknown permission change: %s", name)
+ }
+ before := f.state()
+ require.ErrorIs(t, f.store.ApplyMemoMutation(f.ctx, mutation), store.ErrMemoPermissionDenied)
+ require.Equal(t, before, f.state())
+ })
+ }
+}
+
+func TestMemoMutationReferenceReplacementPreservesCommentAndIncomingRelations(t *testing.T) {
+ for _, replace := range []bool{false, true} {
+ name := "replace references"
+ if !replace {
+ name = "clear references"
+ }
+ t.Run(name, func(t *testing.T) {
+ f := newMemoMutationFixture(t)
+ comment, err := f.store.CreateMemoComment(f.ctx, &store.Memo{
+ UID: "mutation-comment", CreatorID: f.owner.ID, Content: "comment", Visibility: store.Private,
+ }, f.memo.ID, f.owner.ID)
+ require.NoError(t, err)
+ for _, relation := range []*store.MemoRelation{
+ {MemoID: comment.ID, RelatedMemoID: f.target.ID, Type: store.MemoRelationReference},
+ {MemoID: f.target.ID, RelatedMemoID: comment.ID, Type: store.MemoRelationReference},
+ } {
+ _, err := f.store.UpsertMemoRelation(f.ctx, relation)
+ require.NoError(t, err)
+ }
+ mutation := &store.MemoMutation{
+ MemoID: comment.ID, MemoCreatorID: f.owner.ID, ExpectedMemoContent: comment.Content,
+ MemoUpdate: &store.UpdateMemo{ID: comment.ID}, ReplaceReferenceRelations: true,
+ }
+ want := []*store.MemoRelation{{MemoID: comment.ID, RelatedMemoID: f.memo.ID, Type: store.MemoRelationComment}}
+ if replace {
+ mutation.ReferenceRelations = []*store.MemoRelation{{MemoID: comment.ID, RelatedMemoID: f.next.ID, Type: store.MemoRelationReference}}
+ want = append(want, mutation.ReferenceRelations...)
+ }
+ require.NoError(t, f.store.ApplyMemoMutation(f.ctx, mutation))
+ outgoing, err := f.store.ListMemoRelations(f.ctx, &store.FindMemoRelation{MemoID: &comment.ID})
+ require.NoError(t, err)
+ require.ElementsMatch(t, want, outgoing)
+ incoming, err := f.store.ListMemoRelations(f.ctx, &store.FindMemoRelation{RelatedMemoID: &comment.ID})
+ require.NoError(t, err)
+ require.Equal(t, []*store.MemoRelation{{MemoID: f.target.ID, RelatedMemoID: comment.ID, Type: store.MemoRelationReference}}, incoming)
+ })
+ }
+}
diff --git a/store/test/memo_share_test.go b/store/test/memo_share_test.go
index 657345c61..ca7ecc59b 100644
--- a/store/test/memo_share_test.go
+++ b/store/test/memo_share_test.go
@@ -3,6 +3,7 @@ package test
import (
"context"
"testing"
+ "time"
"github.com/stretchr/testify/require"
@@ -37,3 +38,157 @@ func TestMemoShareDeleteRequiresSelector(t *testing.T) {
require.NoError(t, err)
require.Len(t, shares, 1)
}
+
+func TestMemoShareAuthorizedDeletion(t *testing.T) {
+ for _, name := range []string{
+ "owner by id", "owner by uid", "matching selectors", "instance admin", "archived memo",
+ "unrelated actor", "archived actor", "missing actor", "demoted admin", "removed membership",
+ "mismatched memo", "mismatched selectors", "missing share", "missing memo", "database failure",
+ } {
+ t.Run(name, func(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ owner, err := createTestingUserWithRole(ctx, ts, "share-owner", store.RoleUser)
+ require.NoError(t, err)
+ admin, err := createTestingUserWithRole(ctx, ts, "share-admin", store.RoleAdmin)
+ require.NoError(t, err)
+ peer, err := createTestingUserWithRole(ctx, ts, "share-peer", store.RoleUser)
+ require.NoError(t, err)
+ space, err := ts.CreateSpace(ctx, &store.Space{UID: "share-space", Title: "Shares"}, owner.ID)
+ require.NoError(t, err)
+ _, err = createSpaceMemberForTest(ctx, ts, &store.SpaceMember{SpaceID: space.ID, UserID: peer.ID, Role: store.SpaceMemberRoleAdmin}, owner.ID)
+ require.NoError(t, err)
+ memo, err := ts.CreateMemo(ctx, &store.Memo{UID: "share-memo", CreatorID: owner.ID,
+ Content: "memo", Visibility: store.Public, SpaceID: &space.ID})
+ require.NoError(t, err)
+ other, err := ts.CreateMemo(ctx, &store.Memo{UID: "other-share-memo", CreatorID: owner.ID,
+ Content: "other", Visibility: store.Public})
+ require.NoError(t, err)
+ share, err := ts.CreateMemoShare(ctx, &store.MemoShare{UID: "share-token", MemoID: memo.ID,
+ CreatorID: owner.ID, Policy: &store.MemoWritePolicy{ActorUserID: owner.ID, CreatingShare: true}})
+ require.NoError(t, err)
+ keep, err := ts.CreateMemoShare(ctx, &store.MemoShare{UID: "keep-token", MemoID: memo.ID, CreatorID: owner.ID})
+ require.NoError(t, err)
+ delete := &store.DeleteMemoShare{ID: &share.ID, MemoID: &memo.ID, Policy: &store.MemoWritePolicy{ActorUserID: owner.ID}}
+ var wantErr error
+ var removeTrigger func()
+ switch name {
+ case "owner by uid":
+ delete.ID, delete.UID = nil, &share.UID
+ case "matching selectors":
+ delete.UID = &share.UID
+ case "instance admin":
+ delete.Policy.ActorUserID = admin.ID
+ case "archived memo":
+ require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, RowStatus: new(store.Archived)}))
+ case "unrelated actor":
+ delete.Policy.ActorUserID = peer.ID
+ wantErr = store.ErrMemoPermissionDenied
+ case "archived actor":
+ _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: owner.ID, RowStatus: new(store.Archived)})
+ require.NoError(t, err)
+ wantErr = store.ErrMemoSpaceMembershipRequired
+ case "missing actor":
+ delete.Policy.ActorUserID = 99999
+ wantErr = store.ErrMemoSpaceMembershipRequired
+ case "demoted admin":
+ delete.Policy.ActorUserID = admin.ID
+ _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: admin.ID, Role: new(store.RoleUser)})
+ require.NoError(t, err)
+ wantErr = store.ErrMemoPermissionDenied
+ case "removed membership":
+ require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: owner.ID}, peer.ID))
+ wantErr = store.ErrMemoSpaceMembershipRequired
+ case "mismatched memo":
+ delete.MemoID = &other.ID
+ wantErr = store.ErrMemoMutationConflict
+ case "mismatched selectors":
+ delete.UID = &keep.UID
+ wantErr = store.ErrMemoMutationConflict
+ case "missing share":
+ delete.ID = new(int32(99999))
+ wantErr = store.ErrMemoMutationConflict
+ case "missing memo":
+ delete.MemoID = new(int32(99999))
+ wantErr = store.ErrMemoMutationConflict
+ case "database failure":
+ removeTrigger = rejectStoreDelete(t, ts, "memo_share")
+ default:
+ }
+ before, err := ts.ListMemoShares(ctx, &store.FindMemoShare{})
+ require.NoError(t, err)
+ err = ts.DeleteMemoShare(ctx, delete)
+ if wantErr != nil || removeTrigger != nil {
+ if removeTrigger != nil {
+ require.ErrorContains(t, err, "store test delete failure")
+ } else {
+ require.ErrorIs(t, err, wantErr)
+ }
+ after, err := ts.ListMemoShares(ctx, &store.FindMemoShare{})
+ require.NoError(t, err)
+ require.Equal(t, before, after)
+ if removeTrigger != nil {
+ removeTrigger()
+ require.NoError(t, ts.DeleteMemoShare(ctx, delete), "failed transaction must release its locks")
+ }
+ } else {
+ require.NoError(t, err)
+ got, err := ts.GetMemoShare(ctx, &store.FindMemoShare{ID: &share.ID})
+ require.NoError(t, err)
+ require.Nil(t, got)
+ require.ErrorIs(t, ts.DeleteMemoShare(ctx, delete), store.ErrMemoMutationConflict)
+ }
+ got, err := ts.GetMemoShare(ctx, &store.FindMemoShare{ID: &keep.ID})
+ require.NoError(t, err)
+ require.Equal(t, keep, got)
+ })
+ }
+}
+
+func TestMemoShareFiltersAndExpiryRoundTrip(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ owner, err := createTestingHostUser(ctx, ts)
+ require.NoError(t, err)
+ peer, err := createTestingUserWithRole(ctx, ts, "share-peer", store.RoleUser)
+ require.NoError(t, err)
+ var shares []*store.MemoShare
+ for i, user := range []*store.User{owner, peer} {
+ memo, err := ts.CreateMemo(ctx, &store.Memo{UID: user.Username, CreatorID: user.ID, Content: "memo", Visibility: store.Private})
+ require.NoError(t, err)
+ var expiry *int64
+ if i == 1 {
+ expiry = new(time.Now().Add(-time.Hour).Unix())
+ }
+ share, err := ts.CreateMemoShare(ctx, &store.MemoShare{UID: user.Username, MemoID: memo.ID, CreatorID: user.ID, ExpiresTs: expiry})
+ require.NoError(t, err)
+ shares = append(shares, share)
+ }
+ for _, share := range shares {
+ for _, find := range []*store.FindMemoShare{
+ {ID: &share.ID}, {UID: &share.UID}, {MemoID: &share.MemoID}, {CreatorID: &share.CreatorID},
+ {ID: &share.ID, UID: &share.UID, MemoID: &share.MemoID, CreatorID: &share.CreatorID},
+ } {
+ got, err := ts.GetMemoShare(ctx, find)
+ require.NoError(t, err)
+ require.Equal(t, share, got)
+ list, err := ts.ListMemoShares(ctx, find)
+ require.NoError(t, err)
+ require.Equal(t, []*store.MemoShare{share}, list, "store listing includes expired grants for management")
+ }
+ }
+ find := &store.FindMemoShare{ID: &shares[0].ID, CreatorID: &peer.ID}
+ got, err := ts.GetMemoShare(ctx, find)
+ require.NoError(t, err)
+ require.Nil(t, got)
+ list, err := ts.ListMemoShares(ctx, find)
+ require.NoError(t, err)
+ require.Empty(t, list)
+ _, err = ts.CreateMemoShare(ctx, &store.MemoShare{UID: shares[0].UID, MemoID: shares[1].MemoID, CreatorID: peer.ID})
+ require.Error(t, err, "duplicate bearer token must not replace its original grant")
+ list, err = ts.ListMemoShares(ctx, &store.FindMemoShare{})
+ require.NoError(t, err)
+ require.Equal(t, shares, list)
+}
diff --git a/store/test/user_bootstrap_test.go b/store/test/user_bootstrap_test.go
new file mode 100644
index 000000000..405919715
--- /dev/null
+++ b/store/test/user_bootstrap_test.go
@@ -0,0 +1,110 @@
+package test
+
+import (
+ "context"
+ "fmt"
+ "sync"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/usememos/memos/store"
+)
+
+func TestCreateUserIfNoUsersConcurrentSetup(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ const attempts = 8
+ users := make([]*store.User, attempts)
+ created := make([]bool, attempts)
+ errs := make([]error, attempts)
+ start := make(chan struct{})
+ var wg sync.WaitGroup
+ for i := range attempts {
+ wg.Go(func() {
+ <-start
+ users[i], created[i], errs[i] = ts.CreateUserIfNoUsers(ctx, &store.User{
+ Username: fmt.Sprintf("first-%d", i), Role: store.RoleAdmin,
+ Email: fmt.Sprintf(" First%[email protected] ", i),
+ })
+ })
+ }
+ close(start)
+ wg.Wait()
+ var winner *store.User
+ for i := range attempts {
+ require.NoError(t, errs[i])
+ if created[i] {
+ require.Nil(t, winner, "only one first administrator may be created")
+ winner = users[i]
+ require.NotNil(t, winner)
+ require.Equal(t, fmt.Sprintf("first%[email protected]", i), winner.Email)
+ } else {
+ require.Nil(t, users[i])
+ }
+ }
+ require.NotNil(t, winner)
+ persisted, err := ts.ListUsers(ctx, &store.FindUser{})
+ require.NoError(t, err)
+ require.Len(t, persisted, 1)
+ require.Equal(t, winner.ID, persisted[0].ID)
+ require.Equal(t, store.RoleAdmin, persisted[0].Role)
+ cached, err := ts.GetUser(ctx, &store.FindUser{ID: &winner.ID})
+ require.NoError(t, err)
+ require.Equal(t, persisted[0], cached)
+}
+
+func TestCreateUserIfNoUsersFailureAllowsRetry(t *testing.T) {
+ for _, name := range []string{"invalid email", "canceled context"} {
+ t.Run(name, func(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ create := &store.User{Username: "first", Role: store.RoleAdmin, Email: "[email protected]"}
+ attemptCtx := ctx
+ if name == "invalid email" {
+ create.Email = "not an email"
+ } else {
+ canceled, cancel := context.WithCancel(ctx)
+ cancel()
+ attemptCtx = canceled
+ }
+ user, created, err := ts.CreateUserIfNoUsers(attemptCtx, create)
+ require.Error(t, err)
+ require.False(t, created)
+ require.Nil(t, user)
+ users, err := ts.ListUsers(ctx, &store.FindUser{})
+ require.NoError(t, err)
+ require.Empty(t, users)
+ create.Email = "[email protected]"
+ user, created, err = ts.CreateUserIfNoUsers(ctx, create)
+ require.NoError(t, err)
+ require.True(t, created)
+ require.NotNil(t, user)
+ })
+ }
+}
+
+func TestCreateUserIfNoUsersRespectsExistingUser(t *testing.T) {
+ for _, status := range []store.RowStatus{store.Normal, store.Archived} {
+ t.Run(string(status), func(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ existing, err := createTestingUserWithRole(ctx, ts, "existing", store.RoleUser)
+ require.NoError(t, err)
+ _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: existing.ID, RowStatus: &status})
+ require.NoError(t, err)
+ user, created, err := ts.CreateUserIfNoUsers(ctx, &store.User{Username: "new-admin", Role: store.RoleAdmin})
+ require.NoError(t, err)
+ require.False(t, created)
+ require.Nil(t, user)
+ users, err := ts.ListUsers(ctx, &store.FindUser{})
+ require.NoError(t, err)
+ require.Len(t, users, 1)
+ require.Equal(t, existing.ID, users[0].ID)
+ require.Equal(t, status, users[0].RowStatus)
+ })
+ }
+}
diff --git a/store/test/user_delete_test.go b/store/test/user_delete_test.go
index 5ecb7932b..36eab2462 100644
--- a/store/test/user_delete_test.go
+++ b/store/test/user_delete_test.go
@@ -2,6 +2,7 @@ package test
import (
"context"
+ "fmt"
"testing"
"github.com/stretchr/testify/require"
@@ -26,6 +27,150 @@ func TestDeleteUserIsIdempotent(t *testing.T) {
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()
diff --git a/store/test/user_memo_view_test.go b/store/test/user_memo_view_test.go
new file mode 100644
index 000000000..9c14d66cc
--- /dev/null
+++ b/store/test/user_memo_view_test.go
@@ -0,0 +1,162 @@
+package test
+
+import (
+ "context"
+ "sync"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ "google.golang.org/protobuf/proto"
+
+ storepb "github.com/usememos/memos/proto/gen/store"
+ "github.com/usememos/memos/store"
+)
+
+func TestUserMemoViewRemovalAndEmptyUpdates(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ owner, err := createTestingHostUser(ctx, ts)
+ require.NoError(t, err)
+ peer, err := createTestingUserWithRole(ctx, ts, "view-peer", store.RoleUser)
+ require.NoError(t, err)
+ removed, err := ts.RemoveUserMemoView(ctx, owner.ID, "missing")
+ require.NoError(t, err)
+ require.False(t, removed)
+ setting, err := ts.GetUserSetting(ctx, &store.FindUserSetting{UserID: &owner.ID, Key: storepb.UserSetting_MEMO_VIEWS})
+ require.NoError(t, err)
+ require.Nil(t, setting, "removing an absent view must not create a setting")
+ for _, user := range []*store.User{owner, peer} {
+ for _, id := range []string{"first", "middle", "last"} {
+ require.NoError(t, ts.AddUserMemoView(ctx, user.ID, &storepb.MemoViewsUserSetting_MemoView{
+ Id: id, Title: id, Filter: `tag in ["work"]`,
+ Icon: &storepb.MemoViewsUserSetting_MemoView_Icon{Value: &storepb.MemoViewsUserSetting_MemoView_Icon_Emoji{Emoji: "🌱"}},
+ }))
+ }
+ }
+ peerBefore, err := ts.GetUserMemoViews(ctx, peer.ID)
+ require.NoError(t, err)
+ updated, err := ts.UpdateUserMemoView(ctx, owner.ID, "missing", new("unused"), nil, nil)
+ require.NoError(t, err)
+ require.Nil(t, updated)
+ var resetIcon *storepb.MemoViewsUserSetting_MemoView_Icon
+ updated, err = ts.UpdateUserMemoView(ctx, owner.ID, "middle", new(""), new(""), &resetIcon)
+ require.NoError(t, err)
+ require.Equal(t, "", updated.Title)
+ require.Equal(t, "", updated.Filter)
+ require.Nil(t, updated.Icon)
+ views, err := ts.GetUserMemoViews(ctx, owner.ID)
+ require.NoError(t, err)
+ require.Len(t, views, 3)
+ require.True(t, proto.Equal(updated, views[1]))
+ require.True(t, proto.Equal(peerBefore[0], views[0]))
+ require.True(t, proto.Equal(peerBefore[2], views[2]))
+ for _, id := range []string{"middle", "first", "last"} {
+ removed, err := ts.RemoveUserMemoView(ctx, owner.ID, id)
+ require.NoError(t, err)
+ require.True(t, removed)
+ removed, err = ts.RemoveUserMemoView(ctx, owner.ID, id)
+ require.NoError(t, err)
+ require.False(t, removed)
+ views, err = ts.GetUserMemoViews(ctx, owner.ID)
+ require.NoError(t, err)
+ for _, view := range views {
+ require.NotEqual(t, id, view.Id)
+ }
+ }
+ require.Empty(t, views)
+ persisted, err := ts.ListUserSettings(ctx, &store.FindUserSetting{UserID: &owner.ID, Key: storepb.UserSetting_MEMO_VIEWS})
+ require.NoError(t, err)
+ require.Len(t, persisted, 1)
+ require.Empty(t, persisted[0].GetMemoViews().GetMemoViews())
+ peerAfter, err := ts.GetUserMemoViews(ctx, peer.ID)
+ require.NoError(t, err)
+ require.Len(t, peerAfter, len(peerBefore))
+ for i := range peerBefore {
+ require.True(t, proto.Equal(peerBefore[i], peerAfter[i]))
+ }
+}
+
+func TestUserMemoViewConcurrentAddUpdateRemove(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ owner, err := createTestingHostUser(ctx, ts)
+ require.NoError(t, err)
+ for _, id := range []string{"remove", "update"} {
+ require.NoError(t, ts.AddUserMemoView(ctx, owner.ID, &storepb.MemoViewsUserSetting_MemoView{Id: id, Title: id}))
+ }
+ start := make(chan struct{})
+ var wg sync.WaitGroup
+ var errs [3]error
+ var removed bool
+ wg.Go(func() {
+ <-start
+ removed, errs[0] = ts.RemoveUserMemoView(ctx, owner.ID, "remove")
+ })
+ wg.Go(func() {
+ <-start
+ _, errs[1] = ts.UpdateUserMemoView(ctx, owner.ID, "update", new("changed"), nil, nil)
+ })
+ wg.Go(func() {
+ <-start
+ errs[2] = ts.AddUserMemoView(ctx, owner.ID, &storepb.MemoViewsUserSetting_MemoView{Id: "added", Title: "new"})
+ })
+ close(start)
+ wg.Wait()
+ for _, err := range errs {
+ require.NoError(t, err)
+ }
+ require.True(t, removed)
+ // Read through the driver to prove all three writes were persisted.
+ settings, err := ts.ListUserSettings(ctx, &store.FindUserSetting{UserID: &owner.ID, Key: storepb.UserSetting_MEMO_VIEWS})
+ require.NoError(t, err)
+ require.Len(t, settings, 1)
+ want := &storepb.MemoViewsUserSetting{MemoViews: []*storepb.MemoViewsUserSetting_MemoView{
+ {Id: "update", Title: "changed"}, {Id: "added", Title: "new"},
+ }}
+ require.True(t, proto.Equal(want, settings[0].GetMemoViews()))
+}
+
+func TestUserMemoViewFailedWritesPreserveCachedState(t *testing.T) {
+ for _, operation := range []string{"add", "update", "remove"} {
+ t.Run(operation, func(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ owner, err := createTestingHostUser(ctx, ts)
+ require.NoError(t, err)
+ original := &storepb.MemoViewsUserSetting_MemoView{Id: "saved", Title: "original", Filter: `tag in ["work"]`}
+ require.NoError(t, ts.AddUserMemoView(ctx, owner.ID, original))
+ _, err = ts.GetUserMemoViews(ctx, owner.ID)
+ require.NoError(t, err)
+ canceled, cancel := context.WithCancel(ctx)
+ cancel()
+ switch operation {
+ case "add":
+ err = ts.AddUserMemoView(canceled, owner.ID, &storepb.MemoViewsUserSetting_MemoView{Id: "failed"})
+ case "update":
+ _, err = ts.UpdateUserMemoView(canceled, owner.ID, original.Id, new("failed"), nil, nil)
+ case "remove":
+ var removed bool
+ removed, err = ts.RemoveUserMemoView(canceled, owner.ID, original.Id)
+ require.False(t, removed)
+ default:
+ t.Fatalf("unexpected operation: %s", operation)
+ }
+ require.ErrorIs(t, err, context.Canceled)
+ cached, err := ts.GetUserMemoViews(ctx, owner.ID)
+ require.NoError(t, err)
+ require.Len(t, cached, 1)
+ require.True(t, proto.Equal(original, cached[0]))
+ persisted, err := ts.ListUserSettings(ctx, &store.FindUserSetting{UserID: &owner.ID, Key: storepb.UserSetting_MEMO_VIEWS})
+ require.NoError(t, err)
+ require.Len(t, persisted, 1)
+ require.Len(t, persisted[0].GetMemoViews().GetMemoViews(), 1)
+ require.True(t, proto.Equal(original, persisted[0].GetMemoViews().GetMemoViews()[0]))
+ removed, err := ts.RemoveUserMemoView(ctx, owner.ID, original.Id)
+ require.NoError(t, err)
+ require.True(t, removed, "failed write must release the settings lock")
+ })
+ }
+}
diff --git a/store/test/user_setting_delete_test.go b/store/test/user_setting_delete_test.go
new file mode 100644
index 000000000..95675ab83
--- /dev/null
+++ b/store/test/user_setting_delete_test.go
@@ -0,0 +1,118 @@
+package test
+
+import (
+ "context"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ "google.golang.org/protobuf/proto"
+
+ storepb "github.com/usememos/memos/proto/gen/store"
+ "github.com/usememos/memos/store"
+)
+
+func TestDeleteUserSettingsInvalidatesOnlyMatchingCacheEntries(t *testing.T) {
+ for _, name := range []string{"one key", "all user keys", "key across users", "all settings", "missing user", "missing key"} {
+ t.Run(name, func(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ owner, err := createTestingUserWithRole(ctx, ts, "settings-owner", store.RoleUser)
+ require.NoError(t, err)
+ peer, err := createTestingUserWithRole(ctx, ts, "settings-peer", store.RoleUser)
+ require.NoError(t, err)
+ var settings []*storepb.UserSetting
+ for _, user := range []*store.User{owner, peer} {
+ settings = append(settings,
+ &storepb.UserSetting{UserId: user.ID, Key: storepb.UserSetting_GENERAL,
+ Value: &storepb.UserSetting_General{General: &storepb.GeneralUserSetting{Locale: user.Username}}},
+ &storepb.UserSetting{UserId: user.ID, Key: storepb.UserSetting_MEMO_VIEWS,
+ Value: &storepb.UserSetting_MemoViews{MemoViews: &storepb.MemoViewsUserSetting{
+ MemoViews: []*storepb.MemoViewsUserSetting_MemoView{{Id: "saved", Title: user.Username}},
+ }}})
+ }
+ for _, setting := range settings {
+ _, err := ts.UpsertUserSetting(ctx, setting)
+ require.NoError(t, err)
+ cached, err := ts.GetUserSetting(ctx, &store.FindUserSetting{UserID: &setting.UserId, Key: setting.Key})
+ require.NoError(t, err)
+ require.True(t, proto.Equal(setting, cached))
+ }
+ delete := &store.DeleteUserSetting{UserID: &owner.ID, Key: storepb.UserSetting_GENERAL}
+ switch name {
+ case "all user keys":
+ delete.Key = storepb.UserSetting_KEY_UNSPECIFIED
+ case "key across users":
+ delete.UserID = nil
+ case "all settings":
+ delete = &store.DeleteUserSetting{}
+ case "missing user":
+ delete.UserID = new(int32(99999))
+ case "missing key":
+ delete.Key = storepb.UserSetting_WEBHOOKS
+ default:
+ }
+ for range 2 { // Repeated deletion must remain harmless.
+ require.NoError(t, ts.DeleteUserSettings(ctx, delete))
+ var expected []*storepb.UserSetting
+ for _, setting := range settings {
+ got, err := ts.GetUserSetting(ctx, &store.FindUserSetting{UserID: &setting.UserId, Key: setting.Key})
+ require.NoError(t, err)
+ matches := (delete.UserID == nil || *delete.UserID == setting.UserId) &&
+ (delete.Key == storepb.UserSetting_KEY_UNSPECIFIED || delete.Key == setting.Key)
+ if matches {
+ require.Nil(t, got, "deleted setting must not survive in cache")
+ } else {
+ require.True(t, proto.Equal(setting, got), "unrelated setting changed")
+ expected = append(expected, setting)
+ }
+ }
+ persisted, err := ts.ListUserSettings(ctx, &store.FindUserSetting{})
+ require.NoError(t, err)
+ require.Len(t, persisted, len(expected))
+ for _, want := range expected {
+ require.Condition(t, func() bool {
+ for _, got := range persisted {
+ if proto.Equal(want, got) {
+ return true
+ }
+ }
+ return false
+ })
+ }
+ }
+ // Recreating a deleted key must be visible immediately, including after a cached miss.
+ _, err = ts.UpsertUserSetting(ctx, &storepb.UserSetting{UserId: owner.ID, Key: storepb.UserSetting_GENERAL,
+ Value: &storepb.UserSetting_General{General: &storepb.GeneralUserSetting{Locale: "new"}}})
+ require.NoError(t, err)
+ got, err := ts.GetUserSetting(ctx, &store.FindUserSetting{UserID: &owner.ID, Key: storepb.UserSetting_GENERAL})
+ require.NoError(t, err)
+ require.Equal(t, "new", got.GetGeneral().GetLocale())
+ })
+ }
+}
+
+func TestDeleteUserSettingsFailurePreservesDataAndCache(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ user, err := createTestingHostUser(ctx, ts)
+ require.NoError(t, err)
+ setting, err := ts.UpsertUserSetting(ctx, &storepb.UserSetting{UserId: user.ID, Key: storepb.UserSetting_GENERAL,
+ Value: &storepb.UserSetting_General{General: &storepb.GeneralUserSetting{Locale: "en"}}})
+ require.NoError(t, err)
+ removeTrigger := rejectStoreDelete(t, ts, "user_setting")
+ require.ErrorContains(t, ts.DeleteUserSettings(ctx, &store.DeleteUserSetting{UserID: &user.ID}), "store test delete failure")
+ cached, err := ts.GetUserSetting(ctx, &store.FindUserSetting{UserID: &user.ID, Key: setting.Key})
+ require.NoError(t, err)
+ require.True(t, proto.Equal(setting, cached))
+ persisted, err := ts.ListUserSettings(ctx, &store.FindUserSetting{UserID: &user.ID})
+ require.NoError(t, err)
+ require.Len(t, persisted, 1)
+ require.True(t, proto.Equal(setting, persisted[0]))
+ removeTrigger()
+ require.NoError(t, ts.DeleteUserSettings(ctx, &store.DeleteUserSetting{UserID: &user.ID}))
+ cached, err = ts.GetUserSetting(ctx, &store.FindUserSetting{UserID: &user.ID, Key: setting.Key})
+ require.NoError(t, err)
+ require.Nil(t, cached)
+}