Debian Codegraph @

testing/integration/discord/files_test.go

raw
1 package discord_test
2
3 import (
4 "net/http"
5 "testing"
6 "testing/synctest"
7
8 "github.com/stretchr/testify/mock"
9 "github.com/stretchr/testify/require"
10
11 "github.com/nicholas-fedor/shoutrrr/pkg/types"
12 )
13
14 func TestSendSingleFileAttachment(t *testing.T) {
15 t.Parallel()
16 synctest.Test(t, func(t *testing.T) {
17 mockClient := &MockHTTPClient{}
18 service := createTestService(
19 t,
20 "discord://test-token@test-webhook",
21 mockClient,
22 )
23
24 mockClient.On("Do", mock.Anything).
25 Return(createMockResponse(http.StatusNoContent, ""), nil).
26 Once()
27
28 fileData := []byte("test file content")
29 items := []types.MessageItem{
30 createTestMessageItemWithFile("Test message with file", "test.txt", fileData),
31 }
32
33 err := service.SendItems(items, nil)
34
35 require.NoError(t, err)
36 // Verify multipart request was made (contains boundary)
37 assertRequestContains(t, mockClient, "Content-Disposition: form-data")
38 assertRequestContains(t, mockClient, `name="files[0]"`)
39 assertRequestContains(t, mockClient, `filename="test.txt"`)
40 assertRequestContains(t, mockClient, "test file content")
41
42 mockClient.AssertExpectations(t)
43 })
44 }
45
46 func TestSendMultipleFileAttachments(t *testing.T) {
47 t.Parallel()
48 synctest.Test(t, func(t *testing.T) {
49 mockClient := &MockHTTPClient{}
50 service := createTestService(
51 t,
52 "discord://test-token@test-webhook",
53 mockClient,
54 )
55
56 mockClient.On("Do", mock.Anything).
57 Return(createMockResponse(http.StatusNoContent, ""), nil).
58 Once()
59
60 items := []types.MessageItem{
61 createTestMessageItemWithFile("File 1", "file1.txt", []byte("content 1")),
62 createTestMessageItemWithFile("File 2", "file2.txt", []byte("content 2")),
63 createTestMessageItemWithFile("File 3", "file3.txt", []byte("content 3")),
64 }
65
66 err := service.SendItems(items, nil)
67
68 require.NoError(t, err)
69 assertRequestContains(t, mockClient, `filename="file1.txt"`)
70 assertRequestContains(t, mockClient, `filename="file2.txt"`)
71 assertRequestContains(t, mockClient, `filename="file3.txt"`)
72 assertRequestContains(t, mockClient, "content 1")
73 assertRequestContains(t, mockClient, "content 2")
74 assertRequestContains(t, mockClient, "content 3")
75
76 mockClient.AssertExpectations(t)
77 })
78 }
79
80 func TestSendLargeFileAttachment(t *testing.T) {
81 t.Parallel()
82 synctest.Test(t, func(t *testing.T) {
83 mockClient := &MockHTTPClient{}
84 service := createTestService(
85 t,
86 "discord://test-token@test-webhook",
87 mockClient,
88 )
89
90 mockClient.On("Do", mock.Anything).
91 Return(createMockResponse(http.StatusNoContent, ""), nil).
92 Once()
93
94 // Create a large file (5MB)
95 largeData := make([]byte, 5*1024*1024)
96 for i := range largeData {
97 largeData[i] = byte(i % 256)
98 }
99
100 items := []types.MessageItem{
101 createTestMessageItemWithFile("Large file test", "large.bin", largeData),
102 }
103
104 err := service.SendItems(items, nil)
105
106 require.NoError(t, err)
107 assertRequestContains(t, mockClient, `filename="large.bin"`)
108
109 mockClient.AssertExpectations(t)
110 })
111 }
112
113 func TestSendFileWithSpecialCharactersInName(t *testing.T) {
114 t.Parallel()
115 synctest.Test(t, func(t *testing.T) {
116 mockClient := &MockHTTPClient{}
117 service := createTestService(
118 t,
119 "discord://test-token@test-webhook",
120 mockClient,
121 )
122
123 specialNames := []string{
124 "file with spaces.txt",
125 "file-with-dashes.txt",
126 "file_with_underscores.txt",
127 "file.with.dots.txt",
128 "file(1).txt",
129 "file[1].txt",
130 "file+plus.txt",
131 "file%percent.txt",
132 }
133
134 for _, filename := range specialNames {
135 mockClient.On("Do", mock.Anything).
136 Return(createMockResponse(http.StatusNoContent, ""), nil).
137 Once()
138
139 items := []types.MessageItem{
140 createTestMessageItemWithFile("Test file", filename, []byte("content")),
141 }
142
143 err := service.SendItems(items, nil)
144
145 require.NoError(t, err)
146 assertRequestContains(t, mockClient, `filename="`+filename+`"`)
147 }
148
149 mockClient.AssertExpectations(t)
150 })
151 }
152
153 func TestSendFileWithDifferentTypes(t *testing.T) {
154 t.Parallel()
155 synctest.Test(t, func(t *testing.T) {
156 mockClient := &MockHTTPClient{}
157 service := createTestService(
158 t,
159 "discord://test-token@test-webhook",
160 mockClient,
161 )
162
163 testCases := []struct {
164 name string
165 filename string
166 content []byte
167 mimeType string
168 }{
169 {"text file", "test.txt", []byte("plain text"), "text/plain"},
170 {"json file", "data.json", []byte(`{"key": "value"}`), "application/json"},
171 {"xml file", "data.xml", []byte(`<root><item>value</item></root>`), "application/xml"},
172 {"binary file", "data.bin", []byte{0x00, 0x01, 0x02, 0xFF}, "application/octet-stream"},
173 {"image file", "image.png", []byte("fake png content"), "image/png"},
174 {"pdf file", "document.pdf", []byte("fake pdf content"), "application/pdf"},
175 }
176
177 for _, tc := range testCases {
178 mockClient.On("Do", mock.Anything).
179 Return(createMockResponse(http.StatusNoContent, ""), nil).
180 Once()
181
182 items := []types.MessageItem{
183 createTestMessageItemWithFile("Test file", tc.filename, tc.content),
184 }
185
186 err := service.SendItems(items, nil)
187
188 require.NoError(t, err)
189 assertRequestContains(t, mockClient, `filename="`+tc.filename+`"`)
190 assertRequestContains(t, mockClient, string(tc.content))
191 }
192
193 mockClient.AssertExpectations(t)
194 })
195 }
196
197 func TestSendFileWithEmptyContent(t *testing.T) {
198 t.Parallel()
199 synctest.Test(t, func(t *testing.T) {
200 mockClient := &MockHTTPClient{}
201 service := createTestService(
202 t,
203 "discord://test-token@test-webhook",
204 mockClient,
205 )
206
207 mockClient.On("Do", mock.Anything).
208 Return(createMockResponse(http.StatusNoContent, ""), nil).
209 Once()
210
211 items := []types.MessageItem{
212 createTestMessageItemWithFile("Empty file", "empty.txt", []byte{}),
213 }
214
215 err := service.SendItems(items, nil)
216
217 require.NoError(t, err)
218 assertRequestContains(t, mockClient, `filename="empty.txt"`)
219
220 mockClient.AssertExpectations(t)
221 })
222 }
223
224 func TestSendFileWithUnicodeContent(t *testing.T) {
225 t.Parallel()
226 synctest.Test(t, func(t *testing.T) {
227 mockClient := &MockHTTPClient{}
228 service := createTestService(
229 t,
230 "discord://test-token@test-webhook",
231 mockClient,
232 )
233
234 mockClient.On("Do", mock.Anything).
235 Return(createMockResponse(http.StatusNoContent, ""), nil).
236 Once()
237
238 //nolint:gosmopolitan // Intentional string literal containing rune in Han script
239 unicodeContent := []byte("Hello 世界 🌍 éñüñ")
240 items := []types.MessageItem{
241 createTestMessageItemWithFile("Unicode file", "unicode.txt", unicodeContent),
242 }
243
244 err := service.SendItems(items, nil)
245
246 require.NoError(t, err)
247 assertRequestContains(t, mockClient, string(unicodeContent))
248
249 mockClient.AssertExpectations(t)
250 })
251 }
252
253 func TestSendFileWithMessageText(t *testing.T) {
254 t.Parallel()
255 synctest.Test(t, func(t *testing.T) {
256 mockClient := &MockHTTPClient{}
257 service := createTestService(
258 t,
259 "discord://test-token@test-webhook",
260 mockClient,
261 )
262
263 mockClient.On("Do", mock.Anything).
264 Return(createMockResponse(http.StatusNoContent, ""), nil).
265 Once()
266
267 items := []types.MessageItem{
268 createTestMessageItemWithFile(
269 "This is a message with a file attachment",
270 "attachment.txt",
271 []byte("file content"),
272 ),
273 }
274
275 err := service.SendItems(items, nil)
276
277 require.NoError(t, err)
278 assertRequestContains(t, mockClient, "This is a message with a file attachment")
279 assertRequestContains(t, mockClient, `filename="attachment.txt"`)
280 assertRequestContains(t, mockClient, "file content")
281
282 mockClient.AssertExpectations(t)
283 })
284 }