Improve test coverage from ~85% to ~93% across all packages (#32)

Author: 8bitAlex

src/cmd/doctor/doctor_test.go

@@ -1,9 +1,12 @@
 package doctor
 
 import (
+	"bytes"
+	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/8bitalex/raid/src/internal/lib"
@@ -64,3 +67,188 @@ func TestCommand_isConfigured(t *testing.T) {
 		t.Error("Command.Run is nil")
 	}
 }
+
+// TestRunDoctor_allOK exercises the code path where every finding is SeverityOK,
+// which prints "No issues found." and exits normally (no os.Exit).
+func TestRunDoctor_allOK(t *testing.T) {
+	dir := t.TempDir()
+	old := lib.CfgPath
+	t.Cleanup(func() {
+		lib.CfgPath = old
+		lib.ResetContext()
+		viper.Reset()
+	})
+	lib.CfgPath = filepath.Join(dir, "config.toml")
+	lib.ResetContext()
+	if err := lib.InitConfig(); err != nil {
+		t.Fatalf("InitConfig: %v", err)
+	}
+
+	// Create a valid profile with a repo pointing to an existing directory
+	// (so the doctor doesn't report any warnings or errors).
+	repoDir := t.TempDir()
+	// Make it look like a git repo by creating .git dir
+	if err := os.MkdirAll(filepath.Join(repoDir, ".git"), 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	profilePath := filepath.Join(dir, "ok.raid.yaml")
+	content := fmt.Sprintf("name: ok\nrepositories:\n  - name: repo1\n    url: https://example.com/repo.git\n    path: %s\n", repoDir)
+	if err := os.WriteFile(profilePath, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := lib.AddProfile(lib.Profile{Name: "ok", Path: profilePath}); err != nil {
+		t.Fatal(err)
+	}
+	if err := lib.SetProfile("ok"); err != nil {
+		t.Fatal(err)
+	}
+	if err := lib.ForceLoad(); err != nil {
+		t.Fatalf("ForceLoad: %v", err)
+	}
+
+	// Capture stdout (runDoctor uses fmt.Printf → os.Stdout)
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	oldStdout := os.Stdout
+	os.Stdout = w
+
+	cmd := &cobra.Command{}
+	runDoctor(cmd, nil)
+
+	w.Close()
+	os.Stdout = oldStdout
+
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	got := buf.String()
+
+	if !strings.Contains(got, "[ok]") {
+		t.Errorf("runDoctor allOK: expected '[ok]' in output, got %q", got)
+	}
+	if !strings.Contains(got, "No issues found") {
+		t.Errorf("runDoctor allOK: expected 'No issues found', got %q", got)
+	}
+}
+
+// TestRunDoctor_warningsOnly exercises the path where warnings exist but no errors,
+// which prints the warning count and does NOT call os.Exit.
+func TestRunDoctor_warningsOnly(t *testing.T) {
+	dir := t.TempDir()
+	old := lib.CfgPath
+	t.Cleanup(func() {
+		lib.CfgPath = old
+		lib.ResetContext()
+		viper.Reset()
+	})
+	lib.CfgPath = filepath.Join(dir, "config.toml")
+	lib.ResetContext()
+	if err := lib.InitConfig(); err != nil {
+		t.Fatalf("InitConfig: %v", err)
+	}
+
+	// Create a profile with repos pointing to non-existent paths.
+	// Doctor will report: git OK, profile OK, profile file OK, schema OK,
+	// but repos not cloned → Warn findings only.
+	profilePath := filepath.Join(dir, "warn.raid.yaml")
+	content := "name: warn\nrepositories:\n  - name: missing-repo\n    url: https://example.com/repo.git\n    path: /tmp/nonexistent-path-raid-test-12345\n"
+	if err := os.WriteFile(profilePath, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := lib.AddProfile(lib.Profile{Name: "warn", Path: profilePath}); err != nil {
+		t.Fatal(err)
+	}
+	if err := lib.SetProfile("warn"); err != nil {
+		t.Fatal(err)
+	}
+	if err := lib.ForceLoad(); err != nil {
+		t.Fatalf("ForceLoad: %v", err)
+	}
+
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	oldStdout := os.Stdout
+	os.Stdout = w
+
+	cmd := &cobra.Command{}
+	runDoctor(cmd, nil)
+
+	w.Close()
+	os.Stdout = oldStdout
+
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	got := buf.String()
+
+	if !strings.Contains(got, "[warn]") {
+		t.Errorf("runDoctor warnings: expected '[warn]' in output, got %q", got)
+	}
+	if !strings.Contains(got, "warning(s)") {
+		t.Errorf("runDoctor warnings: expected 'warning(s)' in output, got %q", got)
+	}
+	// Should show the suggestion arrow
+	if !strings.Contains(got, "→") {
+		t.Errorf("runDoctor warnings: expected suggestion arrow '→' in output, got %q", got)
+	}
+}
+
+// TestRunDoctor_noReposWarning tests the path where the profile has no repositories
+// configured, which produces a warning finding.
+func TestRunDoctor_noReposWarning(t *testing.T) {
+	dir := t.TempDir()
+	old := lib.CfgPath
+	t.Cleanup(func() {
+		lib.CfgPath = old
+		lib.ResetContext()
+		viper.Reset()
+	})
+	lib.CfgPath = filepath.Join(dir, "config.toml")
+	lib.ResetContext()
+	if err := lib.InitConfig(); err != nil {
+		t.Fatalf("InitConfig: %v", err)
+	}
+
+	profilePath := filepath.Join(dir, "norepo.raid.yaml")
+	if err := os.WriteFile(profilePath, []byte("name: norepo\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if err := lib.AddProfile(lib.Profile{Name: "norepo", Path: profilePath}); err != nil {
+		t.Fatal(err)
+	}
+	if err := lib.SetProfile("norepo"); err != nil {
+		t.Fatal(err)
+	}
+	if err := lib.ForceLoad(); err != nil {
+		t.Fatalf("ForceLoad: %v", err)
+	}
+
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	oldStdout := os.Stdout
+	os.Stdout = w
+
+	cmd := &cobra.Command{}
+	runDoctor(cmd, nil)
+
+	w.Close()
+	os.Stdout = oldStdout
+
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	got := buf.String()
+
+	if !strings.Contains(got, "[warn]") {
+		t.Errorf("runDoctor no repos: expected '[warn]' in output, got %q", got)
+	}
+	if !strings.Contains(got, "none configured") {
+		t.Errorf("runDoctor no repos: expected 'none configured' in output, got %q", got)
+	}
+}

src/cmd/env/env_test.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 
@@ -222,3 +223,124 @@ func TestListEnvCmd_withEnvironments(t *testing.T) {
 		t.Errorf("ListEnvCmd with envs: got %q, want 'staging'", got)
 	}
 }
+
+func TestCommand_envFound_fullSuccess(t *testing.T) {
+	setupConfigWithEnv(t, "success-profile", "prod")
+
+	var buf bytes.Buffer
+	fakeCmd := &cobra.Command{}
+	fakeCmd.SetOut(&buf)
+	fakeCmd.SetErr(&buf)
+	Command.Run(fakeCmd, []string{"prod"})
+
+	got := buf.String()
+	if !strings.Contains(got, "Environment executed successfully") {
+		t.Errorf("Command env success: got %q, want 'Environment executed successfully'", got)
+	}
+}
+
+func TestCommand_envFound_forceLoadError(t *testing.T) {
+	setupConfigWithEnv(t, "exec-err-profile", "failing")
+
+	// Delete the profile file so that ForceLoad (which re-reads it) fails,
+	// while the cached context still has the env for Contains to succeed.
+	profilePath := lib.GetProfile().Path
+	if err := os.Remove(profilePath); err != nil {
+		t.Fatalf("remove profile file: %v", err)
+	}
+
+	var buf bytes.Buffer
+	fakeCmd := &cobra.Command{}
+	fakeCmd.SetOut(&buf)
+	fakeCmd.SetErr(&buf)
+	Command.Run(fakeCmd, []string{"failing"})
+
+	got := buf.String()
+	if !strings.Contains(got, "Failed to reload profile") {
+		t.Errorf("Command env forceLoad error: got %q, want 'Failed to reload profile'", got)
+	}
+}
+
+// TestCommand_envFound_setError covers the env.Set error path by calling
+// with an env name that doesn't exist in the config but passes Contains
+// via a direct context manipulation.
+func TestCommand_envFound_executeError(t *testing.T) {
+	// Set up an env with a task that will fail.
+	repoRoot := repoRootForEnv(t)
+
+	dir := t.TempDir()
+	old := lib.CfgPath
+	t.Cleanup(func() {
+		lib.CfgPath = old
+		lib.ResetContext()
+		viper.Reset()
+	})
+	lib.CfgPath = filepath.Join(dir, "config.toml")
+	lib.ResetContext()
+	if err := lib.InitConfig(); err != nil {
+		t.Fatalf("InitConfig: %v", err)
+	}
+
+	// Profile with env that has a failing task.
+	profilePath := filepath.Join(dir, "failenv.raid.yaml")
+	content := "name: failenv\nenvironments:\n  - name: badenv\n    tasks:\n      - type: Shell\n        cmd: exit 1\n"
+	if err := os.WriteFile(profilePath, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if err := lib.AddProfile(lib.Profile{Name: "failenv", Path: profilePath}); err != nil {
+		t.Fatal(err)
+	}
+	if err := lib.SetProfile("failenv"); err != nil {
+		t.Fatal(err)
+	}
+
+	wd, _ := os.Getwd()
+	if err := os.Chdir(repoRoot); err != nil {
+		t.Fatalf("chdir: %v", err)
+	}
+	t.Cleanup(func() { os.Chdir(wd) })
+
+	if err := lib.ForceLoad(); err != nil {
+		t.Fatalf("ForceLoad: %v", err)
+	}
+
+	var buf bytes.Buffer
+	fakeCmd := &cobra.Command{}
+	fakeCmd.SetOut(&buf)
+	fakeCmd.SetErr(&buf)
+	Command.Run(fakeCmd, []string{"badenv"})
+
+	got := buf.String()
+	if !strings.Contains(got, "Failed to execute environment") {
+		t.Errorf("Command env execute error: got %q, want 'Failed to execute environment'", got)
+	}
+}
+
+// TestCommand_envSetError covers the env.Set error path by making the config
+// file read-only after setup so viper.WriteConfig fails.
+func TestCommand_envSetError(t *testing.T) {
+	if os.Getuid() == 0 {
+		t.Skip("file permissions not enforced as root")
+	}
+	if runtime.GOOS == "windows" {
+		t.Skip("chmod file permissions behave differently on Windows")
+	}
+	setupConfigWithEnv(t, "setfail-profile", "dev")
+
+	// Make the config file read-only so Set (which calls viper.WriteConfig) fails.
+	if err := os.Chmod(lib.CfgPath, 0444); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { os.Chmod(lib.CfgPath, 0644) })
+
+	var buf bytes.Buffer
+	fakeCmd := &cobra.Command{}
+	fakeCmd.SetOut(&buf)
+	fakeCmd.SetErr(&buf)
+	Command.Run(fakeCmd, []string{"dev"})
+
+	got := buf.String()
+	if !strings.Contains(got, "Failed to switch environment") {
+		t.Errorf("Command env setError: got %q, want 'Failed to switch environment'", got)
+	}
+}