test: add tests for GetDescendants, git methods, and log command

New tests:
- tree.GetDescendants and GetDescendantsEmpty
- git.GetTip, GetMergeBase, DeleteBranch, GetGitDir, NeedsRebase
- log command tree building (3 tests)

Total: 38 tests (was 27)

Author: boneskull

cmd/log_test.go

@@ -0,0 +1,109 @@
+// cmd/log_test.go
+package cmd_test
+
+import (
+	"testing"
+
+	"github.com/boneskull/gh-stack/internal/config"
+	"github.com/boneskull/gh-stack/internal/tree"
+)
+
+func TestLogBuildTree(t *testing.T) {
+	dir := setupTestRepo(t)
+
+	cfg, _ := config.Load(dir)
+	cfg.SetTrunk("main")
+	cfg.SetParent("feature-a", "main")
+	cfg.SetParent("feature-b", "feature-a")
+	cfg.SetPR("feature-a", 123)
+
+	root, err := tree.Build(cfg)
+	if err != nil {
+		t.Fatalf("Build failed: %v", err)
+	}
+
+	// Verify tree structure
+	if root.Name != "main" {
+		t.Errorf("expected root 'main', got %q", root.Name)
+	}
+	if len(root.Children) != 1 {
+		t.Fatalf("expected 1 child of main, got %d", len(root.Children))
+	}
+
+	featureA := root.Children[0]
+	if featureA.Name != "feature-a" {
+		t.Errorf("expected 'feature-a', got %q", featureA.Name)
+	}
+	if featureA.PR != 123 {
+		t.Errorf("expected PR 123, got %d", featureA.PR)
+	}
+	if len(featureA.Children) != 1 {
+		t.Fatalf("expected 1 child of feature-a, got %d", len(featureA.Children))
+	}
+
+	featureB := featureA.Children[0]
+	if featureB.Name != "feature-b" {
+		t.Errorf("expected 'feature-b', got %q", featureB.Name)
+	}
+}
+
+func TestLogEmptyStack(t *testing.T) {
+	dir := setupTestRepo(t)
+
+	cfg, _ := config.Load(dir)
+	cfg.SetTrunk("main")
+
+	// No branches tracked, just trunk
+	root, err := tree.Build(cfg)
+	if err != nil {
+		t.Fatalf("Build failed: %v", err)
+	}
+
+	if root.Name != "main" {
+		t.Errorf("expected root 'main', got %q", root.Name)
+	}
+	if len(root.Children) != 0 {
+		t.Errorf("expected 0 children for trunk-only stack, got %d", len(root.Children))
+	}
+}
+
+func TestLogMultipleBranches(t *testing.T) {
+	dir := setupTestRepo(t)
+
+	cfg, _ := config.Load(dir)
+	cfg.SetTrunk("main")
+	// Two branches off main
+	cfg.SetParent("feature-a", "main")
+	cfg.SetParent("feature-b", "main")
+	// One branch off feature-a
+	cfg.SetParent("feature-a-sub", "feature-a")
+
+	root, err := tree.Build(cfg)
+	if err != nil {
+		t.Fatalf("Build failed: %v", err)
+	}
+
+	if len(root.Children) != 2 {
+		t.Errorf("expected 2 children of main, got %d", len(root.Children))
+	}
+
+	// Find feature-a and check its children
+	var featureA *tree.Node
+	for _, child := range root.Children {
+		if child.Name == "feature-a" {
+			featureA = child
+			break
+		}
+	}
+
+	if featureA == nil {
+		t.Fatal("feature-a not found")
+	}
+
+	if len(featureA.Children) != 1 {
+		t.Errorf("expected 1 child of feature-a, got %d", len(featureA.Children))
+	}
+	if featureA.Children[0].Name != "feature-a-sub" {
+		t.Errorf("expected 'feature-a-sub', got %q", featureA.Children[0].Name)
+	}
+}

internal/git/git_test.go

@@ -147,3 +147,112 @@ func TestHasStagedChanges(t *testing.T) {
 		t.Error("expected staged changes after git add")
 	}
 }
