Check the width of comment lines

[onechat] / telegram_api_test.go

diff --git a/telegram_api_test.go b/telegram_api_test.go
index 7cdee660314dca0df947d07d02188c8f28c70172..ca112743c478b64691eaf177c79a96665402e3a4 100644 (file)
--- a/telegram_api_test.go
+++ b/telegram_api_test.go
@@ -6,6 +6,7 @@ import (
        "net/http"
        "net/http/httptest"
        "testing"
        "net/http"
        "net/http/httptest"
        "testing"

+       "testing/synctest"

        "time"
 
        "github.com/stretchr/testify/require"
        "time"
 
        "github.com/stretchr/testify/require"


@@ -28,7 +29,7 @@ func TestGetUpdatesAsksForMessagesFromTheOffset(t *testing.T) {
        require.Equal(t, "getUpdates", call.method)
        require.Equal(t, map[string]any{
                "offset":          float64(7),
        require.Equal(t, "getUpdates", call.method)
        require.Equal(t, map[string]any{
                "offset":          float64(7),

-               "timeout":         float64(telegramPollSeconds),
+               "timeout":         float64(telegramUpdateWaitTimeout / time.Second),

                "allowed_updates": []any{"message"},
        }, call.params)
 }
                "allowed_updates": []any{"message"},
        }, call.params)
 }


@@ -103,30 +104,34 @@ func TestSendCallsTimeOutOnAStalledConnection(t *testing.T) {
 
        for _, tc := range testCases {
                t.Run(tc.method, func(t *testing.T) {
 
        for _, tc := range testCases {
                t.Run(tc.method, func(t *testing.T) {

-                       server := newTelegramFake(t)
-                       server.stall = func(call TelegramFakeCall) bool {
-                               return call.method == tc.method
-                       }
-
-                       api := newTelegramAPI(server.URL, telegramTestToken)
-                       api.sendTimeout = 50 * time.Millisecond
-                       start := time.Now()
-                       err := tc.send(t.Context(), api)
-                       require.ErrorIs(t, err, errTelegramNetwork)
-                       require.Less(t, time.Since(start), 5*time.Second)
-                       require.NotContains(t, err.Error(), telegramTestToken)
-                       require.NotContains(t, err.Error(), server.URL)
+                       synctest.Test(t, func(t *testing.T) {
+                               server := newTelegramLocalFake(t)
+                               server.stall = func(call TelegramFakeCall) bool {
+                                       return call.method == tc.method
+                               }
+
+                               api := newTelegramAPI(server.URL, telegramTestToken)
+                               api.http.Transport = server
+                               start := time.Now()
+                               err := tc.send(t.Context(), api)
+                               require.EqualError(t, err, "no answer in 30s")
+                               require.Equal(t, telegramSendTimeout, time.Since(start))
+                               require.NotContains(t, err.Error(), telegramTestToken)
+                               require.NotContains(t, err.Error(), server.URL)
+
+                               retry, _ := telegramRetryable(err)
+                               require.True(t, retry)
+
+                               ctx, cancel := context.WithCancel(t.Context())
+                               defer cancel()

 
 

-                       retry, _ := telegramRetryable(err)
-                       require.True(t, retry)
+                               time.AfterFunc(time.Second, cancel)

 
 

-                       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)
+                               start = time.Now()
+                               err = tc.send(ctx, api)
+                               require.Error(t, err)
+                               require.Equal(t, time.Second, time.Since(start))
+                       })

                })
        }
 }
                })
        }
 }


@@ -149,31 +154,34 @@ func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
                                }
                        },
                        retry:     true,
                                }
                        },
                        retry:     true,

