feat(telegram,game): single bot + per-user variant preferences

Collapse the two per-language Telegram bots into one unified bot and
replace language-based variant gating with explicit per-user variant
preferences.

- Telegram: one bot; drop service_language and the supported_languages
  set everywhere (DB, account, auth, FlatBuffers Session wire, gateway,
  connector proto). The single bot renders chat and out-of-app push in
  the recipient's preferred_language; remove the game-language push
  routing override (notify Intent.Language / push Event.language).
- Preferences: new accounts.variant_preferences (text[], DB default
  {erudit_ru}, CHECK non-empty + subset of the three variants). Gates
  the New Game picker, vs-AI and the friend invitation the player
  creates, enforced server-side (HTTP 400 otherwise); an invited friend
  may still accept any variant. Edited on the Settings screen; variants
  are Erudit-first everywhere.
- Admin: drop the per-bot language selectors (broadcast / send-to-user)
  and the feedback channel_lang column/field.
- Env/CI: collapse TELEGRAM_BOT_TOKEN_{EN,RU}, TELEGRAM_GAME_CHANNEL_ID_{EN,RU},
  VITE_TELEGRAM_LINK{,_EN,_RU} and VITE_TELEGRAM_GAME_CHANNEL_NAME_{EN,RU}
  to single unsuffixed names; drop GATEWAY_DEFAULT_SUPPORTED_LANGUAGES.
- Docs updated (ARCHITECTURE, FUNCTIONAL + _ru, platform/telegram, gateway,
  backend, ui, UI_DESIGN, PRERELEASE).

The migration squash is deferred to a follow-up PR.

platform/telegram/internal/connector/server.go

@@ -4,15 +4,14 @@
 // methods address a recipient by the identity external_id, so a future platform
 // connector can implement the same service.
 //
-// The connector hosts one bot per configured service language (en/ru); the same
-// Telegram user id spans them all. ValidateInitData tries each bot's token in turn
-// and reports which bot validated (its service language); the push and admin
-// methods route to the bot the request selects by language.
+// The connector hosts a single bot. ValidateInitData/ValidateLoginWidget verify
+// launch data against its token; Notify renders the message in the recipient's
+// interface language (the single bot needs no routing); the admin methods deliver
+// through that bot.
 package connector
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"strconv"
 
@@ -34,103 +33,70 @@ type Sender interface {
 	SendText(ctx context.Context, chatID int64, text string) error
 }
 
-// BotRuntime is one configured language-tagged bot: its sender, game channel id,
-// and the two HMAC validators bound to its token.
+// BotRuntime is the configured bot: its sender, game channel id, and the two HMAC
+// validators bound to its token.
 type BotRuntime struct {
-	// Language is the bot's service language (en/ru).
-	Language string
-	// Sender delivers messages through this bot.
+	// Sender delivers messages through the bot.
 	Sender Sender
-	// ChannelID is this bot's game channel (0 disables channel posts).
+	// ChannelID is the bot's game channel (0 disables channel posts).
 	ChannelID int64
-	// InitValidator verifies Mini App initData signed by this bot's token.
+	// InitValidator verifies Mini App initData signed by the bot's token.
 	InitValidator initdata.Validator
-	// WidgetValidator verifies Login Widget data signed by this bot's token.
+	// WidgetValidator verifies Login Widget data signed by the bot's token.
 	WidgetValidator loginwidget.Validator
 }
 
-// Server implements telegramv1.TelegramServer over one or more language-tagged bots.
+// Server implements telegramv1.TelegramServer over the single configured bot.
 type Server struct {
 	telegramv1.UnimplementedTelegramServer
-	bots  map[string]BotRuntime // keyed by service language
-	order []string              // stable iteration order for validation
-	log   *zap.Logger
+	bot BotRuntime
+	log *zap.Logger
 }
 