+
+func TestGetTip(t *testing.T) {
+	dir := setupTestRepo(t)
+	g := git.New(dir)
+
+	current, _ := g.CurrentBranch()
+	tip, err := g.GetTip(current)
+	if err != nil {
+		t.Fatalf("GetTip failed: %v", err)
+	}
+
+	// Should be a 40-character hex SHA
+	if len(tip) != 40 {
+		t.Errorf("expected 40-char SHA, got %q (len %d)", tip, len(tip))
+	}
+}
+
+func TestGetMergeBase(t *testing.T) {
+	dir := setupTestRepo(t)
+	g := git.New(dir)
+
+	current, _ := g.CurrentBranch()
+
+	// Create a branch, make a commit on each
+	g.CreateBranch("feature")
+	originalTip, _ := g.GetTip(current)
+
+	// Commit on main
+	os.WriteFile(filepath.Join(dir, "main.txt"), []byte("main"), 0644)
+	exec.Command("git", "-C", dir, "add", ".").Run()
+	exec.Command("git", "-C", dir, "commit", "-m", "main commit").Run()
+
+	// Commit on feature
+	g.Checkout("feature")
+	os.WriteFile(filepath.Join(dir, "feature.txt"), []byte("feature"), 0644)
+	exec.Command("git", "-C", dir, "add", ".").Run()
+	exec.Command("git", "-C", dir, "commit", "-m", "feature commit").Run()
+
+	// Merge base should be the original tip
+	base, err := g.GetMergeBase(current, "feature")
+	if err != nil {
+		t.Fatalf("GetMergeBase failed: %v", err)
+	}
+	if base != originalTip {
+		t.Errorf("expected merge base %q, got %q", originalTip, base)
+	}
+}
+
+func TestDeleteBranch(t *testing.T) {
+	dir := setupTestRepo(t)
+	g := git.New(dir)
+
+	g.CreateBranch("to-delete")
+	if !g.BranchExists("to-delete") {
+		t.Fatal("branch should exist before deletion")
+	}
+
+	err := g.DeleteBranch("to-delete")
+	if err != nil {
+		t.Fatalf("DeleteBranch failed: %v", err)
+	}
+
+	if g.BranchExists("to-delete") {
+		t.Error("branch should not exist after deletion")
+	}
+}
+
+func TestGetGitDir(t *testing.T) {
+	dir := setupTestRepo(t)
+	g := git.New(dir)
+
+	gitDir := g.GetGitDir()
+	expected := filepath.Join(dir, ".git")
+	if gitDir != expected {
+		t.Errorf("expected %q, got %q", expected, gitDir)
+	}
+}
+
+func TestNeedsRebase(t *testing.T) {
+	dir := setupTestRepo(t)
+	g := git.New(dir)
+
+	current, _ := g.CurrentBranch()
+
+	// Create feature branch
+	g.CreateBranch("feature")
+
+	// Initially, feature doesn't need rebase (same commit)
+	needs, err := g.NeedsRebase("feature", current)
+	if err != nil {
+		t.Fatalf("NeedsRebase failed: %v", err)
+	}
+	if needs {
+		t.Error("feature should not need rebase initially")
+	}
+
+	// Add commit to main - now feature needs rebase
+	os.WriteFile(filepath.Join(dir, "new.txt"), []byte("new"), 0644)
+	exec.Command("git", "-C", dir, "add", ".").Run()
+	exec.Command("git", "-C", dir, "commit", "-m", "new commit").Run()
+
+	needs, err = g.NeedsRebase("feature", current)
+	if err != nil {
+		t.Fatalf("NeedsRebase failed: %v", err)
+	}
+	if !needs {
+		t.Error("feature should need rebase after main moved forward")
+	}
+}

internal/tree/tree_test.go

@@ -90,3 +90,47 @@ func TestGetAncestors(t *testing.T) {
 		t.Errorf("unexpected ancestors: %v", ancestors)
 	}
 }
+
+func TestGetDescendants(t *testing.T) {
+	cfg, _ := setupTestRepo(t)
+	cfg.SetTrunk("main")
+	cfg.SetParent("feature-a", "main")
+	cfg.SetParent("feature-b", "feature-a")
+	cfg.SetParent("feature-c", "feature-a")
+	cfg.SetParent("feature-d", "feature-b")
+
+	root, _ := tree.Build(cfg)
+	node := tree.FindNode(root, "feature-a")
+
+	descendants := tree.GetDescendants(node)
+
+	// Should get feature-b, feature-c, feature-d in depth-first order
+	if len(descendants) != 3 {
+		t.Fatalf("expected 3 descendants, got %d", len(descendants))
+	}
+
+	// Verify all expected descendants are present
+	names := make(map[string]bool)
+	for _, d := range descendants {
+		names[d.Name] = true
+	}
+	for _, expected := range []string{"feature-b", "feature-c", "feature-d"} {
+		if !names[expected] {
+			t.Errorf("missing descendant: %s", expected)
+		}
+	}
+}
+
+func TestGetDescendantsEmpty(t *testing.T) {
+	cfg, _ := setupTestRepo(t)
+	cfg.SetTrunk("main")
+	cfg.SetParent("feature-a", "main")
+
+	root, _ := tree.Build(cfg)
+	node := tree.FindNode(root, "feature-a")
+
+	descendants := tree.GetDescendants(node)
+	if len(descendants) != 0 {
+		t.Errorf("expected 0 descendants for leaf node, got %d", len(descendants))
+	}
+}