Files
archie/internal/channels/telegram/telegram_test.go
T
sam 7c68e1d436 feat(channels): wire ConfigSchema/ValidateConfig into a startup validation loop
Every chat gateway (Telegram, email, webhook) implemented channels.Channel's
ConfigSchema/ValidateConfig contract but nothing ever called it, so a
misconfigured gateway would only fail once it tried to start rather than at
boot. setupEmailGateway/setupWebhookGateway now call ValidateConfig before
registering a start function and return false (fatal boot error, matching
setupTelegramGateway's existing convention) on failure; telegram_setup.go
does the same for the already-constructed *telegram.Gateway.

Fixed telegram.Gateway.ValidateConfig/ConfigSchema along the way: it only
recognised token_env, but chat.telegram.token (a secret reference) is an
equally valid, already-precedent-ordered credential source per
resolveTelegramToken. Wiring the old validator unmodified would have
rejected every Token-only deployment. Also corrected ConfigSchema's stale
allowed_chat_ids property name to the real allowed_user_ids toml key.
2026-09-15 11:22:23 +10:00

653 lines
20 KiB
Go

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/gateway"
)
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, "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())
router := gateway.NewRouter(nil, nil, "telegram")
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
called := false
if err := g.Start(ctx, router, gateway.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, gateway.NewRouter(nil, nil, "telegram"), gateway.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, gateway.NewRouter(nil, nil, "telegram"), gateway.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.
router := gateway.NewRouter(nil, nil, "telegram")
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, router, gateway.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 gateway.Gateway.
var (
_ gateway.Gateway = (*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, nil, gateway.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")
}
}