Debian Codegraph @

pkg/services/specialized/generic/generic_test.go

raw
1 package generic_test
2
3 import (
4 "errors"
5 "io"
6 "log"
7 "net/http"
8 "net/url"
9 "os"
10 "testing"
11
12 "github.com/jarcoal/httpmock"
13 "github.com/onsi/ginkgo/v2"
14 "github.com/onsi/gomega"
15
16 "github.com/nicholas-fedor/shoutrrr/internal/testutils"
17 "github.com/nicholas-fedor/shoutrrr/pkg/services/specialized/generic"
18 "github.com/nicholas-fedor/shoutrrr/pkg/types"
19 )
20
21 // Test constants.
22 const (
23 TestWebhookURL = "https://host.tld/webhook" // Default test webhook URL
24 )
25
26 var (
27 service *generic.Service
28 logger *log.Logger
29 envGenericURL *url.URL
30 _ = ginkgo.BeforeSuite(func() {
31 service = &generic.Service{}
32 logger = log.New(ginkgo.GinkgoWriter, "Test", log.LstdFlags)
33
34 var err error
35
36 envGenericURL, err = url.Parse(os.Getenv("SHOUTRRR_GENERIC_URL"))
37 if err != nil {
38 envGenericURL = &url.URL{} // Default to empty URL if parsing fails
39 }
40 })
41 )
42
43 var _ = ginkgo.Describe("the generic service", func() {
44 ginkgo.When("running integration tests", func() {
45 ginkgo.It("sends a message successfully with a valid ENV URL", func() {
46 if envGenericURL.String() == "" {
47 ginkgo.Skip("No integration test ENV URL was set")
48
49 return
50 }
51
52 serviceURL := testutils.URLMust(envGenericURL.String())
53 err := service.Initialize(serviceURL, testutils.TestLogger())
54 gomega.Expect(err).NotTo(gomega.HaveOccurred())
55 err = service.Send("This is an integration test message", nil)
56 gomega.Expect(err).NotTo(gomega.HaveOccurred())
57 })
58 })
59
60 ginkgo.Describe("the service", func() {
61 ginkgo.BeforeEach(func() {
62 service = &generic.Service{}
63 service.SetLogger(logger)
64 })
65 ginkgo.It("returns the correct service identifier", func() {
66 gomega.Expect(service.GetID()).To(gomega.Equal("generic"))
67 })
68 })
69
70 ginkgo.When("parsing a custom URL", func() {
71 ginkgo.BeforeEach(func() {
72 service = &generic.Service{}
73 service.SetLogger(logger)
74 })
75 ginkgo.It("correctly sets webhook URL from custom URL", func() {
76 customURL := testutils.URLMust("generic+https://test.tld")
77 serviceURL, err := service.GetServiceURLFromCustom(customURL)
78 gomega.Expect(err).NotTo(gomega.HaveOccurred())
79 err = service.Initialize(serviceURL, logger)
80 gomega.Expect(err).NotTo(gomega.HaveOccurred())
81 gomega.Expect(service.Config.WebhookURL().String()).To(gomega.Equal("https://test.tld"))
82 })
83
84 ginkgo.When("a HTTP URL is provided via query parameter", func() {
85 ginkgo.It("disables TLS", func() {
86 config := &generic.Config{}
87 err := config.SetURL(testutils.URLMust("generic://example.com?disabletls=yes"))
88 gomega.Expect(err).NotTo(gomega.HaveOccurred())
89 gomega.Expect(config.DisableTLS).To(gomega.BeTrue())
90 })
91 })
92 ginkgo.When("a HTTPS URL is provided", func() {
93 ginkgo.It("enables TLS", func() {
94 config := &generic.Config{}
95 err := config.SetURL(testutils.URLMust("generic://example.com"))
96 gomega.Expect(err).NotTo(gomega.HaveOccurred())
97 gomega.Expect(config.DisableTLS).To(gomega.BeFalse())
98 })
99 })
100 ginkgo.It("escapes conflicting custom query keys", func() {
101 serviceURL := testutils.URLMust("generic://example.com/?__template=passed")
102 err := service.Initialize(serviceURL, logger)
103 gomega.Expect(err).NotTo(gomega.HaveOccurred())
104 gomega.Expect(service.Config.Template).NotTo(gomega.Equal("passed"))
105 whURL := service.Config.WebhookURL().String()
106 gomega.Expect(whURL).To(gomega.Equal("https://example.com/?template=passed"))
107 gomega.Expect(service.Config.GetURL().String()).To(gomega.Equal(serviceURL.String()))
108 })
109 ginkgo.It("handles both escaped and service prop versions of keys", func() {
110 serviceURL := testutils.URLMust(
111 "generic://example.com/?__template=passed&template=captured",
112 )
113 err := service.Initialize(serviceURL, logger)
114 gomega.Expect(err).NotTo(gomega.HaveOccurred())
115 gomega.Expect(service.Config.Template).To(gomega.Equal("captured"))
116 whURL := service.Config.WebhookURL().String()
117 gomega.Expect(whURL).To(gomega.Equal("https://example.com/?template=passed"))
118 })
119 })
120
121 ginkgo.When("retrieving the webhook URL", func() {
122 ginkgo.BeforeEach(func() {
123 service = &generic.Service{}
124 service.SetLogger(logger)
125 })
126 ginkgo.It("builds a valid webhook URL", func() {
127 serviceURL := testutils.URLMust("generic://example.com/path?foo=bar")
128 err := service.Initialize(serviceURL, logger)
129 gomega.Expect(err).NotTo(gomega.HaveOccurred())
130 gomega.Expect(service.Config.WebhookURL().String()).
131 To(gomega.Equal("https://example.com/path?foo=bar"))
132 })
133
134 ginkgo.When("TLS is disabled", func() {
135 ginkgo.It("uses http scheme", func() {
136 serviceURL := testutils.URLMust("generic://test.tld?disabletls=yes")
137 err := service.Initialize(serviceURL, logger)
138 gomega.Expect(err).NotTo(gomega.HaveOccurred())
139 gomega.Expect(service.Config.WebhookURL().Scheme).To(gomega.Equal("http"))
140 })
141 })
142 ginkgo.When("TLS is not disabled", func() {
143 ginkgo.It("uses https scheme", func() {
144 serviceURL := testutils.URLMust("generic://test.tld")
145 err := service.Initialize(serviceURL, logger)
146 gomega.Expect(err).NotTo(gomega.HaveOccurred())
147 gomega.Expect(service.Config.WebhookURL().Scheme).To(gomega.Equal("https"))
148 })
149 })
150 })
151
152 ginkgo.Describe("the generic config", func() {
153 ginkgo.When("parsing the configuration URL", func() {
154 ginkgo.It("is identical after de-/serialization", func() {
155 testURL := "generic://user:[email protected]/api/v1/webhook?$context=inside-joke&@Authorization=frend&__title=w&contenttype=a%2Fb&template=f&title=t"
156 expectedURL := "generic://user:[email protected]/api/v1/webhook?%24context=inside-joke&%40Authorization=frend&__title=w&contenttype=a%2Fb&template=f&title=t"
157 serviceURL := testutils.URLMust(testURL)
158 err := service.Initialize(serviceURL, logger)
159 gomega.Expect(err).NotTo(gomega.HaveOccurred())
160 gomega.Expect(service.Config.GetURL().String()).To(gomega.Equal(expectedURL))
161 })
162 })
163 ginkgo.When("parsing from webhook URL", func() {
164 ginkgo.It("sets config properties from webhook URL query parameters", func() {
165 webhookURL := testutils.URLMust(
166 "https://example.com/webhook?template=json&contenttype=application/json&method=POST&titlekey=customtitle&messagekey=custommessage&extra=param",
167 )
168
169 config, _, err := generic.ConfigFromWebhookURL(webhookURL)
170 gomega.Expect(err).NotTo(gomega.HaveOccurred())
171
172 // Verify config properties are set correctly
173 gomega.Expect(config.Template).To(gomega.Equal("json"))
174 gomega.Expect(config.ContentType).To(gomega.Equal("application/json"))
175 gomega.Expect(config.RequestMethod).To(gomega.Equal("POST"))
176 gomega.Expect(config.TitleKey).To(gomega.Equal("customtitle"))
177 gomega.Expect(config.MessageKey).To(gomega.Equal("custommessage"))
178
179 // Verify webhook URL has remaining query params (extra=param)
180 gomega.Expect(config.WebhookURL().RawQuery).To(gomega.Equal("extra=param"))
181 })
182
183 ginkgo.It("handles custom headers and extra data correctly", func() {
184 webhookURL := testutils.URLMust(
185 "https://example.com/webhook?@Authorization=Bearer token&$extraKey=extraValue&template=json",
186 )
187
188 config, _, err := generic.ConfigFromWebhookURL(webhookURL)
189 gomega.Expect(err).NotTo(gomega.HaveOccurred())
190
191 // Verify template is set
192 gomega.Expect(config.Template).To(gomega.Equal("json"))
193
194 // Verify webhook URL has no query params (all processed)
195 gomega.Expect(config.WebhookURL().RawQuery).To(gomega.Equal(""))
196 })
197 })
198 })
199
200 ginkgo.Describe("building the payload", func() {
201 ginkgo.BeforeEach(func() {
202 service = &generic.Service{}
203 service.SetLogger(logger)
204 })
205 ginkgo.When("no template is specified", func() {
206 ginkgo.It("uses the message as payload", func() {
207 serviceURL := testutils.URLMust("generic://host.tld/webhook")
208 err := service.Initialize(serviceURL, logger)
209 gomega.Expect(err).NotTo(gomega.HaveOccurred())
210 payload, err := service.GetPayload(
211 service.Config,
212 types.Params{"message": "test message"},
213 )
214 gomega.Expect(err).NotTo(gomega.HaveOccurred())
215 contents, err := io.ReadAll(payload)
216 gomega.Expect(err).NotTo(gomega.HaveOccurred())
217 gomega.Expect(string(contents)).To(gomega.Equal("test message"))
218 })
219 })
220 ginkgo.When("template is specified as `JSON`", func() {
221 ginkgo.It("creates a JSON object as the payload", func() {
222 serviceURL := testutils.URLMust("generic://host.tld/webhook?template=JSON")
223 err := service.Initialize(serviceURL, logger)
224 gomega.Expect(err).NotTo(gomega.HaveOccurred())
225
226 params := types.Params{"title": "test title", "message": "test message"}
227 payload, err := service.GetPayload(service.Config, params)
228 gomega.Expect(err).NotTo(gomega.HaveOccurred())
229 contents, err := io.ReadAll(payload)
230 gomega.Expect(err).NotTo(gomega.HaveOccurred())
231 gomega.Expect(string(contents)).To(gomega.MatchJSON(`{
232 "title": "test title",
233 "message": "test message"
234 }`))
235 })
236 ginkgo.When("alternate keys are specified", func() {
237 ginkgo.It("creates a JSON object using the specified keys", func() {
238 serviceURL := testutils.URLMust(
239 "generic://host.tld/webhook?template=JSON&messagekey=body&titlekey=header",
240 )
241 err := service.Initialize(serviceURL, logger)
242 gomega.Expect(err).NotTo(gomega.HaveOccurred())
243
244 params := types.Params{"header": "test title", "body": "test message"}
245 payload, err := service.GetPayload(service.Config, params)
246 gomega.Expect(err).NotTo(gomega.HaveOccurred())
247 contents, err := io.ReadAll(payload)
248 gomega.Expect(err).NotTo(gomega.HaveOccurred())
249 gomega.Expect(string(contents)).To(gomega.MatchJSON(`{
250 "header": "test title",
251 "body": "test message"
252 }`))
253 })
254 })
255 })
256 ginkgo.When("a valid template is specified", func() {
257 ginkgo.It("applies the template to the message payload", func() {
258 serviceURL := testutils.URLMust("generic://host.tld/webhook?template=news")
259 err := service.Initialize(serviceURL, logger)
260 gomega.Expect(err).NotTo(gomega.HaveOccurred())
261 err = service.SetTemplateString("news", `{{.title}} ==> {{.message}}`)
262 gomega.Expect(err).NotTo(gomega.HaveOccurred())
263
264 params := types.Params{"title": "BREAKING NEWS", "message": "it's today!"}
265 payload, err := service.GetPayload(service.Config, params)
266 gomega.Expect(err).NotTo(gomega.HaveOccurred())
267 contents, err := io.ReadAll(payload)
268 gomega.Expect(err).NotTo(gomega.HaveOccurred())
269 gomega.Expect(string(contents)).To(gomega.Equal("BREAKING NEWS ==> it's today!"))
270 })
271 ginkgo.When("given nil params", func() {
272 ginkgo.It("applies template with message data", func() {
273 serviceURL := testutils.URLMust("generic://host.tld/webhook?template=arrows")
274 err := service.Initialize(serviceURL, logger)
275 gomega.Expect(err).NotTo(gomega.HaveOccurred())
276 err = service.SetTemplateString("arrows", `==> {{.message}} <==`)
277 gomega.Expect(err).NotTo(gomega.HaveOccurred())
278 payload, err := service.GetPayload(
279 service.Config,
280 types.Params{"message": "LOOK AT ME"},
281 )
282 gomega.Expect(err).NotTo(gomega.HaveOccurred())
283 contents, err := io.ReadAll(payload)
284 gomega.Expect(err).NotTo(gomega.HaveOccurred())
285 gomega.Expect(string(contents)).To(gomega.Equal("==> LOOK AT ME <=="))
286 })
287 })
288 })
289 ginkgo.When("an unknown template is specified", func() {
290 ginkgo.It("returns an error", func() {
291 serviceURL := testutils.URLMust("generic://host.tld/webhook?template=missing")
292 err := service.Initialize(serviceURL, logger)
293 gomega.Expect(err).NotTo(gomega.HaveOccurred())
294 _, err = service.GetPayload(service.Config, nil)
295 gomega.Expect(err).To(gomega.HaveOccurred())
296 })
297 })
298 })
299
300 ginkgo.Describe("sending the payload", func() {
301 ginkgo.BeforeEach(func() {
302 httpmock.Activate()
303
304 service = &generic.Service{}
305 service.SetLogger(logger)
306 })
307 ginkgo.AfterEach(func() {
308 httpmock.DeactivateAndReset()
309 })
310
311 ginkgo.When("sending via webhook URL", func() {
312 ginkgo.It("succeeds if the server accepts the payload", func() {
313 serviceURL := testutils.URLMust("generic://host.tld/webhook")
314 err := service.Initialize(serviceURL, logger)
315 gomega.Expect(err).NotTo(gomega.HaveOccurred())
316 httpmock.RegisterResponder(
317 "POST",
318 TestWebhookURL,
319 httpmock.NewStringResponder(200, ""),
320 )
321
322 err = service.Send("Message", nil)
323 gomega.Expect(err).NotTo(gomega.HaveOccurred())
324 })
325 ginkgo.It("reports an error if sending fails", func() {
326 serviceURL := testutils.URLMust("generic://host.tld/webhook")
327 err := service.Initialize(serviceURL, logger)
328 gomega.Expect(err).NotTo(gomega.HaveOccurred())
329 httpmock.RegisterResponder(
330 "POST",
331 TestWebhookURL,
332 httpmock.NewErrorResponder(errors.New("dummy error")),
333 )
334
335 err = service.Send("Message", nil)
336 gomega.Expect(err).To(gomega.HaveOccurred())
337 })
338 ginkgo.It("includes custom headers in the request", func() {
339 serviceURL := testutils.URLMust("generic://host.tld/webhook?@authorization=frend")
340 err := service.Initialize(serviceURL, logger)
341 gomega.Expect(err).NotTo(gomega.HaveOccurred())
342 httpmock.RegisterResponder("POST", TestWebhookURL,
343 func(req *http.Request) (*http.Response, error) {
344 gomega.Expect(req.Header.Get("Authorization")).To(gomega.Equal("frend"))
345
346 return httpmock.NewStringResponse(200, ""), nil
347 })
348
349 err = service.Send("Message", nil)
350 gomega.Expect(err).NotTo(gomega.HaveOccurred())
351 })
352 ginkgo.It("includes extra data in JSON payload", func() {
353 serviceURL := testutils.URLMust(
354 "generic://host.tld/webhook?template=json&$context=inside+joke",
355 )
356 err := service.Initialize(serviceURL, logger)
357 gomega.Expect(err).NotTo(gomega.HaveOccurred())
358 httpmock.RegisterResponder("POST", TestWebhookURL,
359 func(req *http.Request) (*http.Response, error) {
360 body, err := io.ReadAll(req.Body)
361 gomega.Expect(err).NotTo(gomega.HaveOccurred())
362 gomega.Expect(string(body)).
363 To(gomega.MatchJSON(`{"message":"Message","context":"inside joke"}`))
364
365 return httpmock.NewStringResponse(200, ""), nil
366 })
367
368 err = service.Send("Message", nil)
369 gomega.Expect(err).NotTo(gomega.HaveOccurred())
370 })
371 ginkgo.It("uses the configured HTTP method", func() {
372 serviceURL := testutils.URLMust("generic://host.tld/webhook?method=GET")
373 err := service.Initialize(serviceURL, logger)
374 gomega.Expect(err).NotTo(gomega.HaveOccurred())
375 httpmock.RegisterResponder(
376 "GET",
377 TestWebhookURL,
378 httpmock.NewStringResponder(200, ""),
379 )
380
381 err = service.Send("Message", nil)
382 gomega.Expect(err).NotTo(gomega.HaveOccurred())
383 })
384 ginkgo.It("does not mutate the given params", func() {
385 serviceURL := testutils.URLMust("generic://host.tld/webhook?method=GET")
386 err := service.Initialize(serviceURL, logger)
387 gomega.Expect(err).NotTo(gomega.HaveOccurred())
388 httpmock.RegisterResponder(
389 "GET",
390 TestWebhookURL,
391 httpmock.NewStringResponder(200, ""),
392 )
393
394 params := types.Params{"title": "TITLE"}
395 err = service.Send("Message", &params)
396 gomega.Expect(err).NotTo(gomega.HaveOccurred())
397 gomega.Expect(params).To(gomega.Equal(types.Params{"title": "TITLE"}))
398 })
399 })
400 })
401 })
402
403 // TestGeneric runs the Ginkgo test suite for the generic package.
404 func TestGeneric(t *testing.T) {
405 t.Parallel()
406 gomega.RegisterFailHandler(ginkgo.Fail)
407 ginkgo.RunSpecs(t, "Shoutrrr Generic Webhook Suite")
408 }