Debian Codegraph @

testing/integration/zulip/send_test.go

raw
1 package zulip_test
2
3 import (
4 "context"
5 "net/http"
6 "strings"
7 "testing"
8 "testing/synctest"
9
10 "github.com/stretchr/testify/mock"
11 "github.com/stretchr/testify/require"
12
13 "github.com/nicholas-fedor/shoutrrr/pkg/services/chat/zulip"
14 "github.com/nicholas-fedor/shoutrrr/pkg/services/chat/zulip/mocks"
15 )
16
17 func TestServiceSendPlainText(t *testing.T) {
18 t.Parallel()
19 synctest.Test(t, func(t *testing.T) {
20 mockClient := mocks.NewMockHTTPClient(t)
21 service := createTestService(
22 t,
23 "zulip://[email protected]:[email protected]?stream=general&topic=announcements",
24 mockClient,
25 )
26
27 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
28 setupRegisterThenMessage(t, mockClient, msgResp)
29
30 err := service.Send("Hello, World!", nil)
31
32 require.NoError(t, err)
33 assertRequestContains(t, mockClient, "content=Hello%2C+World%21")
34
35 mockClient.AssertExpectations(t)
36 })
37 }
38
39 func TestServiceSendEmptyMessage(t *testing.T) {
40 t.Parallel()
41 synctest.Test(t, func(t *testing.T) {
42 mockClient := mocks.NewMockHTTPClient(t)
43 service := createTestService(
44 t,
45 "zulip://[email protected]:[email protected]?stream=general",
46 mockClient,
47 )
48
49 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
50 setupRegisterThenMessage(t, mockClient, msgResp)
51
52 err := service.Send("", nil)
53
54 require.NoError(t, err)
55 assertRequestContains(t, mockClient, "content=")
56
57 mockClient.AssertExpectations(t)
58 })
59 }
60
61 func TestServiceSendWithStreamParam(t *testing.T) {
62 t.Parallel()
63 synctest.Test(t, func(t *testing.T) {
64 mockClient := mocks.NewMockHTTPClient(t)
65 service := createTestService(
66 t,
67 "zulip://[email protected]:[email protected]",
68 mockClient,
69 )
70
71 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
72 setupRegisterThenMessage(t, mockClient, msgResp)
73
74 params := createTestParams("stream", "general")
75 err := service.Send("Test message", params)
76
77 require.NoError(t, err)
78 assertRequestContains(t, mockClient, "to=general")
79
80 mockClient.AssertExpectations(t)
81 })
82 }
83
84 func TestServiceSendWithTopicParam(t *testing.T) {
85 t.Parallel()
86 synctest.Test(t, func(t *testing.T) {
87 mockClient := mocks.NewMockHTTPClient(t)
88 service := createTestService(
89 t,
90 "zulip://[email protected]:[email protected]?stream=general",
91 mockClient,
92 )
93
94 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
95 setupRegisterThenMessage(t, mockClient, msgResp)
96
97 params := createTestParams("topic", "announcements")
98 err := service.Send("Test message", params)
99
100 require.NoError(t, err)
101 assertRequestContains(t, mockClient, "topic=announcements")
102
103 mockClient.AssertExpectations(t)
104 })
105 }
106
107 func TestServiceSendWithNilParams(t *testing.T) {
108 t.Parallel()
109 synctest.Test(t, func(t *testing.T) {
110 mockClient := mocks.NewMockHTTPClient(t)
111 service := createTestService(
112 t,
113 "zulip://[email protected]:[email protected]?stream=general&topic=announcements",
114 mockClient,
115 )
116
117 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
118 setupRegisterThenMessage(t, mockClient, msgResp)
119
120 err := service.Send("Test message", nil)
121
122 require.NoError(t, err)
123 assertRequestContains(t, mockClient, "to=general")
124 assertRequestContains(t, mockClient, "topic=announcements")
125
126 mockClient.AssertExpectations(t)
127 })
128 }
129
130 func TestServiceSendWithContext(t *testing.T) {
131 t.Parallel()
132 synctest.Test(t, func(t *testing.T) {
133 mockClient := mocks.NewMockHTTPClient(t)
134 service := createTestService(
135 t,
136 "zulip://[email protected]:[email protected]?stream=general",
137 mockClient,
138 )
139
140 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
141 setupRegisterThenMessage(t, mockClient, msgResp)
142
143 ctx := context.Background()
144 err := service.SendWithContext(ctx, "Context message", nil)
145
146 require.NoError(t, err)
147 assertRequestContains(t, mockClient, "content=Context+message")
148
149 mockClient.AssertExpectations(t)
150 })
151 }
152
153 func TestServiceSendWithCancelledContext(t *testing.T) {
154 t.Parallel()
155 synctest.Test(t, func(t *testing.T) {
156 mockClient := mocks.NewMockHTTPClient(t)
157 service := createTestService(
158 t,
159 "zulip://[email protected]:[email protected]?stream=general",
160 mockClient,
161 )
162
163 // register succeeds (once), messages call gets the cancel (the ctx is for the send)
164 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
165 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
166 Once()
167
168 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
169 Return(nil, context.Canceled).
170 Maybe()
171
172 ctx, cancel := context.WithCancel(context.Background())
173 cancel()
174
175 err := service.SendWithContext(ctx, "Canceled message", nil)
176
177 require.Error(t, err)
178
179 mockClient.AssertExpectations(t)
180 })
181 }
182
183 func TestServiceSendWithTitleParam(t *testing.T) {
184 t.Parallel()
185 synctest.Test(t, func(t *testing.T) {
186 mockClient := mocks.NewMockHTTPClient(t)
187 service := createTestService(
188 t,
189 "zulip://[email protected]:[email protected]?stream=general",
190 mockClient,
191 )
192
193 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
194 setupRegisterThenMessage(t, mockClient, msgResp)
195
196 params := createTestParams("title", "Alert")
197 err := service.Send("Something happened", params)
198
199 require.NoError(t, err)
200 assertRequestContains(t, mockClient, "topic=Alert")
201
202 mockClient.AssertExpectations(t)
203 })
204 }
205
206 func TestServiceSendTitleAsTopicFallback(t *testing.T) {
207 t.Parallel()
208 synctest.Test(t, func(t *testing.T) {
209 mockClient := mocks.NewMockHTTPClient(t)
210 service := createTestService(
211 t,
212 "zulip://[email protected]:[email protected]?stream=general",
213 mockClient,
214 )
215
216 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
217 setupRegisterThenMessage(t, mockClient, msgResp)
218
219 params := createTestParams("title", "Fallback Topic")
220 err := service.Send("body content", params)
221
222 require.NoError(t, err)
223 assertRequestContains(t, mockClient, "topic=Fallback+Topic")
224
225 mockClient.AssertExpectations(t)
226 })
227 }
228
229 func TestServiceSendTitleDoesNotOverrideExplicitTopic(t *testing.T) {
230 t.Parallel()
231 synctest.Test(t, func(t *testing.T) {
232 mockClient := mocks.NewMockHTTPClient(t)
233 service := createTestService(
234 t,
235 "zulip://[email protected]:[email protected]?stream=general&topic=explicit",
236 mockClient,
237 )
238
239 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
240 setupRegisterThenMessage(t, mockClient, msgResp)
241
242 params := createTestParams("title", "Notification Title")
243 err := service.Send("body content", params)
244
245 require.NoError(t, err)
246 assertRequestContains(t, mockClient, "topic=explicit")
247 assertRequestContains(t, mockClient, "content=Notification+Title")
248
249 mockClient.AssertExpectations(t)
250 })
251 }
252
253 func TestServiceSendTitleExceedingTopicLimit(t *testing.T) {
254 t.Parallel()
255 synctest.Test(t, func(t *testing.T) {
256 mockClient := mocks.NewMockHTTPClient(t)
257 service := createTestService(
258 t,
259 "zulip://[email protected]:[email protected]?stream=general",
260 mockClient,
261 )
262
263 longTitle := strings.Repeat("a", 61)
264 params := createTestParams("title", longTitle)
265
266 // register happens; title-as-topic length check fails before messages Do
267 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
268 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
269 Once()
270
271 err := service.Send("body content", params)
272
273 require.Error(t, err)
274 require.ErrorIs(t, err, zulip.ErrTopicTooLong)
275
276 assertNoMessagesAPICall(t, mockClient)
277 })
278 }
279
280 func TestServiceSendWithBothTopicAndTitle(t *testing.T) {
281 t.Parallel()
282 synctest.Test(t, func(t *testing.T) {
283 mockClient := mocks.NewMockHTTPClient(t)
284 service := createTestService(
285 t,
286 "zulip://[email protected]:[email protected]?stream=general",
287 mockClient,
288 )
289
290 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
291 setupRegisterThenMessage(t, mockClient, msgResp)
292
293 params := createTestParams("topic", "my-topic", "title", "my-title")
294 err := service.Send("body content", params)
295
296 require.NoError(t, err)
297 assertRequestContains(t, mockClient, "topic=my-topic")
298 assertRequestContains(t, mockClient, "content=my-title%0A%0Abody+content")
299
300 mockClient.AssertExpectations(t)
301 })
302 }
303
304 func TestServiceSendWithUnicodeMessage(t *testing.T) {
305 t.Parallel()
306 synctest.Test(t, func(t *testing.T) {
307 mockClient := mocks.NewMockHTTPClient(t)
308 service := createTestService(
309 t,
310 "zulip://[email protected]:[email protected]?stream=general",
311 mockClient,
312 )
313
314 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
315 setupRegisterThenMessage(t, mockClient, msgResp)
316
317 err := service.Send("Hello δΈ–η•Œ 🌍", nil) //nolint:gosmopolitan // unicode test message
318
319 require.NoError(t, err)
320 assertRequestContains(t, mockClient, "content=")
321
322 mockClient.AssertExpectations(t)
323 })
324 }
325
326 func TestServiceSendWithSpecialCharacters(t *testing.T) {
327 t.Parallel()
328 synctest.Test(t, func(t *testing.T) {
329 mockClient := mocks.NewMockHTTPClient(t)
330 service := createTestService(
331 t,
332 "zulip://[email protected]:[email protected]?stream=general",
333 mockClient,
334 )
335
336 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
337 setupRegisterThenMessage(t, mockClient, msgResp)
338
339 err := service.Send("Test <script>alert('xss')</script>", nil)
340
341 require.NoError(t, err)
342 assertRequestContains(t, mockClient, "content=")
343
344 mockClient.AssertExpectations(t)
345 })
346 }
347
348 func TestServiceSendWithLongMessage(t *testing.T) {
349 t.Parallel()
350 synctest.Test(t, func(t *testing.T) {
351 mockClient := mocks.NewMockHTTPClient(t)
352 service := createTestService(
353 t,
354 "zulip://[email protected]:[email protected]?stream=general",
355 mockClient,
356 )
357
358 longMessage := strings.Repeat("a", 10000)
359
360 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
361 setupRegisterThenMessage(t, mockClient, msgResp)
362
363 err := service.Send(longMessage, nil)
364
365 require.NoError(t, err)
366
367 mockClient.AssertExpectations(t)
368 })
369 }
370
371 func TestServiceSendWithMessageExceedingLimit(t *testing.T) {
372 t.Parallel()
373 synctest.Test(t, func(t *testing.T) {
374 mockClient := mocks.NewMockHTTPClient(t)
375 service := createTestService(
376 t,
377 "zulip://[email protected]:[email protected]?stream=general",
378 mockClient,
379 )
380
381 longMessage := strings.Repeat("a", 10001)
382
383 // only register (fetch) happens; size error before messages Do
384 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
385 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
386 Once()
387
388 err := service.Send(longMessage, nil)
389
390 require.Error(t, err)
391 require.ErrorIs(t, err, zulip.ErrMessageTooLong)
392
393 assertNoMessagesAPICall(t, mockClient)
394 })
395 }
396
397 func TestServiceSendParamsDoNotMutateConfig(t *testing.T) {
398 t.Parallel()
399 synctest.Test(t, func(t *testing.T) {
400 mockClient := mocks.NewMockHTTPClient(t)
401 service := createTestService(
402 t,
403 "zulip://[email protected]:[email protected]?stream=general&topic=original",
404 mockClient,
405 )
406
407 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
408 setupRegisterThenMessage(t, mockClient, msgResp)
409
410 params := createTestParams("topic", "modified")
411 err := service.Send("Test message", params)
412
413 require.NoError(t, err)
414 require.Equal(t, "original", service.Config.Topic)
415 assertRequestContains(t, mockClient, "topic=modified")
416
417 mockClient.AssertExpectations(t)
418 })
419 }
420
421 // --- New tests for direct message support and server-side limit fetching ---
422
423 func TestServiceSendDirectMessage(t *testing.T) {
424 t.Parallel()
425 synctest.Test(t, func(t *testing.T) {
426 mockClient := mocks.NewMockHTTPClient(t)
427 service := createTestService(
428 t,
429 "zulip://[email protected]:[email protected]",
430 mockClient,
431 )
432
433 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
434 setupRegisterThenMessage(t, mockClient, msgResp)
435
436 params := createTestParams("type", "direct", "to", "[email protected],[email protected]")
437 err := service.Send("Direct hello", params)
438
439 require.NoError(t, err)
440 assertRequestContains(t, mockClient, "type=direct")
441 assertRequestContains(t, mockClient, `to=%5B%22user1%40example.com%22%2C%22user2%40example.com%22%5D`)
442
443 mockClient.AssertExpectations(t)
444 })
445 }
446
447 func TestServiceSendDirectWithReadBySender(t *testing.T) {
448 t.Parallel()
449 synctest.Test(t, func(t *testing.T) {
450 mockClient := mocks.NewMockHTTPClient(t)
451 service := createTestService(
452 t,
453 "zulip://[email protected]:[email protected]",
454 mockClient,
455 )
456
457 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
458 setupRegisterThenMessage(t, mockClient, msgResp)
459
460 params := createTestParams("type", "direct", "to", "[email protected]", "read_by_sender", "true")
461 err := service.Send("DM with read", params)
462
463 require.NoError(t, err)
464 assertRequestContains(t, mockClient, "read_by_sender=true")
465
466 mockClient.AssertExpectations(t)
467 })
468 }
469
470 func TestServiceSendInvalidMessageType(t *testing.T) {
471 t.Parallel()
472 synctest.Test(t, func(t *testing.T) {
473 mockClient := mocks.NewMockHTTPClient(t)
474 service := createTestService(
475 t,
476 "zulip://[email protected]:[email protected]?stream=general",
477 mockClient,
478 )
479
480 // type validation happens before fetch, so no Do calls at all
481 err := service.Send("bad type", createTestParams("type", "foo"))
482
483 require.Error(t, err)
484 require.ErrorIs(t, err, zulip.ErrInvalidMessageType)
485
486 mockClient.AssertNotCalled(t, "Do", mock.AnythingOfType("*http.Request"))
487 })
488 }
489
490 func TestServiceSendMissingRecipientChannel(t *testing.T) {
491 t.Parallel()
492 synctest.Test(t, func(t *testing.T) {
493 mockClient := mocks.NewMockHTTPClient(t)
494 service := createTestService(
495 t,
496 "zulip://[email protected]:[email protected]",
497 mockClient,
498 )
499
500 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
501 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
502 Once() // register only
503
504 err := service.Send("no recipient", nil)
505
506 require.Error(t, err)
507 require.ErrorIs(t, err, zulip.ErrMissingRecipient)
508
509 assertNoMessagesAPICall(t, mockClient)
510 })
511 }
512
513 func TestServiceSendMissingRecipientDirect(t *testing.T) {
514 t.Parallel()
515 synctest.Test(t, func(t *testing.T) {
516 mockClient := mocks.NewMockHTTPClient(t)
517 service := createTestService(
518 t,
519 "zulip://[email protected]:[email protected]",
520 mockClient,
521 )
522
523 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
524 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
525 Once() // register only
526
527 err := service.Send("dm no to", createTestParams("type", "direct"))
528
529 require.Error(t, err)
530 require.ErrorIs(t, err, zulip.ErrMissingRecipient)
531
532 assertNoMessagesAPICall(t, mockClient)
533 })
534 }
535
536 func TestServiceSendUsesCustomServerLimits(t *testing.T) {
537 t.Parallel()
538 synctest.Test(t, func(t *testing.T) {
539 mockClient := mocks.NewMockHTTPClient(t)
540 service := createTestService(
541 t,
542 "zulip://[email protected]:[email protected]?stream=general",
543 mockClient,
544 )
545
546 // first call: register returns custom limits (larger)
547 registerResp := createMockResponse(http.StatusOK, `{"max_message_length": 20000, "max_topic_length": 120}`)
548 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
549 Return(registerResp, nil).
550 Once()
551
552 // second: messages
553 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
554 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
555 Return(msgResp, nil).
556 Once()
557
558 // 15000 byte message should be allowed with custom 20000 limit
559 longMsg := strings.Repeat("a", 15000)
560 err := service.Send(longMsg, nil)
561
562 require.NoError(t, err)
563
564 mockClient.AssertExpectations(t)
565 })
566 }
567
568 func TestServiceSendFallsBackToDefaultLimitsOnRegisterFailure(t *testing.T) {
569 t.Parallel()
570 synctest.Test(t, func(t *testing.T) {
571 mockClient := mocks.NewMockHTTPClient(t)
572 service := createTestService(
573 t,
574 "zulip://[email protected]:[email protected]?stream=general",
575 mockClient,
576 )
577
578 // register fails -> fallback to defaults (10000)
579 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
580 Return(createMockResponse(http.StatusServiceUnavailable, ""), nil).
581 Once()
582
583 // the send should still happen (using default limit)
584 msgResp := createMockResponse(http.StatusOK, `{"result": "success"}`)
585 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
586 Return(msgResp, nil).
587 Once()
588
589 err := service.Send("short after fallback", nil)
590
591 require.NoError(t, err)
592
593 mockClient.AssertExpectations(t)
594 })
595 }