0506272 · crush · git.iko.soy

git.iko.soy/crush

test: improve tests (#315)

commit05062723328182f7f3a9f82d61bb4dcab2808db1 authorCarlos Alexandro Becker <caarlos0@users.noreply.github.com> dateMon 28 Jul 2025, 10:55 (1 year ago) parent60e7d04

9 files changed+360−365

compare with main

unifiedsplit

CRUSH.md+2−1 internal/config/load_test.go+155−155 internal/config/provider_test.go+12−12 internal/config/resolve_test.go+14−14 internal/csync/maps_test.go+107−107 internal/csync/slices_test.go+40−41 internal/env/env_test.go+23−25 internal/llm/prompt/prompt_test.go+4−6 internal/shell/comparison_test.go+3−4

CRUSH.md+2−1

@@ -19,7 +19,8 @@

1919- **Interfaces**: Define interfaces in consuming packages, keep them small and focused

2020- **Structs**: Use struct embedding for composition, group related fields

2121- **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.

2324- **JSON tags**: Use snake_case for JSON field names

2425- **File permissions**: Use octal notation (0o755, 0o644) for file permissions

2526- **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 (

1111 "github.com/charmbracelet/catwalk/pkg/catwalk"

1212 "github.com/charmbracelet/crush/internal/csync"

1313 "github.com/charmbracelet/crush/internal/env"

14− "github.com/stretchr/testify/assert"

14+ "github.com/stretchr/testify/require"

1515)

1616

1717func TestMain(m *testing.M) {

@@ -28,12 +28,12 @@ func TestConfig_LoadFromReaders(t *testing.T) {

2828

2929 loadedConfig, err := loadFromReaders([]io.Reader{data1, data2, data3})

3030

31− assert.NoError(t, err)

32− assert.NotNil(t, loadedConfig)

33− assert.Equal(t, 1, loadedConfig.Providers.Len())

31+ require.NoError(t, err)

32+ require.NotNil(t, loadedConfig)

33+ require.Equal(t, 1, loadedConfig.Providers.Len())

3434 pc, _ := loadedConfig.Providers.Get("openai")

35− assert.Equal(t, "key2", pc.APIKey)

36− assert.Equal(t, "https://api.openai.com/v2", pc.BaseURL)

35+ require.Equal(t, "key2", pc.APIKey)

36+ require.Equal(t, "https://api.openai.com/v2", pc.BaseURL)

3737}

3838

3939func TestConfig_setDefaults(t *testing.T) {

@@ -41,18 +41,18 @@ func TestConfig_setDefaults(t *testing.T) {

4141

4242 cfg.setDefaults("/tmp")

4343

44− assert.NotNil(t, cfg.Options)

45− assert.NotNil(t, cfg.Options.TUI)

46− assert.NotNil(t, cfg.Options.ContextPaths)

47− assert.NotNil(t, cfg.Providers)

48− assert.NotNil(t, cfg.Models)

49− assert.NotNil(t, cfg.LSP)

50− assert.NotNil(t, cfg.MCP)

51− assert.Equal(t, filepath.Join("/tmp", ".crush"), cfg.Options.DataDirectory)

44+ require.NotNil(t, cfg.Options)

45+ require.NotNil(t, cfg.Options.TUI)

46+ require.NotNil(t, cfg.Options.ContextPaths)

47+ require.NotNil(t, cfg.Providers)

48+ require.NotNil(t, cfg.Models)

49+ require.NotNil(t, cfg.LSP)

50+ require.NotNil(t, cfg.MCP)

51+ require.Equal(t, filepath.Join("/tmp", ".crush"), cfg.Options.DataDirectory)

5252 for _, path := range defaultContextPaths {

53− assert.Contains(t, cfg.Options.ContextPaths, path)

53+ require.Contains(t, cfg.Options.ContextPaths, path)

5454 }

55− assert.Equal(t, "/tmp", cfg.workingDir)

55+ require.Equal(t, "/tmp", cfg.workingDir)

5656}

5757

5858func TestConfig_configureProviders(t *testing.T) {

@@ -74,12 +74,12 @@ func TestConfig_configureProviders(t *testing.T) {

7474 })

7575 resolver := NewEnvironmentVariableResolver(env)

7676 err := cfg.configureProviders(env, resolver, knownProviders)

77− assert.NoError(t, err)

78− assert.Equal(t, 1, cfg.Providers.Len())

77+ require.NoError(t, err)

78+ require.Equal(t, 1, cfg.Providers.Len())

7979

8080 // We want to make sure that we keep the configured API key as a placeholder

8181 pc, _ := cfg.Providers.Get("openai")

82− assert.Equal(t, "$OPENAI_API_KEY", pc.APIKey)

82+ require.Equal(t, "$OPENAI_API_KEY", pc.APIKey)

8383}

8484

8585func TestConfig_configureProvidersWithOverride(t *testing.T) {

@@ -117,15 +117,15 @@ func TestConfig_configureProvidersWithOverride(t *testing.T) {

117117 })

118118 resolver := NewEnvironmentVariableResolver(env)

119119 err := cfg.configureProviders(env, resolver, knownProviders)

120− assert.NoError(t, err)

121− assert.Equal(t, 1, cfg.Providers.Len())

120+ require.NoError(t, err)

121+ require.Equal(t, 1, cfg.Providers.Len())

122122

123123 // We want to make sure that we keep the configured API key as a placeholder

124124 pc, _ := cfg.Providers.Get("openai")

125− assert.Equal(t, "xyz", pc.APIKey)

126− assert.Equal(t, "https://api.openai.com/v2", pc.BaseURL)

127− assert.Len(t, pc.Models, 2)

128− assert.Equal(t, "Updated", pc.Models[0].Name)

125+ require.Equal(t, "xyz", pc.APIKey)

126+ require.Equal(t, "https://api.openai.com/v2", pc.BaseURL)

127+ require.Len(t, pc.Models, 2)

128+ require.Equal(t, "Updated", pc.Models[0].Name)

129129}

130130

131131func TestConfig_configureProvidersWithNewProvider(t *testing.T) {

@@ -159,20 +159,20 @@ func TestConfig_configureProvidersWithNewProvider(t *testing.T) {

159159 })

160160 resolver := NewEnvironmentVariableResolver(env)

161161 err := cfg.configureProviders(env, resolver, knownProviders)

162− assert.NoError(t, err)

162+ require.NoError(t, err)

163163 // Should be to because of the env variable

164− assert.Equal(t, cfg.Providers.Len(), 2)

164+ require.Equal(t, cfg.Providers.Len(), 2)

165165

166166 // We want to make sure that we keep the configured API key as a placeholder

167167 pc, _ := cfg.Providers.Get("custom")

168− assert.Equal(t, "xyz", pc.APIKey)

168+ require.Equal(t, "xyz", pc.APIKey)

169169 // Make sure we set the ID correctly

170− assert.Equal(t, "custom", pc.ID)

171− assert.Equal(t, "https://api.someendpoint.com/v2", pc.BaseURL)

172− assert.Len(t, pc.Models, 1)

170+ require.Equal(t, "custom", pc.ID)

171+ require.Equal(t, "https://api.someendpoint.com/v2", pc.BaseURL)

172+ require.Len(t, pc.Models, 1)

173173

174174 _, 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")

176176}

177177

178178func TestConfig_configureProvidersBedrockWithCredentials(t *testing.T) {

@@ -195,13 +195,13 @@ func TestConfig_configureProvidersBedrockWithCredentials(t *testing.T) {

195195 })

196196 resolver := NewEnvironmentVariableResolver(env)

197197 err := cfg.configureProviders(env, resolver, knownProviders)

198− assert.NoError(t, err)

199− assert.Equal(t, cfg.Providers.Len(), 1)

198+ require.NoError(t, err)

199+ require.Equal(t, cfg.Providers.Len(), 1)

200200

201201 bedrockProvider, ok := cfg.Providers.Get("bedrock")

202− assert.True(t, ok, "Bedrock provider should be present")

203− assert.Len(t, bedrockProvider.Models, 1)

204− assert.Equal(t, "anthropic.claude-sonnet-4-20250514-v1:0", bedrockProvider.Models[0].ID)

202+ require.True(t, ok, "Bedrock provider should be present")

203+ require.Len(t, bedrockProvider.Models, 1)

204+ require.Equal(t, "anthropic.claude-sonnet-4-20250514-v1:0", bedrockProvider.Models[0].ID)

205205}

206206

207207func TestConfig_configureProvidersBedrockWithoutCredentials(t *testing.T) {

@@ -221,9 +221,9 @@ func TestConfig_configureProvidersBedrockWithoutCredentials(t *testing.T) {

221221 env := env.NewFromMap(map[string]string{})

222222 resolver := NewEnvironmentVariableResolver(env)

223223 err := cfg.configureProviders(env, resolver, knownProviders)

224− assert.NoError(t, err)

224+ require.NoError(t, err)

225225 // Provider should not be configured without credentials

226− assert.Equal(t, cfg.Providers.Len(), 0)

226+ require.Equal(t, cfg.Providers.Len(), 0)

227227}

228228

229229func TestConfig_configureProvidersBedrockWithoutUnsupportedModel(t *testing.T) {

@@ -246,7 +246,7 @@ func TestConfig_configureProvidersBedrockWithoutUnsupportedModel(t *testing.T) {

246246 })

247247 resolver := NewEnvironmentVariableResolver(env)

248248 err := cfg.configureProviders(env, resolver, knownProviders)

249− assert.Error(t, err)

249+ require.Error(t, err)

250250}

