Debian Codegraph @

shoutrrr/cmd/send/send_test.go

raw
1 package send
2
3 import (
4 "bytes"
5 "errors"
6 "io"
7 "os"
8 "testing"
9
10 "github.com/spf13/cobra"
11 "github.com/stretchr/testify/assert"
12 "github.com/stretchr/testify/require"
13
14 cli "github.com/nicholas-fedor/shoutrrr/shoutrrr/cmd"
15 )
16
17 // TestRun tests the Run function with successful scenarios only.
18 // Note: Error cases that trigger os.Exit are tested via the internal run() function.
19 func TestRun(t *testing.T) {
20 t.Parallel()
21
22 tests := []struct {
23 name string
24 setupCmd func() *cobra.Command
25 wantErr bool
26 }{
27 {
28 name: "successful send with logger URL and message",
29 setupCmd: func() *cobra.Command {
30 cmd := &cobra.Command{Use: "send"}
31 cmd.Flags().BoolP("verbose", "v", false, "")
32 cmd.Flags().StringArrayP("url", "u", []string{}, "")
33 cmd.Flags().StringP("message", "m", "", "")
34 cmd.Flags().StringP("title", "t", "", "")
35
36 _ = cmd.Flags().Set("url", "logger://")
37 _ = cmd.Flags().Set("message", "test message")
38
39 return cmd
40 },
41 wantErr: false,
42 },
43 {
44 name: "successful send with title parameter",
45 setupCmd: func() *cobra.Command {
46 cmd := &cobra.Command{Use: "send"}
47 cmd.Flags().BoolP("verbose", "v", false, "")
48 cmd.Flags().StringArrayP("url", "u", []string{}, "")
49 cmd.Flags().StringP("message", "m", "", "")
50 cmd.Flags().StringP("title", "t", "", "")
51
52 _ = cmd.Flags().Set("url", "logger://")
53 _ = cmd.Flags().Set("message", "test message")
54 _ = cmd.Flags().Set("title", "Test Title")
55
56 return cmd
57 },
58 wantErr: false,
59 },
60 }
61
62 for _, tt := range tests {
63 t.Run(tt.name, func(t *testing.T) {
64 t.Parallel()
65
66 cmd := tt.setupCmd()
67 err := Run(cmd, []string{})
68
69 if tt.wantErr {
70 require.Error(t, err, "Run() should return an error")
71 } else {
72 assert.NoError(t, err, "Run() should not return an error")
73 }
74 })
75 }
76 }
77
78 // Test_logf tests the logf function with various format strings.
79 //
80 //nolint:paralleltest // Test manipulates global os.Stderr, cannot run in parallel
81 func Test_logf(t *testing.T) {
82 tests := []struct {
83 name string
84 format string
85 args []any
86 wantOutput string
87 }{
88 {
89 name: "simple message outputs to stderr",
90 format: "hello",
91 args: nil,
92 wantOutput: "hello\n",
93 },
94 {
95 name: "formatted message with integer",
96 format: "count: %d",
97 args: []any{5},
98 wantOutput: "count: 5\n",
99 },
100 {
101 name: "formatted message with string",
102 format: "name: %s",
103 args: []any{"test"},
104 wantOutput: "name: test\n",
105 },
106 {
107 name: "empty format outputs newline",
108 format: "",
109 args: nil,
110 wantOutput: "\n",
111 },
112 {
113 name: "multiple format arguments",
114 format: "%s: %d",
115 args: []any{"value", 42},
116 wantOutput: "value: 42\n",
117 },
118 {
119 name: "format with percent sign",
120 format: "progress: %d%%",
121 args: []any{75},
122 wantOutput: "progress: 75%\n",
123 },
124 }
125
126 for _, tt := range tests {
127 t.Run(tt.name, func(t *testing.T) {
128 // Capture stderr
129 oldStderr := os.Stderr
130 r, w, err := os.Pipe()
131 require.NoError(t, err, "Failed to create pipe")
132
133 os.Stderr = w
134
135 // Call logf
136 logf(tt.format, tt.args...)
137
138 // Restore stderr and close write end
139 w.Close()
140
141 os.Stderr = oldStderr
142
143 // Read captured output
144 var buf bytes.Buffer
145
146 _, err = io.Copy(&buf, r)
147 require.NoError(t, err, "Failed to read captured output")
148 r.Close()
149
150 assert.Equal(t, tt.wantOutput, buf.String(), "logf() output mismatch")
151 })
152 }
153 }
154
155 // Test_run tests the internal run function with comprehensive scenarios.
156 // This tests both success and error cases since it doesn't trigger os.Exit.
157 //
158 //nolint:paralleltest // Test manipulates global os.Stderr, cannot run in parallel
159 func Test_run(t *testing.T) {
160 tests := []struct {
161 name string
162 setupCmd func() *cobra.Command
163 setupStdin func() func()
164 wantErr bool
165 wantErrType string
166 wantErrMessage string
167 verifyOutput func(t *testing.T, output string)
168 }{
169 {
170 name: "basic send with logger URL returns success",
171 setupCmd: func() *cobra.Command {
172 cmd := &cobra.Command{Use: "send"}
173 cmd.Flags().BoolP("verbose", "v", false, "")
174 cmd.Flags().StringArrayP("url", "u", []string{}, "")
175 cmd.Flags().StringP("message", "m", "", "")
176 cmd.Flags().StringP("title", "t", "", "")
177
178 _ = cmd.Flags().Set("url", "logger://")
179 _ = cmd.Flags().Set("message", "test message")
180
181 return cmd
182 },
183 wantErr: false,
184 },
185 {
186 name: "verbose flag logs URLs and message",
187 setupCmd: func() *cobra.Command {
188 cmd := &cobra.Command{Use: "send"}
189 cmd.Flags().BoolP("verbose", "v", false, "")
190 cmd.Flags().StringArrayP("url", "u", []string{}, "")
191 cmd.Flags().StringP("message", "m", "", "")
192 cmd.Flags().StringP("title", "t", "", "")
193
194 _ = cmd.Flags().Set("verbose", "true")
195 _ = cmd.Flags().Set("url", "logger://")
196 _ = cmd.Flags().Set("message", "verbose test message")
197
198 return cmd
199 },
200 wantErr: false,
201 verifyOutput: func(t *testing.T, output string) {
202 t.Helper()
203 assert.Contains(t, output, "URLs:", "Verbose output should contain URLs")
204 assert.Contains(t, output, "Message:", "Verbose output should contain Message")
205 assert.Contains(t, output, "logger://", "Verbose output should contain the URL")
206 },
207 },
208 {
209 name: "stdin message reads from piped input",
210 setupCmd: func() *cobra.Command {
211 cmd := &cobra.Command{Use: "send"}
212 cmd.Flags().BoolP("verbose", "v", false, "")
213 cmd.Flags().StringArrayP("url", "u", []string{}, "")
214 cmd.Flags().StringP("message", "m", "", "")
215 cmd.Flags().StringP("title", "t", "", "")
216
217 _ = cmd.Flags().Set("url", "logger://")
218 _ = cmd.Flags().Set("message", "-")
219
220 return cmd
221 },
222 setupStdin: func() func() {
223 oldStdin := os.Stdin
224 r, w, _ := os.Pipe()
225 os.Stdin = r
226
227 // Write test input
228 go func() {
229 _, _ = w.WriteString("stdin test message")
230 w.Close()
231 }()
232
233 return func() {
234 os.Stdin = oldStdin
235
236 r.Close()
237 }
238 },
239 wantErr: false,
240 },
241 {
242 name: "URL deduplication removes duplicate URLs",
243 setupCmd: func() *cobra.Command {
244 cmd := &cobra.Command{Use: "send"}
245 cmd.Flags().BoolP("verbose", "v", true, "")
246 cmd.Flags().StringArrayP("url", "u", []string{}, "")
247 cmd.Flags().StringP("message", "m", "", "")
248 cmd.Flags().StringP("title", "t", "", "")
249
250 // Set same URL twice
251 _ = cmd.Flags().Set("url", "logger://")
252 _ = cmd.Flags().Set("url", "logger://")
253 _ = cmd.Flags().Set("message", "dedupe test")
254
255 return cmd
256 },
257 wantErr: false,
258 verifyOutput: func(t *testing.T, output string) {
259 t.Helper()
260 // Should only log the URL once due to deduplication
261 count := 0
262
263 for i := range len(output) - len("logger://") {
264 if output[i:i+len("logger://")] == "logger://" {
265 count++
266 }
267 }
268
269 assert.Equal(t, 1, count, "URL should appear exactly once after deduplication")
270 },
271 },
272 {
273 name: "flag retrieval error for verbose",
274 setupCmd: func() *cobra.Command {
275 cmd := &cobra.Command{Use: "send"}
276 // Create a flag that will cause type mismatch error
277 cmd.Flags().StringP("verbose", "v", "not-a-bool", "")
278 cmd.Flags().StringArrayP("url", "u", []string{}, "")
279 cmd.Flags().StringP("message", "m", "", "")
280 cmd.Flags().StringP("title", "t", "", "")
281
282 _ = cmd.Flags().Set("url", "logger://")
283 _ = cmd.Flags().Set("message", "test")
284
285 return cmd
286 },
287 wantErr: true,
288 wantErrMessage: "failed to get verbose flag",
289 },
290 {
291 name: "flag retrieval error for url",
292 setupCmd: func() *cobra.Command {
293 cmd := &cobra.Command{Use: "send"}
294 cmd.Flags().BoolP("verbose", "v", false, "")
295 // Create url flag with wrong type
296 cmd.Flags().BoolP("url", "u", false, "")
297 cmd.Flags().StringP("message", "m", "", "")
298 cmd.Flags().StringP("title", "t", "", "")
299
300 _ = cmd.Flags().Set("message", "test")
301
302 return cmd
303 },
304 wantErr: true,
305 wantErrMessage: "failed to get url flag",
306 },
307 {
308 name: "flag retrieval error for message",
309 setupCmd: func() *cobra.Command {
310 cmd := &cobra.Command{Use: "send"}
311 cmd.Flags().BoolP("verbose", "v", false, "")
312 cmd.Flags().StringArrayP("url", "u", []string{}, "")
313 // Create message flag with wrong type
314 cmd.Flags().BoolP("message", "m", false, "")
315 cmd.Flags().StringP("title", "t", "", "")
316
317 _ = cmd.Flags().Set("url", "logger://")
318
319 return cmd
320 },
321 wantErr: true,
322 wantErrMessage: "failed to get message flag",
323 },
324 {
325 name: "flag retrieval error for title",
326 setupCmd: func() *cobra.Command {
327 cmd := &cobra.Command{Use: "send"}
328 cmd.Flags().BoolP("verbose", "v", false, "")
329 cmd.Flags().StringArrayP("url", "u", []string{}, "")
330 cmd.Flags().StringP("message", "m", "", "")
331 // Create title flag with wrong type
332 cmd.Flags().BoolP("title", "t", false, "")
333
334 _ = cmd.Flags().Set("url", "logger://")
335 _ = cmd.Flags().Set("message", "test")
336
337 return cmd
338 },
339 wantErr: true,
340 wantErrMessage: "failed to get title flag",
341 },
342 {
343 name: "configuration error with invalid URL",
344 setupCmd: func() *cobra.Command {
345 cmd := &cobra.Command{Use: "send"}
346 cmd.Flags().BoolP("verbose", "v", false, "")
347 cmd.Flags().StringArrayP("url", "u", []string{}, "")
348 cmd.Flags().StringP("message", "m", "", "")
349 cmd.Flags().StringP("title", "t", "", "")
350
351 _ = cmd.Flags().Set("url", "://invalid")
352 _ = cmd.Flags().Set("message", "test")
353
354 return cmd
355 },
356 wantErr: true,
357 wantErrType: "ConfigurationError",
358 wantErrMessage: "error invoking send",
359 },
360 {
361 name: "unknown service scheme returns configuration error",
362 setupCmd: func() *cobra.Command {
363 cmd := &cobra.Command{Use: "send"}
364 cmd.Flags().BoolP("verbose", "v", false, "")
365 cmd.Flags().StringArrayP("url", "u", []string{}, "")
366 cmd.Flags().StringP("message", "m", "", "")
367 cmd.Flags().StringP("title", "t", "", "")
368
369 _ = cmd.Flags().Set("url", "unknownservice://test")
370 _ = cmd.Flags().Set("message", "test")
371
372 return cmd
373 },
374 wantErr: true,
375 wantErrType: "ConfigurationError",
376 wantErrMessage: "error invoking send",
377 },
378 {
379 name: "multiple different URLs work correctly",
380 setupCmd: func() *cobra.Command {
381 cmd := &cobra.Command{Use: "send"}
382 cmd.Flags().BoolP("verbose", "v", true, "")
383 cmd.Flags().StringArrayP("url", "u", []string{}, "")
384 cmd.Flags().StringP("message", "m", "", "")
385 cmd.Flags().StringP("title", "t", "", "")
386
387 _ = cmd.Flags().Set("url", "logger://first")
388 _ = cmd.Flags().Set("url", "logger://second")
389 _ = cmd.Flags().Set("message", "multi url test")
390
391 return cmd
392 },
393 wantErr: false,
394 verifyOutput: func(t *testing.T, output string) {
395 t.Helper()
396 assert.Contains(t, output, "logger://first", "Output should contain first URL")
397 assert.Contains(t, output, "logger://second", "Output should contain second URL")
398 },
399 },
400 {
401 name: "verbose with title logs title",
402 setupCmd: func() *cobra.Command {
403 cmd := &cobra.Command{Use: "send"}
404 cmd.Flags().BoolP("verbose", "v", true, "")
405 cmd.Flags().StringArrayP("url", "u", []string{}, "")
406 cmd.Flags().StringP("message", "m", "", "")
407 cmd.Flags().StringP("title", "t", "", "")
408
409 _ = cmd.Flags().Set("url", "logger://")
410 _ = cmd.Flags().Set("message", "title test")
411 _ = cmd.Flags().Set("title", "My Test Title")
412
413 return cmd
414 },
415 wantErr: false,
416 verifyOutput: func(t *testing.T, output string) {
417 t.Helper()
418 assert.Contains(t, output, "Title:", "Verbose output should contain Title")
419 assert.Contains(t, output, "My Test Title", "Verbose output should contain the title value")
420 },
421 },
422 {
423 name: "long message is truncated in verbose output",
424 setupCmd: func() *cobra.Command {
425 cmd := &cobra.Command{Use: "send"}
426 cmd.Flags().BoolP("verbose", "v", true, "")
427 cmd.Flags().StringArrayP("url", "u", []string{}, "")
428 cmd.Flags().StringP("message", "m", "", "")
429 cmd.Flags().StringP("title", "t", "", "")
430
431 _ = cmd.Flags().Set("url", "logger://")
432 // Message longer than MaxMessageLength (100)
433 longMsg := make([]byte, 150)
434 for i := range longMsg {
435 longMsg[i] = 'A'
436 }
437
438 _ = cmd.Flags().Set("message", string(longMsg))
439
440 return cmd
441 },
442 wantErr: false,
443 verifyOutput: func(t *testing.T, output string) {
444 t.Helper()
445 assert.Contains(t, output, "Message:", "Verbose output should contain Message")
446 assert.Contains(t, output, "[...]", "Long message should be truncated with ellipsis")
447 },
448 },
449 }
450
451 for _, tt := range tests {
452 t.Run(tt.name, func(t *testing.T) {
453 // Setup stdin mock if needed
454 var cleanupStdin func()
455 if tt.setupStdin != nil {
456 cleanupStdin = tt.setupStdin()
457 defer cleanupStdin()
458 }
459
460 // Capture stderr for output verification
461 oldStderr := os.Stderr
462 r, w, err := os.Pipe()
463 require.NoError(t, err, "Failed to create pipe")
464
465 os.Stderr = w
466
467 cmd := tt.setupCmd()
468 runErr := run(cmd)
469
470 // Restore stderr and read output
471 w.Close()
472
473 os.Stderr = oldStderr
474
475 var outputBuf bytes.Buffer
476
477 _, _ = io.Copy(&outputBuf, r)
478 r.Close()
479
480 output := outputBuf.String()
481
482 if tt.wantErr {
483 require.Error(t, runErr, "run() should return an error")
484
485 if tt.wantErrMessage != "" {
486 assert.Contains(t, runErr.Error(), tt.wantErrMessage, "Error message mismatch")
487 }
488
489 if tt.wantErrType != "" {
490 var exitErr cli.ExitError
491 if errors.As(runErr, &exitErr) {
492 switch tt.wantErrType {
493 case "ConfigurationError":
494 assert.Equal(t, cli.ExConfig, exitErr.ExitCode, "Exit code should be ExConfig")
495 case "TaskUnavailable":
496 assert.Equal(t, cli.ExUnavailable, exitErr.ExitCode, "Exit code should be ExUnavailable")
497 }
498 } else {
499 t.Errorf("Expected ExitError, got %T: %v", runErr, runErr)
500 }
501 }
502 } else {
503 require.NoError(t, runErr, "run() should not return an error")
504 // Verify "Notification sent" message was logged
505 assert.Contains(t, output, "Notification sent", "Success should log 'Notification sent'")
506
507 if tt.verifyOutput != nil {
508 tt.verifyOutput(t, output)
509 }
510 }
511 })
512 }
513 }
514
515 // Test_run_stdinError tests stdin reading error scenarios.
516 //
517 //nolint:paralleltest // Test manipulates global os.Stdin, cannot run in parallel
518 func Test_run_stdinError(t *testing.T) {
519 // Test stdin read error by using a pipe that gets closed
520 t.Run("stdin read error returns wrapped error", func(t *testing.T) {
521 oldStdin := os.Stdin
522 r, w, err := os.Pipe()
523 require.NoError(t, err)
524
525 os.Stdin = r
526
527 // Close the write end immediately to cause read error
528 w.Close()
529 // Also close the read end to ensure read fails
530 r.Close()
531
532 defer func() {
533 os.Stdin = oldStdin
534 }()
535
536 cmd := &cobra.Command{Use: "send"}
537 cmd.Flags().BoolP("verbose", "v", false, "")
538 cmd.Flags().StringArrayP("url", "u", []string{}, "")
539 cmd.Flags().StringP("message", "m", "", "")
540 cmd.Flags().StringP("title", "t", "", "")
541
542 _ = cmd.Flags().Set("url", "logger://")
543 _ = cmd.Flags().Set("message", "-")
544
545 runErr := run(cmd)
546 require.Error(t, runErr, "run() should return an error for stdin read failure")
547 assert.Contains(t, runErr.Error(), "failed to read message from stdin", "Error should indicate stdin read failure")
548 })
549 }