chore: refresh gramsrv public release
This commit is contained in:
A
parent
75cebe8dbf
commit
70b6820474
1274 changed files with 378751 additions and 59919 deletions
998
internal/rpc/router_dispatch_test.go
Normal file
998
internal/rpc/router_dispatch_test.go
Normal file
|
|
@ -0,0 +1,998 @@
|
|||
package rpc
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"github.com/gotd/td/bin"
|
||||
"github.com/gotd/td/clock"
|
||||
"github.com/gotd/td/tg"
|
||||
"github.com/gotd/td/tgerr"
|
||||
"go.uber.org/zap"
|
||||
"go.uber.org/zap/zaptest"
|
||||
"go.uber.org/zap/zaptest/observer"
|
||||
"reflect"
|
||||
"sync"
|
||||
appauth "telesrv/internal/app/auth"
|
||||
appdialogs "telesrv/internal/app/dialogs"
|
||||
"telesrv/internal/domain"
|
||||
"telesrv/internal/store/memory"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// TestDispatchUnwrapsWrappers 验证 Router 能剥离
|
||||
// invokeWithLayer(initConnection(help.getConfig)) 并路由到 getConfig handler。
|
||||
func TestDispatchUnwrapsWrappers(t *testing.T) {
|
||||
const (
|
||||
dc = 2
|
||||
ip = "127.0.0.1"
|
||||
port = 2398
|
||||
layer = 225
|
||||
)
|
||||
r := New(Config{DC: dc, IP: ip, Port: port}, Deps{}, zaptest.NewLogger(t), clock.System)
|
||||
|
||||
req := &tg.InvokeWithLayerRequest{
|
||||
Layer: layer,
|
||||
Query: &tg.InitConnectionRequest{
|
||||
APIID: 123,
|
||||
DeviceModel: "TestDevice",
|
||||
SystemVersion: "1.0",
|
||||
AppVersion: "1.0",
|
||||
SystemLangCode: "en",
|
||||
LangPack: "tdesktop",
|
||||
LangCode: "en",
|
||||
Query: &tg.HelpGetConfigRequest{},
|
||||
},
|
||||
}
|
||||
var b bin.Buffer
|
||||
if err := req.Encode(&b); err != nil {
|
||||
t.Fatalf("encode wrapped request: %v", err)
|
||||
}
|
||||
|
||||
enc, err := r.Dispatch(context.Background(), [8]byte{}, 0, &b)
|
||||
if err != nil {
|
||||
t.Fatalf("dispatch: %v", err)
|
||||
}
|
||||
cfg, ok := enc.(*tg.Config)
|
||||
if !ok {
|
||||
t.Fatalf("result type = %T, want *tg.Config", enc)
|
||||
}
|
||||
if cfg.ThisDC != dc {
|
||||
t.Fatalf("ThisDC = %d, want %d", cfg.ThisDC, dc)
|
||||
}
|
||||
if len(cfg.DCOptions) != 0 {
|
||||
t.Fatalf("DCOptions = %+v, want empty (client uses pinned static address)", cfg.DCOptions)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchRejectsAuthorizedRPCBeforeLogin(t *testing.T) {
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{
|
||||
Auth: &captureAuthService{},
|
||||
}, zaptest.NewLogger(t), clock.System)
|
||||
authKeyID := [8]byte{0x68, 0xa7, 0x30, 0x65, 0xc1, 0x11, 0x6e, 0x35}
|
||||
|
||||
var dialogs bin.Buffer
|
||||
if err := (&tg.MessagesGetDialogsRequest{
|
||||
OffsetPeer: &tg.InputPeerEmpty{},
|
||||
Limit: 20,
|
||||
}).Encode(&dialogs); err != nil {
|
||||
t.Fatalf("encode messages.getDialogs: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), authKeyID, 1, &dialogs); !tgerr.Is(err, "AUTH_KEY_UNREGISTERED") {
|
||||
t.Fatalf("messages.getDialogs err = %v, want AUTH_KEY_UNREGISTERED", err)
|
||||
}
|
||||
|
||||
var help bin.Buffer
|
||||
if err := (&tg.HelpGetConfigRequest{}).Encode(&help); err != nil {
|
||||
t.Fatalf("encode help.getConfig: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), authKeyID, 1, &help); err != nil {
|
||||
t.Fatalf("help.getConfig should be allowed before login: %v", err)
|
||||
}
|
||||
|
||||
var sendCode bin.Buffer
|
||||
if err := (&tg.AuthSendCodeRequest{
|
||||
PhoneNumber: "+15550001111",
|
||||
APIID: 2040,
|
||||
APIHash: "test",
|
||||
Settings: tg.CodeSettings{},
|
||||
}).Encode(&sendCode); err != nil {
|
||||
t.Fatalf("encode auth.sendCode: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), authKeyID, 1, &sendCode); err != nil {
|
||||
t.Fatalf("auth.sendCode should be allowed before login: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchRemembersLayerAndClientTypeForSession(t *testing.T) {
|
||||
const layer = 225
|
||||
core, logs := observer.New(zap.DebugLevel)
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{}, zap.New(core), clock.System)
|
||||
rawAuthKeyID := [8]byte{0x22, 0x5}
|
||||
sessionID := int64(88)
|
||||
|
||||
initReq := &tg.InvokeWithLayerRequest{
|
||||
Layer: layer,
|
||||
Query: &tg.InitConnectionRequest{
|
||||
APIID: 123,
|
||||
DeviceModel: "Desktop",
|
||||
SystemVersion: "Windows",
|
||||
AppVersion: "6.8.4 x64",
|
||||
SystemLangCode: "en",
|
||||
LangPack: "tdesktop",
|
||||
LangCode: "en",
|
||||
Query: &tg.HelpGetConfigRequest{},
|
||||
},
|
||||
}
|
||||
var initBuf bin.Buffer
|
||||
if err := initReq.Encode(&initBuf); err != nil {
|
||||
t.Fatalf("encode init request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), rawAuthKeyID, sessionID, &initBuf); err != nil {
|
||||
t.Fatalf("dispatch init request: %v", err)
|
||||
}
|
||||
|
||||
sessionCtx := WithSessionID(WithRawAuthKeyID(WithAuthKeyID(context.Background(), rawAuthKeyID), rawAuthKeyID), sessionID)
|
||||
info, ok := r.clientSessionInfo(sessionCtx)
|
||||
if !ok {
|
||||
t.Fatalf("session metadata missing")
|
||||
}
|
||||
if info.layer != layer {
|
||||
t.Fatalf("remembered layer = %d, want %d", info.layer, layer)
|
||||
}
|
||||
if !info.hasClientInfo || info.clientInfo.ClientType() != ClientTypeTDesktop {
|
||||
t.Fatalf("remembered client info = %+v, want tdesktop", info.clientInfo)
|
||||
}
|
||||
|
||||
var plainBuf bin.Buffer
|
||||
if err := (&tg.HelpGetConfigRequest{}).Encode(&plainBuf); err != nil {
|
||||
t.Fatalf("encode plain request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), rawAuthKeyID, sessionID, &plainBuf); err != nil {
|
||||
t.Fatalf("dispatch plain request: %v", err)
|
||||
}
|
||||
|
||||
entries := logs.FilterMessage("RPC inner handled").All()
|
||||
if len(entries) == 0 {
|
||||
t.Fatalf("RPC inner handled log missing")
|
||||
}
|
||||
fields := entries[len(entries)-1].ContextMap()
|
||||
if got := intLogField(fields["layer"]); got != layer {
|
||||
t.Fatalf("logged layer = %d fields=%v, want %d", got, fields, layer)
|
||||
}
|
||||
if got := fields["client_type"]; got != string(ClientTypeTDesktop) {
|
||||
t.Fatalf("logged client_type = %v, want %s", got, ClientTypeTDesktop)
|
||||
}
|
||||
if got := fields["app_version"]; got != "6.8.4 x64" {
|
||||
t.Fatalf("logged app_version = %v, want 6.8.4 x64", got)
|
||||
}
|
||||
|
||||
newSessionID := int64(99)
|
||||
var newSessionBuf bin.Buffer
|
||||
if err := (&tg.HelpGetConfigRequest{}).Encode(&newSessionBuf); err != nil {
|
||||
t.Fatalf("encode new session request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), rawAuthKeyID, newSessionID, &newSessionBuf); err != nil {
|
||||
t.Fatalf("dispatch new session request: %v", err)
|
||||
}
|
||||
entries = logs.FilterMessage("RPC inner handled").All()
|
||||
fields = entries[len(entries)-1].ContextMap()
|
||||
if got := intLogField(fields["layer"]); got != layer {
|
||||
t.Fatalf("new session logged layer = %d fields=%v, want %d", got, fields, layer)
|
||||
}
|
||||
if got := fields["client_type"]; got != string(ClientTypeTDesktop) {
|
||||
t.Fatalf("new session logged client_type = %v, want %s", got, ClientTypeTDesktop)
|
||||
}
|
||||
if got := fields["app_version"]; got != "6.8.4 x64" {
|
||||
t.Fatalf("new session logged app_version = %v, want 6.8.4 x64", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndroidLegacyCompatLogsClientMetadataWithoutInit(t *testing.T) {
|
||||
core, logs := observer.New(zap.DebugLevel)
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{}, zap.New(core), clock.System)
|
||||
|
||||
var flags bin.Fields
|
||||
flags.Set(0)
|
||||
var in bin.Buffer
|
||||
in.PutID(0x25939651)
|
||||
if err := flags.Encode(&in); err != nil {
|
||||
t.Fatalf("encode flags: %v", err)
|
||||
}
|
||||
in.PutInt(10)
|
||||
in.PutInt(100)
|
||||
in.PutInt(123456)
|
||||
in.PutInt(0)
|
||||
|
||||
rawAuthKeyID := [8]byte{0x68, 0x25}
|
||||
sessionID := int64(-3479521421865518854)
|
||||
if _, err := r.Dispatch(WithUserID(context.Background(), 1780269504), rawAuthKeyID, sessionID, &in); err != nil {
|
||||
t.Fatalf("dispatch legacy updates.getDifference: %v", err)
|
||||
}
|
||||
|
||||
// The legacy android constructor is upgraded by layerwire and dispatched
|
||||
// normally; client metadata is still applied (withAndroidCompatMetadata for
|
||||
// client drift), now surfaced on the standard "RPC inner handled" log.
|
||||
entries := logs.FilterMessage("RPC inner handled").All()
|
||||
if len(entries) == 0 {
|
||||
t.Fatalf("RPC inner handled log missing")
|
||||
}
|
||||
fields := entries[len(entries)-1].ContextMap()
|
||||
if got := intLogField(fields["layer"]); got != currentClientLayer {
|
||||
t.Fatalf("logged layer = %d fields=%v, want %d", got, fields, currentClientLayer)
|
||||
}
|
||||
if got := fields["client_type"]; got != string(ClientTypeAndroid) {
|
||||
t.Fatalf("logged client_type = %v, want %s", got, ClientTypeAndroid)
|
||||
}
|
||||
}
|
||||
|
||||
// TestNegotiatedLayerStickyContract pins the (layer, ok) contract that keeps the
|
||||
// edge from clobbering a live connection's layer: unknown ⇒ ok=false (edge keeps
|
||||
// last-known), a recorded layer ⇒ ok=true, and a reconnect with a NEW session_id
|
||||
// still inherits the layer via the stable auth_key fallback.
|
||||
func TestNegotiatedLayerStickyContract(t *testing.T) {
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{}, zaptest.NewLogger(t), clock.System)
|
||||
authKey := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
|
||||
const session = int64(42)
|
||||
|
||||
if l, ok := r.NegotiatedLayer(authKey, session); ok || l != currentClientLayer {
|
||||
t.Fatalf("unknown = (%d,%v), want (%d,false)", l, ok, currentClientLayer)
|
||||
}
|
||||
|
||||
ctx := WithSessionID(WithRawAuthKeyID(context.Background(), authKey), session)
|
||||
r.rememberClientLayer(ctx, 220)
|
||||
|
||||
if l, ok := r.NegotiatedLayer(authKey, session); !ok || l != 220 {
|
||||
t.Fatalf("recorded = (%d,%v), want (220,true)", l, ok)
|
||||
}
|
||||
// Reconnect: new session_id, same auth_key → inherits 220 (no re-invokeWithLayer).
|
||||
if l, ok := r.NegotiatedLayer(authKey, 999); !ok || l != 220 {
|
||||
t.Fatalf("reconnect new session = (%d,%v), want (220,true)", l, ok)
|
||||
}
|
||||
// Unrelated auth_key stays unknown.
|
||||
if _, ok := r.NegotiatedLayer([8]byte{9, 9}, session); ok {
|
||||
t.Fatalf("unrelated auth_key reported known")
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientTypeDetectsAndroidSDKVersion(t *testing.T) {
|
||||
info := normalizeClientInfo(ClientInfo{
|
||||
DeviceModel: "GooglePixel 9a",
|
||||
SystemVersion: "SDK 36",
|
||||
AppVersion: "12.7.3 (67509) pbeta",
|
||||
})
|
||||
if got := info.ClientType(); got != ClientTypeAndroid {
|
||||
t.Fatalf("client type = %s, want %s", got, ClientTypeAndroid)
|
||||
}
|
||||
|
||||
info = normalizeClientInfo(ClientInfo{
|
||||
DeviceModel: "go1.26.2",
|
||||
SystemVersion: "windows",
|
||||
AppVersion: "v0.144.0",
|
||||
})
|
||||
if got := info.ClientType(); got != ClientTypeUnknown {
|
||||
t.Fatalf("gotd test client type = %s, want %s", got, ClientTypeUnknown)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchRestoresClientMetadataFromAuthorization(t *testing.T) {
|
||||
core, logs := observer.New(zap.DebugLevel)
|
||||
authKeyID := [8]byte{0x68, 0x25, 0xc2, 0xee, 0xf8, 0x82, 0xef, 0x71}
|
||||
userID := int64(1780269504)
|
||||
auth := &captureAuthService{
|
||||
userID: userID,
|
||||
authorizations: []domain.Authorization{{
|
||||
AuthKeyID: authKeyID,
|
||||
UserID: userID,
|
||||
Layer: currentClientLayer,
|
||||
DeviceModel: "Android",
|
||||
Platform: string(ClientTypeAndroid),
|
||||
SystemVersion: "Android 15",
|
||||
APIID: 6,
|
||||
AppVersion: "12.7.3",
|
||||
}},
|
||||
}
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{
|
||||
Auth: auth,
|
||||
}, zap.New(core), clock.System)
|
||||
|
||||
var in bin.Buffer
|
||||
if err := (&tg.HelpGetConfigRequest{}).Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), authKeyID, -3479521421865518854, &in); err != nil {
|
||||
t.Fatalf("dispatch plain request: %v", err)
|
||||
}
|
||||
|
||||
entries := logs.FilterMessage("RPC inner handled").All()
|
||||
if len(entries) == 0 {
|
||||
t.Fatalf("RPC inner handled log missing")
|
||||
}
|
||||
fields := entries[len(entries)-1].ContextMap()
|
||||
if got := intLogField(fields["layer"]); got != currentClientLayer {
|
||||
t.Fatalf("logged layer = %d fields=%v, want %d", got, fields, currentClientLayer)
|
||||
}
|
||||
if got := fields["client_type"]; got != string(ClientTypeAndroid) {
|
||||
t.Fatalf("logged client_type = %v, want %s", got, ClientTypeAndroid)
|
||||
}
|
||||
if got := fields["app_version"]; got != "12.7.3" {
|
||||
t.Fatalf("logged app_version = %v, want 12.7.3", got)
|
||||
}
|
||||
|
||||
var second bin.Buffer
|
||||
if err := (&tg.HelpGetConfigRequest{}).Encode(&second); err != nil {
|
||||
t.Fatalf("encode second request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), authKeyID, -3479521421865518853, &second); err != nil {
|
||||
t.Fatalf("dispatch second plain request: %v", err)
|
||||
}
|
||||
if auth.authorizationLookups != 1 || auth.authorizationLists != 0 {
|
||||
t.Fatalf("authorization lookups/list calls = %d/%d, want exact-key 1/list 0", auth.authorizationLookups, auth.authorizationLists)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchRestoresAndroidMetadataFromAuthorizationSDKVersion(t *testing.T) {
|
||||
core, logs := observer.New(zap.DebugLevel)
|
||||
authKeyID := [8]byte{0x16, 0x65, 0x54, 0x12, 0xaa, 0xbb, 0xcc, 0xdd}
|
||||
userID := int64(1780269504)
|
||||
auth := &captureAuthService{
|
||||
userID: userID,
|
||||
authorizations: []domain.Authorization{{
|
||||
AuthKeyID: authKeyID,
|
||||
UserID: userID,
|
||||
DeviceModel: "GooglePixel 9a",
|
||||
SystemVersion: "SDK 36",
|
||||
APIID: 4,
|
||||
AppVersion: "12.7.3 (67509) pbeta",
|
||||
}},
|
||||
}
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{
|
||||
Auth: auth,
|
||||
}, zap.New(core), clock.System)
|
||||
|
||||
var in bin.Buffer
|
||||
if err := (&tg.HelpGetConfigRequest{}).Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), authKeyID, -3479521421865518854, &in); err != nil {
|
||||
t.Fatalf("dispatch plain request: %v", err)
|
||||
}
|
||||
|
||||
entries := logs.FilterMessage("RPC inner handled").All()
|
||||
if len(entries) == 0 {
|
||||
t.Fatalf("RPC inner handled log missing")
|
||||
}
|
||||
fields := entries[len(entries)-1].ContextMap()
|
||||
if got := intLogField(fields["layer"]); got != currentClientLayer {
|
||||
t.Fatalf("logged layer = %d fields=%v, want %d", got, fields, currentClientLayer)
|
||||
}
|
||||
if got := fields["client_type"]; got != string(ClientTypeAndroid) {
|
||||
t.Fatalf("logged client_type = %v, want %s", got, ClientTypeAndroid)
|
||||
}
|
||||
if got := fields["app_version"]; got != "12.7.3 (67509) pbeta" {
|
||||
t.Fatalf("logged app_version = %v, want 12.7.3 (67509) pbeta", got)
|
||||
}
|
||||
if auth.authorizationLookups != 1 || auth.authorizationLists != 0 {
|
||||
t.Fatalf("authorization lookups/list calls = %d/%d, want exact-key 1/list 0", auth.authorizationLookups, auth.authorizationLists)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchCachesMissingClientMetadataAuthorizationLookup(t *testing.T) {
|
||||
core, logs := observer.New(zap.DebugLevel)
|
||||
authKeyID := [8]byte{0x68, 0x25, 0xc2, 0xee, 0xf8, 0x82, 0xef, 0x71}
|
||||
auth := &captureAuthService{userID: 1780269504}
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{
|
||||
Auth: auth,
|
||||
}, zap.New(core), clock.System)
|
||||
|
||||
for _, sessionID := range []int64{-3479521421865518854, -3479521421865518853} {
|
||||
var in bin.Buffer
|
||||
if err := (&tg.HelpGetConfigRequest{}).Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), authKeyID, sessionID, &in); err != nil {
|
||||
t.Fatalf("dispatch plain request: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
if auth.authorizationLookups != 1 || auth.authorizationLists != 0 {
|
||||
t.Fatalf("authorization lookups/list calls = %d/%d, want one cached exact-key empty lookup/list 0", auth.authorizationLookups, auth.authorizationLists)
|
||||
}
|
||||
entries := logs.FilterMessage("RPC inner handled").All()
|
||||
if len(entries) == 0 {
|
||||
t.Fatalf("RPC inner handled log missing")
|
||||
}
|
||||
fields := entries[len(entries)-1].ContextMap()
|
||||
if got := intLogField(fields["layer"]); got != 0 {
|
||||
t.Fatalf("logged layer = %d fields=%v, want unknown 0", got, fields)
|
||||
}
|
||||
if got := fields["client_type"]; got != string(ClientTypeUnknown) {
|
||||
t.Fatalf("logged client_type = %v, want %s", got, ClientTypeUnknown)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCurrentUserIDUsesAuthUserCache(t *testing.T) {
|
||||
authKeyID := [8]byte{0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42}
|
||||
auth := &captureAuthService{userID: 1000000001}
|
||||
r := New(Config{}, Deps{Auth: auth}, zaptest.NewLogger(t), clock.System)
|
||||
ctx := WithAuthKeyID(context.Background(), authKeyID)
|
||||
|
||||
for i := 0; i < 2; i++ {
|
||||
userID, ok, err := r.currentUserID(ctx)
|
||||
if err != nil || !ok || userID != auth.userID {
|
||||
t.Fatalf("currentUserID %d = user %d ok %v err %v, want %d/true", i, userID, ok, err, auth.userID)
|
||||
}
|
||||
}
|
||||
if auth.userIDCount != 1 {
|
||||
t.Fatalf("auth user lookups = %d, want 1", auth.userIDCount)
|
||||
}
|
||||
}
|
||||
|
||||
func intLogField(v any) int {
|
||||
switch n := v.(type) {
|
||||
case int:
|
||||
return n
|
||||
case int64:
|
||||
return int(n)
|
||||
case int32:
|
||||
return int(n)
|
||||
case float64:
|
||||
return int(n)
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchUnwrapsInvokeAfterWrappers(t *testing.T) {
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{}, zaptest.NewLogger(t), clock.System)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
req bin.Encoder
|
||||
}{
|
||||
{
|
||||
name: "invokeAfterMsg",
|
||||
req: &tg.InvokeAfterMsgRequest{
|
||||
MsgID: 123,
|
||||
Query: &tg.HelpGetConfigRequest{},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "invokeAfterMsgs",
|
||||
req: &tg.InvokeAfterMsgsRequest{
|
||||
MsgIDs: []int64{123, 456},
|
||||
Query: &tg.HelpGetConfigRequest{},
|
||||
},
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
var b bin.Buffer
|
||||
if err := tt.req.Encode(&b); err != nil {
|
||||
t.Fatalf("encode: %v", err)
|
||||
}
|
||||
enc, err := r.Dispatch(context.Background(), [8]byte{}, 0, &b)
|
||||
if err != nil {
|
||||
t.Fatalf("dispatch: %v", err)
|
||||
}
|
||||
if _, ok := enc.(*tg.Config); !ok {
|
||||
t.Fatalf("result type = %T, want *tg.Config", enc)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestDispatchUnknownReturnsError 验证未注册 RPC 经 fallback 返回 rpc_error。
|
||||
func TestDispatchUnknownReturnsError(t *testing.T) {
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{}, zaptest.NewLogger(t), clock.System)
|
||||
|
||||
// help.getCdnConfig 第一阶段未注册，应走 fallback。
|
||||
var b bin.Buffer
|
||||
if err := (&tg.HelpGetCDNConfigRequest{}).Encode(&b); err != nil {
|
||||
t.Fatalf("encode: %v", err)
|
||||
}
|
||||
|
||||
_, err := r.Dispatch(context.Background(), [8]byte{}, 0, &b)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for unregistered RPC")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchResolvesBoundTempAuthKey(t *testing.T) {
|
||||
var tempAuthKeyID = [8]byte{0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55}
|
||||
var permAuthKeyID = [8]byte{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}
|
||||
tempBindings := memory.NewTempAuthKeyBindingStore()
|
||||
if err := tempBindings.Save(context.Background(), domain.TempAuthKeyBinding{
|
||||
TempAuthKeyID: tempAuthKeyID,
|
||||
PermAuthKeyID: int64(binary.LittleEndian.Uint64(permAuthKeyID[:])),
|
||||
ExpiresAt: int(time.Now().Add(time.Hour).Unix()),
|
||||
}); err != nil {
|
||||
t.Fatalf("save temp binding: %v", err)
|
||||
}
|
||||
sessions := &captureSessions{}
|
||||
r := New(Config{}, Deps{
|
||||
Auth: appauth.NewService(nil, nil, nil, nil, tempBindings, "12345"),
|
||||
Sessions: sessions,
|
||||
}, zaptest.NewLogger(t), clock.System)
|
||||
req := &tg.HelpGetConfigRequest{}
|
||||
var in bin.Buffer
|
||||
if err := req.Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
|
||||
if _, err := r.Dispatch(context.Background(), tempAuthKeyID, 123, &in); err != nil {
|
||||
t.Fatalf("dispatch: %v", err)
|
||||
}
|
||||
gotSession := sessions.snapshot()
|
||||
if gotSession.authKeyID != permAuthKeyID || !gotSession.authKeyResolved {
|
||||
t.Fatalf("session auth key = %x resolved %v, want resolved perm %x", gotSession.authKeyID, gotSession.authKeyResolved, permAuthKeyID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchCachesUnauthenticatedIdentity(t *testing.T) {
|
||||
var rawAuthKeyID = [8]byte{0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77}
|
||||
auth := &captureAuthService{}
|
||||
sessions := &captureSessions{}
|
||||
r := New(Config{}, Deps{
|
||||
Auth: auth,
|
||||
Sessions: sessions,
|
||||
}, zaptest.NewLogger(t), clock.System)
|
||||
req := &tg.HelpGetConfigRequest{}
|
||||
|
||||
for i := 0; i < 2; i++ {
|
||||
var in bin.Buffer
|
||||
if err := req.Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), rawAuthKeyID, 777, &in); err != nil {
|
||||
t.Fatalf("dispatch %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
if auth.resolveCount != 1 || auth.userIDCount != 1 {
|
||||
t.Fatalf("identity lookups = resolve %d user %d, want one-time negative cache", auth.resolveCount, auth.userIDCount)
|
||||
}
|
||||
gotSession := sessions.snapshot()
|
||||
if !gotSession.userResolved || gotSession.userID != 0 {
|
||||
t.Fatalf("cached unauth identity = user %d resolved %v, want 0/true", gotSession.userID, gotSession.userResolved)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchCachesTempConnectionIdentity(t *testing.T) {
|
||||
var rawAuthKeyID = [8]byte{0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55}
|
||||
var permAuthKeyID = [8]byte{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}
|
||||
auth := &captureAuthService{
|
||||
resolvedAuthKeyID: permAuthKeyID,
|
||||
hasResolved: true,
|
||||
userID: 1000000001,
|
||||
}
|
||||
sessions := &captureSessions{}
|
||||
r := New(Config{}, Deps{
|
||||
Auth: auth,
|
||||
Sessions: sessions,
|
||||
Users: staticUsersService{user: domain.User{
|
||||
ID: 1000000001,
|
||||
FirstName: "Test",
|
||||
}},
|
||||
}, zaptest.NewLogger(t), clock.System)
|
||||
req := &tg.UsersGetFullUserRequest{ID: &tg.InputUserSelf{}}
|
||||
|
||||
for i := 0; i < 2; i++ {
|
||||
var in bin.Buffer
|
||||
if err := req.Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), rawAuthKeyID, 777, &in); err != nil {
|
||||
t.Fatalf("dispatch %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
if auth.resolveCount != 2 || auth.userIDCount != 1 {
|
||||
t.Fatalf("identity lookups = resolve %d user %d, want temp resolve checks and cached user identity", auth.resolveCount, auth.userIDCount)
|
||||
}
|
||||
gotSession := sessions.snapshot()
|
||||
if gotSession.authKeyID != permAuthKeyID || gotSession.userID != 1000000001 {
|
||||
t.Fatalf("cached identity = auth %x user %d, want perm/user", gotSession.authKeyID, gotSession.userID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchSingleflightsAuthUserLookupAcrossStartupRPCs(t *testing.T) {
|
||||
var authKeyID = [8]byte{0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42}
|
||||
auth := newBlockingUserAuthService(1000000001)
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{
|
||||
Auth: auth,
|
||||
}, zaptest.NewLogger(t), clock.System)
|
||||
|
||||
const calls = 16
|
||||
errs := make(chan error, calls)
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < calls; i++ {
|
||||
wg.Add(1)
|
||||
go func(i int) {
|
||||
defer wg.Done()
|
||||
var in bin.Buffer
|
||||
if err := (&tg.HelpGetConfigRequest{}).Encode(&in); err != nil {
|
||||
errs <- err
|
||||
return
|
||||
}
|
||||
_, err := r.Dispatch(context.Background(), authKeyID, int64(100+i), &in)
|
||||
errs <- err
|
||||
}(i)
|
||||
}
|
||||
|
||||
select {
|
||||
case <-auth.started:
|
||||
case <-time.After(time.Second):
|
||||
t.Fatal("auth lookup did not start")
|
||||
}
|
||||
close(auth.release)
|
||||
wg.Wait()
|
||||
close(errs)
|
||||
for err := range errs {
|
||||
if err != nil {
|
||||
t.Fatalf("dispatch: %v", err)
|
||||
}
|
||||
}
|
||||
if got := auth.UserIDCount(); got != 1 {
|
||||
t.Fatalf("UserID lookups = %d, want singleflighted one lookup", got)
|
||||
}
|
||||
|
||||
for i := 0; i < 3; i++ {
|
||||
var in bin.Buffer
|
||||
if err := (&tg.HelpGetConfigRequest{}).Encode(&in); err != nil {
|
||||
t.Fatalf("encode: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(context.Background(), authKeyID, int64(200+i), &in); err != nil {
|
||||
t.Fatalf("cached dispatch %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
if got := auth.UserIDCount(); got != 1 {
|
||||
t.Fatalf("UserID lookups after cache hits = %d, want still one lookup", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchAnnouncesPresenceWhenSessionIdentityRestored(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
alice := domain.User{ID: 1000000001, AccessHash: 11, FirstName: "Alice"}
|
||||
bob := domain.User{ID: 1000000002, AccessHash: 22, FirstName: "Bob"}
|
||||
dialogs := memory.NewDialogStore()
|
||||
// 私聊 dialog 双向建行：两侧都存。presence 接收者由「主体自己的 dialog 对端 ∩ 在线」
|
||||
// 算出，bob 改状态时需 bob 侧 dialog 含 alice。
|
||||
if err := dialogs.SaveList(ctx, alice.ID, domain.DialogList{
|
||||
Dialogs: []domain.Dialog{{
|
||||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: bob.ID},
|
||||
TopMessage: 10,
|
||||
TopMessageDate: 1700000000,
|
||||
}},
|
||||
Users: []domain.User{bob},
|
||||
}); err != nil {
|
||||
t.Fatalf("save dialogs: %v", err)
|
||||
}
|
||||
if err := dialogs.SaveList(ctx, bob.ID, domain.DialogList{
|
||||
Dialogs: []domain.Dialog{{
|
||||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: alice.ID},
|
||||
TopMessage: 10,
|
||||
TopMessageDate: 1700000000,
|
||||
}},
|
||||
Users: []domain.User{alice},
|
||||
}); err != nil {
|
||||
t.Fatalf("save bob dialogs: %v", err)
|
||||
}
|
||||
auth := &captureAuthService{userID: bob.ID}
|
||||
sessions := &captureSessions{onlineUserIDs: []int64{alice.ID}}
|
||||
r := New(Config{}, Deps{
|
||||
Auth: auth,
|
||||
Dialogs: appdialogs.NewService(dialogs),
|
||||
Sessions: sessions,
|
||||
}, zaptest.NewLogger(t), clock.System)
|
||||
req := &tg.HelpGetConfigRequest{}
|
||||
|
||||
for i := 0; i < 2; i++ {
|
||||
var in bin.Buffer
|
||||
if err := req.Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(ctx, [8]byte{0x22}, 333, &in); err != nil {
|
||||
t.Fatalf("dispatch %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
if auth.userIDCount != 1 {
|
||||
t.Fatalf("user lookup count = %d, want one restored identity lookup", auth.userIDCount)
|
||||
}
|
||||
gotPushes := waitForPushedUserIDs(t, sessions, 2)
|
||||
if !reflect.DeepEqual(gotPushes, []int64{bob.ID, alice.ID}) {
|
||||
t.Fatalf("pushed users = %+v, want self and online private dialog peer once", gotPushes)
|
||||
}
|
||||
// 用 lastUserPush（PushToUser* 的内容）而非 snapshot().message：后者还会被
|
||||
// pushOnlinePeerStatusesToCurrentSession 把 alice 的在线状态推给 bob 当前 session 覆盖。
|
||||
update := pushedUserStatus(t, waitForLastUserPush(t, sessions))
|
||||
if update.UserID != bob.ID {
|
||||
t.Fatalf("status user = %d, want bob", update.UserID)
|
||||
}
|
||||
if status, ok := update.Status.(*tg.UserStatusOnline); !ok || status.Expires <= int(time.Now().Unix()) {
|
||||
t.Fatalf("status = %#v, want online with future expires", update.Status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDispatchPushesOnlinePeerStatusesToRestoredSession(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
alice := domain.User{ID: 1000000001, AccessHash: 11, FirstName: "Alice"}
|
||||
bob := domain.User{ID: 1000000002, AccessHash: 22, FirstName: "Bob"}
|
||||
dialogs := memory.NewDialogStore()
|
||||
if err := dialogs.SaveList(ctx, alice.ID, domain.DialogList{
|
||||
Dialogs: []domain.Dialog{{
|
||||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: bob.ID},
|
||||
TopMessage: 10,
|
||||
TopMessageDate: 1700000000,
|
||||
}},
|
||||
Users: []domain.User{bob},
|
||||
}); err != nil {
|
||||
t.Fatalf("save dialogs: %v", err)
|
||||
}
|
||||
auth := &captureAuthService{userID: alice.ID}
|
||||
sessions := &captureSessions{onlineUserIDs: []int64{bob.ID}}
|
||||
r := New(Config{}, Deps{
|
||||
Auth: auth,
|
||||
Dialogs: appdialogs.NewService(dialogs),
|
||||
Sessions: sessions,
|
||||
}, zaptest.NewLogger(t), clock.System)
|
||||
if ok, err := r.onAccountUpdateStatus(WithSessionID(WithUserID(ctx, bob.ID), 22), false); err != nil || !ok {
|
||||
t.Fatalf("bob account.updateStatus online = %v, %v", ok, err)
|
||||
}
|
||||
sessions.clearMessages()
|
||||
req := &tg.HelpGetConfigRequest{}
|
||||
|
||||
for i := 0; i < 2; i++ {
|
||||
var in bin.Buffer
|
||||
if err := req.Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
if _, err := r.Dispatch(ctx, [8]byte{0x33}, 444, &in); err != nil {
|
||||
t.Fatalf("dispatch %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
if auth.userIDCount != 1 {
|
||||
t.Fatalf("user lookup count = %d, want one restored identity lookup", auth.userIDCount)
|
||||
}
|
||||
update := waitForSessionUserStatus(t, sessions, bob.ID)
|
||||
if update.UserID != bob.ID {
|
||||
t.Fatalf("status user = %d, want bob", update.UserID)
|
||||
}
|
||||
if status, ok := update.Status.(*tg.UserStatusOnline); !ok || status.Expires <= int(time.Now().Unix()) {
|
||||
t.Fatalf("status = %#v, want online peer status for restored session", update.Status)
|
||||
}
|
||||
}
|
||||
|
||||
// TestTDesktopStartupRPCsEncode 验证第一阶段 TDesktop 启动 RPC 均能被路由并编码回包。
|
||||
func TestTDesktopStartupRPCsEncode(t *testing.T) {
|
||||
r := New(Config{DC: 2, IP: "127.0.0.1", Port: 2398}, Deps{
|
||||
Users: staticUsersService{user: domain.User{
|
||||
ID: 1000000001,
|
||||
AccessHash: 42,
|
||||
FirstName: "Test",
|
||||
LastName: "User",
|
||||
Phone: "15550000000",
|
||||
}},
|
||||
}, zaptest.NewLogger(t), clock.System)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
req bin.Encoder
|
||||
}{
|
||||
{name: "auth.bindTempAuthKey", req: &tg.AuthBindTempAuthKeyRequest{PermAuthKeyID: 1, Nonce: 2, ExpiresAt: 3, EncryptedMessage: []byte("binding")}},
|
||||
{name: "auth.exportLoginToken", req: &tg.AuthExportLoginTokenRequest{APIID: 1, APIHash: "hash"}},
|
||||
{name: "help.getAppConfig", req: &tg.HelpGetAppConfigRequest{}},
|
||||
{name: "help.getCountriesList", req: &tg.HelpGetCountriesListRequest{LangCode: "en"}},
|
||||
{name: "help.getTimezonesList", req: &tg.HelpGetTimezonesListRequest{}},
|
||||
{name: "help.getPeerColors", req: &tg.HelpGetPeerColorsRequest{}},
|
||||
{name: "help.getPeerProfileColors", req: &tg.HelpGetPeerProfileColorsRequest{}},
|
||||
{name: "help.getPromoData", req: &tg.HelpGetPromoDataRequest{}},
|
||||
{name: "help.getTermsOfServiceUpdate", req: &tg.HelpGetTermsOfServiceUpdateRequest{}},
|
||||
{name: "help.getPremiumPromo", req: &tg.HelpGetPremiumPromoRequest{}},
|
||||
{name: "help.getInviteText", req: &tg.HelpGetInviteTextRequest{}},
|
||||
{name: "auth.initPasskeyLogin", req: &tg.AuthInitPasskeyLoginRequest{APIID: 4, APIHash: "test"}},
|
||||
{name: "account.getPassword", req: &tg.AccountGetPasswordRequest{}},
|
||||
{name: "account.getNotifySettings", req: &tg.AccountGetNotifySettingsRequest{Peer: &tg.InputNotifyUsers{}}},
|
||||
{name: "account.resetNotifySettings", req: &tg.AccountResetNotifySettingsRequest{}},
|
||||
{name: "account.getPrivacy", req: &tg.AccountGetPrivacyRequest{Key: &tg.InputPrivacyKeyStatusTimestamp{}}},
|
||||
{name: "account.getAuthorizations", req: &tg.AccountGetAuthorizationsRequest{}},
|
||||
{name: "account.getWebAuthorizations", req: &tg.AccountGetWebAuthorizationsRequest{}},
|
||||
{name: "account.getNotifyExceptions", req: &tg.AccountGetNotifyExceptionsRequest{}},
|
||||
{name: "account.getDefaultEmojiStatuses", req: &tg.AccountGetDefaultEmojiStatusesRequest{}},
|
||||
{name: "account.getRecentEmojiStatuses", req: &tg.AccountGetRecentEmojiStatusesRequest{}},
|
||||
{name: "account.getCollectibleEmojiStatuses", req: &tg.AccountGetCollectibleEmojiStatusesRequest{}},
|
||||
{name: "account.getDefaultProfilePhotoEmojis", req: &tg.AccountGetDefaultProfilePhotoEmojisRequest{}},
|
||||
{name: "account.getDefaultGroupPhotoEmojis", req: &tg.AccountGetDefaultGroupPhotoEmojisRequest{}},
|
||||
{name: "account.getDefaultBackgroundEmojis", req: &tg.AccountGetDefaultBackgroundEmojisRequest{}},
|
||||
{name: "account.getChannelDefaultEmojiStatuses", req: &tg.AccountGetChannelDefaultEmojiStatusesRequest{}},
|
||||
{name: "account.getChannelRestrictedStatusEmojis", req: &tg.AccountGetChannelRestrictedStatusEmojisRequest{}},
|
||||
{name: "account.getConnectedBots", req: &tg.AccountGetConnectedBotsRequest{}},
|
||||
{name: "account.getBusinessChatLinks", req: &tg.AccountGetBusinessChatLinksRequest{}},
|
||||
{name: "account.getReactionsNotifySettings", req: &tg.AccountGetReactionsNotifySettingsRequest{}},
|
||||
{name: "account.getContactSignUpNotification", req: &tg.AccountGetContactSignUpNotificationRequest{}},
|
||||
{name: "account.getThemes", req: &tg.AccountGetThemesRequest{Format: "tdesktop"}},
|
||||
{name: "account.getChatThemes", req: &tg.AccountGetChatThemesRequest{}},
|
||||
{name: "account.getWallPapers", req: &tg.AccountGetWallPapersRequest{}},
|
||||
{name: "account.getUniqueGiftChatThemes", req: &tg.AccountGetUniqueGiftChatThemesRequest{Limit: 20}},
|
||||
{name: "account.getContentSettings", req: &tg.AccountGetContentSettingsRequest{}},
|
||||
{name: "account.getGlobalPrivacySettings", req: &tg.AccountGetGlobalPrivacySettingsRequest{}},
|
||||
{name: "account.getPasskeys", req: &tg.AccountGetPasskeysRequest{}},
|
||||
{name: "account.getAutoDownloadSettings", req: &tg.AccountGetAutoDownloadSettingsRequest{}},
|
||||
{name: "account.getSavedMusicIds", req: &tg.AccountGetSavedMusicIDsRequest{}},
|
||||
{name: "account.getSavedRingtones", req: &tg.AccountGetSavedRingtonesRequest{}},
|
||||
{name: "account.resetPassword", req: &tg.AccountResetPasswordRequest{}},
|
||||
{name: "account.updateStatus", req: &tg.AccountUpdateStatusRequest{Offline: true}},
|
||||
{name: "payments.getStarsTopupOptions", req: &tg.PaymentsGetStarsTopupOptionsRequest{}},
|
||||
{name: "payments.getStarsStatus", req: &tg.PaymentsGetStarsStatusRequest{Peer: &tg.InputPeerSelf{}}},
|
||||
{name: "updates.getDifference", req: &tg.UpdatesGetDifferenceRequest{}},
|
||||
{name: "users.getFullUser", req: &tg.UsersGetFullUserRequest{ID: &tg.InputUserSelf{}}},
|
||||
{name: "users.getRequirementsToContact", req: &tg.UsersGetRequirementsToContactRequest{ID: []tg.InputUserClass{&tg.InputUserSelf{}}}},
|
||||
{name: "users.getSavedMusic", req: &tg.UsersGetSavedMusicRequest{ID: &tg.InputUserSelf{}, Limit: 20}},
|
||||
{name: "users.getSavedMusicByID", req: &tg.UsersGetSavedMusicByIDRequest{ID: &tg.InputUserSelf{}, Documents: []tg.InputDocumentClass{}}},
|
||||
{name: "messages.getDialogFilters", req: &tg.MessagesGetDialogFiltersRequest{}},
|
||||
{name: "messages.getDialogs", req: &tg.MessagesGetDialogsRequest{OffsetPeer: &tg.InputPeerEmpty{}, Limit: 20}},
|
||||
{name: "messages.getPinnedDialogs", req: &tg.MessagesGetPinnedDialogsRequest{}},
|
||||
{name: "messages.getPeerDialogs", req: &tg.MessagesGetPeerDialogsRequest{Peers: []tg.InputDialogPeerClass{&tg.InputDialogPeer{Peer: &tg.InputPeerUser{UserID: domain.OfficialSystemUserID, AccessHash: domain.OfficialSystemUser().AccessHash}}}}},
|
||||
{name: "messages.getAvailableReactions", req: &tg.MessagesGetAvailableReactionsRequest{}},
|
||||
{name: "messages.getAvailableEffects", req: &tg.MessagesGetAvailableEffectsRequest{}},
|
||||
{name: "messages.getStickers", req: &tg.MessagesGetStickersRequest{}},
|
||||
{name: "messages.getArchivedStickers", req: &tg.MessagesGetArchivedStickersRequest{Limit: 20}},
|
||||
{name: "messages.getMaskStickers", req: &tg.MessagesGetMaskStickersRequest{}},
|
||||
{name: "messages.getStickerSet", req: &tg.MessagesGetStickerSetRequest{Stickerset: &tg.InputStickerSetEmpty{}}},
|
||||
{name: "messages.getEmojiGroups", req: &tg.MessagesGetEmojiGroupsRequest{}},
|
||||
{name: "messages.getEmojiStatusGroups", req: &tg.MessagesGetEmojiStatusGroupsRequest{}},
|
||||
{name: "messages.getEmojiStickerGroups", req: &tg.MessagesGetEmojiStickerGroupsRequest{}},
|
||||
{name: "messages.getEmojiProfilePhotoGroups", req: &tg.MessagesGetEmojiProfilePhotoGroupsRequest{}},
|
||||
{name: "messages.getEmojiKeywordsLanguages", req: &tg.MessagesGetEmojiKeywordsLanguagesRequest{LangCodes: []string{"en"}}},
|
||||
{name: "messages.getAttachMenuBots", req: &tg.MessagesGetAttachMenuBotsRequest{}},
|
||||
{name: "messages.getQuickReplies", req: &tg.MessagesGetQuickRepliesRequest{}},
|
||||
{name: "messages.getQuickReplyMessages", req: &tg.MessagesGetQuickReplyMessagesRequest{ShortcutID: 1}},
|
||||
{name: "messages.getSavedHistory", req: &tg.MessagesGetSavedHistoryRequest{Peer: &tg.InputPeerSelf{}, Limit: 20}},
|
||||
{name: "messages.readSavedHistory", req: &tg.MessagesReadSavedHistoryRequest{ParentPeer: &tg.InputPeerChannel{ChannelID: 1, AccessHash: 1}, Peer: &tg.InputPeerSelf{}}},
|
||||
{name: "messages.deleteSavedHistory", req: &tg.MessagesDeleteSavedHistoryRequest{Peer: &tg.InputPeerSelf{}}},
|
||||
{name: "messages.getPeerSettings", req: &tg.MessagesGetPeerSettingsRequest{Peer: &tg.InputPeerUser{UserID: domain.OfficialSystemUserID, AccessHash: domain.OfficialSystemUser().AccessHash}}},
|
||||
{name: "messages.setChatWallPaper", req: &tg.MessagesSetChatWallPaperRequest{Peer: &tg.InputPeerUser{UserID: domain.OfficialSystemUserID, AccessHash: domain.OfficialSystemUser().AccessHash}, Wallpaper: &tg.InputWallPaperNoFile{ID: 930000000000000000}}},
|
||||
{name: "messages.getHistory", req: &tg.MessagesGetHistoryRequest{Peer: &tg.InputPeerUser{UserID: domain.OfficialSystemUserID, AccessHash: domain.OfficialSystemUser().AccessHash}, Limit: 20}},
|
||||
{name: "messages.readHistory", req: &tg.MessagesReadHistoryRequest{Peer: &tg.InputPeerUser{UserID: domain.OfficialSystemUserID, AccessHash: domain.OfficialSystemUser().AccessHash}}},
|
||||
{name: "messages.search", req: &tg.MessagesSearchRequest{Peer: &tg.InputPeerUser{UserID: domain.OfficialSystemUserID, AccessHash: domain.OfficialSystemUser().AccessHash}, Filter: &tg.InputMessagesFilterEmpty{}, Limit: 20}},
|
||||
{name: "messages.searchGlobal", req: &tg.MessagesSearchGlobalRequest{Q: "login", Filter: &tg.InputMessagesFilterEmpty{}, OffsetPeer: &tg.InputPeerEmpty{}, Limit: 20}},
|
||||
{name: "messages.getWebPage", req: &tg.MessagesGetWebPageRequest{URL: "https://example.invalid"}},
|
||||
{name: "messages.getScheduledHistory", req: &tg.MessagesGetScheduledHistoryRequest{Peer: &tg.InputPeerUser{UserID: domain.OfficialSystemUserID, AccessHash: domain.OfficialSystemUser().AccessHash}}},
|
||||
{name: "contacts.getContacts", req: &tg.ContactsGetContactsRequest{}},
|
||||
{name: "contacts.search", req: &tg.ContactsSearchRequest{Q: "Test", Limit: 20}},
|
||||
{name: "contacts.getBlocked", req: &tg.ContactsGetBlockedRequest{Limit: 20}},
|
||||
{name: "contacts.getBirthdays", req: &tg.ContactsGetBirthdaysRequest{}},
|
||||
{name: "contacts.getTopPeers", req: &tg.ContactsGetTopPeersRequest{Correspondents: true, Limit: 10}},
|
||||
{name: "contacts.getSponsoredPeers", req: &tg.ContactsGetSponsoredPeersRequest{Q: "Test"}},
|
||||
{name: "stories.getAllStories", req: &tg.StoriesGetAllStoriesRequest{}},
|
||||
{name: "stories.getStoriesArchive", req: &tg.StoriesGetStoriesArchiveRequest{Peer: &tg.InputPeerSelf{}, Limit: 20}},
|
||||
{name: "stories.getPinnedStories", req: &tg.StoriesGetPinnedStoriesRequest{Peer: &tg.InputPeerSelf{}, Limit: 20}},
|
||||
{name: "stories.exportStoryLink", req: &tg.StoriesExportStoryLinkRequest{Peer: &tg.InputPeerSelf{}, ID: 1}},
|
||||
{name: "stories.report", req: &tg.StoriesReportRequest{Peer: &tg.InputPeerSelf{}, ID: []int{1}}},
|
||||
{name: "stories.activateStealthMode", req: &tg.StoriesActivateStealthModeRequest{Past: true, Future: true}},
|
||||
{name: "stories.searchPosts", req: &tg.StoriesSearchPostsRequest{Hashtag: "storytag", Limit: 20}},
|
||||
{name: "stories.getAlbums", req: &tg.StoriesGetAlbumsRequest{Peer: &tg.InputPeerSelf{}}},
|
||||
{name: "stories.getAlbumStories", req: &tg.StoriesGetAlbumStoriesRequest{Peer: &tg.InputPeerSelf{}, AlbumID: 1, Limit: 20}},
|
||||
{name: "stories.toggleAllStoriesHidden", req: &tg.StoriesToggleAllStoriesHiddenRequest{Hidden: true}},
|
||||
{name: "stories.reorderAlbums", req: &tg.StoriesReorderAlbumsRequest{Peer: &tg.InputPeerSelf{}, Order: []int{1}}},
|
||||
{name: "stories.deleteAlbum", req: &tg.StoriesDeleteAlbumRequest{Peer: &tg.InputPeerSelf{}, AlbumID: 1}},
|
||||
{name: "stories.getAllReadPeerStories", req: &tg.StoriesGetAllReadPeerStoriesRequest{}},
|
||||
{name: "stories.getPeerMaxIDs", req: &tg.StoriesGetPeerMaxIDsRequest{ID: []tg.InputPeerClass{&tg.InputPeerSelf{}}}},
|
||||
{name: "stories.getStoriesViews", req: &tg.StoriesGetStoriesViewsRequest{Peer: &tg.InputPeerSelf{}, ID: []int{1}}},
|
||||
{name: "stories.getChatsToSend", req: &tg.StoriesGetChatsToSendRequest{}},
|
||||
{name: "payments.getStarGiftActiveAuctions", req: &tg.PaymentsGetStarGiftActiveAuctionsRequest{}},
|
||||
{name: "payments.getStarGifts", req: &tg.PaymentsGetStarGiftsRequest{}},
|
||||
{name: "payments.getStarGiftCollections", req: &tg.PaymentsGetStarGiftCollectionsRequest{Peer: &tg.InputPeerSelf{}}},
|
||||
{name: "payments.getSavedStarGifts", req: &tg.PaymentsGetSavedStarGiftsRequest{Peer: &tg.InputPeerSelf{}, Limit: 20}},
|
||||
{name: "payments.getSavedStarGift", req: &tg.PaymentsGetSavedStarGiftRequest{Stargift: []tg.InputSavedStarGiftClass{}}},
|
||||
{name: "payments.getStarsRevenueAdsAccountUrl", req: &tg.PaymentsGetStarsRevenueAdsAccountURLRequest{Peer: &tg.InputPeerSelf{}}},
|
||||
{name: "payments.getStarsRevenueStats", req: &tg.PaymentsGetStarsRevenueStatsRequest{Ton: true, Peer: &tg.InputPeerSelf{}}},
|
||||
{name: "bots.getBotRecommendations", req: &tg.BotsGetBotRecommendationsRequest{Bot: &tg.InputUser{UserID: domain.OfficialSystemUserID, AccessHash: domain.OfficialSystemUser().AccessHash}}},
|
||||
{name: "aicompose.getTones", req: &tg.AicomposeGetTonesRequest{}},
|
||||
{name: "langpack.getLanguage", req: &tg.LangpackGetLanguageRequest{LangPack: "tdesktop", LangCode: "en"}},
|
||||
{name: "langpack.getLangPack", req: &tg.LangpackGetLangPackRequest{LangPack: "tdesktop", LangCode: "en"}},
|
||||
{name: "langpack.getDifference", req: &tg.LangpackGetDifferenceRequest{LangPack: "tdesktop", LangCode: "en", FromVersion: 1}},
|
||||
{name: "langpack.getStrings", req: &tg.LangpackGetStringsRequest{LangPack: "tdesktop", LangCode: "en", Keys: []string{"lng_intro_about"}}},
|
||||
{name: "help.getDeepLinkInfo", req: &tg.HelpGetDeepLinkInfoRequest{Path: "join?invite=abc"}},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
var in bin.Buffer
|
||||
if err := tt.req.Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
ctx := WithUserID(context.Background(), 1000000001)
|
||||
enc, err := r.Dispatch(ctx, [8]byte{}, 0, &in)
|
||||
if err != nil {
|
||||
t.Fatalf("dispatch: %v", err)
|
||||
}
|
||||
var out bin.Buffer
|
||||
if err := enc.Encode(&out); err != nil {
|
||||
t.Fatalf("encode response: %v", err)
|
||||
}
|
||||
if out.Len() == 0 {
|
||||
t.Fatal("encoded response is empty")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestHelpGetDeepLinkInfoReturnsEmpty 回归：help.getDeepLinkInfo 此前未注册 handler，
|
||||
// 落 fallback 返回 500 NOT_IMPLEMENTED。客户端遇到无法识别的 tg:// 深链就会发该请求
|
||||
// （DrKLO LaunchActivity unsupportedUrl 分支），应返回规范的 deepLinkInfoEmpty 而非报错。
|
||||
func TestHelpGetDeepLinkInfoReturnsEmpty(t *testing.T) {
|
||||
r := New(Config{}, Deps{}, zaptest.NewLogger(t), clock.System)
|
||||
req := &tg.HelpGetDeepLinkInfoRequest{Path: "resolve?domain=unknown"}
|
||||
var in bin.Buffer
|
||||
if err := req.Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
enc, err := r.Dispatch(WithUserID(context.Background(), 1000000001), [8]byte{}, 0, &in)
|
||||
if err != nil {
|
||||
t.Fatalf("dispatch help.getDeepLinkInfo err = %v, want nil (未注册时为 500 NOT_IMPLEMENTED)", err)
|
||||
}
|
||||
var out bin.Buffer
|
||||
if err := enc.Encode(&out); err != nil {
|
||||
t.Fatalf("encode response: %v", err)
|
||||
}
|
||||
res, err := tg.DecodeHelpDeepLinkInfo(&out)
|
||||
if err != nil {
|
||||
t.Fatalf("decode response: %v", err)
|
||||
}
|
||||
if _, ok := res.(*tg.HelpDeepLinkInfoEmpty); !ok {
|
||||
t.Fatalf("response type = %T, want *tg.HelpDeepLinkInfoEmpty", res)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStoriesStartLiveDispatchReturnsMethodInvalid(t *testing.T) {
|
||||
r := New(Config{}, Deps{}, zaptest.NewLogger(t), clock.System)
|
||||
req := &tg.StoriesStartLiveRequest{
|
||||
Peer: &tg.InputPeerSelf{},
|
||||
PrivacyRules: []tg.InputPrivacyRuleClass{&tg.InputPrivacyValueAllowAll{}},
|
||||
RandomID: 42,
|
||||
}
|
||||
var in bin.Buffer
|
||||
if err := req.Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
_, err := r.Dispatch(WithUserID(context.Background(), 1000000001), [8]byte{}, 0, &in)
|
||||
if err == nil || !tgerr.Is(err, "METHOD_INVALID") {
|
||||
t.Fatalf("dispatch stories.startLive err = %v, want METHOD_INVALID", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStoriesAlbumMutationDispatchReturnsMethodInvalid(t *testing.T) {
|
||||
r := New(Config{}, Deps{}, zaptest.NewLogger(t), clock.System)
|
||||
updateReq := &tg.StoriesUpdateAlbumRequest{
|
||||
Peer: &tg.InputPeerSelf{},
|
||||
AlbumID: 1,
|
||||
}
|
||||
updateReq.SetTitle("Travel")
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
req bin.Encoder
|
||||
}{
|
||||
{name: "stories.createAlbum", req: &tg.StoriesCreateAlbumRequest{
|
||||
Peer: &tg.InputPeerSelf{},
|
||||
Title: "Favorites",
|
||||
Stories: []int{1},
|
||||
}},
|
||||
{name: "stories.updateAlbum", req: updateReq},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
var in bin.Buffer
|
||||
if err := tt.req.Encode(&in); err != nil {
|
||||
t.Fatalf("encode request: %v", err)
|
||||
}
|
||||
_, err := r.Dispatch(WithUserID(context.Background(), 1000000001), [8]byte{}, 0, &in)
|
||||
if err == nil || !tgerr.Is(err, "METHOD_INVALID") {
|
||||
t.Fatalf("dispatch %s err = %v, want METHOD_INVALID", tt.name, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue