test: add sandbox integration tests for Graphite driver

Build a fakegt test double (env-var-controlled) via TestMain and
prepend it to PATH, then test the Graphite driver end-to-end in
isolation without needing the real gt CLI or GitHub.

Tests cover: NewGraphite, CreateBranch (with real temp git repo),
Push (created/updated/existing PR paths), --title/--description/
--draft flag forwarding, Push failure, Rebase success, and Rebase
conflict detection.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: nvandessel

internal/driver/graphite_test.go

@@ -1,10 +1,94 @@
 package driver
 
 import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
 	"strings"
 	"testing"
 )
 
+// fakeBinDir holds the directory containing the built fakegt binary.
+// Set by TestMain before any tests run.
+var fakeBinDir string
+
+func TestMain(m *testing.M) {
+	// Build fakegt and prepend its directory to PATH so that
+	// exec.LookPath("gt") and runGT find our test double.
+	dir, err := os.MkdirTemp("", "fakegt-*")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "creating temp dir: %v\n", err)
+		os.Exit(1)
+	}
+	defer os.RemoveAll(dir)
+
+	gtBin := filepath.Join(dir, "gt")
+	cmd := exec.Command("go", "build", "-o", gtBin, "./testdata/fakegt")
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		fmt.Fprintf(os.Stderr, "building fakegt: %v\n", err)
+		os.Exit(1)
+	}
+
+	fakeBinDir = dir
+	os.Setenv("PATH", dir+":"+os.Getenv("PATH"))
+
+	os.Exit(m.Run())
+}
+
+// initGitRepo creates a temp git repo with an initial commit, chdir's into it,
+// and restores the original directory on cleanup. This is needed because the
+// git package operates on the current working directory.
+func initGitRepo(t *testing.T) (dir string, ctx context.Context) {
+	t.Helper()
+	dir = t.TempDir()
+	ctx = context.Background()
+
+	gitEnv := []string{
+		"GIT_AUTHOR_NAME=Test User",
+		"GIT_AUTHOR_EMAIL=test@example.com",
+		"GIT_COMMITTER_NAME=Test User",
+		"GIT_COMMITTER_EMAIL=test@example.com",
+		"GIT_CONFIG_NOSYSTEM=1",
+		"HOME=" + dir,
+	}
+
+	gitCmd := func(args ...string) {
+		t.Helper()
+		cmd := exec.Command("git", args...)
+		cmd.Dir = dir
+		cmd.Env = append(os.Environ(), gitEnv...)
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			t.Fatalf("setup git %s: %s\n%s", strings.Join(args, " "), err, out)
+		}
+	}
+
+	gitCmd("init", "-b", "main")
+	gitCmd("commit", "--allow-empty", "-m", "init")
+
+	origDir, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chdir(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = os.Chdir(origDir) })
+
+	for _, e := range gitEnv {
+		parts := strings.SplitN(e, "=", 2)
+		t.Setenv(parts[0], parts[1])
+	}
+
+	return dir, ctx
+}
+
+// --- Unit tests for parseSubmitResult ---
+
 func TestParseSubmitResult(t *testing.T) {
 	tests := []struct {
 		name        string
@@ -81,3 +165,208 @@ pp--06-14-part_3: https://app.graphite.com/github/pr/withgraphite/repo/102 (crea
 		})
 	}
 }
+
+// --- Integration tests using fakegt + temp git repos ---
+
+func TestNewGraphiteWithFakeGT(t *testing.T) {
+	// fakegt is on PATH via TestMain, so NewGraphite should succeed.
+	g, err := NewGraphite()
+	if err != nil {
+		t.Fatalf("NewGraphite() with fakegt on PATH: %v", err)
+	}
+	if g.Name() != "graphite" {
+		t.Errorf("Name() = %q, want %q", g.Name(), "graphite")
+	}
+}
+
+func TestGraphiteCreateBranch(t *testing.T) {
+	_, ctx := initGitRepo(t)
+
+	g := &Graphite{}
+
+	// CreateBranch checks out the parent (real git) then calls gt create (fakegt).
+	if err := g.CreateBranch(ctx, "my-feature", "main"); err != nil {
+		t.Fatalf("CreateBranch: %v", err)
+	}
+}
+
+func TestGraphitePush(t *testing.T) {
+	tests := []struct {
+		name        string
+		submitOut   string
+		branch      string
+		opts        PushOpts
+		wantPR      int
+		wantCreated bool
+		wantErr     string
+	}{
+		{
+			name:      "new PR created",
+			submitOut: "feat-a: https://app.graphite.com/github/pr/owner/repo/77 (created)",
+			branch:    "feat-a",
+			opts: PushOpts{
+				Branch: "feat-a",
+				Base:   "main",
+				Title:  "Add feature A",
+			},
+			wantPR:      77,
+			wantCreated: true,
+		},
+		{
+			name:      "existing PR updated by gt",
+			submitOut: "feat-b: https://app.graphite.com/github/pr/owner/repo/88 (updated)",
+			branch:    "feat-b",
+			opts: PushOpts{
+				Branch: "feat-b",
+				Base:   "main",
+			},
+			wantPR:      88,
+			wantCreated: false,
+		},
+		{
+			name:      "existing PR via ExistingPR field",
+			submitOut: "feat-c: https://app.graphite.com/github/pr/owner/repo/99 (updated)",
+			branch:    "feat-c",
+			opts: PushOpts{
+				Branch:     "feat-c",
+				Base:       "main",
+				ExistingPR: intPtr(55),
+			},
+			wantPR:      55,
+			wantCreated: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Setenv("FAKEGT_SUBMIT_OUTPUT", tt.submitOut)
+			ctx := context.Background()
+			g := &Graphite{}
+
+			result, err := g.Push(ctx, tt.opts)
+			if tt.wantErr != "" {
+				if err == nil {
+					t.Fatalf("expected error containing %q, got nil", tt.wantErr)
+				}
+				if !strings.Contains(err.Error(), tt.wantErr) {
+					t.Errorf("error = %q, want containing %q", err.Error(), tt.wantErr)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("Push: %v", err)
+			}
+			if result.PRNumber != tt.wantPR {
+				t.Errorf("PRNumber = %d, want %d", result.PRNumber, tt.wantPR)
+			}
+			if result.Created != tt.wantCreated {
+				t.Errorf("Created = %v, want %v", result.Created, tt.wantCreated)
+			}
+		})
+	}
+}
+
+func TestGraphitePushPassesBodyAndTitle(t *testing.T) {
+	// Verify that --title and --description flags are passed to gt submit.
+	recordFile := filepath.Join(t.TempDir(), "record.txt")
+	t.Setenv("FAKEGT_RECORD", recordFile)
+	t.Setenv("FAKEGT_SUBMIT_OUTPUT", "my-feat: https://app.graphite.com/github/pr/o/r/1 (created)")
+
+	ctx := context.Background()
+	g := &Graphite{}
+
+	_, err := g.Push(ctx, PushOpts{
+		Branch: "my-feat",
+		Base:   "main",
+		Title:  "My title",
+		Body:   "My description",
+	})
+	if err != nil {
+		t.Fatalf("Push: %v", err)
+	}
+
+	recorded, err := os.ReadFile(recordFile)
+	if err != nil {
+		t.Fatalf("reading record file: %v", err)
+	}
+	args := string(recorded)
+
+	if !strings.Contains(args, "--title My title") {
+		t.Errorf("expected --title in args, got: %s", args)
+	}
+	if !strings.Contains(args, "--description My description") {
+		t.Errorf("expected --description in args, got: %s", args)
+	}
+}
+
+func TestGraphitePushDraft(t *testing.T) {
+	recordFile := filepath.Join(t.TempDir(), "record.txt")
+	t.Setenv("FAKEGT_RECORD", recordFile)
+	t.Setenv("FAKEGT_SUBMIT_OUTPUT", "my-feat: https://app.graphite.com/github/pr/o/r/1 (created)")
+
+	ctx := context.Background()
+	g := &Graphite{}
+
+	_, err := g.Push(ctx, PushOpts{
+		Branch: "my-feat",
+		Base:   "main",
+		Title:  "Draft PR",
+		Draft:  true,
+	})
+	if err != nil {
+		t.Fatalf("Push: %v", err)
+	}
+
+	recorded, err := os.ReadFile(recordFile)
+	if err != nil {
+		t.Fatalf("reading record file: %v", err)
+	}
+	if !strings.Contains(string(recorded), "--draft") {
+		t.Errorf("expected --draft in args, got: %s", recorded)
+	}
+}
+
+func TestGraphitePushFailure(t *testing.T) {
+	t.Setenv("FAKEGT_FAIL", "1")
+	ctx := context.Background()
+	g := &Graphite{}
+
+	_, err := g.Push(ctx, PushOpts{Branch: "feat", Base: "main"})
+	if err == nil {
+		t.Fatal("expected error when gt submit fails")
+	}
+	if !strings.Contains(err.Error(), "gt submit") {
+		t.Errorf("error = %q, want containing 'gt submit'", err.Error())
+	}
+}
+
+func TestGraphiteRebase(t *testing.T) {
+	ctx := context.Background()
+	g := &Graphite{}
+
+	// Normal restack succeeds.
+	if err := g.Rebase(ctx, "main", "feature"); err != nil {
+		t.Fatalf("Rebase: %v", err)
+	}
+}
+
+func TestGraphiteRebaseConflict(t *testing.T) {
+	t.Setenv("FAKEGT_CONFLICT", "1")
+	ctx := context.Background()
+	g := &Graphite{}
+
+	err := g.Rebase(ctx, "main", "feature")
+	if err == nil {
+		t.Fatal("expected error on conflict")
+	}
+
+	var conflictErr *RebaseConflictError
+	if !errors.As(err, &conflictErr) {
+		t.Fatalf("expected RebaseConflictError, got %T: %v", err, err)
+	}
+	if !strings.Contains(conflictErr.Detail, "CONFLICT") {
+		t.Errorf("Detail = %q, want containing 'CONFLICT'", conflictErr.Detail)
+	}
+}
+
+func intPtr(n int) *int { return &n }