251251

252252func TestConfig_configureProvidersVertexAIWithCredentials(t *testing.T) {

@@ -270,15 +270,15 @@ func TestConfig_configureProvidersVertexAIWithCredentials(t *testing.T) {

270270 })

271271 resolver := NewEnvironmentVariableResolver(env)

272272 err := cfg.configureProviders(env, resolver, knownProviders)

273− assert.NoError(t, err)

274− assert.Equal(t, cfg.Providers.Len(), 1)

273+ require.NoError(t, err)

274+ require.Equal(t, cfg.Providers.Len(), 1)

275275

276276 vertexProvider, ok := cfg.Providers.Get("vertexai")

277− assert.True(t, ok, "VertexAI provider should be present")

278− assert.Len(t, vertexProvider.Models, 1)

279− assert.Equal(t, "gemini-pro", vertexProvider.Models[0].ID)

280− assert.Equal(t, "test-project", vertexProvider.ExtraParams["project"])

281− assert.Equal(t, "us-central1", vertexProvider.ExtraParams["location"])

277+ require.True(t, ok, "VertexAI provider should be present")

278+ require.Len(t, vertexProvider.Models, 1)

279+ require.Equal(t, "gemini-pro", vertexProvider.Models[0].ID)

280+ require.Equal(t, "test-project", vertexProvider.ExtraParams["project"])

281+ require.Equal(t, "us-central1", vertexProvider.ExtraParams["location"])

282282}

283283

284284func TestConfig_configureProvidersVertexAIWithoutCredentials(t *testing.T) {

@@ -302,9 +302,9 @@ func TestConfig_configureProvidersVertexAIWithoutCredentials(t *testing.T) {

302302 })

303303 resolver := NewEnvironmentVariableResolver(env)

304304 err := cfg.configureProviders(env, resolver, knownProviders)

305− assert.NoError(t, err)

305+ require.NoError(t, err)

306306 // Provider should not be configured without proper credentials

307− assert.Equal(t, cfg.Providers.Len(), 0)

307+ require.Equal(t, cfg.Providers.Len(), 0)

308308}

309309

310310func TestConfig_configureProvidersVertexAIMissingProject(t *testing.T) {

@@ -327,9 +327,9 @@ func TestConfig_configureProvidersVertexAIMissingProject(t *testing.T) {

327327 })

328328 resolver := NewEnvironmentVariableResolver(env)

329329 err := cfg.configureProviders(env, resolver, knownProviders)

330− assert.NoError(t, err)

330+ require.NoError(t, err)

331331 // Provider should not be configured without project

332− assert.Equal(t, cfg.Providers.Len(), 0)

332+ require.Equal(t, cfg.Providers.Len(), 0)

333333}

334334

335335func TestConfig_configureProvidersSetProviderID(t *testing.T) {

@@ -351,12 +351,12 @@ func TestConfig_configureProvidersSetProviderID(t *testing.T) {

351351 })

352352 resolver := NewEnvironmentVariableResolver(env)

353353 err := cfg.configureProviders(env, resolver, knownProviders)

354− assert.NoError(t, err)

355− assert.Equal(t, cfg.Providers.Len(), 1)

354+ require.NoError(t, err)

355+ require.Equal(t, cfg.Providers.Len(), 1)

356356

357357 // Provider ID should be set

358358 pc, _ := cfg.Providers.Get("openai")

359− assert.Equal(t, "openai", pc.ID)

359+ require.Equal(t, "openai", pc.ID)

360360}

361361

362362func TestConfig_EnabledProviders(t *testing.T) {

@@ -377,7 +377,7 @@ func TestConfig_EnabledProviders(t *testing.T) {

377377 }

378378

379379 enabled := cfg.EnabledProviders()

380− assert.Len(t, enabled, 2)

380+ require.Len(t, enabled, 2)

381381 })

382382

383383 t.Run("some providers disabled", func(t *testing.T) {

@@ -397,8 +397,8 @@ func TestConfig_EnabledProviders(t *testing.T) {

397397 }

398398

399399 enabled := cfg.EnabledProviders()

400− assert.Len(t, enabled, 1)

401− assert.Equal(t, "openai", enabled[0].ID)

400+ require.Len(t, enabled, 1)

401+ require.Equal(t, "openai", enabled[0].ID)

402402 })

403403

404404 t.Run("empty providers map", func(t *testing.T) {

@@ -407,7 +407,7 @@ func TestConfig_EnabledProviders(t *testing.T) {

407407 }

408408

409409 enabled := cfg.EnabledProviders()

410− assert.Len(t, enabled, 0)

410+ require.Len(t, enabled, 0)

411411 })

412412}

413413

@@ -423,7 +423,7 @@ func TestConfig_IsConfigured(t *testing.T) {

423423 }),

424424 }

425425

426− assert.True(t, cfg.IsConfigured())

426+ require.True(t, cfg.IsConfigured())

427427 })

428428

429429 t.Run("returns false when no providers are configured", func(t *testing.T) {

@@ -431,7 +431,7 @@ func TestConfig_IsConfigured(t *testing.T) {

431431 Providers: csync.NewMap[string, ProviderConfig](),

432432 }

433433

434− assert.False(t, cfg.IsConfigured())

434+ require.False(t, cfg.IsConfigured())

435435 })

436436

437437 t.Run("returns false when all providers are disabled", func(t *testing.T) {

@@ -450,7 +450,7 @@ func TestConfig_IsConfigured(t *testing.T) {

450450 }),

451451 }

452452

453− assert.False(t, cfg.IsConfigured())

453+ require.False(t, cfg.IsConfigured())

454454 })

455455}

456456

@@ -480,12 +480,12 @@ func TestConfig_configureProvidersWithDisabledProvider(t *testing.T) {

480480 })

481481 resolver := NewEnvironmentVariableResolver(env)

482482 err := cfg.configureProviders(env, resolver, knownProviders)

483− assert.NoError(t, err)

483+ require.NoError(t, err)

484484

485485 // Provider should be removed from config when disabled

486− assert.Equal(t, cfg.Providers.Len(), 0)

486+ require.Equal(t, cfg.Providers.Len(), 0)

487487 _, exists := cfg.Providers.Get("openai")

488− assert.False(t, exists)

488+ require.False(t, exists)

489489}

490490

491491func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {

@@ -508,11 +508,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {

508508 env := env.NewFromMap(map[string]string{})

509509 resolver := NewEnvironmentVariableResolver(env)

510510 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})

511− assert.NoError(t, err)

511+ require.NoError(t, err)

512512

513− assert.Equal(t, cfg.Providers.Len(), 1)

513+ require.Equal(t, cfg.Providers.Len(), 1)

514514 _, exists := cfg.Providers.Get("custom")

515− assert.True(t, exists)

515+ require.True(t, exists)

516516 })

517517

518518 t.Run("custom provider with missing BaseURL is removed", func(t *testing.T) {

@@ -531,11 +531,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {

531531 env := env.NewFromMap(map[string]string{})

532532 resolver := NewEnvironmentVariableResolver(env)

533533 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})

534− assert.NoError(t, err)

534+ require.NoError(t, err)

535535

536− assert.Equal(t, cfg.Providers.Len(), 0)

536+ require.Equal(t, cfg.Providers.Len(), 0)

537537 _, exists := cfg.Providers.Get("custom")

538− assert.False(t, exists)

538+ require.False(t, exists)

539539 })

540540

541541 t.Run("custom provider with no models is removed", func(t *testing.T) {

@@ -553,11 +553,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {

553553 env := env.NewFromMap(map[string]string{})

554554 resolver := NewEnvironmentVariableResolver(env)

555555 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})

556− assert.NoError(t, err)

556+ require.NoError(t, err)

557557

558− assert.Equal(t, cfg.Providers.Len(), 0)

558+ require.Equal(t, cfg.Providers.Len(), 0)

559559 _, exists := cfg.Providers.Get("custom")

560− assert.False(t, exists)

560+ require.False(t, exists)

561561 })

562562

563563 t.Run("custom provider with unsupported type is removed", func(t *testing.T) {

@@ -578,11 +578,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {

578578 env := env.NewFromMap(map[string]string{})

579579 resolver := NewEnvironmentVariableResolver(env)

580580 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})

581− assert.NoError(t, err)

581+ require.NoError(t, err)

582582

583− assert.Equal(t, cfg.Providers.Len(), 0)

583+ require.Equal(t, cfg.Providers.Len(), 0)

584584 _, exists := cfg.Providers.Get("custom")

585− assert.False(t, exists)

585+ require.False(t, exists)

586586 })

587587

588588 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) {

603603 env := env.NewFromMap(map[string]string{})

604604 resolver := NewEnvironmentVariableResolver(env)

605605 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})

