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:
bluedbird
2026-09-19 23:59:09 +08:00
parent f4d97fafcd
commit 7a0586af0d
12 changed files with 1521 additions and 7 deletions
+8 -6
View File
@@ -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
}
+160
View File
@@ -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)
})
}
})
}
}
+36
View File
@@ -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)
}
+35
View File
@@ -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)
}
}
+1 -1
View File
@@ -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)
+46
View File
@@ -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)
}
}
+545
View File
@@ -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)
})
}
}
+155
View File
@@ -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)
}
+110
View File
@@ -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)
})
}
}
+145
View File
@@ -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()
+162
View File
@@ -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")
})
}
}
+118
View File
@@ -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)
}