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

   1 package main
   2
   3 import (
   4         "context"
   5         "io"
   6         "net/http"
   7         "net/http/httptest"
   8         "testing"
   9         "testing/synctest"
  10         "time"
  11
  12         "github.com/stretchr/testify/require"
  13 )
  14
  15 func TestGetUpdatesAsksForMessagesFromTheOffset(t *testing.T) {
  16         server := newTelegramFake(t)
  17         server.Add(TelegramUpdate{
  18                 UpdateID: 7,
  19                 Message:  telegramOwnerMessage("hello"),
  20         })
  21
  22         updates, err := newTelegramAPI(server.URL, telegramTestToken).GetUpdates(t.Context(), 7)
  23         require.NoError(t, err)
  24         require.Len(t, updates, 1)
  25         require.Equal(t, int64(7), updates[0].UpdateID)
  26         require.Equal(t, "hello", updates[0].Message.Text)
  27
  28         call := server.Calls()[0]
  29         require.Equal(t, "getUpdates", call.method)
  30         require.Equal(t, map[string]any{
  31                 "offset":          float64(7),
  32                 "timeout":         float64(telegramUpdateWaitTimeout / time.Second),
  33                 "allowed_updates": []any{"message"},
  34         }, call.params)
  35 }
  36
  37 func TestSendMessageSendsPlainText(t *testing.T) {
  38         server := newTelegramFake(t)
  39         err := newTelegramAPI(server.URL, telegramTestToken).SendMessage(t.Context(), telegramTestOwner, "*not bold*", nil)
  40         require.NoError(t, err)
  41
  42         require.Equal(t, map[string]any{
  43                 "chat_id": float64(telegramTestOwner),
  44                 "text":    "*not bold*",
  45         }, server.Calls()[0].params)
  46 }
  47
  48 func TestSendMessageSendsTheEntities(t *testing.T) {
  49         server := newTelegramFake(t)
  50         err := newTelegramAPI(server.URL, telegramTestToken).SendMessage(t.Context(), telegramTestOwner, "a link", []TelegramEntity{
  51                 {
  52                         Type:   "text_link",
  53                         Offset: 2,
  54                         Length: 4,
  55                         URL:    "https://example.com",
  56                 },
  57         })
  58         require.NoError(t, err)
  59
  60         require.Equal(t, []any{
  61                 map[string]any{
  62                         "type":   "text_link",
  63                         "offset": float64(2),
  64                         "length": float64(4),
  65                         "url":    "https://example.com",
  66                 },
  67         }, server.Calls()[0].params["entities"])
  68 }
  69
  70 func TestSendRichMessageSendsTheMarkdownUnchanged(t *testing.T) {
  71         server := newTelegramFake(t)
  72         markdown := "| a | b |\n|---|---|\n| **1** | `2` |"
  73         err := newTelegramAPI(server.URL, telegramTestToken).SendRichMessage(t.Context(), telegramTestOwner, markdown)
  74         require.NoError(t, err)
  75
  76         call := server.Calls()[0]
  77         require.Equal(t, "sendRichMessage", call.method)
  78         require.Equal(t, map[string]any{
  79                 "chat_id": float64(telegramTestOwner),
  80                 "rich_message": map[string]any{
  81                         "markdown": markdown,
  82                 },
  83         }, call.params)
  84 }
  85
  86 func TestSendCallsTimeOutOnAStalledConnection(t *testing.T) {
  87         testCases := []struct {
  88                 method string
  89                 send   func(ctx context.Context, api *TelegramAPI) error
  90         }{
  91                 {
  92                         method: "sendMessage",
  93                         send: func(ctx context.Context, api *TelegramAPI) error {
  94                                 return api.SendMessage(ctx, telegramTestOwner, "hi", nil)
  95                         },
  96                 },
  97                 {
  98                         method: "sendRichMessage",
  99                         send: func(ctx context.Context, api *TelegramAPI) error {
 100                                 return api.SendRichMessage(ctx, telegramTestOwner, "hi")
 101                         },
 102                 },
 103         }
 104
 105         for _, tc := range testCases {
 106                 t.Run(tc.method, func(t *testing.T) {
 107                         synctest.Test(t, func(t *testing.T) {
 108                                 server := newTelegramLocalFake(t)
 109                                 server.stall = func(call TelegramFakeCall) bool {
 110                                         return call.method == tc.method
 111                                 }
 112
 113                                 api := newTelegramAPI(server.URL, telegramTestToken)
 114                                 api.http.Transport = server
 115                                 start := time.Now()
 116                                 err := tc.send(t.Context(), api)
 117                                 require.EqualError(t, err, "no answer in 30s")
 118                                 require.Equal(t, telegramSendTimeout, time.Since(start))
 119                                 require.NotContains(t, err.Error(), telegramTestToken)
 120                                 require.NotContains(t, err.Error(), server.URL)
 121
 122                                 retry, _ := telegramRetryable(err)
 123                                 require.True(t, retry)
 124
 125                                 ctx, cancel := context.WithCancel(t.Context())
 126                                 defer cancel()
 127
 128                                 time.AfterFunc(time.Second, cancel)
 129
 130                                 start = time.Now()
 131                                 err = tc.send(ctx, api)
 132                                 require.Error(t, err)
 133                                 require.Equal(t, time.Second, time.Since(start))
 134                         })
 135                 })
 136         }
 137 }
 138
 139 func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
 140         testCases := []struct {
 141                 name      string
 142                 reply     func(w http.ResponseWriter)
 143                 retry     bool
 144                 wait      time.Duration
 145                 rejected  bool
 146                 errorText string
 147         }{
 148                 {
 149                         name: "refused connection is retried",
 150                         reply: func(w http.ResponseWriter) {
 151                                 conn, _, err := http.NewResponseController(w).Hijack()
 152                                 if err != nil {
 153                                         panic(err)
 154                                 }
 155
 156                                 // This forced disconnect has no response or
 157                                 // retry after close.
 158                                 conn.Close() // nolint: errcheck
 159                         },
 160                         retry:     true,
 161                         errorText: "no answer",
 162                 },
 163                 {
 164                         name: "rate limit waits as asked",
 165                         reply: func(w http.ResponseWriter) {
 166                                 w.WriteHeader(http.StatusTooManyRequests)
 167
 168                                 _, err := io.WriteString(w, `{"ok":false,"error_code":429,"description":"Too Many Requests: retry after 3","parameters":{"retry_after":3}}`)
 169                                 if err != nil {
 170                                         panic(err)
 171                                 }
 172                         },
 173                         retry:     true,
 174                         wait:      3 * time.Second,
 175                         errorText: "429",
 176                 },
 177                 {
 178                         name: "server error page is retried",
 179                         reply: func(w http.ResponseWriter) {
 180                                 w.WriteHeader(http.StatusBadGateway)
 181
 182                                 _, err := io.WriteString(w, "<html>bad gateway</html>")
 183                                 if err != nil {
 184                                         panic(err)
 185                                 }
 186                         },
 187                         retry:     true,
 188                         errorText: "502 Bad Gateway",
 189                 },
 190                 {
 191                         name: "token echoed in a description is hidden",
 192                         reply: func(w http.ResponseWriter) {
 193                                 w.WriteHeader(http.StatusUnauthorized)
 194
 195                                 _, err := io.WriteString(w, `{"ok":false,"error_code":401,"description":"Unauthorized: bot`+telegramTestToken+`"}`)
 196                                 if err != nil {
 197                                         panic(err)
 198                                 }
 199                         },
 200                         retry:     false,
 201                         errorText: "Unauthorized: botTOKEN",
 202                 },
 203                 {
 204                         name: "bad request is a refusal",
 205                         reply: func(w http.ResponseWriter) {
 206                                 w.WriteHeader(http.StatusBadRequest)
 207
 208                                 _, err := io.WriteString(w, `{"ok":false,"error_code":400,"description":"Bad Request: can't parse"}`)
 209                                 if err != nil {
 210                                         panic(err)
 211                                 }
 212                         },
 213                         retry:     false,
 214                         rejected:  true,
 215                         errorText: "400 Bad Request: can't parse",
 216                 },
 217                 {
 218                         name: "unknown method is a refusal",
 219                         reply: func(w http.ResponseWriter) {
 220                                 w.WriteHeader(http.StatusNotFound)
 221
 222                                 _, err := io.WriteString(w, `{"ok":false,"error_code":404,"description":"Not Found"}`)
 223                                 if err != nil {
 224                                         panic(err)
 225                                 }
 226                         },
 227                         retry:     false,
 228                         rejected:  true,
 229                         errorText: "404 Not Found",
 230                 },
 231                 {
 232                         name: "not found page of a proxy is not a refusal",
 233                         reply: func(w http.ResponseWriter) {
 234                                 w.WriteHeader(http.StatusNotFound)
 235
 236                                 _, err := io.WriteString(w, "<html>not found</html>")
 237                                 if err != nil {
 238                                         panic(err)
 239                                 }
 240                         },
 241                         retry:     false,
 242                         errorText: "404 Not Found",
 243                 },
 244                 {
 245                         name: "broken answer is retried",
 246                         reply: func(w http.ResponseWriter) {
 247                                 _, err := io.WriteString(w, `{"ok":`)
 248                                 if err != nil {
 249                                         panic(err)
 250                                 }
 251                         },
 252                         retry:     true,
 253                         errorText: "invalid JSON",
 254                 },
 255         }
 256
 257         for _, tc := range testCases {
 258                 t.Run(tc.name, func(t *testing.T) {
 259                         server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 260                                 tc.reply(w)
 261                         }))
 262
 263                         t.Cleanup(server.Close)
 264
 265                         err := newTelegramAPI(server.URL, telegramTestToken).SendMessage(t.Context(), telegramTestOwner, "hi", nil)
 266                         require.ErrorContains(t, err, tc.errorText)
 267                         require.NotContains(t, err.Error(), telegramTestToken)
 268                         require.NotContains(t, err.Error(), server.URL)
 269
 270                         retry, wait := telegramRetryable(err)
 271                         require.Equal(t, tc.retry, retry)
 272                         require.Equal(t, tc.wait, wait)
 273                         require.Equal(t, tc.rejected, telegramRejected(err))
 274                 })
 275         }
 276
 277         server := httptest.NewServer(http.NotFoundHandler())
 278         server.Close()
 279
 280         _, err := newTelegramAPI(server.URL, telegramTestToken).GetUpdates(t.Context(), 0)
 281         require.ErrorAs(t, err, new(*TelegramNetworkError))
 282         require.NotContains(t, err.Error(), telegramTestToken)
 283 }