git.iko.soy/crush
on main help sign in
test: improve tests (#315)
0506272Carlos Alexandro Becker
CRUSH.md+2−1
compare with main
unifiedsplit
@@ -19,7 +19,8 @@
19- **Interfaces**: Define interfaces in consuming packages, keep them small and focused
19- **Interfaces**: Define interfaces in consuming packages, keep them small and focused
20- **Structs**: Use struct embedding for composition, group related fields
20- **Structs**: Use struct embedding for composition, group related fields
21- **Constants**: Use typed constants with iota for enums, group in const blocks
21- **Constants**: Use typed constants with iota for enums, group in const blocks
22−- **Testing**: Use testify/assert and testify/require, parallel tests with `t.Parallel()`
22+- **Testing**: Use testify's `require` package, parallel tests with `t.Parallel()`,
23+ `t.SetEnv()` to set environment variables.
23- **JSON tags**: Use snake_case for JSON field names
24- **JSON tags**: Use snake_case for JSON field names
24- **File permissions**: Use octal notation (0o755, 0o644) for file permissions
25- **File permissions**: Use octal notation (0o755, 0o644) for file permissions
25- **Comments**: End comments in periods unless comments are at the end of the line.
26- **Comments**: End comments in periods unless comments are at the end of the line.
internal/config/load_test.go+155−155
@@ -11,7 +11,7 @@ import (
11 "github.com/charmbracelet/catwalk/pkg/catwalk"
11 "github.com/charmbracelet/catwalk/pkg/catwalk"
12 "github.com/charmbracelet/crush/internal/csync"
12 "github.com/charmbracelet/crush/internal/csync"
13 "github.com/charmbracelet/crush/internal/env"
13 "github.com/charmbracelet/crush/internal/env"
14− "github.com/stretchr/testify/assert"
14+ "github.com/stretchr/testify/require"
15)
15)
16
16
17func TestMain(m *testing.M) {
17func TestMain(m *testing.M) {
@@ -28,12 +28,12 @@ func TestConfig_LoadFromReaders(t *testing.T) {
28
28
29 loadedConfig, err := loadFromReaders([]io.Reader{data1, data2, data3})
29 loadedConfig, err := loadFromReaders([]io.Reader{data1, data2, data3})
30
30
31− assert.NoError(t, err)
31+ require.NoError(t, err)
32− assert.NotNil(t, loadedConfig)
32+ require.NotNil(t, loadedConfig)
33− assert.Equal(t, 1, loadedConfig.Providers.Len())
33+ require.Equal(t, 1, loadedConfig.Providers.Len())
34 pc, _ := loadedConfig.Providers.Get("openai")
34 pc, _ := loadedConfig.Providers.Get("openai")
35− assert.Equal(t, "key2", pc.APIKey)
35+ require.Equal(t, "key2", pc.APIKey)
36− assert.Equal(t, "https://api.openai.com/v2", pc.BaseURL)
36+ require.Equal(t, "https://api.openai.com/v2", pc.BaseURL)
37}
37}
38
38
39func TestConfig_setDefaults(t *testing.T) {
39func TestConfig_setDefaults(t *testing.T) {
@@ -41,18 +41,18 @@ func TestConfig_setDefaults(t *testing.T) {
41
41
42 cfg.setDefaults("/tmp")
42 cfg.setDefaults("/tmp")
43
43
44− assert.NotNil(t, cfg.Options)
44+ require.NotNil(t, cfg.Options)
45− assert.NotNil(t, cfg.Options.TUI)
45+ require.NotNil(t, cfg.Options.TUI)
46− assert.NotNil(t, cfg.Options.ContextPaths)
46+ require.NotNil(t, cfg.Options.ContextPaths)
47− assert.NotNil(t, cfg.Providers)
47+ require.NotNil(t, cfg.Providers)
48− assert.NotNil(t, cfg.Models)
48+ require.NotNil(t, cfg.Models)
49− assert.NotNil(t, cfg.LSP)
49+ require.NotNil(t, cfg.LSP)
50− assert.NotNil(t, cfg.MCP)
50+ require.NotNil(t, cfg.MCP)
51− assert.Equal(t, filepath.Join("/tmp", ".crush"), cfg.Options.DataDirectory)
51+ require.Equal(t, filepath.Join("/tmp", ".crush"), cfg.Options.DataDirectory)
52 for _, path := range defaultContextPaths {
52 for _, path := range defaultContextPaths {
53− assert.Contains(t, cfg.Options.ContextPaths, path)
53+ require.Contains(t, cfg.Options.ContextPaths, path)
54 }
54 }
55− assert.Equal(t, "/tmp", cfg.workingDir)
55+ require.Equal(t, "/tmp", cfg.workingDir)
56}
56}
57
57
58func TestConfig_configureProviders(t *testing.T) {
58func TestConfig_configureProviders(t *testing.T) {
@@ -74,12 +74,12 @@ func TestConfig_configureProviders(t *testing.T) {
74 })
74 })
75 resolver := NewEnvironmentVariableResolver(env)
75 resolver := NewEnvironmentVariableResolver(env)
76 err := cfg.configureProviders(env, resolver, knownProviders)
76 err := cfg.configureProviders(env, resolver, knownProviders)
77− assert.NoError(t, err)
77+ require.NoError(t, err)
78− assert.Equal(t, 1, cfg.Providers.Len())
78+ require.Equal(t, 1, cfg.Providers.Len())
79
79
80 // We want to make sure that we keep the configured API key as a placeholder
80 // We want to make sure that we keep the configured API key as a placeholder
81 pc, _ := cfg.Providers.Get("openai")
81 pc, _ := cfg.Providers.Get("openai")
82− assert.Equal(t, "$OPENAI_API_KEY", pc.APIKey)
82+ require.Equal(t, "$OPENAI_API_KEY", pc.APIKey)
83}
83}
84
84
85func TestConfig_configureProvidersWithOverride(t *testing.T) {
85func TestConfig_configureProvidersWithOverride(t *testing.T) {
@@ -117,15 +117,15 @@ func TestConfig_configureProvidersWithOverride(t *testing.T) {
117 })
117 })
118 resolver := NewEnvironmentVariableResolver(env)
118 resolver := NewEnvironmentVariableResolver(env)
119 err := cfg.configureProviders(env, resolver, knownProviders)
119 err := cfg.configureProviders(env, resolver, knownProviders)
120− assert.NoError(t, err)
120+ require.NoError(t, err)
121− assert.Equal(t, 1, cfg.Providers.Len())
121+ require.Equal(t, 1, cfg.Providers.Len())
122
122
123 // We want to make sure that we keep the configured API key as a placeholder
123 // We want to make sure that we keep the configured API key as a placeholder
124 pc, _ := cfg.Providers.Get("openai")
124 pc, _ := cfg.Providers.Get("openai")
125− assert.Equal(t, "xyz", pc.APIKey)
125+ require.Equal(t, "xyz", pc.APIKey)
126− assert.Equal(t, "https://api.openai.com/v2", pc.BaseURL)
126+ require.Equal(t, "https://api.openai.com/v2", pc.BaseURL)
127− assert.Len(t, pc.Models, 2)
127+ require.Len(t, pc.Models, 2)
128− assert.Equal(t, "Updated", pc.Models[0].Name)
128+ require.Equal(t, "Updated", pc.Models[0].Name)
129}
129}
130
130
131func TestConfig_configureProvidersWithNewProvider(t *testing.T) {
131func TestConfig_configureProvidersWithNewProvider(t *testing.T) {
@@ -159,20 +159,20 @@ func TestConfig_configureProvidersWithNewProvider(t *testing.T) {
159 })
159 })
160 resolver := NewEnvironmentVariableResolver(env)
160 resolver := NewEnvironmentVariableResolver(env)
161 err := cfg.configureProviders(env, resolver, knownProviders)
161 err := cfg.configureProviders(env, resolver, knownProviders)
162− assert.NoError(t, err)
162+ require.NoError(t, err)
163 // Should be to because of the env variable
163 // Should be to because of the env variable
164− assert.Equal(t, cfg.Providers.Len(), 2)
164+ require.Equal(t, cfg.Providers.Len(), 2)
165
165
166 // We want to make sure that we keep the configured API key as a placeholder
166 // We want to make sure that we keep the configured API key as a placeholder
167 pc, _ := cfg.Providers.Get("custom")
167 pc, _ := cfg.Providers.Get("custom")
168− assert.Equal(t, "xyz", pc.APIKey)
168+ require.Equal(t, "xyz", pc.APIKey)
169 // Make sure we set the ID correctly
169 // Make sure we set the ID correctly
170− assert.Equal(t, "custom", pc.ID)
170+ require.Equal(t, "custom", pc.ID)
171− assert.Equal(t, "https://api.someendpoint.com/v2", pc.BaseURL)
171+ require.Equal(t, "https://api.someendpoint.com/v2", pc.BaseURL)
172− assert.Len(t, pc.Models, 1)
172+ require.Len(t, pc.Models, 1)
173
173
174 _, ok := cfg.Providers.Get("openai")
174 _, ok := cfg.Providers.Get("openai")
175− assert.True(t, ok, "OpenAI provider should still be present")
175+ require.True(t, ok, "OpenAI provider should still be present")
176}
176}
177
177
178func TestConfig_configureProvidersBedrockWithCredentials(t *testing.T) {
178func TestConfig_configureProvidersBedrockWithCredentials(t *testing.T) {
@@ -195,13 +195,13 @@ func TestConfig_configureProvidersBedrockWithCredentials(t *testing.T) {
195 })
195 })
196 resolver := NewEnvironmentVariableResolver(env)
196 resolver := NewEnvironmentVariableResolver(env)
197 err := cfg.configureProviders(env, resolver, knownProviders)
197 err := cfg.configureProviders(env, resolver, knownProviders)
198− assert.NoError(t, err)
198+ require.NoError(t, err)
199− assert.Equal(t, cfg.Providers.Len(), 1)
199+ require.Equal(t, cfg.Providers.Len(), 1)
200
200
201 bedrockProvider, ok := cfg.Providers.Get("bedrock")
201 bedrockProvider, ok := cfg.Providers.Get("bedrock")
202− assert.True(t, ok, "Bedrock provider should be present")
202+ require.True(t, ok, "Bedrock provider should be present")
203− assert.Len(t, bedrockProvider.Models, 1)
203+ require.Len(t, bedrockProvider.Models, 1)
204− assert.Equal(t, "anthropic.claude-sonnet-4-20250514-v1:0", bedrockProvider.Models[0].ID)
204+ require.Equal(t, "anthropic.claude-sonnet-4-20250514-v1:0", bedrockProvider.Models[0].ID)
205}
205}
206
206
207func TestConfig_configureProvidersBedrockWithoutCredentials(t *testing.T) {
207func TestConfig_configureProvidersBedrockWithoutCredentials(t *testing.T) {
@@ -221,9 +221,9 @@ func TestConfig_configureProvidersBedrockWithoutCredentials(t *testing.T) {
221 env := env.NewFromMap(map[string]string{})
221 env := env.NewFromMap(map[string]string{})
222 resolver := NewEnvironmentVariableResolver(env)
222 resolver := NewEnvironmentVariableResolver(env)
223 err := cfg.configureProviders(env, resolver, knownProviders)
223 err := cfg.configureProviders(env, resolver, knownProviders)
224− assert.NoError(t, err)
224+ require.NoError(t, err)
225 // Provider should not be configured without credentials
225 // Provider should not be configured without credentials
226− assert.Equal(t, cfg.Providers.Len(), 0)
226+ require.Equal(t, cfg.Providers.Len(), 0)
227}
227}
228
228
229func TestConfig_configureProvidersBedrockWithoutUnsupportedModel(t *testing.T) {
229func TestConfig_configureProvidersBedrockWithoutUnsupportedModel(t *testing.T) {
@@ -246,7 +246,7 @@ func TestConfig_configureProvidersBedrockWithoutUnsupportedModel(t *testing.T) {
246 })
246 })
247 resolver := NewEnvironmentVariableResolver(env)
247 resolver := NewEnvironmentVariableResolver(env)
248 err := cfg.configureProviders(env, resolver, knownProviders)
248 err := cfg.configureProviders(env, resolver, knownProviders)
249− assert.Error(t, err)
249+ require.Error(t, err)
250}
250}
251
251
252func TestConfig_configureProvidersVertexAIWithCredentials(t *testing.T) {
252func TestConfig_configureProvidersVertexAIWithCredentials(t *testing.T) {
@@ -270,15 +270,15 @@ func TestConfig_configureProvidersVertexAIWithCredentials(t *testing.T) {
270 })
270 })
271 resolver := NewEnvironmentVariableResolver(env)
271 resolver := NewEnvironmentVariableResolver(env)
272 err := cfg.configureProviders(env, resolver, knownProviders)
272 err := cfg.configureProviders(env, resolver, knownProviders)
273− assert.NoError(t, err)
273+ require.NoError(t, err)
274− assert.Equal(t, cfg.Providers.Len(), 1)
274+ require.Equal(t, cfg.Providers.Len(), 1)
275
275
276 vertexProvider, ok := cfg.Providers.Get("vertexai")
276 vertexProvider, ok := cfg.Providers.Get("vertexai")
277− assert.True(t, ok, "VertexAI provider should be present")
277+ require.True(t, ok, "VertexAI provider should be present")
278− assert.Len(t, vertexProvider.Models, 1)
278+ require.Len(t, vertexProvider.Models, 1)
279− assert.Equal(t, "gemini-pro", vertexProvider.Models[0].ID)
279+ require.Equal(t, "gemini-pro", vertexProvider.Models[0].ID)
280− assert.Equal(t, "test-project", vertexProvider.ExtraParams["project"])
280+ require.Equal(t, "test-project", vertexProvider.ExtraParams["project"])
281− assert.Equal(t, "us-central1", vertexProvider.ExtraParams["location"])
281+ require.Equal(t, "us-central1", vertexProvider.ExtraParams["location"])
282}
282}
283
283
284func TestConfig_configureProvidersVertexAIWithoutCredentials(t *testing.T) {
284func TestConfig_configureProvidersVertexAIWithoutCredentials(t *testing.T) {
@@ -302,9 +302,9 @@ func TestConfig_configureProvidersVertexAIWithoutCredentials(t *testing.T) {
302 })
302 })
303 resolver := NewEnvironmentVariableResolver(env)
303 resolver := NewEnvironmentVariableResolver(env)
304 err := cfg.configureProviders(env, resolver, knownProviders)
304 err := cfg.configureProviders(env, resolver, knownProviders)
305− assert.NoError(t, err)
305+ require.NoError(t, err)
306 // Provider should not be configured without proper credentials
306 // Provider should not be configured without proper credentials
307− assert.Equal(t, cfg.Providers.Len(), 0)
307+ require.Equal(t, cfg.Providers.Len(), 0)
308}
308}
309
309
310func TestConfig_configureProvidersVertexAIMissingProject(t *testing.T) {
310func TestConfig_configureProvidersVertexAIMissingProject(t *testing.T) {
@@ -327,9 +327,9 @@ func TestConfig_configureProvidersVertexAIMissingProject(t *testing.T) {
327 })
327 })
328 resolver := NewEnvironmentVariableResolver(env)
328 resolver := NewEnvironmentVariableResolver(env)
329 err := cfg.configureProviders(env, resolver, knownProviders)
329 err := cfg.configureProviders(env, resolver, knownProviders)
330− assert.NoError(t, err)
330+ require.NoError(t, err)
331 // Provider should not be configured without project
331 // Provider should not be configured without project
332− assert.Equal(t, cfg.Providers.Len(), 0)
332+ require.Equal(t, cfg.Providers.Len(), 0)
333}
333}
334
334
335func TestConfig_configureProvidersSetProviderID(t *testing.T) {
335func TestConfig_configureProvidersSetProviderID(t *testing.T) {
@@ -351,12 +351,12 @@ func TestConfig_configureProvidersSetProviderID(t *testing.T) {
351 })
351 })
352 resolver := NewEnvironmentVariableResolver(env)
352 resolver := NewEnvironmentVariableResolver(env)
353 err := cfg.configureProviders(env, resolver, knownProviders)
353 err := cfg.configureProviders(env, resolver, knownProviders)
354− assert.NoError(t, err)
354+ require.NoError(t, err)
355− assert.Equal(t, cfg.Providers.Len(), 1)
355+ require.Equal(t, cfg.Providers.Len(), 1)
356
356
357 // Provider ID should be set
357 // Provider ID should be set
358 pc, _ := cfg.Providers.Get("openai")
358 pc, _ := cfg.Providers.Get("openai")
359− assert.Equal(t, "openai", pc.ID)
359+ require.Equal(t, "openai", pc.ID)
360}
360}
361
361
362func TestConfig_EnabledProviders(t *testing.T) {
362func TestConfig_EnabledProviders(t *testing.T) {
@@ -377,7 +377,7 @@ func TestConfig_EnabledProviders(t *testing.T) {
377 }
377 }
378
378
379 enabled := cfg.EnabledProviders()
379 enabled := cfg.EnabledProviders()
380− assert.Len(t, enabled, 2)
380+ require.Len(t, enabled, 2)
381 })
381 })
382
382
383 t.Run("some providers disabled", func(t *testing.T) {
383 t.Run("some providers disabled", func(t *testing.T) {
@@ -397,8 +397,8 @@ func TestConfig_EnabledProviders(t *testing.T) {
397 }
397 }
398
398
399 enabled := cfg.EnabledProviders()
399 enabled := cfg.EnabledProviders()
400− assert.Len(t, enabled, 1)
400+ require.Len(t, enabled, 1)
401− assert.Equal(t, "openai", enabled[0].ID)
401+ require.Equal(t, "openai", enabled[0].ID)
402 })
402 })
403
403
404 t.Run("empty providers map", func(t *testing.T) {
404 t.Run("empty providers map", func(t *testing.T) {
@@ -407,7 +407,7 @@ func TestConfig_EnabledProviders(t *testing.T) {
407 }
407 }
408
408
409 enabled := cfg.EnabledProviders()
409 enabled := cfg.EnabledProviders()
410− assert.Len(t, enabled, 0)
410+ require.Len(t, enabled, 0)
411 })
411 })
412}
412}
413
413
@@ -423,7 +423,7 @@ func TestConfig_IsConfigured(t *testing.T) {
423 }),
423 }),
424 }
424 }
425
425
426− assert.True(t, cfg.IsConfigured())
426+ require.True(t, cfg.IsConfigured())
427 })
427 })
428
428
429 t.Run("returns false when no providers are configured", func(t *testing.T) {
429 t.Run("returns false when no providers are configured", func(t *testing.T) {
@@ -431,7 +431,7 @@ func TestConfig_IsConfigured(t *testing.T) {
431 Providers: csync.NewMap[string, ProviderConfig](),
431 Providers: csync.NewMap[string, ProviderConfig](),
432 }
432 }
433
433
434− assert.False(t, cfg.IsConfigured())
434+ require.False(t, cfg.IsConfigured())
435 })
435 })
436
436
437 t.Run("returns false when all providers are disabled", func(t *testing.T) {
437 t.Run("returns false when all providers are disabled", func(t *testing.T) {
@@ -450,7 +450,7 @@ func TestConfig_IsConfigured(t *testing.T) {
450 }),
450 }),
451 }
451 }
452
452
453− assert.False(t, cfg.IsConfigured())
453+ require.False(t, cfg.IsConfigured())
454 })
454 })
455}
455}
456
456
@@ -480,12 +480,12 @@ func TestConfig_configureProvidersWithDisabledProvider(t *testing.T) {
480 })
480 })
481 resolver := NewEnvironmentVariableResolver(env)
481 resolver := NewEnvironmentVariableResolver(env)
482 err := cfg.configureProviders(env, resolver, knownProviders)
482 err := cfg.configureProviders(env, resolver, knownProviders)
483− assert.NoError(t, err)
483+ require.NoError(t, err)
484
484
485 // Provider should be removed from config when disabled
485 // Provider should be removed from config when disabled
486− assert.Equal(t, cfg.Providers.Len(), 0)
486+ require.Equal(t, cfg.Providers.Len(), 0)
487 _, exists := cfg.Providers.Get("openai")
487 _, exists := cfg.Providers.Get("openai")
488− assert.False(t, exists)
488+ require.False(t, exists)
489}
489}
490
490
491func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
491func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
@@ -508,11 +508,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
508 env := env.NewFromMap(map[string]string{})
508 env := env.NewFromMap(map[string]string{})
509 resolver := NewEnvironmentVariableResolver(env)
509 resolver := NewEnvironmentVariableResolver(env)
510 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
510 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
511− assert.NoError(t, err)
511+ require.NoError(t, err)
512
512
513− assert.Equal(t, cfg.Providers.Len(), 1)
513+ require.Equal(t, cfg.Providers.Len(), 1)
514 _, exists := cfg.Providers.Get("custom")
514 _, exists := cfg.Providers.Get("custom")
515− assert.True(t, exists)
515+ require.True(t, exists)
516 })
516 })
517
517
518 t.Run("custom provider with missing BaseURL is removed", func(t *testing.T) {
518 t.Run("custom provider with missing BaseURL is removed", func(t *testing.T) {
@@ -531,11 +531,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
531 env := env.NewFromMap(map[string]string{})
531 env := env.NewFromMap(map[string]string{})
532 resolver := NewEnvironmentVariableResolver(env)
532 resolver := NewEnvironmentVariableResolver(env)
533 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
533 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
534− assert.NoError(t, err)
534+ require.NoError(t, err)
535
535
536− assert.Equal(t, cfg.Providers.Len(), 0)
536+ require.Equal(t, cfg.Providers.Len(), 0)
537 _, exists := cfg.Providers.Get("custom")
537 _, exists := cfg.Providers.Get("custom")
538− assert.False(t, exists)
538+ require.False(t, exists)
539 })
539 })
540
540
541 t.Run("custom provider with no models is removed", func(t *testing.T) {
541 t.Run("custom provider with no models is removed", func(t *testing.T) {
@@ -553,11 +553,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
553 env := env.NewFromMap(map[string]string{})
553 env := env.NewFromMap(map[string]string{})
554 resolver := NewEnvironmentVariableResolver(env)
554 resolver := NewEnvironmentVariableResolver(env)
555 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
555 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
556− assert.NoError(t, err)
556+ require.NoError(t, err)
557
557
558− assert.Equal(t, cfg.Providers.Len(), 0)
558+ require.Equal(t, cfg.Providers.Len(), 0)
559 _, exists := cfg.Providers.Get("custom")
559 _, exists := cfg.Providers.Get("custom")
560− assert.False(t, exists)
560+ require.False(t, exists)
561 })
561 })
562
562
563 t.Run("custom provider with unsupported type is removed", func(t *testing.T) {
563 t.Run("custom provider with unsupported type is removed", func(t *testing.T) {
@@ -578,11 +578,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
578 env := env.NewFromMap(map[string]string{})
578 env := env.NewFromMap(map[string]string{})
579 resolver := NewEnvironmentVariableResolver(env)
579 resolver := NewEnvironmentVariableResolver(env)
580 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
580 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
581− assert.NoError(t, err)
581+ require.NoError(t, err)
582
582
583− assert.Equal(t, cfg.Providers.Len(), 0)
583+ require.Equal(t, cfg.Providers.Len(), 0)
584 _, exists := cfg.Providers.Get("custom")
584 _, exists := cfg.Providers.Get("custom")
585− assert.False(t, exists)
585+ require.False(t, exists)
586 })
586 })
587
587
588 t.Run("valid custom provider is kept and ID is set", func(t *testing.T) {
588 t.Run("valid custom provider is kept and ID is set", func(t *testing.T) {
@@ -603,14 +603,14 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
603 env := env.NewFromMap(map[string]string{})
603 env := env.NewFromMap(map[string]string{})
604 resolver := NewEnvironmentVariableResolver(env)
604 resolver := NewEnvironmentVariableResolver(env)
605 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
605 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
606− assert.NoError(t, err)
606+ require.NoError(t, err)
607
607
608− assert.Equal(t, cfg.Providers.Len(), 1)
608+ require.Equal(t, cfg.Providers.Len(), 1)
609 customProvider, exists := cfg.Providers.Get("custom")
609 customProvider, exists := cfg.Providers.Get("custom")
610− assert.True(t, exists)
610+ require.True(t, exists)
611− assert.Equal(t, "custom", customProvider.ID)
611+ require.Equal(t, "custom", customProvider.ID)
612− assert.Equal(t, "test-key", customProvider.APIKey)
612+ require.Equal(t, "test-key", customProvider.APIKey)
613− assert.Equal(t, "https://api.custom.com/v1", customProvider.BaseURL)
613+ require.Equal(t, "https://api.custom.com/v1", customProvider.BaseURL)
614 })
614 })
615
615
616 t.Run("custom anthropic provider is supported", func(t *testing.T) {
616 t.Run("custom anthropic provider is supported", func(t *testing.T) {
@@ -631,15 +631,15 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
631 env := env.NewFromMap(map[string]string{})
631 env := env.NewFromMap(map[string]string{})
632 resolver := NewEnvironmentVariableResolver(env)
632 resolver := NewEnvironmentVariableResolver(env)
633 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
633 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
634− assert.NoError(t, err)
634+ require.NoError(t, err)
635
635
636− assert.Equal(t, cfg.Providers.Len(), 1)
636+ require.Equal(t, cfg.Providers.Len(), 1)
637 customProvider, exists := cfg.Providers.Get("custom-anthropic")
637 customProvider, exists := cfg.Providers.Get("custom-anthropic")
638− assert.True(t, exists)
638+ require.True(t, exists)
639− assert.Equal(t, "custom-anthropic", customProvider.ID)
639+ require.Equal(t, "custom-anthropic", customProvider.ID)
640− assert.Equal(t, "test-key", customProvider.APIKey)
640+ require.Equal(t, "test-key", customProvider.APIKey)
641− assert.Equal(t, "https://api.anthropic.com/v1", customProvider.BaseURL)
641+ require.Equal(t, "https://api.anthropic.com/v1", customProvider.BaseURL)
642− assert.Equal(t, catwalk.TypeAnthropic, customProvider.Type)
642+ require.Equal(t, catwalk.TypeAnthropic, customProvider.Type)
643 })
643 })
644
644
645 t.Run("disabled custom provider is removed", func(t *testing.T) {
645 t.Run("disabled custom provider is removed", func(t *testing.T) {
@@ -661,11 +661,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
661 env := env.NewFromMap(map[string]string{})
661 env := env.NewFromMap(map[string]string{})
662 resolver := NewEnvironmentVariableResolver(env)
662 resolver := NewEnvironmentVariableResolver(env)
663 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
663 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
664− assert.NoError(t, err)
664+ require.NoError(t, err)
665
665
666− assert.Equal(t, cfg.Providers.Len(), 0)
666+ require.Equal(t, cfg.Providers.Len(), 0)
667 _, exists := cfg.Providers.Get("custom")
667 _, exists := cfg.Providers.Get("custom")
668− assert.False(t, exists)
668+ require.False(t, exists)
669 })
669 })
670}
670}
671
671
@@ -696,11 +696,11 @@ func TestConfig_configureProvidersEnhancedCredentialValidation(t *testing.T) {
696 })
696 })
697 resolver := NewEnvironmentVariableResolver(env)
697 resolver := NewEnvironmentVariableResolver(env)
698 err := cfg.configureProviders(env, resolver, knownProviders)
698 err := cfg.configureProviders(env, resolver, knownProviders)
699− assert.NoError(t, err)
699+ require.NoError(t, err)
700
700
701− assert.Equal(t, cfg.Providers.Len(), 0)
701+ require.Equal(t, cfg.Providers.Len(), 0)
702 _, exists := cfg.Providers.Get("vertexai")
702 _, exists := cfg.Providers.Get("vertexai")
703− assert.False(t, exists)
703+ require.False(t, exists)
704 })
704 })
705
705
706 t.Run("Bedrock provider removed when AWS credentials missing with existing config", func(t *testing.T) {
706 t.Run("Bedrock provider removed when AWS credentials missing with existing config", func(t *testing.T) {
@@ -727,11 +727,11 @@ func TestConfig_configureProvidersEnhancedCredentialValidation(t *testing.T) {
727 env := env.NewFromMap(map[string]string{})
727 env := env.NewFromMap(map[string]string{})
728 resolver := NewEnvironmentVariableResolver(env)
728 resolver := NewEnvironmentVariableResolver(env)
729 err := cfg.configureProviders(env, resolver, knownProviders)
729 err := cfg.configureProviders(env, resolver, knownProviders)
730− assert.NoError(t, err)
730+ require.NoError(t, err)
731
731
732− assert.Equal(t, cfg.Providers.Len(), 0)
732+ require.Equal(t, cfg.Providers.Len(), 0)
733 _, exists := cfg.Providers.Get("bedrock")
733 _, exists := cfg.Providers.Get("bedrock")
734− assert.False(t, exists)
734+ require.False(t, exists)
735 })
735 })
736
736
737 t.Run("provider removed when API key missing with existing config", func(t *testing.T) {
737 t.Run("provider removed when API key missing with existing config", func(t *testing.T) {
@@ -758,11 +758,11 @@ func TestConfig_configureProvidersEnhancedCredentialValidation(t *testing.T) {
758 env := env.NewFromMap(map[string]string{})
758 env := env.NewFromMap(map[string]string{})
759 resolver := NewEnvironmentVariableResolver(env)
759 resolver := NewEnvironmentVariableResolver(env)
760 err := cfg.configureProviders(env, resolver, knownProviders)
760 err := cfg.configureProviders(env, resolver, knownProviders)
761− assert.NoError(t, err)
761+ require.NoError(t, err)
762
762
763− assert.Equal(t, cfg.Providers.Len(), 0)
763+ require.Equal(t, cfg.Providers.Len(), 0)
764 _, exists := cfg.Providers.Get("openai")
764 _, exists := cfg.Providers.Get("openai")
765− assert.False(t, exists)
765+ require.False(t, exists)
766 })
766 })
767
767
768 t.Run("known provider should still be added if the endpoint is missing the client will use default endpoints", func(t *testing.T) {
768 t.Run("known provider should still be added if the endpoint is missing the client will use default endpoints", func(t *testing.T) {
@@ -791,11 +791,11 @@ func TestConfig_configureProvidersEnhancedCredentialValidation(t *testing.T) {
791 })
791 })
792 resolver := NewEnvironmentVariableResolver(env)
792 resolver := NewEnvironmentVariableResolver(env)
793 err := cfg.configureProviders(env, resolver, knownProviders)
793 err := cfg.configureProviders(env, resolver, knownProviders)
794− assert.NoError(t, err)
794+ require.NoError(t, err)
795
795
796− assert.Equal(t, cfg.Providers.Len(), 1)
796+ require.Equal(t, cfg.Providers.Len(), 1)
797 _, exists := cfg.Providers.Get("openai")
797 _, exists := cfg.Providers.Get("openai")
798− assert.True(t, exists)
798+ require.True(t, exists)
799 })
799 })
800}
800}
801
801
@@ -825,16 +825,16 @@ func TestConfig_defaultModelSelection(t *testing.T) {
825 env := env.NewFromMap(map[string]string{})
825 env := env.NewFromMap(map[string]string{})
826 resolver := NewEnvironmentVariableResolver(env)
826 resolver := NewEnvironmentVariableResolver(env)
827 err := cfg.configureProviders(env, resolver, knownProviders)
827 err := cfg.configureProviders(env, resolver, knownProviders)
828− assert.NoError(t, err)
828+ require.NoError(t, err)
829
829
830 large, small, err := cfg.defaultModelSelection(knownProviders)
830 large, small, err := cfg.defaultModelSelection(knownProviders)
831− assert.NoError(t, err)
831+ require.NoError(t, err)
832− assert.Equal(t, "large-model", large.Model)
832+ require.Equal(t, "large-model", large.Model)
833− assert.Equal(t, "openai", large.Provider)
833+ require.Equal(t, "openai", large.Provider)
834− assert.Equal(t, int64(1000), large.MaxTokens)
834+ require.Equal(t, int64(1000), large.MaxTokens)
835− assert.Equal(t, "small-model", small.Model)
835+ require.Equal(t, "small-model", small.Model)
836− assert.Equal(t, "openai", small.Provider)
836+ require.Equal(t, "openai", small.Provider)
837− assert.Equal(t, int64(500), small.MaxTokens)
837+ require.Equal(t, int64(500), small.MaxTokens)
838 })
838 })
839 t.Run("should error if no providers configured", func(t *testing.T) {
839 t.Run("should error if no providers configured", func(t *testing.T) {
840 knownProviders := []catwalk.Provider{
840 knownProviders := []catwalk.Provider{
@@ -861,10 +861,10 @@ func TestConfig_defaultModelSelection(t *testing.T) {
861 env := env.NewFromMap(map[string]string{})
861 env := env.NewFromMap(map[string]string{})
862 resolver := NewEnvironmentVariableResolver(env)
862 resolver := NewEnvironmentVariableResolver(env)
863 err := cfg.configureProviders(env, resolver, knownProviders)
863 err := cfg.configureProviders(env, resolver, knownProviders)
864− assert.NoError(t, err)
864+ require.NoError(t, err)
865
865
866 _, _, err = cfg.defaultModelSelection(knownProviders)
866 _, _, err = cfg.defaultModelSelection(knownProviders)
867− assert.Error(t, err)
867+ require.Error(t, err)
868 })
868 })
869 t.Run("should error if model is missing", func(t *testing.T) {
869 t.Run("should error if model is missing", func(t *testing.T) {
870 knownProviders := []catwalk.Provider{
870 knownProviders := []catwalk.Provider{
@@ -891,9 +891,9 @@ func TestConfig_defaultModelSelection(t *testing.T) {
891 env := env.NewFromMap(map[string]string{})
891 env := env.NewFromMap(map[string]string{})
892 resolver := NewEnvironmentVariableResolver(env)
892 resolver := NewEnvironmentVariableResolver(env)
893 err := cfg.configureProviders(env, resolver, knownProviders)
893 err := cfg.configureProviders(env, resolver, knownProviders)
894− assert.NoError(t, err)
894+ require.NoError(t, err)
895 _, _, err = cfg.defaultModelSelection(knownProviders)
895 _, _, err = cfg.defaultModelSelection(knownProviders)
896− assert.Error(t, err)
896+ require.Error(t, err)
897 })
897 })
898
898
899 t.Run("should configure the default models with a custom provider", func(t *testing.T) {
899 t.Run("should configure the default models with a custom provider", func(t *testing.T) {
@@ -934,15 +934,15 @@ func TestConfig_defaultModelSelection(t *testing.T) {
934 env := env.NewFromMap(map[string]string{})
934 env := env.NewFromMap(map[string]string{})
935 resolver := NewEnvironmentVariableResolver(env)
935 resolver := NewEnvironmentVariableResolver(env)
936 err := cfg.configureProviders(env, resolver, knownProviders)
936 err := cfg.configureProviders(env, resolver, knownProviders)
937− assert.NoError(t, err)
937+ require.NoError(t, err)
938 large, small, err := cfg.defaultModelSelection(knownProviders)
938 large, small, err := cfg.defaultModelSelection(knownProviders)
939− assert.NoError(t, err)
939+ require.NoError(t, err)
940− assert.Equal(t, "model", large.Model)
940+ require.Equal(t, "model", large.Model)
941− assert.Equal(t, "custom", large.Provider)
941+ require.Equal(t, "custom", large.Provider)
942− assert.Equal(t, int64(600), large.MaxTokens)
942+ require.Equal(t, int64(600), large.MaxTokens)
943− assert.Equal(t, "model", small.Model)
943+ require.Equal(t, "model", small.Model)
944− assert.Equal(t, "custom", small.Provider)
944+ require.Equal(t, "custom", small.Provider)
945− assert.Equal(t, int64(600), small.MaxTokens)
945+ require.Equal(t, int64(600), small.MaxTokens)
946 })
946 })
947
947
948 t.Run("should fail if no model configured", func(t *testing.T) {
948 t.Run("should fail if no model configured", func(t *testing.T) {
@@ -978,9 +978,9 @@ func TestConfig_defaultModelSelection(t *testing.T) {
978 env := env.NewFromMap(map[string]string{})
978 env := env.NewFromMap(map[string]string{})
979 resolver := NewEnvironmentVariableResolver(env)
979 resolver := NewEnvironmentVariableResolver(env)
980 err := cfg.configureProviders(env, resolver, knownProviders)
980 err := cfg.configureProviders(env, resolver, knownProviders)
981− assert.NoError(t, err)
981+ require.NoError(t, err)
982 _, _, err = cfg.defaultModelSelection(knownProviders)
982 _, _, err = cfg.defaultModelSelection(knownProviders)
983− assert.Error(t, err)
983+ require.Error(t, err)
984 })
984 })
985 t.Run("should use the default provider first", func(t *testing.T) {
985 t.Run("should use the default provider first", func(t *testing.T) {
986 knownProviders := []catwalk.Provider{
986 knownProviders := []catwalk.Provider{
@@ -1020,15 +1020,15 @@ func TestConfig_defaultModelSelection(t *testing.T) {
1020 env := env.NewFromMap(map[string]string{})
1020 env := env.NewFromMap(map[string]string{})
1021 resolver := NewEnvironmentVariableResolver(env)
1021 resolver := NewEnvironmentVariableResolver(env)
1022 err := cfg.configureProviders(env, resolver, knownProviders)
1022 err := cfg.configureProviders(env, resolver, knownProviders)
1023− assert.NoError(t, err)
1023+ require.NoError(t, err)
1024 large, small, err := cfg.defaultModelSelection(knownProviders)
1024 large, small, err := cfg.defaultModelSelection(knownProviders)
1025− assert.NoError(t, err)
1025+ require.NoError(t, err)
1026− assert.Equal(t, "large-model", large.Model)
1026+ require.Equal(t, "large-model", large.Model)
1027− assert.Equal(t, "openai", large.Provider)
1027+ require.Equal(t, "openai", large.Provider)
1028− assert.Equal(t, int64(1000), large.MaxTokens)
1028+ require.Equal(t, int64(1000), large.MaxTokens)
1029− assert.Equal(t, "small-model", small.Model)
1029+ require.Equal(t, "small-model", small.Model)
1030− assert.Equal(t, "openai", small.Provider)
1030+ require.Equal(t, "openai", small.Provider)
1031− assert.Equal(t, int64(500), small.MaxTokens)
1031+ require.Equal(t, int64(500), small.MaxTokens)
1032 })
1032 })
1033}
1033}
1034
1034
@@ -1068,18 +1068,18 @@ func TestConfig_configureSelectedModels(t *testing.T) {
1068 env := env.NewFromMap(map[string]string{})
1068 env := env.NewFromMap(map[string]string{})
1069 resolver := NewEnvironmentVariableResolver(env)
1069 resolver := NewEnvironmentVariableResolver(env)
1070 err := cfg.configureProviders(env, resolver, knownProviders)
1070 err := cfg.configureProviders(env, resolver, knownProviders)
1071− assert.NoError(t, err)
1071+ require.NoError(t, err)
1072
1072
1073 err = cfg.configureSelectedModels(knownProviders)
1073 err = cfg.configureSelectedModels(knownProviders)
1074− assert.NoError(t, err)
1074+ require.NoError(t, err)
1075 large := cfg.Models[SelectedModelTypeLarge]
1075 large := cfg.Models[SelectedModelTypeLarge]
1076 small := cfg.Models[SelectedModelTypeSmall]
1076 small := cfg.Models[SelectedModelTypeSmall]
1077− assert.Equal(t, "larger-model", large.Model)
1077+ require.Equal(t, "larger-model", large.Model)
1078− assert.Equal(t, "openai", large.Provider)
1078+ require.Equal(t, "openai", large.Provider)
1079− assert.Equal(t, int64(2000), large.MaxTokens)
1079+ require.Equal(t, int64(2000), large.MaxTokens)
1080− assert.Equal(t, "small-model", small.Model)
1080+ require.Equal(t, "small-model", small.Model)
1081− assert.Equal(t, "openai", small.Provider)
1081+ require.Equal(t, "openai", small.Provider)
1082− assert.Equal(t, int64(500), small.MaxTokens)
1082+ require.Equal(t, int64(500), small.MaxTokens)
1083 })
1083 })
1084 t.Run("should be possible to use multiple providers", func(t *testing.T) {
1084 t.Run("should be possible to use multiple providers", func(t *testing.T) {
1085 knownProviders := []catwalk.Provider{
1085 knownProviders := []catwalk.Provider{
@@ -1130,18 +1130,18 @@ func TestConfig_configureSelectedModels(t *testing.T) {
1130 env := env.NewFromMap(map[string]string{})
1130 env := env.NewFromMap(map[string]string{})
1131 resolver := NewEnvironmentVariableResolver(env)
1131 resolver := NewEnvironmentVariableResolver(env)
1132 err := cfg.configureProviders(env, resolver, knownProviders)
1132 err := cfg.configureProviders(env, resolver, knownProviders)
1133− assert.NoError(t, err)
1133+ require.NoError(t, err)
1134
1134
1135 err = cfg.configureSelectedModels(knownProviders)
1135 err = cfg.configureSelectedModels(knownProviders)
1136− assert.NoError(t, err)
1136+ require.NoError(t, err)
1137 large := cfg.Models[SelectedModelTypeLarge]
1137 large := cfg.Models[SelectedModelTypeLarge]
1138 small := cfg.Models[SelectedModelTypeSmall]
1138 small := cfg.Models[SelectedModelTypeSmall]
1139− assert.Equal(t, "large-model", large.Model)
1139+ require.Equal(t, "large-model", large.Model)
1140− assert.Equal(t, "openai", large.Provider)
1140+ require.Equal(t, "openai", large.Provider)
1141− assert.Equal(t, int64(1000), large.MaxTokens)
1141+ require.Equal(t, int64(1000), large.MaxTokens)
1142− assert.Equal(t, "a-small-model", small.Model)
1142+ require.Equal(t, "a-small-model", small.Model)
1143− assert.Equal(t, "anthropic", small.Provider)
1143+ require.Equal(t, "anthropic", small.Provider)
1144− assert.Equal(t, int64(300), small.MaxTokens)
1144+ require.Equal(t, int64(300), small.MaxTokens)
1145 })
1145 })
1146
1146
1147 t.Run("should override the max tokens only", func(t *testing.T) {
1147 t.Run("should override the max tokens only", func(t *testing.T) {
@@ -1175,13 +1175,13 @@ func TestConfig_configureSelectedModels(t *testing.T) {
1175 env := env.NewFromMap(map[string]string{})
1175 env := env.NewFromMap(map[string]string{})
1176 resolver := NewEnvironmentVariableResolver(env)
1176 resolver := NewEnvironmentVariableResolver(env)
1177 err := cfg.configureProviders(env, resolver, knownProviders)
1177 err := cfg.configureProviders(env, resolver, knownProviders)
1178− assert.NoError(t, err)
1178+ require.NoError(t, err)
1179
1179
1180 err = cfg.configureSelectedModels(knownProviders)
1180 err = cfg.configureSelectedModels(knownProviders)
1181− assert.NoError(t, err)
1181+ require.NoError(t, err)
1182 large := cfg.Models[SelectedModelTypeLarge]
1182 large := cfg.Models[SelectedModelTypeLarge]
1183− assert.Equal(t, "large-model", large.Model)
1183+ require.Equal(t, "large-model", large.Model)
1184− assert.Equal(t, "openai", large.Provider)
1184+ require.Equal(t, "openai", large.Provider)
1185− assert.Equal(t, int64(100), large.MaxTokens)
1185+ require.Equal(t, int64(100), large.MaxTokens)
1186 })
1186 })
1187}
1187}
internal/config/provider_test.go+12−12
@@ -7,7 +7,7 @@ import (
7 "testing"
7 "testing"
8
8
9 "github.com/charmbracelet/catwalk/pkg/catwalk"
9 "github.com/charmbracelet/catwalk/pkg/catwalk"
10− "github.com/stretchr/testify/assert"
10+ "github.com/stretchr/testify/require"
11)
11)
12
12
13type mockProviderClient struct {
13type mockProviderClient struct {
@@ -29,14 +29,14 @@ func TestProvider_loadProvidersNoIssues(t *testing.T) {
29 client := &mockProviderClient{shouldFail: false}
29 client := &mockProviderClient{shouldFail: false}
30 tmpPath := t.TempDir() + "/providers.json"
30 tmpPath := t.TempDir() + "/providers.json"
31 providers, err := loadProviders(client, tmpPath)
31 providers, err := loadProviders(client, tmpPath)
32− assert.NoError(t, err)
32+ require.NoError(t, err)
33− assert.NotNil(t, providers)
33+ require.NotNil(t, providers)
34− assert.Len(t, providers, 1)
34+ require.Len(t, providers, 1)
35
35
36 // check if file got saved
36 // check if file got saved
37 fileInfo, err := os.Stat(tmpPath)
37 fileInfo, err := os.Stat(tmpPath)
38− assert.NoError(t, err)
38+ require.NoError(t, err)
39− assert.False(t, fileInfo.IsDir(), "Expected a file, not a directory")
39+ require.False(t, fileInfo.IsDir(), "Expected a file, not a directory")
40}
40}
41
41
42func TestProvider_loadProvidersWithIssues(t *testing.T) {
42func TestProvider_loadProvidersWithIssues(t *testing.T) {
@@ -58,16 +58,16 @@ func TestProvider_loadProvidersWithIssues(t *testing.T) {
58 t.Fatalf("Failed to write old providers to file: %v", err)
58 t.Fatalf("Failed to write old providers to file: %v", err)
59 }
59 }
60 providers, err := loadProviders(client, tmpPath)
60 providers, err := loadProviders(client, tmpPath)
61− assert.NoError(t, err)
61+ require.NoError(t, err)
62− assert.NotNil(t, providers)
62+ require.NotNil(t, providers)
63− assert.Len(t, providers, 1)
63+ require.Len(t, providers, 1)
64− assert.Equal(t, "OldProvider", providers[0].Name, "Expected to keep old provider when loading fails")
64+ require.Equal(t, "OldProvider", providers[0].Name, "Expected to keep old provider when loading fails")
65}
65}
66
66
67func TestProvider_loadProvidersWithIssuesAndNoCache(t *testing.T) {
67func TestProvider_loadProvidersWithIssuesAndNoCache(t *testing.T) {
68 client := &mockProviderClient{shouldFail: true}
68 client := &mockProviderClient{shouldFail: true}
69 tmpPath := t.TempDir() + "/providers.json"
69 tmpPath := t.TempDir() + "/providers.json"
70 providers, err := loadProviders(client, tmpPath)
70 providers, err := loadProviders(client, tmpPath)
71− assert.Error(t, err)
71+ require.Error(t, err)
72− assert.Nil(t, providers, "Expected nil providers when loading fails and no cache exists")
72+ require.Nil(t, providers, "Expected nil providers when loading fails and no cache exists")
73}
73}
internal/config/resolve_test.go+14−14
@@ -6,7 +6,7 @@ import (
6 "testing"
6 "testing"
7
7
8 "github.com/charmbracelet/crush/internal/env"
8 "github.com/charmbracelet/crush/internal/env"
9− "github.com/stretchr/testify/assert"
9+ "github.com/stretchr/testify/require"
10)
10)
11
11
12// mockShell implements the Shell interface for testing
12// mockShell implements the Shell interface for testing
@@ -85,10 +85,10 @@ func TestShellVariableResolver_ResolveValue(t *testing.T) {
85 result, err := resolver.ResolveValue(tt.value)
85 result, err := resolver.ResolveValue(tt.value)
86
86
87 if tt.expectError {
87 if tt.expectError {
88− assert.Error(t, err)
88+ require.Error(t, err)
89 } else {
89 } else {
90− assert.NoError(t, err)
90+ require.NoError(t, err)
91− assert.Equal(t, tt.expected, result)
91+ require.Equal(t, tt.expected, result)
92 }
92 }
93 })
93 })
94 }
94 }
@@ -250,10 +250,10 @@ func TestShellVariableResolver_EnhancedResolveValue(t *testing.T) {
250 result, err := resolver.ResolveValue(tt.value)
250 result, err := resolver.ResolveValue(tt.value)
251
251
252 if tt.expectError {
252 if tt.expectError {
253− assert.Error(t, err)
253+ require.Error(t, err)
254 } else {
254 } else {
255− assert.NoError(t, err)
255+ require.NoError(t, err)
256− assert.Equal(t, tt.expected, result)
256+ require.Equal(t, tt.expected, result)
257 }
257 }
258 })
258 })
259 }
259 }
@@ -306,10 +306,10 @@ func TestEnvironmentVariableResolver_ResolveValue(t *testing.T) {
306 result, err := resolver.ResolveValue(tt.value)
306 result, err := resolver.ResolveValue(tt.value)
307
307
308 if tt.expectError {
308 if tt.expectError {
309− assert.Error(t, err)
309+ require.Error(t, err)
310 } else {
310 } else {
311− assert.NoError(t, err)
311+ require.NoError(t, err)
312− assert.Equal(t, tt.expected, result)
312+ require.Equal(t, tt.expected, result)
313 }
313 }
314 })
314 })
315 }
315 }
@@ -319,14 +319,14 @@ func TestNewShellVariableResolver(t *testing.T) {
319 testEnv := env.NewFromMap(map[string]string{"TEST": "value"})
319 testEnv := env.NewFromMap(map[string]string{"TEST": "value"})
320 resolver := NewShellVariableResolver(testEnv)
320 resolver := NewShellVariableResolver(testEnv)
321
321
322− assert.NotNil(t, resolver)
322+ require.NotNil(t, resolver)
323− assert.Implements(t, (*VariableResolver)(nil), resolver)
323+ require.Implements(t, (*VariableResolver)(nil), resolver)
324}
324}
325
325
326func TestNewEnvironmentVariableResolver(t *testing.T) {
326func TestNewEnvironmentVariableResolver(t *testing.T) {
327 testEnv := env.NewFromMap(map[string]string{"TEST": "value"})
327 testEnv := env.NewFromMap(map[string]string{"TEST": "value"})
328 resolver := NewEnvironmentVariableResolver(testEnv)
328 resolver := NewEnvironmentVariableResolver(testEnv)
329
329
330− assert.NotNil(t, resolver)
330+ require.NotNil(t, resolver)
331− assert.Implements(t, (*VariableResolver)(nil), resolver)
331+ require.Implements(t, (*VariableResolver)(nil), resolver)
332}
332}
internal/csync/maps_test.go+107−107
@@ -6,16 +6,16 @@ import (
6 "sync"
6 "sync"
7 "testing"
7 "testing"
8
8
9− "github.com/stretchr/testify/assert"
9+ "github.com/stretchr/testify/require"
10)
10)
11
11
12func TestNewMap(t *testing.T) {
12func TestNewMap(t *testing.T) {
13 t.Parallel()
13 t.Parallel()
14
14
15 m := NewMap[string, int]()
15 m := NewMap[string, int]()
16− assert.NotNil(t, m)
16+ require.NotNil(t, m)
17− assert.NotNil(t, m.inner)
17+ require.NotNil(t, m.inner)
18− assert.Equal(t, 0, m.Len())
18+ require.Equal(t, 0, m.Len())
19}
19}
20
20
21func TestNewMapFrom(t *testing.T) {
21func TestNewMapFrom(t *testing.T) {
@@ -27,13 +27,13 @@ func TestNewMapFrom(t *testing.T) {
27 }
27 }
28
28
29 m := NewMapFrom(original)
29 m := NewMapFrom(original)
30− assert.NotNil(t, m)
30+ require.NotNil(t, m)
31− assert.Equal(t, original, m.inner)
31+ require.Equal(t, original, m.inner)
32− assert.Equal(t, 2, m.Len())
32+ require.Equal(t, 2, m.Len())
33
33
34 value, ok := m.Get("key1")
34 value, ok := m.Get("key1")
35− assert.True(t, ok)
35+ require.True(t, ok)
36− assert.Equal(t, 1, value)
36+ require.Equal(t, 1, value)
37}
37}
38
38
39func TestMap_Set(t *testing.T) {
39func TestMap_Set(t *testing.T) {
@@ -43,15 +43,15 @@ func TestMap_Set(t *testing.T) {
43
43
44 m.Set("key1", 42)
44 m.Set("key1", 42)
45 value, ok := m.Get("key1")
45 value, ok := m.Get("key1")
46− assert.True(t, ok)
46+ require.True(t, ok)
47− assert.Equal(t, 42, value)
47+ require.Equal(t, 42, value)
48− assert.Equal(t, 1, m.Len())
48+ require.Equal(t, 1, m.Len())
49
49
50 m.Set("key1", 100)
50 m.Set("key1", 100)
51 value, ok = m.Get("key1")
51 value, ok = m.Get("key1")
52− assert.True(t, ok)
52+ require.True(t, ok)
53− assert.Equal(t, 100, value)
53+ require.Equal(t, 100, value)
54− assert.Equal(t, 1, m.Len())
54+ require.Equal(t, 1, m.Len())
55}
55}
56
56
57func TestMap_Get(t *testing.T) {
57func TestMap_Get(t *testing.T) {
@@ -60,13 +60,13 @@ func TestMap_Get(t *testing.T) {
60 m := NewMap[string, int]()
60 m := NewMap[string, int]()
61
61
62 value, ok := m.Get("nonexistent")
62 value, ok := m.Get("nonexistent")
63− assert.False(t, ok)
63+ require.False(t, ok)
64− assert.Equal(t, 0, value)
64+ require.Equal(t, 0, value)
65
65
66 m.Set("key1", 42)
66 m.Set("key1", 42)
67 value, ok = m.Get("key1")
67 value, ok = m.Get("key1")
68− assert.True(t, ok)
68+ require.True(t, ok)
69− assert.Equal(t, 42, value)
69+ require.Equal(t, 42, value)
70}
70}
71
71
72func TestMap_Del(t *testing.T) {
72func TestMap_Del(t *testing.T) {
@@ -76,38 +76,38 @@ func TestMap_Del(t *testing.T) {
76 m.Set("key1", 42)
76 m.Set("key1", 42)
77 m.Set("key2", 100)
77 m.Set("key2", 100)
78
78
79− assert.Equal(t, 2, m.Len())
79+ require.Equal(t, 2, m.Len())
80
80
81 m.Del("key1")
81 m.Del("key1")
82 _, ok := m.Get("key1")
82 _, ok := m.Get("key1")
83− assert.False(t, ok)
83+ require.False(t, ok)
84− assert.Equal(t, 1, m.Len())
84+ require.Equal(t, 1, m.Len())
85
85
86 value, ok := m.Get("key2")
86 value, ok := m.Get("key2")
87− assert.True(t, ok)
87+ require.True(t, ok)
88− assert.Equal(t, 100, value)
88+ require.Equal(t, 100, value)
89
89
90 m.Del("nonexistent")
90 m.Del("nonexistent")
91− assert.Equal(t, 1, m.Len())
91+ require.Equal(t, 1, m.Len())
92}
92}
93
93
94func TestMap_Len(t *testing.T) {
94func TestMap_Len(t *testing.T) {
95 t.Parallel()
95 t.Parallel()
96
96
97 m := NewMap[string, int]()
97 m := NewMap[string, int]()
98− assert.Equal(t, 0, m.Len())
98+ require.Equal(t, 0, m.Len())
99
99
100 m.Set("key1", 1)
100 m.Set("key1", 1)
101− assert.Equal(t, 1, m.Len())
101+ require.Equal(t, 1, m.Len())
102
102
103 m.Set("key2", 2)
103 m.Set("key2", 2)
104− assert.Equal(t, 2, m.Len())
104+ require.Equal(t, 2, m.Len())
105
105
106 m.Del("key1")
106 m.Del("key1")
107− assert.Equal(t, 1, m.Len())
107+ require.Equal(t, 1, m.Len())
108
108
109 m.Del("key2")
109 m.Del("key2")
110− assert.Equal(t, 0, m.Len())
110+ require.Equal(t, 0, m.Len())
111}
111}
112
112
113func TestMap_Take(t *testing.T) {
113func TestMap_Take(t *testing.T) {
@@ -117,19 +117,19 @@ func TestMap_Take(t *testing.T) {
117 m.Set("key1", 42)
117 m.Set("key1", 42)
118 m.Set("key2", 100)
118 m.Set("key2", 100)
119
119
120− assert.Equal(t, 2, m.Len())
120+ require.Equal(t, 2, m.Len())
121
121
122 value, ok := m.Take("key1")
122 value, ok := m.Take("key1")
123− assert.True(t, ok)
123+ require.True(t, ok)
124− assert.Equal(t, 42, value)
124+ require.Equal(t, 42, value)
125− assert.Equal(t, 1, m.Len())
125+ require.Equal(t, 1, m.Len())
126
126
127 _, exists := m.Get("key1")
127 _, exists := m.Get("key1")
128− assert.False(t, exists)
128+ require.False(t, exists)
129
129
130 value, ok = m.Get("key2")
130 value, ok = m.Get("key2")
131− assert.True(t, ok)
131+ require.True(t, ok)
132− assert.Equal(t, 100, value)
132+ require.Equal(t, 100, value)
133}
133}
134
134
135func TestMap_Take_NonexistentKey(t *testing.T) {
135func TestMap_Take_NonexistentKey(t *testing.T) {
@@ -139,13 +139,13 @@ func TestMap_Take_NonexistentKey(t *testing.T) {
139 m.Set("key1", 42)
139 m.Set("key1", 42)
140
140
141 value, ok := m.Take("nonexistent")
141 value, ok := m.Take("nonexistent")
142− assert.False(t, ok)
142+ require.False(t, ok)
143− assert.Equal(t, 0, value)
143+ require.Equal(t, 0, value)
144− assert.Equal(t, 1, m.Len())
144+ require.Equal(t, 1, m.Len())
145
145
146 value, ok = m.Get("key1")
146 value, ok = m.Get("key1")
147− assert.True(t, ok)
147+ require.True(t, ok)
148− assert.Equal(t, 42, value)
148+ require.Equal(t, 42, value)
149}
149}
150
150
151func TestMap_Take_EmptyMap(t *testing.T) {
151func TestMap_Take_EmptyMap(t *testing.T) {
@@ -154,9 +154,9 @@ func TestMap_Take_EmptyMap(t *testing.T) {
154 m := NewMap[string, int]()
154 m := NewMap[string, int]()
155
155
156 value, ok := m.Take("key1")
156 value, ok := m.Take("key1")
157− assert.False(t, ok)
157+ require.False(t, ok)
158− assert.Equal(t, 0, value)
158+ require.Equal(t, 0, value)
159− assert.Equal(t, 0, m.Len())
159+ require.Equal(t, 0, m.Len())
160}
160}
161
161
162func TestMap_Take_SameKeyTwice(t *testing.T) {
162func TestMap_Take_SameKeyTwice(t *testing.T) {
@@ -166,14 +166,14 @@ func TestMap_Take_SameKeyTwice(t *testing.T) {
166 m.Set("key1", 42)
166 m.Set("key1", 42)
167
167
168 value, ok := m.Take("key1")
168 value, ok := m.Take("key1")
169− assert.True(t, ok)
169+ require.True(t, ok)
170− assert.Equal(t, 42, value)
170+ require.Equal(t, 42, value)
171− assert.Equal(t, 0, m.Len())
171+ require.Equal(t, 0, m.Len())
172
172
173 value, ok = m.Take("key1")
173 value, ok = m.Take("key1")
174− assert.False(t, ok)
174+ require.False(t, ok)
175− assert.Equal(t, 0, value)
175+ require.Equal(t, 0, value)
176− assert.Equal(t, 0, m.Len())
176+ require.Equal(t, 0, m.Len())
177}
177}
178
178
179func TestMap_Seq2(t *testing.T) {
179func TestMap_Seq2(t *testing.T) {
@@ -186,10 +186,10 @@ func TestMap_Seq2(t *testing.T) {
186
186
187 collected := maps.Collect(m.Seq2())
187 collected := maps.Collect(m.Seq2())
188
188
189− assert.Equal(t, 3, len(collected))
189+ require.Equal(t, 3, len(collected))
190− assert.Equal(t, 1, collected["key1"])
190+ require.Equal(t, 1, collected["key1"])
191− assert.Equal(t, 2, collected["key2"])
191+ require.Equal(t, 2, collected["key2"])
192− assert.Equal(t, 3, collected["key3"])
192+ require.Equal(t, 3, collected["key3"])
193}
193}
194
194
195func TestMap_Seq2_EarlyReturn(t *testing.T) {
195func TestMap_Seq2_EarlyReturn(t *testing.T) {
@@ -208,7 +208,7 @@ func TestMap_Seq2_EarlyReturn(t *testing.T) {
208 }
208 }
209 }
209 }
210
210
211− assert.Equal(t, 2, count)
211+ require.Equal(t, 2, count)
212}
212}
213
213
214func TestMap_Seq2_EmptyMap(t *testing.T) {
214func TestMap_Seq2_EmptyMap(t *testing.T) {
@@ -221,7 +221,7 @@ func TestMap_Seq2_EmptyMap(t *testing.T) {
221 count++
221 count++
222 }
222 }
223
223
224− assert.Equal(t, 0, count)
224+ require.Equal(t, 0, count)
225}
225}
226
226
227func TestMap_Seq(t *testing.T) {
227func TestMap_Seq(t *testing.T) {
@@ -237,10 +237,10 @@ func TestMap_Seq(t *testing.T) {
237 collected = append(collected, v)
237 collected = append(collected, v)
238 }
238 }
239
239
240− assert.Equal(t, 3, len(collected))
240+ require.Equal(t, 3, len(collected))
241− assert.Contains(t, collected, 1)
241+ require.Contains(t, collected, 1)
242− assert.Contains(t, collected, 2)
242+ require.Contains(t, collected, 2)
243− assert.Contains(t, collected, 3)
243+ require.Contains(t, collected, 3)
244}
244}
245
245
246func TestMap_Seq_EarlyReturn(t *testing.T) {
246func TestMap_Seq_EarlyReturn(t *testing.T) {
@@ -259,7 +259,7 @@ func TestMap_Seq_EarlyReturn(t *testing.T) {
259 }
259 }
260 }
260 }
261
261
262− assert.Equal(t, 2, count)
262+ require.Equal(t, 2, count)
263}
263}
264
264
265func TestMap_Seq_EmptyMap(t *testing.T) {
265func TestMap_Seq_EmptyMap(t *testing.T) {
@@ -272,7 +272,7 @@ func TestMap_Seq_EmptyMap(t *testing.T) {
272 count++
272 count++
273 }
273 }
274
274
275− assert.Equal(t, 0, count)
275+ require.Equal(t, 0, count)
276}
276}
277
277
278func TestMap_MarshalJSON(t *testing.T) {
278func TestMap_MarshalJSON(t *testing.T) {
@@ -283,16 +283,16 @@ func TestMap_MarshalJSON(t *testing.T) {
283 m.Set("key2", 2)
283 m.Set("key2", 2)
284
284
285 data, err := json.Marshal(m)
285 data, err := json.Marshal(m)
286− assert.NoError(t, err)
286+ require.NoError(t, err)
287
287
288 result := &Map[string, int]{}
288 result := &Map[string, int]{}
289 err = json.Unmarshal(data, result)
289 err = json.Unmarshal(data, result)
290− assert.NoError(t, err)
290+ require.NoError(t, err)
291− assert.Equal(t, 2, result.Len())
291+ require.Equal(t, 2, result.Len())
292 v1, _ := result.Get("key1")
292 v1, _ := result.Get("key1")
293 v2, _ := result.Get("key2")
293 v2, _ := result.Get("key2")
294− assert.Equal(t, 1, v1)
294+ require.Equal(t, 1, v1)
295− assert.Equal(t, 2, v2)
295+ require.Equal(t, 2, v2)
296}
296}
297
297
298func TestMap_MarshalJSON_EmptyMap(t *testing.T) {
298func TestMap_MarshalJSON_EmptyMap(t *testing.T) {
@@ -301,8 +301,8 @@ func TestMap_MarshalJSON_EmptyMap(t *testing.T) {
301 m := NewMap[string, int]()
301 m := NewMap[string, int]()
302
302
303 data, err := json.Marshal(m)
303 data, err := json.Marshal(m)
304− assert.NoError(t, err)
304+ require.NoError(t, err)
305− assert.Equal(t, "{}", string(data))
305+ require.Equal(t, "{}", string(data))
306}
306}
307
307
308func TestMap_UnmarshalJSON(t *testing.T) {
308func TestMap_UnmarshalJSON(t *testing.T) {
@@ -312,16 +312,16 @@ func TestMap_UnmarshalJSON(t *testing.T) {
312
312
313 m := NewMap[string, int]()
313 m := NewMap[string, int]()
314 err := json.Unmarshal([]byte(jsonData), m)
314 err := json.Unmarshal([]byte(jsonData), m)
315− assert.NoError(t, err)
315+ require.NoError(t, err)
316
316
317− assert.Equal(t, 2, m.Len())
317+ require.Equal(t, 2, m.Len())
318 value, ok := m.Get("key1")
318 value, ok := m.Get("key1")
319− assert.True(t, ok)
319+ require.True(t, ok)
320− assert.Equal(t, 1, value)
320+ require.Equal(t, 1, value)
321
321
322 value, ok = m.Get("key2")
322 value, ok = m.Get("key2")
323− assert.True(t, ok)
323+ require.True(t, ok)
324− assert.Equal(t, 2, value)
324+ require.Equal(t, 2, value)
325}
325}
326
326
327func TestMap_UnmarshalJSON_EmptyJSON(t *testing.T) {
327func TestMap_UnmarshalJSON_EmptyJSON(t *testing.T) {
@@ -331,8 +331,8 @@ func TestMap_UnmarshalJSON_EmptyJSON(t *testing.T) {
331
331
332 m := NewMap[string, int]()
332 m := NewMap[string, int]()
333 err := json.Unmarshal([]byte(jsonData), m)
333 err := json.Unmarshal([]byte(jsonData), m)
334− assert.NoError(t, err)
334+ require.NoError(t, err)
335− assert.Equal(t, 0, m.Len())
335+ require.Equal(t, 0, m.Len())
336}
336}
337
337
338func TestMap_UnmarshalJSON_InvalidJSON(t *testing.T) {
338func TestMap_UnmarshalJSON_InvalidJSON(t *testing.T) {
@@ -342,7 +342,7 @@ func TestMap_UnmarshalJSON_InvalidJSON(t *testing.T) {
342
342
343 m := NewMap[string, int]()
343 m := NewMap[string, int]()
344 err := json.Unmarshal([]byte(jsonData), m)
344 err := json.Unmarshal([]byte(jsonData), m)
345− assert.Error(t, err)
345+ require.Error(t, err)
346}
346}
347
347
348func TestMap_UnmarshalJSON_OverwritesExistingData(t *testing.T) {
348func TestMap_UnmarshalJSON_OverwritesExistingData(t *testing.T) {
@@ -353,15 +353,15 @@ func TestMap_UnmarshalJSON_OverwritesExistingData(t *testing.T) {
353
353
354 jsonData := `{"key1": 1, "key2": 2}`
354 jsonData := `{"key1": 1, "key2": 2}`
355 err := json.Unmarshal([]byte(jsonData), m)
355 err := json.Unmarshal([]byte(jsonData), m)
356− assert.NoError(t, err)
356+ require.NoError(t, err)
357
357
358− assert.Equal(t, 2, m.Len())
358+ require.Equal(t, 2, m.Len())
359 _, ok := m.Get("existing")
359 _, ok := m.Get("existing")
360− assert.False(t, ok)
360+ require.False(t, ok)
361
361
362 value, ok := m.Get("key1")
362 value, ok := m.Get("key1")
363− assert.True(t, ok)
363+ require.True(t, ok)
364− assert.Equal(t, 1, value)
364+ require.Equal(t, 1, value)
365}
365}
366
366
367func TestMap_JSONRoundTrip(t *testing.T) {
367func TestMap_JSONRoundTrip(t *testing.T) {
@@ -373,18 +373,18 @@ func TestMap_JSONRoundTrip(t *testing.T) {
373 original.Set("key3", 3)
373 original.Set("key3", 3)
374
374
375 data, err := json.Marshal(original)
375 data, err := json.Marshal(original)
376− assert.NoError(t, err)
376+ require.NoError(t, err)
377
377
378 restored := NewMap[string, int]()
378 restored := NewMap[string, int]()
379 err = json.Unmarshal(data, restored)
379 err = json.Unmarshal(data, restored)
380− assert.NoError(t, err)
380+ require.NoError(t, err)
381
381
382− assert.Equal(t, original.Len(), restored.Len())
382+ require.Equal(t, original.Len(), restored.Len())
383
383
384 for k, v := range original.Seq2() {
384 for k, v := range original.Seq2() {
385 restoredValue, ok := restored.Get(k)
385 restoredValue, ok := restored.Get(k)
386− assert.True(t, ok)
386+ require.True(t, ok)
387− assert.Equal(t, v, restoredValue)
387+ require.Equal(t, v, restoredValue)
388 }
388 }
389}
389}
390
390
@@ -405,15 +405,15 @@ func TestMap_ConcurrentAccess(t *testing.T) {
405 key := id*numOperations + j
405 key := id*numOperations + j
406 m.Set(key, key*2)
406 m.Set(key, key*2)
407 value, ok := m.Get(key)
407 value, ok := m.Get(key)
408− assert.True(t, ok)
408+ require.True(t, ok)
409− assert.Equal(t, key*2, value)
409+ require.Equal(t, key*2, value)
410 }
410 }
411 }(i)
411 }(i)
412 }
412 }
413
413
414 wg.Wait()
414 wg.Wait()
415
415
416− assert.Equal(t, numGoroutines*numOperations, m.Len())
416+ require.Equal(t, numGoroutines*numOperations, m.Len())
417}
417}
418
418
419func TestMap_ConcurrentReadWrite(t *testing.T) {
419func TestMap_ConcurrentReadWrite(t *testing.T) {
@@ -438,7 +438,7 @@ func TestMap_ConcurrentReadWrite(t *testing.T) {
438 key := j % 1000
438 key := j % 1000
439 value, ok := m.Get(key)
439 value, ok := m.Get(key)
440 if ok {
440 if ok {
441− assert.Equal(t, key, value)
441+ require.Equal(t, key, value)
442 }
442 }
443 _ = m.Len()
443 _ = m.Len()
444 }
444 }
@@ -478,10 +478,10 @@ func TestMap_ConcurrentSeq2(t *testing.T) {
478 defer wg.Done()
478 defer wg.Done()
479 count := 0
479 count := 0
480 for k, v := range m.Seq2() {
480 for k, v := range m.Seq2() {
481− assert.Equal(t, k*2, v)
481+ require.Equal(t, k*2, v)
482 count++
482 count++
483 }
483 }
484− assert.Equal(t, 100, count)
484+ require.Equal(t, 100, count)
485 }()
485 }()
486 }
486 }
487
487
@@ -509,9 +509,9 @@ func TestMap_ConcurrentSeq(t *testing.T) {
509 values[v] = true
509 values[v] = true
510 count++
510 count++
511 }
511 }
512− assert.Equal(t, 100, count)
512+ require.Equal(t, 100, count)
513 for i := range 100 {
513 for i := range 100 {
514− assert.True(t, values[i*2])
514+ require.True(t, values[i*2])
515 }
515 }
516 }()
516 }()
517 }
517 }
@@ -548,19 +548,19 @@ func TestMap_ConcurrentTake(t *testing.T) {
548
548
549 wg.Wait()
549 wg.Wait()
550
550
551− assert.Equal(t, 0, m.Len())
551+ require.Equal(t, 0, m.Len())
552
552
553 allTaken := make(map[int]bool)
553 allTaken := make(map[int]bool)
554 for _, workerTaken := range taken {
554 for _, workerTaken := range taken {
555 for _, value := range workerTaken {
555 for _, value := range workerTaken {
556− assert.False(t, allTaken[value], "Value %d was taken multiple times", value)
556+ require.False(t, allTaken[value], "Value %d was taken multiple times", value)
557 allTaken[value] = true
557 allTaken[value] = true
558 }
558 }
559 }
559 }
560
560
561− assert.Equal(t, numItems, len(allTaken))
561+ require.Equal(t, numItems, len(allTaken))
562 for i := range numItems {
562 for i := range numItems {
563− assert.True(t, allTaken[i*2], "Expected value %d to be taken", i*2)
563+ require.True(t, allTaken[i*2], "Expected value %d to be taken", i*2)
564 }
564 }
565}
565}
566
566
@@ -570,20 +570,20 @@ func TestMap_TypeSafety(t *testing.T) {
570 stringIntMap := NewMap[string, int]()
570 stringIntMap := NewMap[string, int]()
571 stringIntMap.Set("key", 42)
571 stringIntMap.Set("key", 42)
572 value, ok := stringIntMap.Get("key")
572 value, ok := stringIntMap.Get("key")
573− assert.True(t, ok)
573+ require.True(t, ok)
574− assert.Equal(t, 42, value)
574+ require.Equal(t, 42, value)
575
575
576 intStringMap := NewMap[int, string]()
576 intStringMap := NewMap[int, string]()
577 intStringMap.Set(42, "value")
577 intStringMap.Set(42, "value")
578 strValue, ok := intStringMap.Get(42)
578 strValue, ok := intStringMap.Get(42)
579− assert.True(t, ok)
579+ require.True(t, ok)
580− assert.Equal(t, "value", strValue)
580+ require.Equal(t, "value", strValue)
581
581
582 structMap := NewMap[string, struct{ Name string }]()
582 structMap := NewMap[string, struct{ Name string }]()
583 structMap.Set("key", struct{ Name string }{Name: "test"})
583 structMap.Set("key", struct{ Name string }{Name: "test"})
584 structValue, ok := structMap.Get("key")
584 structValue, ok := structMap.Get("key")
585− assert.True(t, ok)
585+ require.True(t, ok)
586− assert.Equal(t, "test", structValue.Name)
586+ require.Equal(t, "test", structValue.Name)
587}
587}
588
588
589func TestMap_InterfaceCompliance(t *testing.T) {
589func TestMap_InterfaceCompliance(t *testing.T) {
internal/csync/slices_test.go+40−41
@@ -6,7 +6,6 @@ import (
6 "testing"
6 "testing"
7 "time"
7 "time"
8
8
9− "github.com/stretchr/testify/assert"
10 "github.com/stretchr/testify/require"
9 "github.com/stretchr/testify/require"
11)
10)
12
11
@@ -25,7 +24,7 @@ func TestLazySlice_Seq(t *testing.T) {
25 result = append(result, v)
24 result = append(result, v)
26 }
25 }
27
26
28− assert.Equal(t, data, result)
27+ require.Equal(t, data, result)
29}
28}
30
29
31func TestLazySlice_SeqWaitsForLoading(t *testing.T) {
30func TestLazySlice_SeqWaitsForLoading(t *testing.T) {
@@ -41,15 +40,15 @@ func TestLazySlice_SeqWaitsForLoading(t *testing.T) {
41 return data
40 return data
42 })
41 })
43
42
44− assert.False(t, loaded.Load(), "should not be loaded immediately")
43+ require.False(t, loaded.Load(), "should not be loaded immediately")
45
44
46 var result []string
45 var result []string
47 for v := range s.Seq() {
46 for v := range s.Seq() {
48 result = append(result, v)
47 result = append(result, v)
49 }
48 }
50
49
51− assert.True(t, loaded.Load(), "should be loaded after Seq")
50+ require.True(t, loaded.Load(), "should be loaded after Seq")
52− assert.Equal(t, data, result)
51+ require.Equal(t, data, result)
53}
52}
54
53
55func TestLazySlice_EmptySlice(t *testing.T) {
54func TestLazySlice_EmptySlice(t *testing.T) {
@@ -64,7 +63,7 @@ func TestLazySlice_EmptySlice(t *testing.T) {
64 result = append(result, v)
63 result = append(result, v)
65 }
64 }
66
65
67− assert.Empty(t, result)
66+ require.Empty(t, result)
68}
67}
69
68
70func TestLazySlice_EarlyBreak(t *testing.T) {
69func TestLazySlice_EarlyBreak(t *testing.T) {
@@ -85,25 +84,25 @@ func TestLazySlice_EarlyBreak(t *testing.T) {
85 }
84 }
86 }
85 }
87
86
88− assert.Equal(t, []string{"a", "b"}, result)
87+ require.Equal(t, []string{"a", "b"}, result)
89}
88}
90
89
91func TestSlice(t *testing.T) {
90func TestSlice(t *testing.T) {
92 t.Run("NewSlice", func(t *testing.T) {
91 t.Run("NewSlice", func(t *testing.T) {
93 s := NewSlice[int]()
92 s := NewSlice[int]()
94− assert.Equal(t, 0, s.Len())
93+ require.Equal(t, 0, s.Len())
95 })
94 })
96
95
97 t.Run("NewSliceFrom", func(t *testing.T) {
96 t.Run("NewSliceFrom", func(t *testing.T) {
98 original := []int{1, 2, 3}
97 original := []int{1, 2, 3}
99 s := NewSliceFrom(original)
98 s := NewSliceFrom(original)
100− assert.Equal(t, 3, s.Len())
99+ require.Equal(t, 3, s.Len())
101
100
102 // Verify it's a copy, not a reference
101 // Verify it's a copy, not a reference
103 original[0] = 999
102 original[0] = 999
104 val, ok := s.Get(0)
103 val, ok := s.Get(0)
105 require.True(t, ok)
104 require.True(t, ok)
106− assert.Equal(t, 1, val)
105+ require.Equal(t, 1, val)
107 })
106 })
108
107
109 t.Run("Append", func(t *testing.T) {
108 t.Run("Append", func(t *testing.T) {
@@ -111,14 +110,14 @@ func TestSlice(t *testing.T) {
111 s.Append("hello")
110 s.Append("hello")
112 s.Append("world")
111 s.Append("world")
113
112
114− assert.Equal(t, 2, s.Len())
113+ require.Equal(t, 2, s.Len())
115 val, ok := s.Get(0)
114 val, ok := s.Get(0)
116 require.True(t, ok)
115 require.True(t, ok)
117− assert.Equal(t, "hello", val)
116+ require.Equal(t, "hello", val)
118
117
119 val, ok = s.Get(1)
118 val, ok = s.Get(1)
120 require.True(t, ok)
119 require.True(t, ok)
121− assert.Equal(t, "world", val)
120+ require.Equal(t, "world", val)
122 })
121 })
123
122
124 t.Run("Prepend", func(t *testing.T) {
123 t.Run("Prepend", func(t *testing.T) {
@@ -126,14 +125,14 @@ func TestSlice(t *testing.T) {
126 s.Append("world")
125 s.Append("world")
127 s.Prepend("hello")
126 s.Prepend("hello")
128
127
129− assert.Equal(t, 2, s.Len())
128+ require.Equal(t, 2, s.Len())
130 val, ok := s.Get(0)
129 val, ok := s.Get(0)
131 require.True(t, ok)
130 require.True(t, ok)
132− assert.Equal(t, "hello", val)
131+ require.Equal(t, "hello", val)
133
132
134 val, ok = s.Get(1)
133 val, ok = s.Get(1)
135 require.True(t, ok)
134 require.True(t, ok)
136− assert.Equal(t, "world", val)
135+ require.Equal(t, "world", val)
137 })
136 })
138
137
139 t.Run("Delete", func(t *testing.T) {
138 t.Run("Delete", func(t *testing.T) {
@@ -141,22 +140,22 @@ func TestSlice(t *testing.T) {
141
140
142 // Delete middle element
141 // Delete middle element
143 ok := s.Delete(2)
142 ok := s.Delete(2)
144− assert.True(t, ok)
143+ require.True(t, ok)
145− assert.Equal(t, 4, s.Len())
144+ require.Equal(t, 4, s.Len())
146
145
147 expected := []int{1, 2, 4, 5}
146 expected := []int{1, 2, 4, 5}
148 actual := s.Slice()
147 actual := s.Slice()
149− assert.Equal(t, expected, actual)
148+ require.Equal(t, expected, actual)
150
149
151 // Delete out of bounds
150 // Delete out of bounds
152 ok = s.Delete(10)
151 ok = s.Delete(10)
153− assert.False(t, ok)
152+ require.False(t, ok)
154− assert.Equal(t, 4, s.Len())
153+ require.Equal(t, 4, s.Len())
155
154
156 // Delete negative index
155 // Delete negative index
157 ok = s.Delete(-1)
156 ok = s.Delete(-1)
158− assert.False(t, ok)
157+ require.False(t, ok)
159− assert.Equal(t, 4, s.Len())
158+ require.Equal(t, 4, s.Len())
160 })
159 })
161
160
162 t.Run("Get", func(t *testing.T) {
161 t.Run("Get", func(t *testing.T) {
@@ -164,34 +163,34 @@ func TestSlice(t *testing.T) {
164
163
165 val, ok := s.Get(1)
164 val, ok := s.Get(1)
166 require.True(t, ok)
165 require.True(t, ok)
167− assert.Equal(t, "b", val)
166+ require.Equal(t, "b", val)
168
167
169 // Out of bounds
168 // Out of bounds
170 _, ok = s.Get(10)
169 _, ok = s.Get(10)
171− assert.False(t, ok)
170+ require.False(t, ok)
172
171
173 // Negative index
172 // Negative index
174 _, ok = s.Get(-1)
173 _, ok = s.Get(-1)
175− assert.False(t, ok)
174+ require.False(t, ok)
176 })
175 })
177
176
178 t.Run("Set", func(t *testing.T) {
177 t.Run("Set", func(t *testing.T) {
179 s := NewSliceFrom([]string{"a", "b", "c"})
178 s := NewSliceFrom([]string{"a", "b", "c"})
180
179
181 ok := s.Set(1, "modified")
180 ok := s.Set(1, "modified")
182− assert.True(t, ok)
181+ require.True(t, ok)
183
182
184 val, ok := s.Get(1)
183 val, ok := s.Get(1)
185 require.True(t, ok)
184 require.True(t, ok)
186− assert.Equal(t, "modified", val)
185+ require.Equal(t, "modified", val)
187
186
188 // Out of bounds
187 // Out of bounds
189 ok = s.Set(10, "invalid")
188 ok = s.Set(10, "invalid")
190− assert.False(t, ok)
189+ require.False(t, ok)
191
190
192 // Negative index
191 // Negative index
193 ok = s.Set(-1, "invalid")
192 ok = s.Set(-1, "invalid")
194− assert.False(t, ok)
193+ require.False(t, ok)
195 })
194 })
196
195
197 t.Run("SetSlice", func(t *testing.T) {
196 t.Run("SetSlice", func(t *testing.T) {
@@ -202,22 +201,22 @@ func TestSlice(t *testing.T) {
202 newItems := []int{10, 20, 30}
201 newItems := []int{10, 20, 30}
203 s.SetSlice(newItems)
202 s.SetSlice(newItems)
204
203
205− assert.Equal(t, 3, s.Len())
204+ require.Equal(t, 3, s.Len())
206− assert.Equal(t, newItems, s.Slice())
205+ require.Equal(t, newItems, s.Slice())
207
206
208 // Verify it's a copy
207 // Verify it's a copy
209 newItems[0] = 999
208 newItems[0] = 999
210 val, ok := s.Get(0)
209 val, ok := s.Get(0)
211 require.True(t, ok)
210 require.True(t, ok)
212− assert.Equal(t, 10, val)
211+ require.Equal(t, 10, val)
213 })
212 })
214
213
215 t.Run("Clear", func(t *testing.T) {
214 t.Run("Clear", func(t *testing.T) {
216 s := NewSliceFrom([]int{1, 2, 3})
215 s := NewSliceFrom([]int{1, 2, 3})
217− assert.Equal(t, 3, s.Len())
216+ require.Equal(t, 3, s.Len())
218
217
219 s.Clear()
218 s.Clear()
220− assert.Equal(t, 0, s.Len())
219+ require.Equal(t, 0, s.Len())
221 })
220 })
222
221
223 t.Run("Slice", func(t *testing.T) {
222 t.Run("Slice", func(t *testing.T) {
@@ -225,13 +224,13 @@ func TestSlice(t *testing.T) {
225 s := NewSliceFrom(original)
224 s := NewSliceFrom(original)
226
225
227 copy := s.Slice()
226 copy := s.Slice()
228− assert.Equal(t, original, copy)
227+ require.Equal(t, original, copy)
229
228
230 // Verify it's a copy
229 // Verify it's a copy
231 copy[0] = 999
230 copy[0] = 999
232 val, ok := s.Get(0)
231 val, ok := s.Get(0)
233 require.True(t, ok)
232 require.True(t, ok)
234− assert.Equal(t, 1, val)
233+ require.Equal(t, 1, val)
235 })
234 })
236
235
237 t.Run("Seq", func(t *testing.T) {
236 t.Run("Seq", func(t *testing.T) {
@@ -242,7 +241,7 @@ func TestSlice(t *testing.T) {
242 result = append(result, v)
241 result = append(result, v)
243 }
242 }
244
243
245− assert.Equal(t, []int{1, 2, 3}, result)
244+ require.Equal(t, []int{1, 2, 3}, result)
246 })
245 })
247
246
248 t.Run("SeqWithIndex", func(t *testing.T) {
247 t.Run("SeqWithIndex", func(t *testing.T) {
@@ -255,8 +254,8 @@ func TestSlice(t *testing.T) {
255 values = append(values, v)
254 values = append(values, v)
256 }
255 }
257
256
258− assert.Equal(t, []int{0, 1, 2}, indices)
257+ require.Equal(t, []int{0, 1, 2}, indices)
259− assert.Equal(t, []string{"a", "b", "c"}, values)
258+ require.Equal(t, []string{"a", "b", "c"}, values)
260 })
259 })
261
260
262 t.Run("ConcurrentAccess", func(t *testing.T) {
261 t.Run("ConcurrentAccess", func(t *testing.T) {
@@ -291,6 +290,6 @@ func TestSlice(t *testing.T) {
291 wg.Wait()
290 wg.Wait()
292
291
293 // Should have all items
292 // Should have all items
294− assert.Equal(t, numGoroutines*itemsPerGoroutine, s.Len())
293+ require.Equal(t, numGoroutines*itemsPerGoroutine, s.Len())
295 })
294 })
296}
295}
internal/env/env_test.go+23−25
@@ -1,26 +1,24 @@
1package env
1package env
2
2
3import (
3import (
4− "os"
5 "strings"
4 "strings"
6 "testing"
5 "testing"
7
6
8− "github.com/stretchr/testify/assert"
7+ "github.com/stretchr/testify/require"
9)
8)
10
9
11func TestOsEnv_Get(t *testing.T) {
10func TestOsEnv_Get(t *testing.T) {
12 env := New()
11 env := New()
13
12
14 // Test getting an existing environment variable
13 // Test getting an existing environment variable
15− os.Setenv("TEST_VAR", "test_value")
14+ t.Setenv("TEST_VAR", "test_value")
16− defer os.Unsetenv("TEST_VAR")
17
15
18 value := env.Get("TEST_VAR")
16 value := env.Get("TEST_VAR")
19− assert.Equal(t, "test_value", value)
17+ require.Equal(t, "test_value", value)
20
18
21 // Test getting a non-existent environment variable
19 // Test getting a non-existent environment variable
22 value = env.Get("NON_EXISTENT_VAR")
20 value = env.Get("NON_EXISTENT_VAR")
23− assert.Equal(t, "", value)
21+ require.Equal(t, "", value)
24}
22}
25
23
26func TestOsEnv_Env(t *testing.T) {
24func TestOsEnv_Env(t *testing.T) {
@@ -29,12 +27,12 @@ func TestOsEnv_Env(t *testing.T) {
29 envVars := env.Env()
27 envVars := env.Env()
30
28
31 // Environment should not be empty in normal circumstances
29 // Environment should not be empty in normal circumstances
32− assert.NotNil(t, envVars)
30+ require.NotNil(t, envVars)
33− assert.Greater(t, len(envVars), 0)
31+ require.Greater(t, len(envVars), 0)
34
32
35 // Each environment variable should be in key=value format
33 // Each environment variable should be in key=value format
36 for _, envVar := range envVars {
34 for _, envVar := range envVars {
37− assert.Contains(t, envVar, "=")
35+ require.Contains(t, envVar, "=")
38 }
36 }
39}
37}
40
38
@@ -45,8 +43,8 @@ func TestNewFromMap(t *testing.T) {
45 }
43 }
46
44
47 env := NewFromMap(testMap)
45 env := NewFromMap(testMap)
48− assert.NotNil(t, env)
46+ require.NotNil(t, env)
49− assert.IsType(t, &mapEnv{}, env)
47+ require.IsType(t, &mapEnv{}, env)
50}
48}
51
49
52func TestMapEnv_Get(t *testing.T) {
50func TestMapEnv_Get(t *testing.T) {
@@ -58,11 +56,11 @@ func TestMapEnv_Get(t *testing.T) {
58 env := NewFromMap(testMap)
56 env := NewFromMap(testMap)
59
57
60 // Test getting existing keys
58 // Test getting existing keys
61− assert.Equal(t, "value1", env.Get("KEY1"))
59+ require.Equal(t, "value1", env.Get("KEY1"))
62− assert.Equal(t, "value2", env.Get("KEY2"))
60+ require.Equal(t, "value2", env.Get("KEY2"))
63
61
64 // Test getting non-existent key
62 // Test getting non-existent key
65− assert.Equal(t, "", env.Get("NON_EXISTENT"))
63+ require.Equal(t, "", env.Get("NON_EXISTENT"))
66}
64}
67
65
68func TestMapEnv_Env(t *testing.T) {
66func TestMapEnv_Env(t *testing.T) {
@@ -75,30 +73,30 @@ func TestMapEnv_Env(t *testing.T) {
75 env := NewFromMap(testMap)
73 env := NewFromMap(testMap)
76 envVars := env.Env()
74 envVars := env.Env()
77
75
78− assert.Len(t, envVars, 2)
76+ require.Len(t, envVars, 2)
79
77
80 // Convert to map for easier testing (order is not guaranteed)
78 // Convert to map for easier testing (order is not guaranteed)
81 envMap := make(map[string]string)
79 envMap := make(map[string]string)
82 for _, envVar := range envVars {
80 for _, envVar := range envVars {
83 parts := strings.SplitN(envVar, "=", 2)
81 parts := strings.SplitN(envVar, "=", 2)
84− assert.Len(t, parts, 2)
82+ require.Len(t, parts, 2)
85 envMap[parts[0]] = parts[1]
83 envMap[parts[0]] = parts[1]
86 }
84 }
87
85
88− assert.Equal(t, "value1", envMap["KEY1"])
86+ require.Equal(t, "value1", envMap["KEY1"])
89− assert.Equal(t, "value2", envMap["KEY2"])
87+ require.Equal(t, "value2", envMap["KEY2"])
90 })
88 })
91
89
92 t.Run("empty map", func(t *testing.T) {
90 t.Run("empty map", func(t *testing.T) {
93 env := NewFromMap(map[string]string{})
91 env := NewFromMap(map[string]string{})
94 envVars := env.Env()
92 envVars := env.Env()
95− assert.Nil(t, envVars)
93+ require.Nil(t, envVars)
96 })
94 })
97
95
98 t.Run("nil map", func(t *testing.T) {
96 t.Run("nil map", func(t *testing.T) {
99 env := NewFromMap(nil)
97 env := NewFromMap(nil)
100 envVars := env.Env()
98 envVars := env.Env()
101− assert.Nil(t, envVars)
99+ require.Nil(t, envVars)
102 })
100 })
103}
101}
104
102
@@ -111,8 +109,8 @@ func TestMapEnv_GetEmptyValue(t *testing.T) {
111 env := NewFromMap(testMap)
109 env := NewFromMap(testMap)
112
110
113 // Test that empty values are returned correctly
111 // Test that empty values are returned correctly
114− assert.Equal(t, "", env.Get("EMPTY_KEY"))
112+ require.Equal(t, "", env.Get("EMPTY_KEY"))
115− assert.Equal(t, "value", env.Get("NORMAL_KEY"))
113+ require.Equal(t, "value", env.Get("NORMAL_KEY"))
116}
114}
117
115
118func TestMapEnv_EnvFormat(t *testing.T) {
116func TestMapEnv_EnvFormat(t *testing.T) {
@@ -124,7 +122,7 @@ func TestMapEnv_EnvFormat(t *testing.T) {
124 env := NewFromMap(testMap)
122 env := NewFromMap(testMap)
125 envVars := env.Env()
123 envVars := env.Env()
126
124
127− assert.Len(t, envVars, 2)
125+ require.Len(t, envVars, 2)
128
126
129 // Check that the format is correct even with special characters
127 // Check that the format is correct even with special characters
130 found := make(map[string]bool)
128 found := make(map[string]bool)
@@ -137,6 +135,6 @@ func TestMapEnv_EnvFormat(t *testing.T) {
137 }
135 }
138 }
136 }
139
137
140− assert.True(t, found["equals"], "Should handle values with equals signs")
138+ require.True(t, found["equals"], "Should handle values with equals signs")
141− assert.True(t, found["spaces"], "Should handle values with spaces")
139+ require.True(t, found["spaces"], "Should handle values with spaces")
142}
140}
internal/llm/prompt/prompt_test.go+4−6
@@ -97,8 +97,7 @@ func TestProcessContextPaths(t *testing.T) {
97
97
98 // Test with tilde expansion (if we can create a file in home directory)
98 // Test with tilde expansion (if we can create a file in home directory)
99 tmpDir = t.TempDir()
99 tmpDir = t.TempDir()
100− rollback := setHomeEnv(tmpDir)
100+ setHomeEnv(t, tmpDir)
101− defer rollback()
102 homeTestFile := filepath.Join(tmpDir, "crush_test_file.txt")
101 homeTestFile := filepath.Join(tmpDir, "crush_test_file.txt")
103 err = os.WriteFile(homeTestFile, []byte(testContent), 0o644)
102 err = os.WriteFile(homeTestFile, []byte(testContent), 0o644)
104 if err == nil {
103 if err == nil {
@@ -114,12 +113,11 @@ func TestProcessContextPaths(t *testing.T) {
114 }
113 }
115}
114}
116
115
117−func setHomeEnv(path string) (rollback func()) {
116+func setHomeEnv(tb testing.TB, path string) {
117+ tb.Helper()
118 key := "HOME"
118 key := "HOME"
119 if runtime.GOOS == "windows" {
119 if runtime.GOOS == "windows" {
120 key = "USERPROFILE"
120 key = "USERPROFILE"
121 }
121 }
122− original := os.Getenv(key)
123− os.Setenv(key, path)
122+ tb.Setenv(key, path)
124− return func() { os.Setenv(key, original) }
125}
123}
internal/shell/comparison_test.go+3−4
@@ -4,7 +4,6 @@ import (
4 "testing"
4 "testing"
5 "time"
5 "time"
6
6
7− "github.com/stretchr/testify/assert"
8 "github.com/stretchr/testify/require"
7 "github.com/stretchr/testify/require"
9)
8)
10
9
@@ -18,9 +17,9 @@ func TestShellPerformanceComparison(t *testing.T) {
18 duration := time.Since(start)
17 duration := time.Since(start)
19
18
20 require.NoError(t, err)
19 require.NoError(t, err)
21− assert.Equal(t, 0, exitCode)
20+ require.Equal(t, 0, exitCode)
22− assert.Contains(t, stdout, "hello")
21+ require.Contains(t, stdout, "hello")
23− assert.Empty(t, stderr)
22+ require.Empty(t, stderr)
24
23
25 t.Logf("Quick command took: %v", duration)
24 t.Logf("Quick command took: %v", duration)
26}
25}