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.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
test(store): expand cross-database edge case coverage
bluedbird7a0586af0d36
diff --git a/store/memo_attachment.go b/store/memo_attachment.goindex 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) emutation.MemoCreatorID = create.CreatorIDmutation.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) eremovedAttachmentIDs[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) ereturn 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 657345c61..ca7ecc59b 100644--- a/store/test/memo_share_test.go+++ b/store/test/memo_share_test.go@@ -3,6 +3,7 @@ package testimport ("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.gonew file mode 100644index 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.goindex 5ecb7932b..36eab2462 100644--- a/store/test/user_delete_test.go+++ b/store/test/user_delete_test.go@@ -2,6 +2,7 @@ package testimport ("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.gonew file mode 100644index 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.gonew file mode 100644index 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)+}