internal/driver/testdata/fakegt/main.go

@@ -0,0 +1,63 @@
+// Command fakegt is a test double for the Graphite CLI (gt).
+// Behavior is controlled via environment variables:
+//
+//   - FAKEGT_FAIL: if set, exit 1 with error message
+//   - FAKEGT_CONFLICT: if set, exit 1 with CONFLICT output (for restack)
+//   - FAKEGT_SUBMIT_OUTPUT: custom stdout for "submit" command
+//   - FAKEGT_RECORD: if set to a file path, append each invocation's args
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	args := os.Args[1:]
+
+	// Record invocations for test assertions.
+	if recordFile := os.Getenv("FAKEGT_RECORD"); recordFile != "" {
+		f, err := os.OpenFile(recordFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
+		if err == nil {
+			fmt.Fprintln(f, strings.Join(args, " "))
+			f.Close()
+		}
+	}
+
+	// Unconditional failure mode.
+	if os.Getenv("FAKEGT_FAIL") != "" {
+		fmt.Fprintln(os.Stderr, "fatal: something went wrong")
+		os.Exit(1)
+	}
+
+	if len(args) == 0 {
+		os.Exit(0)
+	}
+
+	switch args[0] {
+	case "create":
+		// gt create <name> — no output on success.
+	case "submit":
+		// Conflict mode for submit.
+		if os.Getenv("FAKEGT_CONFLICT") != "" {
+			fmt.Fprintln(os.Stderr, "CONFLICT (content): Merge conflict in file.go")
+			os.Exit(1)
+		}
+		// Custom output or default.
+		if out := os.Getenv("FAKEGT_SUBMIT_OUTPUT"); out != "" {
+			fmt.Println(out)
+		} else {
+			fmt.Println("default-branch: https://app.graphite.com/github/pr/owner/repo/1 (created)")
+		}
+	case "restack":
+		if os.Getenv("FAKEGT_CONFLICT") != "" {
+			fmt.Println("CONFLICT (content): Merge conflict in file.go")
+			fmt.Fprintln(os.Stderr, "could not apply abc1234... commit message")
+			os.Exit(1)
+		}
+		fmt.Println("Restacked")
+	default:
+		// Unknown commands succeed silently.
+	}
+}