test: refactor claude setup for coverage

cmd/bd/setup/claude.go

@@ -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
+	env, err := claudeEnvProvider()
-
-	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
 	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)
+			fmt.Fprintf(env.stderr, "Error: failed to parse settings.json: %v\n", err)
-			os.Exit(1)
+			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)
+		fmt.Fprintf(env.stderr, "Error: marshal settings: %v\n", err)
-		os.Exit(1)
+		return err
 	}
 
-	if err := atomicWriteFile(settingsPath, data); err != nil {
+	if err := env.writeFile(settingsPath, data); err != nil {
-		fmt.Fprintf(os.Stderr, "Error: write settings: %v\n", err)
+		fmt.Fprintf(env.stderr, "Error: write settings: %v\n", err)
-		os.Exit(1)
+		return err
 	}
 
-	fmt.Printf("\n✓ Claude Code integration installed\n")
+	fmt.Fprintln(env.stdout, "\n✓ Claude Code integration installed")
-	fmt.Printf("  Settings: %s\n", settingsPath)
+	fmt.Fprintf(env.stdout, "  Settings: %s\n", settingsPath)
-	fmt.Println("\nRestart Claude Code for changes to take effect.")
+	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)
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
+		setupExit(1)
+		return
 	}
+	if err := checkClaude(env); err != nil {
+		setupExit(1)
+	}
+}
 
-	globalSettings := filepath.Join(home, ".claude/settings.json")
+func checkClaude(env claudeEnv) error {
-	projectSettings := ".claude/settings.local.json"
+	globalSettings := globalSettingsPath(env.homeDir)
+	projectSettings := projectSettingsPath(env.projectDir)
 
-	globalHooks := hasBeadsHooks(globalSettings)
+	switch {
-	projectHooks := hasBeadsHooks(projectSettings)
+	case hasBeadsHooks(globalSettings):
-
+		fmt.Fprintf(env.stdout, "✓ Global hooks installed: %s\n", globalSettings)
-	if globalHooks {
+		return nil
-		fmt.Println("✓ Global hooks installed:", globalSettings)
+	case hasBeadsHooks(projectSettings):
-	} else if projectHooks {
+		fmt.Fprintf(env.stdout, "✓ Project hooks installed: %s\n", projectSettings)
-		fmt.Println("✓ Project hooks installed:", projectSettings)
+		return nil
-	} else {
+	default:
-		fmt.Println("✗ No hooks installed")
+		fmt.Fprintln(env.stdout, "✗ No hooks installed")
-		fmt.Println("  Run: bd setup claude")
+		fmt.Fprintln(env.stdout, "  Run: bd setup claude")
-		os.Exit(1)
+		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"
+		settingsPath = projectSettingsPath(env.projectDir)
-		fmt.Println("Removing Claude hooks from project...")
+		fmt.Fprintln(env.stdout, "Removing Claude hooks from project...")
 	} else {
-		home, err := os.UserHomeDir()
+		settingsPath = globalSettingsPath(env.homeDir)
-		if err != nil {
+		fmt.Fprintln(env.stdout, "Removing Claude hooks globally...")
-			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...")
 	}
 
-	// Load settings
+	data, err := env.readFile(settingsPath)
-	data, err := os.ReadFile(settingsPath) // #nosec G304 -- settingsPath is constructed from user home dir, not user input
 	if err != nil {
-		fmt.Println("No settings file found")
+		fmt.Fprintln(env.stdout, "No settings file found")
-		return
+		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)
+		fmt.Fprintf(env.stderr, "Error: failed to parse settings.json: %v\n", err)
-		os.Exit(1)
+		return err
 	}
 
 	hooks, ok := settings["hooks"].(map[string]interface{})
 	if !ok {
-		fmt.Println("No hooks found")
+		fmt.Fprintln(env.stdout, "No hooks found")
-		return
+		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)
+		fmt.Fprintf(env.stderr, "Error: marshal settings: %v\n", err)
-		os.Exit(1)
+		return err
 	}
 
-	if err := atomicWriteFile(settingsPath, data); err != nil {
+	if err := env.writeFile(settingsPath, data); err != nil {
-		fmt.Fprintf(os.Stderr, "Error: write settings: %v\n", err)
+		fmt.Fprintf(env.stderr, "Error: write settings: %v\n", err)
-		os.Exit(1)
+		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

cmd/bd/setup/claude_test.go

@@ -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")
+		}
+	})
+}