Debian Codegraph @

pkg/services/chat/slack/slack_test.go

raw
1 package slack_test
2
3 import (
4 "errors"
5 "fmt"
6 "log"
7 "net/url"
8 "os"
9 "strings"
10 "testing"
11
12 "github.com/jarcoal/httpmock"
13 "github.com/onsi/ginkgo/v2"
14 "github.com/onsi/gomega"
15 "github.com/onsi/gomega/format"
16
17 "github.com/nicholas-fedor/shoutrrr/internal/testutils"
18 "github.com/nicholas-fedor/shoutrrr/pkg/services/chat/slack"
19 )
20
21 const (
22 TestWebhookURL = "https://hooks.slack.com/services/AAAAAAAAA/BBBBBBBBB/123456789123456789123456"
23 )
24
25 var (
26 service *slack.Service
27 envSlackURL *url.URL
28 logger *log.Logger
29 _ = ginkgo.BeforeSuite(func() {
30 service = &slack.Service{}
31 logger = log.New(ginkgo.GinkgoWriter, "Test", log.LstdFlags)
32 envSlackURL, _ = url.Parse(os.Getenv("SHOUTRRR_SLACK_URL"))
33 })
34 )
35
36 var _ = ginkgo.Describe("the slack service", func() {
37 ginkgo.When("running integration tests", func() {
38 ginkgo.It("should not error out", func() {
39 if envSlackURL.String() == "" {
40 return
41 }
42
43 serviceURL, _ := url.Parse(envSlackURL.String())
44 err := service.Initialize(serviceURL, testutils.TestLogger())
45 gomega.Expect(err).NotTo(gomega.HaveOccurred())
46
47 err = service.Send("This is an integration test message", nil)
48 gomega.Expect(err).NotTo(gomega.HaveOccurred())
49 })
50 ginkgo.It("returns the correct service identifier", func() {
51 gomega.Expect(service.GetID()).To(gomega.Equal("slack"))
52 })
53 })
54
55 // xoxb:123456789012-1234567890123-4mt0t4l1YL3g1T5L4cK70k3N
56
57 ginkgo.When("given a token with a malformed part", func() {
58 ginkgo.It("should return an error if part A is not 9 letters", func() {
59 expectErrorMessageGivenURL(
60 slack.ErrInvalidToken,
61 "slack://lol@12345678/123456789/123456789123456789123456",
62 )
63 })
64 ginkgo.It("should return an error if part B is not 9 letters", func() {
65 expectErrorMessageGivenURL(
66 slack.ErrInvalidToken,
67 "slack://lol@123456789/12345678/123456789123456789123456",
68 )
69 })
70 ginkgo.It("should return an error if part C is not 24 letters", func() {
71 expectErrorMessageGivenURL(
72 slack.ErrInvalidToken,
73 "slack://123456789/123456789/12345678912345678912345",
74 )
75 })
76 })
77 ginkgo.When("given a token missing a part", func() {
78 ginkgo.It("should return an error if the missing part is A", func() {
79 expectErrorMessageGivenURL(
80 slack.ErrInvalidToken,
81 "slack://lol@/123456789/123456789123456789123456",
82 )
83 })
84 ginkgo.It("should return an error if the missing part is B", func() {
85 expectErrorMessageGivenURL(slack.ErrInvalidToken, "slack://lol@123456789//123456789")
86 })
87 ginkgo.It("should return an error if the missing part is C", func() {
88 expectErrorMessageGivenURL(slack.ErrInvalidToken, "slack://lol@123456789/123456789/")
89 })
90 })
91 ginkgo.Describe("the slack config", func() {
92 ginkgo.When("parsing the configuration URL", func() {
93 ginkgo.When("given a config using the legacy format", func() {
94 ginkgo.It("should be converted to the new format after de-/serialization", func() {
95 oldURL := "slack://testbot@AAAAAAAAA/BBBBBBBBB/123456789123456789123456?color=3f00fe&title=Test+title"
96 newURL := "slack://hook:AAAAAAAAA-BBBBBBBBB-123456789123456789123456@webhook?botname=testbot&color=3f00fe&title=Test+title"
97
98 config := &slack.Config{}
99 err := config.SetURL(testutils.URLMust(oldURL))
100 gomega.Expect(err).NotTo(gomega.HaveOccurred(), "verifying")
101
102 gomega.Expect(config.GetURL().String()).To(gomega.Equal(newURL))
103 })
104 })
105 })
106 ginkgo.When("the URL contains an invalid property", func() {
107 testURL := testutils.URLMust(
108 "slack://hook:AAAAAAAAA-BBBBBBBBB-123456789123456789123456@webhook?bass=dirty",
109 )
110 err := (&slack.Config{}).SetURL(testURL)
111 gomega.Expect(err).To(gomega.HaveOccurred())
112 })
113 ginkgo.It("should be identical after de-/serialization", func() {
114 testURL := "slack://hook:AAAAAAAAA-BBBBBBBBB-123456789123456789123456@webhook?botname=testbot&color=3f00fe&title=Test+title"
115
116 config := &slack.Config{}
117 err := config.SetURL(testutils.URLMust(testURL))
118 gomega.Expect(err).NotTo(gomega.HaveOccurred(), "verifying")
119
120 outputURL := config.GetURL()
121 gomega.Expect(outputURL.String()).To(gomega.Equal(testURL))
122 })
123 ginkgo.When("generating a config object", func() {
124 ginkgo.It(
125 "should use the default botname if the argument list contains three strings",
126 func() {
127 slackURL, _ := url.Parse("slack://AAAAAAAAA/BBBBBBBBB/123456789123456789123456")
128 config, configError := slack.CreateConfigFromURL(slackURL)
129
130 gomega.Expect(configError).NotTo(gomega.HaveOccurred())
131 gomega.Expect(config.BotName).To(gomega.BeEmpty())
132 },
133 )
134 ginkgo.It("should set the botname if the argument list is three", func() {
135 slackURL, _ := url.Parse(
136 "slack://testbot@AAAAAAAAA/BBBBBBBBB/123456789123456789123456",
137 )
138 config, configError := slack.CreateConfigFromURL(slackURL)
139
140 gomega.Expect(configError).NotTo(gomega.HaveOccurred())
141 gomega.Expect(config.BotName).To(gomega.Equal("testbot"))
142 })
143 ginkgo.It("should return an error if the argument list is shorter than three", func() {
144 slackURL, _ := url.Parse("slack://AAAAAAAA")
145
146 _, configError := slack.CreateConfigFromURL(slackURL)
147 gomega.Expect(configError).To(gomega.HaveOccurred())
148 })
149 })
150 ginkgo.When("getting credentials from token", func() {
151 ginkgo.It("should return a valid webhook URL for the given token", func() {
152 token := tokenMust("AAAAAAAAA/BBBBBBBBB/123456789123456789123456")
153 gomega.Expect(token.WebhookURL()).To(gomega.Equal(TestWebhookURL))
154 })
155 ginkgo.It(
156 "should return a valid authorization header value for the given token",
157 func() {
158 token := tokenMust("xoxb:AAAAAAAAA-BBBBBBBBB-123456789123456789123456")
159 expected := "Bearer xoxb-AAAAAAAAA-BBBBBBBBB-123456789123456789123456"
160 gomega.Expect(token.Authorization()).To(gomega.Equal(expected))
161 },
162 )
163 })
164 })
165
166 ginkgo.Describe("creating the payload", func() {
167 ginkgo.Describe("the icon fields", func() {
168 payload := slack.MessagePayload{}
169
170 ginkgo.It("should set IconURL when the configured icon looks like an URL", func() {
171 payload.SetIcon("https://example.com/logo.png")
172 gomega.Expect(payload.IconURL).To(gomega.Equal("https://example.com/logo.png"))
173 gomega.Expect(payload.IconEmoji).To(gomega.BeEmpty())
174 })
175 ginkgo.It(
176 "should set IconEmoji when the configured icon does not look like an URL",
177 func() {
178 payload.SetIcon("tanabata_tree")
179 gomega.Expect(payload.IconEmoji).To(gomega.Equal("tanabata_tree"))
180 gomega.Expect(payload.IconURL).To(gomega.BeEmpty())
181 },
182 )
183 ginkgo.It("should clear both fields when icon is empty", func() {
184 payload.SetIcon("")
185 gomega.Expect(payload.IconEmoji).To(gomega.BeEmpty())
186 gomega.Expect(payload.IconURL).To(gomega.BeEmpty())
187 })
188 })
189 ginkgo.When("when more than 99 lines are being sent", func() {
190 ginkgo.It("should append the exceeding lines to the last attachment", func() {
191 config := slack.Config{}
192
193 sb := strings.Builder{}
194 for i := 1; i <= 110; i++ {
195 fmt.Fprintf(&sb, "Line %d\n", i)
196 }
197
198 payload := slack.CreateJSONPayload(&config, sb.String()).(slack.MessagePayload)
199 atts := payload.Attachments
200
201 _, _ = fmt.Fprint(
202 ginkgo.GinkgoWriter,
203 "\nLines: ",
204 len(atts),
205 " Last: ",
206 atts[len(atts)-1],
207 "\n",
208 )
209
210 gomega.Expect(atts).To(gomega.HaveLen(100))
211 gomega.Expect(atts[len(atts)-1].Text).To(gomega.ContainSubstring("Line 110"))
212 })
213 })
214 ginkgo.When("when the last message line ends with a newline", func() {
215 ginkgo.It("should not send an empty attachment", func() {
216 payload := slack.CreateJSONPayload(&slack.Config{}, "One\nTwo\nThree\n").(slack.MessagePayload)
217 atts := payload.Attachments
218 gomega.Expect(atts[len(atts)-1].Text).NotTo(gomega.BeEmpty())
219 })
220 })
221 })
222
223 ginkgo.Describe("sending the payload", func() {
224 ginkgo.When("sending via webhook URL", func() {
225 var err error
226
227 ginkgo.BeforeEach(func() {
228 httpmock.Activate()
229 })
230 ginkgo.AfterEach(func() {
231 httpmock.DeactivateAndReset()
232 })
233
234 ginkgo.It("should not report an error if the server accepts the payload", func() {
235 serviceURL, _ := url.Parse(
236 "slack://testbot@AAAAAAAAA/BBBBBBBBB/123456789123456789123456",
237 )
238 err = service.Initialize(serviceURL, logger)
239 gomega.Expect(err).NotTo(gomega.HaveOccurred())
240
241 httpmock.RegisterResponder(
242 "POST",
243 TestWebhookURL,
244 httpmock.NewStringResponder(200, ""),
245 )
246
247 err = service.Send("Message", nil)
248 gomega.Expect(err).NotTo(gomega.HaveOccurred())
249 })
250 ginkgo.It("should not panic if an error occurs when sending the payload", func() {
251 serviceURL, _ := url.Parse(
252 "slack://testbot@AAAAAAAAA/BBBBBBBBB/123456789123456789123456",
253 )
254 err = service.Initialize(serviceURL, logger)
255 gomega.Expect(err).NotTo(gomega.HaveOccurred())
256
257 httpmock.RegisterResponder(
258 "POST",
259 TestWebhookURL,
260 httpmock.NewErrorResponder(errors.New("dummy error")),
261 )
262
263 err = service.Send("Message", nil)
264 gomega.Expect(err).To(gomega.HaveOccurred())
265 })
266 })
267 ginkgo.When("sending via bot API", func() {
268 var err error
269
270 ginkgo.BeforeEach(func() {
271 httpmock.Activate()
272 })
273 ginkgo.AfterEach(func() {
274 httpmock.DeactivateAndReset()
275 })
276
277 ginkgo.It("should not report an error if the server accepts the payload", func() {
278 serviceURL := testutils.URLMust(
279 "slack://xoxb:123456789012-1234567890123-4mt0t4l1YL3g1T5L4cK70k3N@C0123456789",
280 )
281 err = service.Initialize(serviceURL, logger)
282 gomega.Expect(err).NotTo(gomega.HaveOccurred())
283
284 targetURL := "https://slack.com/api/chat.postMessage"
285 httpmock.RegisterResponder(
286 "POST",
287 targetURL,
288 testutils.JSONRespondMust(200, slack.APIResponse{
289 Ok: true,
290 }),
291 )
292
293 err = service.Send("Message", nil)
294 gomega.Expect(err).NotTo(gomega.HaveOccurred())
295 })
296 ginkgo.It("should not panic if an error occurs when sending the payload", func() {
297 serviceURL := testutils.URLMust(
298 "slack://xoxb:123456789012-1234567890123-4mt0t4l1YL3g1T5L4cK70k3N@C0123456789",
299 )
300 err = service.Initialize(serviceURL, logger)
301 gomega.Expect(err).NotTo(gomega.HaveOccurred())
302
303 targetURL := "https://slack.com/api/chat.postMessage"
304 httpmock.RegisterResponder(
305 "POST",
306 targetURL,
307 testutils.JSONRespondMust(200, slack.APIResponse{
308 Error: "someone turned off the internet",
309 }),
310 )
311
312 err = service.Send("Message", nil)
313 gomega.Expect(err).To(gomega.HaveOccurred())
314 })
315 })
316 })
317 })
318
319 func TestSlack(t *testing.T) {
320 t.Parallel()
321
322 format.CharactersAroundMismatchToInclude = 20
323
324 gomega.RegisterFailHandler(ginkgo.Fail)
325 ginkgo.RunSpecs(t, "Shoutrrr Slack Suite")
326 }
327
328 func tokenMust(rawToken string) *slack.Token {
329 token, err := slack.ParseToken(rawToken)
330 gomega.ExpectWithOffset(1, err).NotTo(gomega.HaveOccurred())
331
332 return token
333 }
334
335 func expectErrorMessageGivenURL(expected error, rawURL string) {
336 err := service.Initialize(testutils.URLMust(rawURL), testutils.TestLogger())
337 gomega.ExpectWithOffset(1, err).To(gomega.HaveOccurred())
338 gomega.ExpectWithOffset(1, err).To(gomega.Equal(expected))
339 }