1093 lines
29 KiB
Go
1093 lines
29 KiB
Go
package test
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
func TestMemoRelationStore(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
memoCreate := &store.Memo{
|
|
UID: "main-memo",
|
|
CreatorID: user.ID,
|
|
Content: "main memo content",
|
|
Visibility: store.Public,
|
|
}
|
|
memo, err := ts.CreateMemo(ctx, memoCreate)
|
|
require.NoError(t, err)
|
|
require.Equal(t, memoCreate.Content, memo.Content)
|
|
relatedMemoCreate := &store.Memo{
|
|
UID: "related-memo",
|
|
CreatorID: user.ID,
|
|
Content: "related memo content",
|
|
Visibility: store.Public,
|
|
}
|
|
relatedMemo, err := ts.CreateMemo(ctx, relatedMemoCreate)
|
|
require.NoError(t, err)
|
|
require.Equal(t, relatedMemoCreate.Content, relatedMemo.Content)
|
|
commentMemoCreate := &store.Memo{
|
|
UID: "comment-memo",
|
|
CreatorID: user.ID,
|
|
Content: "comment memo content",
|
|
Visibility: store.Public,
|
|
}
|
|
commentMemo, err := ts.CreateMemo(ctx, commentMemoCreate)
|
|
require.NoError(t, err)
|
|
require.Equal(t, commentMemoCreate.Content, commentMemo.Content)
|
|
|
|
// Reference relation.
|
|
referenceRelation := &store.MemoRelation{
|
|
MemoID: memo.ID,
|
|
RelatedMemoID: relatedMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
}
|
|
_, err = ts.UpsertMemoRelation(ctx, referenceRelation)
|
|
require.NoError(t, err)
|
|
// Comment relation.
|
|
commentRelation := &store.MemoRelation{
|
|
MemoID: memo.ID,
|
|
RelatedMemoID: commentMemo.ID,
|
|
Type: store.MemoRelationComment,
|
|
}
|
|
_, err = ts.UpsertMemoRelation(ctx, commentRelation)
|
|
require.Error(t, err)
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationListByMemoID(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
// Create main memo
|
|
mainMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "main-memo",
|
|
CreatorID: user.ID,
|
|
Content: "main memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create related memos
|
|
relatedMemo1, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo-1",
|
|
CreatorID: user.ID,
|
|
Content: "related memo 1 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
relatedMemo2, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo-2",
|
|
CreatorID: user.ID,
|
|
Content: "related memo 2 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create relations
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo1.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo2.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// List by memo ID
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(relations))
|
|
|
|
// List by type
|
|
refType := store.MemoRelationReference
|
|
refRelations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
Type: &refType,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(refRelations))
|
|
require.Equal(t, store.MemoRelationReference, refRelations[0].Type)
|
|
|
|
// List by related memo ID
|
|
relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
RelatedMemoID: &relatedMemo1.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(relations))
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationDelete(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
// Create memos
|
|
mainMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "main-memo",
|
|
CreatorID: user.ID,
|
|
Content: "main memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
relatedMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo",
|
|
CreatorID: user.ID,
|
|
Content: "related memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create relation
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Verify relation exists
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(relations))
|
|
|
|
// Delete relation by memo ID
|
|
relType := store.MemoRelationReference
|
|
err = ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
RelatedMemoID: &relatedMemo.ID,
|
|
Type: &relType,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Verify relation is deleted
|
|
relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, 0, len(relations))
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationDeleteRequiresExplicitReferenceType(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
defer ts.Close()
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
contextMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "delete-guard-context",
|
|
CreatorID: user.ID,
|
|
Content: "context",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
comment, err := ts.CreateMemoComment(ctx, &store.Memo{
|
|
UID: "delete-guard-comment",
|
|
CreatorID: user.ID,
|
|
Content: "comment",
|
|
Visibility: store.Private,
|
|
}, contextMemo.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
commentType := store.MemoRelationComment
|
|
referenceType := store.MemoRelationReference
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: comment.ID,
|
|
RelatedMemoID: contextMemo.ID,
|
|
Type: referenceType,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
assertRelationExists := func(t *testing.T, relationType store.MemoRelationType) {
|
|
t.Helper()
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &comment.ID,
|
|
Type: &relationType,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 1)
|
|
require.Equal(t, contextMemo.ID, relations[0].RelatedMemoID)
|
|
}
|
|
assertRelationsExist := func(t *testing.T) {
|
|
t.Helper()
|
|
assertRelationExists(t, commentType)
|
|
assertRelationExists(t, referenceType)
|
|
}
|
|
assertRelationsExist(t)
|
|
|
|
zeroID := int32(0)
|
|
negativeID := int32(-1)
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
run func() error
|
|
}{
|
|
{
|
|
name: "store rejects omitted type",
|
|
run: func() error {
|
|
return ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{
|
|
MemoID: &comment.ID, RelatedMemoID: &contextMemo.ID,
|
|
})
|
|
},
|
|
},
|
|
{
|
|
name: "driver rejects omitted type",
|
|
run: func() error {
|
|
return ts.GetDriver().DeleteMemoRelation(ctx, &store.DeleteMemoRelation{
|
|
MemoID: &comment.ID, RelatedMemoID: &contextMemo.ID,
|
|
})
|
|
},
|
|
},
|
|
{
|
|
name: "driver rejects comment type",
|
|
run: func() error {
|
|
return ts.GetDriver().DeleteMemoRelation(ctx, &store.DeleteMemoRelation{
|
|
MemoID: &comment.ID, RelatedMemoID: &contextMemo.ID, Type: &commentType,
|
|
})
|
|
},
|
|
},
|
|
{
|
|
name: "store rejects unscoped reference delete",
|
|
run: func() error {
|
|
return ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{Type: &referenceType})
|
|
},
|
|
},
|
|
{
|
|
name: "driver rejects unscoped reference delete",
|
|
run: func() error {
|
|
return ts.GetDriver().DeleteMemoRelation(ctx, &store.DeleteMemoRelation{Type: &referenceType})
|
|
},
|
|
},
|
|
{
|
|
name: "store rejects non-positive memo endpoint",
|
|
run: func() error {
|
|
return ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{MemoID: &zeroID, Type: &referenceType})
|
|
},
|
|
},
|
|
{
|
|
name: "driver rejects non-positive related endpoint",
|
|
run: func() error {
|
|
return ts.GetDriver().DeleteMemoRelation(ctx, &store.DeleteMemoRelation{RelatedMemoID: &negativeID, Type: &referenceType})
|
|
},
|
|
},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
require.Error(t, test.run())
|
|
assertRelationsExist(t)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMemoRelationDifferentTypes(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
mainMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "main-memo",
|
|
CreatorID: user.ID,
|
|
Content: "main memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
relatedMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo",
|
|
CreatorID: user.ID,
|
|
Content: "related memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create reference relation
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// COMMENT context is created atomically with its memo and cannot be
|
|
// persisted through the generic relation mutation path.
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo.ID,
|
|
Type: store.MemoRelationComment,
|
|
})
|
|
require.Error(t, err)
|
|
|
|
// Verify only the reference relation exists.
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 1)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationUpsertSameRelation(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
mainMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "main-memo",
|
|
CreatorID: user.ID,
|
|
Content: "main memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
relatedMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo",
|
|
CreatorID: user.ID,
|
|
Content: "related memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create relation
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Upsert the same relation again (should not create duplicate)
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Verify only one relation exists
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 1)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationDeleteByType(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
mainMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "main-memo",
|
|
CreatorID: user.ID,
|
|
Content: "main memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
relatedMemo1, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo-1",
|
|
CreatorID: user.ID,
|
|
Content: "related memo 1 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
relatedMemo2, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo-2",
|
|
CreatorID: user.ID,
|
|
Content: "related memo 2 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create reference relations
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo1.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create a second reference relation.
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo2.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Delete only reference type relations
|
|
refType := store.MemoRelationReference
|
|
err = ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
Type: &refType,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Verify all reference relations were deleted.
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Empty(t, relations)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationDeleteByMemoID(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
memo1, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-1",
|
|
CreatorID: user.ID,
|
|
Content: "memo 1 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memo2, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-2",
|
|
CreatorID: user.ID,
|
|
Content: "memo 2 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
relatedMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo",
|
|
CreatorID: user.ID,
|
|
Content: "related memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create relations for both memos
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memo1.ID,
|
|
RelatedMemoID: relatedMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memo2.ID,
|
|
RelatedMemoID: relatedMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Delete all reference relations for memo1.
|
|
referenceType := store.MemoRelationReference
|
|
err = ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{
|
|
MemoID: &memo1.ID,
|
|
Type: &referenceType,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Verify memo1's relations are gone
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &memo1.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 0)
|
|
|
|
// Verify memo2's relations still exist
|
|
relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &memo2.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 1)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationListByRelatedMemoID(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
// Create a memo that will be referenced by others
|
|
targetMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "target-memo",
|
|
CreatorID: user.ID,
|
|
Content: "target memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create memos that reference the target
|
|
referrer1, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "referrer-1",
|
|
CreatorID: user.ID,
|
|
Content: "referrer 1 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
referrer2, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "referrer-2",
|
|
CreatorID: user.ID,
|
|
Content: "referrer 2 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create relations pointing to target
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: referrer1.ID,
|
|
RelatedMemoID: targetMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: referrer2.ID,
|
|
RelatedMemoID: targetMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// List by related memo ID (find all memos that reference the target)
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
RelatedMemoID: &targetMemo.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 2)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationListCombinedFilters(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
mainMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "main-memo",
|
|
CreatorID: user.ID,
|
|
Content: "main memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
relatedMemo1, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo-1",
|
|
CreatorID: user.ID,
|
|
Content: "related memo 1 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
relatedMemo2, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo-2",
|
|
CreatorID: user.ID,
|
|
Content: "related memo 2 content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create multiple relations
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo1.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo2.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// List with MemoID and Type filter
|
|
refType := store.MemoRelationReference
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
RelatedMemoID: &relatedMemo1.ID,
|
|
Type: &refType,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 1)
|
|
require.Equal(t, relatedMemo1.ID, relations[0].RelatedMemoID)
|
|
|
|
// List with MemoID, RelatedMemoID, and Type filter
|
|
relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
RelatedMemoID: &relatedMemo2.ID,
|
|
Type: &refType,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 1)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationListEmpty(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
memo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-no-relations",
|
|
CreatorID: user.ID,
|
|
Content: "memo with no relations",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// List relations for memo with none
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &memo.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 0)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationBidirectional(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
memoA, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-a",
|
|
CreatorID: user.ID,
|
|
Content: "memo A content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memoB, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-b",
|
|
CreatorID: user.ID,
|
|
Content: "memo B content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create relation A -> B
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memoA.ID,
|
|
RelatedMemoID: memoB.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create relation B -> A (reverse direction)
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memoB.ID,
|
|
RelatedMemoID: memoA.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Verify A -> B exists
|
|
relationsFromA, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &memoA.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relationsFromA, 1)
|
|
require.Equal(t, memoB.ID, relationsFromA[0].RelatedMemoID)
|
|
|
|
// Verify B -> A exists
|
|
relationsFromB, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &memoB.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relationsFromB, 1)
|
|
require.Equal(t, memoA.ID, relationsFromB[0].RelatedMemoID)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationListByMemoIDList(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
// Create 3 memos.
|
|
memoA, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-a",
|
|
CreatorID: user.ID,
|
|
Content: "memo A content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memoB, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-b",
|
|
CreatorID: user.ID,
|
|
Content: "memo B content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memoC, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-c",
|
|
CreatorID: user.ID,
|
|
Content: "memo C content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memoD, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-d",
|
|
CreatorID: user.ID,
|
|
Content: "memo D content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// A -> B (reference)
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memoA.ID,
|
|
RelatedMemoID: memoB.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// A -> C (reference)
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memoA.ID,
|
|
RelatedMemoID: memoC.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// D -> B (reference) — B appears as related_memo_id
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memoD.ID,
|
|
RelatedMemoID: memoB.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Batch query for memos A and B: should return all 3 relations
|
|
// (A->B because A is in list, A->C because A is in list, D->B because B is in list)
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoIDList: []int32{memoA.ID, memoB.ID},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 3)
|
|
|
|
// Batch query for memo C only: should return 1 relation (A->C because C is related_memo_id)
|
|
relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoIDList: []int32{memoC.ID},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 1)
|
|
require.Equal(t, memoA.ID, relations[0].MemoID)
|
|
require.Equal(t, memoC.ID, relations[0].RelatedMemoID)
|
|
|
|
// Batch query for memo D only: should return 1 relation (D->B because D is memo_id)
|
|
relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoIDList: []int32{memoD.ID},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 1)
|
|
require.Equal(t, memoD.ID, relations[0].MemoID)
|
|
require.Equal(t, memoB.ID, relations[0].RelatedMemoID)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationListByMemoIDListEmpty(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
memo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-no-relations",
|
|
CreatorID: user.ID,
|
|
Content: "memo with no relations",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Batch query with a memo that has no relations.
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoIDList: []int32{memo.ID},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 0)
|
|
|
|
// Empty MemoIDList should not filter by MemoIDList (returns based on other filters).
|
|
relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoIDList: []int32{},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 0)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationListByMemoIDListWithTypeFilter(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
memoA, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-a",
|
|
CreatorID: user.ID,
|
|
Content: "memo A content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memoB, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-b",
|
|
CreatorID: user.ID,
|
|
Content: "memo B content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memoC, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-c",
|
|
CreatorID: user.ID,
|
|
Content: "memo C content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// A -> B (reference)
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memoA.ID,
|
|
RelatedMemoID: memoB.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// A -> C (reference)
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memoA.ID,
|
|
RelatedMemoID: memoC.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Batch query with type filter: only references
|
|
refType := store.MemoRelationReference
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoIDList: []int32{memoA.ID},
|
|
Type: &refType,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 2)
|
|
require.Equal(t, store.MemoRelationReference, relations[0].Type)
|
|
|
|
// Batch query with type filter: only comments
|
|
commentType := store.MemoRelationComment
|
|
relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoIDList: []int32{memoA.ID},
|
|
Type: &commentType,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Empty(t, relations)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationListByMemoIDListBothDirections(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
memoA, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-a",
|
|
CreatorID: user.ID,
|
|
Content: "memo A content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memoB, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-b",
|
|
CreatorID: user.ID,
|
|
Content: "memo B content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
memoX, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "memo-x",
|
|
CreatorID: user.ID,
|
|
Content: "memo X content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// X -> A (A appears as related_memo_id)
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memoX.ID,
|
|
RelatedMemoID: memoA.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// A -> B (A appears as memo_id)
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: memoA.ID,
|
|
RelatedMemoID: memoB.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Query with MemoIDList=[A]: should find both relations (A as source and A as target).
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoIDList: []int32{memoA.ID},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 2)
|
|
|
|
// Verify we got both directions.
|
|
memoIDs := map[int32]bool{}
|
|
relatedIDs := map[int32]bool{}
|
|
for _, r := range relations {
|
|
memoIDs[r.MemoID] = true
|
|
relatedIDs[r.RelatedMemoID] = true
|
|
}
|
|
require.True(t, memoIDs[memoX.ID], "should include X->A relation")
|
|
require.True(t, memoIDs[memoA.ID], "should include A->B relation")
|
|
require.True(t, relatedIDs[memoA.ID], "should include X->A relation")
|
|
require.True(t, relatedIDs[memoB.ID], "should include A->B relation")
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationMultipleRelationsToSameMemo(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
|
|
mainMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "main-memo",
|
|
CreatorID: user.ID,
|
|
Content: "main memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Create multiple memos that all relate to the main memo
|
|
for i := 1; i <= 5; i++ {
|
|
relatedMemo, err := ts.CreateMemo(ctx, &store.Memo{
|
|
UID: "related-memo-" + string(rune('0'+i)),
|
|
CreatorID: user.ID,
|
|
Content: "related memo content",
|
|
Visibility: store.Public,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{
|
|
MemoID: mainMemo.ID,
|
|
RelatedMemoID: relatedMemo.ID,
|
|
Type: store.MemoRelationReference,
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// Verify all 5 relations exist
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
MemoID: &mainMemo.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 5)
|
|
|
|
ts.Close()
|
|
}
|
|
|
|
func TestMemoRelationFiltersSourceStatusBeforePagination(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
defer ts.Close()
|
|
user, err := createTestingHostUser(ctx, ts)
|
|
require.NoError(t, err)
|
|
parent, err := ts.CreateMemo(ctx, &store.Memo{UID: "status-parent", CreatorID: user.ID, Content: "parent", Visibility: store.Public})
|
|
require.NoError(t, err)
|
|
normalMemo, err := ts.CreateMemo(ctx, &store.Memo{UID: "status-normal", CreatorID: user.ID, Content: "normal", Visibility: store.Public})
|
|
require.NoError(t, err)
|
|
archivedMemo, err := ts.CreateMemo(ctx, &store.Memo{UID: "status-archived", CreatorID: user.ID, Content: "archived", Visibility: store.Public})
|
|
require.NoError(t, err)
|
|
archived := store.Archived
|
|
require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: archivedMemo.ID, RowStatus: &archived}))
|
|
for _, memoID := range []int32{normalMemo.ID, archivedMemo.ID} {
|
|
_, err := ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: memoID, RelatedMemoID: parent.ID, Type: store.MemoRelationReference})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
normal := store.Normal
|
|
referenceType := store.MemoRelationReference
|
|
limit := 1
|
|
relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{
|
|
RelatedMemoID: &parent.ID,
|
|
Type: &referenceType,
|
|
SourceMemoRowStatus: &normal,
|
|
Limit: &limit,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, relations, 1)
|
|
require.Equal(t, normalMemo.ID, relations[0].MemoID)
|
|
}
|