Keep time limits with their operations

[onechat] / telegram_api_test.go

diff --git a/telegram_api_test.go b/telegram_api_test.go
index 98aa232a9539894007921f177c3622c81a88462d..6fa4cba18179bd048ba21c45961cae910e22b9f4 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"


@@ -103,31 +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.EqualError(t, err, "no answer in 50ms")
-                       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)

 
 

-                       retry, _ := telegramRetryable(err)
-                       require.True(t, retry)
+                               ctx, cancel := context.WithCancel(t.Context())
+                               defer cancel()

 
 

-                       api.sendTimeout = time.Hour
-                       ctx, cancel := context.WithCancel(t.Context())
-                       time.AfterFunc(50*time.Millisecond, cancel)
+                               time.AfterFunc(time.Second, 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))
+                       })

                })
        }
 }
                })
        }
 }