606− assert.NoError(t, err)

606+ require.NoError(t, err)

607607

608− assert.Equal(t, cfg.Providers.Len(), 1)

608+ require.Equal(t, cfg.Providers.Len(), 1)

609609 customProvider, exists := cfg.Providers.Get("custom")

610− assert.True(t, exists)

611− assert.Equal(t, "custom", customProvider.ID)

612− assert.Equal(t, "test-key", customProvider.APIKey)

613− assert.Equal(t, "https://api.custom.com/v1", customProvider.BaseURL)

610+ require.True(t, exists)

611+ require.Equal(t, "custom", customProvider.ID)

612+ require.Equal(t, "test-key", customProvider.APIKey)

613+ require.Equal(t, "https://api.custom.com/v1", customProvider.BaseURL)

614614 })

615615

616616 t.Run("custom anthropic provider is supported", func(t *testing.T) {

@@ -631,15 +631,15 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {

631631 env := env.NewFromMap(map[string]string{})

632632 resolver := NewEnvironmentVariableResolver(env)

633633 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})

634− assert.NoError(t, err)

634+ require.NoError(t, err)

635635

636− assert.Equal(t, cfg.Providers.Len(), 1)

636+ require.Equal(t, cfg.Providers.Len(), 1)

637637 customProvider, exists := cfg.Providers.Get("custom-anthropic")

638− assert.True(t, exists)

639− assert.Equal(t, "custom-anthropic", customProvider.ID)

640− assert.Equal(t, "test-key", customProvider.APIKey)

641− assert.Equal(t, "https://api.anthropic.com/v1", customProvider.BaseURL)

642− assert.Equal(t, catwalk.TypeAnthropic, customProvider.Type)

638+ require.True(t, exists)

639+ require.Equal(t, "custom-anthropic", customProvider.ID)

640+ require.Equal(t, "test-key", customProvider.APIKey)

641+ require.Equal(t, "https://api.anthropic.com/v1", customProvider.BaseURL)

642+ require.Equal(t, catwalk.TypeAnthropic, customProvider.Type)

643643 })

644644

645645 t.Run("disabled custom provider is removed", func(t *testing.T) {

@@ -661,11 +661,11 @@ func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {

661661 env := env.NewFromMap(map[string]string{})

662662 resolver := NewEnvironmentVariableResolver(env)

663663 err := cfg.configureProviders(env, resolver, []catwalk.Provider{})

664− assert.NoError(t, err)

664+ require.NoError(t, err)

665665

666− assert.Equal(t, cfg.Providers.Len(), 0)

666+ require.Equal(t, cfg.Providers.Len(), 0)

667667 _, exists := cfg.Providers.Get("custom")

668− assert.False(t, exists)

668+ require.False(t, exists)

669669 })

670670}

671671

@@ -696,11 +696,11 @@ func TestConfig_configureProvidersEnhancedCredentialValidation(t *testing.T) {

696696 })

697697 resolver := NewEnvironmentVariableResolver(env)

698698 err := cfg.configureProviders(env, resolver, knownProviders)

699− assert.NoError(t, err)

699+ require.NoError(t, err)

700700

701− assert.Equal(t, cfg.Providers.Len(), 0)

701+ require.Equal(t, cfg.Providers.Len(), 0)

702702 _, exists := cfg.Providers.Get("vertexai")

703− assert.False(t, exists)

703+ require.False(t, exists)

704704 })

705705

706706 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) {

727727 env := env.NewFromMap(map[string]string{})

728728 resolver := NewEnvironmentVariableResolver(env)

729729 err := cfg.configureProviders(env, resolver, knownProviders)

730− assert.NoError(t, err)

730+ require.NoError(t, err)

731731

732− assert.Equal(t, cfg.Providers.Len(), 0)

732+ require.Equal(t, cfg.Providers.Len(), 0)

733733 _, exists := cfg.Providers.Get("bedrock")

734− assert.False(t, exists)

734+ require.False(t, exists)

735735 })

736736

737737 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) {

758758 env := env.NewFromMap(map[string]string{})

759759 resolver := NewEnvironmentVariableResolver(env)

760760 err := cfg.configureProviders(env, resolver, knownProviders)

761− assert.NoError(t, err)

761+ require.NoError(t, err)

762762

763− assert.Equal(t, cfg.Providers.Len(), 0)

763+ require.Equal(t, cfg.Providers.Len(), 0)

764764 _, exists := cfg.Providers.Get("openai")

765− assert.False(t, exists)

765+ require.False(t, exists)

766766 })

767767

768768 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) {

791791 })

792792 resolver := NewEnvironmentVariableResolver(env)

793793 err := cfg.configureProviders(env, resolver, knownProviders)

794− assert.NoError(t, err)

794+ require.NoError(t, err)

795795

796− assert.Equal(t, cfg.Providers.Len(), 1)

796+ require.Equal(t, cfg.Providers.Len(), 1)

797797 _, exists := cfg.Providers.Get("openai")

798− assert.True(t, exists)

798+ require.True(t, exists)

799799 })

800800}

801801

@@ -825,16 +825,16 @@ func TestConfig_defaultModelSelection(t *testing.T) {

825825 env := env.NewFromMap(map[string]string{})

826826 resolver := NewEnvironmentVariableResolver(env)

827827 err := cfg.configureProviders(env, resolver, knownProviders)

828− assert.NoError(t, err)

828+ require.NoError(t, err)

829829

830830 large, small, err := cfg.defaultModelSelection(knownProviders)

831− assert.NoError(t, err)

832− assert.Equal(t, "large-model", large.Model)

833− assert.Equal(t, "openai", large.Provider)

834− assert.Equal(t, int64(1000), large.MaxTokens)

835− assert.Equal(t, "small-model", small.Model)

836− assert.Equal(t, "openai", small.Provider)

837− assert.Equal(t, int64(500), small.MaxTokens)

831+ require.NoError(t, err)

832+ require.Equal(t, "large-model", large.Model)

833+ require.Equal(t, "openai", large.Provider)

834+ require.Equal(t, int64(1000), large.MaxTokens)

835+ require.Equal(t, "small-model", small.Model)

836+ require.Equal(t, "openai", small.Provider)

837+ require.Equal(t, int64(500), small.MaxTokens)

838838 })

