git.giacomolli.uk - onechat/blob - telegram_test.go

   1 package main
   2
   3 import (
   4         "context"
   5         "net/http"
   6         "os"
   7         "path/filepath"
   8         "slices"
   9         "strconv"
  10         "strings"
  11         "testing"
  12         "testing/synctest"
  13         "time"
  14
  15         "github.com/stretchr/testify/require"
  16 )
  17
  18 func TestOwnerTalksToTheAgentThroughTelegram(t *testing.T) {
  19         server := newModelFake(t)
  20         server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {
  21                 modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("Hello from the agent.")}, 100, 0, 5))
  22         }
  23
  24         telegram := newTelegramFake(t)
  25         bot, _ := telegramStartTestBot(t, telegram)
  26         socket := daemonStartTestWithBot(t, server, bot)
  27         terminal := terminalStartTestClient(t, socket)
  28         terminal.WaitFor(t, "[connected to OneChat]")
  29
  30         telegram.Add(TelegramUpdate{
  31                 UpdateID: 1,
  32                 Message:  telegramOwnerMessage("hi from the phone"),
  33         })
  34
  35         terminal.WaitFor(t, "[telegram] hi from the phone\n[working]\nHello from the agent.\n[done]")
  36         telegramWaitForSent(t, telegram, "Hello from the agent.")
  37         require.True(t, slices.ContainsFunc(telegram.Calls(), func(call TelegramFakeCall) bool {
  38                 return call.method == "sendChatAction" && call.params["action"] == "typing"
  39         }))
  40
  41         terminal.Type("hi from the desk")
  42         require.Equal(t, []string{"Hello from the agent.", "[terminal] hi from the desk", "Hello from the agent."}, telegramWaitForSent(t, telegram, "Hello from the agent.", "[terminal] hi from the desk", "Hello from the agent."))
  43 }
  44
  45 func TestBotIgnoresEveryoneButTheOwner(t *testing.T) {
  46         telegram := newTelegramFake(t)
  47         bot, logs := telegramStartTestBot(t, telegram)
  48         socket := daemonStartTestWithBot(t, newModelFake(t), bot)
  49         terminal := terminalStartTestClient(t, socket)
  50         terminal.WaitFor(t, "[connected to OneChat]")
  51
  52         group := telegramOwnerMessage("secret in a group")
  53         group.Chat = TelegramChat{
  54                 ID:   -100,
  55                 Type: "group",
  56         }
  57
  58         stranger := telegramOwnerMessage("secret of a stranger")
  59         stranger.Chat.ID = 77
  60         stranger.From.ID = 77
  61
  62         unsigned := telegramOwnerMessage("secret with no sender")
  63         unsigned.From = nil
  64
  65         for id, message := range []*TelegramMessage{group, stranger, unsigned, nil} {
  66                 telegram.Add(TelegramUpdate{
  67                         UpdateID: int64(10 + id),
  68                         Message:  message,
  69                 })
  70         }
  71
  72         require.Eventually(t, func() bool {
  73                 offset, err := telegramLoadOffset(bot.offsetPath)
  74                 return err == nil && offset == 14
  75         }, 10*time.Second, time.Millisecond)
  76
  77         require.Empty(t, telegram.Sent())
  78         require.NotContains(t, terminal.Output(), "secret")
  79         require.NotContains(t, logs.String(), "secret")
  80         require.Contains(t, logs.String(), "<6>message ignored")
  81 }
  82
  83 func TestBotAnswersThatOnlyTextIsSupported(t *testing.T) {
  84         telegram := newTelegramFake(t)
  85         bot, _ := telegramStartTestBot(t, telegram)
  86         daemonStartTestWithBot(t, newModelFake(t), bot)
  87
  88         telegram.Add(TelegramUpdate{
  89                 UpdateID: 1,
  90                 Message:  telegramOwnerMessage(""),
  91         })
  92
  93         telegramWaitForSent(t, telegram, telegramTextOnly)
  94 }
  95
  96 func TestStopFromTelegramInterruptsTheTurn(t *testing.T) {
  97         server := newModelFake(t)
  98         arrived := make(chan struct{})
  99         release := make(chan struct{})
 100         t.Cleanup(func() {
 101                 close(release)
 102         })
 103
 104         server.reply = func(_ http.ResponseWriter, _ ModelFakeCall) {
 105                 close(arrived)
 106                 <-release
 107         }
 108
 109         telegram := newTelegramFake(t)
 110         bot, _ := telegramStartTestBot(t, telegram)
 111         daemonStartTestWithBot(t, server, bot)
 112
 113         telegram.Add(TelegramUpdate{
 114                 UpdateID: 1,
 115                 Message:  telegramOwnerMessage("a long task"),
 116         })
 117
 118         <-arrived
 119         telegram.Add(TelegramUpdate{
 120                 UpdateID: 2,
 121                 Message:  telegramOwnerMessage(stopCommand),
 122         })
 123
 124         telegramWaitForSent(t, telegram, "Error: interrupted")
 125
 126         telegram.Add(TelegramUpdate{
 127                 UpdateID: 3,
 128                 Message:  telegramOwnerMessage(stopCommand),
 129         })
 130
 131         telegramWaitForSent(t, telegram, "Error: interrupted", "No turn runs.")
 132
 133         telegram.Add(TelegramUpdate{
 134                 UpdateID: 4,
 135                 Message:  telegramOwnerMessage(stopCommand + " BlueFox"),
 136         })
 137
 138         telegramWaitForSent(t, telegram, "No turn runs.", "No subagent BlueFox runs.")
 139 }
 140
 141 func TestBotShowsOnlyTheStartAndTheEndOfASubagent(t *testing.T) {
 142         telegram := newTelegramFake(t)
 143         server := newModelFake(t)
 144         server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
 145                 last := subagentTestLastItem(call)
 146                 switch {
 147                 case subagentTestCall(call):
 148                         // The report comes after the reply of the turn of the
 149                         // spawn.
 150                         require.Eventually(t, func() bool {
 151                                 return slices.Contains(telegram.Sent(), "Started.")
 152                         }, 10*time.Second, time.Millisecond)
 153                         modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("There are 3 files.")}, 100, 0, 5))
 154                 case last["type"] == "function_call_output":
 155                         modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("Started.")}, 100, 0, 5))
 156                 case strings.HasPrefix(subagentTestText(last), "["):
 157                         modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("It counted 3 files.")}, 100, 0, 5))
 158                 default:
 159                         modelWriteEvents(w, modelCompletedEvent([]any{modelFunctionCallItem("fc_1", "call_1", "spawn", `{"tasks":["Count the files."],"effort":null}`)}, 100, 0, 5))
 160                 }
 161         }
 162
 163         bot, _ := telegramStartTestBot(t, telegram)
 164         daemonStartTestWithBot(t, server, bot)
 165         telegram.Add(TelegramUpdate{
 166                 UpdateID: 1,
 167                 Message:  telegramOwnerMessage("Count the files in a subagent."),
 168         })
 169
 170         require.Eventually(t, func() bool {
 171                 return slices.Contains(telegram.Sent(), "It counted 3 files.")
 172         }, 10*time.Second, time.Millisecond)
 173
 174         sent := telegram.Sent()
 175         name := strings.TrimSuffix(strings.TrimPrefix(sent[0], "["), "] started")
 176         require.True(t, subagentNameValid(name), sent[0])
 177         require.Equal(t, []string{
 178                 "[" + name + "] started",
 179                 "Started.",
 180                 "[" + name + "] finished",
 181                 "It counted 3 files.",
 182         }, sent)
 183 }
 184
 185 func TestBotSkipsTheWorkOfWhatsAppAndTheSchedules(t *testing.T) {
 186         bot := &TelegramBot{
 187                 ready: make(chan struct{}, 1),
 188         }
 189
 190         bot.Notify(Event{
 191                 Kind:   "work",
 192                 Source: whatsappSource,
 193                 Text:   "[WhatsApp] Ana Souza",
 194         })
 195
 196         bot.Notify(Event{
 197                 Kind:   "work",
 198                 Source: scheduleSource,
 199                 Text:   "[Schedule 1] Sunday 2026-11-08 20:05 -03:00, once",
 200         })
 201
 202         require.Empty(t, bot.queue)
 203 }
 204
 205 func TestBotStartsAtTheStoredOffset(t *testing.T) {
 206         server := newModelFake(t)
 207         server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {
 208                 modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("ok")}, 100, 0, 5))
 209         }
 210
 211         telegram := newTelegramFake(t)
 212         bot, _ := telegramStartTestBot(t, telegram)
 213         require.NoError(t, telegramSaveOffset(bot.offsetPath, 10))
 214
 215         telegram.Add(TelegramUpdate{
 216                 UpdateID: 9,
 217                 Message:  telegramOwnerMessage("handled before the restart"),
 218         })
 219
 220         telegram.Add(TelegramUpdate{
 221                 UpdateID: 10,
 222                 Message:  telegramOwnerMessage("new after the restart"),
 223         })
 224
 225         socket := daemonStartTestWithBot(t, server, bot)
 226         terminal := terminalStartTestClient(t, socket)
 227         terminal.WaitFor(t, "[connected to OneChat]")
 228         telegramWaitForSent(t, telegram, "ok")
 229
 230         require.InDelta(t, float64(10), telegram.Calls()[0].params["offset"], 0)
 231         require.NotContains(t, terminal.Output(), "handled before the restart")
 232
 233         require.Eventually(t, func() bool {
 234                 offset, err := telegramLoadOffset(bot.offsetPath)
 235                 return err == nil && offset == 11
 236         }, 10*time.Second, time.Millisecond)
 237 }
 238
 239 func TestBotTriesAgainAfterFailures(t *testing.T) {
 240         server := newModelFake(t)
 241         server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {
 242                 modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("ok")}, 100, 0, 5))
 243         }
 244
 245         telegram := newTelegramFake(t)
 246         failures := map[string]int{
 247                 "getUpdates":      2,
 248                 "sendRichMessage": 1,
 249         }
 250
 251         telegram.fail = func(call TelegramFakeCall) (int, string) {
 252                 if failures[call.method] == 0 {
 253                         return 0, ""
 254                 }
 255
 256                 failures[call.method]--
 257                 if call.method == "sendRichMessage" {
 258                         return http.StatusTooManyRequests, "Too Many Requests: retry after 1"
 259                 }
 260
 261                 return http.StatusBadGateway, "Bad Gateway"
 262         }
 263
 264         bot, logs := telegramStartTestBot(t, telegram)
 265         daemonStartTestWithBot(t, server, bot)
 266
 267         telegram.Add(TelegramUpdate{
 268                 UpdateID: 1,
 269                 Message:  telegramOwnerMessage("hello"),
 270         })
 271
 272         telegramWaitForSent(t, telegram, "ok")
 273         require.Contains(t, logs.String(), "<4>receive failed retry=1s: 502")
 274         require.Contains(t, logs.String(), "<6>receive back after=")
 275         require.Contains(t, logs.String(), "<4>send failed retry=1s: 429")
 276
 277         // The bot logs the end of the outage after the send returns, so the
 278         // line can come after the fake server has the message.
 279         require.Eventually(t, func() bool {
 280                 return strings.Contains(logs.String(), "<6>send back after=")
 281         }, 10*time.Second, time.Millisecond)
 282
 283         require.NotContains(t, logs.String(), telegramTestToken)
 284 }
 285
 286 func TestDeliverTriesAgainAfterATimeout(t *testing.T) {
 287         synctest.Test(t, func(t *testing.T) {
 288                 telegram := newTelegramLocalFake(t)
 289                 stalls := 1
 290                 telegram.stall = func(call TelegramFakeCall) bool {
 291                         if call.method != "sendMessage" || stalls == 0 {
 292                                 return false
 293                         }
 294
 295                         stalls--
 296
 297                         return true
 298                 }
 299
 300                 bot, logs := telegramStartTestBot(t, telegram)
 301                 bot.api.http.Transport = telegram
 302                 bot.deliver(t.Context(), TelegramPart{
 303                         text: "hello",
 304                 })
 305
 306                 require.Equal(t, []string{"hello"}, telegram.Sent())
 307                 require.Len(t, telegram.Calls(), 2)
 308                 require.Contains(t, logs.String(), "<4>send failed retry=1s: no answer in 30s\n")
 309                 require.Contains(t, logs.String(), "<6>send back after=1s\n")
 310                 require.Equal(t, 2, strings.Count(logs.String(), "\n"))
 311                 require.NotContains(t, logs.String(), telegramTestToken)
 312         })
 313 }
 314
 315 func TestRepliesGoAsRichMessages(t *testing.T) {
 316         reply := "**Done.** The table:\n\n| Name | Size |\n|:-----|-----:|\n| `a.go` | 10 |\n\n- one\n- two\n\n```go\nx := 1\n```"
 317         server := newModelFake(t)
 318         server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {
 319                 modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem(reply)}, 100, 0, 5))
 320         }
 321
 322         telegram := newTelegramFake(t)
 323         bot, _ := telegramStartTestBot(t, telegram)
 324         socket := daemonStartTestWithBot(t, server, bot)
 325         terminal := terminalStartTestClient(t, socket)
 326         terminal.WaitFor(t, "[connected to OneChat]")
 327
 328         terminal.Type("make **it** so")
 329         telegramWaitForSent(t, telegram, "[terminal] make **it** so", reply)
 330
 331         telegram.Add(TelegramUpdate{
 332                 UpdateID: 1,
 333                 Message:  telegramOwnerMessage(""),
 334         })
 335
 336         telegramWaitForSent(t, telegram, telegramTextOnly)
 337
 338         var sends []TelegramFakeCall
 339
 340         for _, call := range telegram.Calls() {
 341                 if call.method == "sendMessage" || call.method == "sendRichMessage" {
 342                         sends = append(sends, call)
 343                 }
 344         }
 345
 346         require.Equal(t, []TelegramFakeCall{
 347                 {
 348                         method: "sendMessage",
 349                         params: map[string]any{
 350                                 "chat_id": float64(telegramTestOwner),
 351                                 "text":    "[terminal] make **it** so",
 352                         },
 353                         ok: true,
 354                 },
 355                 {
 356                         method: "sendRichMessage",
 357                         params: map[string]any{
 358                                 "chat_id": float64(telegramTestOwner),
 359                                 "rich_message": map[string]any{
 360                                         "markdown": reply,
 361                                 },
 362                         },
 363                         ok: true,
 364                 },
 365                 {
 366                         method: "sendMessage",
 367                         params: map[string]any{
 368                                 "chat_id": float64(telegramTestOwner),
 369                                 "text":    telegramTextOnly,
 370                         },
 371                         ok: true,
 372                 },
 373         }, sends)
 374 }
 375
 376 func TestRichMessageFailures(t *testing.T) {
 377         testCases := []struct {
 378                 name    string
 379                 status  int
 380                 always  bool
 381                 methods []string
 382                 sent    []string
 383                 lines   int
 384                 logText string
 385         }{
 386                 {
 387                         name:    "bad request sends the reply once with entities",
 388                         status:  http.StatusBadRequest,
 389                         always:  true,
 390                         methods: []string{"sendRichMessage", "sendMessage"},
 391                         sent:    []string{"a secret word"},
 392                         lines:   1,
 393                         logText: "<4>reply sent with simple formatting",
 394                 },
 395                 {
 396                         name:    "unknown method sends the reply once with entities",
 397                         status:  http.StatusNotFound,
 398                         always:  true,
 399                         methods: []string{"sendRichMessage", "sendMessage"},
 400                         sent:    []string{"a secret word"},
 401                         lines:   1,
 402                         logText: "<4>reply sent with simple formatting",
 403                 },
 404                 {
 405                         name:    "rate limit tries the rich message again",
 406                         status:  http.StatusTooManyRequests,
 407                         methods: []string{"sendRichMessage", "sendRichMessage"},
 408                         sent:    []string{"a **secret** word"},
 409                         lines:   2,
 410                         logText: "<4>send failed retry=1s: 429",
 411                 },
 412                 {
 413                         name:    "server error tries the rich message again",
 414                         status:  http.StatusInternalServerError,
 415                         methods: []string{"sendRichMessage", "sendRichMessage"},
 416                         sent:    []string{"a **secret** word"},
 417                         lines:   2,
 418                         logText: "<4>send failed retry=1s: 500",
 419                 },
 420                 {
 421                         name:    "other refusal drops the reply",
 422                         status:  http.StatusForbidden,
 423                         always:  true,
 424                         methods: []string{"sendRichMessage"},
 425                         lines:   1,
 426                         logText: "<3>reply lost: 403",
 427                 },
 428         }
 429
 430         for _, tc := range testCases {
 431                 t.Run(tc.name, func(t *testing.T) {
 432                         telegram := newTelegramFake(t)
 433                         failed := false
 434                         telegram.fail = func(call TelegramFakeCall) (int, string) {
 435                                 if call.method != "sendRichMessage" || failed && !tc.always {
 436                                         return 0, ""
 437                                 }
 438
 439                                 failed = true
 440
 441                                 return tc.status, "refused for bot" + telegramTestToken
 442                         }
 443
 444                         bot, logs := telegramStartTestBot(t, telegram)
 445                         bot.post(t.Context(), Event{
 446                                 Kind: "reply",
 447                                 Text: "a **secret** word",
 448                         })
 449
 450                         var methods []string
 451
 452                         for _, call := range telegram.Calls() {
 453                                 methods = append(methods, call.method)
 454                         }
 455
 456                         require.Equal(t, tc.methods, methods)
 457                         require.Equal(t, tc.sent, telegram.Sent())
 458                         require.Equal(t, tc.lines, strings.Count(logs.String(), "\n"))
 459                         require.Contains(t, logs.String(), tc.logText)
 460
 461                         if tc.lines == 2 {
 462                                 require.Contains(t, logs.String(), "<6>send back after=")
 463                         }
 464
 465                         require.NotContains(t, logs.String(), telegramTestToken)
 466                         require.NotContains(t, logs.String(), "secret word")
 467
 468                         calls := telegram.Calls()
 469                         if calls[len(calls)-1].method == "sendMessage" {
 470                                 require.NotNil(t, calls[len(calls)-1].params["entities"])
 471                         }
 472                 })
 473         }
 474 }
 475
 476 func TestLongReplyGoesAsRichMessagesSplitBetweenBlocks(t *testing.T) {
 477         paragraphs := strings.Repeat("A paragraph of the reply.\n\n", telegramRichBytes/len("A paragraph of the reply.\n\n"))
 478         table := "| a | b |\n|---|---|\n| 1 | 2 |\n"
 479         reply := paragraphs + table
 480
 481         telegram := newTelegramFake(t)
 482         bot, _ := telegramStartTestBot(t, telegram)
 483         bot.post(t.Context(), Event{
 484                 Kind: "reply",
 485                 Text: reply,
 486         })
 487
 488         require.Equal(t, []string{paragraphs, table}, telegram.Sent())
 489 }
 490
 491 func TestReplyTagsGoAsText(t *testing.T) {
 492         testCases := []struct {
 493                 name   string
 494                 status int
 495                 sent   []string
 496         }{
 497                 {
 498                         name: "rich message escapes the tag outside code",
 499                         sent: []string{"a &lt;details> &amp; tag and `<b>`"},
 500                 },
 501                 {
 502                         name:   "entity fallback shows the tag as written",
 503                         status: http.StatusBadRequest,
 504                         sent:   []string{"a <details> & tag and <b>"},
 505                 },
 506         }
 507
 508         for _, tc := range testCases {
 509                 t.Run(tc.name, func(t *testing.T) {
 510                         telegram := newTelegramFake(t)
 511                         telegram.fail = func(call TelegramFakeCall) (int, string) {
 512                                 if call.method != "sendRichMessage" {
 513                                         return 0, ""
 514                                 }
 515
 516                                 return tc.status, "Bad Request"
 517                         }
 518
 519                         bot, _ := telegramStartTestBot(t, telegram)
 520                         bot.post(t.Context(), Event{
 521                                 Kind: "reply",
 522                                 Text: "a <details> & tag and `<b>`",
 523                         })
 524
 525                         require.Equal(t, tc.sent, telegram.Sent())
 526                 })
 527         }
 528 }
 529
 530 func TestLongReplySplitCountsTheEscapedTags(t *testing.T) {
 531         paragraph := "A <b> tag.\n\n"
 532         count := telegramRichBytes / len(paragraph)
 533         reply := strings.Repeat(paragraph, count)
 534         require.LessOrEqual(t, len(reply), telegramRichBytes)
 535
 536         telegram := newTelegramFake(t)
 537         bot, _ := telegramStartTestBot(t, telegram)
 538         bot.post(t.Context(), Event{
 539                 Kind: "reply",
 540                 Text: reply,
 541         })
 542
 543         sent := telegram.Sent()
 544         require.Len(t, sent, 2)
 545         require.Equal(t, telegramEscapeTags(reply), strings.Join(sent, ""))
 546
 547         for _, markdown := range sent {
 548                 require.LessOrEqual(t, len(markdown), telegramRichBytes)
 549         }
 550 }
 551
 552 func TestRefusedRichPartGoesWithTheTextAsWritten(t *testing.T) {
 553         paragraph := "A <b> & c.\n\n"
 554         reply := strings.Repeat(paragraph, telegramRichBytes/len(paragraph))
 555
 556         telegram := newTelegramFake(t)
 557         refused := false
 558         telegram.fail = func(call TelegramFakeCall) (int, string) {
 559                 if call.method != "sendRichMessage" || refused {
 560                         return 0, ""
 561                 }
 562
 563                 refused = true
 564
 565                 return http.StatusBadRequest, "Bad Request"
 566         }
 567
 568         bot, _ := telegramStartTestBot(t, telegram)
 569         bot.post(t.Context(), Event{
 570                 Kind: "reply",
 571                 Text: reply,
 572         })
 573
 574         var fallback, rich []string
 575
 576         for _, call := range telegram.Calls() {
 577                 switch {
 578                 case !call.ok:
 579                 case call.method == "sendMessage":
 580                         fallback = append(fallback, call.params["text"].(string))
 581                 case call.method == "sendRichMessage":
 582                         rich = append(rich, call.params["rich_message"].(map[string]any)["markdown"].(string))
 583                 }
 584         }
 585
 586         require.Greater(t, len(fallback), 1)
 587         require.Len(t, rich, 1)
 588         require.True(t, strings.HasPrefix(reply, strings.Join(fallback, "")), "fallback text is not the reply as written")
 589
 590         for _, text := range fallback {
 591                 require.LessOrEqual(t, telegramUTF16Units(text), telegramMessageUnits)
 592         }
 593
 594         require.Equal(t, reply, strings.Join(fallback, "")+telegramUnescapeTags(rich[0]), "reply is not sent once and whole")
 595 }
 596
 597 func TestRefusedEntitiesGoAgainAsPlainText(t *testing.T) {
 598         telegram := newTelegramFake(t)
 599         telegram.fail = func(call TelegramFakeCall) (int, string) {
 600                 if call.params["entities"] == nil {
 601                         return 0, ""
 602                 }
 603
 604                 return http.StatusBadRequest, "Bad Request: can't parse entities of bot" + telegramTestToken
 605         }
 606
 607         bot, logs := telegramStartTestBot(t, telegram)
 608         text, entities := telegramMarkdownEntities("a **secret** word")
 609         bot.deliver(t.Context(), TelegramPart{
 610                 text:     text,
 611                 entities: entities,
 612         })
 613
 614         calls := telegram.Calls()
 615         require.Len(t, calls, 2)
 616         require.NotNil(t, calls[0].params["entities"])
 617         require.Nil(t, calls[1].params["entities"])
 618         require.Equal(t, []string{"a secret word"}, telegram.Sent())
 619         require.Equal(t, 1, strings.Count(logs.String(), "\n"))
 620         require.Contains(t, logs.String(), "<4>reply sent as plain text")
 621         require.NotContains(t, logs.String(), telegramTestToken)
 622         require.NotContains(t, logs.String(), "secret word")
 623 }
 624
 625 func TestBotLogsALostPlainReplyAsAnError(t *testing.T) {
 626         telegram := newTelegramFake(t)
 627         telegram.fail = func(call TelegramFakeCall) (int, string) {
 628                 if call.method == "sendMessage" {
 629                         return http.StatusForbidden, "Forbidden"
 630                 }
 631
 632                 return 0, ""
 633         }
 634
 635         bot, logs := telegramStartTestBot(t, telegram)
 636         bot.deliver(t.Context(), TelegramPart{text: "secret reply"})
 637         require.Equal(t, "<3>reply lost: 403 Forbidden\n", logs.String())
 638         require.Empty(t, telegram.Sent())
 639 }
 640
 641 func TestBotLogsNoTokenWhenTheNetworkFails(t *testing.T) {
 642         telegram := newTelegramFake(t)
 643         telegram.Close()
 644
 645         bot, logs := telegramStartTestBot(t, telegram)
 646         daemonStartTestWithBot(t, newModelFake(t), bot)
 647
 648         require.Eventually(t, func() bool {
 649                 return strings.Contains(logs.String(), "<4>receive failed retry=1s: no answer: ")
 650         }, 10*time.Second, time.Millisecond)
 651
 652         require.NotContains(t, logs.String(), telegramTestToken)
 653 }
 654
 655 func TestBotLogsAnOutageOnlyAtItsStartAndEnd(t *testing.T) {
 656         synctest.Test(t, func(t *testing.T) {
 657                 telegram := newTelegramLocalFake(t)
 658                 failures := 5
 659                 telegram.fail = func(call TelegramFakeCall) (int, string) {
 660                         if call.method != "getUpdates" || failures == 0 {
 661                                 return 0, ""
 662                         }
 663
 664                         failures--
 665
 666                         return http.StatusBadGateway, "Bad Gateway"
 667                 }
 668
 669                 bot, logs := telegramStartTestBot(t, telegram)
 670                 bot.api.http.Transport = telegram
 671                 whatsapp, _, _ := whatsappStartTest(t, t.TempDir(), newTestClock())
 672                 loop, _ := newTestIdleTurnLoop(t, whatsapp)
 673
 674                 telegram.Add(TelegramUpdate{
 675                         UpdateID: 1,
 676                         Message:  telegramOwnerMessage("a secret word"),
 677                 })
 678
 679                 ctx, cancel := context.WithCancel(t.Context())
 680                 defer cancel()
 681
 682                 done := make(chan error, 1)
 683                 go func() {
 684                         done <- bot.poll(ctx, loop, whatsapp)
 685                 }()
 686
 687                 time.Sleep(31 * time.Second)
 688                 synctest.Wait()
 689                 require.Equal(t, 1, loop.memory.Len())
 690
 691                 message, err := loop.memory.Message(0)
 692                 require.NoError(t, err)
 693                 require.Equal(t, "a secret word", message.Text)
 694
 695                 lines := strings.Split(strings.TrimSuffix(logs.String(), "\n"), "\n")
 696                 require.Equal(t, []string{
 697                         "<4>receive failed retry=1s: 502 Bad Gateway",
 698                         "<6>receive back after=31s",
 699                 }, lines)
 700
 701                 require.NotContains(t, logs.String(), "secret word")
 702                 require.NotContains(t, logs.String(), strconv.FormatInt(telegramTestOwner, 10))
 703                 cancel()
 704                 require.NoError(t, <-done)
 705         })
 706 }
 707
 708 func TestSplitMessage(t *testing.T) {
 709         testCases := []struct {
 710                 name  string
 711                 text  string
 712                 limit int
 713                 parts []string
 714         }{
 715                 {
 716                         name:  "short text stays whole",
 717                         text:  "one two",
 718                         limit: 10,
 719                         parts: []string{"one two"},
 720                 },
 721                 {
 722                         name:  "cut after the last line break",
 723                         text:  "first line\nsecond line",
 724                         limit: 16,
 725                         parts: []string{"first line\n", "second line"},
 726                 },
 727                 {
 728                         name:  "cut after the last space without a line break",
 729                         text:  "aaaa bbbb cccc",
 730                         limit: 12,
 731                         parts: []string{"aaaa bbbb ", "cccc"},
 732                 },
 733                 {
 734                         name:  "hard cut of one long word",
 735                         text:  "abcdefghij",
 736                         limit: 4,
 737                         parts: []string{"abcd", "efgh", "ij"},
 738                 },
 739                 {
 740                         name:  "a character outside the BMP counts two units and is not cut",
 741                         text:  "ab\U0001F600cd",
 742                         limit: 3,
 743                         parts: []string{"ab", "\U0001F600c", "d"},
 744                 },
 745         }
 746
 747         for _, tc := range testCases {
 748                 t.Run(tc.name, func(t *testing.T) {
 749                         require.Equal(t, tc.parts, telegramSplitMessage(tc.text, tc.limit))
 750                 })
 751         }
 752
 753         long := strings.Repeat("word ", 2000)
 754         parts := telegramSplitMessage(long, telegramMessageUnits)
 755         require.Len(t, parts, 3)
 756         require.Equal(t, long, strings.Join(parts, ""))
 757 }
 758
 759 func TestSplitEntitiesCutsAnEntityAcrossASplit(t *testing.T) {
 760         parts := telegramSplitEntities("aabbbbcc", []TelegramEntity{
 761                 {
 762                         Type:   "bold",
 763                         Offset: 2,
 764                         Length: 4,
 765                 },
 766                 {
 767                         Type:   "italic",
 768                         Offset: 6,
 769                         Length: 2,
 770                 },
 771         }, 5)
 772
 773         require.Equal(t, []TelegramPart{
 774                 {
 775                         text: "aabbb",
 776                         entities: []TelegramEntity{
 777                                 {
 778                                         Type:   "bold",
 779                                         Offset: 2,
 780                                         Length: 3,
 781                                 },
 782                         },
 783                 },
 784                 {
 785                         text: "bcc",
 786                         entities: []TelegramEntity{
 787                                 {
 788                                         Type:   "bold",
 789                                         Offset: 0,
 790                                         Length: 1,
 791                                 },
 792                                 {
 793                                         Type:   "italic",
 794                                         Offset: 1,
 795                                         Length: 2,
 796                                 },
 797                         },
 798                 },
 799         }, parts)
 800 }
 801
 802 func TestSplitRich(t *testing.T) {
 803         testCases := []struct {
 804                 name     string
 805                 markdown string
 806                 limit    int
 807                 parts    []string
 808         }{
 809                 {
 810                         name:     "short reply stays whole",
 811                         markdown: "| a | b |",
 812                         limit:    100,
 813                         parts:    []string{"| a | b |"},
 814                 },
 815                 {
 816                         name:     "cut after a blank line keeps a table whole",
 817                         markdown: "Intro.\n\n| a | b |\n|---|---|\n| 1 | 2 |\n",
 818                         limit:    30,
 819                         parts:    []string{"Intro.\n\n", "| a | b |\n|---|---|\n| 1 | 2 |\n"},
 820                 },
 821                 {
 822                         name:     "blank line in a code block is not a cut",
 823                         markdown: "Text.\n\n```go\nx\n\ny\n```\n\nEnd.\n",
 824                         limit:    20,
 825                         parts:    []string{"Text.\n\n", "```go\nx\n\ny\n```\n\n", "End.\n"},
 826                 },
 827                 {
 828                         name:     "paragraph with no blank line is cut after a line",
 829                         markdown: "aaa\nbbb\nccc\n",
 830                         limit:    9,
 831                         parts:    []string{"aaa\nbbb\n", "ccc\n"},
 832                 },
 833                 {
 834                         name:     "long code block is closed and opened again",
 835                         markdown: "```sh\none\ntwo\nthree\n```\n",
 836                         limit:    16,
 837                         parts:    []string{"```sh\none\n```\n", "```sh\ntwo\n```\n", "```sh\nthree\n```\n"},
 838                 },
 839                 {
 840                         name:     "long line is cut at the limit and not inside a character",
 841                         markdown: "ab\u00e9cd",
 842                         limit:    3,
 843                         parts:    []string{"ab", "\u00e9c", "d"},
 844                 },
 845                 {
 846                         name:     "long line is not cut inside an entity",
 847                         markdown: "abc&amp;def",
 848                         limit:    6,
 849                         parts:    []string{"abc", "&amp;d", "ef"},
 850                 },
 851         }
 852
 853         for _, tc := range testCases {
 854                 t.Run(tc.name, func(t *testing.T) {
 855                         require.Equal(t, tc.parts, telegramSplitRich(tc.markdown, tc.limit))
 856                 })
 857         }
 858
 859         long := strings.Repeat("A paragraph of the reply.\n\n", 2000)
 860         parts := telegramSplitRich(long, telegramRichBytes)
 861         require.Len(t, parts, 2)
 862         require.Len(t, parts[0], telegramRichBytes-telegramRichBytes%len("A paragraph of the reply.\n\n"))
 863         require.Equal(t, long, strings.Join(parts, ""))
 864 }
 865
 866 func TestLoadBotConfig(t *testing.T) {
 867         testCases := []struct {
 868                 name      string
 869                 content   string
 870                 mode      os.FileMode
 871                 errorText string
 872         }{
 873                 {
 874                         name:    "owner file is read",
 875                         content: `{"token": "` + telegramTestToken + `", "owner": 4242}`,
 876                         mode:    0o600,
 877                 },
 878                 {
 879                         name:      "file that others can read is refused",
 880                         content:   `{"token": "` + telegramTestToken + `", "owner": 4242}`,
 881                         mode:      0o640,
 882                         errorText: "mode must be 0600",
 883                 },
 884                 {
 885                         name:      "token with a path character is refused",
 886                         content:   `{"token": "123:abc/../x", "owner": 4242}`,
 887                         mode:      0o600,
 888                         errorText: "form of a bot token",
 889                 },
 890                 {
 891                         name:      "missing owner is refused",
 892                         content:   `{"token": "` + telegramTestToken + `"}`,
 893                         mode:      0o600,
 894                         errorText: "numeric Telegram user ID",
 895                 },
 896                 {
 897                         name:      "unknown field is refused",
 898                         content:   `{"token": "` + telegramTestToken + `", "owner": 4242, "chat": 1}`,
 899                         mode:      0o600,
 900                         errorText: "not valid JSON",
 901                 },
 902         }
 903
 904         for _, tc := range testCases {
 905                 t.Run(tc.name, func(t *testing.T) {
 906                         dir := t.TempDir()
 907                         path := filepath.Join(dir, telegramConfigFileName)
 908                         require.NoError(t, os.WriteFile(path, []byte(tc.content), tc.mode))
 909                         require.NoError(t, os.Chmod(path, tc.mode))
 910
 911                         config, found, err := loadTelegramConfig(dir)
 912                         if tc.errorText != "" {
 913                                 require.ErrorContains(t, err, tc.errorText)
 914                                 require.NotContains(t, err.Error(), telegramTestToken)
 915
 916                                 return
 917                         }
 918
 919                         require.NoError(t, err)
 920                         require.True(t, found)
 921                         require.Equal(t, TelegramConfig{
 922                                 Token: telegramTestToken,
 923                                 Owner: telegramTestOwner,
 924                         }, config)
 925                 })
 926         }
 927
 928         _, found, err := loadTelegramConfig(t.TempDir())
 929         require.NoError(t, err)
 930         require.False(t, found)
 931 }
 932
 933 // telegramStartTestBot returns a bot of telegramTestOwner on server, with its
 934 // offset file in a temporary directory and the buffer of its log.
 935 func telegramStartTestBot(t *testing.T, server *TelegramFake) (*TelegramBot, *SyncBuffer) {
 936         t.Helper()
 937
 938         logs := &SyncBuffer{}
 939         bot := newTelegramBot(newTelegramAPI(server.URL, telegramTestToken), telegramTestOwner, filepath.Join(t.TempDir(), telegramOffsetFileName), daemonTestLogger(logs))
 940
 941         return bot, logs
 942 }
 943
 944 // telegramWaitForSent waits until the bot sent the texts in order, and returns
 945 // them.
 946 func telegramWaitForSent(t *testing.T, server *TelegramFake, texts ...string) []string {
 947         t.Helper()
 948
 949         require.Eventually(t, func() bool {
 950                 sent := server.Sent()
 951                 return len(sent) >= len(texts) && slices.Equal(sent[len(sent)-len(texts):], texts)
 952         }, 10*time.Second, time.Millisecond, "sent so far: %q", server.Sent())
 953
 954         return server.Sent()
 955 }