Debian Codegraph @

pkg/services/chat/telegram/telegram_test.go

raw
1 package telegram
2
3 import (
4 "fmt"
5 "log"
6 "net/url"
7 "os"
8 "strings"
9 "testing"
10
11 "github.com/jarcoal/httpmock"
12 "github.com/onsi/ginkgo/v2"
13 "github.com/onsi/gomega"
14
15 "github.com/nicholas-fedor/shoutrrr/internal/testutils"
16 )
17
18 var (
19 envTelegramURL string
20 logger *log.Logger
21
22 _ = ginkgo.BeforeSuite(func() {
23 envTelegramURL = os.Getenv("SHOUTRRR_TELEGRAM_URL")
24 logger = log.New(ginkgo.GinkgoWriter, "Test", log.LstdFlags)
25 })
26 )
27
28 var _ = ginkgo.Describe("the telegram service", func() {
29 var telegram *Service // No telegram. prefix needed
30
31 ginkgo.BeforeEach(func() {
32 telegram = &Service{}
33 })
34
35 ginkgo.When("running integration tests", func() {
36 ginkgo.It("should not error out", func() {
37 if envTelegramURL == "" {
38 return
39 }
40
41 serviceURL, _ := url.Parse(envTelegramURL)
42 err := telegram.Initialize(serviceURL, logger)
43 gomega.Expect(err).NotTo(gomega.HaveOccurred())
44 err = telegram.Send("This is an integration test Message", nil)
45 gomega.Expect(err).NotTo(gomega.HaveOccurred())
46 })
47 ginkgo.When("given a Message that exceeds the max length", func() {
48 ginkgo.It("should generate an error", func() {
49 if envTelegramURL == "" {
50 return
51 }
52
53 hundredChars := "this string is exactly (to the letter) a hundred characters long which will make the send func error"
54 serviceURL, _ := url.Parse("telegram://12345:mock-token@telegram/?chats=channel-1")
55
56 builder := strings.Builder{}
57 for range 42 {
58 builder.WriteString(hundredChars)
59 }
60
61 err := telegram.Initialize(serviceURL, logger)
62 gomega.Expect(err).NotTo(gomega.HaveOccurred())
63 err = telegram.Send(builder.String(), nil)
64 gomega.Expect(err).To(gomega.HaveOccurred())
65 })
66 })
67 ginkgo.When("given a valid request with a faked token", func() {
68 if envTelegramURL == "" {
69 return
70 }
71
72 ginkgo.It("should generate a 401", func() {
73 serviceURL, _ := url.Parse(
74 "telegram://000000000:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA@telegram/?chats=channel-id",
75 )
76 message := "this is a perfectly valid Message"
77
78 err := telegram.Initialize(serviceURL, logger)
79 gomega.Expect(err).NotTo(gomega.HaveOccurred())
80 err = telegram.Send(message, nil)
81 gomega.Expect(err).To(gomega.HaveOccurred())
82 gomega.Expect(strings.Contains(err.Error(), "401 Unauthorized")).To(gomega.BeTrue())
83 })
84 })
85 })
86
87 ginkgo.Describe("creating configurations", func() {
88 ginkgo.When("given an url", func() {
89 ginkgo.It("should return an error if no arguments where supplied", func() {
90 expectErrorAndEmptyObject(telegram, "telegram://", logger)
91 })
92 ginkgo.It("should return an error if the token has an invalid format", func() {
93 expectErrorAndEmptyObject(telegram, "telegram://invalid-token", logger)
94 })
95 ginkgo.It("should return an error if only the api token where supplied", func() {
96 expectErrorAndEmptyObject(telegram, "telegram://12345:mock-token@telegram", logger)
97 })
98
99 ginkgo.When("the url is valid", func() {
100 var config *Config // No telegram. prefix
101
102 var err error
103
104 ginkgo.BeforeEach(func() {
105 serviceURL, _ := url.Parse(
106 "telegram://12345:mock-token@telegram/?chats=channel-1,channel-2,channel-3",
107 )
108 err = telegram.Initialize(serviceURL, logger)
109 config = telegram.GetConfig()
110 })
111
112 ginkgo.It("should create a config object", func() {
113 gomega.Expect(err).NotTo(gomega.HaveOccurred())
114 gomega.Expect(config).ToNot(gomega.BeNil())
115 })
116 ginkgo.It("should create a config object containing the API Token", func() {
117 gomega.Expect(err).NotTo(gomega.HaveOccurred())
118 gomega.Expect(config.Token).To(gomega.Equal("12345:mock-token"))
119 })
120 ginkgo.It("should add every chats query field as a chat ID", func() {
121 gomega.Expect(err).NotTo(gomega.HaveOccurred())
122 gomega.Expect(config.Chats).To(gomega.Equal([]string{
123 "channel-1",
124 "channel-2",
125 "channel-3",
126 }))
127 })
128 })
129 })
130 })
131
132 ginkgo.Describe("sending the payload", func() {
133 var err error
134
135 ginkgo.BeforeEach(func() {
136 httpmock.Activate()
137 })
138 ginkgo.AfterEach(func() {
139 httpmock.DeactivateAndReset()
140 })
141 ginkgo.It("should not report an error if the server accepts the payload", func() {
142 serviceURL, _ := url.Parse(
143 "telegram://12345:mock-token@telegram/?chats=channel-1,channel-2,channel-3",
144 )
145 err = telegram.Initialize(serviceURL, logger)
146 gomega.Expect(err).NotTo(gomega.HaveOccurred())
147
148 setupResponder("sendMessage", telegram.GetConfig().Token, 200, "")
149
150 err = telegram.Send("Message", nil)
151 gomega.Expect(err).NotTo(gomega.HaveOccurred())
152 })
153 })
154
155 ginkgo.It("should implement basic service API methods correctly", func() {
156 serviceURL, _ := url.Parse("telegram://12345:mock-token@telegram/?chats=channel-1")
157 err := telegram.Initialize(serviceURL, logger)
158 gomega.Expect(err).NotTo(gomega.HaveOccurred())
159
160 config := telegram.GetConfig()
161 testutils.TestConfigGetInvalidQueryValue(config)
162 testutils.TestConfigSetInvalidQueryValue(
163 config,
164 "telegram://12345:mock-token@telegram/?chats=channel-1&foo=bar",
165 )
166 testutils.TestConfigGetEnumsCount(config, 1)
167 testutils.TestConfigGetFieldsCount(config, 6)
168 })
169 ginkgo.It("should return the correct service ID", func() {
170 service := &Service{}
171 gomega.Expect(service.GetID()).To(gomega.Equal("telegram"))
172 })
173 })
174
175 func TestTelegram(t *testing.T) {
176 t.Parallel()
177 gomega.RegisterFailHandler(ginkgo.Fail)
178 ginkgo.RunSpecs(t, "Shoutrrr Telegram Suite")
179 }
180
181 func expectErrorAndEmptyObject(telegram *Service, rawURL string, logger *log.Logger) {
182 serviceURL, _ := url.Parse(rawURL)
183 err := telegram.Initialize(serviceURL, logger)
184 gomega.Expect(err).To(gomega.HaveOccurred())
185
186 config := telegram.GetConfig()
187 gomega.Expect(config.Token).To(gomega.BeEmpty())
188 gomega.Expect(config.Chats).To(gomega.BeEmpty())
189 }
190
191 func setupResponder(endpoint, token string, code int, body string) {
192 targetURL := fmt.Sprintf("https://api.telegram.org/bot%s/%s", token, endpoint)
193 httpmock.RegisterResponder("POST", targetURL, httpmock.NewStringResponder(code, body))
194 }