Files
archie/internal/channels/telegram/model_test.go
T
sam f7815d3b62 fix(channels): delete unreachable Telegram webhook delivery mode
telegram.New only ever constructed with empty webhookURL/webhookSecret
(telegram_setup.go) and config.TelegramConfig has no field to set them, so
the SetWebhook/StartWebhook branch, WebhookHandler, and webhook teardown in
Stop were dead code exercised only by tests. Long-polling is the only
reachable mode; delete the webhook path and its ConfigSchema properties so
the schema no longer advertises unsupported config.
2026-09-15 10:18:48 +10:00

662 lines
21 KiB
Go

package telegram
import (
"context"
"encoding/json"
"fmt"
"log/slog"
"net/http"
"net/http/httptest"
"slices"
"strings"
"testing"
"github.com/go-telegram/bot"
"github.com/go-telegram/bot/models"
"github.com/samcharles93/archie-core/internal/gateway"
)
type modelManagerStub struct {
models []string
active string
}
type detailedModelManagerStub struct {
*modelManagerStub
details map[string]gateway.ModelDetails
}
func (m *detailedModelManagerStub) ModelDetails(ref string) (gateway.ModelDetails, bool) {
details, ok := m.details[ref]
return details, ok
}
func (m *modelManagerStub) Models() []string {
return append([]string(nil), m.models...)
}
func (m *modelManagerStub) ActiveModel() string {
return m.active
}
func (m *modelManagerStub) SetActiveModel(_ context.Context, ref string) error {
if slices.Contains(m.models, ref) {
m.active = ref
return nil
}
return fmt.Errorf("unknown model: %s", ref)
}
func (m *modelManagerStub) Providers() []string {
seen := make(map[string]bool)
var providers []string
for _, model := range m.models {
provider, _, ok := strings.Cut(model, "/")
if ok && !seen[provider] {
seen[provider] = true
providers = append(providers, provider)
}
}
return providers
}
func (m *modelManagerStub) ActiveProvider() string {
provider, _, _ := strings.Cut(m.active, "/")
return provider
}
func (m *modelManagerStub) ModelsForProvider(provider string) []string {
var models []string
for _, model := range m.models {
if strings.HasPrefix(model, provider+"/") {
models = append(models, model)
}
}
return models
}
func (m *modelManagerStub) SetActiveProvider(_ context.Context, provider string) error {
models := m.ModelsForProvider(provider)
if len(models) == 0 {
return fmt.Errorf("unknown provider: %s", provider)
}
m.active = models[0]
return nil
}
type telegramRequest struct {
method string
form map[string]string
}
func newTelegramTestBot(t *testing.T) (*bot.Bot, *[]telegramRequest) {
t.Helper()
var requests []telegramRequest
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)
}
form := make(map[string]string, len(r.MultipartForm.Value))
for key, values := range r.MultipartForm.Value {
if len(values) > 0 {
form[key] = values[0]
}
}
requests = append(requests, telegramRequest{
method: r.URL.Path[strings.LastIndexByte(r.URL.Path, '/')+1:],
form: form,
})
w.Header().Set("Content-Type", "application/json")
switch requests[len(requests)-1].method {
case "answerCallbackQuery", "sendChatAction":
_, _ = w.Write([]byte(`{"ok":true,"result":true}`))
default:
_, _ = w.Write([]byte(`{"ok":true,"result":{"message_id":9,"date":1,"chat":{"id":7,"type":"private"}}}`))
}
}))
t.Cleanup(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)
}
return b, &requests
}
func TestModelCommandShowsInlineSelector(t *testing.T) {
const allowedUserID = int64(42)
manager := &modelManagerStub{
models: []string{"provider/alpha", "provider/beta", "other/gamma"},
active: "provider/beta",
}
router := gateway.NewRouter(nil, nil, "telegram")
router.Models = manager
g := New("1:test", []int64{allowedUserID}, slog.Default())
b, requests := newTelegramTestBot(t)
g.defaultHandler(router)(context.Background(), b, &models.Update{
Message: &models.Message{
From: &models.User{ID: allowedUserID},
Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate},
Text: "/model",
},
})
var markup models.InlineKeyboardMarkup
found := false
for _, request := range *requests {
raw, ok := request.form["reply_markup"]
if request.method != "sendMessage" || !ok {
continue
}
if err := json.Unmarshal([]byte(raw), &markup); err != nil {
t.Fatalf("decode reply markup: %v", err)
}
found = true
}
if !found {
t.Fatalf("/model did not send an inline keyboard; requests: %#v", *requests)
}
if got := len(markup.InlineKeyboard); got != 2 {
t.Fatalf("provider keyboard rows = %d, want provider row and cancel row", got)
}
if got := len(markup.InlineKeyboard[0]); got != 2 {
t.Fatalf("provider buttons = %d, want 2", got)
}
if !strings.Contains(markup.InlineKeyboard[0][0].Text, "(2)") {
t.Errorf("provider button lacks model count: %q", markup.InlineKeyboard[0][0].Text)
}
if !strings.HasPrefix(markup.InlineKeyboard[0][0].Text, "✓ ") {
t.Errorf("active provider button is not marked: %q", markup.InlineKeyboard[0][0].Text)
}
if got := markup.InlineKeyboard[1][0].CallbackData; got != modelCancelCallback {
t.Errorf("provider cancel callback = %q", got)
}
}
func TestModelCommandDrillsFromProviderIntoFilteredModels(t *testing.T) {
const allowedUserID = int64(42)
manager := &modelManagerStub{
models: []string{
"openrouter/openai/gpt-5.6",
"openai/gpt-5.6",
"openai/o3",
},
active: "openrouter/openai/gpt-5.6",
}
router := gateway.NewRouter(nil, nil, "telegram")
router.Models = manager
g := New("1:test", []int64{allowedUserID}, slog.Default())
b, requests := newTelegramTestBot(t)
g.defaultHandler(router)(context.Background(), b, &models.Update{
Message: &models.Message{
From: &models.User{ID: allowedUserID},
Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate},
Text: "/model",
},
})
var providerMarkup models.InlineKeyboardMarkup
if err := json.Unmarshal([]byte((*requests)[0].form["reply_markup"]), &providerMarkup); err != nil {
t.Fatal(err)
}
if len(providerMarkup.InlineKeyboard) != 2 || len(providerMarkup.InlineKeyboard[0]) != 2 {
t.Fatalf("provider grid = %#v, want two-column row and cancel", providerMarkup.InlineKeyboard)
}
*requests = nil
providerCallback := providerMarkup.InlineKeyboard[0][1].CallbackData
g.defaultHandler(router)(context.Background(), b, &models.Update{
CallbackQuery: &models.CallbackQuery{
ID: "provider-callback",
From: models.User{ID: allowedUserID},
Data: providerCallback,
Message: models.MaybeInaccessibleMessage{
Type: models.MaybeInaccessibleMessageTypeMessage,
Message: &models.Message{ID: 9, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}},
},
},
})
if manager.ActiveProvider() != "openrouter" {
t.Fatalf("provider selection changed active model prematurely: %q", manager.ActiveProvider())
}
var modelMarkup models.InlineKeyboardMarkup
for _, request := range *requests {
if raw := request.form["reply_markup"]; raw != "" {
if err := json.Unmarshal([]byte(raw), &modelMarkup); err != nil {
t.Fatal(err)
}
}
}
if len(modelMarkup.InlineKeyboard) != 2 {
t.Fatalf("filtered model rows = %d, want one two-column model row plus navigation", len(modelMarkup.InlineKeyboard))
}
for _, button := range modelMarkup.InlineKeyboard[0] {
model, ok := g.modelForCallback(button.CallbackData)
if !ok {
continue
}
if strings.HasPrefix(model, "openrouter/") {
t.Fatalf("OpenRouter model leaked into OpenAI selection: %q", model)
}
}
}
// TestModelSelectorKeyboardPageAcrossModelCounts covers the sizes that
// actually stress pageBounds and the nav-row logic: none, one (no pairing,
// no nav), exactly one page size (no nav), one over a page (nav appears),
// and enough to need many pages (nav survives past double digits).
func TestModelSelectorKeyboardPageAcrossModelCounts(t *testing.T) {
tests := []struct {
name string
count int
wantPages int
}{
{"zero models", 0, 1},
{"one model", 1, 1},
{"exactly one page", modelPageSize, 1},
{"one over a page", modelPageSize + 1, 2},
{"many pages", 100, (100 + modelPageSize - 1) / modelPageSize},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
manager := &modelManagerStub{}
for i := 0; i < tt.count; i++ {
manager.models = append(manager.models, fmt.Sprintf("provider/model-%02d", i))
}
g := New("1:test", []int64{42}, slog.Default())
page := g.modelSelectorKeyboardPage(manager, "provider", 0)
rows := page.InlineKeyboard
if len(rows) == 0 {
t.Fatalf("no rows returned for %d models", tt.count)
}
actions := rows[len(rows)-1]
if len(actions) != 2 || actions[0].CallbackData != modelBackCallback ||
actions[1].CallbackData != modelCancelCallback {
t.Fatalf("actions row = %#v, want back+cancel", actions)
}
modelButtons := 0
for _, row := range rows[:len(rows)-1] {
for _, button := range row {
if button.CallbackData == modelNoopCallback {
continue
}
if _, isPageLink := g.modelPageForCallback(button.CallbackData); isPageLink {
continue
}
modelButtons++
}
}
if modelButtons != min(tt.count, modelPageSize) {
t.Fatalf("model buttons on first page = %d, want %d", modelButtons, min(tt.count, modelPageSize))
}
hasNav := tt.wantPages > 1
navRowPresent := false
for _, row := range rows[:len(rows)-1] {
for _, button := range row {
if button.CallbackData == modelNoopCallback {
navRowPresent = true
}
}
}
if navRowPresent != hasNav {
t.Fatalf("nav row present = %v, want %v for %d models", navRowPresent, hasNav, tt.count)
}
})
}
}
func TestModelSelectorPageCallbackAdvancesToNextPage(t *testing.T) {
manager := &modelManagerStub{active: "provider/model-09"}
for i := 1; i <= 9; i++ {
manager.models = append(manager.models, fmt.Sprintf("provider/model-%02d", i))
}
g := New("1:test", []int64{42}, slog.Default())
first := g.modelSelectorKeyboardPage(manager, "provider", 0)
nav := first.InlineKeyboard[4]
next, ok := g.modelPageForCallback(nav[1].CallbackData)
if !ok {
t.Fatal("next page callback was not recorded")
}
second := g.modelSelectorKeyboardPage(manager, next.Provider, next.Page)
if got := len(second.InlineKeyboard[0]); got != 1 {
t.Fatalf("second page model row = %d buttons, want 1 (nine models, page size eight)", got)
}
if got := second.InlineKeyboard[0][0].Text; got != "✓ model-09" {
t.Fatalf("second page model = %q", got)
}
}
func TestModelSelectionConfirmationIncludesCatalogMetadata(t *testing.T) {
const ref = "google/gemini-3.6-flash"
manager := &detailedModelManagerStub{
modelManagerStub: &modelManagerStub{models: []string{ref}, active: ref},
details: map[string]gateway.ModelDetails{
ref: {
Ref: ref, ContextWindow: 1_048_576, MaxOutputTokens: 65_536,
Reasoning: true, Tools: true, Structured: true,
InputModalities: []string{"text", "image", "audio"},
},
},
}
got := modelSelectionConfirmation(manager, ref)
for _, want := range []string{
"Model switched to gemini-3.6-flash",
"Provider: Google",
"Context: 1048576 tokens",
"Max output: 65536 tokens",
"Capabilities: reasoning, tools, image, audio, structured output",
"active for this daemon process; resets on restart",
} {
if !strings.Contains(got, want) {
t.Errorf("confirmation missing %q:\n%s", want, got)
}
}
}
func TestProviderCallbackHonoursTheProviderRenderedInTheSelector(t *testing.T) {
const allowedUserID = int64(42)
manager := &modelManagerStub{
models: []string{"openai/gpt-5.6", "openrouter/openai/gpt-5.6"},
active: "openai/gpt-5.6",
}
router := gateway.NewRouter(nil, nil, "telegram")
router.Models = manager
g := New("1:test", []int64{allowedUserID}, slog.Default())
b, _ := newTelegramTestBot(t)
markup := g.providerSelectorKeyboard(manager)
renderedCallback := markup.InlineKeyboard[0][0].CallbackData
manager.models = []string{"deepseek/deepseek-v4-pro", "openai/gpt-5.6", "openrouter/openai/gpt-5.6"}
g.handleProviderCallback(context.Background(), b, &models.Update{CallbackQuery: &models.CallbackQuery{
ID: "callback-id",
From: models.User{ID: allowedUserID},
Data: renderedCallback,
}}, router)
if got := manager.ActiveProvider(); got != "openai" {
t.Errorf("opening a provider page changed active provider to %q", got)
}
}
func TestModelCallbackSwitchesAndUpdatesSelector(t *testing.T) {
const allowedUserID = int64(42)
manager := &modelManagerStub{
models: []string{"provider/alpha", "provider/beta"},
active: "provider/alpha",
}
router := gateway.NewRouter(nil, nil, "telegram")
router.Models = manager
g := New("1:test", []int64{allowedUserID}, slog.Default())
b, requests := newTelegramTestBot(t)
g.defaultHandler(router)(context.Background(), b, &models.Update{
CallbackQuery: &models.CallbackQuery{
ID: "callback-id",
From: models.User{ID: allowedUserID},
Data: g.modelCallbackToken("provider/beta"),
Message: models.MaybeInaccessibleMessage{
Type: models.MaybeInaccessibleMessageTypeMessage,
Message: &models.Message{ID: 9, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}},
},
},
})
if manager.active != "provider/beta" {
t.Fatalf("active model = %q, want provider/beta", manager.active)
}
var answered, edited bool
for _, request := range *requests {
if request.method == "answerCallbackQuery" {
answered = true
if got := request.form["text"]; got != "The model has been changed to: beta" {
t.Errorf("selection acknowledgement = %q", got)
}
}
if request.method == "editMessageText" {
edited = true
if markup, present := request.form["reply_markup"]; present {
t.Errorf("confirmation edit sent reply_markup=%q, want field omitted", markup)
}
}
}
if !answered || !edited {
t.Fatalf("callback answered=%t edited=%t, requests: %#v", answered, edited, *requests)
}
}
func TestDirectModelSelectionWithProviderIsAtomicOnFailure(t *testing.T) {
const allowedUserID = int64(42)
manager := &modelManagerStub{
models: []string{"openai/gpt-5.6", "anthropic/claude"},
active: "openai/gpt-5.6",
}
router := gateway.NewRouter(nil, nil, "telegram")
router.Models = manager
g := New("1:test", []int64{allowedUserID}, slog.Default())
b, _ := newTelegramTestBot(t)
g.handleModelCommand(context.Background(), b, &models.Message{
From: &models.User{ID: allowedUserID},
Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate},
Text: "/model missing --provider anthropic",
}, router)
if manager.active != "openai/gpt-5.6" {
t.Fatalf("failed selection changed active model to %q", manager.active)
}
}
func TestModelPageIndicatorCallbackIsAnswered(t *testing.T) {
const allowedUserID = int64(42)
g := New("1:test", []int64{allowedUserID}, slog.Default())
b, requests := newTelegramTestBot(t)
g.defaultHandler(gateway.NewRouter(nil, nil, "telegram"))(context.Background(), b, &models.Update{
CallbackQuery: &models.CallbackQuery{
ID: "noop-id", From: models.User{ID: allowedUserID}, Data: modelNoopCallback,
},
})
if len(*requests) != 1 || (*requests)[0].method != "answerCallbackQuery" {
t.Fatalf("page indicator requests = %#v, want callback acknowledgement", *requests)
}
}
func TestModelCallbackHonoursTheModelRenderedInTheSelector(t *testing.T) {
const allowedUserID = int64(42)
manager := &modelManagerStub{
models: []string{"openai/gpt-5.6", "openrouter/openai/gpt-5.6"},
active: "openai/gpt-5.6",
}
router := gateway.NewRouter(nil, nil, "telegram")
router.Models = manager
g := New("1:test", []int64{allowedUserID}, slog.Default())
b, _ := newTelegramTestBot(t)
markup := g.modelSelectorKeyboard(manager)
renderedCallback := markup.InlineKeyboard[0][0].CallbackData
if err := manager.SetActiveProvider(context.Background(), "openrouter"); err != nil {
t.Fatal(err)
}
g.handleModelCallback(context.Background(), b, &models.Update{CallbackQuery: &models.CallbackQuery{
ID: "callback-id",
From: models.User{ID: allowedUserID},
Data: renderedCallback,
}}, router)
if got := manager.ActiveModel(); got != "openai/gpt-5.6" {
t.Errorf("stale selector chose %q, want the originally rendered model", got)
}
}
func TestModelCallbackRejectsUnauthorizedAndMalformedSelections(t *testing.T) {
const allowedUserID = int64(42)
tests := []struct {
name string
userID int64
data string
}{
{name: "unauthorized sender", userID: 99, data: "model:1"},
{name: "malformed index", userID: allowedUserID, data: "model:not-an-index"},
{name: "out of range", userID: allowedUserID, data: "model:99"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
manager := &modelManagerStub{
models: []string{"provider/alpha", "provider/beta"},
active: "provider/alpha",
}
router := gateway.NewRouter(nil, nil, "telegram")
router.Models = manager
g := New("1:test", []int64{allowedUserID}, slog.Default())
b, requests := newTelegramTestBot(t)
g.defaultHandler(router)(context.Background(), b, &models.Update{
CallbackQuery: &models.CallbackQuery{
ID: "callback-id",
From: models.User{ID: tt.userID},
Data: tt.data,
},
})
if manager.active != "provider/alpha" {
t.Fatalf("active model changed to %q", manager.active)
}
var answer *telegramRequest
for index := range *requests {
if (*requests)[index].method == "answerCallbackQuery" {
answer = &(*requests)[index]
}
}
if answer == nil || answer.form["show_alert"] != "true" {
t.Fatalf("rejection did not answer with an alert; requests: %#v", *requests)
}
})
}
}
func TestProviderCallbackRejectsUnauthorizedAndMalformedSelections(t *testing.T) {
const allowedUserID = int64(42)
tests := []struct {
name string
userID int64
data string
}{
{name: "unauthorized sender", userID: 99, data: "provider:1"},
{name: "malformed index", userID: allowedUserID, data: "provider:not-an-index"},
{name: "out of range", userID: allowedUserID, data: "provider:99"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
manager := &modelManagerStub{
models: []string{"openrouter/openai/gpt-5.6", "openai/gpt-5.6"},
active: "openrouter/openai/gpt-5.6",
}
router := gateway.NewRouter(nil, nil, "telegram")
router.Models = manager
g := New("1:test", []int64{allowedUserID}, slog.Default())
b, requests := newTelegramTestBot(t)
g.defaultHandler(router)(context.Background(), b, &models.Update{
CallbackQuery: &models.CallbackQuery{
ID: "callback-id",
From: models.User{ID: tt.userID},
Data: tt.data,
},
})
if manager.active != "openrouter/openai/gpt-5.6" {
t.Fatalf("active provider/model changed to %q", manager.active)
}
var answer *telegramRequest
for index := range *requests {
if (*requests)[index].method == "answerCallbackQuery" {
answer = &(*requests)[index]
}
}
if answer == nil || answer.form["show_alert"] != "true" {
t.Fatalf("rejection did not answer with an alert; requests: %#v", *requests)
}
})
}
}
// TestParseModelRestReturnsDeclaredValuesInOrder covers the naked return that a
// nakedret autofix expanded in 6d4e0be. Every result shares a type with at
// least one other -- two strings, three bools -- so a transposed pair compiles
// silently and would surface only as /model switching the wrong scope. Each
// case sets exactly one flag so no pair of bools can swap undetected.
func TestParseModelRestReturnsDeclaredValuesInOrder(t *testing.T) {
tests := []struct {
name string
rest string
model string
provider string
global bool
session bool
refresh bool
}{
{name: "model only", rest: "gpt-5.6", model: "gpt-5.6"},
{name: "inline provider", rest: "gpt-5.6 --provider=openai", model: "gpt-5.6", provider: "openai"},
{name: "separated provider", rest: "gpt-5.6 --provider openai", model: "gpt-5.6", provider: "openai"},
{name: "global scope", rest: "gpt-5.6 --global", model: "gpt-5.6", global: true},
{name: "session scope", rest: "gpt-5.6 --session", model: "gpt-5.6", session: true},
{name: "refresh", rest: "--refresh", refresh: true},
{name: "provider without model", rest: "--provider=openai --global", provider: "openai", global: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
model, provider, global, session, refresh := parseModelRest(tt.rest)
if model != tt.model || provider != tt.provider {
t.Fatalf("parseModelRest(%q) = model %q, provider %q; want %q, %q",
tt.rest, model, provider, tt.model, tt.provider)
}
if global != tt.global || session != tt.session || refresh != tt.refresh {
t.Fatalf("parseModelRest(%q) = global %v, session %v, refresh %v; want %v, %v, %v",
tt.rest, global, session, refresh, tt.global, tt.session, tt.refresh)
}
})
}
}
// TestParseModelRestDoesNotDoubleTheModelName guards the regression introduced
// by the nestif extraction in 651de0a: the extracted helper appended surviving
// fields to a slice the caller then appended to again, so "/model gpt-5.6"
// asked the router for "gpt-5.6 gpt-5.6" and every direct model switch failed
// as an unknown model. A separated provider value was doubled into the name
// too. The assertion is on field count rather than equality so that a future
// re-extraction cannot pass by doubling a different part of the string.
func TestParseModelRestDoesNotDoubleTheModelName(t *testing.T) {
for _, rest := range []string{
"gpt-5.6",
"gpt-5.6 --global",
"gpt-5.6 --provider openai",
"gpt-5.6 --provider=openai --session",
} {
model, _, _, _, _ := parseModelRest(rest)
if fields := strings.Fields(model); len(fields) != 1 {
t.Fatalf("parseModelRest(%q) model = %q; want a single field", rest, model)
}
}
}