package telegram import ( "context" "encoding/json" "log/slog" "net/http" "net/http/httptest" "os" "strings" "sync" "testing" "time" "github.com/go-telegram/bot" "github.com/go-telegram/bot/models" "github.com/samcharles93/archie-core/internal/channels" ) func TestName(t *testing.T) { g := New("token", nil, slog.Default()) if got := g.Name(); got != "telegram" { t.Errorf("Name() = %q, want telegram", got) } } func TestNewStoresFields(t *testing.T) { g := New("abc123", []int64{42}, slog.Default()) if g.Token != "abc123" { t.Errorf("Token = %q", g.Token) } if len(g.AllowedUserIDs) != 1 || g.AllowedUserIDs[0] != 42 { t.Errorf("AllowedUserIDs = %v", g.AllowedUserIDs) } } func TestHelpDescribesPublishedCommandsAndChat(t *testing.T) { const allowedUserID = int64(42) var sentText string api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if err := r.ParseMultipartForm(1 << 20); err != nil { t.Errorf("parse Telegram request: %v", err) } else { var rich models.InputRichMessage if err := json.Unmarshal([]byte(r.FormValue("rich_message")), &rich); err != nil { t.Errorf("decode Telegram rich_message: %v", err) } else { sentText = strings.Join(blocksToPlainText(rich.Blocks), "\n\n") } } w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"ok":true,"result":{"message_id":1,"date":1,"chat":{"id":7,"type":"private"}}}`)) })) defer api.Close() b, err := bot.New( "1:test", bot.WithServerURL(api.URL), bot.WithSkipGetMe(), bot.WithNotAsyncHandlers(), ) if err != nil { t.Fatalf("new test bot: %v", err) } g := New("1:test", []int64{allowedUserID}, slog.Default()) g.helpHandler()(context.Background(), b, &models.Update{ Message: &models.Message{ From: &models.User{ID: allowedUserID}, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, }, }) for _, spec := range gatewayCommandSpecs { if !strings.Contains(sentText, spec.Usage) { t.Errorf("help text does not contain exact usage %q:\n%s", spec.Usage, sentText) } if !strings.Contains(sentText, spec.Description) { t.Errorf("help text does not contain description %q for /%s:\n%s", spec.Description, spec.Command, sentText) } } if strings.Contains(sentText, "not yet wired") { t.Errorf("help text still claims working LLM chat is not wired:\n%s", sentText) } if !strings.Contains(sentText, "🤖 Archie") { t.Errorf("help should identify Archie directly:\n%s", sentText) } if strings.Contains(sentText, "Archie Gateway") { t.Errorf("help must not expose internal gateway terminology:\n%s", sentText) } if !strings.Contains(strings.ToLower(sentText), "chat") { t.Errorf("help text does not describe free-text chat:\n%s", sentText) } } func TestTelegramUserFacingCommandCopyDoesNotCallArchieAGateway(t *testing.T) { for _, spec := range gatewayCommandSpecs { if strings.Contains(strings.ToLower(spec.Description), "gateway") { t.Errorf("/%s exposes internal gateway terminology: %q", spec.Command, spec.Description) } } } // /delete removes a stored conversation, so it has to appear in the menu // beside /sessions and /resume: an operator who can list a session and // switch to it must be able to see how to get rid of it. func TestSessionManagementCommandsArePublished(t *testing.T) { found := make(map[string]bool, len(gatewayCommandSpecs)) for _, spec := range gatewayCommandSpecs { found[spec.Command] = true } for _, cmd := range []string{"sessions", "resume", "delete"} { if !found[cmd] { t.Errorf("/%s is missing from gatewayCommandSpecs", cmd) } } } func TestCommandSurfaceUsesOneModelSelectorAndUsefulHelpCopy(t *testing.T) { for _, spec := range gatewayCommandSpecs { if spec.Command == "models" { t.Fatal("/models is redundant beside /model and must not be published") } if spec.Command == "help" && spec.Description == "Show this guide" { t.Fatal("/help menu copy is self-referential") } } if strings.Contains(gatewayHelpText(), "/models") { t.Fatal("/help must not advertise the removed /models command") } } func TestStartHasDeterministicGatewayResponse(t *testing.T) { const allowedUserID = int64(42) g := New("1:test", []int64{allowedUserID}, slog.Default()) b, requests := newTelegramTestBot(t) g.startHandler()(context.Background(), b, &models.Update{ Message: &models.Message{ From: &models.User{ID: allowedUserID}, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, Text: "/start", }, }) if len(*requests) == 0 { t.Fatal("/start sent no response") } found := false for _, request := range *requests { found = found || request.method == "sendRichMessage" } if !found { t.Fatalf("/start did not use deterministic gateway help response: %#v", *requests) } } func TestVersionReportsBothComponents(t *testing.T) { const allowedUserID = int64(42) g := New("1:test", []int64{allowedUserID}, slog.Default()) g.Version = func() string { return "Archie\nGateway: v1.2.3\nRuntime: v4.5.6" } b, requests := newTelegramTestBot(t) g.versionHandler()(context.Background(), b, &models.Update{Message: &models.Message{ From: &models.User{ID: allowedUserID}, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, }}) if len(*requests) != 1 || !strings.Contains((*requests)[0].form["rich_message"], "Gateway: v1.2.3") || !strings.Contains((*requests)[0].form["rich_message"], "Runtime: v4.5.6") { t.Fatalf("version reply = %#v", *requests) } } type releaseAnnouncerStub struct { recipients []int64 message string } func (s *releaseAnnouncerStub) Announce( ctx context.Context, recipients []int64, send func(context.Context, int64, string) error, ) error { s.recipients = append([]int64(nil), recipients...) for _, recipient := range recipients { if err := send(ctx, recipient, s.message); err != nil { return err } } return nil } func TestReleaseAnnouncementTargetsAuthorizedUsers(t *testing.T) { const message = "Archie has just been updated to v0.2.0" announcer := &releaseAnnouncerStub{message: message} g := New("1:test", []int64{7, 8}, slog.Default()) g.ReleaseAnnouncements = announcer b, requests := newTelegramTestBot(t) g.announceRelease(context.Background(), b) if len(announcer.recipients) != 2 || announcer.recipients[0] != 7 || announcer.recipients[1] != 8 { t.Fatalf("announcement recipients = %v, want authorized users [7 8]", announcer.recipients) } var sends int for _, request := range *requests { if request.method == "sendMessage" && request.form["text"] == message { sends++ } } if sends != 2 { t.Fatalf("release announcement sends = %d, want 2; requests: %#v", sends, *requests) } } // The allowlist must fail closed: a bot handle is public, so an unset // allowlist has to deny rather than admit everyone. func TestSenderAllowlistFailsClosed(t *testing.T) { if New("t", nil, slog.Default()).isSenderAllowed(100000000) { t.Error("empty allowlist must deny every sender") } g := New("t", []int64{100000000}, slog.Default()) if !g.isSenderAllowed(100000000) { t.Error("listed sender must be allowed") } if g.isSenderAllowed(999) { t.Error("unlisted sender must be denied") } } func TestStartWithoutToken(t *testing.T) { g := New("", nil, slog.Default()) chat := &fakeChatContract{} ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) defer cancel() called := false if err := g.Start(ctx, chat, channels.Lifecycle{Running: func() { called = true }}); err == nil { t.Error("expected error when starting without token") } if called { t.Error("running callback fired after failed startup") } } func TestStartReportsRunningAfterLaunch(t *testing.T) { pollStarted := make(chan struct{}) releasePoll := make(chan struct{}) var firstPoll sync.Once api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") if strings.HasSuffix(r.URL.Path, "getUpdates") { firstPoll.Do(func() { close(pollStarted) }) select { case <-releasePoll: case <-r.Context().Done(): return } _, _ = w.Write([]byte(`{"ok":true,"result":[]}`)) return } _, _ = w.Write([]byte(`{"ok":true,"result":true}`)) })) defer api.Close() g := New("1:test", []int64{42}, slog.New(slog.DiscardHandler)) g.serverURL = api.URL ctx, cancel := context.WithCancel(t.Context()) started := make(chan bool, 1) errCh := make(chan error, 1) go func() { errCh <- g.Start(ctx, &fakeChatContract{}, channels.Lifecycle{ Running: func() { started <- g.running }, }) }() select { case <-pollStarted: case <-time.After(time.Second): t.Fatal("Telegram long poll did not start") } select { case <-started: t.Fatal("running callback fired before the first successful long poll") default: } close(releasePoll) select { case running := <-started: if !running { t.Fatal("running callback fired before Telegram delivery started") } case <-time.After(time.Second): t.Fatal("running callback was not fired after Telegram launched") } cancel() if err := <-errCh; err != nil { t.Fatalf("Start returned an error after cancellation: %v", err) } } func TestStartReportsStartingOnRestart(t *testing.T) { api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") if strings.HasSuffix(r.URL.Path, "getUpdates") { _, _ = w.Write([]byte(`{"ok":true,"result":[]}`)) return } _, _ = w.Write([]byte(`{"ok":true,"result":true}`)) })) defer api.Close() g := New("1:test", []int64{42}, slog.New(slog.DiscardHandler)) g.serverURL = api.URL ctx, cancel := context.WithCancel(t.Context()) events := make(chan string, 4) errCh := make(chan error, 1) go func() { errCh <- g.Start(ctx, &fakeChatContract{}, channels.Lifecycle{ Starting: func() { events <- "starting" }, Running: func() { events <- "running" }, }) }() wantEvent(t, events, "starting") wantEvent(t, events, "running") if err := g.RequestRestart(); err != nil { t.Fatal(err) } wantEvent(t, events, "starting") wantEvent(t, events, "running") cancel() if err := <-errCh; err != nil { t.Fatalf("Start returned an error after cancellation: %v", err) } } func wantEvent(t *testing.T, events <-chan string, want string) { t.Helper() select { case got := <-events: if got != want { t.Fatalf("lifecycle event = %q, want %q", got, want) } case <-time.After(time.Second): t.Fatalf("timed out waiting for lifecycle event %q", want) } } func TestStartAndStopLifecycle(t *testing.T) { // Use a noop webhook server so the bot can initialize without hitting // the real Telegram API. api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"ok":true,"result":true}`)) })) defer api.Close() log := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelWarn})) g := New("test-token", nil, log) // Override the API base URL -- the go-telegram/bot library uses // https://api.telegram.org by default. We want it to hit our test // server instead. The library doesn't expose a BaseURL override, so // we test what we can: ensure Start fails predictably when the API // rejects us, rather than trying to mock the full Bot API wire // protocol. chat := &fakeChatContract{} ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond) defer cancel() // This will fail because our test server returns {"ok":true} but // go-telegram/bot's Start() calls getMe() to validate the token, // and our test server doesn't return a valid User object. // The point: we exercise the Start/Stop path; accept either // success or failure. _ = g.Start(ctx, chat, channels.Lifecycle{}) // Best-effort stop -- don't assert on Start result since we can't // fully mock the Bot API without the library supporting a base URL // override. stopCtx, stopCancel := context.WithTimeout(context.Background(), 2*time.Second) defer stopCancel() if err := g.Stop(stopCtx); err != nil { t.Logf("Stop: %v (expected in test env)", err) } } // Compile-time guard: Gateway implements channels.Channel. var ( _ channels.Channel = (*Gateway)(nil) _ = (*bot.Bot)(nil) _ = models.Update{} ) // ── Regression tests for previously untested paths ──────────────────── func TestIsSenderAllowed(t *testing.T) { g := New("tok", []int64{100, 200, 300}, slog.Default()) t.Run("empty allowlist denies all", func(t *testing.T) { g2 := New("tok", nil, slog.Default()) if g2.isSenderAllowed(999999) { t.Error("empty allowlist must deny every sender, not admit them") } }) t.Run("explicit allowed senders", func(t *testing.T) { for _, id := range []int64{100, 200, 300} { if !g.isSenderAllowed(id) { t.Errorf("sender %d should be allowed", id) } } }) t.Run("not in allowlist", func(t *testing.T) { if g.isSenderAllowed(999) { t.Error("sender 999 should not be allowed") } }) t.Run("zero and negative ids", func(t *testing.T) { g3 := New("tok", []int64{-1, 0, 1}, slog.Default()) if !g3.isSenderAllowed(-1) || !g3.isSenderAllowed(0) { t.Error("explicitly listed -1 and 0 should be allowed") } if g3.isSenderAllowed(2) { t.Error("2 should not be allowed") } }) } func TestUpdateMetadata(t *testing.T) { t.Run("nil update returns unknown", func(t *testing.T) { kind, _, hasChat := updateMetadata(nil) if kind != "unknown" { t.Errorf("kind = %q, want 'unknown'", kind) } if hasChat { t.Error("nil update should have hasChat=false") } }) t.Run("message update", func(t *testing.T) { u := &models.Update{ ID: 42, Message: &models.Message{Chat: models.Chat{ID: 12345}}, } kind, chatID, hasChat := updateMetadata(u) if kind != "message" || !hasChat || chatID != 12345 { t.Errorf("kind=%q hasChat=%v chatID=%d, want message/true/12345", kind, hasChat, chatID) } }) t.Run("callback query with message", func(t *testing.T) { u := &models.Update{ ID: 99, CallbackQuery: &models.CallbackQuery{ Message: models.MaybeInaccessibleMessage{ Message: &models.Message{Chat: models.Chat{ID: 888}}, }, }, } kind, chatID, hasChat := updateMetadata(u) if kind != "callback_query" || !hasChat || chatID != 888 { t.Errorf("kind=%q hasChat=%v chatID=%d, want callback_query/true/888", kind, hasChat, chatID) } }) t.Run("other update type", func(t *testing.T) { u := &models.Update{ID: 7} kind, _, hasChat := updateMetadata(u) if kind != "other" || hasChat { t.Errorf("kind=%q hasChat=%v, want other/false", kind, hasChat) } }) } func TestPanicRecoveryMiddlewareDoesNotCrash(t *testing.T) { g := New("tok", nil, slog.Default()) mw := g.panicRecoveryMiddleware() handler := mw(func(ctx context.Context, b *bot.Bot, update *models.Update) { panic("test panic") }) // Must not panic. handler(context.Background(), nil, &models.Update{ ID: 1, Message: &models.Message{Chat: models.Chat{ID: 123}}, }) } func TestUpdateLoggingMiddlewareCallsInner(t *testing.T) { g := New("tok", nil, slog.Default()) mw := g.updateLoggingMiddleware() called := false handler := mw(func(ctx context.Context, b *bot.Bot, update *models.Update) { called = true }) handler(context.Background(), nil, &models.Update{ ID: 1, Message: &models.Message{Chat: models.Chat{ID: 456}}, }) if !called { t.Error("inner handler was not called") } } func TestAuthorizedMessageNilMessage(t *testing.T) { g := New("tok", []int64{42}, slog.Default()) msg, ok := g.authorizedMessage(context.Background(), nil, &models.Update{ID: 1}) if ok || msg != nil { t.Error("nil message should return false, nil") } } func TestGatewayStopWhenNotRunning(t *testing.T) { g := New("tok", nil, slog.Default()) if err := g.Stop(context.Background()); err != nil { t.Errorf("unexpected error stopping unstarted gateway: %v", err) } } func TestThreadIDString(t *testing.T) { tests := []struct { name string id int want string }{ {name: "zero is empty", id: 0, want: ""}, {name: "positive thread id", id: 5, want: "5"}, {name: "large thread id", id: 123456789, want: "123456789"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got := threadIDString(tt.id) if got != tt.want { t.Errorf("threadIDString(%d) = %q, want %q", tt.id, got, tt.want) } }) } } // A restart must not answer messages that arrived while the daemon was // down. Telegram holds undelivered updates for 24h and replays them on the // first getUpdates, so a boot after an outage answers hours-old chatter. // The webhook path already passes DropPendingUpdates; long polling has to // clear the backlog explicitly. func TestDropPendingUpdatesClearsTheBacklog(t *testing.T) { var gotPath string var gotDrop bool api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { gotPath = r.URL.Path // The client sends multipart/form-data, not JSON. if err := r.ParseMultipartForm(1 << 20); err != nil { t.Errorf("parse Telegram request: %v", err) } gotDrop = r.FormValue("drop_pending_updates") == "true" w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"ok":true,"result":true}`)) })) defer api.Close() b, err := bot.New("1:test", bot.WithServerURL(api.URL), bot.WithSkipGetMe()) if err != nil { t.Fatalf("new test bot: %v", err) } g := New("1:test", []int64{42}, slog.New(slog.DiscardHandler)) g.dropPendingUpdates(context.Background(), b) if !strings.Contains(gotPath, "deleteWebhook") { t.Errorf("called %q, want deleteWebhook", gotPath) } if !gotDrop { t.Error("drop_pending_updates was not set; the backlog would be replayed on boot") } } // Clearing the backlog is best-effort. A Telegram error here must not stop // the gateway coming up -- chat availability matters more than a clean queue -- // but it must say so, or a silently replayed backlog looks like a bot bug. func TestDropPendingUpdatesSurvivesAPIFailure(t *testing.T) { api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusInternalServerError) _, _ = w.Write([]byte(`{"ok":false,"description":"boom"}`)) })) defer api.Close() b, err := bot.New("1:test", bot.WithServerURL(api.URL), bot.WithSkipGetMe()) if err != nil { t.Fatalf("new test bot: %v", err) } var logged strings.Builder g := New("1:test", []int64{42}, slog.New(slog.NewTextHandler(&logged, nil))) g.dropPendingUpdates(context.Background(), b) // must not panic or block if !strings.Contains(logged.String(), "could not drop pending telegram updates") { t.Errorf("failure was swallowed silently; log = %q", logged.String()) } } // The helper working is not the fix; launch calling it is. Without this, // deleting the call from the polling branch leaves the suite green. func TestLaunchDropsPendingUpdatesBeforePolling(t *testing.T) { var mu sync.Mutex var dropped bool api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if strings.HasSuffix(r.URL.Path, "deleteWebhook") { if err := r.ParseMultipartForm(1 << 20); err == nil { mu.Lock() dropped = r.FormValue("drop_pending_updates") == "true" mu.Unlock() } } w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"ok":true,"result":true}`)) })) defer api.Close() g := New("1:test", []int64{42}, slog.New(slog.DiscardHandler)) g.serverURL = api.URL ctx, cancel := context.WithCancel(context.Background()) defer cancel() if _, err := g.launch(ctx, &fakeChatContract{}, channels.Lifecycle{}); err != nil { t.Fatalf("launch() error = %v", err) } cancel() mu.Lock() defer mu.Unlock() if !dropped { t.Error("launch() started long polling without dropping pending updates") } } func TestValidateConfigAcceptsTokenEnv(t *testing.T) { g := New("token", nil, slog.Default()) if err := g.ValidateConfig(map[string]any{"token_env": "TELEGRAM_BOT_TOKEN"}); err != nil { t.Errorf("ValidateConfig with token_env set = %v, want nil", err) } } func TestValidateConfigAcceptsTokenRef(t *testing.T) { g := New("token", nil, slog.Default()) if err := g.ValidateConfig(map[string]any{"token": map[string]any{"engine": "env", "key": "TELEGRAM_BOT_TOKEN"}}); err != nil { t.Errorf("ValidateConfig with a token secret ref set = %v, want nil: chat.telegram.token is an equally valid credential source to token_env", err) } } func TestValidateConfigRejectsNeitherCredential(t *testing.T) { g := New("token", nil, slog.Default()) if err := g.ValidateConfig(map[string]any{}); err == nil { t.Error("ValidateConfig with neither token nor token_env set = nil, want an error") } }