839839 t.Run("should error if no providers configured", func(t *testing.T) {

840840 knownProviders := []catwalk.Provider{

@@ -861,10 +861,10 @@ func TestConfig_defaultModelSelection(t *testing.T) {

861861 env := env.NewFromMap(map[string]string{})

862862 resolver := NewEnvironmentVariableResolver(env)

863863 err := cfg.configureProviders(env, resolver, knownProviders)

864− assert.NoError(t, err)

864+ require.NoError(t, err)

865865

866866 _, _, err = cfg.defaultModelSelection(knownProviders)

867− assert.Error(t, err)

867+ require.Error(t, err)

868868 })

869869 t.Run("should error if model is missing", func(t *testing.T) {

870870 knownProviders := []catwalk.Provider{

@@ -891,9 +891,9 @@ func TestConfig_defaultModelSelection(t *testing.T) {

891891 env := env.NewFromMap(map[string]string{})

892892 resolver := NewEnvironmentVariableResolver(env)

893893 err := cfg.configureProviders(env, resolver, knownProviders)

894− assert.NoError(t, err)

894+ require.NoError(t, err)

895895 _, _, err = cfg.defaultModelSelection(knownProviders)

896− assert.Error(t, err)

896+ require.Error(t, err)

897897 })

898898

899899 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) {

934934 env := env.NewFromMap(map[string]string{})

935935 resolver := NewEnvironmentVariableResolver(env)

936936 err := cfg.configureProviders(env, resolver, knownProviders)

937− assert.NoError(t, err)

937+ require.NoError(t, err)

938938 large, small, err := cfg.defaultModelSelection(knownProviders)

939− assert.NoError(t, err)

940− assert.Equal(t, "model", large.Model)

941− assert.Equal(t, "custom", large.Provider)

942− assert.Equal(t, int64(600), large.MaxTokens)

943− assert.Equal(t, "model", small.Model)

944− assert.Equal(t, "custom", small.Provider)

945− assert.Equal(t, int64(600), small.MaxTokens)

939+ require.NoError(t, err)

940+ require.Equal(t, "model", large.Model)

941+ require.Equal(t, "custom", large.Provider)

942+ require.Equal(t, int64(600), large.MaxTokens)

943+ require.Equal(t, "model", small.Model)

944+ require.Equal(t, "custom", small.Provider)

945+ require.Equal(t, int64(600), small.MaxTokens)

946946 })

947947

948948 t.Run("should fail if no model configured", func(t *testing.T) {

@@ -978,9 +978,9 @@ func TestConfig_defaultModelSelection(t *testing.T) {

978978 env := env.NewFromMap(map[string]string{})

979979 resolver := NewEnvironmentVariableResolver(env)

980980 err := cfg.configureProviders(env, resolver, knownProviders)

981− assert.NoError(t, err)

981+ require.NoError(t, err)

982982 _, _, err = cfg.defaultModelSelection(knownProviders)

983− assert.Error(t, err)

983+ require.Error(t, err)

984984 })

985985 t.Run("should use the default provider first", func(t *testing.T) {

986986 knownProviders := []catwalk.Provider{

@@ -1020,15 +1020,15 @@ func TestConfig_defaultModelSelection(t *testing.T) {

10201020 env := env.NewFromMap(map[string]string{})

10211021 resolver := NewEnvironmentVariableResolver(env)

10221022 err := cfg.configureProviders(env, resolver, knownProviders)

1023− assert.NoError(t, err)

1023+ require.NoError(t, err)

10241024 large, small, err := cfg.defaultModelSelection(knownProviders)

1025− assert.NoError(t, err)

1026− assert.Equal(t, "large-model", large.Model)

1027− assert.Equal(t, "openai", large.Provider)

1028− assert.Equal(t, int64(1000), large.MaxTokens)

1029− assert.Equal(t, "small-model", small.Model)

1030− assert.Equal(t, "openai", small.Provider)

1031− assert.Equal(t, int64(500), small.MaxTokens)

1025+ require.NoError(t, err)

1026+ require.Equal(t, "large-model", large.Model)

1027+ require.Equal(t, "openai", large.Provider)

1028+ require.Equal(t, int64(1000), large.MaxTokens)

1029+ require.Equal(t, "small-model", small.Model)

1030+ require.Equal(t, "openai", small.Provider)

1031+ require.Equal(t, int64(500), small.MaxTokens)

10321032 })

10331033}

10341034

@@ -1068,18 +1068,18 @@ func TestConfig_configureSelectedModels(t *testing.T) {

10681068 env := env.NewFromMap(map[string]string{})

10691069 resolver := NewEnvironmentVariableResolver(env)

10701070 err := cfg.configureProviders(env, resolver, knownProviders)

1071− assert.NoError(t, err)

1071+ require.NoError(t, err)

10721072

10731073 err = cfg.configureSelectedModels(knownProviders)

1074− assert.NoError(t, err)

1074+ require.NoError(t, err)

10751075 large := cfg.Models[SelectedModelTypeLarge]

10761076 small := cfg.Models[SelectedModelTypeSmall]

1077− assert.Equal(t, "larger-model", large.Model)

1078− assert.Equal(t, "openai", large.Provider)

1079− assert.Equal(t, int64(2000), large.MaxTokens)

1080− assert.Equal(t, "small-model", small.Model)

1081− assert.Equal(t, "openai", small.Provider)

1082− assert.Equal(t, int64(500), small.MaxTokens)

1077+ require.Equal(t, "larger-model", large.Model)

1078+ require.Equal(t, "openai", large.Provider)

1079+ require.Equal(t, int64(2000), large.MaxTokens)

1080+ require.Equal(t, "small-model", small.Model)

1081+ require.Equal(t, "openai", small.Provider)

1082+ require.Equal(t, int64(500), small.MaxTokens)

10831083 })

10841084 t.Run("should be possible to use multiple providers", func(t *testing.T) {

10851085 knownProviders := []catwalk.Provider{

@@ -1130,18 +1130,18 @@ func TestConfig_configureSelectedModels(t *testing.T) {

11301130 env := env.NewFromMap(map[string]string{})

11311131 resolver := NewEnvironmentVariableResolver(env)

11321132 err := cfg.configureProviders(env, resolver, knownProviders)

1133− assert.NoError(t, err)

1133+ require.NoError(t, err)

11341134

11351135 err = cfg.configureSelectedModels(knownProviders)

1136− assert.NoError(t, err)

1136+ require.NoError(t, err)

11371137 large := cfg.Models[SelectedModelTypeLarge]

11381138 small := cfg.Models[SelectedModelTypeSmall]

1139− assert.Equal(t, "large-model", large.Model)

1140− assert.Equal(t, "openai", large.Provider)

1141− assert.Equal(t, int64(1000), large.MaxTokens)

1142− assert.Equal(t, "a-small-model", small.Model)

1143− assert.Equal(t, "anthropic", small.Provider)

1144− assert.Equal(t, int64(300), small.MaxTokens)

1139+ require.Equal(t, "large-model", large.Model)

1140+ require.Equal(t, "openai", large.Provider)

1141+ require.Equal(t, int64(1000), large.MaxTokens)

1142+ require.Equal(t, "a-small-model", small.Model)

1143+ require.Equal(t, "anthropic", small.Provider)

1144+ require.Equal(t, int64(300), small.MaxTokens)

11451145 })

11461146

11471147 t.Run("should override the max tokens only", func(t *testing.T) {

@@ -1175,13 +1175,13 @@ func TestConfig_configureSelectedModels(t *testing.T) {

11751175 env := env.NewFromMap(map[string]string{})

11761176 resolver := NewEnvironmentVariableResolver(env)

11771177 err := cfg.configureProviders(env, resolver, knownProviders)

1178− assert.NoError(t, err)

1178+ require.NoError(t, err)

11791179

11801180 err = cfg.configureSelectedModels(knownProviders)

1181− assert.NoError(t, err)

1181+ require.NoError(t, err)

11821182 large := cfg.Models[SelectedModelTypeLarge]

1183− assert.Equal(t, "large-model", large.Model)

1184− assert.Equal(t, "openai", large.Provider)

1185− assert.Equal(t, int64(100), large.MaxTokens)

1183+ require.Equal(t, "large-model", large.Model)

1184+ require.Equal(t, "openai", large.Provider)

1185+ require.Equal(t, int64(100), large.MaxTokens)

11861186 })

11871187}

internal/config/provider_test.go+12−12

@@ -7,7 +7,7 @@ import (

77 "testing"

99 "github.com/charmbracelet/catwalk/pkg/catwalk"

10− "github.com/stretchr/testify/assert"

10+ "github.com/stretchr/testify/require"

1111)

1212

1313type mockProviderClient struct {

@@ -29,14 +29,14 @@ func TestProvider_loadProvidersNoIssues(t *testing.T) {

2929 client := &mockProviderClient{shouldFail: false}

3030 tmpPath := t.TempDir() + "/providers.json"

3131 providers, err := loadProviders(client, tmpPath)

32− assert.NoError(t, err)

33− assert.NotNil(t, providers)

34− assert.Len(t, providers, 1)

32+ require.NoError(t, err)

33+ require.NotNil(t, providers)

34+ require.Len(t, providers, 1)

3535

3636 // check if file got saved

3737 fileInfo, err := os.Stat(tmpPath)

38− assert.NoError(t, err)

39− assert.False(t, fileInfo.IsDir(), "Expected a file, not a directory")

38+ require.NoError(t, err)

39+ require.False(t, fileInfo.IsDir(), "Expected a file, not a directory")

4040}

4141

4242func TestProvider_loadProvidersWithIssues(t *testing.T) {

@@ -58,16 +58,16 @@ func TestProvider_loadProvidersWithIssues(t *testing.T) {

5858 t.Fatalf("Failed to write old providers to file: %v", err)

5959 }

6060 providers, err := loadProviders(client, tmpPath)

61− assert.NoError(t, err)

62− assert.NotNil(t, providers)

63− assert.Len(t, providers, 1)

64− assert.Equal(t, "OldProvider", providers[0].Name, "Expected to keep old provider when loading fails")

61+ require.NoError(t, err)

62+ require.NotNil(t, providers)

63+ require.Len(t, providers, 1)

64+ require.Equal(t, "OldProvider", providers[0].Name, "Expected to keep old provider when loading fails")

6565}

6666

6767func TestProvider_loadProvidersWithIssuesAndNoCache(t *testing.T) {

6868 client := &mockProviderClient{shouldFail: true}

6969 tmpPath := t.TempDir() + "/providers.json"

7070 providers, err := loadProviders(client, tmpPath)

71− assert.Error(t, err)

72− assert.Nil(t, providers, "Expected nil providers when loading fails and no cache exists")

71+ require.Error(t, err)

72+ require.Nil(t, providers, "Expected nil providers when loading fails and no cache exists")

7373}

internal/config/resolve_test.go+14−14

@@ -6,7 +6,7 @@ import (

66 "testing"

88 "github.com/charmbracelet/crush/internal/env"

9− "github.com/stretchr/testify/assert"

9+ "github.com/stretchr/testify/require"

1010)

1111

1212// mockShell implements the Shell interface for testing

@@ -85,10 +85,10 @@ func TestShellVariableResolver_ResolveValue(t *testing.T) {

8585 result, err := resolver.ResolveValue(tt.value)

8686

8787 if tt.expectError {

88− assert.Error(t, err)

88+ require.Error(t, err)

8989 } else {

90− assert.NoError(t, err)

91− assert.Equal(t, tt.expected, result)

90+ require.NoError(t, err)

91+ require.Equal(t, tt.expected, result)

9292 }

9393 })

9494 }

@@ -250,10 +250,10 @@ func TestShellVariableResolver_EnhancedResolveValue(t *testing.T) {

250250 result, err := resolver.ResolveValue(tt.value)

251251

252252 if tt.expectError {

253− assert.Error(t, err)

253+ require.Error(t, err)

254254 } else {

255− assert.NoError(t, err)

256− assert.Equal(t, tt.expected, result)

255+ require.NoError(t, err)

256+ require.Equal(t, tt.expected, result)

257257 }

258258 })

259259 }

@@ -306,10 +306,10 @@ func TestEnvironmentVariableResolver_ResolveValue(t *testing.T) {

306306 result, err := resolver.ResolveValue(tt.value)

307307

308308 if tt.expectError {

309− assert.Error(t, err)

309+ require.Error(t, err)

310310 } else {

311− assert.NoError(t, err)

312− assert.Equal(t, tt.expected, result)

311+ require.NoError(t, err)

312+ require.Equal(t, tt.expected, result)

313313 }

314314 })

315315 }

