Debian Codegraph @

shoutrrr/cmd/verify/verify_test.go

raw
1 package verify
2
3 import (
4 "bytes"
5 "context"
6 "errors"
7 "fmt"
8 "io"
9 "os"
10 "os/exec"
11 "testing"
12
13 "github.com/spf13/cobra"
14 "github.com/stretchr/testify/assert"
15 "github.com/stretchr/testify/require"
16 )
17
18 // TestRun_FlagRetrievalError tests the Run function with flag retrieval error.
19 func TestRun_FlagRetrievalError(t *testing.T) {
20 t.Parallel()
21
22 if os.Getenv("TEST_SUBPROCESS") == "1" {
23 cmd := &cobra.Command{Use: "verify"}
24 // Create url flag with wrong type to cause type mismatch error
25 cmd.Flags().BoolP("url", "u", false, "")
26
27 Run(cmd, []string{})
28
29 return
30 }
31
32 // Run the test in a subprocess
33 ctx := context.Background()
34 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_FlagRetrievalError")
35
36 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
37
38 var outputBuf bytes.Buffer
39
40 cmd.Stdout = &outputBuf
41 cmd.Stderr = &outputBuf
42
43 err := cmd.Run()
44
45 var exitErr *exec.ExitError
46 if errors.As(err, &exitErr) {
47 assert.Equal(t, 1, exitErr.ExitCode(), "Exit code mismatch")
48 } else {
49 t.Fatalf("Expected ExitError, got: %v", err)
50 }
51 }
52
53 // TestRun_UnknownService tests the Run function with unknown service error.
54 func TestRun_UnknownService(t *testing.T) {
55 t.Parallel()
56
57 if os.Getenv("TEST_SUBPROCESS") == "1" {
58 cmd := &cobra.Command{Use: "verify"}
59 cmd.Flags().StringArrayP("url", "u", []string{}, "")
60
61 _ = cmd.Flags().Set("url", "unknownservice://test")
62
63 Run(cmd, []string{})
64
65 return
66 }
67
68 // Run the test in a subprocess
69 ctx := context.Background()
70 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_UnknownService")
71
72 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
73
74 var outputBuf bytes.Buffer
75
76 cmd.Stdout = &outputBuf
77 cmd.Stderr = &outputBuf
78
79 err := cmd.Run()
80 output := outputBuf.String()
81
82 var exitErr *exec.ExitError
83 if errors.As(err, &exitErr) {
84 assert.Equal(t, 1, exitErr.ExitCode(), "Exit code mismatch")
85 } else {
86 t.Fatalf("Expected ExitError, got: %v", err)
87 }
88
89 // Error message should be sanitized
90 assert.Contains(t, output, "service not recognized", "Error should be sanitized for unknown service")
91 }
92
93 // TestRun_InvalidURLFormat tests the Run function with invalid URL format.
94 func TestRun_InvalidURLFormat(t *testing.T) {
95 t.Parallel()
96
97 if os.Getenv("TEST_SUBPROCESS") == "1" {
98 cmd := &cobra.Command{Use: "verify"}
99 cmd.Flags().StringArrayP("url", "u", []string{}, "")
100
101 _ = cmd.Flags().Set("url", "://invalid")
102
103 Run(cmd, []string{})
104
105 return
106 }
107
108 // Run the test in a subprocess
109 ctx := context.Background()
110 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_InvalidURLFormat")
111
112 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
113
114 err := cmd.Run()
115
116 var exitErr *exec.ExitError
117 if errors.As(err, &exitErr) {
118 assert.Equal(t, 1, exitErr.ExitCode(), "Exit code mismatch")
119 } else {
120 t.Fatalf("Expected ExitError, got: %v", err)
121 }
122 }
123
124 // TestRun_SubprocessErrorOutput tests the error output messages from verify command.
125 // This specifically tests that sanitizeError is properly applied to error messages.
126 func TestRun_SubprocessErrorOutput(t *testing.T) {
127 t.Parallel()
128
129 if os.Getenv("TEST_SUBPROCESS") == "1" {
130 cmd := &cobra.Command{Use: "verify"}
131 cmd.Flags().StringArrayP("url", "u", []string{}, "")
132
133 // Use an unknown service URL
134 _ = cmd.Flags().Set("url", "xyzservice://test")
135
136 Run(cmd, []string{})
137
138 return
139 }
140
141 // Run in subprocess
142 ctx := context.Background()
143 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_SubprocessErrorOutput")
144
145 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
146
147 var outputBuf bytes.Buffer
148
149 cmd.Stdout = &outputBuf
150 cmd.Stderr = &outputBuf
151
152 err := cmd.Run()
153 output := outputBuf.String()
154
155 // Should exit with code 1
156 var exitErr *exec.ExitError
157 if errors.As(err, &exitErr) {
158 assert.Equal(t, 1, exitErr.ExitCode(), "Should exit with code 1")
159 } else {
160 t.Fatalf("Expected ExitError, got: %v", err)
161 }
162
163 // Error message should be sanitized
164 assert.Contains(t, output, "service not recognized", "Error should be sanitized for unknown service")
165 }
166
167 // Test_sanitizeError tests the error sanitization function with various error inputs.
168 // This is a pure function and can be tested directly with table-driven tests.
169 func Test_sanitizeError(t *testing.T) {
170 t.Parallel()
171
172 tests := []struct {
173 name string
174 err error
175 want string
176 }{
177 {
178 name: "unknown service error returns service not recognized",
179 err: errors.New("unknown service: xyz"),
180 want: "service not recognized",
181 },
182 {
183 name: "parse invalid URL error returns invalid URL format",
184 err: errors.New("parse \"://\": invalid URL"),
185 want: "invalid URL format",
186 },
187 {
188 name: "random error returns unable to process URL",
189 err: errors.New("some random error"),
190 want: "unable to process URL",
191 },
192 {
193 name: "parse error in query returns invalid URL format",
194 err: errors.New("parse error in query"),
195 want: "invalid URL format",
196 },
197 {
198 name: "error containing 'invalid' returns invalid URL format",
199 err: errors.New("invalid scheme provided"),
200 want: "invalid URL format",
201 },
202 {
203 name: "wrapped unknown service error returns service not recognized",
204 err: fmt.Errorf("locating service for URL: %w", errors.New("unknown service: test")),
205 want: "service not recognized",
206 },
207 {
208 name: "empty error returns unable to process URL",
209 err: errors.New(""),
210 want: "unable to process URL",
211 },
212 }
213
214 for _, tt := range tests {
215 t.Run(tt.name, func(t *testing.T) {
216 t.Parallel()
217
218 got := sanitizeError(tt.err)
219 assert.Equal(t, tt.want, got, "sanitizeError() output mismatch")
220 })
221 }
222 }
223
224 // TestRun_CaptureStdout tests that successful verification outputs to stdout.
225 func TestRun_CaptureStdout(t *testing.T) {
226 t.Parallel()
227
228 if os.Getenv("TEST_SUBPROCESS") == "1" {
229 cmd := &cobra.Command{Use: "verify"}
230 cmd.Flags().StringArrayP("url", "u", []string{}, "")
231
232 _ = cmd.Flags().Set("url", "logger://")
233
234 Run(cmd, []string{})
235
236 return
237 }
238
239 // Run in subprocess
240 ctx := context.Background()
241 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_CaptureStdout")
242
243 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
244
245 var stdoutBuf, stderrBuf bytes.Buffer
246
247 cmd.Stdout = &stdoutBuf
248 cmd.Stderr = &stderrBuf
249
250 err := cmd.Run()
251
252 // Should succeed
253 require.NoError(t, err, "Valid URL verification should succeed")
254
255 // Should output configuration to stdout
256 stdout := stdoutBuf.String()
257 assert.NotEmpty(t, stdout, "Successful verification should output configuration")
258 }
259
260 // TestRun_IntegrationWithExitCodes_ValidURL tests valid URL exits with success code.
261 func TestRun_IntegrationWithExitCodes_ValidURL(t *testing.T) {
262 t.Parallel()
263
264 if os.Getenv("TEST_SUBPROCESS") == "1" {
265 cmd := &cobra.Command{Use: "verify"}
266 cmd.Flags().StringArrayP("url", "u", []string{}, "")
267
268 _ = cmd.Flags().Set("url", "logger://")
269
270 Run(cmd, []string{})
271
272 return
273 }
274
275 // Run in subprocess
276 ctx := context.Background()
277 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_IntegrationWithExitCodes_ValidURL")
278
279 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
280
281 err := cmd.Run()
282 require.NoError(t, err, "Expected successful exit")
283 }
284
285 // TestRun_IntegrationWithExitCodes_InvalidURL tests invalid URL exits with error code.
286 func TestRun_IntegrationWithExitCodes_InvalidURL(t *testing.T) {
287 t.Parallel()
288
289 if os.Getenv("TEST_SUBPROCESS") == "1" {
290 cmd := &cobra.Command{Use: "verify"}
291 cmd.Flags().StringArrayP("url", "u", []string{}, "")
292
293 _ = cmd.Flags().Set("url", "://badurl")
294
295 Run(cmd, []string{})
296
297 return
298 }
299
300 // Run in subprocess
301 ctx := context.Background()
302 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_IntegrationWithExitCodes_InvalidURL")
303
304 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
305
306 err := cmd.Run()
307
308 var exitErr *exec.ExitError
309 if errors.As(err, &exitErr) {
310 assert.Equal(t, 1, exitErr.ExitCode(), "Exit code mismatch")
311 } else {
312 t.Fatalf("Expected ExitError with code 1, got: %v", err)
313 }
314 }
315
316 // TestRun_WithSimpleLoggerURL tests verification with simple logger URL.
317 func TestRun_WithSimpleLoggerURL(t *testing.T) {
318 t.Parallel()
319
320 if os.Getenv("TEST_SUBPROCESS") == "1" {
321 cmd := &cobra.Command{Use: "verify"}
322 cmd.Flags().StringArrayP("url", "u", []string{}, "")
323
324 _ = cmd.Flags().Set("url", "logger://")
325
326 Run(cmd, []string{})
327
328 return
329 }
330
331 ctx := context.Background()
332 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_WithSimpleLoggerURL")
333
334 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
335
336 var outputBuf bytes.Buffer
337
338 cmd.Stdout = &outputBuf
339 cmd.Stderr = &outputBuf
340
341 err := cmd.Run()
342 output := outputBuf.String()
343
344 require.NoError(t, err, "Valid logger URL should succeed")
345 assert.NotEmpty(t, output, "Output should contain configuration")
346 }
347
348 // TestRun_WithLoggerURLWithPath tests verification with logger URL with path.
349 func TestRun_WithLoggerURLWithPath(t *testing.T) {
350 t.Parallel()
351
352 if os.Getenv("TEST_SUBPROCESS") == "1" {
353 cmd := &cobra.Command{Use: "verify"}
354 cmd.Flags().StringArrayP("url", "u", []string{}, "")
355
356 _ = cmd.Flags().Set("url", "logger://test/path")
357
358 Run(cmd, []string{})
359
360 return
361 }
362
363 ctx := context.Background()
364 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_WithLoggerURLWithPath")
365
366 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
367
368 var outputBuf bytes.Buffer
369
370 cmd.Stdout = &outputBuf
371 cmd.Stderr = &outputBuf
372
373 err := cmd.Run()
374 output := outputBuf.String()
375
376 require.NoError(t, err, "Valid logger URL with path should succeed")
377 assert.NotEmpty(t, output, "Output should contain configuration")
378 }
379
380 // TestRun_StderrOutput tests that flag errors output to stderr.
381 func TestRun_StderrOutput(t *testing.T) {
382 t.Parallel()
383
384 if os.Getenv("TEST_SUBPROCESS") == "1" {
385 cmd := &cobra.Command{Use: "verify"}
386 // Create a flag type mismatch to trigger stderr output
387 cmd.Flags().BoolP("url", "u", false, "")
388
389 Run(cmd, []string{})
390
391 return
392 }
393
394 // Run in subprocess
395 ctx := context.Background()
396 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_StderrOutput")
397
398 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
399
400 var stderrBuf bytes.Buffer
401
402 cmd.Stderr = &stderrBuf
403 cmd.Stdout = io.Discard
404
405 err := cmd.Run()
406
407 // Should fail
408 var exitErr *exec.ExitError
409 if errors.As(err, &exitErr) {
410 assert.Equal(t, 1, exitErr.ExitCode(), "Should exit with code 1")
411 } else {
412 t.Fatalf("Expected ExitError, got: %v", err)
413 }
414
415 // Error should be in stderr
416 stderr := stderrBuf.String()
417 assert.Contains(t, stderr, "Error getting URL flags", "Error message should be written to stderr")
418 }
419
420 // Test_sanitizeError_EdgeCases tests edge cases for error sanitization.
421 func Test_sanitizeError_EdgeCases(t *testing.T) {
422 t.Parallel()
423
424 tests := []struct {
425 name string
426 err error
427 want string
428 }{
429 {
430 name: "error with both unknown service and parse",
431 err: errors.New("parse error: unknown service"),
432 // Note: "unknown service" check comes before "parse" check
433 want: "service not recognized",
434 },
435 {
436 name: "error with invalid keyword",
437 err: errors.New("invalid token"),
438 want: "invalid URL format",
439 },
440 {
441 name: "error with parse keyword",
442 err: errors.New("failed to parse configuration"),
443 want: "invalid URL format",
444 },
445 {
446 name: "unknown service at beginning",
447 err: errors.New("unknown service xyz"),
448 want: "service not recognized",
449 },
450 {
451 name: "unknown service in middle",
452 err: errors.New("error: unknown service xyz not found"),
453 want: "service not recognized",
454 },
455 }
456
457 for _, tt := range tests {
458 t.Run(tt.name, func(t *testing.T) {
459 t.Parallel()
460
461 got := sanitizeError(tt.err)
462 assert.Equal(t, tt.want, got, "sanitizeError() output mismatch")
463 })
464 }
465 }
466
467 // TestCmd_Initialization tests that the Cmd is properly initialized.
468 func TestCmd_Initialization(t *testing.T) {
469 t.Parallel()
470
471 t.Run("verify command is properly initialized", func(t *testing.T) {
472 t.Parallel()
473 assert.NotNil(t, Cmd, "Cmd should be initialized")
474 assert.Equal(t, "verify", Cmd.Use, "Command use should be 'verify'")
475 assert.NotEmpty(t, Cmd.Short, "Command should have a short description")
476 assert.NotNil(t, Cmd.Run, "Command should have a Run function")
477 assert.NotNil(t, Cmd.PreRunE, "Command should have a PreRunE function")
478
479 // Check that url flag exists
480 urlFlag := Cmd.Flags().Lookup("url")
481 assert.NotNil(t, urlFlag, "URL flag should exist")
482 assert.Equal(t, "u", urlFlag.Shorthand, "URL flag should have shorthand 'u'")
483 })
484 }
485
486 // TestRun_WithLoggerSchemeSucceeds tests verification with logger scheme succeeds.
487 func TestRun_WithLoggerSchemeSucceeds(t *testing.T) {
488 t.Parallel()
489
490 if os.Getenv("TEST_SUBPROCESS") == "1" {
491 cmd := &cobra.Command{Use: "verify"}
492 cmd.Flags().StringArrayP("url", "u", []string{}, "")
493
494 _ = cmd.Flags().Set("url", "logger://")
495
496 Run(cmd, []string{})
497
498 return
499 }
500
501 ctx := context.Background()
502 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_WithLoggerSchemeSucceeds")
503
504 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
505
506 err := cmd.Run()
507 require.NoError(t, err, "Expected success for valid scheme")
508 }
509
510 // TestRun_WithUnknownSchemeFails tests verification with unknown scheme fails.
511 func TestRun_WithUnknownSchemeFails(t *testing.T) {
512 t.Parallel()
513
514 if os.Getenv("TEST_SUBPROCESS") == "1" {
515 cmd := &cobra.Command{Use: "verify"}
516 cmd.Flags().StringArrayP("url", "u", []string{}, "")
517
518 _ = cmd.Flags().Set("url", "unknown123://test")
519
520 Run(cmd, []string{})
521
522 return
523 }
524
525 ctx := context.Background()
526 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_WithUnknownSchemeFails")
527
528 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
529
530 err := cmd.Run()
531
532 var exitErr *exec.ExitError
533 if errors.As(err, &exitErr) {
534 assert.Equal(t, 1, exitErr.ExitCode(), "Expected exit code 1 for invalid scheme")
535 } else {
536 t.Fatalf("Expected ExitError, got: %v", err)
537 }
538 }
539
540 // TestRun_MultipleURLs tests that providing multiple --url values results in an error.
541 func TestRun_MultipleURLs(t *testing.T) {
542 t.Parallel()
543
544 if os.Getenv("TEST_SUBPROCESS") == "1" {
545 cmd := &cobra.Command{Use: "verify"}
546 cmd.Flags().StringArrayP("url", "u", []string{}, "")
547
548 require.NoError(t, cmd.Flags().Set("url", "logger://"))
549 require.NoError(t, cmd.Flags().Set("url", "logger://test/path"))
550
551 Run(cmd, []string{})
552
553 return
554 }
555
556 ctx := context.Background()
557 cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestRun_MultipleURLs")
558
559 cmd.Env = append(os.Environ(), "TEST_SUBPROCESS=1")
560
561 var outputBuf bytes.Buffer
562
563 cmd.Stdout = &outputBuf
564 cmd.Stderr = &outputBuf
565
566 err := cmd.Run()
567 output := outputBuf.String()
568
569 var exitErr *exec.ExitError
570 if errors.As(err, &exitErr) {
571 assert.Equal(t, 1, exitErr.ExitCode(), "Expected exit code 1 for multiple URLs")
572 } else {
573 t.Fatalf("Expected ExitError, got: %v", err)
574 }
575
576 assert.Contains(t, output, "multiple --url values are not supported", "Error should indicate multiple URLs are not supported")
577 }