Debian Codegraph @

shoutrrr/cmd/generate/generate_test.go

raw
1 package generate
2
3 import (
4 "net/url"
5 "testing"
6
7 "github.com/spf13/cobra"
8 "github.com/stretchr/testify/assert"
9 "github.com/stretchr/testify/require"
10 )
11
12 // Test_loadArgsFromAltSources tests the loadArgsFromAltSources function with various scenarios.
13 func Test_loadArgsFromAltSources(t *testing.T) {
14 t.Parallel()
15
16 tests := []struct {
17 name string
18 args []string
19 wantService string
20 wantGen string
21 wantNoChange bool
22 }{
23 {
24 name: "positional service only",
25 args: []string{"discord"},
26 wantService: "discord",
27 wantGen: "basic",
28 },
29 {
30 name: "positional both args",
31 args: []string{"discord", "basic"},
32 wantService: "discord",
33 wantGen: "basic",
34 },
35 {
36 name: "no positional args",
37 args: []string{},
38 wantNoChange: true,
39 },
40 }
41
42 for _, tt := range tests {
43 t.Run(tt.name, func(t *testing.T) {
44 t.Parallel()
45
46 // Create a cobra command with the expected flags
47 cmd := &cobra.Command{
48 Use: "generate",
49 }
50 cmd.Flags().StringP("service", "s", "", "Notification service")
51 cmd.Flags().StringP("generator", "g", "basic", "Generator to use")
52
53 loadArgsFromAltSources(cmd, tt.args)
54
55 if tt.wantNoChange {
56 // Verify flags remain at their defaults/empty values
57 service, _ := cmd.Flags().GetString("service")
58 assert.Empty(t, service, "service flag should remain empty")
59 } else {
60 // Verify the flags were set correctly
61 service, _ := cmd.Flags().GetString("service")
62 gen, _ := cmd.Flags().GetString("generator")
63
64 assert.Equal(t, tt.wantService, service, "service flag mismatch")
65 assert.Equal(t, tt.wantGen, gen, "generator flag mismatch")
66 }
67 })
68 }
69 }
70
71 // Test_maskSensitiveURL tests the maskSensitiveURL function with various service schemas.
72 func Test_maskSensitiveURL(t *testing.T) {
73 t.Parallel()
74
75 tests := []struct {
76 name string
77 serviceSchema string
78 urlStr string
79 want string
80 }{
81 {
82 name: "discord service masks user",
83 serviceSchema: "discord",
84 urlStr: "https://[email protected]/api/webhooks/123",
85 want: "https://[email protected]/api/webhooks/123",
86 },
87 {
88 name: "slack service masks user",
89 serviceSchema: "slack",
90 urlStr: "https://[email protected]/services/123",
91 want: "https://[email protected]/services/123",
92 },
93 {
94 name: "teams service masks user",
95 serviceSchema: "teams",
96 urlStr: "https://[email protected]/webhook",
97 want: "https://[email protected]/webhook",
98 },
99 {
100 name: "smtp service masks password",
101 serviceSchema: "smtp",
102 urlStr: "smtp://user:pass@host:587",
103 want: "smtp://user:REDACTED@host:587",
104 },
105 {
106 name: "pushover service masks token and user",
107 serviceSchema: "pushover",
108 urlStr: "pushover://pushover.net?token=abc&user=def",
109 want: "pushover://pushover.net?token=REDACTED&user=REDACTED",
110 },
111 {
112 name: "gotify service masks token",
113 serviceSchema: "gotify",
114 urlStr: "gotify://gotify.net?token=secret",
115 want: "gotify://gotify.net?token=REDACTED",
116 },
117 {
118 name: "generic service masks user and query params",
119 serviceSchema: "unknown",
120 urlStr: "https://user:pass@host?a=1&b=2",
121 want: "https://REDACTED@host?a=REDACTED&b=REDACTED",
122 },
123 {
124 name: "invalid URL returns original",
125 serviceSchema: "discord",
126 urlStr: "://invalid",
127 want: "://invalid",
128 },
129 }
130
131 for _, tt := range tests {
132 t.Run(tt.name, func(t *testing.T) {
133 t.Parallel()
134
135 got := maskSensitiveURL(tt.serviceSchema, tt.urlStr)
136 assert.Equal(t, tt.want, got, "maskSensitiveURL() returned unexpected value")
137 })
138 }
139 }
140
141 // Test_maskUser tests the maskUser function.
142 func Test_maskUser(t *testing.T) {
143 t.Parallel()
144
145 tests := []struct {
146 name string
147 urlStr string
148 placeholder string
149 wantUser string
150 }{
151 {
152 name: "masks user with placeholder",
153 urlStr: "https://token@host/path",
154 placeholder: redactedStr,
155 wantUser: redactedStr,
156 },
157 {
158 name: "empty user remains nil",
159 urlStr: "https://host/path",
160 placeholder: redactedStr,
161 wantUser: "",
162 },
163 }
164
165 for _, tt := range tests {
166 t.Run(tt.name, func(t *testing.T) {
167 t.Parallel()
168
169 parsedURL, err := url.Parse(tt.urlStr)
170 require.NoError(t, err, "failed to parse URL")
171
172 maskUser(parsedURL, tt.placeholder)
173
174 if tt.wantUser == "" {
175 assert.Nil(t, parsedURL.User, "user should be nil")
176 } else {
177 assert.Equal(t, tt.wantUser, parsedURL.User.Username(), "user mismatch")
178 }
179 })
180 }
181 }
182
183 // Test_maskSMTPUser tests the maskSMTPUser function.
184 func Test_maskSMTPUser(t *testing.T) {
185 t.Parallel()
186
187 tests := []struct {
188 name string
189 urlStr string
190 wantUser string
191 wantPass string
192 }{
193 {
194 name: "masks password preserving username",
195 urlStr: "smtp://user:pass@host:587",
196 wantUser: "user",
197 wantPass: redactedStr,
198 },
199 {
200 name: "user without password gets redacted password",
201 urlStr: "smtp://user@host:587",
202 wantUser: "user",
203 wantPass: redactedStr,
204 },
205 {
206 name: "nil user remains nil",
207 urlStr: "smtp://host:587",
208 wantUser: "",
209 wantPass: "",
210 },
211 }
212
213 for _, tt := range tests {
214 t.Run(tt.name, func(t *testing.T) {
215 t.Parallel()
216
217 parsedURL, err := url.Parse(tt.urlStr)
218 require.NoError(t, err, "failed to parse URL")
219
220 maskSMTPUser(parsedURL)
221
222 if tt.wantUser == "" {
223 assert.Nil(t, parsedURL.User, "user should be nil")
224 } else {
225 assert.Equal(t, tt.wantUser, parsedURL.User.Username(), "username mismatch")
226
227 pass, hasPass := parsedURL.User.Password()
228 if tt.wantPass != "" {
229 assert.True(t, hasPass, "password should be set")
230 assert.Equal(t, tt.wantPass, pass, "password mismatch")
231 }
232 }
233 })
234 }
235 }
236
237 // Test_maskPushoverQuery tests the maskPushoverQuery function.
238 func Test_maskPushoverQuery(t *testing.T) {
239 t.Parallel()
240
241 tests := []struct {
242 name string
243 urlStr string
244 wantTok string
245 wantUser string
246 }{
247 {
248 name: "masks token and user",
249 urlStr: "pushover://?token=abc&user=def",
250 wantTok: redactedStr,
251 wantUser: redactedStr,
252 },
253 {
254 name: "masks only token",
255 urlStr: "pushover://?token=abc",
256 wantTok: redactedStr,
257 wantUser: "",
258 },
259 {
260 name: "leaves other params unchanged",
261 urlStr: "pushover://?other=value",
262 wantTok: "",
263 wantUser: "",
264 },
265 }
266
267 for _, tt := range tests {
268 t.Run(tt.name, func(t *testing.T) {
269 t.Parallel()
270
271 parsedURL, err := url.Parse(tt.urlStr)
272 require.NoError(t, err, "failed to parse URL")
273
274 maskPushoverQuery(parsedURL)
275
276 query := parsedURL.Query()
277 if tt.wantTok != "" {
278 assert.Equal(t, tt.wantTok, query.Get("token"), "token mismatch")
279 }
280
281 if tt.wantUser != "" {
282 assert.Equal(t, tt.wantUser, query.Get("user"), "user mismatch")
283 }
284
285 if tt.wantTok == "" && tt.wantUser == "" {
286 // Verify other params are unchanged
287 assert.Equal(t, "value", query.Get("other"), "other param should be unchanged")
288 }
289 })
290 }
291 }
292
293 // Test_maskGotifyQuery tests the maskGotifyQuery function.
294 func Test_maskGotifyQuery(t *testing.T) {
295 t.Parallel()
296
297 tests := []struct {
298 name string
299 urlStr string
300 wantTok string
301 }{
302 {
303 name: "masks token",
304 urlStr: "gotify://?token=secret",
305 wantTok: redactedStr,
306 },
307 {
308 name: "leaves other params unchanged",
309 urlStr: "gotify://?other=value",
310 wantTok: "",
311 },
312 }
313
314 for _, tt := range tests {
315 t.Run(tt.name, func(t *testing.T) {
316 t.Parallel()
317
318 parsedURL, err := url.Parse(tt.urlStr)
319 require.NoError(t, err, "failed to parse URL")
320
321 maskGotifyQuery(parsedURL)
322
323 query := parsedURL.Query()
324 if tt.wantTok != "" {
325 assert.Equal(t, tt.wantTok, query.Get("token"), "token mismatch")
326 } else {
327 // Verify other params are unchanged
328 assert.Equal(t, "value", query.Get("other"), "other param should be unchanged")
329 }
330 })
331 }
332 }
333
334 // Test_maskGeneric tests the maskGeneric function.
335 func Test_maskGeneric(t *testing.T) {
336 t.Parallel()
337
338 tests := []struct {
339 name string
340 urlStr string
341 wantUser string
342 wantParams map[string]string
343 wantQueryLen int
344 }{
345 {
346 name: "masks user and all query params",
347 urlStr: "https://user:pass@host?a=1&b=2",
348 wantUser: redactedStr,
349 wantParams: map[string]string{
350 "a": redactedStr,
351 "b": redactedStr,
352 },
353 wantQueryLen: 2,
354 },
355 {
356 name: "masks only user when no query params",
357 urlStr: "https://user:pass@host",
358 wantUser: redactedStr,
359 },
360 {
361 name: "nil user with query params",
362 urlStr: "https://host?a=1",
363 wantUser: "",
364 wantParams: map[string]string{"a": redactedStr},
365 wantQueryLen: 1,
366 },
367 }
368
369 for _, tt := range tests {
370 t.Run(tt.name, func(t *testing.T) {
371 t.Parallel()
372
373 parsedURL, err := url.Parse(tt.urlStr)
374 require.NoError(t, err, "failed to parse URL")
375
376 maskGeneric(parsedURL)
377
378 if tt.wantUser != "" {
379 assert.Equal(t, tt.wantUser, parsedURL.User.Username(), "user mismatch")
380 } else if parsedURL.User != nil {
381 t.Errorf("expected nil user, got %v", parsedURL.User)
382 }
383
384 query := parsedURL.Query()
385 if tt.wantParams != nil {
386 assert.Len(t, query, tt.wantQueryLen, "query param count mismatch")
387
388 for key, wantVal := range tt.wantParams {
389 assert.Equal(t, wantVal, query.Get(key), "param %s mismatch", key)
390 }
391 }
392 })
393 }
394 }