@@ -319,14 +319,14 @@ func TestNewShellVariableResolver(t *testing.T) {

319319 testEnv := env.NewFromMap(map[string]string{"TEST": "value"})

320320 resolver := NewShellVariableResolver(testEnv)

321321

322− assert.NotNil(t, resolver)

323− assert.Implements(t, (*VariableResolver)(nil), resolver)

322+ require.NotNil(t, resolver)

323+ require.Implements(t, (*VariableResolver)(nil), resolver)

324324}

325325

326326func TestNewEnvironmentVariableResolver(t *testing.T) {

327327 testEnv := env.NewFromMap(map[string]string{"TEST": "value"})

328328 resolver := NewEnvironmentVariableResolver(testEnv)

329329

330− assert.NotNil(t, resolver)

331− assert.Implements(t, (*VariableResolver)(nil), resolver)

330+ require.NotNil(t, resolver)

331+ require.Implements(t, (*VariableResolver)(nil), resolver)

332332}

internal/csync/maps_test.go+107−107

@@ -6,16 +6,16 @@ import (

66 "sync"

77 "testing"

9− "github.com/stretchr/testify/assert"

9+ "github.com/stretchr/testify/require"

1010)

1111

1212func TestNewMap(t *testing.T) {

1313 t.Parallel()

1414

1515 m := NewMap[string, int]()

16− assert.NotNil(t, m)

17− assert.NotNil(t, m.inner)

18− assert.Equal(t, 0, m.Len())

16+ require.NotNil(t, m)

17+ require.NotNil(t, m.inner)

18+ require.Equal(t, 0, m.Len())

1919}

2020

2121func TestNewMapFrom(t *testing.T) {

@@ -27,13 +27,13 @@ func TestNewMapFrom(t *testing.T) {

2727 }

2828

2929 m := NewMapFrom(original)

30− assert.NotNil(t, m)

31− assert.Equal(t, original, m.inner)

32− assert.Equal(t, 2, m.Len())

30+ require.NotNil(t, m)

31+ require.Equal(t, original, m.inner)

32+ require.Equal(t, 2, m.Len())

3333

3434 value, ok := m.Get("key1")

35− assert.True(t, ok)

36− assert.Equal(t, 1, value)

35+ require.True(t, ok)

36+ require.Equal(t, 1, value)

3737}

3838

