test: refactor claude setup for coverage
This commit is contained in:
Jordan Hubbard
committed by
Steve Yegge
Steve Yegge
parent
8f8a075943
commit
283a275740
1449
.beads/issues.jsonl
1449
.beads/issues.jsonl
File diff suppressed because one or more lines are too long
@@ -2,166 +2,219 @@ package setup
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
var (
|
||||
claudeEnvProvider = defaultClaudeEnv
|
||||
errClaudeHooksMissing = errors.New("claude hooks not installed")
|
||||
)
|
||||
|
||||
type claudeEnv struct {
|
||||
stdout io.Writer
|
||||
stderr io.Writer
|
||||
homeDir string
|
||||
projectDir string
|
||||
ensureDir func(string, os.FileMode) error
|
||||
readFile func(string) ([]byte, error)
|
||||
writeFile func(string, []byte) error
|
||||
}
|
||||
|
||||
func defaultClaudeEnv() (claudeEnv, error) {
|
||||
home, err := os.UserHomeDir()
|
||||
if err != nil {
|
||||
return claudeEnv{}, fmt.Errorf("home directory: %w", err)
|
||||
}
|
||||
workDir, err := os.Getwd()
|
||||
if err != nil {
|
||||
return claudeEnv{}, fmt.Errorf("working directory: %w", err)
|
||||
}
|
||||
return claudeEnv{
|
||||
stdout: os.Stdout,
|
||||
stderr: os.Stderr,
|
||||
homeDir: home,
|
||||
projectDir: workDir,
|
||||
ensureDir: EnsureDir,
|
||||
readFile: os.ReadFile,
|
||||
writeFile: func(path string, data []byte) error {
|
||||
return atomicWriteFile(path, data)
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func projectSettingsPath(base string) string {
|
||||
return filepath.Join(base, ".claude", "settings.local.json")
|
||||
}
|
||||
|
||||
func globalSettingsPath(home string) string {
|
||||
return filepath.Join(home, ".claude", "settings.json")
|
||||
}
|
||||
|
||||
// InstallClaude installs Claude Code hooks
|
||||
func InstallClaude(project bool, stealth bool) {
|
||||
var settingsPath string
|
||||
|
||||
if project {
|
||||
settingsPath = ".claude/settings.local.json"
|
||||
fmt.Println("Installing Claude hooks for this project...")
|
||||
} else {
|
||||
home, err := os.UserHomeDir()
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: failed to get home directory: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
settingsPath = filepath.Join(home, ".claude/settings.json")
|
||||
fmt.Println("Installing Claude hooks globally...")
|
||||
}
|
||||
|
||||
// Ensure parent directory exists
|
||||
if err := EnsureDir(filepath.Dir(settingsPath), 0755); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Load or create settings
|
||||
var settings map[string]interface{}
|
||||
data, err := os.ReadFile(settingsPath) // #nosec G304 -- settingsPath is constructed from user home dir, not user input
|
||||
env, err := claudeEnvProvider()
|
||||
if err != nil {
|
||||
settings = make(map[string]interface{})
|
||||
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
||||
setupExit(1)
|
||||
return
|
||||
}
|
||||
if err := installClaude(env, project, stealth); err != nil {
|
||||
setupExit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func installClaude(env claudeEnv, project bool, stealth bool) error {
|
||||
var settingsPath string
|
||||
if project {
|
||||
settingsPath = projectSettingsPath(env.projectDir)
|
||||
fmt.Fprintln(env.stdout, "Installing Claude hooks for this project...")
|
||||
} else {
|
||||
settingsPath = globalSettingsPath(env.homeDir)
|
||||
fmt.Fprintln(env.stdout, "Installing Claude hooks globally...")
|
||||
}
|
||||
|
||||
if err := env.ensureDir(filepath.Dir(settingsPath), 0o755); err != nil {
|
||||
fmt.Fprintf(env.stderr, "Error: %v\n", err)
|
||||
return err
|
||||
}
|
||||
|
||||
settings := make(map[string]interface{})
|
||||
if data, err := env.readFile(settingsPath); err == nil {
|
||||
if err := json.Unmarshal(data, &settings); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: failed to parse settings.json: %v\n", err)
|
||||
os.Exit(1)
|
||||
fmt.Fprintf(env.stderr, "Error: failed to parse settings.json: %v\n", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// Get or create hooks section
|
||||
hooks, ok := settings["hooks"].(map[string]interface{})
|
||||
if !ok {
|
||||
hooks = make(map[string]interface{})
|
||||
settings["hooks"] = hooks
|
||||
}
|
||||
|
||||
// Determine which command to use
|
||||
command := "bd prime"
|
||||
if stealth {
|
||||
command = "bd prime --stealth"
|
||||
}
|
||||
|
||||
// Add SessionStart hook
|
||||
if addHookCommand(hooks, "SessionStart", command) {
|
||||
fmt.Println("✓ Registered SessionStart hook")
|
||||
fmt.Fprintln(env.stdout, "✓ Registered SessionStart hook")
|
||||
}
|
||||
|
||||
// Add PreCompact hook
|
||||
if addHookCommand(hooks, "PreCompact", command) {
|
||||
fmt.Println("✓ Registered PreCompact hook")
|
||||
fmt.Fprintln(env.stdout, "✓ Registered PreCompact hook")
|
||||
}
|
||||
|
||||
// Write back to file
|
||||
data, err = json.MarshalIndent(settings, "", " ")
|
||||
data, err := json.MarshalIndent(settings, "", " ")
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: marshal settings: %v\n", err)
|
||||
os.Exit(1)
|
||||
fmt.Fprintf(env.stderr, "Error: marshal settings: %v\n", err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := atomicWriteFile(settingsPath, data); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: write settings: %v\n", err)
|
||||
os.Exit(1)
|
||||
if err := env.writeFile(settingsPath, data); err != nil {
|
||||
fmt.Fprintf(env.stderr, "Error: write settings: %v\n", err)
|
||||
return err
|
||||
}
|
||||
|
||||
fmt.Printf("\n✓ Claude Code integration installed\n")
|
||||
fmt.Printf(" Settings: %s\n", settingsPath)
|
||||
fmt.Println("\nRestart Claude Code for changes to take effect.")
|
||||
fmt.Fprintln(env.stdout, "\n✓ Claude Code integration installed")
|
||||
fmt.Fprintf(env.stdout, " Settings: %s\n", settingsPath)
|
||||
fmt.Fprintln(env.stdout, "\nRestart Claude Code for changes to take effect.")
|
||||
return nil
|
||||
}
|
||||
|
||||
// CheckClaude checks if Claude integration is installed
|
||||
func CheckClaude() {
|
||||
home, err := os.UserHomeDir()
|
||||
env, err := claudeEnvProvider()
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: failed to get home directory: %v\n", err)
|
||||
os.Exit(1)
|
||||
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
||||
setupExit(1)
|
||||
return
|
||||
}
|
||||
if err := checkClaude(env); err != nil {
|
||||
setupExit(1)
|
||||
}
|
||||
}
|
||||
|
||||
globalSettings := filepath.Join(home, ".claude/settings.json")
|
||||
projectSettings := ".claude/settings.local.json"
|
||||
func checkClaude(env claudeEnv) error {
|
||||
globalSettings := globalSettingsPath(env.homeDir)
|
||||
projectSettings := projectSettingsPath(env.projectDir)
|
||||
|
||||
globalHooks := hasBeadsHooks(globalSettings)
|
||||
projectHooks := hasBeadsHooks(projectSettings)
|
||||
|
||||
if globalHooks {
|
||||
fmt.Println("✓ Global hooks installed:", globalSettings)
|
||||
} else if projectHooks {
|
||||
fmt.Println("✓ Project hooks installed:", projectSettings)
|
||||
} else {
|
||||
fmt.Println("✗ No hooks installed")
|
||||
fmt.Println(" Run: bd setup claude")
|
||||
os.Exit(1)
|
||||
switch {
|
||||
case hasBeadsHooks(globalSettings):
|
||||
fmt.Fprintf(env.stdout, "✓ Global hooks installed: %s\n", globalSettings)
|
||||
return nil
|
||||
case hasBeadsHooks(projectSettings):
|
||||
fmt.Fprintf(env.stdout, "✓ Project hooks installed: %s\n", projectSettings)
|
||||
return nil
|
||||
default:
|
||||
fmt.Fprintln(env.stdout, "✗ No hooks installed")
|
||||
fmt.Fprintln(env.stdout, " Run: bd setup claude")
|
||||
return errClaudeHooksMissing
|
||||
}
|
||||
}
|
||||
|
||||
// RemoveClaude removes Claude Code hooks
|
||||
func RemoveClaude(project bool) {
|
||||
var settingsPath string
|
||||
env, err := claudeEnvProvider()
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
||||
setupExit(1)
|
||||
return
|
||||
}
|
||||
if err := removeClaude(env, project); err != nil {
|
||||
setupExit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func removeClaude(env claudeEnv, project bool) error {
|
||||
var settingsPath string
|
||||
if project {
|
||||
settingsPath = ".claude/settings.local.json"
|
||||
fmt.Println("Removing Claude hooks from project...")
|
||||
settingsPath = projectSettingsPath(env.projectDir)
|
||||
fmt.Fprintln(env.stdout, "Removing Claude hooks from project...")
|
||||
} else {
|
||||
home, err := os.UserHomeDir()
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: failed to get home directory: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
settingsPath = filepath.Join(home, ".claude/settings.json")
|
||||
fmt.Println("Removing Claude hooks globally...")
|
||||
settingsPath = globalSettingsPath(env.homeDir)
|
||||
fmt.Fprintln(env.stdout, "Removing Claude hooks globally...")
|
||||
}
|
||||
|
||||
// Load settings
|
||||
data, err := os.ReadFile(settingsPath) // #nosec G304 -- settingsPath is constructed from user home dir, not user input
|
||||
data, err := env.readFile(settingsPath)
|
||||
if err != nil {
|
||||
fmt.Println("No settings file found")
|
||||
return
|
||||
fmt.Fprintln(env.stdout, "No settings file found")
|
||||
return nil
|
||||
}
|
||||
|
||||
var settings map[string]interface{}
|
||||
if err := json.Unmarshal(data, &settings); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: failed to parse settings.json: %v\n", err)
|
||||
os.Exit(1)
|
||||
fmt.Fprintf(env.stderr, "Error: failed to parse settings.json: %v\n", err)
|
||||
return err
|
||||
}
|
||||
|
||||
hooks, ok := settings["hooks"].(map[string]interface{})
|
||||
if !ok {
|
||||
fmt.Println("No hooks found")
|
||||
return
|
||||
fmt.Fprintln(env.stdout, "No hooks found")
|
||||
return nil
|
||||
}
|
||||
|
||||
// Remove bd prime hooks (both variants for backwards compatibility)
|
||||
removeHookCommand(hooks, "SessionStart", "bd prime")
|
||||
removeHookCommand(hooks, "PreCompact", "bd prime")
|
||||
removeHookCommand(hooks, "SessionStart", "bd prime --stealth")
|
||||
removeHookCommand(hooks, "PreCompact", "bd prime --stealth")
|
||||
|
||||
// Write back
|
||||
data, err = json.MarshalIndent(settings, "", " ")
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: marshal settings: %v\n", err)
|
||||
os.Exit(1)
|
||||
fmt.Fprintf(env.stderr, "Error: marshal settings: %v\n", err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := atomicWriteFile(settingsPath, data); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: write settings: %v\n", err)
|
||||
os.Exit(1)
|
||||
if err := env.writeFile(settingsPath, data); err != nil {
|
||||
fmt.Fprintf(env.stderr, "Error: write settings: %v\n", err)
|
||||
return err
|
||||
}
|
||||
|
||||
fmt.Println("✓ Claude hooks removed")
|
||||
fmt.Fprintln(env.stdout, "✓ Claude hooks removed")
|
||||
return nil
|
||||
}
|
||||
|
||||
// addHookCommand adds a hook command to an event if not already present
|
||||
|
||||
@@ -1,12 +1,68 @@
|
||||
package setup
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func newClaudeTestEnv(t *testing.T) (claudeEnv, *bytes.Buffer, *bytes.Buffer) {
|
||||
t.Helper()
|
||||
root := t.TempDir()
|
||||
projectDir := filepath.Join(root, "project")
|
||||
homeDir := filepath.Join(root, "home")
|
||||
if err := os.MkdirAll(projectDir, 0o755); err != nil {
|
||||
t.Fatalf("mkdir project: %v", err)
|
||||
}
|
||||
if err := os.MkdirAll(homeDir, 0o755); err != nil {
|
||||
t.Fatalf("mkdir home: %v", err)
|
||||
}
|
||||
stdout := &bytes.Buffer{}
|
||||
stderr := &bytes.Buffer{}
|
||||
env := claudeEnv{
|
||||
stdout: stdout,
|
||||
stderr: stderr,
|
||||
homeDir: homeDir,
|
||||
projectDir: projectDir,
|
||||
ensureDir: EnsureDir,
|
||||
readFile: os.ReadFile,
|
||||
writeFile: func(path string, data []byte) error {
|
||||
return atomicWriteFile(path, data)
|
||||
},
|
||||
}
|
||||
return env, stdout, stderr
|
||||
}
|
||||
|
||||
func stubClaudeEnvProvider(t *testing.T, env claudeEnv, err error) {
|
||||
t.Helper()
|
||||
orig := claudeEnvProvider
|
||||
claudeEnvProvider = func() (claudeEnv, error) {
|
||||
if err != nil {
|
||||
return claudeEnv{}, err
|
||||
}
|
||||
return env, nil
|
||||
}
|
||||
t.Cleanup(func() { claudeEnvProvider = orig })
|
||||
}
|
||||
|
||||
func writeSettings(t *testing.T, path string, settings map[string]interface{}) {
|
||||
t.Helper()
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
t.Fatalf("mkdir settings dir: %v", err)
|
||||
}
|
||||
data, err := json.MarshalIndent(settings, "", " ")
|
||||
if err != nil {
|
||||
t.Fatalf("marshal settings: %v", err)
|
||||
}
|
||||
if err := atomicWriteFile(path, data); err != nil {
|
||||
t.Fatalf("write settings: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddHookCommand(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
@@ -406,3 +462,236 @@ func TestIdempotencyWithStealth(t *testing.T) {
|
||||
t.Errorf("Expected 'bd prime --stealth', got %v", cmdMap["command"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestInstallClaudeProject(t *testing.T) {
|
||||
env, stdout, stderr := newClaudeTestEnv(t)
|
||||
if err := installClaude(env, true, false); err != nil {
|
||||
t.Fatalf("installClaude: %v", err)
|
||||
}
|
||||
data, err := os.ReadFile(projectSettingsPath(env.projectDir))
|
||||
if err != nil {
|
||||
t.Fatalf("read project settings: %v", err)
|
||||
}
|
||||
var settings map[string]interface{}
|
||||
if err := json.Unmarshal(data, &settings); err != nil {
|
||||
t.Fatalf("unmarshal settings: %v", err)
|
||||
}
|
||||
if !hasBeadsHooks(projectSettingsPath(env.projectDir)) {
|
||||
t.Fatal("project hooks not detected")
|
||||
}
|
||||
if !strings.Contains(stdout.String(), "project") {
|
||||
t.Error("expected project installation message")
|
||||
}
|
||||
if stderr.Len() != 0 {
|
||||
t.Errorf("unexpected stderr output: %s", stderr.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestInstallClaudeGlobalStealth(t *testing.T) {
|
||||
env, stdout, _ := newClaudeTestEnv(t)
|
||||
if err := installClaude(env, false, true); err != nil {
|
||||
t.Fatalf("installClaude: %v", err)
|
||||
}
|
||||
data, err := os.ReadFile(globalSettingsPath(env.homeDir))
|
||||
if err != nil {
|
||||
t.Fatalf("read global settings: %v", err)
|
||||
}
|
||||
if !strings.Contains(string(data), "bd prime --stealth") {
|
||||
t.Error("expected stealth command in settings")
|
||||
}
|
||||
if !strings.Contains(stdout.String(), "globally") {
|
||||
t.Error("expected global installation message")
|
||||
}
|
||||
}
|
||||
|
||||
func TestInstallClaudeErrors(t *testing.T) {
|
||||
t.Run("invalid json", func(t *testing.T) {
|
||||
env, _, stderr := newClaudeTestEnv(t)
|
||||
path := projectSettingsPath(env.projectDir)
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
t.Fatalf("mkdir: %v", err)
|
||||
}
|
||||
if err := os.WriteFile(path, []byte("not json"), 0o644); err != nil {
|
||||
t.Fatalf("write file: %v", err)
|
||||
}
|
||||
if err := installClaude(env, true, false); err == nil {
|
||||
t.Fatal("expected parse error")
|
||||
}
|
||||
if !strings.Contains(stderr.String(), "failed to parse") {
|
||||
t.Error("expected parse error output")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("ensure dir error", func(t *testing.T) {
|
||||
env, _, _ := newClaudeTestEnv(t)
|
||||
env.ensureDir = func(string, os.FileMode) error { return errors.New("boom") }
|
||||
if err := installClaude(env, true, false); err == nil {
|
||||
t.Fatal("expected ensureDir error")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestCheckClaudeScenarios(t *testing.T) {
|
||||
t.Run("global hooks", func(t *testing.T) {
|
||||
env, stdout, _ := newClaudeTestEnv(t)
|
||||
writeSettings(t, globalSettingsPath(env.homeDir), map[string]interface{}{
|
||||
"hooks": map[string]interface{}{
|
||||
"SessionStart": []interface{}{
|
||||
map[string]interface{}{
|
||||
"matcher": "",
|
||||
"hooks": []interface{}{
|
||||
map[string]interface{}{"type": "command", "command": "bd prime"},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
if err := checkClaude(env); err != nil {
|
||||
t.Fatalf("checkClaude: %v", err)
|
||||
}
|
||||
if !strings.Contains(stdout.String(), "Global hooks installed") {
|
||||
t.Error("expected global hooks message")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("project hooks", func(t *testing.T) {
|
||||
env, stdout, _ := newClaudeTestEnv(t)
|
||||
writeSettings(t, projectSettingsPath(env.projectDir), map[string]interface{}{
|
||||
"hooks": map[string]interface{}{
|
||||
"PreCompact": []interface{}{
|
||||
map[string]interface{}{
|
||||
"matcher": "",
|
||||
"hooks": []interface{}{
|
||||
map[string]interface{}{"type": "command", "command": "bd prime"},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
if err := checkClaude(env); err != nil {
|
||||
t.Fatalf("checkClaude: %v", err)
|
||||
}
|
||||
if !strings.Contains(stdout.String(), "Project hooks installed") {
|
||||
t.Error("expected project hooks message")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing hooks", func(t *testing.T) {
|
||||
env, stdout, _ := newClaudeTestEnv(t)
|
||||
if err := checkClaude(env); !errors.Is(err, errClaudeHooksMissing) {
|
||||
t.Fatalf("expected errClaudeHooksMissing, got %v", err)
|
||||
}
|
||||
if !strings.Contains(stdout.String(), "Run: bd setup claude") {
|
||||
t.Error("expected guidance message")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestRemoveClaudeScenarios(t *testing.T) {
|
||||
t.Run("remove global hooks", func(t *testing.T) {
|
||||
env, stdout, _ := newClaudeTestEnv(t)
|
||||
path := globalSettingsPath(env.homeDir)
|
||||
writeSettings(t, path, map[string]interface{}{
|
||||
"hooks": map[string]interface{}{
|
||||
"SessionStart": []interface{}{
|
||||
map[string]interface{}{
|
||||
"matcher": "",
|
||||
"hooks": []interface{}{
|
||||
map[string]interface{}{"type": "command", "command": "bd prime"},
|
||||
map[string]interface{}{"type": "command", "command": "other"},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
if err := removeClaude(env, false); err != nil {
|
||||
t.Fatalf("removeClaude: %v", err)
|
||||
}
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("read file: %v", err)
|
||||
}
|
||||
if strings.Contains(string(data), "bd prime") {
|
||||
t.Error("expected bd prime hooks removed")
|
||||
}
|
||||
if !strings.Contains(stdout.String(), "hooks removed") {
|
||||
t.Error("expected success message")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing file", func(t *testing.T) {
|
||||
env, stdout, _ := newClaudeTestEnv(t)
|
||||
if err := removeClaude(env, true); err != nil {
|
||||
t.Fatalf("removeClaude: %v", err)
|
||||
}
|
||||
if !strings.Contains(stdout.String(), "No settings file found") {
|
||||
t.Error("expected missing file message")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("invalid json", func(t *testing.T) {
|
||||
env, _, stderr := newClaudeTestEnv(t)
|
||||
path := projectSettingsPath(env.projectDir)
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
t.Fatalf("mkdir: %v", err)
|
||||
}
|
||||
if err := os.WriteFile(path, []byte("not json"), 0o644); err != nil {
|
||||
t.Fatalf("write file: %v", err)
|
||||
}
|
||||
if err := removeClaude(env, true); err == nil {
|
||||
t.Fatal("expected parse error")
|
||||
}
|
||||
if !strings.Contains(stderr.String(), "failed to parse") {
|
||||
t.Error("expected parse error output")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestClaudeWrappersExit(t *testing.T) {
|
||||
t.Run("install provider error", func(t *testing.T) {
|
||||
cap := stubSetupExit(t)
|
||||
stubClaudeEnvProvider(t, claudeEnv{}, errors.New("boom"))
|
||||
InstallClaude(false, false)
|
||||
if !cap.called || cap.code != 1 {
|
||||
t.Fatal("InstallClaude should exit on provider error")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("install internal error", func(t *testing.T) {
|
||||
cap := stubSetupExit(t)
|
||||
env, _, _ := newClaudeTestEnv(t)
|
||||
env.ensureDir = func(string, os.FileMode) error { return errors.New("boom") }
|
||||
stubClaudeEnvProvider(t, env, nil)
|
||||
InstallClaude(true, false)
|
||||
if !cap.called || cap.code != 1 {
|
||||
t.Fatal("InstallClaude should exit when installClaude fails")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("check missing hooks", func(t *testing.T) {
|
||||
cap := stubSetupExit(t)
|
||||
env, _, _ := newClaudeTestEnv(t)
|
||||
stubClaudeEnvProvider(t, env, nil)
|
||||
CheckClaude()
|
||||
if !cap.called || cap.code != 1 {
|
||||
t.Fatal("CheckClaude should exit when hooks missing")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("remove parse error", func(t *testing.T) {
|
||||
cap := stubSetupExit(t)
|
||||
env, _, _ := newClaudeTestEnv(t)
|
||||
path := globalSettingsPath(env.homeDir)
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
t.Fatalf("mkdir: %v", err)
|
||||
}
|
||||
if err := os.WriteFile(path, []byte("oops"), 0o644); err != nil {
|
||||
t.Fatalf("write file: %v", err)
|
||||
}
|
||||
stubClaudeEnvProvider(t, env, nil)
|
||||
RemoveClaude(false)
|
||||
if !cap.called || cap.code != 1 {
|
||||
t.Fatal("RemoveClaude should exit on parse error")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user