Debian Codegraph @

pkg/services/push/gotify/gotify_test.go

raw
1 package gotify
2
3 import (
4 "bufio"
5 "bytes"
6 "context"
7 "encoding/json"
8 "errors"
9 "flag"
10 "fmt"
11 "log"
12 "net"
13 "net/http"
14 "net/url"
15 "os"
16 "strconv"
17 "strings"
18 "sync"
19 "testing"
20 "testing/synctest"
21 "time"
22
23 "github.com/jarcoal/httpmock"
24 "github.com/onsi/ginkgo/v2"
25 "github.com/onsi/gomega"
26
27 "github.com/nicholas-fedor/shoutrrr/internal/testutils"
28 "github.com/nicholas-fedor/shoutrrr/pkg/types"
29 )
30
31 // MockHTTPClientManager provides a mock implementation of HTTPClientManager for testing.
32 // It allows httpmock setup by using custom transports for testing.
33 type MockHTTPClientManager struct {
34 Transport *http.Transport
35 }
36
37 // Test constants.
38 // These constants define test URLs and endpoints used throughout the test suite
39 // for mocking Gotify API interactions and verifying URL construction.
40 const (
41 TargetURL = "https://my.gotify.tld/message?token=Aaa.bbb.ccc.ddd" // Standard test URL with token in query parameter
42 TestDateRFC = "2023-12-04T20:00:00Z" // Standard test date in RFC3339 format
43 TestDateConfig = "2023-01-01T00:00:00Z" // Test date for config
44 )
45
46 // Test suite global variables and setup.
47 // These variables maintain state across test cases and provide shared test infrastructure.
48 // The BeforeSuite block initializes common test resources used throughout the test suite.
49 var (
50 service *Service // Global service instance for testing
51 logger *log.Logger // Test logger for capturing service output
52 envGotifyURL *url.URL // Environment-provided Gotify URL for integration tests
53
54 // httpmockActivateMutex serializes httpmock.Activate() calls to prevent race conditions
55 // when running tests in parallel with t.Parallel().
56 httpmockActivateMutex sync.Mutex
57
58 _ = ginkgo.BeforeSuite(func() {
59 service = &Service{} // Initialize fresh service instance
60 logger = log.New(
61 ginkgo.GinkgoWriter,
62 "Test",
63 log.LstdFlags,
64 ) // Create logger that writes to Ginkgo output
65
66 var err error
67
68 envGotifyURL, err = url.Parse(
69 os.Getenv("SHOUTRRR_GOTIFY_URL"),
70 ) // Parse integration test URL from environment
71 if err != nil {
72 envGotifyURL = &url.URL{} // Default to empty URL if parsing fails
73 }
74 })
75 )
76
77 // Main test suite for Gotify service functionality.
78 // This comprehensive test suite covers all aspects of the Gotify service including
79 // configuration parsing, URL construction, token validation, HTTP communication,
80 // error handling, and various authentication methods.
81 var _ = ginkgo.Describe("the Gotify service", func() {
82 ginkgo.When("running integration tests", func() {
83 ginkgo.It("sends a message successfully with a valid ENV URL", func() {
84 if envGotifyURL.String() == "" {
85 ginkgo.Skip("No integration test ENV URL was set")
86
87 return
88 }
89
90 serviceURL := testutils.URLMust(envGotifyURL.String())
91 err := service.Initialize(serviceURL, testutils.TestLogger())
92 gomega.Expect(err).NotTo(gomega.HaveOccurred())
93 err = service.Send("This is an integration test message", nil)
94 gomega.Expect(err).NotTo(gomega.HaveOccurred())
95 })
96 })
97
98 ginkgo.Describe("the service", func() {
99 ginkgo.BeforeEach(func() {
100 service = &Service{}
101 service.SetLogger(logger)
102 })
103 ginkgo.It("returns the correct service identifier", func() {
104 gomega.Expect(service.GetID()).To(gomega.Equal("gotify"))
105 })
106 })
107
108 ginkgo.When("parsing the configuration URL", func() {
109 ginkgo.BeforeEach(func() {
110 service = &Service{}
111 service.SetLogger(logger)
112 })
113 ginkgo.It("builds a valid Gotify URL without path", func() {
114 serviceURL := testutils.URLMust("gotify://test.tld/Aaa.bbb.ccc.ddd")
115 err := service.Initialize(serviceURL, logger)
116 gomega.Expect(err).NotTo(gomega.HaveOccurred())
117 gomega.Expect(service.Config.GetURL().String()).To(gomega.Equal(serviceURL.String()))
118 })
119 ginkgo.When("TLS is disabled", func() {
120 ginkgo.It("uses http scheme", func() {
121 serviceURL := testutils.URLMust(
122 "gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?disabletls=yes",
123 )
124 err := service.Initialize(serviceURL, logger)
125 gomega.Expect(err).NotTo(gomega.HaveOccurred())
126 gomega.Expect(service.Config.DisableTLS).To(gomega.BeTrue())
127 })
128 })
129 ginkgo.When("a custom path is provided", func() {
130 ginkgo.It("includes the path in the URL", func() {
131 serviceURL := testutils.URLMust("gotify://my.gotify.tld/gotify/Aaa.bbb.ccc.ddd")
132 err := service.Initialize(serviceURL, logger)
133 gomega.Expect(err).NotTo(gomega.HaveOccurred())
134 gomega.Expect(service.Config.GetURL().String()).To(gomega.Equal(serviceURL.String()))
135 })
136 })
137 ginkgo.When("the token has an invalid length", func() {
138 ginkgo.It("reports an error during send", func() {
139 serviceURL := testutils.URLMust("gotify://my.gotify.tld/short") // Length < 15
140 err := service.Initialize(serviceURL, logger)
141 gomega.Expect(err).NotTo(gomega.HaveOccurred())
142 err = service.Send("Message", nil)
143 gomega.Expect(err).
144 To(gomega.MatchError("failed to build request: invalid gotify token: \"short\""))
145 })
146 })
147 ginkgo.When("the token has an invalid prefix", func() {
148 ginkgo.It("reports an error during send", func() {
149 serviceURL := testutils.URLMust(
150 "gotify://my.gotify.tld/Chwbsdyhwwgarxd",
151 ) // Starts with 'C', not 'A'
152 err := service.Initialize(serviceURL, logger)
153 gomega.Expect(err).NotTo(gomega.HaveOccurred())
154 err = service.Send("Message", nil)
155 gomega.Expect(err).
156 To(gomega.MatchError("failed to build request: invalid gotify token: \"Chwbsdyhwwgarxd\""))
157 })
158 })
159 ginkgo.It("is identical after de-/serialization with path", func() {
160 testURL := "gotify://my.gotify.tld/gotify/Aaa.bbb.ccc.ddd?title=Test+title"
161 serviceURL := testutils.URLMust(testURL)
162 err := service.Initialize(serviceURL, logger)
163 gomega.Expect(err).NotTo(gomega.HaveOccurred())
164 gomega.Expect(service.Config.GetURL().String()).To(gomega.Equal(testURL))
165 })
166 ginkgo.It("is identical after de-/serialization without path", func() {
167 testURL := "gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?disabletls=Yes&priority=1&title=Test+title"
168 serviceURL := testutils.URLMust(testURL)
169 err := service.Initialize(serviceURL, logger)
170 gomega.Expect(err).NotTo(gomega.HaveOccurred())
171 gomega.Expect(service.Config.GetURL().String()).To(gomega.Equal(testURL))
172 })
173 ginkgo.It("allows slash at the end of the token", func() {
174 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.ddd/")
175 err := service.Initialize(serviceURL, logger)
176 gomega.Expect(err).NotTo(gomega.HaveOccurred())
177 gomega.Expect(service.Config.Token).To(gomega.Equal("Aaa.bbb.ccc.ddd"))
178 })
179 ginkgo.It("allows slash at the end of the token with additional path", func() {
180 serviceURL := testutils.URLMust("gotify://my.gotify.tld/path/to/gotify/Aaa.bbb.ccc.ddd/")
181 err := service.Initialize(serviceURL, logger)
182 gomega.Expect(err).NotTo(gomega.HaveOccurred())
183 gomega.Expect(service.Config.Token).To(gomega.Equal("Aaa.bbb.ccc.ddd"))
184 })
185 ginkgo.It("does not crash on empty token or path slash", func() {
186 serviceURL := testutils.URLMust("gotify://my.gotify.tld//")
187 err := service.Initialize(serviceURL, logger)
188 gomega.Expect(err).NotTo(gomega.HaveOccurred())
189 gomega.Expect(service.Config.Token).To(gomega.Equal(""))
190 })
191 ginkgo.When("handling malformed inputs", func() {
192 ginkgo.BeforeEach(func() {
193 service = &Service{}
194 service.SetLogger(logger)
195 // Set up interface implementations for tests that call Send without Initialize
196 service.httpClientManager = &DefaultHTTPClientManager{}
197 service.urlBuilder = &DefaultURLBuilder{}
198 service.payloadBuilder = &DefaultPayloadBuilder{}
199 service.validator = &DefaultValidator{}
200 service.sender = &DefaultSender{}
201 })
202 ginkgo.It("handles invalid URL schemes gracefully", func() {
203 invalidURL, err := url.Parse("invalid://url")
204 gomega.Expect(err).NotTo(gomega.HaveOccurred())
205 err = service.Initialize(invalidURL, logger)
206 // Service may accept invalid schemes, but Send should fail
207 gomega.Expect(err).NotTo(gomega.HaveOccurred())
208 err = service.Send("Message", nil)
209 gomega.Expect(err).To(gomega.HaveOccurred())
210 })
211 ginkgo.It("handles URLs with invalid host", func() {
212 invalidURL, err := url.Parse("gotify://[::1]:99999/Aaa.bbb.ccc.ddd")
213 gomega.Expect(err).NotTo(gomega.HaveOccurred())
214 err = service.Initialize(invalidURL, logger)
215 gomega.Expect(err).NotTo(gomega.HaveOccurred())
216 // Send should fail due to invalid host
217 err = service.Send("Message", nil)
218 gomega.Expect(err).To(gomega.HaveOccurred())
219 })
220 ginkgo.It("handles malformed JSON in extras parameter", func() {
221 serviceURL := testutils.URLMust(
222 "gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?extras={invalid}",
223 )
224 err := service.Initialize(serviceURL, logger)
225 gomega.Expect(err).To(gomega.HaveOccurred())
226 gomega.Expect(err.Error()).
227 To(gomega.ContainSubstring("failed to parse extras JSON from URL query"))
228 })
229 ginkgo.It("handles empty host in URL", func() {
230 serviceURL := testutils.URLMust("gotify:///Aaa.bbb.ccc.ddd")
231 err := service.Initialize(serviceURL, logger)
232 gomega.Expect(err).NotTo(gomega.HaveOccurred())
233 gomega.Expect(service.Config.Host).To(gomega.Equal(""))
234 })
235 ginkgo.It("handles URL with only host and no token", func() {
236 serviceURL := testutils.URLMust("gotify://my.gotify.tld/")
237 err := service.Initialize(serviceURL, logger)
238 gomega.Expect(err).NotTo(gomega.HaveOccurred())
239 gomega.Expect(service.Config.Token).To(gomega.Equal(""))
240 })
241 ginkgo.It("handles extreme priority values", func() {
242 serviceURL := testutils.URLMust("gotify://test.tld/Aaa.bbb.ccc.ddd")
243 err := service.Initialize(serviceURL, logger)
244 gomega.Expect(err).NotTo(gomega.HaveOccurred())
245
246 params := types.Params{"priority": "-100"}
247 err = service.Send("Message", &params)
248 gomega.Expect(err).To(gomega.HaveOccurred())
249 gomega.Expect(err).
250 To(gomega.MatchError("failed to process config: priority validation failed: priority must be between -2 and 10"))
251 })
252 ginkgo.It("handles nil config gracefully", func() {
253 service.Config = nil
254 err := service.Send("Message", nil)
255 gomega.Expect(err).To(gomega.HaveOccurred())
256 })
257 ginkgo.It("handles empty config extras", func() {
258 activateHTTPMockGinkgo()
259
260 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.ddd")
261 err := service.Initialize(serviceURL, logger)
262 gomega.Expect(err).NotTo(gomega.HaveOccurred())
263
264 mockManager := &MockHTTPClientManager{}
265 service.httpClientManager = mockManager
266 // Force recreation of client with mock transport
267 service.httpClient = nil
268 service.client = nil
269 service.Config.Extras = map[string]any{}
270
271 httpmock.RegisterResponder(
272 "POST",
273 TargetURL,
274 func(req *http.Request) (*http.Response, error) {
275 var requestBody map[string]any
276 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
277 return nil, err
278 }
279
280 gomega.Expect(requestBody["extras"]).To(gomega.Equal(map[string]any{}))
281
282 return testutils.JSONRespondMust(200, map[string]any{
283 "id": float64(1),
284 "appid": float64(1),
285 "message": "Message",
286 "title": "Shoutrrr notification",
287 "priority": float64(0),
288 "date": "2023-01-01T00:00:00Z",
289 })(req)
290 },
291 )
292
293 err = service.Send("Message", nil)
294 gomega.Expect(err).NotTo(gomega.HaveOccurred())
295 })
296 })
297 ginkgo.It("parses valid extras JSON from URL parameters", func() {
298 extrasJSON := `{"key1":"value1","key2":42}`
299 serviceURL := testutils.URLMust(
300 "gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?extras=" + url.QueryEscape(extrasJSON),
301 )
302 err := service.Initialize(serviceURL, logger)
303 gomega.Expect(err).NotTo(gomega.HaveOccurred())
304 gomega.Expect(service.Config.Extras).To(gomega.Equal(map[string]any{
305 "key1": "value1",
306 "key2": float64(42),
307 }))
308 })
309 ginkgo.It("reports error on invalid extras JSON from URL parameters", func() {
310 serviceURL := testutils.URLMust(
311 "gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?extras=invalid-json",
312 )
313 err := service.Initialize(serviceURL, logger)
314 gomega.Expect(err).To(gomega.HaveOccurred())
315 gomega.Expect(err.Error()).
316 To(gomega.ContainSubstring("failed to parse extras JSON from URL query"))
317 })
318 ginkgo.It("handles empty extras JSON from URL parameters", func() {
319 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?extras=")
320 err := service.Initialize(serviceURL, logger)
321 gomega.Expect(err).NotTo(gomega.HaveOccurred())
322 gomega.Expect(service.Config.Extras).To(gomega.BeNil())
323 })
324 ginkgo.It("parses useheader parameter from URL", func() {
325 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?useheader=yes")
326 err := service.Initialize(serviceURL, logger)
327 gomega.Expect(err).NotTo(gomega.HaveOccurred())
328 gomega.Expect(service.Config.UseHeader).To(gomega.BeTrue())
329 })
330 ginkgo.It("handles malformed URLs gracefully", func() {
331 // Test with URL that has invalid extras JSON
332 invalidURL := testutils.URLMust(
333 "gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?extras=invalid-json",
334 )
335 err := service.Initialize(invalidURL, logger)
336 gomega.Expect(err).To(gomega.HaveOccurred())
337 })
338 ginkgo.It("builds URL without token when useheader is enabled", func() {
339 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?useheader=yes")
340 err := service.Initialize(serviceURL, logger)
341 gomega.Expect(err).NotTo(gomega.HaveOccurred())
342 builtURL, err := service.urlBuilder.BuildURL(service.Config)
343 gomega.Expect(err).NotTo(gomega.HaveOccurred())
344 gomega.Expect(builtURL).To(gomega.Equal("https://my.gotify.tld/message"))
345 gomega.Expect(builtURL).NotTo(gomega.ContainSubstring("token="))
346 })
347 })
348
349 ginkgo.When("the token contains invalid characters", func() {
350 ginkgo.It("reports an error during send", func() {
351 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.dd!")
352 err := service.Initialize(serviceURL, logger)
353 gomega.Expect(err).NotTo(gomega.HaveOccurred())
354 err = service.Send("Message", nil)
355 gomega.Expect(err).
356 To(gomega.MatchError("failed to build request: invalid gotify token: \"Aaa.bbb.ccc.dd!\""))
357 })
358 })
359 ginkgo.When("the token has exactly 15 chars but invalid prefix", func() {
360 ginkgo.It("reports an error during send", func() {
361 serviceURL := testutils.URLMust(
362 "gotify://my.gotify.tld/Baa.bbb.ccc.ddd",
363 ) // Starts with 'B', not 'A'
364 err := service.Initialize(serviceURL, logger)
365 gomega.Expect(err).NotTo(gomega.HaveOccurred())
366 err = service.Send("Message", nil)
367 gomega.Expect(err).
368 To(gomega.MatchError("failed to build request: invalid gotify token: \"Baa.bbb.ccc.ddd\""))
369 })
370 })
371 ginkgo.When("the token has valid prefix but invalid characters at different positions", func() {
372 ginkgo.It("reports an error for invalid char at position 5", func() {
373 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa!bbb.ccc.ddd")
374 err := service.Initialize(serviceURL, logger)
375 gomega.Expect(err).NotTo(gomega.HaveOccurred())
376 err = service.Send("Message", nil)
377 gomega.Expect(err).
378 To(gomega.MatchError("failed to build request: invalid gotify token: \"Aaa!bbb.ccc.ddd\""))
379 })
380 ginkgo.It("reports an error for invalid char at position 10", func() {
381 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb!ccc.ddd")
382 err := service.Initialize(serviceURL, logger)
383 gomega.Expect(err).NotTo(gomega.HaveOccurred())
384 err = service.Send("Message", nil)
385 gomega.Expect(err).
386 To(gomega.MatchError("failed to build request: invalid gotify token: \"Aaa.bbb!ccc.ddd\""))
387 })
388 ginkgo.It("reports an error for invalid char at position 15", func() {
389 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.dd!")
390 err := service.Initialize(serviceURL, logger)
391 gomega.Expect(err).NotTo(gomega.HaveOccurred())
392 err = service.Send("Message", nil)
393 gomega.Expect(err).
394 To(gomega.MatchError("failed to build request: invalid gotify token: \"Aaa.bbb.ccc.dd!\""))
395 })
396 })
397
398 ginkgo.Describe("sending the payload", func() {
399 var mockManager *MockHTTPClientManager
400
401 ginkgo.BeforeEach(func() {
402 service = &Service{}
403 service.SetLogger(logger)
404 activateHTTPMockGinkgo()
405
406 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.ddd")
407 err := service.Initialize(serviceURL, logger)
408 gomega.Expect(err).NotTo(gomega.HaveOccurred())
409
410 mockManager = &MockHTTPClientManager{}
411 service.httpClientManager = mockManager
412 // Force recreation of client with mock transport
413 service.httpClient = nil
414 service.client = nil
415 })
416 ginkgo.AfterEach(func() {
417 httpmock.DeactivateAndReset()
418 })
419 ginkgo.When("sending via webhook URL", func() {
420 ginkgo.It("does not report an error if the server accepts the payload", func() {
421 httpmock.RegisterResponder(
422 "POST",
423 TargetURL,
424 testutils.JSONRespondMust(200, map[string]any{
425 "id": float64(1),
426 "appid": float64(1),
427 "message": "Message",
428 "title": "Shoutrrr notification",
429 "priority": float64(0),
430 "date": "2023-01-01T00:00:00Z",
431 }),
432 )
433
434 err := service.Send("Message", nil)
435 gomega.Expect(err).NotTo(gomega.HaveOccurred())
436 })
437
438 ginkgo.It(
439 "reports an error if the server rejects the payload with an error response",
440 func() {
441 httpmock.RegisterResponder(
442 "POST",
443 TargetURL,
444 testutils.JSONRespondMust(401, map[string]any{
445 "error": "Unauthorized",
446 "errorCode": float64(401),
447 "errorDescription": "you need to provide a valid access token or user credentials to access this api",
448 }),
449 )
450
451 err := service.Send("Message", nil)
452 gomega.Expect(err.Error()).
453 To(gomega.ContainSubstring("server responded with Unauthorized (401): you need to provide a valid access token or user credentials to access this api"))
454 },
455 )
456 ginkgo.It("reports an error for 403 Forbidden response", func() {
457 httpmock.RegisterResponder(
458 "POST",
459 TargetURL,
460 testutils.JSONRespondMust(403, map[string]any{
461 "error": "Forbidden",
462 "errorCode": float64(403),
463 "errorDescription": "access denied",
464 }),
465 )
466
467 err := service.Send("Message", nil)
468 gomega.Expect(err).To(gomega.HaveOccurred())
469 gomega.Expect(err.Error()).
470 To(gomega.ContainSubstring("server responded with Forbidden (403)"))
471 })
472 ginkgo.It("reports an error for 404 Not Found response", func() {
473 httpmock.RegisterResponder(
474 "POST",
475 TargetURL,
476 testutils.JSONRespondMust(404, map[string]any{
477 "error": "Not Found",
478 "errorCode": float64(404),
479 "errorDescription": "endpoint not found",
480 }),
481 )
482
483 err := service.Send("Message", nil)
484 gomega.Expect(err).To(gomega.HaveOccurred())
485 gomega.Expect(err.Error()).
486 To(gomega.ContainSubstring("server responded with Not Found (404)"))
487 })
488 ginkgo.It("reports an error for 429 Too Many Requests response", func() {
489 httpmock.RegisterResponder(
490 "POST",
491 TargetURL,
492 testutils.JSONRespondMust(429, map[string]any{
493 "error": "Too Many Requests",
494 "errorCode": float64(429),
495 "errorDescription": "rate limit exceeded",
496 }),
497 )
498
499 err := service.Send("Message", nil)
500 gomega.Expect(err).To(gomega.HaveOccurred())
501 gomega.Expect(err.Error()).
502 To(gomega.ContainSubstring("server responded with Too Many Requests (429)"))
503 })
504 ginkgo.It("reports an error for 500 Internal Server Error response", func() {
505 httpmock.RegisterResponder(
506 "POST",
507 TargetURL,
508 testutils.JSONRespondMust(500, map[string]any{
509 "error": "Internal Server Error",
510 "errorCode": float64(500),
511 "errorDescription": "internal error",
512 }),
513 )
514
515 err := service.Send("Message", nil)
516 gomega.Expect(err).To(gomega.HaveOccurred())
517 gomega.Expect(err.Error()).
518 To(gomega.ContainSubstring("server responded with Internal Server Error (500)"))
519 })
520 ginkgo.It("reports an error for 502 Bad Gateway response", func() {
521 httpmock.RegisterResponder(
522 "POST",
523 TargetURL,
524 testutils.JSONRespondMust(502, map[string]any{
525 "error": "Bad Gateway",
526 "errorCode": float64(502),
527 "errorDescription": "bad gateway",
528 }),
529 )
530
531 err := service.Send("Message", nil)
532 gomega.Expect(err).To(gomega.HaveOccurred())
533 gomega.Expect(err.Error()).
534 To(gomega.ContainSubstring("server responded with Bad Gateway (502)"))
535 })
536 ginkgo.It("reports an error for 503 Service Unavailable response", func() {
537 httpmock.RegisterResponder(
538 "POST",
539 TargetURL,
540 testutils.JSONRespondMust(503, map[string]any{
541 "error": "Service Unavailable",
542 "errorCode": float64(503),
543 "errorDescription": "service unavailable",
544 }),
545 )
546
547 err := service.Send("Message", nil)
548 gomega.Expect(err).To(gomega.HaveOccurred())
549 gomega.Expect(err.Error()).
550 To(gomega.ContainSubstring("server responded with Service Unavailable (503)"))
551 })
552 ginkgo.It("reports an error for 504 Gateway Timeout response", func() {
553 httpmock.RegisterResponder(
554 "POST",
555 TargetURL,
556 testutils.JSONRespondMust(504, map[string]any{
557 "error": "Gateway Timeout",
558 "errorCode": float64(504),
559 "errorDescription": "gateway timeout",
560 }),
561 )
562
563 err := service.Send("Message", nil)
564 gomega.Expect(err).To(gomega.HaveOccurred())
565 gomega.Expect(err.Error()).
566 To(gomega.ContainSubstring("server responded with Gateway Timeout (504)"))
567 })
568 ginkgo.It("reports an error if sending fails with a network error", func() {
569 httpmock.RegisterResponder(
570 "POST",
571 TargetURL,
572 httpmock.NewErrorResponder(errors.New("network failure")),
573 )
574
575 err := service.Send("Message", nil)
576 gomega.Expect(err.Error()).
577 To(gomega.ContainSubstring("sending POST request to \"https://my.gotify.tld/message?token=Aaa.bbb.ccc.ddd\": Post \"https://my.gotify.tld/message?token=Aaa.bbb.ccc.ddd\": network failure"))
578 })
579 ginkgo.It("returns an error if params update fails", func() {
580 params := types.Params{"priority": "invalid"}
581 err := service.Send("Message", &params)
582 gomega.Expect(err).To(gomega.HaveOccurred())
583 gomega.Expect(err.Error()).
584 To(gomega.ContainSubstring("failed to update config from params"))
585 })
586 ginkgo.It("returns an error if message is empty", func() {
587 err := service.Send("", nil)
588 gomega.Expect(err).To(gomega.HaveOccurred())
589 gomega.Expect(err.Error()).
590 To(gomega.Equal("input validation failed: message validation failed: message cannot be empty"))
591 })
592 ginkgo.It("returns an error if priority is too low", func() {
593 params := types.Params{"priority": "-3"}
594 err := service.Send("Message", &params)
595 gomega.Expect(err).To(gomega.HaveOccurred())
596 gomega.Expect(err).
597 To(gomega.MatchError("failed to process config: priority validation failed: priority must be between -2 and 10"))
598 })
599 ginkgo.It("returns an error if priority is too high", func() {
600 params := types.Params{"priority": "11"}
601 err := service.Send("Message", &params)
602 gomega.Expect(err).To(gomega.HaveOccurred())
603 gomega.Expect(err).
604 To(gomega.MatchError("failed to process config: priority validation failed: priority must be between -2 and 10"))
605 })
606 ginkgo.It("recreates HTTP client when service.httpClient is nil", func() {
607 // Set httpClient to nil to simulate recreation
608 service.httpClient = nil
609 service.client = nil
610 // Call Send to trigger recreation (it will fail due to no httpmock)
611 _ = service.Send("Message", nil)
612 // Verify client was recreated
613 gomega.Expect(service.httpClient).NotTo(gomega.BeNil())
614 gomega.Expect(service.client).NotTo(gomega.BeNil())
615 // Now activate httpmock and set client to nil to force recreation with mocked transport
616 activateHTTPMockGinkgo()
617
618 service.httpClient = nil
619 service.client = nil
620
621 httpmock.RegisterResponder(
622 "POST",
623 TargetURL,
624 testutils.JSONRespondMust(200, map[string]any{
625 "id": float64(1),
626 "appid": float64(1),
627 "message": "Message",
628 "title": "Shoutrrr notification",
629 "priority": float64(0),
630 "date": "2023-01-01T00:00:00Z",
631 }),
632 )
633 // Now call Send again with httpmock active
634 err := service.Send("Message", nil)
635 gomega.Expect(err).NotTo(gomega.HaveOccurred())
636 })
637 ginkgo.It("handles very long messages", func() {
638 longMessage := strings.Repeat("a", 10000)
639
640 httpmock.RegisterResponder(
641 "POST",
642 TargetURL,
643 func(req *http.Request) (*http.Response, error) {
644 var requestBody map[string]any
645 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
646 return nil, err
647 }
648
649 gomega.Expect(requestBody["message"]).To(gomega.Equal(longMessage))
650
651 return testutils.JSONRespondMust(200, map[string]any{
652 "id": float64(1),
653 "appid": float64(1),
654 "message": longMessage,
655 "title": "Shoutrrr notification",
656 "priority": float64(0),
657 "date": "2023-01-01T00:00:00Z",
658 })(req)
659 },
660 )
661
662 err := service.Send(longMessage, nil)
663 gomega.Expect(err).NotTo(gomega.HaveOccurred())
664 })
665 //nolint:gosmopolitan // Intentional string literal containing rune in Han script
666 ginkgo.It("handles messages with special characters", func() {
667 specialMessage := "Message with special chars: éñüñ 中文 🚀 \n\t\"quotes\" 'single'"
668
669 httpmock.RegisterResponder(
670 "POST",
671 TargetURL,
672 func(req *http.Request) (*http.Response, error) {
673 var requestBody map[string]any
674 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
675 return nil, err
676 }
677
678 gomega.Expect(requestBody["message"]).To(gomega.Equal(specialMessage))
679
680 return testutils.JSONRespondMust(200, map[string]any{
681 "id": float64(1),
682 "appid": float64(1),
683 "message": specialMessage,
684 "title": "Shoutrrr notification",
685 "priority": float64(0),
686 "date": "2023-01-01T00:00:00Z",
687 })(req)
688 },
689 )
690
691 err := service.Send(specialMessage, nil)
692 gomega.Expect(err).NotTo(gomega.HaveOccurred())
693 })
694 ginkgo.It("handles non-JSON error responses", func() {
695 httpmock.RegisterResponder(
696 "POST",
697 TargetURL,
698 httpmock.NewStringResponder(500, "Internal Server Error"),
699 )
700
701 err := service.Send("Message", nil)
702 gomega.Expect(err).To(gomega.HaveOccurred())
703 gomega.Expect(err.Error()).
704 To(gomega.ContainSubstring("failed to send notification to Gotify"))
705 })
706 ginkgo.It("handles concurrent access from multiple goroutines", func() {
707 httpmock.RegisterResponder(
708 "POST",
709 TargetURL,
710 testutils.JSONRespondMust(200, map[string]any{
711 "id": float64(1),
712 "appid": float64(1),
713 "message": "Message",
714 "title": "Shoutrrr notification",
715 "priority": float64(0),
716 "date": "2023-01-01T00:00:00Z",
717 }),
718 )
719
720 numGoroutines := 10
721
722 errChan := make(chan error, numGoroutines)
723 for i := range numGoroutines {
724 go func(id int) {
725 err := service.Send("Concurrent message "+strconv.Itoa(id), nil)
726 errChan <- err
727 }(i)
728 }
729
730 for range numGoroutines {
731 err := <-errChan
732 gomega.Expect(err).NotTo(gomega.HaveOccurred())
733 }
734 })
735 ginkgo.It("handles very large extras payload", func() {
736 // Create a large extras payload
737 largeExtras := make(map[string]any)
738 for i := range 1000 {
739 largeExtras[strconv.Itoa(i)] = strings.Repeat(
740 "data",
741 100,
742 ) // ~400 bytes per entry
743 }
744
745 httpmock.RegisterResponder(
746 "POST",
747 TargetURL,
748 func(req *http.Request) (*http.Response, error) {
749 var requestBody map[string]any
750 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
751 return nil, err
752 }
753
754 gomega.Expect(requestBody["extras"]).To(gomega.Equal(largeExtras))
755
756 return testutils.JSONRespondMust(200, map[string]any{
757 "id": float64(1),
758 "appid": float64(1),
759 "message": "Message",
760 "title": "Shoutrrr notification",
761 "priority": float64(0),
762 "date": "2023-01-01T00:00:00Z",
763 })(req)
764 },
765 )
766
767 service.Config.Extras = largeExtras
768 err := service.Send("Message", nil)
769 gomega.Expect(err).NotTo(gomega.HaveOccurred())
770 })
771 ginkgo.It("handles combined large message and extras", func() {
772 largeMessage := strings.Repeat("message", 2000) // ~12KB message
773
774 largeExtras := make(map[string]any)
775 for i := range 500 {
776 largeExtras[strconv.Itoa(i)] = strings.Repeat(
777 "extra",
778 50,
779 ) // ~250 bytes per entry
780 }
781
782 httpmock.RegisterResponder(
783 "POST",
784 TargetURL,
785 func(req *http.Request) (*http.Response, error) {
786 var requestBody map[string]any
787 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
788 return nil, err
789 }
790
791 gomega.Expect(requestBody["message"]).To(gomega.Equal(largeMessage))
792 gomega.Expect(requestBody["extras"]).To(gomega.Equal(largeExtras))
793
794 return testutils.JSONRespondMust(200, map[string]any{
795 "id": float64(1),
796 "appid": float64(1),
797 "message": largeMessage,
798 "title": "Shoutrrr notification",
799 "priority": float64(0),
800 "date": "2023-01-01T00:00:00Z",
801 })(req)
802 },
803 )
804
805 service.Config.Extras = largeExtras
806 err := service.Send(largeMessage, nil)
807 gomega.Expect(err).NotTo(gomega.HaveOccurred())
808 })
809 })
810 ginkgo.When("sending with extras from params", func() {
811 ginkgo.It("includes extras in request payload from params", func() {
812 extrasJSON := `{"paramKey":"paramValue"}`
813
814 httpmock.RegisterResponder(
815 "POST",
816 TargetURL,
817 func(req *http.Request) (*http.Response, error) {
818 var requestBody map[string]any
819 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
820 return nil, err
821 }
822
823 gomega.Expect(requestBody["extras"]).To(gomega.Equal(map[string]any{
824 "paramKey": "paramValue",
825 }))
826
827 return testutils.JSONRespondMust(200, map[string]any{
828 "id": float64(1),
829 "appid": float64(1),
830 "message": "Message",
831 "title": "Shoutrrr notification",
832 "priority": float64(0),
833 "date": "2023-01-01T00:00:00Z",
834 })(req)
835 },
836 )
837
838 params := types.Params{"extras": extrasJSON}
839 err := service.Send("Message", &params)
840 gomega.Expect(err).NotTo(gomega.HaveOccurred())
841 })
842 ginkgo.It("includes extras in request payload from config", func() {
843 service.Config.Extras = map[string]any{"configKey": "configValue"}
844
845 httpmock.RegisterResponder(
846 "POST",
847 TargetURL,
848 func(req *http.Request) (*http.Response, error) {
849 var requestBody map[string]any
850 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
851 return nil, err
852 }
853
854 gomega.Expect(requestBody["extras"]).To(gomega.Equal(map[string]any{
855 "configKey": "configValue",
856 }))
857
858 return testutils.JSONRespondMust(200, map[string]any{
859 "id": float64(1),
860 "appid": float64(1),
861 "message": "Message",
862 "title": "Shoutrrr notification",
863 "priority": float64(0),
864 "date": "2023-01-01T00:00:00Z",
865 })(req)
866 },
867 )
868
869 err := service.Send("Message", nil)
870 gomega.Expect(err).NotTo(gomega.HaveOccurred())
871 })
872
873 ginkgo.It("prioritizes extras from params over config", func() {
874 service.Config.Extras = map[string]any{"configKey": "configValue"}
875 extrasJSON := `{"paramKey":"paramValue"}`
876
877 httpmock.RegisterResponder(
878 "POST",
879 TargetURL,
880 func(req *http.Request) (*http.Response, error) {
881 var requestBody map[string]any
882 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
883 return nil, err
884 }
885
886 gomega.Expect(requestBody["extras"]).To(gomega.Equal(map[string]any{
887 "paramKey": "paramValue",
888 }))
889
890 return testutils.JSONRespondMust(200, map[string]any{
891 "id": float64(1),
892 "appid": float64(1),
893 "message": "Message",
894 "title": "Shoutrrr notification",
895 "priority": float64(0),
896 "date": "2023-01-01T00:00:00Z",
897 })(req)
898 },
899 )
900
901 params := types.Params{"extras": extrasJSON}
902 err := service.Send("Message", &params)
903 gomega.Expect(err).NotTo(gomega.HaveOccurred())
904 })
905 })
906 ginkgo.When("sending with date parameter", func() {
907 ginkgo.It("includes date in request payload when provided", func() {
908 customDate := TestDateRFC
909
910 httpmock.RegisterResponder(
911 "POST",
912 TargetURL,
913 func(req *http.Request) (*http.Response, error) {
914 var requestBody map[string]any
915 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
916 return nil, err
917 }
918
919 gomega.Expect(requestBody["date"]).To(gomega.Equal(customDate))
920
921 return testutils.JSONRespondMust(200, map[string]any{
922 "id": float64(1),
923 "appid": float64(1),
924 "message": "Message",
925 "title": "Shoutrrr notification",
926 "priority": float64(0),
927 "date": customDate,
928 })(req)
929 },
930 )
931
932 params := types.Params{"date": customDate}
933 err := service.Send("Message", &params)
934 gomega.Expect(err).NotTo(gomega.HaveOccurred())
935 })
936 ginkgo.It("converts Unix timestamp date parameter to RFC3339", func() {
937 unixDate := "1701720000" // 2023-12-04T20:00:00Z
938 expectedDate := TestDateRFC
939
940 httpmock.RegisterResponder(
941 "POST",
942 TargetURL,
943 func(req *http.Request) (*http.Response, error) {
944 var requestBody map[string]any
945 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
946 return nil, err
947 }
948
949 gomega.Expect(requestBody["date"]).To(gomega.Equal(expectedDate))
950
951 return testutils.JSONRespondMust(200, map[string]any{
952 "id": float64(1),
953 "appid": float64(1),
954 "message": "Message",
955 "title": "Shoutrrr notification",
956 "priority": float64(0),
957 "date": expectedDate,
958 })(req)
959 },
960 )
961
962 params := types.Params{"date": unixDate}
963 err := service.Send("Message", &params)
964 gomega.Expect(err).NotTo(gomega.HaveOccurred())
965 })
966 ginkgo.It("converts basic date-time format to RFC3339", func() {
967 basicDate := "2023-12-04 20:00:00"
968 expectedDate := TestDateRFC
969
970 httpmock.RegisterResponder(
971 "POST",
972 TargetURL,
973 func(req *http.Request) (*http.Response, error) {
974 var requestBody map[string]any
975 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
976 return nil, err
977 }
978
979 gomega.Expect(requestBody["date"]).To(gomega.Equal(expectedDate))
980
981 return testutils.JSONRespondMust(200, map[string]any{
982 "id": float64(1),
983 "appid": float64(1),
984 "message": "Message",
985 "title": "Shoutrrr notification",
986 "priority": float64(0),
987 "date": expectedDate,
988 })(req)
989 },
990 )
991
992 params := types.Params{"date": basicDate}
993 err := service.Send("Message", &params)
994 gomega.Expect(err).NotTo(gomega.HaveOccurred())
995 })
996 ginkgo.It("logs warning for invalid date parameter and sends with empty date", func() {
997 var logBuffer bytes.Buffer
998
999 testLogger := log.New(&logBuffer, "Test", log.LstdFlags)
1000 service.SetLogger(testLogger)
1001
1002 invalidDate := "not-a-date"
1003
1004 httpmock.RegisterResponder(
1005 "POST",
1006 TargetURL,
1007 func(req *http.Request) (*http.Response, error) {
1008 var requestBody map[string]any
1009 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
1010 return nil, err
1011 }
1012 // Should send with empty date when invalid date provided
1013 gomega.Expect(requestBody["date"]).To(gomega.BeNil())
1014
1015 return testutils.JSONRespondMust(200, map[string]any{
1016 "id": float64(1),
1017 "appid": float64(1),
1018 "message": "Message",
1019 "title": "Shoutrrr notification",
1020 "priority": float64(0),
1021 "date": "2023-01-01T00:00:00Z",
1022 })(req)
1023 },
1024 )
1025
1026 params := types.Params{"date": invalidDate}
1027 err := service.Send("Message", &params)
1028 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1029 gomega.Expect(logBuffer.String()).To(gomega.ContainSubstring("Invalid date format"))
1030 })
1031 ginkgo.It("prioritizes date from params over config", func() {
1032 // Set date in config
1033 service.Config.Date = TestDateConfig
1034 paramDate := TestDateRFC
1035
1036 httpmock.RegisterResponder(
1037 "POST",
1038 TargetURL,
1039 func(req *http.Request) (*http.Response, error) {
1040 var requestBody map[string]any
1041 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
1042 return nil, err
1043 }
1044
1045 gomega.Expect(requestBody["date"]).To(gomega.Equal(paramDate))
1046
1047 return testutils.JSONRespondMust(200, map[string]any{
1048 "id": float64(1),
1049 "appid": float64(1),
1050 "message": "Message",
1051 "title": "Shoutrrr notification",
1052 "priority": float64(0),
1053 "date": paramDate,
1054 })(req)
1055 },
1056 )
1057
1058 params := types.Params{"date": paramDate}
1059 err := service.Send("Message", &params)
1060 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1061 })
1062 ginkgo.It("uses config date when no param date provided", func() {
1063 configDate := TestDateConfig
1064 service.Config.Date = configDate
1065
1066 httpmock.RegisterResponder(
1067 "POST",
1068 TargetURL,
1069 func(req *http.Request) (*http.Response, error) {
1070 var requestBody map[string]any
1071 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
1072 return nil, err
1073 }
1074
1075 gomega.Expect(requestBody["date"]).To(gomega.Equal(configDate))
1076
1077 return testutils.JSONRespondMust(200, map[string]any{
1078 "id": float64(1),
1079 "appid": float64(1),
1080 "message": "Message",
1081 "title": "Shoutrrr notification",
1082 "priority": float64(0),
1083 "date": configDate,
1084 })(req)
1085 },
1086 )
1087
1088 err := service.Send("Message", nil)
1089 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1090 })
1091 ginkgo.It("includes date with priority parameter", func() {
1092 customDate := TestDateRFC
1093
1094 httpmock.RegisterResponder(
1095 "POST",
1096 TargetURL,
1097 func(req *http.Request) (*http.Response, error) {
1098 var requestBody map[string]any
1099 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
1100 return nil, err
1101 }
1102
1103 gomega.Expect(requestBody["date"]).To(gomega.Equal(customDate))
1104 gomega.Expect(requestBody["priority"]).To(gomega.Equal(float64(3)))
1105
1106 return testutils.JSONRespondMust(200, map[string]any{
1107 "id": float64(1),
1108 "appid": float64(1),
1109 "message": "Message",
1110 "title": "Shoutrrr notification",
1111 "priority": float64(3),
1112 "date": customDate,
1113 })(req)
1114 },
1115 )
1116
1117 params := types.Params{"date": customDate, "priority": "3"}
1118 err := service.Send("Message", &params)
1119 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1120 })
1121 ginkgo.It("includes date with extras parameter", func() {
1122 customDate := TestDateRFC
1123 extrasJSON := `{"key":"value"}`
1124
1125 httpmock.RegisterResponder(
1126 "POST",
1127 TargetURL,
1128 func(req *http.Request) (*http.Response, error) {
1129 var requestBody map[string]any
1130 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
1131 return nil, err
1132 }
1133
1134 gomega.Expect(requestBody["date"]).To(gomega.Equal(customDate))
1135 gomega.Expect(requestBody["extras"]).To(gomega.Equal(map[string]any{
1136 "key": "value",
1137 }))
1138
1139 return testutils.JSONRespondMust(200, map[string]any{
1140 "id": float64(1),
1141 "appid": float64(1),
1142 "message": "Message",
1143 "title": "Shoutrrr notification",
1144 "priority": float64(0),
1145 "date": customDate,
1146 })(req)
1147 },
1148 )
1149
1150 params := types.Params{"date": customDate, "extras": extrasJSON}
1151 err := service.Send("Message", &params)
1152 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1153 })
1154 })
1155 ginkgo.When("using header authentication", func() {
1156 ginkgo.BeforeEach(func() {
1157 service = &Service{}
1158 service.SetLogger(logger)
1159 activateHTTPMockGinkgo()
1160
1161 serviceURL := testutils.URLMust(
1162 "gotify://my.gotify.tld/Aaa.bbb.ccc.ddd?useheader=yes",
1163 )
1164 err := service.Initialize(serviceURL, logger)
1165 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1166
1167 mockManager = &MockHTTPClientManager{}
1168 service.httpClientManager = mockManager
1169 // Force recreation of client with mock transport
1170 service.httpClient = nil
1171 service.client = nil
1172 })
1173 ginkgo.AfterEach(func() {
1174 httpmock.DeactivateAndReset()
1175 })
1176 ginkgo.It("sends X-Gotify-Key header when useheader is enabled", func() {
1177 httpmock.RegisterResponder(
1178 "POST",
1179 "https://my.gotify.tld/message",
1180 func(req *http.Request) (*http.Response, error) {
1181 gomega.Expect(req.Header.Get("X-Gotify-Key")).
1182 To(gomega.Equal("Aaa.bbb.ccc.ddd"))
1183
1184 return testutils.JSONRespondMust(200, map[string]any{
1185 "id": float64(1),
1186 "appid": float64(1),
1187 "message": "Message",
1188 "title": "Shoutrrr notification",
1189 "priority": float64(0),
1190 "date": "2023-01-01T00:00:00Z",
1191 })(req)
1192 },
1193 )
1194
1195 err := service.Send("Message", nil)
1196 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1197 })
1198 ginkgo.It("cleans up X-Gotify-Key header after send", func() {
1199 httpmock.RegisterResponder(
1200 "POST",
1201 "https://my.gotify.tld/message",
1202 func(req *http.Request) (*http.Response, error) {
1203 gomega.Expect(req.Header.Get("X-Gotify-Key")).
1204 To(gomega.Equal("Aaa.bbb.ccc.ddd"))
1205
1206 return testutils.JSONRespondMust(200, map[string]any{
1207 "id": float64(1),
1208 "appid": float64(1),
1209 "message": "Message",
1210 "title": "Shoutrrr notification",
1211 "priority": float64(0),
1212 "date": "2023-01-01T00:00:00Z",
1213 })(req)
1214 },
1215 )
1216
1217 err := service.Send("Message", nil)
1218 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1219 // Verify header was cleaned up
1220 gomega.Expect(service.client.Headers().Get("X-Gotify-Key")).
1221 To(gomega.Equal(""))
1222 })
1223 })
1224 ginkgo.When("parsing extras with invalid JSON", func() {
1225 ginkgo.It("logs error and falls back to config extras", func() {
1226 service.Config.Extras = map[string]any{"configKey": "configValue"}
1227
1228 httpmock.RegisterResponder(
1229 "POST",
1230 TargetURL,
1231 func(req *http.Request) (*http.Response, error) {
1232 var requestBody map[string]any
1233 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
1234 return nil, err
1235 }
1236 // Should fall back to config extras since params extras are invalid
1237 gomega.Expect(requestBody["extras"]).To(gomega.Equal(map[string]any{
1238 "configKey": "configValue",
1239 }))
1240
1241 return testutils.JSONRespondMust(200, map[string]any{
1242 "id": float64(1),
1243 "appid": float64(1),
1244 "message": "Message",
1245 "title": "Shoutrrr notification",
1246 "priority": float64(0),
1247 "date": "2023-01-01T00:00:00Z",
1248 })(req)
1249 },
1250 )
1251
1252 params := types.Params{"extras": "invalid-json"}
1253 err := service.Send("Message", &params)
1254 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1255 })
1256 })
1257 ginkgo.When("extras contain non-marshallable data", func() {
1258 ginkgo.It("fails with marshaling error", func() {
1259 service.Config.Extras = map[string]any{"bad": make(chan int)}
1260 err := service.Send("Message", nil)
1261 gomega.Expect(err).To(gomega.HaveOccurred())
1262 gomega.Expect(err.Error()).
1263 To(gomega.ContainSubstring("failed to send notification to Gotify"))
1264 })
1265 })
1266 })
1267
1268 // Helper functions test suite.
1269 // This section tests the internal utility functions that support the main service operations,
1270 // including request preparation, configuration validation, URL building, and extras parsing.
1271 ginkgo.Describe("helper functions", func() {
1272 ginkgo.BeforeEach(func() {
1273 service = &Service{}
1274 service.SetLogger(logger)
1275 // Set up interface implementations directly instead of relying on Initialize
1276 service.httpClientManager = &DefaultHTTPClientManager{}
1277 service.urlBuilder = &DefaultURLBuilder{}
1278 service.payloadBuilder = &DefaultPayloadBuilder{}
1279 service.validator = &DefaultValidator{}
1280 service.sender = &DefaultSender{}
1281 })
1282 ginkgo.Describe("prepareRequest", func() {
1283 ginkgo.It("constructs payload correctly", func() {
1284 config := &Config{
1285 Title: "Test Title",
1286 Priority: 5,
1287 }
1288 extras := map[string]any{"key": "value"}
1289 message := "Test message"
1290 date := "2023-01-01T00:00:00Z"
1291
1292 request := service.payloadBuilder.PrepareRequest(message, config, extras, date)
1293
1294 gomega.Expect(request.Message).To(gomega.Equal(message))
1295 gomega.Expect(request.Title).To(gomega.Equal(config.Title))
1296 gomega.Expect(request.Priority).To(gomega.Equal(config.Priority))
1297 gomega.Expect(request.Date).To(gomega.Equal(&date))
1298 gomega.Expect(request.Extras).To(gomega.Equal(extras))
1299 })
1300 })
1301 ginkgo.Describe("createTransport", func() {
1302 ginkgo.It("configures TLS correctly when TLS is disabled", func() {
1303 service.Config = &Config{}
1304 service.Config.DisableTLS = true
1305 transport := service.httpClientManager.CreateTransport(service.Config)
1306 gomega.Expect(transport.TLSClientConfig.InsecureSkipVerify).To(gomega.BeTrue())
1307 })
1308 ginkgo.It("configures TLS correctly when TLS is enabled", func() {
1309 service.Config = &Config{}
1310 service.Config.DisableTLS = false
1311 transport := service.httpClientManager.CreateTransport(service.Config)
1312 gomega.Expect(transport.TLSClientConfig.InsecureSkipVerify).To(gomega.BeFalse())
1313 })
1314 })
1315 ginkgo.Describe("createHTTPClient", func() {
1316 ginkgo.It("creates transport correctly", func() {
1317 service.Config = &Config{}
1318 transport := service.httpClientManager.CreateTransport(service.Config)
1319 gomega.Expect(transport).NotTo(gomega.BeNil())
1320 })
1321 })
1322 ginkgo.Describe("parseExtras", func() {
1323 ginkgo.It("parses valid JSON extras from params", func() {
1324 params := &types.Params{"extras": `{"key":"value"}`}
1325 config := &Config{}
1326 result, err := service.payloadBuilder.ParseExtras(params, config)
1327 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1328 gomega.Expect(result).To(gomega.Equal(map[string]any{"key": "value"}))
1329 })
1330 ginkgo.It("returns config extras when no params extras", func() {
1331 params := &types.Params{}
1332 config := &Config{Extras: map[string]any{"config": "value"}}
1333 result, err := service.payloadBuilder.ParseExtras(params, config)
1334 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1335 gomega.Expect(result).To(gomega.Equal(map[string]any{"config": "value"}))
1336 })
1337 })
1338
1339 ginkgo.Describe("validateDate", func() {
1340 ginkgo.It("returns empty string for empty input", func() {
1341 result, err := service.validator.ValidateDate("")
1342 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1343 gomega.Expect(result).To(gomega.Equal(""))
1344 })
1345 ginkgo.It("validates RFC3339 format correctly", func() {
1346 input := TestDateRFC
1347 result, err := service.validator.ValidateDate(input)
1348 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1349 gomega.Expect(result).To(gomega.Equal(input))
1350 })
1351 ginkgo.It("validates RFC3339 with timezone offset", func() {
1352 input := "2023-12-04T20:00:00+05:00"
1353 result, err := service.validator.ValidateDate(input)
1354 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1355 gomega.Expect(result).To(gomega.Equal("2023-12-04T15:00:00Z"))
1356 })
1357 ginkgo.It("validates RFC3339 without timezone (assumes UTC)", func() {
1358 input := "2023-12-04T20:00:00"
1359 result, err := service.validator.ValidateDate(input)
1360 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1361 gomega.Expect(result).To(gomega.Equal("2023-12-04T20:00:00Z"))
1362 })
1363 ginkgo.It("validates Unix timestamp seconds", func() {
1364 input := "1701720000" // 2023-12-04T20:00:00Z
1365 result, err := service.validator.ValidateDate(input)
1366 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1367 gomega.Expect(result).To(gomega.Equal("2023-12-04T20:00:00Z"))
1368 })
1369 ginkgo.It("validates basic date-time format", func() {
1370 input := "2023-12-04 20:00:00"
1371 result, err := service.validator.ValidateDate(input)
1372 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1373 gomega.Expect(result).To(gomega.Equal("2023-12-04T20:00:00Z"))
1374 })
1375 ginkgo.It("handles zero Unix timestamp", func() {
1376 input := "0"
1377 result, err := service.validator.ValidateDate(input)
1378 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1379 gomega.Expect(result).To(gomega.Equal("1970-01-01T00:00:00Z"))
1380 })
1381 ginkgo.It("handles negative Unix timestamp", func() {
1382 input := "-1"
1383 result, err := service.validator.ValidateDate(input)
1384 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1385 gomega.Expect(result).To(gomega.Equal("1969-12-31T23:59:59Z"))
1386 })
1387 ginkgo.It("handles large Unix timestamp", func() {
1388 input := "2147483647" // Max int32
1389 result, err := service.validator.ValidateDate(input)
1390 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1391 gomega.Expect(result).To(gomega.Equal("2038-01-19T03:14:07Z"))
1392 })
1393 ginkgo.It("returns error for invalid RFC3339 format", func() {
1394 input := "2023-13-04T20:00:00Z" // Invalid month
1395 result, err := service.validator.ValidateDate(input)
1396 gomega.Expect(err).To(gomega.MatchError(ErrInvalidDate))
1397 gomega.Expect(result).To(gomega.Equal(""))
1398 })
1399 ginkgo.It("returns error for invalid date string", func() {
1400 input := "not-a-date"
1401 result, err := service.validator.ValidateDate(input)
1402 gomega.Expect(err).To(gomega.MatchError(ErrInvalidDate))
1403 gomega.Expect(result).To(gomega.Equal(""))
1404 })
1405 ginkgo.It("returns error for malformed RFC3339", func() {
1406 input := "2023-13-04T20:00:00Z" // Invalid month
1407 result, err := service.validator.ValidateDate(input)
1408 gomega.Expect(err).To(gomega.MatchError(ErrInvalidDate))
1409 gomega.Expect(result).To(gomega.Equal(""))
1410 })
1411 ginkgo.It("returns error for invalid Unix timestamp", func() {
1412 input := "abc123"
1413 result, err := service.validator.ValidateDate(input)
1414 gomega.Expect(err).To(gomega.MatchError(ErrInvalidDate))
1415 gomega.Expect(result).To(gomega.Equal(""))
1416 })
1417 ginkgo.It("returns error for Unix timestamp with decimal", func() {
1418 input := "1701720000.5"
1419 result, err := service.validator.ValidateDate(input)
1420 gomega.Expect(err).To(gomega.MatchError(ErrInvalidDate))
1421 gomega.Expect(result).To(gomega.Equal(""))
1422 })
1423 ginkgo.It("returns error for date with invalid separators", func() {
1424 input := "2023/12/04 20:00:00"
1425 result, err := service.validator.ValidateDate(input)
1426 gomega.Expect(err).To(gomega.MatchError(ErrInvalidDate))
1427 gomega.Expect(result).To(gomega.Equal(""))
1428 })
1429 ginkgo.It("returns error for date with extra characters", func() {
1430 input := "2023-12-04T20:00:00Z extra"
1431 result, err := service.validator.ValidateDate(input)
1432 gomega.Expect(err).To(gomega.MatchError(ErrInvalidDate))
1433 gomega.Expect(result).To(gomega.Equal(""))
1434 })
1435 ginkgo.It("handles RFC3339Nano format", func() {
1436 input := "2023-12-04T20:00:00.123456789Z"
1437 result, err := service.validator.ValidateDate(input)
1438 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1439 gomega.Expect(result).
1440 To(gomega.Equal("2023-12-04T20:00:00Z"))
1441 // Nanoseconds are truncated to RFC3339
1442 })
1443 ginkgo.It("validates RFC3339 with +00:00 timezone", func() {
1444 input := "2023-12-04T20:00:00+00:00"
1445 result, err := service.validator.ValidateDate(input)
1446 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1447 gomega.Expect(result).To(gomega.Equal("2023-12-04T20:00:00Z"))
1448 })
1449 ginkgo.It("validates RFC3339 with -08:00 timezone", func() {
1450 input := "2023-12-04T20:00:00-08:00"
1451 result, err := service.validator.ValidateDate(input)
1452 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1453 gomega.Expect(result).To(gomega.Equal("2023-12-05T04:00:00Z"))
1454 })
1455 ginkgo.It("validates Unix timestamp with leading zeros", func() {
1456 input := "0001701720000"
1457 result, err := service.validator.ValidateDate(input)
1458 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1459 gomega.Expect(result).To(gomega.Equal("2023-12-04T20:00:00Z"))
1460 })
1461 ginkgo.It("validates Unix timestamp for 2021-01-01", func() {
1462 input := "1609459200"
1463 result, err := service.validator.ValidateDate(input)
1464 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1465 gomega.Expect(result).To(gomega.Equal("2021-01-01T00:00:00Z"))
1466 })
1467 ginkgo.It("returns error for date-only format", func() {
1468 input := "2023-12-04"
1469 result, err := service.validator.ValidateDate(input)
1470 gomega.Expect(err).To(gomega.MatchError(ErrInvalidDate))
1471 gomega.Expect(result).To(gomega.Equal(""))
1472 })
1473 ginkgo.It("returns error for time-only format", func() {
1474 input := "20:00:00"
1475 result, err := service.validator.ValidateDate(input)
1476 gomega.Expect(err).To(gomega.MatchError(ErrInvalidDate))
1477 gomega.Expect(result).To(gomega.Equal(""))
1478 })
1479 })
1480 })
1481 })
1482
1483 // CreateClient creates a client with the given transport.
1484 func (m *MockHTTPClientManager) CreateClient(transport *http.Transport) *http.Client {
1485 if transport == nil {
1486 return &http.Client{
1487 Transport: http.DefaultTransport,
1488 Timeout: 10 * time.Second,
1489 }
1490 }
1491
1492 return &http.Client{
1493 Transport: transport,
1494 Timeout: 10 * time.Second,
1495 }
1496 }
1497
1498 // CreateTransport creates a basic HTTP transport for the mock manager.
1499 func (m *MockHTTPClientManager) CreateTransport(_ *Config) *http.Transport {
1500 if m.Transport != nil {
1501 return m.Transport
1502 }
1503
1504 // Return nil to use the default transport, avoiding nil dereferences
1505 return nil
1506 }
1507
1508 // TestGotify runs the Ginkgo test suite for the Gotify package.
1509 func TestGotify(t *testing.T) {
1510 // Register gomega handler before any parallel tests run
1511 gomega.RegisterFailHandler(ginkgo.Fail)
1512 t.Parallel()
1513 ginkgo.RunSpecs(t, "Shoutrrr Gotify Suite")
1514 }
1515
1516 // TestMain sets up gomega for all tests before running them.
1517 // This ensures gomega state is initialized once, avoiding race conditions
1518 // when tests run in parallel.
1519 func TestMain(m *testing.M) {
1520 // Set up gomega with a fail handler for all tests
1521 gomega.RegisterFailHandler(ginkgo.Fail)
1522 flag.Parse()
1523 os.Exit(m.Run())
1524 }
1525
1526 // TestSend tests basic message sending functionality.
1527 func TestSend(t *testing.T) {
1528 t.Parallel()
1529
1530 service := &Service{}
1531 logger := log.New(os.Stderr, "Test", log.LstdFlags)
1532 service.SetLogger(logger)
1533
1534 activateHTTPMock(t)
1535
1536 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.ddd")
1537
1538 err := service.Initialize(serviceURL, logger)
1539 if err != nil {
1540 t.Fatalf("failed to initialize service: %v", err)
1541 }
1542
1543 mockManager := &MockHTTPClientManager{}
1544 service.httpClientManager = mockManager
1545 // Force recreation of client with mock transport
1546 service.httpClient = nil
1547 service.client = nil
1548
1549 httpmock.RegisterResponder(
1550 "POST",
1551 TargetURL,
1552 testutils.JSONRespondMust(200, map[string]any{
1553 "id": float64(1),
1554 "appid": float64(1),
1555 "message": "Message",
1556 "title": "Shoutrrr notification",
1557 "priority": float64(0),
1558 "date": "2023-01-01T00:00:00Z",
1559 }),
1560 )
1561
1562 err = service.Send("Message", nil)
1563 if err != nil {
1564 t.Fatalf("send failed: %v", err)
1565 }
1566 }
1567
1568 // TestSendWithPriority tests sending a message with a custom priority.
1569 func TestSendWithPriority(t *testing.T) {
1570 t.Parallel()
1571
1572 service := &Service{}
1573 logger := log.New(os.Stderr, "Test", log.LstdFlags)
1574 service.SetLogger(logger)
1575
1576 activateHTTPMock(t)
1577
1578 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.ddd")
1579
1580 err := service.Initialize(serviceURL, logger)
1581 if err != nil {
1582 t.Fatalf("failed to initialize service: %v", err)
1583 }
1584
1585 mockManager := &MockHTTPClientManager{}
1586 service.httpClientManager = mockManager
1587 // Force recreation of client with mock transport
1588 service.httpClient = nil
1589 service.client = nil
1590
1591 httpmock.RegisterResponder(
1592 "POST",
1593 TargetURL,
1594 func(req *http.Request) (*http.Response, error) {
1595 var requestBody map[string]any
1596 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
1597 return nil, err
1598 }
1599
1600 if requestBody["priority"] != float64(5) {
1601 return nil, fmt.Errorf("expected priority 5, got %v", requestBody["priority"])
1602 }
1603
1604 return testutils.JSONRespondMust(200, map[string]any{
1605 "id": float64(1),
1606 "appid": float64(1),
1607 "message": "Message",
1608 "title": "Shoutrrr notification",
1609 "priority": float64(5),
1610 "date": "2023-01-01T00:00:00Z",
1611 })(req)
1612 },
1613 )
1614
1615 params := types.Params{"priority": "5"}
1616
1617 err = service.Send("Message", &params)
1618 if err != nil {
1619 t.Fatalf("send failed: %v", err)
1620 }
1621 }
1622
1623 // TestSendWithTitle tests sending a message with a custom title.
1624 func TestSendWithTitle(t *testing.T) {
1625 t.Parallel()
1626
1627 service := &Service{}
1628 logger := log.New(os.Stderr, "Test", log.LstdFlags)
1629 service.SetLogger(logger)
1630
1631 activateHTTPMock(t)
1632
1633 serviceURL := testutils.URLMust("gotify://my.gotify.tld/Aaa.bbb.ccc.ddd")
1634
1635 err := service.Initialize(serviceURL, logger)
1636 if err != nil {
1637 t.Fatalf("failed to initialize service: %v", err)
1638 }
1639
1640 mockManager := &MockHTTPClientManager{}
1641 service.httpClientManager = mockManager
1642 // Force recreation of client with mock transport
1643 service.httpClient = nil
1644 service.client = nil
1645
1646 httpmock.RegisterResponder(
1647 "POST",
1648 TargetURL,
1649 func(req *http.Request) (*http.Response, error) {
1650 var requestBody map[string]any
1651 if err := json.NewDecoder(req.Body).Decode(&requestBody); err != nil {
1652 return nil, err
1653 }
1654
1655 if requestBody["title"] != "Custom Title" {
1656 return nil, fmt.Errorf("expected title 'Custom Title', got %v", requestBody["title"])
1657 }
1658
1659 return testutils.JSONRespondMust(200, map[string]any{
1660 "id": float64(1),
1661 "appid": float64(1),
1662 "message": "Message",
1663 "title": "Custom Title",
1664 "priority": float64(0),
1665 "date": "2023-01-01T00:00:00Z",
1666 })(req)
1667 },
1668 )
1669
1670 params := types.Params{"title": "Custom Title"}
1671
1672 err = service.Send("Message", &params)
1673 if err != nil {
1674 t.Fatalf("send failed: %v", err)
1675 }
1676 }
1677
1678 // TestTimeout tests timeout handling using synctest for instant execution.
1679 func TestTimeout(t *testing.T) {
1680 t.Parallel()
1681 synctest.Test(t, func(t *testing.T) {
1682 // Create fake network connection
1683 srvConn, cliConn := net.Pipe()
1684
1685 defer func() { _ = srvConn.Close() }()
1686 defer func() { _ = cliConn.Close() }()
1687
1688 errChan := make(chan error, 1)
1689
1690 // Create service with custom HTTP client using fake connection
1691 service := &Service{}
1692 logger := log.New(os.Stderr, "Test", log.LstdFlags)
1693 service.SetLogger(logger)
1694
1695 serviceURL := testutils.URLMust("gotify://test.tld/Aaa.bbb.ccc.ddd")
1696 err := service.Initialize(serviceURL, logger)
1697 gomega.Expect(err).NotTo(gomega.HaveOccurred())
1698
1699 // Use MockHTTPClientManager with custom transport for fake connection
1700 mockManager := &MockHTTPClientManager{
1701 Transport: &http.Transport{
1702 DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
1703 return cliConn, nil
1704 },
1705 },
1706 }
1707 service.httpClientManager = mockManager
1708 // Force recreation of client with custom transport
1709 service.httpClient = nil
1710 service.client = nil
1711
1712 // Simulate slow server in goroutine
1713 go func() {
1714 req, err := http.ReadRequest(bufio.NewReader(srvConn))
1715 if err != nil {
1716 return
1717 }
1718 // Simulate slow response
1719 time.Sleep(15 * time.Second)
1720
1721 resp, err := testutils.JSONRespondMust(200, map[string]any{
1722 "id": float64(1),
1723 "appid": float64(1),
1724 "message": "Message",
1725 "title": "Shoutrrr notification",
1726 "priority": float64(0),
1727 "date": "2023-01-01T00:00:00Z",
1728 })(req)
1729 if err != nil {
1730 return
1731 }
1732
1733 err = resp.Write(srvConn)
1734 if err != nil {
1735 errChan <- err
1736
1737 return
1738 }
1739
1740 if err := resp.Body.Close(); err != nil {
1741 errChan <- err
1742 }
1743 }()
1744
1745 // Send request and expect timeout
1746 err = service.Send("Message", nil)
1747 gomega.Expect(err).To(gomega.HaveOccurred())
1748 gomega.Expect(err.Error()).To(gomega.ContainSubstring("context deadline exceeded"))
1749
1750 select {
1751 case writeErr := <-errChan:
1752 t.Fatalf("failed to write response: %v", writeErr)
1753 default:
1754 }
1755 })
1756 }
1757
1758 // activateHTTPMock safely activates httpmock with a mutex to prevent race conditions
1759 // when multiple tests run in parallel. It ensures proper activation/deactivation ordering.
1760 func activateHTTPMock(t *testing.T) {
1761 t.Helper()
1762 httpmockActivateMutex.Lock()
1763 // Register cleanup to unlock the mutex after httpmock is deactivated
1764 t.Cleanup(func() {
1765 httpmock.DeactivateAndReset()
1766 httpmockActivateMutex.Unlock()
1767 })
1768 httpmock.Activate()
1769 }
1770
1771 // activateHTTPMockGinkgo safely activates httpmock for Ginkgo tests.
1772 // Note: Ginkgo specs run serially within the Ginkgo suite, so no mutex is needed.
1773 // The mutex is only needed to serialize between Ginkgo tests and standalone tests
1774 // when they both run in parallel (via t.Parallel()). The standalone tests use
1775 // activateHTTPMock which handles the mutex protection.
1776 func activateHTTPMockGinkgo() {
1777 // No mutex needed for Ginkgo - specs run serially within the suite
1778 // The mutex protection is handled by standalone tests via activateHTTPMock(t)
1779 // which ensures proper ordering when tests run in parallel
1780 httpmock.Activate()
1781 }