250 lines
7.4 KiB
Go
250 lines
7.4 KiB
Go
package logic
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
|
|
"spark-server/internal/infrastructure/id"
|
|
friendlogic "spark-server/internal/module/friend/logic"
|
|
friendmodel "spark-server/internal/module/friend/model"
|
|
"spark-server/internal/module/square/entity"
|
|
squaremodel "spark-server/internal/module/square/model"
|
|
userentity "spark-server/internal/module/user/entity"
|
|
userlogic "spark-server/internal/module/user/logic"
|
|
"spark-server/internal/module/user/logictest"
|
|
"spark-server/internal/pkg/errs"
|
|
"spark-server/internal/pkg/reqctx"
|
|
)
|
|
|
|
type memObj struct {
|
|
deleted []string
|
|
}
|
|
|
|
func (m *memObj) Delete(_ context.Context, key string) error {
|
|
m.deleted = append(m.deleted, key)
|
|
return nil
|
|
}
|
|
|
|
func testSquare(t *testing.T) (*Service, *friendlogic.Service, *userlogic.Service) {
|
|
t.Helper()
|
|
ids, err := id.New(1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
users := logictest.Users(ids, nil)
|
|
friends := friendlogic.NewService(friendmodel.NewMemoryRepo(), users, ids, nil)
|
|
svc := NewService(squaremodel.NewMemoryRepo(), friends, users, &memObj{}, ids)
|
|
return svc, friends, users
|
|
}
|
|
|
|
func twoAccounts(t *testing.T, users *userlogic.Service) (*userentity.User, *userentity.User) {
|
|
t.Helper()
|
|
ctx := t.Context()
|
|
a, err := users.AuthenticateEmail(ctx, "test01@spark.com", "1", &userentity.LoginDevice{DeviceID: 1, DeviceType: userentity.DeviceIOS})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b, err := users.AuthenticateEmail(ctx, "test02@spark.com", "1", &userentity.LoginDevice{DeviceID: 2, DeviceType: userentity.DeviceWeb})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return a, b
|
|
}
|
|
|
|
func becomeFriends(t *testing.T, friends *friendlogic.Service, a, b *userentity.User) {
|
|
t.Helper()
|
|
ctx := t.Context()
|
|
applied, err := friends.Apply(ctx, a.ID, &friendlogic.ApplyInput{Email: "test02@spark.com"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := friends.Accept(ctx, b.ID, friendlogic.AcceptInput{RequestID: applied.RequestID}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func ctxUser(t *testing.T, uid int64, ip string) context.Context {
|
|
t.Helper()
|
|
return reqctx.With(t.Context(), &reqctx.RequestContext{UserID: uid, Language: "zh-CN", RealIP: ip})
|
|
}
|
|
|
|
func TestSquarePublishFeedPrivateAndNotice(t *testing.T) {
|
|
svc, friends, users := testSquare(t)
|
|
a, b := twoAccounts(t, users)
|
|
becomeFriends(t, friends, a, b)
|
|
ctxA := ctxUser(t, a.ID, "10.0.0.1")
|
|
ctxB := ctxUser(t, b.ID, "10.0.0.2")
|
|
pub, err := svc.Publish(ctxA, a.ID, &PublishInput{Text: "hello square"})
|
|
if err != nil || pub.Text != "hello square" {
|
|
t.Fatalf("%+v %v", pub, err)
|
|
}
|
|
feed, err := svc.Feed(ctxB, b.ID, 0, 20)
|
|
if err != nil || len(feed.Items) != 1 {
|
|
t.Fatalf("feed %+v %v", feed, err)
|
|
}
|
|
priv, err := svc.Publish(ctxA, a.ID, &PublishInput{Text: "secret", Visibility: entity.VisibilityPrivate})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
feed, err = svc.Feed(ctxB, b.ID, 0, 20)
|
|
if err != nil || len(feed.Items) != 1 {
|
|
t.Fatalf("private in feed %+v", feed)
|
|
}
|
|
if _, err := svc.Get(ctxB, b.ID, priv.ID); !errors.Is(err, errs.ErrNotFound) {
|
|
t.Fatalf("private get %v", err)
|
|
}
|
|
liked, err := svc.Like(ctxB, b.ID, pub.ID)
|
|
if err != nil || !liked.Liked {
|
|
t.Fatal(liked, err)
|
|
}
|
|
notices, err := svc.ListNotices(ctxA, a.ID, 0, 20)
|
|
if err != nil || len(notices.Items) != 1 || notices.Items[0].Kind != entity.NoticeLike {
|
|
t.Fatalf("notice %+v %v", notices, err)
|
|
}
|
|
unread, err := svc.NoticeUnread(ctxA, a.ID)
|
|
if err != nil || !unread.HasNew {
|
|
t.Fatalf("unread %+v", unread)
|
|
}
|
|
}
|
|
|
|
func TestSquareExcludeIncludeAndUserPosts(t *testing.T) {
|
|
svc, friends, users := testSquare(t)
|
|
a, b := twoAccounts(t, users)
|
|
becomeFriends(t, friends, a, b)
|
|
ctx := t.Context()
|
|
c, err := users.AuthenticateEmail(ctx, "test03@spark.com", "1", &userentity.LoginDevice{DeviceID: 3, DeviceType: userentity.DeviceIOS})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctxA := ctxUser(t, a.ID, "10.0.0.1")
|
|
ctxB := ctxUser(t, b.ID, "10.0.0.2")
|
|
ctxC := ctxUser(t, c.ID, "10.0.0.3")
|
|
excl, err := svc.Publish(ctxA, a.ID, &PublishInput{
|
|
Text: "hide from b", Visibility: entity.VisibilityExclude, AudienceUIDs: []int64{b.ID},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
feedB, err := svc.Feed(ctxB, b.ID, 0, 20)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, item := range feedB.Items {
|
|
if item.ID == excl.ID {
|
|
t.Fatal("excluded user still sees post in feed")
|
|
}
|
|
}
|
|
feedC, err := svc.Feed(ctxC, c.ID, 0, 20)
|
|
if err != nil || len(feedC.Items) != 1 {
|
|
t.Fatalf("stranger feed %+v %v", feedC, err)
|
|
}
|
|
incl, err := svc.Publish(ctxA, a.ID, &PublishInput{
|
|
Text: "only b", Visibility: entity.VisibilityInclude, AudienceUIDs: []int64{b.ID},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
feedC, err = svc.Feed(ctxC, c.ID, 0, 20)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, item := range feedC.Items {
|
|
if item.ID == incl.ID {
|
|
t.Fatal("include post leaked to stranger feed")
|
|
}
|
|
}
|
|
album, err := svc.UserPosts(ctxB, b.ID, a.ID, 0, 20)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var sawIncl bool
|
|
for _, item := range album.Items {
|
|
if item.ID == excl.ID {
|
|
t.Fatal("excluded user sees post on profile")
|
|
}
|
|
if item.ID == incl.ID {
|
|
sawIncl = true
|
|
}
|
|
}
|
|
if !sawIncl {
|
|
t.Fatalf("include missing from album %+v", album)
|
|
}
|
|
if _, err := svc.Get(ctxB, b.ID, incl.ID); err != nil {
|
|
t.Fatalf("include get %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSquareUnlikeCommentDeleteAndPurge(t *testing.T) {
|
|
svc, friends, users := testSquare(t)
|
|
a, b := twoAccounts(t, users)
|
|
becomeFriends(t, friends, a, b)
|
|
ctxA := ctxUser(t, a.ID, "10.0.0.1")
|
|
ctxB := ctxUser(t, b.ID, "10.0.0.2")
|
|
post, err := svc.Publish(ctxA, a.ID, &PublishInput{Text: "hi"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := svc.Like(ctxB, b.ID, post.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
unliked, err := svc.Unlike(ctxB, b.ID, post.ID)
|
|
if err != nil || unliked.Liked || unliked.LikeCount != 0 {
|
|
t.Fatalf("unlike %+v %v", unliked, err)
|
|
}
|
|
commented, err := svc.Comment(ctxB, b.ID, post.ID, &CommentInput{Text: "nice"})
|
|
if err != nil || commented.CommentCount != 1 {
|
|
t.Fatalf("comment %+v %v", commented, err)
|
|
}
|
|
cid := commented.Comments[0].ID
|
|
replied, err := svc.Comment(ctxA, a.ID, post.ID, &CommentInput{Text: "thanks", ReplyToID: cid})
|
|
if err != nil || replied.CommentCount != 2 {
|
|
t.Fatalf("reply %+v %v", replied, err)
|
|
}
|
|
if _, err := svc.DeleteComment(ctxB, b.ID, post.ID, cid); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := svc.Get(ctxA, a.ID, post.ID)
|
|
if err != nil || got.CommentCount != 1 {
|
|
t.Fatalf("deleted comment %+v %v", got, err)
|
|
}
|
|
if err := svc.Delete(ctxA, a.ID, post.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
feed, err := svc.Feed(ctxB, b.ID, 0, 20)
|
|
if err != nil || len(feed.Items) != 0 {
|
|
t.Fatalf("deleted feed %+v %v", feed, err)
|
|
}
|
|
post2, err := svc.Publish(ctxA, a.ID, &PublishInput{
|
|
Images: []*entity.Image{{Key: "perm/square/image/20260922/abcdefghijklmnop.jpg"}},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := svc.ReadNotices(ctxA, a.ID, &NoticeReadInput{Cursor: 0}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
unread, err := svc.NoticeUnread(ctxA, a.ID)
|
|
if err != nil || unread.HasNew {
|
|
t.Fatalf("after read %+v %v", unread, err)
|
|
}
|
|
if err := svc.PurgeUser(ctxA, a.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := svc.Get(ctxA, a.ID, post2.ID); !errors.Is(err, errs.ErrNotFound) {
|
|
t.Fatalf("purged get %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSquareImageKeyRejectedIfChatPrefix(t *testing.T) {
|
|
svc, _, users := testSquare(t)
|
|
a, _ := twoAccounts(t, users)
|
|
ctx := ctxUser(t, a.ID, "10.0.0.1")
|
|
_, err := svc.Publish(ctx, a.ID, &PublishInput{
|
|
Images: []*entity.Image{{Key: "chat/image/20260918/xxxx.jpg"}},
|
|
})
|
|
if err == nil {
|
|
t.Fatal("accepted chat key")
|
|
}
|
|
}
|