Format only the Go files of the repository

[onechat] / telegram_test.go

diff --git a/telegram_test.go b/telegram_test.go
index e360045f50341bd027b29ff631ec456ae6e1638c..2166bdfd3106adf159f0c84a8ac9eb5d5e8e65ae 100644 (file)
--- a/telegram_test.go
+++ b/telegram_test.go
@@ -1,7 +1,6 @@
 package main
 
 import (
 package main
 
 import (

-       "log"

        "net/http"
        "os"
        "path/filepath"
        "net/http"
        "os"
        "path/filepath"


@@ -76,7 +75,7 @@ func TestBotIgnoresEveryoneButTheOwner(t *testing.T) {
        require.Empty(t, telegram.Sent())
        require.NotContains(t, terminal.Output(), "secret")
        require.NotContains(t, logs.String(), "secret")
        require.Empty(t, telegram.Sent())
        require.NotContains(t, terminal.Output(), "secret")
        require.NotContains(t, logs.String(), "secret")

-       require.Contains(t, logs.String(), "message ignored")
+       require.Contains(t, logs.String(), "<6>message ignored")

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


@@ -266,8 +265,10 @@ func TestBotTriesAgainAfterFailures(t *testing.T) {
        })
 
        telegramWaitForSent(t, telegram, "ok")
        })
 
        telegramWaitForSent(t, telegram, "ok")

-       require.Contains(t, logs.String(), "502")
-       require.Contains(t, logs.String(), "429")
+       require.Contains(t, logs.String(), "<4>receive failed retry=1ms: 502")
+       require.Contains(t, logs.String(), "<6>receive back after=")
+       require.Contains(t, logs.String(), "<4>send failed retry=1s: 429")
+       require.Contains(t, logs.String(), "<6>send back after=")

        require.NotContains(t, logs.String(), telegramTestToken)
 }
 
        require.NotContains(t, logs.String(), telegramTestToken)
 }
 


@@ -292,8 +293,8 @@ func TestDeliverTriesAgainAfterATimeout(t *testing.T) {
 
        require.Equal(t, []string{"hello"}, telegram.Sent())
        require.Len(t, telegram.Calls(), 2)
 
        require.Equal(t, []string{"hello"}, telegram.Sent())
        require.Len(t, telegram.Calls(), 2)

-       require.Contains(t, logs.String(), "send failed: no answer in 50ms (retry in 1ms)\n")
-       require.Contains(t, logs.String(), "send back after ")
+       require.Contains(t, logs.String(), "<4>send failed retry=1ms: no answer in 50ms\n")
+       require.Contains(t, logs.String(), "<6>send back after=")

        require.Equal(t, 2, strings.Count(logs.String(), "\n"))
        require.NotContains(t, logs.String(), telegramTestToken)
 }
        require.Equal(t, 2, strings.Count(logs.String(), "\n"))
        require.NotContains(t, logs.String(), telegramTestToken)
 }