-// NewServer builds the gRPC service from the configured bots (at least one).
-func NewServer(bots []BotRuntime, log *zap.Logger) *Server {
+// NewServer builds the gRPC service from the configured bot.
+func NewServer(bot BotRuntime, log *zap.Logger) *Server {
 	if log == nil {
 		log = zap.NewNop()
 	}
-	m := make(map[string]BotRuntime, len(bots))
-	order := make([]string, 0, len(bots))
-	for _, b := range bots {
-		m[b.Language] = b
-		order = append(order, b.Language)
-	}
-	return &Server{bots: m, order: order, log: log}
+	return &Server{bot: bot, log: log}
 }
 
-// ValidateInitData verifies Mini App launch data against each bot's token in turn
-// and returns the user identity plus the validating bot's service language (which
-// routes the user's later push) and its set of offered game languages.
+// ValidateInitData verifies Mini App launch data against the bot's token and returns
+// the user identity.
 func (s *Server) ValidateInitData(ctx context.Context, req *telegramv1.ValidateInitDataRequest) (*telegramv1.ValidateInitDataResponse, error) {
-	var lastErr error
-	for _, lang := range s.order {
-		u, err := s.bots[lang].InitValidator.Validate(req.GetInitData())
-		if err != nil {
-			lastErr = err
-			continue
-		}
-		return &telegramv1.ValidateInitDataResponse{
-			ExternalId:         u.ExternalID,
-			Username:           u.Username,
-			FirstName:          u.FirstName,
-			LanguageCode:       u.LanguageCode,
-			ServiceLanguage:    lang,
-			SupportedLanguages: []string{lang},
-		}, nil
+	u, err := s.bot.InitValidator.Validate(req.GetInitData())
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
-	if lastErr == nil {
-		lastErr = errors.New("no bot configured")
-	}
-	return nil, status.Error(codes.InvalidArgument, lastErr.Error())
+	return &telegramv1.ValidateInitDataResponse{
+		ExternalId:   u.ExternalID,
+		Username:     u.Username,
+		FirstName:    u.FirstName,
+		LanguageCode: u.LanguageCode,
+	}, nil
 }
 
-// ValidateLoginWidget verifies Login Widget authorization data against each bot's
-// token in turn and returns the user identity, for attaching a Telegram identity to
-// an existing account.
+// ValidateLoginWidget verifies Login Widget authorization data against the bot's
+// token and returns the user identity, for attaching a Telegram identity to an
+// existing account.
 func (s *Server) ValidateLoginWidget(ctx context.Context, req *telegramv1.ValidateLoginWidgetRequest) (*telegramv1.ValidateLoginWidgetResponse, error) {
-	var lastErr error
-	for _, lang := range s.order {
-		u, err := s.bots[lang].WidgetValidator.Validate(req.GetData())
-		if err != nil {
-			lastErr = err
-			continue
-		}
-		return &telegramv1.ValidateLoginWidgetResponse{
-			ExternalId: u.ExternalID,
-			Username:   u.Username,
-			FirstName:  u.FirstName,
-		}, nil
+	u, err := s.bot.WidgetValidator.Validate(req.GetData())
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
-	if lastErr == nil {
-		lastErr = errors.New("no bot configured")
-	}
-	return nil, status.Error(codes.InvalidArgument, lastErr.Error())
+	return &telegramv1.ValidateLoginWidgetResponse{
+		ExternalId: u.ExternalID,
+		Username:   u.Username,
+		FirstName:  u.FirstName,
+	}, nil
 }
 
-// Notify renders and delivers an out-of-app notification through the bot selected by
-// the recipient's service language. It reports delivered=false (without an error)
-// when no bot serves that language, the kind is not pushed out-of-app, or the bot
-// could not deliver (e.g. the user never started it), so the gateway treats a
+// Notify renders and delivers an out-of-app notification through the bot. The message
+// is rendered in the recipient's interface language (req language). It reports
+// delivered=false (without an error) when the kind is not pushed out-of-app or the
+// bot could not deliver (e.g. the user never started it), so the gateway treats a
 // fallback miss as best-effort.
 func (s *Server) Notify(ctx context.Context, req *telegramv1.NotifyRequest) (*telegramv1.NotifyResponse, error) {
-	bot, ok := s.bots[req.GetLanguage()]
-	if !ok {
-		s.log.Warn("notify: no bot for language", zap.String("language", req.GetLanguage()), zap.String("kind", req.GetKind()))
-		return &telegramv1.NotifyResponse{Delivered: false}, nil
-	}
 	msg, ok := render.Render(req.GetKind(), req.GetPayload(), req.GetLanguage())
 	if !ok {
 		return &telegramv1.NotifyResponse{Delivered: false}, nil
@@ -139,58 +105,38 @@ func (s *Server) Notify(ctx context.Context, req *telegramv1.NotifyRequest) (*te
 	if err != nil {
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
-	if err := bot.Sender.Notify(ctx, chat, msg.Text, msg.ButtonText, msg.StartParam); err != nil {
+	if err := s.bot.Sender.Notify(ctx, chat, msg.Text, msg.ButtonText, msg.StartParam); err != nil {
 		s.log.Warn("notify delivery failed", zap.String("kind", req.GetKind()), zap.Error(err))
 		return &telegramv1.NotifyResponse{Delivered: false}, nil
 	}
 	return &telegramv1.NotifyResponse{Delivered: true}, nil
 }
 
-// SendToUser sends an arbitrary admin message to one user through the bot selected
-// by language (an operator choice in the admin console).
+// SendToUser sends an arbitrary admin message to one user through the bot.
 func (s *Server) SendToUser(ctx context.Context, req *telegramv1.SendToUserRequest) (*telegramv1.SendResponse, error) {
-	bot, err := s.botFor(req.GetLanguage())
-	if err != nil {
-		return nil, err
-	}
 	chat, err := parseChatID(req.GetExternalId())
 	if err != nil {
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
-	if err := bot.Sender.SendText(ctx, chat, req.GetText()); err != nil {
+	if err := s.bot.Sender.SendText(ctx, chat, req.GetText()); err != nil {
 		s.log.Warn("send to user failed", zap.Error(err))
 		return &telegramv1.SendResponse{Delivered: false}, nil
 	}
 	return &telegramv1.SendResponse{Delivered: true}, nil
 }
 
-// SendToGameChannel posts an arbitrary admin message to the game channel of the bot
-// selected by language (an operator choice in the admin console).
+// SendToGameChannel posts an arbitrary admin message to the bot's game channel.
 func (s *Server) SendToGameChannel(ctx context.Context, req *telegramv1.SendToGameChannelRequest) (*telegramv1.SendResponse, error) {
-	bot, err := s.botFor(req.GetLanguage())
-	if err != nil {
-		return nil, err
+	if s.bot.ChannelID == 0 {
+		return nil, status.Error(codes.FailedPrecondition, "game channel is not configured")
 	}
-	if bot.ChannelID == 0 {
-		return nil, status.Error(codes.FailedPrecondition, fmt.Sprintf("game channel is not configured for language %q", req.GetLanguage()))
-	}
-	if err := bot.Sender.SendText(ctx, bot.ChannelID, req.GetText()); err != nil {
+	if err := s.bot.Sender.SendText(ctx, s.bot.ChannelID, req.GetText()); err != nil {
 		s.log.Warn("send to channel failed", zap.Error(err))
 		return &telegramv1.SendResponse{Delivered: false}, nil
 	}
 	return &telegramv1.SendResponse{Delivered: true}, nil
 }
 
-// botFor returns the bot tagged with language, or a FailedPrecondition error when no
-// bot serves it (admin broadcasts choose the language explicitly).
-func (s *Server) botFor(language string) (BotRuntime, error) {
-	bot, ok := s.bots[language]
-	if !ok {
-		return BotRuntime{}, status.Error(codes.FailedPrecondition, fmt.Sprintf("no bot configured for language %q", language))
-	}
-	return bot, nil
-}
-
 // parseChatID converts a Telegram identity external_id into a numeric chat id.
 func parseChatID(externalID string) (int64, error) {
 	id, err := strconv.ParseInt(externalID, 10, 64)

platform/telegram/internal/connector/server_test.go

@@ -56,9 +56,9 @@ func (f *fakeSender) SendText(_ context.Context, chatID int64, text string) erro
 	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}
+// botRT assembles the bot runtime for a test.
+func botRT(sender Sender, channelID int64, iv initdata.Validator, wv loginwidget.Validator) BotRuntime {
+	return BotRuntime{Sender: sender, ChannelID: channelID, InitValidator: iv, WidgetValidator: wv}
 }
 
 func yourTurnPayload(gameID string) []byte {
@@ -72,7 +72,7 @@ func yourTurnPayload(gameID string) []byte {
 
 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)
+	srv := NewServer(botRT(&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)
@@ -80,36 +80,16 @@ func TestValidateInitData(t *testing.T) {
 	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)
+	bad := NewServer(botRT(&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)
+	srv := NewServer(botRT(&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)
@@ -118,7 +98,7 @@ func TestValidateLoginWidget(t *testing.T) {
 		t.Errorf("resp = %+v, want %+v", resp, want)
 	}
 
-	bad := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{err: loginwidget.ErrInvalidLoginWidget})}, nil)
+	bad := NewServer(botRT(&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))
 	}
@@ -127,7 +107,7 @@ func TestValidateLoginWidget(t *testing.T) {
 func TestNotifyDelivers(t *testing.T) {
 	const gameID = "7c9e6679-7425-40de-944b-e07fc1f90ae7"
 	sender := &fakeSender{}
-	srv := NewServer([]BotRuntime{botRT("en", sender, 0, stubValidator{}, stubWidgetValidator{})}, nil)
+	srv := NewServer(botRT(sender, 0, stubValidator{}, stubWidgetValidator{}), nil)
 	resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
 		ExternalId: "12345", Kind: "your_turn", Payload: yourTurnPayload(gameID), Language: "en",
 	})
@@ -145,44 +125,9 @@ func TestNotifyDelivers(t *testing.T) {
 	}
 }
 
-// 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)
+	srv := NewServer(botRT(sender, 0, stubValidator{}, stubWidgetValidator{}), nil)
 	resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
 		ExternalId: "12345", Kind: "opponent_moved", Language: "en",
 	})
@@ -198,7 +143,7 @@ func TestNotifySkipsUnrenderedKind(t *testing.T) {
 }
 
 func TestNotifyInvalidExternalID(t *testing.T) {
-	srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{})}, nil)
+	srv := NewServer(botRT(&fakeSender{}, 0, stubValidator{}, stubWidgetValidator{}), nil)
 	_, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
 		ExternalId: "not-a-number", Kind: "your_turn", Payload: yourTurnPayload("g"), Language: "en",
 	})
@@ -209,8 +154,8 @@ func TestNotifyInvalidExternalID(t *testing.T) {
 
 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"})
+	srv := NewServer(botRT(sender, 0, stubValidator{}, stubWidgetValidator{}), nil)
+	resp, err := srv.SendToUser(context.Background(), &telegramv1.SendToUserRequest{ExternalId: "999", Text: "hi"})
 	if err != nil {
 		t.Fatalf("send to user: %v", err)
 	}
@@ -219,36 +164,23 @@ func TestSendToUser(t *testing.T) {
 	}
 }
 
-// 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"})
+		srv := NewServer(botRT(&fakeSender{}, 0, stubValidator{}, stubWidgetValidator{}), nil)
+		_, err := srv.SendToGameChannel(context.Background(), &telegramv1.SendToGameChannelRequest{Text: "x"})
 		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"})
+	t.Run("configured", func(t *testing.T) {
+		sender := &fakeSender{}
+		srv := NewServer(botRT(sender, 555, stubValidator{}, stubWidgetValidator{}), nil)
+		resp, err := srv.SendToGameChannel(context.Background(), &telegramv1.SendToGameChannelRequest{Text: "news"})
 		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)
+		if !resp.GetDelivered() || len(sender.text) != 1 || sender.text[0].chatID != 555 {
+			t.Errorf("send to channel: %+v", sender.text)
 		}
 	})
 }