mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
test(store): expand cross-database edge case coverage
Cover transaction rollback, stale state, permissions, cache invalidation, batch deletion, and concurrent writes across all three database drivers. Reject nil attachment bindings and enforce effective lifecycle policies before memo mutations reach the driver.
This commit is contained in:
@@ -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
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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%d@Example.COM ", 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%d@example.com", 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: "first@example.com"}
|
||||
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 = "first@example.com"
|
||||
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)
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
|
||||
|
||||
@@ -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")
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
Reference in New Issue
Block a user