458 lines
16 KiB
Go
458 lines
16 KiB
Go
package rpc
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"testing"
|
||
"time"
|
||
|
||
"github.com/gotd/td/bin"
|
||
"github.com/gotd/td/proto"
|
||
"github.com/gotd/td/tg"
|
||
"go.uber.org/zap/zaptest"
|
||
|
||
"telesrv/internal/domain"
|
||
"telesrv/internal/store"
|
||
)
|
||
|
||
func TestOutboxDispatcherPushesNewMessageAndMarksDelivered(t *testing.T) {
|
||
msg := domain.Message{
|
||
ID: 10,
|
||
OwnerUserID: 1000000002,
|
||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: 1000000001},
|
||
From: domain.Peer{Type: domain.PeerTypeUser, ID: 1000000001},
|
||
Date: 1700000300,
|
||
Body: "hello",
|
||
Pts: 7,
|
||
}
|
||
outbox := &captureDispatchOutbox{items: []store.DispatchOutboxItem{{
|
||
ID: 55,
|
||
TargetUserID: msg.OwnerUserID,
|
||
Pts: msg.Pts,
|
||
EventType: domain.UpdateEventNewMessage,
|
||
ExcludeSessionID: 99,
|
||
}}}
|
||
events := &captureUpdateEventStore{events: []domain.UpdateEvent{{
|
||
UserID: msg.OwnerUserID,
|
||
Type: domain.UpdateEventNewMessage,
|
||
Pts: msg.Pts,
|
||
PtsCount: 1,
|
||
Date: msg.Date,
|
||
Message: msg,
|
||
Users: []domain.User{{
|
||
ID: msg.From.ID,
|
||
FirstName: "Sender",
|
||
}},
|
||
}}}
|
||
sessions := &captureSessions{}
|
||
metrics := &captureOutboxMetrics{}
|
||
dispatcher := NewOutboxDispatcher(events, outbox, sessions, zaptest.NewLogger(t), WithOutboxMetrics(metrics))
|
||
dispatcher.DispatchOnce(context.Background())
|
||
|
||
if !outbox.delivered || outbox.deliveredUserID != msg.OwnerUserID || outbox.deliveredID != 55 {
|
||
t.Fatalf("delivered = %v user=%d id=%d, want outbox delivered", outbox.delivered, outbox.deliveredUserID, outbox.deliveredID)
|
||
}
|
||
if sessions.userID != msg.OwnerUserID || sessions.sessionID != 99 || sessions.messageType != proto.MessageFromServer {
|
||
t.Fatalf("push target = user %d exclude %d type %v, want outbox target/exclude", sessions.userID, sessions.sessionID, sessions.messageType)
|
||
}
|
||
updates, ok := sessions.message.(*tg.Updates)
|
||
if !ok {
|
||
t.Fatalf("pushed message = %T, want *tg.Updates", sessions.message)
|
||
}
|
||
if len(updates.Updates) != 1 || len(updates.Users) != 1 {
|
||
t.Fatalf("updates = %+v, want one update and sender user", updates)
|
||
}
|
||
update, ok := updates.Updates[0].(*tg.UpdateNewMessage)
|
||
if !ok || update.Pts != msg.Pts {
|
||
t.Fatalf("update = %#v, want UpdateNewMessage pts=%d", updates.Updates[0], msg.Pts)
|
||
}
|
||
if metrics.claimed != 1 || metrics.delivered != 1 || metrics.failed != 0 {
|
||
t.Fatalf("metrics = claimed %d delivered %d failed %d, want 1/1/0", metrics.claimed, metrics.delivered, metrics.failed)
|
||
}
|
||
}
|
||
|
||
func TestOutboxDispatcherUsesScopedAuthKeyExclusion(t *testing.T) {
|
||
var excludeAuthKeyID [8]byte
|
||
excludeAuthKeyID[0] = 7
|
||
peer := domain.Peer{Type: domain.PeerTypeUser, ID: 1000000001}
|
||
outbox := &captureDispatchOutbox{items: []store.DispatchOutboxItem{{
|
||
ID: 57,
|
||
TargetUserID: 1000000002,
|
||
Pts: 9,
|
||
EventType: domain.UpdateEventPeerSettings,
|
||
ExcludeAuthKeyID: excludeAuthKeyID,
|
||
ExcludeSessionID: 99,
|
||
}}}
|
||
events := &captureUpdateEventStore{events: []domain.UpdateEvent{{
|
||
UserID: 1000000002,
|
||
Type: domain.UpdateEventPeerSettings,
|
||
Pts: 9,
|
||
PtsCount: 1,
|
||
Date: 1700000302,
|
||
Peer: peer,
|
||
}}}
|
||
sessions := &captureScopedSessions{captureSessions: &captureSessions{}}
|
||
dispatcher := NewOutboxDispatcher(events, outbox, sessions, zaptest.NewLogger(t))
|
||
dispatcher.DispatchOnce(context.Background())
|
||
|
||
if sessions.scopedAuthKeyID != excludeAuthKeyID || sessions.sessionID != 99 || sessions.userID != 1000000002 {
|
||
t.Fatalf("scoped push = auth %x session %d user %d, want precise outbox exclusion", sessions.scopedAuthKeyID, sessions.sessionID, sessions.userID)
|
||
}
|
||
}
|
||
|
||
// TestOutboxDispatcherBatchPath 覆盖生产批量路径：store 同时具备 BatchByCursor + MarkDeliveredBatch
|
||
// 时，DispatchOnce 一次批量取事件、推送、再批量标记 delivered，而非逐条。
|
||
func TestOutboxDispatcherBatchPath(t *testing.T) {
|
||
msg := domain.Message{
|
||
ID: 10,
|
||
OwnerUserID: 1000000002,
|
||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: 1000000001},
|
||
From: domain.Peer{Type: domain.PeerTypeUser, ID: 1000000001},
|
||
Date: 1700000300,
|
||
Body: "hello",
|
||
Pts: 7,
|
||
}
|
||
events := &batchEventStore{captureUpdateEventStore: &captureUpdateEventStore{events: []domain.UpdateEvent{{
|
||
UserID: msg.OwnerUserID,
|
||
Type: domain.UpdateEventNewMessage,
|
||
Pts: msg.Pts,
|
||
PtsCount: 1,
|
||
Date: msg.Date,
|
||
Message: msg,
|
||
Users: []domain.User{{ID: msg.From.ID, FirstName: "Sender"}},
|
||
}}}}
|
||
outbox := &batchDispatchOutbox{captureDispatchOutbox: &captureDispatchOutbox{items: []store.DispatchOutboxItem{{
|
||
ID: 55,
|
||
TargetUserID: msg.OwnerUserID,
|
||
Pts: msg.Pts,
|
||
EventType: domain.UpdateEventNewMessage,
|
||
ExcludeSessionID: 99,
|
||
}}}}
|
||
sessions := &captureSessions{}
|
||
metrics := &captureOutboxMetrics{}
|
||
dispatcher := NewOutboxDispatcher(events, outbox, sessions, zaptest.NewLogger(t), WithOutboxMetrics(metrics))
|
||
dispatcher.DispatchOnce(context.Background())
|
||
|
||
if len(events.batchCursors) != 1 || events.batchCursors[0] != (store.EventCursor{UserID: msg.OwnerUserID, Pts: msg.Pts}) {
|
||
t.Fatalf("batch cursors = %+v, want one cursor for (%d,%d)", events.batchCursors, msg.OwnerUserID, msg.Pts)
|
||
}
|
||
if sessions.userID != msg.OwnerUserID || sessions.sessionID != 99 {
|
||
t.Fatalf("push target = user %d exclude %d, want batch push to outbox target", sessions.userID, sessions.sessionID)
|
||
}
|
||
if len(outbox.deliveredBatch) != 1 || outbox.deliveredBatch[0].ID != 55 {
|
||
t.Fatalf("delivered batch = %+v, want one item id=55", outbox.deliveredBatch)
|
||
}
|
||
if outbox.delivered {
|
||
t.Fatalf("batch path should not call per-item MarkDelivered")
|
||
}
|
||
if metrics.claimed != 1 || metrics.delivered != 1 || metrics.failed != 0 {
|
||
t.Fatalf("metrics = claimed %d delivered %d failed %d, want 1/1/0", metrics.claimed, metrics.delivered, metrics.failed)
|
||
}
|
||
}
|
||
|
||
func TestOutboxDispatcherUsesBestEffortPush(t *testing.T) {
|
||
msg := domain.Message{
|
||
ID: 10,
|
||
OwnerUserID: 1000000002,
|
||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: 1000000001},
|
||
From: domain.Peer{Type: domain.PeerTypeUser, ID: 1000000001},
|
||
Date: 1700000300,
|
||
Body: "hello",
|
||
Pts: 7,
|
||
}
|
||
events := &captureUpdateEventStore{events: []domain.UpdateEvent{{
|
||
UserID: msg.OwnerUserID,
|
||
Type: domain.UpdateEventNewMessage,
|
||
Pts: msg.Pts,
|
||
PtsCount: 1,
|
||
Date: msg.Date,
|
||
Message: msg,
|
||
Users: []domain.User{{ID: msg.From.ID, FirstName: "Sender"}},
|
||
}}}
|
||
outbox := &captureDispatchOutbox{items: []store.DispatchOutboxItem{{
|
||
ID: 55,
|
||
TargetUserID: msg.OwnerUserID,
|
||
Pts: msg.Pts,
|
||
EventType: domain.UpdateEventNewMessage,
|
||
ExcludeSessionID: 99,
|
||
}}}
|
||
sessions := &captureBestEffortSessions{captureSessions: &captureSessions{}}
|
||
dispatcher := NewOutboxDispatcher(events, outbox, sessions, zaptest.NewLogger(t), WithOutboxPushTimeout(50*time.Millisecond))
|
||
dispatcher.DispatchOnce(context.Background())
|
||
|
||
if !sessions.bestEffort || sessions.timeout != 50*time.Millisecond {
|
||
t.Fatalf("best-effort push = %v timeout %v, want true/50ms", sessions.bestEffort, sessions.timeout)
|
||
}
|
||
if !outbox.delivered || outbox.failed {
|
||
t.Fatalf("outbox delivered=%v failed=%v, want delivered after accepted best-effort push", outbox.delivered, outbox.failed)
|
||
}
|
||
}
|
||
|
||
type captureBestEffortSessions struct {
|
||
*captureSessions
|
||
bestEffort bool
|
||
timeout time.Duration
|
||
}
|
||
|
||
func (s *captureBestEffortSessions) PushToUserExceptSessionBestEffort(ctx context.Context, userID, excludeSessionID int64, t proto.MessageType, msg bin.Encoder, timeout time.Duration) (int, error) {
|
||
s.bestEffort = true
|
||
s.timeout = timeout
|
||
return s.PushToUserExceptSession(ctx, userID, excludeSessionID, t, msg)
|
||
}
|
||
|
||
// batchEventStore 给 captureUpdateEventStore 加上 BatchByCursor 批量能力。
|
||
type batchEventStore struct {
|
||
*captureUpdateEventStore
|
||
batchCursors []store.EventCursor
|
||
}
|
||
|
||
func (s *batchEventStore) BatchByCursor(_ context.Context, cursors []store.EventCursor) ([]domain.UpdateEvent, error) {
|
||
s.batchCursors = cursors
|
||
out := make([]domain.UpdateEvent, 0, len(cursors))
|
||
for _, c := range cursors {
|
||
for _, event := range s.events {
|
||
if event.UserID == c.UserID && event.Pts == c.Pts {
|
||
out = append(out, event)
|
||
}
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
// batchDispatchOutbox 给 captureDispatchOutbox 加上 MarkDeliveredBatch 批量能力。
|
||
type batchDispatchOutbox struct {
|
||
*captureDispatchOutbox
|
||
deliveredBatch []store.DispatchOutboxItem
|
||
}
|
||
|
||
func (s *batchDispatchOutbox) MarkDeliveredBatch(_ context.Context, items []store.DispatchOutboxItem) error {
|
||
s.deliveredBatch = append(s.deliveredBatch, items...)
|
||
return nil
|
||
}
|
||
|
||
type captureUpdateEventStore struct {
|
||
events []domain.UpdateEvent
|
||
}
|
||
|
||
func (s *captureUpdateEventStore) Append(context.Context, int64, domain.UpdateEvent) error {
|
||
return nil
|
||
}
|
||
|
||
func (s *captureUpdateEventStore) ListAfter(_ context.Context, _ int64, pts, limit int) ([]domain.UpdateEvent, error) {
|
||
out := make([]domain.UpdateEvent, 0, len(s.events))
|
||
for _, event := range s.events {
|
||
if event.Pts > pts {
|
||
out = append(out, event)
|
||
if len(out) == limit {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *captureUpdateEventStore) Current(context.Context, int64) (int, error) {
|
||
maxPts := 0
|
||
for _, event := range s.events {
|
||
if event.Pts > maxPts {
|
||
maxPts = event.Pts
|
||
}
|
||
}
|
||
return maxPts, nil
|
||
}
|
||
|
||
func (s *captureUpdateEventStore) MaxContiguousPts(context.Context, int64) (int, error) {
|
||
present := make(map[int]struct{}, len(s.events))
|
||
for _, event := range s.events {
|
||
present[event.Pts] = struct{}{}
|
||
}
|
||
contiguous := 0
|
||
for {
|
||
if _, ok := present[contiguous+1]; !ok {
|
||
break
|
||
}
|
||
contiguous++
|
||
}
|
||
return contiguous, nil
|
||
}
|
||
|
||
func (s *captureUpdateEventStore) AdvanceContiguousPts(ctx context.Context, userID int64) (int, error) {
|
||
return s.MaxContiguousPts(ctx, userID)
|
||
}
|
||
|
||
type captureDispatchOutbox struct {
|
||
items []store.DispatchOutboxItem
|
||
delivered bool
|
||
deliveredUserID int64
|
||
deliveredID int64
|
||
failed bool
|
||
failedError string
|
||
}
|
||
|
||
type captureScopedSessions struct {
|
||
*captureSessions
|
||
scopedAuthKeyID [8]byte
|
||
}
|
||
|
||
func (s *captureScopedSessions) BindAuthKeyForSession(rawAuthKeyID [8]byte, sessionID int64, authKeyID [8]byte) {
|
||
s.BindAuthKey(sessionID, authKeyID)
|
||
s.scopedAuthKeyID = rawAuthKeyID
|
||
}
|
||
|
||
func (s *captureScopedSessions) AuthKeyIDForSession([8]byte, int64) ([8]byte, bool) {
|
||
return s.AuthKeyID(0)
|
||
}
|
||
|
||
func (s *captureScopedSessions) BindUserForAuthKey(rawAuthKeyID [8]byte, sessionID, userID int64) {
|
||
s.BindUser(sessionID, userID)
|
||
s.scopedAuthKeyID = rawAuthKeyID
|
||
}
|
||
|
||
func (s *captureScopedSessions) UserIDForAuthKey([8]byte, int64) (int64, bool) {
|
||
return s.UserID(0)
|
||
}
|
||
|
||
func (s *captureScopedSessions) UserIDResolvedForAuthKey([8]byte, int64) (int64, bool) {
|
||
return s.UserIDResolved(0)
|
||
}
|
||
|
||
func (s *captureScopedSessions) SetReceivesUpdatesForAuthKey([8]byte, int64, bool) {}
|
||
|
||
func (s *captureScopedSessions) PushToSessionForAuthKey(_ context.Context, rawAuthKeyID [8]byte, sessionID int64, t proto.MessageType, msg bin.Encoder) error {
|
||
s.scopedAuthKeyID = rawAuthKeyID
|
||
return s.PushToSession(context.Background(), sessionID, t, msg)
|
||
}
|
||
|
||
func (s *captureScopedSessions) PushToUserExceptAuthKeySession(_ context.Context, userID int64, excludeAuthKeyID [8]byte, excludeSessionID int64, t proto.MessageType, msg bin.Encoder) (int, error) {
|
||
s.scopedAuthKeyID = excludeAuthKeyID
|
||
return s.PushToUserExceptSession(context.Background(), userID, excludeSessionID, t, msg)
|
||
}
|
||
|
||
func (s *captureDispatchOutbox) ClaimPending(context.Context, int) ([]store.DispatchOutboxItem, error) {
|
||
items := s.items
|
||
s.items = nil
|
||
return items, nil
|
||
}
|
||
|
||
func (s *captureDispatchOutbox) MarkDelivered(_ context.Context, targetUserID, id int64) error {
|
||
s.delivered = true
|
||
s.deliveredUserID = targetUserID
|
||
s.deliveredID = id
|
||
return nil
|
||
}
|
||
|
||
func (s *captureDispatchOutbox) MarkFailed(_ context.Context, _ int64, _ int64, lastError string) error {
|
||
s.failed = true
|
||
s.failedError = lastError
|
||
return nil
|
||
}
|
||
|
||
func (s *captureDispatchOutbox) DeleteFailed(context.Context, time.Duration, int) (int, error) {
|
||
return 0, nil
|
||
}
|
||
|
||
func TestOutboxDispatcherUsesNoopAsDelivered(t *testing.T) {
|
||
outbox := &captureDispatchOutbox{items: []store.DispatchOutboxItem{{
|
||
ID: 56,
|
||
TargetUserID: 1000000002,
|
||
Pts: 8,
|
||
EventType: domain.UpdateEventNoop,
|
||
}}}
|
||
events := &captureUpdateEventStore{events: []domain.UpdateEvent{{
|
||
UserID: 1000000002,
|
||
Type: domain.UpdateEventNoop,
|
||
Pts: 8,
|
||
Date: 1700000301,
|
||
}}}
|
||
metrics := &captureOutboxMetrics{}
|
||
dispatcher := NewOutboxDispatcher(events, outbox, &captureSessions{}, zaptest.NewLogger(t), WithOutboxMetrics(metrics))
|
||
dispatcher.DispatchOnce(context.Background())
|
||
|
||
if !outbox.delivered || outbox.failed {
|
||
t.Fatalf("noop delivered=%v failed=%v, want delivered without push", outbox.delivered, outbox.failed)
|
||
}
|
||
if metrics.delivered != 1 {
|
||
t.Fatalf("noop delivered metrics = %d, want 1", metrics.delivered)
|
||
}
|
||
}
|
||
|
||
type captureOutboxMetrics struct {
|
||
claimed int
|
||
delivered int
|
||
failed int
|
||
}
|
||
|
||
func (m *captureOutboxMetrics) MessageSend(time.Duration, bool, error) {}
|
||
|
||
func (m *captureOutboxMetrics) MessageRateLimited(int) {}
|
||
|
||
func (m *captureOutboxMetrics) OutboxClaimed(count int) {
|
||
m.claimed += count
|
||
}
|
||
|
||
func (m *captureOutboxMetrics) OutboxDelivered(time.Duration) {
|
||
m.delivered++
|
||
}
|
||
|
||
func (m *captureOutboxMetrics) OutboxFailed(error) {
|
||
m.failed++
|
||
}
|
||
|
||
// queueFullBestEffortSessions 模拟出站队列拥塞：best-effort 推送总是失败（入队超时 / 队列满）。
|
||
type queueFullBestEffortSessions struct {
|
||
*captureSessions
|
||
attempts int
|
||
}
|
||
|
||
func (s *queueFullBestEffortSessions) PushToUserExceptSessionBestEffort(_ context.Context, _ int64, _ int64, _ proto.MessageType, _ bin.Encoder, _ time.Duration) (int, error) {
|
||
s.attempts++
|
||
return 0, errors.New("mtproto outbound queue full")
|
||
}
|
||
|
||
// TestOutboxDispatcherDefersOnPushQueueFull 验证 best-effort 推送因出站队列拥塞失败时，dispatcher
|
||
// 既不标记 delivered（任务保留，靠 dispatching 租约过期重投，满足至少一次投递语义），也不标记
|
||
// failed（拥塞不计入 attempts 升级，避免正常满 fan-out 负载把可靠 update 误打成 failed）。
|
||
func TestOutboxDispatcherDefersOnPushQueueFull(t *testing.T) {
|
||
msg := domain.Message{
|
||
ID: 10,
|
||
OwnerUserID: 1000000002,
|
||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: 1000000001},
|
||
From: domain.Peer{Type: domain.PeerTypeUser, ID: 1000000001},
|
||
Date: 1700000300,
|
||
Body: "hello",
|
||
Pts: 7,
|
||
}
|
||
events := &captureUpdateEventStore{events: []domain.UpdateEvent{{
|
||
UserID: msg.OwnerUserID,
|
||
Type: domain.UpdateEventNewMessage,
|
||
Pts: msg.Pts,
|
||
PtsCount: 1,
|
||
Date: msg.Date,
|
||
Message: msg,
|
||
Users: []domain.User{{ID: msg.From.ID, FirstName: "Sender"}},
|
||
}}}
|
||
outbox := &captureDispatchOutbox{items: []store.DispatchOutboxItem{{
|
||
ID: 55,
|
||
TargetUserID: msg.OwnerUserID,
|
||
Pts: msg.Pts,
|
||
EventType: domain.UpdateEventNewMessage,
|
||
ExcludeSessionID: 99,
|
||
}}}
|
||
sessions := &queueFullBestEffortSessions{captureSessions: &captureSessions{}}
|
||
metrics := &captureOutboxMetrics{}
|
||
dispatcher := NewOutboxDispatcher(events, outbox, sessions, zaptest.NewLogger(t), WithOutboxPushTimeout(50*time.Millisecond), WithOutboxMetrics(metrics))
|
||
dispatcher.DispatchOnce(context.Background())
|
||
|
||
if sessions.attempts != 1 {
|
||
t.Fatalf("best-effort push attempts = %d, want 1（应走 best-effort 推送路径）", sessions.attempts)
|
||
}
|
||
if outbox.delivered {
|
||
t.Fatalf("outbox delivered=true, want 未投递（拥塞应保留 dispatching 行靠租约重投）")
|
||
}
|
||
if outbox.failed {
|
||
t.Fatalf("outbox failed=true, want 未失败（拥塞不计入 attempts 升级）")
|
||
}
|
||
if metrics.failed != 0 {
|
||
t.Fatalf("metrics.failed=%d, want 0（拥塞不算投递失败）", metrics.failed)
|
||
}
|
||
}
|