Debian Codegraph @

pkg/services/push/mqtt/mqtt_test.go

raw
1 package mqtt
2
3 import (
4 "context"
5 "crypto/tls"
6 "net/url"
7 "sync"
8
9 ginkgo "github.com/onsi/ginkgo/v2"
10 gomega "github.com/onsi/gomega"
11
12 "github.com/nicholas-fedor/shoutrrr/pkg/services/standard"
13 "github.com/nicholas-fedor/shoutrrr/pkg/types"
14 )
15
16 var _ = ginkgo.Describe("Service", func() {
17 var (
18 service *Service
19 testURL *url.URL
20 logger types.StdLogger
21 )
22
23 ginkgo.BeforeEach(func() {
24 service = &Service{}
25 logger = ginkgo.GinkgoT()
26 })
27
28 ginkgo.Describe("GetID", func() {
29 ginkgo.It("should return 'mqtt'", func() {
30 gomega.Expect(service.GetID()).To(gomega.Equal("mqtt"))
31 })
32
33 ginkgo.It("should return consistent ID across multiple calls", func() {
34 id1 := service.GetID()
35 id2 := service.GetID()
36 gomega.Expect(id1).To(gomega.Equal(id2))
37 gomega.Expect(id1).To(gomega.Equal("mqtt"))
38 })
39 })
40
41 ginkgo.Describe("getDefaultPortForScheme", func() {
42 ginkgo.It("should return 1883 for mqtt scheme", func() {
43 gomega.Expect(service.getDefaultPortForScheme("mqtt")).To(gomega.Equal(1883))
44 })
45
46 ginkgo.It("should return 8883 for mqtts scheme", func() {
47 gomega.Expect(service.getDefaultPortForScheme("mqtts")).To(gomega.Equal(8883))
48 })
49
50 ginkgo.It("should return 1883 for unknown scheme", func() {
51 gomega.Expect(service.getDefaultPortForScheme("unknown")).To(gomega.Equal(1883))
52 })
53
54 ginkgo.It("should return 1883 for empty scheme", func() {
55 gomega.Expect(service.getDefaultPortForScheme("")).To(gomega.Equal(1883))
56 })
57
58 ginkgo.It("should return 1883 for http scheme (treated as non-secure)", func() {
59 gomega.Expect(service.getDefaultPortForScheme("http")).To(gomega.Equal(1883))
60 })
61
62 ginkgo.It("should be case-sensitive for mqtts scheme", func() {
63 // "MQTTS" is not the same as "mqtts", so it returns default
64 gomega.Expect(service.getDefaultPortForScheme("MQTTS")).To(gomega.Equal(1883))
65 })
66 })
67
68 ginkgo.Describe("Initialize", func() {
69 ginkgo.BeforeEach(func() {
70 var err error
71
72 testURL, err = url.Parse("mqtt://broker.example.com:1883/notifications/alerts")
73 gomega.Expect(err).NotTo(gomega.HaveOccurred())
74 })
75
76 ginkgo.It("should parse valid URL successfully", func() {
77 err := service.Initialize(testURL, logger)
78 gomega.Expect(err).NotTo(gomega.HaveOccurred())
79 gomega.Expect(service.Config).NotTo(gomega.BeNil())
80 })
81
82 ginkgo.It("should set default port for mqtt scheme when port specified in URL", func() {
83 mqttURL, err := url.Parse("mqtt://broker.example.com:1883/test/topic")
84 gomega.Expect(err).NotTo(gomega.HaveOccurred())
85
86 err = service.Initialize(mqttURL, logger)
87 gomega.Expect(err).NotTo(gomega.HaveOccurred())
88 gomega.Expect(service.Config.Port).To(gomega.Equal(1883))
89 })
90
91 ginkgo.It("should set default port for mqtts scheme when port specified in URL", func() {
92 mqttsURL, err := url.Parse("mqtts://broker.example.com:8883/test/topic")
93 gomega.Expect(err).NotTo(gomega.HaveOccurred())
94
95 err = service.Initialize(mqttsURL, logger)
96 gomega.Expect(err).NotTo(gomega.HaveOccurred())
97 gomega.Expect(service.Config.Port).To(gomega.Equal(8883))
98 })
99
100 ginkgo.It("should parse query parameters", func() {
101 serviceURL, err := url.Parse(
102 "mqtt://broker.example.com:1883/test/topic?clientid=myclient&qos=1&retained=yes",
103 )
104 gomega.Expect(err).NotTo(gomega.HaveOccurred())
105
106 err = service.Initialize(serviceURL, logger)
107 gomega.Expect(err).NotTo(gomega.HaveOccurred())
108 gomega.Expect(service.Config.ClientID).To(gomega.Equal("myclient"))
109 gomega.Expect(service.Config.QoS).To(gomega.Equal(QoSAtLeastOnce))
110 gomega.Expect(service.Config.Retained).To(gomega.BeTrue())
111 })
112
113 ginkgo.It("should store config correctly", func() {
114 serviceURL, err := url.Parse(
115 "mqtt://user:[email protected]:1883/notifications/alerts",
116 )
117 gomega.Expect(err).NotTo(gomega.HaveOccurred())
118
119 err = service.Initialize(serviceURL, logger)
120 gomega.Expect(err).NotTo(gomega.HaveOccurred())
121 gomega.Expect(service.Config.Host).To(gomega.Equal("broker.example.com"))
122 gomega.Expect(service.Config.Port).To(gomega.Equal(1883))
123 gomega.Expect(service.Config.Topic).To(gomega.Equal("notifications/alerts"))
124 gomega.Expect(service.Config.Username).To(gomega.Equal("user"))
125 gomega.Expect(service.Config.Password).To(gomega.Equal("pass"))
126 })
127
128 ginkgo.It("should set logger", func() {
129 err := service.Initialize(testURL, logger)
130 gomega.Expect(err).NotTo(gomega.HaveOccurred())
131 // Logger is set via SetLogger, we verify no error occurred
132 })
133
134 ginkgo.It("should parse URL with username only", func() {
135 serviceURL, err := url.Parse("mqtt://[email protected]:1883/test/topic")
136 gomega.Expect(err).NotTo(gomega.HaveOccurred())
137
138 err = service.Initialize(serviceURL, logger)
139 gomega.Expect(err).NotTo(gomega.HaveOccurred())
140 gomega.Expect(service.Config.Username).To(gomega.Equal("user"))
141 gomega.Expect(service.Config.Password).To(gomega.BeEmpty())
142 })
143
144 ginkgo.It("should parse URL without credentials", func() {
145 serviceURL, err := url.Parse("mqtt://broker.example.com:1883/test/topic")
146 gomega.Expect(err).NotTo(gomega.HaveOccurred())
147
148 err = service.Initialize(serviceURL, logger)
149 gomega.Expect(err).NotTo(gomega.HaveOccurred())
150 gomega.Expect(service.Config.Username).To(gomega.BeEmpty())
151 gomega.Expect(service.Config.Password).To(gomega.BeEmpty())
152 })
153
154 ginkgo.It("should parse URL with custom port", func() {
155 serviceURL, err := url.Parse("mqtt://broker.example.com:9999/test/topic")
156 gomega.Expect(err).NotTo(gomega.HaveOccurred())
157
158 err = service.Initialize(serviceURL, logger)
159 gomega.Expect(err).NotTo(gomega.HaveOccurred())
160 gomega.Expect(service.Config.Port).To(gomega.Equal(9999))
161 })
162
163 ginkgo.It("should apply default values from struct tags", func() {
164 serviceURL, err := url.Parse("mqtt://broker.example.com:1883/test/topic")
165 gomega.Expect(err).NotTo(gomega.HaveOccurred())
166
167 err = service.Initialize(serviceURL, logger)
168 gomega.Expect(err).NotTo(gomega.HaveOccurred())
169 gomega.Expect(service.Config.ClientID).To(gomega.Equal("shoutrrr"))
170 gomega.Expect(service.Config.QoS).To(gomega.Equal(QoSAtMostOnce))
171 gomega.Expect(service.Config.Retained).To(gomega.BeFalse())
172 gomega.Expect(service.Config.CleanSession).To(gomega.BeTrue())
173 })
174
175 ginkgo.It("should parse URL with DisableTLS parameter", func() {
176 serviceURL, err := url.Parse("mqtts://broker.example.com:8883/test/topic?disabletls=yes")
177 gomega.Expect(err).NotTo(gomega.HaveOccurred())
178
179 err = service.Initialize(serviceURL, logger)
180 gomega.Expect(err).NotTo(gomega.HaveOccurred())
181 gomega.Expect(service.Config.DisableTLS).To(gomega.BeTrue())
182 })
183
184 ginkgo.It("should parse URL with DisableTLSVerification parameter", func() {
185 serviceURL, err := url.Parse(
186 "mqtts://broker.example.com:8883/test/topic?disabletlsverification=yes",
187 )
188 gomega.Expect(err).NotTo(gomega.HaveOccurred())
189
190 err = service.Initialize(serviceURL, logger)
191 gomega.Expect(err).NotTo(gomega.HaveOccurred())
192 gomega.Expect(service.Config.DisableTLSVerification).To(gomega.BeTrue())
193 })
194
195 ginkgo.It("should parse URL with CleanSession=false", func() {
196 serviceURL, err := url.Parse("mqtt://broker.example.com:1883/test/topic?cleansession=no")
197 gomega.Expect(err).NotTo(gomega.HaveOccurred())
198
199 err = service.Initialize(serviceURL, logger)
200 gomega.Expect(err).NotTo(gomega.HaveOccurred())
201 gomega.Expect(service.Config.CleanSession).To(gomega.BeFalse())
202 })
203
204 ginkgo.It("should handle deeply nested topic paths", func() {
205 serviceURL, err := url.Parse(
206 "mqtt://broker.example.com:1883/level1/level2/level3/level4/level5",
207 )
208 gomega.Expect(err).NotTo(gomega.HaveOccurred())
209
210 err = service.Initialize(serviceURL, logger)
211 gomega.Expect(err).NotTo(gomega.HaveOccurred())
212 gomega.Expect(service.Config.Topic).
213 To(gomega.Equal("level1/level2/level3/level4/level5"))
214 })
215
216 ginkgo.It("should initialize pkr field", func() {
217 err := service.Initialize(testURL, logger)
218 gomega.Expect(err).NotTo(gomega.HaveOccurred())
219 // pkr is unexported, but we can verify it works via the config
220 gomega.Expect(service.Config).NotTo(gomega.BeNil())
221 })
222 })
223
224 ginkgo.Describe("getCancel", func() {
225 ginkgo.It("should return valid cancel function", func() {
226 cancel := service.getCancel()
227 gomega.Expect(cancel).NotTo(gomega.BeNil())
228 })
229
230 ginkgo.It("should initialize context field", func() {
231 service.getCancel()
232 // ctx is unexported, but we verify it was set by checking cancel is not nil
233 gomega.Expect(service.cancel).NotTo(gomega.BeNil())
234 })
235
236 ginkgo.It(
237 "should be thread-safe and return same cancel function on multiple calls",
238 func() {
239 var wg sync.WaitGroup
240
241 cancels := make([]context.CancelFunc, 10)
242
243 for i := range 10 {
244 wg.Add(1)
245
246 go func(idx int) {
247 defer wg.Done()
248
249 cancels[idx] = service.getCancel()
250 }(i)
251 }
252
253 wg.Wait()
254
255 // All cancel functions should be non-nil
256 for i := range 10 {
257 gomega.Expect(cancels[i]).NotTo(gomega.BeNil())
258 }
259 },
260 )
261
262 ginkgo.It("should allow cancel to be called without panic", func() {
263 cancel := service.getCancel()
264
265 gomega.Expect(func() { cancel() }).NotTo(gomega.Panic())
266 })
267
268 ginkgo.It("should allow cancel to be called multiple times safely", func() {
269 cancel := service.getCancel()
270 cancel()
271 gomega.Expect(func() { cancel() }).NotTo(gomega.Panic())
272 })
273 })
274
275 ginkgo.Describe("createTLSConfig", func() {
276 ginkgo.BeforeEach(func() {
277 // Initialize the standard logger to avoid nil pointer dereference
278 service.Standard = standard.Standard{}
279 service.SetLogger(logger)
280 service.Config = &Config{}
281 })
282
283 ginkgo.It("should create TLS config with verification enabled by default", func() {
284 service.Config.DisableTLSVerification = false
285
286 tlsConfig := service.createTLSConfig()
287
288 gomega.Expect(tlsConfig).NotTo(gomega.BeNil())
289 gomega.Expect(tlsConfig.InsecureSkipVerify).To(gomega.BeFalse())
290 })
291
292 ginkgo.It("should create TLS config without verification when disabled", func() {
293 service.Config.DisableTLSVerification = true
294
295 tlsConfig := service.createTLSConfig()
296
297 gomega.Expect(tlsConfig).NotTo(gomega.BeNil())
298 gomega.Expect(tlsConfig.InsecureSkipVerify).To(gomega.BeTrue())
299 })
300
301 ginkgo.It("should set minimum TLS version to 1.2", func() {
302 tlsConfig := service.createTLSConfig()
303
304 gomega.Expect(tlsConfig).NotTo(gomega.BeNil())
305 gomega.Expect(tlsConfig.MinVersion).To(gomega.Equal(uint16(tls.VersionTLS12)))
306 })
307
308 ginkgo.It("should return config even with nil Config.DisableTLSVerification", func() {
309 // DisableTLSVerification defaults to false
310 tlsConfig := service.createTLSConfig()
311
312 gomega.Expect(tlsConfig).NotTo(gomega.BeNil())
313 })
314
315 ginkgo.It("should create independent TLS configs on multiple calls", func() {
316 tlsConfig1 := service.createTLSConfig()
317 tlsConfig2 := service.createTLSConfig()
318
319 // Each call creates a new config
320 gomega.Expect(tlsConfig1).NotTo(gomega.BeIdenticalTo(tlsConfig2))
321 })
322 })
323
324 ginkgo.Describe("Close", func() {
325 ginkgo.BeforeEach(func() {
326 // Initialize the standard logger to avoid nil pointer dereference
327 service.Standard = standard.Standard{}
328 service.SetLogger(logger)
329 })
330
331 ginkgo.It("should handle nil connection manager gracefully", func() {
332 service.connectionManager = nil
333 service.closeOnce = sync.Once{} // Reset for this test
334
335 err := service.Close()
336 gomega.Expect(err).NotTo(gomega.HaveOccurred())
337 })
338
339 ginkgo.It("should be idempotent - safe to call multiple times", func() {
340 service.connectionManager = nil
341 service.closeOnce = sync.Once{} // Reset
342
343 err1 := service.Close()
344 err2 := service.Close()
345 err3 := service.Close()
346
347 gomega.Expect(err1).NotTo(gomega.HaveOccurred())
348 gomega.Expect(err2).NotTo(gomega.HaveOccurred())
349 gomega.Expect(err3).NotTo(gomega.HaveOccurred())
350 })
351
352 ginkgo.It("should return same error on subsequent calls", func() {
353 service.connectionManager = nil
354 service.closeOnce = sync.Once{} // Reset
355 service.closeErr = nil // Reset
356
357 // First close
358 _ = service.Close()
359
360 // Subsequent closes should return the same result (nil)
361 err1 := service.Close()
362 err2 := service.Close()
363
364 gomega.Expect(err1).ToNot(gomega.HaveOccurred())
365 gomega.Expect(err2).ToNot(gomega.HaveOccurred())
366 })
367
368 ginkgo.It("should handle close without initialized cancel function", func() {
369 service.connectionManager = nil
370 service.cancel = nil
371 service.closeOnce = sync.Once{} // Reset
372
373 err := service.Close()
374 gomega.Expect(err).NotTo(gomega.HaveOccurred())
375 })
376
377 ginkgo.It("should cancel context when cancel function exists", func() {
378 service.connectionManager = nil
379 service.closeOnce = sync.Once{} // Reset
380
381 // Initialize the cancel function
382 _ = service.getCancel()
383 gomega.Expect(service.cancel).NotTo(gomega.BeNil())
384
385 // Close should call cancel without error
386 err := service.Close()
387 gomega.Expect(err).NotTo(gomega.HaveOccurred())
388 })
389 })
390
391 ginkgo.Describe("Service Constants", func() {
392 ginkgo.It("should have correct Scheme constant", func() {
393 gomega.Expect(Scheme).To(gomega.Equal("mqtt"))
394 })
395
396 ginkgo.It("should have correct SecureScheme constant", func() {
397 gomega.Expect(SchemeTLS).To(gomega.Equal("mqtts"))
398 })
399 })
400
401 ginkgo.Describe("Service Struct", func() {
402 ginkgo.It("should initialize with zero values", func() {
403 svc := &Service{}
404 gomega.Expect(svc.Config).To(gomega.BeNil())
405 gomega.Expect(svc.connectionManager).To(gomega.BeNil())
406 gomega.Expect(svc.connectionInitialized).To(gomega.BeFalse())
407 })
408
409 ginkgo.It("should have correct default state after initialization", func() {
410 svc := &Service{}
411 serviceURL, err := url.Parse("mqtt://broker.example.com:1883/test/topic")
412 gomega.Expect(err).NotTo(gomega.HaveOccurred())
413
414 err = svc.Initialize(serviceURL, logger)
415 gomega.Expect(err).NotTo(gomega.HaveOccurred())
416 gomega.Expect(svc.Config).NotTo(gomega.BeNil())
417 gomega.Expect(svc.connectionInitialized).To(gomega.BeFalse())
418 gomega.Expect(svc.connectionManager).To(gomega.BeNil())
419 })
420 })
421 })