Debian Codegraph @

testing/integration/mqtt/edge_cases_test.go

raw
1 package mqtt_test
2
3 import (
4 "strings"
5 "testing"
6 "testing/synctest"
7
8 "github.com/stretchr/testify/mock"
9 "github.com/stretchr/testify/require"
10 )
11
12 func TestPublishEmptyMessage(t *testing.T) {
13 t.Parallel()
14 synctest.Test(t, func(t *testing.T) {
15 mockManager := &MockConnectionManager{}
16 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
17 mockManager.On("Publish", mock.Anything, mock.Anything).
18 Return(createMockPublishResponse(0), nil).
19 Once()
20
21 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
22
23 err := service.Send("", nil)
24 require.NoError(t, err)
25
26 // Verify empty payload was sent
27 assertPublishPayload(t, mockManager, "")
28
29 mockManager.AssertExpectations(t)
30 })
31 }
32
33 func TestPublishVeryLongMessage(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(createMockPublishResponse(0), nil).
40 Once()
41
42 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
43
44 // Create a very long message (1MB)
45 longMessage := strings.Repeat("x", 1024*1024)
46
47 err := service.Send(longMessage, nil)
48 require.NoError(t, err)
49
50 // Verify the full payload was sent
51 assertPublishPayload(t, mockManager, longMessage)
52
53 mockManager.AssertExpectations(t)
54 })
55 }
56
57 func TestPublishSpecialCharactersInTopic(t *testing.T) {
58 t.Parallel()
59 synctest.Test(t, func(t *testing.T) {
60 tests := []struct {
61 name string
62 topic string
63 expectedTopic string
64 }{
65 {
66 name: "topic with underscores",
67 topic: "test_topic_name",
68 expectedTopic: "test_topic_name",
69 },
70 {
71 name: "topic with hyphens",
72 topic: "test-topic-name",
73 expectedTopic: "test-topic-name",
74 },
75 {
76 name: "topic with numbers",
77 topic: "test123/topic456",
78 expectedTopic: "test123/topic456",
79 },
80 {
81 name: "deep nested topic",
82 topic: "a/b/c/d/e/f/g/h",
83 expectedTopic: "a/b/c/d/e/f/g/h",
84 },
85 }
86
87 for _, tt := range tests {
88 mockManager := &MockConnectionManager{}
89 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
90 mockManager.On("Publish", mock.Anything, mock.Anything).
91 Return(createMockPublishResponse(0), nil).
92 Once()
93
94 url := "mqtt://broker.example.com/" + tt.topic
95 service := createTestService(t, url, mockManager)
96
97 err := service.Send("Test message", nil)
98 require.NoError(t, err)
99
100 assertPublishCalled(t, mockManager, tt.expectedTopic)
101
102 mockManager.AssertExpectations(t)
103 }
104 })
105 }
106
107 //nolint:gosmopolitan // Unicode characters used intentionally for testing rune handling
108 func TestPublishUnicodeInMessage(t *testing.T) {
109 t.Parallel()
110 synctest.Test(t, func(t *testing.T) {
111 tests := []struct {
112 name string
113 message string
114 }{
115 {"emoji", "Hello 👋 World 🌍"},
116 {"chinese", "你好世界"},
117 {"japanese", "こんにちは"},
118 {"arabic", "مرحبا بالعالم"},
119 {"russian", "Привет мир"},
120 {"mixed unicode", "Hello 世界 🌍 Привет"},
121 {"unicode with special chars", "Test™ © 2024 • ★ ♠"},
122 }
123
124 for _, tt := range tests {
125 mockManager := &MockConnectionManager{}
126 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
127 mockManager.On("Publish", mock.Anything, mock.Anything).
128 Return(createMockPublishResponse(0), nil).
129 Once()
130
131 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
132
133 err := service.Send(tt.message, nil)
134 require.NoError(t, err)
135
136 assertPublishPayload(t, mockManager, tt.message)
137
138 mockManager.AssertExpectations(t)
139 }
140 })
141 }
142
143 func TestPublishNewlinesInMessage(t *testing.T) {
144 t.Parallel()
145 synctest.Test(t, func(t *testing.T) {
146 tests := []struct {
147 name string
148 message string
149 }{
150 {"unix newlines", "Line1\nLine2\nLine3"},
151 {"windows newlines", "Line1\r\nLine2\r\nLine3"},
152 {"mixed newlines", "Line1\nLine2\r\nLine3"},
153 {"only newlines", "\n\n\n"},
154 }
155
156 for _, tt := range tests {
157 mockManager := &MockConnectionManager{}
158 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
159 mockManager.On("Publish", mock.Anything, mock.Anything).
160 Return(createMockPublishResponse(0), nil).
161 Once()
162
163 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
164
165 err := service.Send(tt.message, nil)
166 require.NoError(t, err)
167
168 assertPublishPayload(t, mockManager, tt.message)
169
170 mockManager.AssertExpectations(t)
171 }
172 })
173 }
174
175 func TestPublishTabsInMessage(t *testing.T) {
176 t.Parallel()
177 synctest.Test(t, func(t *testing.T) {
178 mockManager := &MockConnectionManager{}
179 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
180 mockManager.On("Publish", mock.Anything, mock.Anything).
181 Return(createMockPublishResponse(0), nil).
182 Once()
183
184 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
185
186 message := "Column1\tColumn2\tColumn3"
187 err := service.Send(message, nil)
188 require.NoError(t, err)
189
190 assertPublishPayload(t, mockManager, message)
191
192 mockManager.AssertExpectations(t)
193 })
194 }
195
196 func TestPublishJSONMessage(t *testing.T) {
197 t.Parallel()
198 synctest.Test(t, func(t *testing.T) {
199 mockManager := &MockConnectionManager{}
200 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
201 mockManager.On("Publish", mock.Anything, mock.Anything).
202 Return(createMockPublishResponse(0), nil).
203 Once()
204
205 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
206
207 jsonMessage := `{"key": "value", "nested": {"array": [1, 2, 3]}}`
208 err := service.Send(jsonMessage, nil)
209 require.NoError(t, err)
210
211 assertPublishPayload(t, mockManager, jsonMessage)
212
213 mockManager.AssertExpectations(t)
214 })
215 }
216
217 func TestPublishXMLMessage(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
226 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
227
228 xmlMessage := `<message><to>user</to><from>sender</from><body>Hello</body></message>`
229 err := service.Send(xmlMessage, nil)
230 require.NoError(t, err)
231
232 assertPublishPayload(t, mockManager, xmlMessage)
233
234 mockManager.AssertExpectations(t)
235 })
236 }
237
238 func TestPublishHTMLEntities(t *testing.T) {
239 t.Parallel()
240 synctest.Test(t, func(t *testing.T) {
241 mockManager := &MockConnectionManager{}
242 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
243 mockManager.On("Publish", mock.Anything, mock.Anything).
244 Return(createMockPublishResponse(0), nil).
245 Once()
246
247 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
248
249 htmlMessage := "<tag> & \"quoted\" 'apostrophe'"
250 err := service.Send(htmlMessage, nil)
251 require.NoError(t, err)
252
253 assertPublishPayload(t, mockManager, htmlMessage)
254
255 mockManager.AssertExpectations(t)
256 })
257 }
258
259 func TestPublishWhitespaceOnly(t *testing.T) {
260 t.Parallel()
261 synctest.Test(t, func(t *testing.T) {
262 tests := []struct {
263 name string
264 message string
265 }{
266 {"single space", " "},
267 {"multiple spaces", " "},
268 {"tabs", "\t\t\t"},
269 {"mixed whitespace", " \t\n\r "},
270 }
271
272 for _, tt := range tests {
273 mockManager := &MockConnectionManager{}
274 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
275 mockManager.On("Publish", mock.Anything, mock.Anything).
276 Return(createMockPublishResponse(0), nil).
277 Once()
278
279 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
280
281 err := service.Send(tt.message, nil)
282 require.NoError(t, err)
283
284 assertPublishPayload(t, mockManager, tt.message)
285
286 mockManager.AssertExpectations(t)
287 }
288 })
289 }
290
291 func TestPublishBinaryLikeData(t *testing.T) {
292 t.Parallel()
293 synctest.Test(t, func(t *testing.T) {
294 mockManager := &MockConnectionManager{}
295 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
296 mockManager.On("Publish", mock.Anything, mock.Anything).
297 Return(createMockPublishResponse(0), nil).
298 Once()
299
300 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
301
302 // Create a string with all byte values (simulating binary data)
303 var binaryLike strings.Builder
304 for i := range 256 {
305 binaryLike.WriteByte(byte(i))
306 }
307
308 message := binaryLike.String()
309
310 err := service.Send(message, nil)
311 require.NoError(t, err)
312
313 assertPublishPayload(t, mockManager, message)
314
315 mockManager.AssertExpectations(t)
316 })
317 }
318
319 func TestPublishWithNilParams(t *testing.T) {
320 t.Parallel()
321 synctest.Test(t, func(t *testing.T) {
322 mockManager := &MockConnectionManager{}
323 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
324 mockManager.On("Publish", mock.Anything, mock.Anything).
325 Return(createMockPublishResponse(0), nil).
326 Once()
327
328 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
329
330 err := service.Send("Test message", nil)
331 require.NoError(t, err)
332
333 mockManager.AssertExpectations(t)
334 })
335 }
336
337 func TestPublishWithEmptyParams(t *testing.T) {
338 t.Parallel()
339 synctest.Test(t, func(t *testing.T) {
340 mockManager := &MockConnectionManager{}
341 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
342 mockManager.On("Publish", mock.Anything, mock.Anything).
343 Return(createMockPublishResponse(0), nil).
344 Once()
345
346 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
347
348 params := createTestParams()
349 err := service.Send("Test message", params)
350 require.NoError(t, err)
351
352 mockManager.AssertExpectations(t)
353 })
354 }
355
356 func TestPublishMultipleConcurrentMessages(t *testing.T) {
357 t.Parallel()
358 synctest.Test(t, func(t *testing.T) {
359 mockManager := &MockConnectionManager{}
360 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
361
362 // Set up mock for multiple concurrent publish calls
363 for range 5 {
364 mockManager.On("Publish", mock.Anything, mock.Anything).
365 Return(createMockPublishResponse(0), nil).
366 Once()
367 }
368
369 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
370
371 // Send multiple messages
372 done := make(chan error, 5)
373
374 for i := range 5 {
375 go func(_ int) {
376 done <- service.Send("Message", nil)
377 }(i)
378 }
379
380 // Wait for all to complete
381 for range 5 {
382 err := <-done
383 require.NoError(t, err)
384 }
385
386 mockManager.AssertExpectations(t)
387 })
388 }
389
390 func TestPublishWithEscapedCharactersInURL(t *testing.T) {
391 t.Parallel()
392 synctest.Test(t, func(t *testing.T) {
393 mockManager := &MockConnectionManager{}
394 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
395 mockManager.On("Publish", mock.Anything, mock.Anything).
396 Return(createMockPublishResponse(0), nil).
397 Once()
398
399 // URL with percent-encoded characters in password
400 service := createTestService(
401 t,
402 "mqtt://user:pass%[email protected]/test/topic",
403 mockManager,
404 )
405
406 err := service.Send("Test message", nil)
407 require.NoError(t, err)
408
409 // Verify password was decoded correctly
410 require.Equal(t, "pass@word", service.Config.Password)
411
412 mockManager.AssertExpectations(t)
413 })
414 }
415
416 func TestPublishWithPortInURL(t *testing.T) {
417 t.Parallel()
418 synctest.Test(t, func(t *testing.T) {
419 mockManager := &MockConnectionManager{}
420 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
421 mockManager.On("Publish", mock.Anything, mock.Anything).
422 Return(createMockPublishResponse(0), nil).
423 Once()
424
425 service := createTestService(t, "mqtt://broker.example.com:1884/test/topic", mockManager)
426
427 err := service.Send("Test message", nil)
428 require.NoError(t, err)
429
430 require.Equal(t, 1884, service.Config.Port)
431
432 mockManager.AssertExpectations(t)
433 })
434 }
435
436 func TestPublishDeepTopicPath(t *testing.T) {
437 t.Parallel()
438 synctest.Test(t, func(t *testing.T) {
439 mockManager := &MockConnectionManager{}
440 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
441 mockManager.On("Publish", mock.Anything, mock.Anything).
442 Return(createMockPublishResponse(0), nil).
443 Once()
444
445 // Very deep topic path
446 deepTopic := "level1/level2/level3/level4/level5/level6/level7/level8/level9/level10"
447 service := createTestService(t, "mqtt://broker.example.com/"+deepTopic, mockManager)
448
449 err := service.Send("Test message", nil)
450 require.NoError(t, err)
451
452 assertPublishCalled(t, mockManager, deepTopic)
453
454 mockManager.AssertExpectations(t)
455 })
456 }