@@ -322,6 +323,7 @@ func TestRepliesGoAsRichMessages(t *testing.T) {
        telegramWaitForSent(t, telegram, telegramTextOnly)
 
        var sends []TelegramFakeCall
        telegramWaitForSent(t, telegram, telegramTextOnly)
 
        var sends []TelegramFakeCall

+

        for _, call := range telegram.Calls() {
                if call.method == "sendMessage" || call.method == "sendRichMessage" {
                        sends = append(sends, call)
        for _, call := range telegram.Calls() {
                if call.method == "sendMessage" || call.method == "sendRichMessage" {
                        sends = append(sends, call)


@@ -375,7 +377,7 @@ func TestRichMessageFailures(t *testing.T) {
                        methods: []string{"sendRichMessage", "sendMessage"},
                        sent:    []string{"a secret word"},
                        lines:   1,
                        methods: []string{"sendRichMessage", "sendMessage"},
                        sent:    []string{"a secret word"},
                        lines:   1,

-                       logText: "reply sent with simple formatting",
+                       logText: "<4>reply sent with simple formatting",

                },
                {
                        name:    "unknown method sends the reply once with entities",
                },
                {
                        name:    "unknown method sends the reply once with entities",


@@ -384,7 +386,7 @@ func TestRichMessageFailures(t *testing.T) {
                        methods: []string{"sendRichMessage", "sendMessage"},
                        sent:    []string{"a secret word"},
                        lines:   1,
                        methods: []string{"sendRichMessage", "sendMessage"},
                        sent:    []string{"a secret word"},
                        lines:   1,

-                       logText: "reply sent with simple formatting",
+                       logText: "<4>reply sent with simple formatting",

                },
                {
                        name:    "rate limit tries the rich message again",
                },
                {
                        name:    "rate limit tries the rich message again",


@@ -392,7 +394,7 @@ func TestRichMessageFailures(t *testing.T) {
                        methods: []string{"sendRichMessage", "sendRichMessage"},
                        sent:    []string{"a **secret** word"},
                        lines:   2,
                        methods: []string{"sendRichMessage", "sendRichMessage"},
                        sent:    []string{"a **secret** word"},
                        lines:   2,

-                       logText: "send failed: 429",
+                       logText: "<4>send failed retry=1s: 429",

                },
                {
                        name:    "server error tries the rich message again",
                },
                {
                        name:    "server error tries the rich message again",


@@ -400,7 +402,7 @@ func TestRichMessageFailures(t *testing.T) {
                        methods: []string{"sendRichMessage", "sendRichMessage"},
                        sent:    []string{"a **secret** word"},
                        lines:   2,
                        methods: []string{"sendRichMessage", "sendRichMessage"},
                        sent:    []string{"a **secret** word"},
                        lines:   2,

-                       logText: "send failed: 500",
+                       logText: "<4>send failed retry=1ms: 500",

                },
                {
                        name:    "other refusal drops the reply",
                },
                {
                        name:    "other refusal drops the reply",


@@ -408,7 +410,7 @@ func TestRichMessageFailures(t *testing.T) {
                        always:  true,
                        methods: []string{"sendRichMessage"},
                        lines:   1,
                        always:  true,
                        methods: []string{"sendRichMessage"},
                        lines:   1,

-                       logText: "reply lost: 403",
+                       logText: "<3>reply lost: 403",

                },
        }
 
                },
        }
 


@@ -433,6 +435,7 @@ func TestRichMessageFailures(t *testing.T) {
                        })
 
                        var methods []string
                        })
 
                        var methods []string

+

                        for _, call := range telegram.Calls() {
                                methods = append(methods, call.method)
                        }
                        for _, call := range telegram.Calls() {
                                methods = append(methods, call.method)
                        }


@@ -441,6 +444,11 @@ func TestRichMessageFailures(t *testing.T) {
                        require.Equal(t, tc.sent, telegram.Sent())
                        require.Equal(t, tc.lines, strings.Count(logs.String(), "\n"))
                        require.Contains(t, logs.String(), tc.logText)
                        require.Equal(t, tc.sent, telegram.Sent())
                        require.Equal(t, tc.lines, strings.Count(logs.String(), "\n"))
                        require.Contains(t, logs.String(), tc.logText)

+
+                       if tc.lines == 2 {
+                               require.Contains(t, logs.String(), "<6>send back after=")
+                       }
+

                        require.NotContains(t, logs.String(), telegramTestToken)
                        require.NotContains(t, logs.String(), "secret word")
 
                        require.NotContains(t, logs.String(), telegramTestToken)
                        require.NotContains(t, logs.String(), "secret word")
 


@@ -551,6 +559,7 @@ func TestRefusedRichPartGoesWithTheTextAsWritten(t *testing.T) {
        })
 
        var fallback, rich []string
        })
 
        var fallback, rich []string

+

        for _, call := range telegram.Calls() {
                switch {
                case !call.ok:
        for _, call := range telegram.Calls() {
                switch {
                case !call.ok:


@@ -595,11 +604,27 @@ func TestRefusedEntitiesGoAgainAsPlainText(t *testing.T) {
        require.Nil(t, calls[1].params["entities"])
        require.Equal(t, []string{"a secret word"}, telegram.Sent())
        require.Equal(t, 1, strings.Count(logs.String(), "\n"))
        require.Nil(t, calls[1].params["entities"])
        require.Equal(t, []string{"a secret word"}, telegram.Sent())
        require.Equal(t, 1, strings.Count(logs.String(), "\n"))

-       require.Contains(t, logs.String(), "reply sent as plain text")
+       require.Contains(t, logs.String(), "<4>reply sent as plain text")

        require.NotContains(t, logs.String(), telegramTestToken)
        require.NotContains(t, logs.String(), "secret word")
 }
 
        require.NotContains(t, logs.String(), telegramTestToken)
        require.NotContains(t, logs.String(), "secret word")
 }
 

+func TestBotLogsALostPlainReplyAsAnError(t *testing.T) {
+       telegram := newTelegramFake(t)
+       telegram.fail = func(call TelegramFakeCall) (int, string) {
+               if call.method == "sendMessage" {
+                       return http.StatusForbidden, "Forbidden"
+               }
+
+               return 0, ""
+       }
+
+       bot, logs := telegramStartTestBot(t, telegram)
+       bot.deliver(t.Context(), TelegramPart{text: "secret reply"})
+       require.Equal(t, "<3>reply lost: 403 Forbidden\n", logs.String())
+       require.Empty(t, telegram.Sent())
+}
+

 func TestBotLogsNoTokenWhenTheNetworkFails(t *testing.T) {
        telegram := newTelegramFake(t)
        telegram.Close()
 func TestBotLogsNoTokenWhenTheNetworkFails(t *testing.T) {
        telegram := newTelegramFake(t)
        telegram.Close()


@@ -608,7 +633,7 @@ func TestBotLogsNoTokenWhenTheNetworkFails(t *testing.T) {
        daemonStartTestWithBot(t, newModelFake(t), bot)
 
        require.Eventually(t, func() bool {
        daemonStartTestWithBot(t, newModelFake(t), bot)
 
        require.Eventually(t, func() bool {

-               return strings.Contains(logs.String(), "receive failed: no answer: ")
+               return strings.Contains(logs.String(), "<4>receive failed retry=1ms: no answer: ")

        }, 10*time.Second, time.Millisecond)
        require.NotContains(t, logs.String(), telegramTestToken)
 }
        }, 10*time.Second, time.Millisecond)
        require.NotContains(t, logs.String(), telegramTestToken)
 }


@@ -640,10 +665,11 @@ func TestBotLogsAnOutageOnlyAtItsStartAndEnd(t *testing.T) {
        })
 
        telegramWaitForSent(t, telegram, "ok")
        })
 
        telegramWaitForSent(t, telegram, "ok")

+

        lines := strings.Split(strings.TrimSuffix(logs.String(), "\n"), "\n")
        require.Len(t, lines, 2)
        lines := strings.Split(strings.TrimSuffix(logs.String(), "\n"), "\n")
        require.Len(t, lines, 2)

-       require.Equal(t, "receive failed: 502 Bad Gateway (retry in 1ms)", lines[0])
-       require.Regexp(t, `^receive back after [0-9]+m?s$`, lines[1])
+       require.Equal(t, "<4>receive failed retry=1ms: 502 Bad Gateway", lines[0])
+       require.Regexp(t, `^<6>receive back after=[0-9]+m?s$`, lines[1])

        require.NotContains(t, logs.String(), "secret word")
        require.NotContains(t, logs.String(), strconv.FormatInt(telegramTestOwner, 10))
 }
        require.NotContains(t, logs.String(), "secret word")
        require.NotContains(t, logs.String(), strconv.FormatInt(telegramTestOwner, 10))
 }


@@ -880,7 +906,7 @@ func telegramStartTestBot(t *testing.T, server *TelegramFake) (*TelegramBot, *Sy
        t.Helper()
 
        logs := &SyncBuffer{}
        t.Helper()
 
        logs := &SyncBuffer{}

-       bot := newTelegramBot(newTelegramAPI(server.URL, telegramTestToken), telegramTestOwner, filepath.Join(t.TempDir(), telegramOffsetFileName), log.New(logs, "", 0))
+       bot := newTelegramBot(newTelegramAPI(server.URL, telegramTestToken), telegramTestOwner, filepath.Join(t.TempDir(), telegramOffsetFileName), daemonTestLogger(logs))

        bot.minWait = time.Millisecond
        bot.maxWait = 10 * time.Millisecond
 
        bot.minWait = time.Millisecond
        bot.maxWait = 10 * time.Millisecond