-                       errorText: "no valid answer",
+                       errorText: "no answer",

                },
                {
                        name: "rate limit waits as asked",
                        reply: func(w http.ResponseWriter) {
                                w.WriteHeader(http.StatusTooManyRequests)
                },
                {
                        name: "rate limit waits as asked",
                        reply: func(w http.ResponseWriter) {
                                w.WriteHeader(http.StatusTooManyRequests)

+

                                _, _ = io.WriteString(w, `{"ok":false,"error_code":429,"description":"Too Many Requests: retry after 3","parameters":{"retry_after":3}}`)
                        },
                        retry:     true,
                        wait:      3 * time.Second,
                                _, _ = io.WriteString(w, `{"ok":false,"error_code":429,"description":"Too Many Requests: retry after 3","parameters":{"retry_after":3}}`)
                        },
                        retry:     true,
                        wait:      3 * time.Second,

-                       errorText: "answered 429",
+                       errorText: "429",

                },
                {
                        name: "server error page is retried",
                        reply: func(w http.ResponseWriter) {
                                w.WriteHeader(http.StatusBadGateway)
                },
                {
                        name: "server error page is retried",
                        reply: func(w http.ResponseWriter) {
                                w.WriteHeader(http.StatusBadGateway)

+

                                _, _ = io.WriteString(w, "<html>bad gateway</html>")
                        },
                        retry:     true,
                                _, _ = io.WriteString(w, "<html>bad gateway</html>")
                        },
                        retry:     true,

-                       errorText: "answered 502: Bad Gateway",
+                       errorText: "502 Bad Gateway",

                },
                {
                        name: "token echoed in a description is hidden",
                        reply: func(w http.ResponseWriter) {
                                w.WriteHeader(http.StatusUnauthorized)
                },
                {
                        name: "token echoed in a description is hidden",
                        reply: func(w http.ResponseWriter) {
                                w.WriteHeader(http.StatusUnauthorized)

+

                                _, _ = io.WriteString(w, `{"ok":false,"error_code":401,"description":"Unauthorized: bot`+telegramTestToken+`"}`)
                        },
                        retry:     false,
                                _, _ = io.WriteString(w, `{"ok":false,"error_code":401,"description":"Unauthorized: bot`+telegramTestToken+`"}`)
                        },
                        retry:     false,


@@ -183,30 +191,33 @@ func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
                        name: "bad request is a refusal",
                        reply: func(w http.ResponseWriter) {
                                w.WriteHeader(http.StatusBadRequest)
                        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,
                                _, _ = 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",
+                       errorText: "400 Bad Request: can't parse",

                },
                {
                        name: "unknown method is a refusal",
                        reply: func(w http.ResponseWriter) {
                                w.WriteHeader(http.StatusNotFound)
                },
                {
                        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,
                                _, _ = io.WriteString(w, `{"ok":false,"error_code":404,"description":"Not Found"}`)
                        },
                        retry:     false,
                        rejected:  true,

-                       errorText: "answered 404: Not Found",
+                       errorText: "404 Not Found",

                },
                {
                        name: "not found page of a proxy is not a refusal",
                        reply: func(w http.ResponseWriter) {
                                w.WriteHeader(http.StatusNotFound)
                },
                {
                        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,
                                _, _ = io.WriteString(w, "<html>not found</html>")
                        },
                        retry:     false,

-                       errorText: "answered 404: Not Found",
+                       errorText: "404 Not Found",

                },
                {
                        name: "broken answer is retried",
                },
                {
                        name: "broken answer is retried",


@@ -214,13 +225,13 @@ func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
                                _, _ = io.WriteString(w, `{"ok":`)
                        },
                        retry:     true,
                                _, _ = io.WriteString(w, `{"ok":`)
                        },
                        retry:     true,

-                       errorText: "decode answer",
+                       errorText: "invalid JSON",

                },
        }
 
        for _, tc := range testCases {
                t.Run(tc.name, func(t *testing.T) {
                },
        }
 
        for _, tc := range testCases {
                t.Run(tc.name, func(t *testing.T) {

-                       server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+                       server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {

                                tc.reply(w)
                        }))
                        t.Cleanup(server.Close)
                                tc.reply(w)
                        }))
                        t.Cleanup(server.Close)


@@ -241,6 +252,6 @@ func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
        server.Close()
 
        _, err := newTelegramAPI(server.URL, telegramTestToken).GetUpdates(t.Context(), 0)
        server.Close()
 
        _, err := newTelegramAPI(server.URL, telegramTestToken).GetUpdates(t.Context(), 0)

-       require.ErrorIs(t, err, errTelegramNetwork)
+       require.ErrorAs(t, err, new(*TelegramNetworkError))

        require.NotContains(t, err.Error(), telegramTestToken)
 }
        require.NotContains(t, err.Error(), telegramTestToken)
 }