Debian Codegraph @

testing/integration/mqtt/errors_test.go

raw
1 package mqtt_test
2
3 import (
4 "context"
5 "errors"
6 "testing"
7 "testing/synctest"
8
9 "github.com/stretchr/testify/mock"
10 "github.com/stretchr/testify/require"
11
12 "github.com/nicholas-fedor/shoutrrr/pkg/services/push/mqtt"
13 )
14
15 func TestSendWithConnectionError(t *testing.T) {
16 t.Parallel()
17 synctest.Test(t, func(t *testing.T) {
18 mockManager := &MockConnectionManager{}
19 mockManager.On("AwaitConnection", mock.Anything).
20 Return(errors.New("connection refused")).
21 Once()
22
23 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
24
25 err := service.Send("Test message", nil)
26 require.Error(t, err)
27 require.Contains(t, err.Error(), "connecting to MQTT broker")
28
29 mockManager.AssertExpectations(t)
30 })
31 }
32
33 func TestSendWithPublishError(t *testing.T) {
34 t.Parallel()
35 synctest.Test(t, func(t *testing.T) {
36 mockManager := &MockConnectionManager{}
37 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
38 mockManager.On("Publish", mock.Anything, mock.Anything).
39 Return(nil, errors.New("network error")).
40 Once()
41
42 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
43
44 err := service.Send("Test message", nil)
45 require.Error(t, err)
46 require.Contains(t, err.Error(), "publishing to MQTT topic")
47
48 mockManager.AssertExpectations(t)
49 })
50 }
51
52 func TestSendWithFailureReasonCode(t *testing.T) {
53 t.Parallel()
54 synctest.Test(t, func(t *testing.T) {
55 tests := []struct {
56 name string
57 reasonCode byte
58 reasonString string
59 }{
60 {
61 name: "unspecified error",
62 reasonCode: 0x80,
63 reasonString: "Unspecified error",
64 },
65 {
66 name: "malformed packet",
67 reasonCode: 0x81,
68 reasonString: "Malformed Packet",
69 },
70 {
71 name: "protocol error",
72 reasonCode: 0x82,
73 reasonString: "Protocol Error",
74 },
75 {
76 name: "implementation specific error",
77 reasonCode: 0x83,
78 reasonString: "Implementation specific error",
79 },
80 {
81 name: "unsupported protocol version",
82 reasonCode: 0x84,
83 reasonString: "Unsupported Protocol Version",
84 },
85 {
86 name: "client identifier not valid",
87 reasonCode: 0x85,
88 reasonString: "Client Identifier not valid",
89 },
90 {
91 name: "bad user name or password",
92 reasonCode: 0x86,
93 reasonString: "Bad User Name or Password",
94 },
95 {
96 name: "not authorized",
97 reasonCode: 0x87,
98 reasonString: "Not authorized",
99 },
100 }
101
102 for _, tt := range tests {
103 mockManager := &MockConnectionManager{}
104 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
105 mockManager.On("Publish", mock.Anything, mock.Anything).
106 Return(createMockPublishResponseWithReason(tt.reasonCode, tt.reasonString), nil).
107 Once()
108
109 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
110
111 err := service.Send("Test message", nil)
112 require.Error(t, err)
113
114 // Verify it's a PublishError
115 var publishErr mqtt.PublishError
116 require.ErrorAs(t, err, &publishErr)
117 require.Equal(t, tt.reasonCode, publishErr.ReasonCode)
118 require.Equal(t, tt.reasonString, publishErr.ReasonString)
119
120 mockManager.AssertExpectations(t)
121 }
122 })
123 }
124
125 func TestSendWithReasonCodeNoReasonString(t *testing.T) {
126 t.Parallel()
127 synctest.Test(t, func(t *testing.T) {
128 mockManager := &MockConnectionManager{}
129 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
130 mockManager.On("Publish", mock.Anything, mock.Anything).
131 Return(createMockPublishResponse(0x80), nil). // Failure code without reason string
132 Once()
133
134 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
135
136 err := service.Send("Test message", nil)
137 require.Error(t, err)
138
139 var publishErr mqtt.PublishError
140 require.ErrorAs(t, err, &publishErr)
141 require.Equal(t, byte(0x80), publishErr.ReasonCode)
142 require.Empty(t, publishErr.ReasonString)
143
144 mockManager.AssertExpectations(t)
145 })
146 }
147
148 func TestSendWithInvalidQoS(t *testing.T) {
149 t.Parallel()
150 synctest.Test(t, func(t *testing.T) {
151 // Create service without mock manager - it should fail before connection
152 service := createTestService(t, "mqtt://broker.example.com/test/topic")
153
154 // Manually set invalid QoS
155 service.Config.QoS = 3
156
157 err := service.Send("Test message", nil)
158 require.Error(t, err)
159 require.Contains(t, err.Error(), "validating QoS")
160 })
161 }
162
163 func TestSendWithNegativeQoS(t *testing.T) {
164 t.Parallel()
165 synctest.Test(t, func(t *testing.T) {
166 // Create service without mock manager - it should fail before connection
167 service := createTestService(t, "mqtt://broker.example.com/test/topic")
168
169 // Manually set invalid QoS
170 service.Config.QoS = -1
171
172 err := service.Send("Test message", nil)
173 require.Error(t, err)
174 require.Contains(t, err.Error(), "validating QoS")
175 })
176 }
177
178 func TestDisconnectError(t *testing.T) {
179 t.Parallel()
180 synctest.Test(t, func(t *testing.T) {
181 mockManager := &MockConnectionManager{}
182 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
183 mockManager.On("Publish", mock.Anything, mock.Anything).
184 Return(createMockPublishResponse(0), nil).
185 Once()
186 mockManager.On("Disconnect", mock.Anything).
187 Return(errors.New("disconnect error")).
188 Once()
189
190 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
191
192 // Send a message first
193 err := service.Send("Test message", nil)
194 require.NoError(t, err)
195
196 // Close should return the disconnect error
197 err = service.Close()
198 require.Error(t, err)
199 require.Contains(t, err.Error(), "disconnecting from MQTT broker")
200
201 mockManager.AssertExpectations(t)
202 })
203 }
204
205 func TestCloseWithoutConnection(t *testing.T) {
206 t.Parallel()
207 synctest.Test(t, func(t *testing.T) {
208 // Create service without initializing connection
209 service := createTestService(t, "mqtt://broker.example.com/test/topic")
210
211 // Close should not error when connection was never established
212 err := service.Close()
213 require.NoError(t, err)
214 })
215 }
216
217 func TestCloseIdempotent(t *testing.T) {
218 t.Parallel()
219 synctest.Test(t, func(t *testing.T) {
220 mockManager := &MockConnectionManager{}
221 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
222 mockManager.On("Publish", mock.Anything, mock.Anything).
223 Return(createMockPublishResponse(0), nil).
224 Once()
225 mockManager.On("Disconnect", mock.Anything).Return(nil).Once()
226
227 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
228
229 // Send a message first
230 err := service.Send("Test message", nil)
231 require.NoError(t, err)
232
233 // First close
234 err = service.Close()
235 require.NoError(t, err)
236
237 // Second close should return same result (no error, no panic)
238 err = service.Close()
239 require.NoError(t, err)
240
241 // Disconnect should only be called once
242 mockManager.AssertExpectations(t)
243 })
244 }
245
246 func TestContextCancellationDuringAwaitConnection(t *testing.T) {
247 t.Parallel()
248 synctest.Test(t, func(t *testing.T) {
249 mockManager := &MockConnectionManager{}
250 mockManager.On("AwaitConnection", mock.Anything).
251 Return(context.Canceled).
252 Once()
253
254 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
255
256 err := service.Send("Test message", nil)
257 require.Error(t, err)
258 require.Contains(t, err.Error(), "connecting to MQTT broker")
259
260 mockManager.AssertExpectations(t)
261 })
262 }
263
264 func TestContextDeadlineExceededDuringAwaitConnection(t *testing.T) {
265 t.Parallel()
266 synctest.Test(t, func(t *testing.T) {
267 mockManager := &MockConnectionManager{}
268 mockManager.On("AwaitConnection", mock.Anything).
269 Return(context.DeadlineExceeded).
270 Once()
271
272 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
273
274 err := service.Send("Test message", nil)
275 require.Error(t, err)
276 require.Contains(t, err.Error(), "connecting to MQTT broker")
277
278 mockManager.AssertExpectations(t)
279 })
280 }
281
282 func TestPublishErrorErrorMethod(t *testing.T) {
283 t.Parallel()
284
285 tests := []struct {
286 name string
287 reasonCode byte
288 reasonString string
289 expectedMsg string
290 }{
291 {
292 name: "with reason string",
293 reasonCode: 0x87,
294 reasonString: "Not authorized",
295 expectedMsg: "MQTT publish failed: reason code 0x87 - Not authorized",
296 },
297 {
298 name: "without reason string",
299 reasonCode: 0x80,
300 reasonString: "",
301 expectedMsg: "MQTT publish failed: reason code 0x80",
302 },
303 }
304
305 for _, tt := range tests {
306 err := mqtt.PublishError{
307 ReasonCode: tt.reasonCode,
308 ReasonString: tt.reasonString,
309 }
310
311 require.Equal(t, tt.expectedMsg, err.Error())
312 }
313 }
314
315 func TestIsFailureCode(t *testing.T) {
316 t.Parallel()
317
318 tests := []struct {
319 code byte
320 expected bool
321 }{
322 {0x00, false}, // Success
323 {0x01, false}, // Granted QoS 1
324 {0x02, false}, // Granted QoS 2
325 {0x10, false}, // No matching subscribers (not a failure)
326 {0x7F, false}, // Just below threshold
327 {0x80, true}, // Unspecified error
328 {0x87, true}, // Not authorized
329 {0xFF, true}, // Maximum value
330 }
331
332 for _, tt := range tests {
333 result := mqtt.IsFailureCode(tt.code)
334 require.Equal(t, tt.expected, result, "IsFailureCode(0x%02X)", tt.code)
335 }
336 }