3939func TestMap_Set(t *testing.T) {

@@ -43,15 +43,15 @@ func TestMap_Set(t *testing.T) {

4343

4444 m.Set("key1", 42)

4545 value, ok := m.Get("key1")

46− assert.True(t, ok)

47− assert.Equal(t, 42, value)

48− assert.Equal(t, 1, m.Len())

46+ require.True(t, ok)

47+ require.Equal(t, 42, value)

48+ require.Equal(t, 1, m.Len())

4949

5050 m.Set("key1", 100)

5151 value, ok = m.Get("key1")

52− assert.True(t, ok)

53− assert.Equal(t, 100, value)

54− assert.Equal(t, 1, m.Len())

52+ require.True(t, ok)

53+ require.Equal(t, 100, value)

54+ require.Equal(t, 1, m.Len())

5555}

5656

5757func TestMap_Get(t *testing.T) {

@@ -60,13 +60,13 @@ func TestMap_Get(t *testing.T) {

6060 m := NewMap[string, int]()

6161

6262 value, ok := m.Get("nonexistent")

63− assert.False(t, ok)

64− assert.Equal(t, 0, value)

63+ require.False(t, ok)

64+ require.Equal(t, 0, value)

6565

6666 m.Set("key1", 42)

6767 value, ok = m.Get("key1")

68− assert.True(t, ok)

69− assert.Equal(t, 42, value)

68+ require.True(t, ok)

69+ require.Equal(t, 42, value)

7070}

7171

7272func TestMap_Del(t *testing.T) {

@@ -76,38 +76,38 @@ func TestMap_Del(t *testing.T) {

7676 m.Set("key1", 42)

7777 m.Set("key2", 100)

7878

79− assert.Equal(t, 2, m.Len())

79+ require.Equal(t, 2, m.Len())

8080

8181 m.Del("key1")

8282 _, ok := m.Get("key1")

83− assert.False(t, ok)

84− assert.Equal(t, 1, m.Len())

83+ require.False(t, ok)

84+ require.Equal(t, 1, m.Len())

8585

8686 value, ok := m.Get("key2")

87− assert.True(t, ok)

88− assert.Equal(t, 100, value)

87+ require.True(t, ok)

88+ require.Equal(t, 100, value)

8989

9090 m.Del("nonexistent")

91− assert.Equal(t, 1, m.Len())

91+ require.Equal(t, 1, m.Len())

9292}

9393

9494func TestMap_Len(t *testing.T) {

9595 t.Parallel()

9696

9797 m := NewMap[string, int]()

98− assert.Equal(t, 0, m.Len())

98+ require.Equal(t, 0, m.Len())

9999

100100 m.Set("key1", 1)

101− assert.Equal(t, 1, m.Len())

101+ require.Equal(t, 1, m.Len())

102102

103103 m.Set("key2", 2)

104− assert.Equal(t, 2, m.Len())

104+ require.Equal(t, 2, m.Len())

105105

106106 m.Del("key1")

107− assert.Equal(t, 1, m.Len())

107+ require.Equal(t, 1, m.Len())

108108

109109 m.Del("key2")

110− assert.Equal(t, 0, m.Len())

110+ require.Equal(t, 0, m.Len())

111111}

112112

113113func TestMap_Take(t *testing.T) {

@@ -117,19 +117,19 @@ func TestMap_Take(t *testing.T) {

117117 m.Set("key1", 42)

118118 m.Set("key2", 100)

119119

120− assert.Equal(t, 2, m.Len())

120+ require.Equal(t, 2, m.Len())

121121

122122 value, ok := m.Take("key1")

123− assert.True(t, ok)

124− assert.Equal(t, 42, value)

125− assert.Equal(t, 1, m.Len())

123+ require.True(t, ok)

124+ require.Equal(t, 42, value)

125+ require.Equal(t, 1, m.Len())

126126

127127 _, exists := m.Get("key1")

128− assert.False(t, exists)

128+ require.False(t, exists)

129129

130130 value, ok = m.Get("key2")

131− assert.True(t, ok)

132− assert.Equal(t, 100, value)

131+ require.True(t, ok)

132+ require.Equal(t, 100, value)

133133}

134134

135135func TestMap_Take_NonexistentKey(t *testing.T) {

@@ -139,13 +139,13 @@ func TestMap_Take_NonexistentKey(t *testing.T) {

139139 m.Set("key1", 42)

140140

141141 value, ok := m.Take("nonexistent")

142− assert.False(t, ok)

143− assert.Equal(t, 0, value)

144− assert.Equal(t, 1, m.Len())

142+ require.False(t, ok)

143+ require.Equal(t, 0, value)

144+ require.Equal(t, 1, m.Len())

145145

146146 value, ok = m.Get("key1")

147− assert.True(t, ok)

148− assert.Equal(t, 42, value)

147+ require.True(t, ok)

148+ require.Equal(t, 42, value)

149149}

150150

151151func TestMap_Take_EmptyMap(t *testing.T) {

@@ -154,9 +154,9 @@ func TestMap_Take_EmptyMap(t *testing.T) {

154154 m := NewMap[string, int]()

155155

156156 value, ok := m.Take("key1")

157− assert.False(t, ok)

158− assert.Equal(t, 0, value)

159− assert.Equal(t, 0, m.Len())

157+ require.False(t, ok)

158+ require.Equal(t, 0, value)

159+ require.Equal(t, 0, m.Len())

160160}

161161

162162func TestMap_Take_SameKeyTwice(t *testing.T) {

@@ -166,14 +166,14 @@ func TestMap_Take_SameKeyTwice(t *testing.T) {

166166 m.Set("key1", 42)

167167

168168 value, ok := m.Take("key1")

169− assert.True(t, ok)

170− assert.Equal(t, 42, value)

171− assert.Equal(t, 0, m.Len())

169+ require.True(t, ok)

170+ require.Equal(t, 42, value)

171+ require.Equal(t, 0, m.Len())

172172

173173 value, ok = m.Take("key1")

174− assert.False(t, ok)

175− assert.Equal(t, 0, value)

176− assert.Equal(t, 0, m.Len())

174+ require.False(t, ok)

175+ require.Equal(t, 0, value)

176+ require.Equal(t, 0, m.Len())

177177}

178178

179179func TestMap_Seq2(t *testing.T) {

@@ -186,10 +186,10 @@ func TestMap_Seq2(t *testing.T) {

186186

187187 collected := maps.Collect(m.Seq2())

188188

189− assert.Equal(t, 3, len(collected))

190− assert.Equal(t, 1, collected["key1"])

191− assert.Equal(t, 2, collected["key2"])

192− assert.Equal(t, 3, collected["key3"])

189+ require.Equal(t, 3, len(collected))

190+ require.Equal(t, 1, collected["key1"])

191+ require.Equal(t, 2, collected["key2"])

192+ require.Equal(t, 3, collected["key3"])

193193}

194194

195195func TestMap_Seq2_EarlyReturn(t *testing.T) {

@@ -208,7 +208,7 @@ func TestMap_Seq2_EarlyReturn(t *testing.T) {

208208 }

209209 }

210210

211− assert.Equal(t, 2, count)

211+ require.Equal(t, 2, count)

212212}

213213

214214func TestMap_Seq2_EmptyMap(t *testing.T) {

@@ -221,7 +221,7 @@ func TestMap_Seq2_EmptyMap(t *testing.T) {

221221 count++

222222 }

223223

224− assert.Equal(t, 0, count)

224+ require.Equal(t, 0, count)

225225}

226226

227227func TestMap_Seq(t *testing.T) {

@@ -237,10 +237,10 @@ func TestMap_Seq(t *testing.T) {

237237 collected = append(collected, v)

238238 }

239239

240− assert.Equal(t, 3, len(collected))

241− assert.Contains(t, collected, 1)

242− assert.Contains(t, collected, 2)

243− assert.Contains(t, collected, 3)

240+ require.Equal(t, 3, len(collected))

241+ require.Contains(t, collected, 1)

242+ require.Contains(t, collected, 2)

243+ require.Contains(t, collected, 3)

244244}

245245

246246func TestMap_Seq_EarlyReturn(t *testing.T) {

@@ -259,7 +259,7 @@ func TestMap_Seq_EarlyReturn(t *testing.T) {

259259 }

260260 }

261261

262− assert.Equal(t, 2, count)

262+ require.Equal(t, 2, count)

263263}

264264

265265func TestMap_Seq_EmptyMap(t *testing.T) {

@@ -272,7 +272,7 @@ func TestMap_Seq_EmptyMap(t *testing.T) {

272272 count++

273273 }

274274

275− assert.Equal(t, 0, count)

275+ require.Equal(t, 0, count)

276276}

277277

278278func TestMap_MarshalJSON(t *testing.T) {

@@ -283,16 +283,16 @@ func TestMap_MarshalJSON(t *testing.T) {

283283 m.Set("key2", 2)

284284

285285 data, err := json.Marshal(m)

286− assert.NoError(t, err)

286+ require.NoError(t, err)

287287

288288 result := &Map[string, int]{}

289289 err = json.Unmarshal(data, result)

290− assert.NoError(t, err)

291− assert.Equal(t, 2, result.Len())

290+ require.NoError(t, err)

291+ require.Equal(t, 2, result.Len())

292292 v1, _ := result.Get("key1")

293293 v2, _ := result.Get("key2")

294− assert.Equal(t, 1, v1)

295− assert.Equal(t, 2, v2)

294+ require.Equal(t, 1, v1)

295+ require.Equal(t, 2, v2)

296296}

297297

298298func TestMap_MarshalJSON_EmptyMap(t *testing.T) {

@@ -301,8 +301,8 @@ func TestMap_MarshalJSON_EmptyMap(t *testing.T) {

301301 m := NewMap[string, int]()

302302

303303 data, err := json.Marshal(m)

304− assert.NoError(t, err)

305− assert.Equal(t, "{}", string(data))

304+ require.NoError(t, err)

305+ require.Equal(t, "{}", string(data))

306306}

307307

308308func TestMap_UnmarshalJSON(t *testing.T) {

@@ -312,16 +312,16 @@ func TestMap_UnmarshalJSON(t *testing.T) {

312312

313313 m := NewMap[string, int]()

314314 err := json.Unmarshal([]byte(jsonData), m)

315− assert.NoError(t, err)

315+ require.NoError(t, err)

316316

317− assert.Equal(t, 2, m.Len())

317+ require.Equal(t, 2, m.Len())

318318 value, ok := m.Get("key1")

319− assert.True(t, ok)

320− assert.Equal(t, 1, value)

319+ require.True(t, ok)

320+ require.Equal(t, 1, value)

321321

322322 value, ok = m.Get("key2")

323− assert.True(t, ok)

324− assert.Equal(t, 2, value)

323+ require.True(t, ok)

324+ require.Equal(t, 2, value)

325325}

326326

327327func TestMap_UnmarshalJSON_EmptyJSON(t *testing.T) {

@@ -331,8 +331,8 @@ func TestMap_UnmarshalJSON_EmptyJSON(t *testing.T) {

331331

332332 m := NewMap[string, int]()

333333 err := json.Unmarshal([]byte(jsonData), m)

334− assert.NoError(t, err)

335− assert.Equal(t, 0, m.Len())

334+ require.NoError(t, err)

335+ require.Equal(t, 0, m.Len())

336336}

337337

338338func TestMap_UnmarshalJSON_InvalidJSON(t *testing.T) {

@@ -342,7 +342,7 @@ func TestMap_UnmarshalJSON_InvalidJSON(t *testing.T) {

342342

343343 m := NewMap[string, int]()

344344 err := json.Unmarshal([]byte(jsonData), m)

345− assert.Error(t, err)

345+ require.Error(t, err)

346346}

347347

348348func TestMap_UnmarshalJSON_OverwritesExistingData(t *testing.T) {

@@ -353,15 +353,15 @@ func TestMap_UnmarshalJSON_OverwritesExistingData(t *testing.T) {

353353

354354 jsonData := `{"key1": 1, "key2": 2}`

355355 err := json.Unmarshal([]byte(jsonData), m)

356− assert.NoError(t, err)

356+ require.NoError(t, err)

357357

358− assert.Equal(t, 2, m.Len())

358+ require.Equal(t, 2, m.Len())

359359 _, ok := m.Get("existing")

360− assert.False(t, ok)

360+ require.False(t, ok)

361361

362362 value, ok := m.Get("key1")

363− assert.True(t, ok)

364− assert.Equal(t, 1, value)

363+ require.True(t, ok)

364+ require.Equal(t, 1, value)

365365}

366366

367367func TestMap_JSONRoundTrip(t *testing.T) {

@@ -373,18 +373,18 @@ func TestMap_JSONRoundTrip(t *testing.T) {

373373 original.Set("key3", 3)

374374

375375 data, err := json.Marshal(original)

376− assert.NoError(t, err)

376+ require.NoError(t, err)

377377

378378 restored := NewMap[string, int]()

379379 err = json.Unmarshal(data, restored)

380− assert.NoError(t, err)

380+ require.NoError(t, err)

381381

382− assert.Equal(t, original.Len(), restored.Len())

382+ require.Equal(t, original.Len(), restored.Len())

383383

384384 for k, v := range original.Seq2() {

385385 restoredValue, ok := restored.Get(k)

386− assert.True(t, ok)

387− assert.Equal(t, v, restoredValue)

386+ require.True(t, ok)

387+ require.Equal(t, v, restoredValue)

388388 }

389389}

390390

@@ -405,15 +405,15 @@ func TestMap_ConcurrentAccess(t *testing.T) {

405405 key := id*numOperations + j

406406 m.Set(key, key*2)

407407 value, ok := m.Get(key)

408− assert.True(t, ok)

409− assert.Equal(t, key*2, value)

408+ require.True(t, ok)

409+ require.Equal(t, key*2, value)

410410 }

411411 }(i)

412412 }

413413

414414 wg.Wait()

415415

416− assert.Equal(t, numGoroutines*numOperations, m.Len())

416+ require.Equal(t, numGoroutines*numOperations, m.Len())

417417}

418418

419419func TestMap_ConcurrentReadWrite(t *testing.T) {

@@ -438,7 +438,7 @@ func TestMap_ConcurrentReadWrite(t *testing.T) {

438438 key := j % 1000

439439 value, ok := m.Get(key)

440440 if ok {

441− assert.Equal(t, key, value)

441+ require.Equal(t, key, value)

442442 }

443443 _ = m.Len()

444444 }

@@ -478,10 +478,10 @@ func TestMap_ConcurrentSeq2(t *testing.T) {

478478 defer wg.Done()

479479 count := 0

480480 for k, v := range m.Seq2() {

481− assert.Equal(t, k*2, v)

481+ require.Equal(t, k*2, v)

482482 count++

483483 }

484− assert.Equal(t, 100, count)

484+ require.Equal(t, 100, count)

485485 }()

486486 }

487487

@@ -509,9 +509,9 @@ func TestMap_ConcurrentSeq(t *testing.T) {

509509 values[v] = true

510510 count++

511511 }

512− assert.Equal(t, 100, count)

512+ require.Equal(t, 100, count)

513513 for i := range 100 {

514− assert.True(t, values[i*2])

514+ require.True(t, values[i*2])

515515 }

516516 }()

517517 }

@@ -548,19 +548,19 @@ func TestMap_ConcurrentTake(t *testing.T) {

548548

549549 wg.Wait()

550550

551− assert.Equal(t, 0, m.Len())

551+ require.Equal(t, 0, m.Len())

552552

553553 allTaken := make(map[int]bool)

554554 for _, workerTaken := range taken {

555555 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)

557557 allTaken[value] = true

558558 }

559559 }

560560

561− assert.Equal(t, numItems, len(allTaken))

561+ require.Equal(t, numItems, len(allTaken))

562562 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)

564564 }

565565}

566566

@@ -570,20 +570,20 @@ func TestMap_TypeSafety(t *testing.T) {

570570 stringIntMap := NewMap[string, int]()

571571 stringIntMap.Set("key", 42)

572572 value, ok := stringIntMap.Get("key")

573− assert.True(t, ok)

574− assert.Equal(t, 42, value)

573+ require.True(t, ok)

574+ require.Equal(t, 42, value)

575575

576576 intStringMap := NewMap[int, string]()

577577 intStringMap.Set(42, "value")

578578 strValue, ok := intStringMap.Get(42)

579− assert.True(t, ok)

580− assert.Equal(t, "value", strValue)

579+ require.True(t, ok)

580+ require.Equal(t, "value", strValue)

581581

582582 structMap := NewMap[string, struct{ Name string }]()

583583 structMap.Set("key", struct{ Name string }{Name: "test"})

584584 structValue, ok := structMap.Get("key")

585− assert.True(t, ok)

586− assert.Equal(t, "test", structValue.Name)

585+ require.True(t, ok)

586+ require.Equal(t, "test", structValue.Name)

587587}

588588

589589func TestMap_InterfaceCompliance(t *testing.T) {

internal/csync/slices_test.go+40−41

@@ -6,7 +6,6 @@ import (

66 "testing"

77 "time"

9− "github.com/stretchr/testify/assert"

109 "github.com/stretchr/testify/require"

1110)

1211

@@ -25,7 +24,7 @@ func TestLazySlice_Seq(t *testing.T) {

2524 result = append(result, v)

2625 }

2726

28− assert.Equal(t, data, result)

27+ require.Equal(t, data, result)

2928}

3029

3130func TestLazySlice_SeqWaitsForLoading(t *testing.T) {

@@ -41,15 +40,15 @@ func TestLazySlice_SeqWaitsForLoading(t *testing.T) {

4140 return data

4241 })

4342

44− assert.False(t, loaded.Load(), "should not be loaded immediately")

43+ require.False(t, loaded.Load(), "should not be loaded immediately")

4544

4645 var result []string

4746 for v := range s.Seq() {

4847 result = append(result, v)

4948 }

5049

51− assert.True(t, loaded.Load(), "should be loaded after Seq")

52− assert.Equal(t, data, result)

50+ require.True(t, loaded.Load(), "should be loaded after Seq")

51+ require.Equal(t, data, result)

5352}

5453

5554func TestLazySlice_EmptySlice(t *testing.T) {

@@ -64,7 +63,7 @@ func TestLazySlice_EmptySlice(t *testing.T) {

6463 result = append(result, v)

6564 }

6665

67− assert.Empty(t, result)

66+ require.Empty(t, result)

6867}

6968

7069func TestLazySlice_EarlyBreak(t *testing.T) {

@@ -85,25 +84,25 @@ func TestLazySlice_EarlyBreak(t *testing.T) {

8584 }

8685 }

8786

88− assert.Equal(t, []string{"a", "b"}, result)

87+ require.Equal(t, []string{"a", "b"}, result)

8988}

9089

9190func TestSlice(t *testing.T) {

9291 t.Run("NewSlice", func(t *testing.T) {

9392 s := NewSlice[int]()

94− assert.Equal(t, 0, s.Len())

93+ require.Equal(t, 0, s.Len())

9594 })

9695

9796 t.Run("NewSliceFrom", func(t *testing.T) {

9897 original := []int{1, 2, 3}

9998 s := NewSliceFrom(original)

100− assert.Equal(t, 3, s.Len())

99+ require.Equal(t, 3, s.Len())

101100

102101 // Verify it's a copy, not a reference

103102 original[0] = 999

104103 val, ok := s.Get(0)

105104 require.True(t, ok)

106− assert.Equal(t, 1, val)

105+ require.Equal(t, 1, val)

107106 })

108107

109108 t.Run("Append", func(t *testing.T) {

@@ -111,14 +110,14 @@ func TestSlice(t *testing.T) {

111110 s.Append("hello")

112111 s.Append("world")

113112

114− assert.Equal(t, 2, s.Len())

113+ require.Equal(t, 2, s.Len())

115114 val, ok := s.Get(0)

116115 require.True(t, ok)

117− assert.Equal(t, "hello", val)

116+ require.Equal(t, "hello", val)

118117

119118 val, ok = s.Get(1)

120119 require.True(t, ok)

121− assert.Equal(t, "world", val)

120+ require.Equal(t, "world", val)

122121 })

123122

124123 t.Run("Prepend", func(t *testing.T) {

@@ -126,14 +125,14 @@ func TestSlice(t *testing.T) {

126125 s.Append("world")

127126 s.Prepend("hello")

128127

129− assert.Equal(t, 2, s.Len())

128+ require.Equal(t, 2, s.Len())

130129 val, ok := s.Get(0)

131130 require.True(t, ok)

132− assert.Equal(t, "hello", val)

131+ require.Equal(t, "hello", val)

133132

134133 val, ok = s.Get(1)

135134 require.True(t, ok)

136− assert.Equal(t, "world", val)

135+ require.Equal(t, "world", val)

137136 })

138137

139138 t.Run("Delete", func(t *testing.T) {

@@ -141,22 +140,22 @@ func TestSlice(t *testing.T) {

141140

142141 // Delete middle element

143142 ok := s.Delete(2)

144− assert.True(t, ok)

145− assert.Equal(t, 4, s.Len())

143+ require.True(t, ok)

144+ require.Equal(t, 4, s.Len())

146145

147146 expected := []int{1, 2, 4, 5}

148147 actual := s.Slice()

149− assert.Equal(t, expected, actual)

148+ require.Equal(t, expected, actual)

150149

151150 // Delete out of bounds

152151 ok = s.Delete(10)

153− assert.False(t, ok)

154− assert.Equal(t, 4, s.Len())

152+ require.False(t, ok)

153+ require.Equal(t, 4, s.Len())

155154

156155 // Delete negative index

157156 ok = s.Delete(-1)

158− assert.False(t, ok)

159− assert.Equal(t, 4, s.Len())

157+ require.False(t, ok)

158+ require.Equal(t, 4, s.Len())

160159 })

161160

162161 t.Run("Get", func(t *testing.T) {

@@ -164,34 +163,34 @@ func TestSlice(t *testing.T) {

164163

165164 val, ok := s.Get(1)

166165 require.True(t, ok)

167− assert.Equal(t, "b", val)

166+ require.Equal(t, "b", val)

168167

169168 // Out of bounds

170169 _, ok = s.Get(10)

171− assert.False(t, ok)

170+ require.False(t, ok)

172171

173172 // Negative index

174173 _, ok = s.Get(-1)

175− assert.False(t, ok)

174+ require.False(t, ok)

176175 })

177176

178177 t.Run("Set", func(t *testing.T) {

179178 s := NewSliceFrom([]string{"a", "b", "c"})

180179

181180 ok := s.Set(1, "modified")

182− assert.True(t, ok)

181+ require.True(t, ok)

183182

184183 val, ok := s.Get(1)

185184 require.True(t, ok)

186− assert.Equal(t, "modified", val)

185+ require.Equal(t, "modified", val)

187186

188187 // Out of bounds

189188 ok = s.Set(10, "invalid")

190− assert.False(t, ok)

189+ require.False(t, ok)

191190

192191 // Negative index

193192 ok = s.Set(-1, "invalid")

194− assert.False(t, ok)

193+ require.False(t, ok)

195194 })

196195

197196 t.Run("SetSlice", func(t *testing.T) {

@@ -202,22 +201,22 @@ func TestSlice(t *testing.T) {

202201 newItems := []int{10, 20, 30}

203202 s.SetSlice(newItems)

204203

205− assert.Equal(t, 3, s.Len())

206− assert.Equal(t, newItems, s.Slice())

204+ require.Equal(t, 3, s.Len())

205+ require.Equal(t, newItems, s.Slice())

207206

208207 // Verify it's a copy

209208 newItems[0] = 999

210209 val, ok := s.Get(0)

211210 require.True(t, ok)

212− assert.Equal(t, 10, val)

211+ require.Equal(t, 10, val)

213212 })

214213

215214 t.Run("Clear", func(t *testing.T) {

216215 s := NewSliceFrom([]int{1, 2, 3})

217− assert.Equal(t, 3, s.Len())

216+ require.Equal(t, 3, s.Len())

218217

219218 s.Clear()

220− assert.Equal(t, 0, s.Len())

219+ require.Equal(t, 0, s.Len())

221220 })

222221

223222 t.Run("Slice", func(t *testing.T) {

@@ -225,13 +224,13 @@ func TestSlice(t *testing.T) {

225224 s := NewSliceFrom(original)

226225

227226 copy := s.Slice()

228− assert.Equal(t, original, copy)

227+ require.Equal(t, original, copy)

229228

230229 // Verify it's a copy

231230 copy[0] = 999

232231 val, ok := s.Get(0)

233232 require.True(t, ok)

234− assert.Equal(t, 1, val)

233+ require.Equal(t, 1, val)

235234 })

236235

237236 t.Run("Seq", func(t *testing.T) {

@@ -242,7 +241,7 @@ func TestSlice(t *testing.T) {

242241 result = append(result, v)

243242 }

244243

245− assert.Equal(t, []int{1, 2, 3}, result)

244+ require.Equal(t, []int{1, 2, 3}, result)

246245 })

247246

248247 t.Run("SeqWithIndex", func(t *testing.T) {

@@ -255,8 +254,8 @@ func TestSlice(t *testing.T) {

255254 values = append(values, v)

256255 }

257256

258− assert.Equal(t, []int{0, 1, 2}, indices)

259− assert.Equal(t, []string{"a", "b", "c"}, values)

257+ require.Equal(t, []int{0, 1, 2}, indices)

258+ require.Equal(t, []string{"a", "b", "c"}, values)

260259 })

261260

262261 t.Run("ConcurrentAccess", func(t *testing.T) {

@@ -291,6 +290,6 @@ func TestSlice(t *testing.T) {

291290 wg.Wait()

292291

293292 // Should have all items

294− assert.Equal(t, numGoroutines*itemsPerGoroutine, s.Len())

293+ require.Equal(t, numGoroutines*itemsPerGoroutine, s.Len())

295294 })

296295}

internal/env/env_test.go+23−25

@@ -1,26 +1,24 @@

11package env

33import (

4− "os"

54 "strings"

65 "testing"

8− "github.com/stretchr/testify/assert"

7+ "github.com/stretchr/testify/require"

98)

109

1110func TestOsEnv_Get(t *testing.T) {

1211 env := New()

1312

1413 // Test getting an existing environment variable

15− os.Setenv("TEST_VAR", "test_value")

16− defer os.Unsetenv("TEST_VAR")

14+ t.Setenv("TEST_VAR", "test_value")

1715

1816 value := env.Get("TEST_VAR")

19− assert.Equal(t, "test_value", value)

17+ require.Equal(t, "test_value", value)

2018

2119 // Test getting a non-existent environment variable

2220 value = env.Get("NON_EXISTENT_VAR")

23− assert.Equal(t, "", value)

21+ require.Equal(t, "", value)

2422}

2523

2624func TestOsEnv_Env(t *testing.T) {

@@ -29,12 +27,12 @@ func TestOsEnv_Env(t *testing.T) {

2927 envVars := env.Env()

3028

3129 // Environment should not be empty in normal circumstances

32− assert.NotNil(t, envVars)

33− assert.Greater(t, len(envVars), 0)

30+ require.NotNil(t, envVars)

31+ require.Greater(t, len(envVars), 0)

3432

3533 // Each environment variable should be in key=value format

3634 for _, envVar := range envVars {

37− assert.Contains(t, envVar, "=")

35+ require.Contains(t, envVar, "=")

3836 }

3937}

4038

@@ -45,8 +43,8 @@ func TestNewFromMap(t *testing.T) {

4543 }

4644

4745 env := NewFromMap(testMap)

48− assert.NotNil(t, env)

49− assert.IsType(t, &mapEnv{}, env)

46+ require.NotNil(t, env)

47+ require.IsType(t, &mapEnv{}, env)

5048}

5149

5250func TestMapEnv_Get(t *testing.T) {

@@ -58,11 +56,11 @@ func TestMapEnv_Get(t *testing.T) {

5856 env := NewFromMap(testMap)

5957

6058 // Test getting existing keys

61− assert.Equal(t, "value1", env.Get("KEY1"))

62− assert.Equal(t, "value2", env.Get("KEY2"))

59+ require.Equal(t, "value1", env.Get("KEY1"))

60+ require.Equal(t, "value2", env.Get("KEY2"))

6361

6462 // Test getting non-existent key

65− assert.Equal(t, "", env.Get("NON_EXISTENT"))

63+ require.Equal(t, "", env.Get("NON_EXISTENT"))

6664}

6765

6866func TestMapEnv_Env(t *testing.T) {

@@ -75,30 +73,30 @@ func TestMapEnv_Env(t *testing.T) {

7573 env := NewFromMap(testMap)

7674 envVars := env.Env()

7775

78− assert.Len(t, envVars, 2)

76+ require.Len(t, envVars, 2)

7977

8078 // Convert to map for easier testing (order is not guaranteed)

8179 envMap := make(map[string]string)

8280 for _, envVar := range envVars {

8381 parts := strings.SplitN(envVar, "=", 2)

84− assert.Len(t, parts, 2)

82+ require.Len(t, parts, 2)

8583 envMap[parts[0]] = parts[1]

8684 }

8785

88− assert.Equal(t, "value1", envMap["KEY1"])

89− assert.Equal(t, "value2", envMap["KEY2"])

86+ require.Equal(t, "value1", envMap["KEY1"])

87+ require.Equal(t, "value2", envMap["KEY2"])

9088 })

9189

9290 t.Run("empty map", func(t *testing.T) {

9391 env := NewFromMap(map[string]string{})

9492 envVars := env.Env()

95− assert.Nil(t, envVars)

93+ require.Nil(t, envVars)

9694 })

9795

9896 t.Run("nil map", func(t *testing.T) {

9997 env := NewFromMap(nil)

10098 envVars := env.Env()

101− assert.Nil(t, envVars)

99+ require.Nil(t, envVars)

102100 })

103101}

104102

@@ -111,8 +109,8 @@ func TestMapEnv_GetEmptyValue(t *testing.T) {

111109 env := NewFromMap(testMap)

112110

113111 // Test that empty values are returned correctly

114− assert.Equal(t, "", env.Get("EMPTY_KEY"))

115− assert.Equal(t, "value", env.Get("NORMAL_KEY"))

112+ require.Equal(t, "", env.Get("EMPTY_KEY"))

113+ require.Equal(t, "value", env.Get("NORMAL_KEY"))

116114}

117115

118116func TestMapEnv_EnvFormat(t *testing.T) {

@@ -124,7 +122,7 @@ func TestMapEnv_EnvFormat(t *testing.T) {

124122 env := NewFromMap(testMap)

125123 envVars := env.Env()

126124

127− assert.Len(t, envVars, 2)

125+ require.Len(t, envVars, 2)

128126

129127 // Check that the format is correct even with special characters

130128 found := make(map[string]bool)

@@ -137,6 +135,6 @@ func TestMapEnv_EnvFormat(t *testing.T) {

137135 }

138136 }

139137

140− assert.True(t, found["equals"], "Should handle values with equals signs")

141− assert.True(t, found["spaces"], "Should handle values with spaces")

138+ require.True(t, found["equals"], "Should handle values with equals signs")

139+ require.True(t, found["spaces"], "Should handle values with spaces")

142140}

internal/llm/prompt/prompt_test.go+4−6

@@ -97,8 +97,7 @@ func TestProcessContextPaths(t *testing.T) {

9797

9898 // Test with tilde expansion (if we can create a file in home directory)

9999 tmpDir = t.TempDir()

100− rollback := setHomeEnv(tmpDir)

101− defer rollback()

100+ setHomeEnv(t, tmpDir)

102101 homeTestFile := filepath.Join(tmpDir, "crush_test_file.txt")

103102 err = os.WriteFile(homeTestFile, []byte(testContent), 0o644)

104103 if err == nil {

@@ -114,12 +113,11 @@ func TestProcessContextPaths(t *testing.T) {

114113 }

115114}

116115

117−func setHomeEnv(path string) (rollback func()) {

116+func setHomeEnv(tb testing.TB, path string) {

117+ tb.Helper()

118118 key := "HOME"

119119 if runtime.GOOS == "windows" {

120120 key = "USERPROFILE"

121121 }

122− original := os.Getenv(key)

123− os.Setenv(key, path)

124− return func() { os.Setenv(key, original) }

122+ tb.Setenv(key, path)

125123}

internal/shell/comparison_test.go+3−4

@@ -4,7 +4,6 @@ import (

44 "testing"

55 "time"

7− "github.com/stretchr/testify/assert"

87 "github.com/stretchr/testify/require"

98)

109

@@ -18,9 +17,9 @@ func TestShellPerformanceComparison(t *testing.T) {

1817 duration := time.Since(start)

1918

2019 require.NoError(t, err)

21− assert.Equal(t, 0, exitCode)

22− assert.Contains(t, stdout, "hello")

23− assert.Empty(t, stderr)

20+ require.Equal(t, 0, exitCode)

21+ require.Contains(t, stdout, "hello")

22+ require.Empty(t, stderr)

2423

2524 t.Logf("Quick command took: %v", duration)

2625}