Debian Codegraph @

internal/util/cobra_test.go

raw
1 package util
2
3 import (
4 "sync"
5 "testing"
6
7 "github.com/spf13/cobra"
8 "github.com/spf13/viper"
9 "github.com/stretchr/testify/assert"
10 "github.com/stretchr/testify/require"
11 )
12
13 // viperMu protects viper state during parallel test execution.
14 var viperMu sync.Mutex
15
16 func TestLoadFlagsFromAltSources(t *testing.T) {
17 t.Parallel()
18
19 tests := []struct {
20 name string
21 args []string
22 envURL string
23 initialMessage string
24 wantErr bool
25 wantURL string
26 wantMessage string
27 errContains string
28 }{
29 {
30 name: "positional_args_url_only",
31 args: []string{"https://example.com/notify"},
32 wantErr: false,
33 wantURL: "https://example.com/notify",
34 wantMessage: "",
35 },
36 {
37 name: "positional_args_url_and_message",
38 args: []string{"https://example.com/notify", "test message"},
39 wantErr: false,
40 wantURL: "https://example.com/notify",
41 wantMessage: "test message",
42 },
43 {
44 name: "env_var_set_no_args",
45 args: []string{},
46 envURL: "https://env.example.com/notify",
47 wantErr: false,
48 wantURL: "https://env.example.com/notify",
49 wantMessage: "-",
50 },
51 {
52 name: "env_var_set_with_existing_message_flag",
53 args: []string{},
54 envURL: "https://env.example.com/notify",
55 initialMessage: "existing message",
56 wantErr: false,
57 wantURL: "https://env.example.com/notify",
58 wantMessage: "existing message",
59 },
60 {
61 name: "no_args_no_env",
62 args: []string{},
63 envURL: "",
64 wantErr: false,
65 wantURL: "",
66 wantMessage: "",
67 },
68 {
69 name: "empty_args_slice",
70 args: nil,
71 envURL: "",
72 wantErr: false,
73 wantURL: "",
74 wantMessage: "",
75 },
76 {
77 name: "multiple_positional_args_uses_first_two",
78 args: []string{"https://example.com/notify", "msg1", "extra"},
79 wantErr: false,
80 wantURL: "https://example.com/notify",
81 // Only first two args are used
82 wantMessage: "msg1",
83 },
84 }
85
86 for _, tt := range tests {
87 t.Run(tt.name, func(t *testing.T) {
88 t.Parallel()
89
90 // Setup command before acquiring mutex (no viper dependency)
91 cmd := setupTestCommand()
92
93 // Set initial message flag if specified (no viper dependency)
94 if tt.initialMessage != "" {
95 err := cmd.Flags().Set("message", tt.initialMessage)
96 require.NoError(t, err)
97 }
98
99 // Serialize all viper operations to prevent races between
100 // parallel subtests that share viper's global state.
101 viperMu.Lock()
102
103 viper.Reset()
104
105 if tt.envURL != "" {
106 viper.Set("SHOUTRRR_URL", tt.envURL)
107 }
108
109 // Execute the function while holding the lock so viper state
110 // (Reset + Set + read inside LoadFlagsFromAltSources) is atomic
111 err := LoadFlagsFromAltSources(cmd, tt.args)
112
113 viperMu.Unlock()
114
115 // Check error expectation
116 if tt.wantErr {
117 assert.Error(t, err)
118
119 if tt.errContains != "" {
120 assert.Contains(t, err.Error(), tt.errContains)
121 }
122
123 return
124 }
125
126 require.NoError(t, err)
127
128 // Verify flag values (no viper dependency, safe outside lock)
129 urls, err := cmd.Flags().GetStringArray("url")
130 require.NoError(t, err)
131
132 if tt.wantURL == "" {
133 assert.Empty(t, urls, "URL flag mismatch")
134 } else {
135 require.Len(t, urls, 1, "URL flag mismatch")
136 assert.Equal(t, tt.wantURL, urls[0], "URL flag mismatch")
137 }
138
139 message, err := cmd.Flags().GetString("message")
140 require.NoError(t, err)
141 assert.Equal(t, tt.wantMessage, message, "Message flag mismatch")
142 })
143 }
144 }
145
146 func TestLoadFlagsFromAltSources_URLFlagAlreadySet(t *testing.T) {
147 t.Parallel()
148
149 // When URL flag is already set, positional args should still override
150 cmd := setupTestCommand()
151
152 // Pre-set the URL flag (no viper dependency)
153 err := cmd.Flags().Set("url", "https://preset.example.com")
154 require.NoError(t, err)
155
156 // Serialize viper access
157 viperMu.Lock()
158 viper.Reset()
159
160 err = LoadFlagsFromAltSources(cmd, []string{"https://positional.example.com"})
161 viperMu.Unlock()
162
163 require.NoError(t, err)
164
165 // Positional arg should be appended (StringArray.Set appends)
166 urls, err := cmd.Flags().GetStringArray("url")
167 require.NoError(t, err)
168 assert.Contains(t, urls, "https://positional.example.com")
169 }
170
171 func TestLoadFlagsFromAltSources_EnvVarOverridesEmptyFlag(t *testing.T) {
172 t.Parallel()
173
174 // When URL flag is empty but env var is set, env var should be used
175 cmd := setupTestCommand()
176
177 // Serialize viper access
178 viperMu.Lock()
179 viper.Reset()
180 viper.Set("SHOUTRRR_URL", "https://env.example.com")
181
182 err := LoadFlagsFromAltSources(cmd, []string{})
183 viperMu.Unlock()
184
185 require.NoError(t, err)
186
187 urls, err := cmd.Flags().GetStringArray("url")
188 require.NoError(t, err)
189 require.Len(t, urls, 1)
190 assert.Equal(t, "https://env.example.com", urls[0])
191 }
192
193 func TestLoadFlagsFromAltSources_ErrorCases(t *testing.T) {
194 t.Parallel()
195
196 tests := []struct {
197 name string
198 setupCmd func() *cobra.Command
199 args []string
200 envURL string
201 wantErr bool
202 errContains string
203 }{
204 {
205 name: "error_url_flag_not_exists",
206 setupCmd: func() *cobra.Command {
207 cmd := &cobra.Command{Use: "test"}
208 // Only add message flag, not url flag
209 cmd.Flags().String("message", "", "The notification message")
210
211 return cmd
212 },
213 args: []string{},
214 envURL: "https://example.com",
215 wantErr: true,
216 errContains: "checking url flag and env",
217 },
218 {
219 name: "error_message_flag_not_exists_for_env_path",
220 setupCmd: func() *cobra.Command {
221 cmd := &cobra.Command{Use: "test"}
222 // Only add url flag, not message flag
223 cmd.Flags().StringArray("url", []string{}, "The notification URL")
224
225 return cmd
226 },
227 args: []string{},
228 envURL: "https://example.com",
229 wantErr: true,
230 errContains: "getting message flag value",
231 },
232 }
233
234 for _, tt := range tests {
235 t.Run(tt.name, func(t *testing.T) {
236 t.Parallel()
237
238 cmd := tt.setupCmd()
239
240 // Serialize viper access
241 viperMu.Lock()
242 viper.Reset()
243
244 if tt.envURL != "" {
245 viper.Set("SHOUTRRR_URL", tt.envURL)
246 }
247
248 err := LoadFlagsFromAltSources(cmd, tt.args)
249 viperMu.Unlock()
250
251 require.Error(t, err)
252 assert.Contains(t, err.Error(), tt.errContains)
253 })
254 }
255 }
256
257 func Test_hasURLInEnvButNotFlag(t *testing.T) {
258 t.Parallel()
259
260 tests := []struct {
261 name string
262 flagURL string
263 envURL string
264 want bool
265 wantErr bool
266 errContain string
267 }{
268 {
269 name: "flag_empty_env_set",
270 flagURL: "",
271 envURL: "https://example.com",
272 want: true,
273 wantErr: false,
274 },
275 {
276 name: "flag_set_env_empty",
277 flagURL: "https://example.com",
278 envURL: "",
279 want: false,
280 wantErr: false,
281 },
282 {
283 name: "both_empty",
284 flagURL: "",
285 envURL: "",
286 want: false,
287 wantErr: false,
288 },
289 {
290 name: "both_set",
291 flagURL: "https://flag.example.com",
292 envURL: "https://env.example.com",
293 want: false,
294 wantErr: false,
295 },
296 {
297 name: "flag_set_env_set_different",
298 flagURL: "https://example.com",
299 envURL: "https://other.example.com",
300 want: false,
301 wantErr: false,
302 },
303 }
304
305 for _, tt := range tests {
306 t.Run(tt.name, func(t *testing.T) {
307 t.Parallel()
308
309 // Setup command with flag value (no viper dependency)
310 cmd := setupTestCommand()
311
312 if tt.flagURL != "" {
313 err := cmd.Flags().Set("url", tt.flagURL)
314 require.NoError(t, err)
315 }
316
317 // Serialize viper access
318 viperMu.Lock()
319 viper.Reset()
320
321 if tt.envURL != "" {
322 viper.Set("SHOUTRRR_URL", tt.envURL)
323 }
324
325 got, err := hasURLInEnvButNotFlag(cmd)
326 viperMu.Unlock()
327
328 if tt.wantErr {
329 assert.Error(t, err)
330
331 if tt.errContain != "" {
332 assert.Contains(t, err.Error(), tt.errContain)
333 }
334
335 return
336 }
337
338 require.NoError(t, err)
339 assert.Equal(t, tt.want, got)
340 })
341 }
342 }
343
344 func Test_hasURLInEnvButNotFlag_MissingFlag(t *testing.T) {
345 t.Parallel()
346
347 // Test when the url flag doesn't exist on the command
348 cmd := &cobra.Command{
349 Use: "test",
350 }
351
352 // Only add message flag, not url flag
353 cmd.Flags().String("message", "", "The notification message")
354
355 // Serialize viper access
356 viperMu.Lock()
357 viper.Reset()
358 viper.Set("SHOUTRRR_URL", "https://example.com")
359
360 got, err := hasURLInEnvButNotFlag(cmd)
361 viperMu.Unlock()
362
363 // This should return an error because the flag doesn't exist
364 require.Error(t, err)
365 assert.False(t, got)
366 assert.Contains(t, err.Error(), "getting url flag value")
367 }
368
369 // setupTestCommand creates a cobra command with url and message flags for testing.
370 func setupTestCommand() *cobra.Command {
371 cmd := &cobra.Command{
372 Use: "test",
373 }
374
375 cmd.Flags().StringArray("url", []string{}, "The notification URL")
376 cmd.Flags().String("message", "", "The notification message")
377
378 return cmd
379 }