Send the Telegram replies as rich messages

[onechat] / botapi_test.go

diff --git a/botapi_test.go b/botapi_test.go
index e1827471b425478352ce0200897b84f22e026dc7..fb57b45b468116c0687419123eedd7421c5fd738 100644 (file)
--- a/botapi_test.go
+++ b/botapi_test.go
@@ -48,7 +48,7 @@ func TestGetUpdatesAsksForMessagesFromTheOffset(t *testing.T) {
 
 func TestSendMessageSendsPlainText(t *testing.T) {
        server := newFakeBot(t)
 
 func TestSendMessageSendsPlainText(t *testing.T) {
        server := newFakeBot(t)

-       err := newBotAPI(server.URL, testBotToken).SendMessage(t.Context(), testOwner, "*not bold*")
+       err := newBotAPI(server.URL, testBotToken).SendMessage(t.Context(), testOwner, "*not bold*", nil)

        require.NoError(t, err)
 
        require.Equal(t, map[string]any{
        require.NoError(t, err)
 
        require.Equal(t, map[string]any{


@@ -57,31 +57,91 @@ func TestSendMessageSendsPlainText(t *testing.T) {
        }, server.Calls()[0].params)
 }
 
        }, server.Calls()[0].params)
 }
 

-func TestSendMessageTimesOutOnAStalledConnection(t *testing.T) {
+func TestSendMessageSendsTheEntities(t *testing.T) {

        server := newFakeBot(t)
        server := newFakeBot(t)

-       server.stall = func(call fakeBotCall) bool {
-               return call.method == "sendMessage"
+       err := newBotAPI(server.URL, testBotToken).SendMessage(t.Context(), testOwner, "a link", []botEntity{
+               {
+                       Type:   "text_link",
+                       Offset: 2,
+                       Length: 4,
+                       URL:    "https://example.com",
+               },
+       })
+       require.NoError(t, err)
+
+       require.Equal(t, []any{
+               map[string]any{
+                       "type":   "text_link",
+                       "offset": float64(2),
+                       "length": float64(4),
+                       "url":    "https://example.com",
+               },
+       }, server.Calls()[0].params["entities"])
+}
+
+func TestSendRichMessageSendsTheMarkdownUnchanged(t *testing.T) {
+       server := newFakeBot(t)
+       markdown := "| a | b |\n|---|---|\n| **1** | `2` |"
+       err := newBotAPI(server.URL, testBotToken).SendRichMessage(t.Context(), testOwner, markdown)
+       require.NoError(t, err)
+
+       call := server.Calls()[0]
+       require.Equal(t, "sendRichMessage", call.method)
+       require.Equal(t, map[string]any{
+               "chat_id": float64(testOwner),
+               "rich_message": map[string]any{
+                       "markdown": markdown,
+               },
+       }, call.params)
+}
+
+func TestSendCallsTimeOutOnAStalledConnection(t *testing.T) {
+       testCases := []struct {
+               method string
+               send   func(ctx context.Context, api *botAPI) error
+       }{
+               {
+                       method: "sendMessage",
+                       send: func(ctx context.Context, api *botAPI) error {
+                               return api.SendMessage(ctx, testOwner, "hi", nil)
+                       },
+               },
+               {
+                       method: "sendRichMessage",
+                       send: func(ctx context.Context, api *botAPI) error {
+                               return api.SendRichMessage(ctx, testOwner, "hi")
+                       },
+               },

        }
 
        }
 

-       api := newBotAPI(server.URL, testBotToken)
-       api.sendTimeout = 50 * time.Millisecond
-       start := time.Now()
-       err := api.SendMessage(t.Context(), testOwner, "hi")
-       require.ErrorIs(t, err, errBotNetwork)
-       require.Less(t, time.Since(start), 5*time.Second)
-       require.NotContains(t, err.Error(), testBotToken)
-       require.NotContains(t, err.Error(), server.URL)
-
-       retry, _ := retryable(err)
-       require.True(t, retry)
-
-       api.sendTimeout = time.Hour
-       ctx, cancel := context.WithCancel(t.Context())
-       time.AfterFunc(50*time.Millisecond, cancel)
-       start = time.Now()
-       err = api.SendMessage(ctx, testOwner, "hi")
-       require.Error(t, err)
-       require.Less(t, time.Since(start), 5*time.Second)
+       for _, tc := range testCases {
+               t.Run(tc.method, func(t *testing.T) {
+                       server := newFakeBot(t)
+                       server.stall = func(call fakeBotCall) bool {
+                               return call.method == tc.method
+                       }
+
+                       api := newBotAPI(server.URL, testBotToken)
+                       api.sendTimeout = 50 * time.Millisecond
+                       start := time.Now()
+                       err := tc.send(t.Context(), api)
+                       require.ErrorIs(t, err, errBotNetwork)
+                       require.Less(t, time.Since(start), 5*time.Second)
+                       require.NotContains(t, err.Error(), testBotToken)
+                       require.NotContains(t, err.Error(), server.URL)
+
+                       retry, _ := retryable(err)
+                       require.True(t, retry)
+
+                       api.sendTimeout = time.Hour
+                       ctx, cancel := context.WithCancel(t.Context())
+                       time.AfterFunc(50*time.Millisecond, cancel)
+                       start = time.Now()
+                       err = tc.send(ctx, api)
+                       require.Error(t, err)
+                       require.Less(t, time.Since(start), 5*time.Second)
+               })
+       }

 }
 
 func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
 }
 
 func TestBotErrorsDoNotHoldTheToken(t *testing.T) {


@@ -90,6 +150,7 @@ func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
                reply     func(w http.ResponseWriter)
                retry     bool
                wait      time.Duration
                reply     func(w http.ResponseWriter)
                retry     bool
                wait      time.Duration

+               rejected  bool

                errorText string
        }{
                {
                errorText string
        }{
                {


@@ -131,6 +192,35 @@ func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
                        retry:     false,
                        errorText: "Unauthorized: botTOKEN",
                },
                        retry:     false,
                        errorText: "Unauthorized: botTOKEN",
                },

+               {
+                       name: "bad request is a refusal",
+                       reply: func(w http.ResponseWriter) {
+                               w.WriteHeader(http.StatusBadRequest)
+                               _, _ = io.WriteString(w, `{"ok":false,"error_code":400,"description":"Bad Request: can't parse"}`)
+                       },
+                       retry:     false,
+                       rejected:  true,
+                       errorText: "answered 400: Bad Request: can't parse",
+               },
+               {
+                       name: "unknown method is a refusal",
+                       reply: func(w http.ResponseWriter) {
+                               w.WriteHeader(http.StatusNotFound)
+                               _, _ = io.WriteString(w, `{"ok":false,"error_code":404,"description":"Not Found"}`)
+                       },
+                       retry:     false,
+                       rejected:  true,
+                       errorText: "answered 404: Not Found",
+               },
+               {
+                       name: "not found page of a proxy is not a refusal",
+                       reply: func(w http.ResponseWriter) {
+                               w.WriteHeader(http.StatusNotFound)
+                               _, _ = io.WriteString(w, "<html>not found</html>")
+                       },
+                       retry:     false,
+                       errorText: "answered 404: Not Found",
+               },

                {
                        name: "broken answer is retried",
                        reply: func(w http.ResponseWriter) {
                {
                        name: "broken answer is retried",
                        reply: func(w http.ResponseWriter) {


@@ -148,7 +238,7 @@ func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
                        }))
                        t.Cleanup(server.Close)
 
                        }))
                        t.Cleanup(server.Close)
 

-                       err := newBotAPI(server.URL, testBotToken).SendMessage(t.Context(), testOwner, "hi")
+                       err := newBotAPI(server.URL, testBotToken).SendMessage(t.Context(), testOwner, "hi", nil)

                        require.ErrorContains(t, err, tc.errorText)
                        require.NotContains(t, err.Error(), testBotToken)
                        require.NotContains(t, err.Error(), server.URL)
                        require.ErrorContains(t, err, tc.errorText)
                        require.NotContains(t, err.Error(), testBotToken)
                        require.NotContains(t, err.Error(), server.URL)


@@ -156,6 +246,7 @@ func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
                        retry, wait := retryable(err)
                        require.Equal(t, tc.retry, retry)
                        require.Equal(t, tc.wait, wait)
                        retry, wait := retryable(err)
                        require.Equal(t, tc.retry, retry)
                        require.Equal(t, tc.wait, wait)

+                       require.Equal(t, tc.rejected, rejected(err))

                })
        }
 
                })
        }
 


@@ -231,12 +322,17 @@ func (f *fakeBot) Calls() []fakeBotCall {
        return append([]fakeBotCall(nil), f.calls...)
 }
 
        return append([]fakeBotCall(nil), f.calls...)
 }
 

-// Sent returns the texts of the sendMessage calls that succeeded.
+// Sent returns the texts of the sendMessage calls and the Markdown of the
+// sendRichMessage calls that succeeded, in order.

 func (f *fakeBot) Sent() []string {
        var texts []string
        for _, call := range f.Calls() {
 func (f *fakeBot) Sent() []string {
        var texts []string
        for _, call := range f.Calls() {

-               if call.method == "sendMessage" && call.ok {
+               switch {
+               case !call.ok:
+               case call.method == "sendMessage":

                        texts = append(texts, call.params["text"].(string))
                        texts = append(texts, call.params["text"].(string))

+               case call.method == "sendRichMessage":
+                       texts = append(texts, call.params["rich_message"].(map[string]any)["markdown"].(string))

                }
        }
 
                }
        }