Ilia Denisov
e9f836db87
Tests · Go / test (push) Successful in 9s
Tests · Integration / integration (push) Successful in 10s
Tests · UI / test (push) Successful in 20s
Tests · Go / test (pull_request) Successful in 8s
Tests · Integration / integration (pull_request) Successful in 11s
Tests · UI / test (pull_request) Successful in 19s
Service-agnostic refinement of the owner's idea: the sign-in service returns a set of supported game languages with the user identity, and the lobby gates the New Game variant choice by it (en -> English; ru -> Russian + Эрудит). - Connector hosts two bots in one container (one per service language, each its own token + game channel; the same telegram_id spans both). ValidateInitData tries each token and returns the validating bot's service_language + supported_languages. Per-language config (TELEGRAM_BOT_TOKEN_EN/_RU, channels). - supported_languages rides the Session (fbs, session-scoped, not persisted); the UI offers only the matching variants on New Game — gating only the START of a new game (auto-match + friend invite), not accept/open/play; backend does not enforce. - service_language persisted (accounts.service_language, migration 00010, written every login, last-login-wins) and routes the user-facing Notify push back through the right bot (push-target coalesces with preferred_language). - Admin SendToUser/SendToGameChannel gain an operator-chosen language selector in the console (unrelated to ValidateInitData). - Non-Telegram logins carry the gateway default set (GATEWAY_DEFAULT_SUPPORTED_LANGUAGES, all variants). Wire (committed regen): ValidateInitDataResponse +service_language +supported_languages; Session +supported_languages; SendToUser/SendToGameChannel +language. Docs (ARCHITECTURE/FUNCTIONAL/_ru/READMEs) + PLAN updated; stage marked done.
255 lines
10 KiB
Go
255 lines
10 KiB
Go
package connector
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
flatbuffers "github.com/google/flatbuffers/go"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
"scrabble/pkg/fbs/scrabblefb"
|
|
telegramv1 "scrabble/pkg/proto/telegram/v1"
|
|
"scrabble/platform/telegram/internal/initdata"
|
|
"scrabble/platform/telegram/internal/loginwidget"
|
|
)
|
|
|
|
// stubValidator returns a fixed user / error from Validate.
|
|
type stubValidator struct {
|
|
user initdata.User
|
|
err error
|
|
}
|
|
|
|
func (s stubValidator) Validate(string) (initdata.User, error) { return s.user, s.err }
|
|
|
|
// stubWidgetValidator returns a fixed user / error from the Login Widget Validate.
|
|
type stubWidgetValidator struct {
|
|
user loginwidget.User
|
|
err error
|
|
}
|
|
|
|
func (s stubWidgetValidator) Validate(string) (loginwidget.User, error) { return s.user, s.err }
|
|
|
|
// fakeSender records the delivery calls the server makes.
|
|
type fakeSender struct {
|
|
notify []notifyCall
|
|
text []textCall
|
|
err error
|
|
}
|
|
|
|
type notifyCall struct {
|
|
chatID int64
|
|
text, buttonText, startParam string
|
|
}
|
|
type textCall struct {
|
|
chatID int64
|
|
text string
|
|
}
|
|
|
|
func (f *fakeSender) Notify(_ context.Context, chatID int64, text, buttonText, startParam string) error {
|
|
f.notify = append(f.notify, notifyCall{chatID, text, buttonText, startParam})
|
|
return f.err
|
|
}
|
|
|
|
func (f *fakeSender) SendText(_ context.Context, chatID int64, text string) error {
|
|
f.text = append(f.text, textCall{chatID, text})
|
|
return f.err
|
|
}
|
|
|
|
// botRT assembles one language-tagged bot runtime for a test.
|
|
func botRT(lang string, sender Sender, channelID int64, iv initdata.Validator, wv loginwidget.Validator) BotRuntime {
|
|
return BotRuntime{Language: lang, Sender: sender, ChannelID: channelID, InitValidator: iv, WidgetValidator: wv}
|
|
}
|
|
|
|
func yourTurnPayload(gameID string) []byte {
|
|
b := flatbuffers.NewBuilder(0)
|
|
gid := b.CreateString(gameID)
|
|
scrabblefb.YourTurnEventStart(b)
|
|
scrabblefb.YourTurnEventAddGameId(b, gid)
|
|
b.Finish(scrabblefb.YourTurnEventEnd(b))
|
|
return b.FinishedBytes()
|
|
}
|
|
|
|
func TestValidateInitData(t *testing.T) {
|
|
want := initdata.User{ExternalID: "42", Username: "neo", FirstName: "Thomas", LanguageCode: "en-GB"}
|
|
srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{user: want}, stubWidgetValidator{})}, nil)
|
|
resp, err := srv.ValidateInitData(context.Background(), &telegramv1.ValidateInitDataRequest{InitData: "x"})
|
|
if err != nil {
|
|
t.Fatalf("validate: %v", err)
|
|
}
|
|
if resp.GetExternalId() != "42" || resp.GetUsername() != "neo" || resp.GetFirstName() != "Thomas" || resp.GetLanguageCode() != "en-GB" {
|
|
t.Errorf("resp = %+v, want %+v", resp, want)
|
|
}
|
|
if resp.GetServiceLanguage() != "en" || len(resp.GetSupportedLanguages()) != 1 || resp.GetSupportedLanguages()[0] != "en" {
|
|
t.Errorf("service_language=%q supported=%v, want en / [en]", resp.GetServiceLanguage(), resp.GetSupportedLanguages())
|
|
}
|
|
|
|
bad := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{err: initdata.ErrInvalidInitData}, stubWidgetValidator{})}, nil)
|
|
if _, err := bad.ValidateInitData(context.Background(), &telegramv1.ValidateInitDataRequest{}); status.Code(err) != codes.InvalidArgument {
|
|
t.Errorf("err code = %v, want InvalidArgument", status.Code(err))
|
|
}
|
|
}
|
|
|
|
// TestValidateInitDataPicksValidatingBot proves the second bot's token validates and
|
|
// its service language is reported when the first bot rejects the data.
|
|
func TestValidateInitDataPicksValidatingBot(t *testing.T) {
|
|
want := initdata.User{ExternalID: "7", Username: "ru_user", FirstName: "Иван", LanguageCode: "ru"}
|
|
srv := NewServer([]BotRuntime{
|
|
botRT("en", &fakeSender{}, 0, stubValidator{err: initdata.ErrInvalidInitData}, stubWidgetValidator{}),
|
|
botRT("ru", &fakeSender{}, 0, stubValidator{user: want}, stubWidgetValidator{}),
|
|
}, nil)
|
|
resp, err := srv.ValidateInitData(context.Background(), &telegramv1.ValidateInitDataRequest{InitData: "x"})
|
|
if err != nil {
|
|
t.Fatalf("validate: %v", err)
|
|
}
|
|
if resp.GetExternalId() != "7" || resp.GetServiceLanguage() != "ru" || resp.GetSupportedLanguages()[0] != "ru" {
|
|
t.Errorf("resp = %+v, want external 7 / service ru", resp)
|
|
}
|
|
}
|
|
|
|
func TestValidateLoginWidget(t *testing.T) {
|
|
want := loginwidget.User{ExternalID: "42", Username: "neo", FirstName: "Thomas"}
|
|
srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{user: want})}, nil)
|
|
resp, err := srv.ValidateLoginWidget(context.Background(), &telegramv1.ValidateLoginWidgetRequest{Data: "x"})
|
|
if err != nil {
|
|
t.Fatalf("validate: %v", err)
|
|
}
|
|
if resp.GetExternalId() != "42" || resp.GetUsername() != "neo" || resp.GetFirstName() != "Thomas" {
|
|
t.Errorf("resp = %+v, want %+v", resp, want)
|
|
}
|
|
|
|
bad := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{err: loginwidget.ErrInvalidLoginWidget})}, nil)
|
|
if _, err := bad.ValidateLoginWidget(context.Background(), &telegramv1.ValidateLoginWidgetRequest{}); status.Code(err) != codes.InvalidArgument {
|
|
t.Errorf("err code = %v, want InvalidArgument", status.Code(err))
|
|
}
|
|
}
|
|
|
|
func TestNotifyDelivers(t *testing.T) {
|
|
const gameID = "7c9e6679-7425-40de-944b-e07fc1f90ae7"
|
|
sender := &fakeSender{}
|
|
srv := NewServer([]BotRuntime{botRT("en", sender, 0, stubValidator{}, stubWidgetValidator{})}, nil)
|
|
resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
|
|
ExternalId: "12345", Kind: "your_turn", Payload: yourTurnPayload(gameID), Language: "en",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("notify: %v", err)
|
|
}
|
|
if !resp.GetDelivered() {
|
|
t.Fatal("expected delivered=true")
|
|
}
|
|
if len(sender.notify) != 1 {
|
|
t.Fatalf("notify calls = %d, want 1", len(sender.notify))
|
|
}
|
|
if got := sender.notify[0]; got.chatID != 12345 || got.startParam != "g"+gameID {
|
|
t.Errorf("notify call = %+v, want chatID 12345 startParam g%s", got, gameID)
|
|
}
|
|
}
|
|
|
|
// TestNotifyRoutesByLanguage proves the push goes through the bot for the recipient's
|
|
// service language, not the other bot.
|
|
func TestNotifyRoutesByLanguage(t *testing.T) {
|
|
en, ru := &fakeSender{}, &fakeSender{}
|
|
srv := NewServer([]BotRuntime{
|
|
botRT("en", en, 0, stubValidator{}, stubWidgetValidator{}),
|
|
botRT("ru", ru, 0, stubValidator{}, stubWidgetValidator{}),
|
|
}, nil)
|
|
resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
|
|
ExternalId: "12345", Kind: "your_turn", Payload: yourTurnPayload("7c9e6679-7425-40de-944b-e07fc1f90ae7"), Language: "ru",
|
|
})
|
|
if err != nil || !resp.GetDelivered() {
|
|
t.Fatalf("notify: %v delivered=%v", err, resp.GetDelivered())
|
|
}
|
|
if len(ru.notify) != 1 || len(en.notify) != 0 {
|
|
t.Errorf("routing wrong: ru=%d en=%d, want 1/0", len(ru.notify), len(en.notify))
|
|
}
|
|
}
|
|
|
|
// TestNotifyUnknownLanguage proves a push for a language with no bot is a best-effort
|
|
// miss (delivered=false, no delivery attempt), not an error.
|
|
func TestNotifyUnknownLanguage(t *testing.T) {
|
|
en := &fakeSender{}
|
|
srv := NewServer([]BotRuntime{botRT("en", en, 0, stubValidator{}, stubWidgetValidator{})}, nil)
|
|
resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
|
|
ExternalId: "12345", Kind: "your_turn", Payload: yourTurnPayload("g"), Language: "ru",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("notify: %v", err)
|
|
}
|
|
if resp.GetDelivered() || len(en.notify) != 0 {
|
|
t.Errorf("delivered=%v en calls=%d, want false / 0", resp.GetDelivered(), len(en.notify))
|
|
}
|
|
}
|
|
|
|
func TestNotifySkipsUnrenderedKind(t *testing.T) {
|
|
sender := &fakeSender{}
|
|
srv := NewServer([]BotRuntime{botRT("en", sender, 0, stubValidator{}, stubWidgetValidator{})}, nil)
|
|
resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
|
|
ExternalId: "12345", Kind: "opponent_moved", Language: "en",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("notify: %v", err)
|
|
}
|
|
if resp.GetDelivered() {
|
|
t.Error("expected delivered=false for an unrendered kind")
|
|
}
|
|
if len(sender.notify) != 0 {
|
|
t.Errorf("sender called %d times, want 0", len(sender.notify))
|
|
}
|
|
}
|
|
|
|
func TestNotifyInvalidExternalID(t *testing.T) {
|
|
srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{})}, nil)
|
|
_, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
|
|
ExternalId: "not-a-number", Kind: "your_turn", Payload: yourTurnPayload("g"), Language: "en",
|
|
})
|
|
if status.Code(err) != codes.InvalidArgument {
|
|
t.Errorf("err code = %v, want InvalidArgument", status.Code(err))
|
|
}
|
|
}
|
|
|
|
func TestSendToUser(t *testing.T) {
|
|
sender := &fakeSender{}
|
|
srv := NewServer([]BotRuntime{botRT("en", sender, 0, stubValidator{}, stubWidgetValidator{})}, nil)
|
|
resp, err := srv.SendToUser(context.Background(), &telegramv1.SendToUserRequest{ExternalId: "999", Text: "hi", Language: "en"})
|
|
if err != nil {
|
|
t.Fatalf("send to user: %v", err)
|
|
}
|
|
if !resp.GetDelivered() || len(sender.text) != 1 || sender.text[0].chatID != 999 || sender.text[0].text != "hi" {
|
|
t.Errorf("send to user = %v / calls %+v", resp.GetDelivered(), sender.text)
|
|
}
|
|
}
|
|
|
|
// TestSendToUserUnknownLanguage proves the admin broadcast errors when no bot serves
|
|
// the operator-chosen language.
|
|
func TestSendToUserUnknownLanguage(t *testing.T) {
|
|
srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{})}, nil)
|
|
_, err := srv.SendToUser(context.Background(), &telegramv1.SendToUserRequest{ExternalId: "999", Text: "hi", Language: "ru"})
|
|
if status.Code(err) != codes.FailedPrecondition {
|
|
t.Errorf("err code = %v, want FailedPrecondition", status.Code(err))
|
|
}
|
|
}
|
|
|
|
func TestSendToGameChannel(t *testing.T) {
|
|
t.Run("unconfigured", func(t *testing.T) {
|
|
srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{})}, nil)
|
|
_, err := srv.SendToGameChannel(context.Background(), &telegramv1.SendToGameChannelRequest{Text: "x", Language: "en"})
|
|
if status.Code(err) != codes.FailedPrecondition {
|
|
t.Errorf("err code = %v, want FailedPrecondition", status.Code(err))
|
|
}
|
|
})
|
|
t.Run("configured routes by language", func(t *testing.T) {
|
|
en, ru := &fakeSender{}, &fakeSender{}
|
|
srv := NewServer([]BotRuntime{
|
|
botRT("en", en, 111, stubValidator{}, stubWidgetValidator{}),
|
|
botRT("ru", ru, 555, stubValidator{}, stubWidgetValidator{}),
|
|
}, nil)
|
|
resp, err := srv.SendToGameChannel(context.Background(), &telegramv1.SendToGameChannelRequest{Text: "news", Language: "ru"})
|
|
if err != nil {
|
|
t.Fatalf("send to channel: %v", err)
|
|
}
|
|
if !resp.GetDelivered() || len(ru.text) != 1 || ru.text[0].chatID != 555 || len(en.text) != 0 {
|
|
t.Errorf("send to channel: ru=%+v en=%+v", ru.text, en.text)
|
|
}
|
|
})
|
|
}
|