107 lines
2.7 KiB
Go
107 lines
2.7 KiB
Go
package logic
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
|
|
"spark-server/internal/infrastructure/id"
|
|
"spark-server/internal/module/conversation/entity"
|
|
"spark-server/internal/module/conversation/model"
|
|
"spark-server/internal/pkg/errs"
|
|
)
|
|
|
|
func TestEnsureP2PAndUpdateLastMsg(t *testing.T) {
|
|
ids, err := id.New(1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
repo := model.NewMemoryP2P()
|
|
svc := NewP2PService(repo, ids)
|
|
ctx := t.Context()
|
|
if _, err := svc.EnsureP2P(ctx, 0, 1); !errors.Is(err, errs.ErrInvalidArgument) {
|
|
t.Fatalf("invalid %v", err)
|
|
}
|
|
if _, err := svc.EnsureP2P(ctx, 1, 1); !errors.Is(err, errs.ErrInvalidArgument) {
|
|
t.Fatalf("same user %v", err)
|
|
}
|
|
cid, err := svc.EnsureP2P(ctx, 1, 2)
|
|
if err != nil || cid <= 0 {
|
|
t.Fatalf("create %d %v", cid, err)
|
|
}
|
|
again, err := svc.EnsureP2P(ctx, 2, 1)
|
|
if err != nil || again != cid {
|
|
t.Fatalf("idempotent %d %v", again, err)
|
|
}
|
|
if err := svc.UpdateLastMsg(ctx, cid, 99, 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := repo.Get(ctx, cid)
|
|
if err != nil || got.LastMsgID != 99 {
|
|
t.Fatalf("last %+v %v", got, err)
|
|
}
|
|
if err := (*P2PService)(nil).UpdateLastMsg(ctx, cid, 1, 1); !errors.Is(err, errs.ErrAvailable) {
|
|
t.Fatalf("nil svc %v", err)
|
|
}
|
|
}
|
|
|
|
type stubP2P struct {
|
|
existing *entity.Conversation
|
|
getErr error
|
|
createErr error
|
|
}
|
|
|
|
func (s stubP2P) GetP2P(context.Context, int64, int64) (*entity.Conversation, error) {
|
|
if s.getErr != nil {
|
|
return nil, s.getErr
|
|
}
|
|
if s.existing != nil {
|
|
return s.existing, nil
|
|
}
|
|
return nil, errs.ErrNotFound
|
|
}
|
|
|
|
func (s stubP2P) CreateP2P(context.Context, *entity.Conversation, *entity.P2P, []*entity.Member) error {
|
|
return s.createErr
|
|
}
|
|
|
|
func (s stubP2P) UpdateLastMsg(context.Context, int64, int64, int64) error { return nil }
|
|
|
|
type dupP2P struct {
|
|
gets int
|
|
id int64
|
|
}
|
|
|
|
func (d *dupP2P) GetP2P(context.Context, int64, int64) (*entity.Conversation, error) {
|
|
d.gets++
|
|
if d.gets == 1 {
|
|
return nil, errs.ErrNotFound
|
|
}
|
|
return &entity.Conversation{ID: d.id}, nil
|
|
}
|
|
|
|
func (d *dupP2P) CreateP2P(context.Context, *entity.Conversation, *entity.P2P, []*entity.Member) error {
|
|
return errs.ErrDuplicate
|
|
}
|
|
|
|
func (d *dupP2P) UpdateLastMsg(context.Context, int64, int64, int64) error { return nil }
|
|
|
|
func TestEnsureP2PDuplicateAndErrors(t *testing.T) {
|
|
ids, err := id.New(1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx := t.Context()
|
|
dup := NewP2PService(&dupP2P{id: 9}, ids)
|
|
id9, err := dup.EnsureP2P(ctx, 1, 2)
|
|
if err != nil || id9 != 9 {
|
|
t.Fatalf("dup %d %v", id9, err)
|
|
}
|
|
if _, err := NewP2PService(stubP2P{getErr: errs.ErrAvailable}, ids).EnsureP2P(ctx, 1, 2); !errors.Is(err, errs.ErrAvailable) {
|
|
t.Fatalf("get %v", err)
|
|
}
|
|
if _, err := NewP2PService(stubP2P{createErr: errs.ErrInner}, ids).EnsureP2P(ctx, 1, 2); !errors.Is(err, errs.ErrInner) {
|
|
t.Fatalf("create %v", err)
|
|
}
|
|
}
|