Rework tests and main.go

internal/gitw/gitw.go

@@ -7,8 +7,11 @@ import (
 	"strings"
 
 	"github.com/ldez/go-git-cmd-wrapper/v2/branch"
+	"github.com/ldez/go-git-cmd-wrapper/v2/checkout"
 	"github.com/ldez/go-git-cmd-wrapper/v2/config"
+	"github.com/ldez/go-git-cmd-wrapper/v2/fetch"
 	"github.com/ldez/go-git-cmd-wrapper/v2/git"
+	"github.com/ldez/go-git-cmd-wrapper/v2/merge"
 	"github.com/ldez/go-git-cmd-wrapper/v2/revparse"
 	"github.com/ldez/go-git-cmd-wrapper/v2/types"
 )
@@ -150,6 +153,73 @@ func IsGitDir() bool {
 	return err == nil
 }
 
+// Fetch fetches and prunes remote without touching tags.
+//
+// Tags are skipped because a force-moved tag makes fetch.pruneTags hard-fail.
+func Fetch(remote string) error {
+	// git fetch --prune --progress --no-tags --no-prune-tags <remote>
+	noPruneTags := func(g *types.Cmd) { g.AddOptions("--no-prune-tags") }
+	out, err := git.Fetch(fetch.Prune, fetch.Progress, fetch.NoTags, noPruneTags, fetch.Remote(remote))
+	if err != nil {
+		return errors.New(out)
+	}
+	return nil
+}
+
+// Upstream returns the full upstream ref of branch (like refs/remotes/origin/main).
+// It errors if the branch has no upstream, including when it was deleted on the remote.
+func Upstream(branch string) (string, error) {
+	// git rev-parse --symbolic-full-name <branch>@{upstream}
+	out, err := git.RevParse(revparse.SymbolicFullName, revparse.Args(branch+"@{upstream}"))
+	if err != nil {
+		return "", errors.New(out)
+	}
+	return strings.TrimSpace(out), nil
+}
+
+// FastForwardCurrent fast-forwards the checked out branch to ref.
+func FastForwardCurrent(ref string) error {
+	// git merge --ff-only --quiet <ref>
+	out, err := git.Merge(merge.FfOnly, merge.Quiet, merge.Commits(ref))
+	if err != nil {
+		return errors.New(out)
+	}
+	return nil
+}
+
+// UpdateRef points ref at target.
+func UpdateRef(ref, target string) error {
+	// git update-ref <ref> <target>
+	out, err := git.Raw("update-ref", func(g *types.Cmd) {
+		g.AddOptions(ref)
+		g.AddOptions(target)
+	})
+	if err != nil {
+		return errors.New(out)
+	}
+	return nil
+}
+
+// Checkout switches to the named branch.
+func Checkout(name string) error {
+	// git checkout --quiet <name>
+	out, err := git.Checkout(checkout.Quiet, checkout.Branch(name))
+	if err != nil {
+		return errors.New(out)
+	}
+	return nil
+}
+
+// DeleteBranch force-deletes the named local branch.
+func DeleteBranch(name string) error {
+	// git branch -D <name>
+	out, err := git.Branch(branch.DeleteForce, branch.BranchName(name))
+	if err != nil {
+		return errors.New(out)
+	}
+	return nil
+}
+
 func outputLines(output string) []string {
 	output = strings.TrimSuffix(output, "\n")
 	if output == "" {

internal/gitw/gitw_test.go

@@ -154,3 +154,207 @@ func TestNewRange_Identical(t *testing.T) {
 		t.Fatal("IsIdentical() = false, want true")
 	}
 }
+
+func TestFetch(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	peer := remote.Clone(t)
+	local.Chdir(t)
+
+	sha := peer.Commit(t, "upstream work")
+	peer.Push(t, "origin", "main")
+
+	if err := gitw.Fetch("origin"); err != nil {
+		t.Fatalf("Fetch() error: %v", err)
+	}
+	if got := local.Git(t, "rev-parse", "refs/remotes/origin/main"); got != sha {
+		t.Fatalf("origin/main = %q, want %q", got, sha)
+	}
+}
+
+func TestFetch_PrunesDeletedBranches(t *testing.T) {
+	remote := gittest.NewBare(t)
+	peer := remote.Clone(t)
+	peer.CreateBranch(t, "feature")
+	peer.Push(t, "origin", "feature")
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	peer.Push(t, "origin", "--delete", "feature")
+
+	if err := gitw.Fetch("origin"); err != nil {
+		t.Fatalf("Fetch() error: %v", err)
+	}
+	if got := local.Git(t, "for-each-ref", "refs/remotes/origin/feature"); got != "" {
+		t.Fatalf("refs/remotes/origin/feature still exists: %q", got)
+	}
+}
+
+func TestFetch_UnknownRemote(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	if err := gitw.Fetch("nope"); err == nil {
+		t.Fatal("Fetch() error = nil, want error for unknown remote")
+	}
+}
+
+func TestUpstream(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	got, err := gitw.Upstream("main")
+	if err != nil {
+		t.Fatalf("Upstream() error: %v", err)
+	}
+	if want := "refs/remotes/origin/main"; got != want {
+		t.Fatalf("Upstream() = %q, want %q", got, want)
+	}
+}
+
+func TestUpstream_NoUpstream(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	local.CreateBranch(t, "feature")
+
+	if got, err := gitw.Upstream("feature"); err == nil {
+		t.Fatalf("Upstream() = %q, want error for branch without upstream", got)
+	}
+}
+
+func TestFastForwardCurrent(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	peer := remote.Clone(t)
+	local.Chdir(t)
+
+	sha := peer.Commit(t, "upstream work")
+	peer.Push(t, "origin", "main")
+	local.Git(t, "fetch", "origin")
+
+	if err := gitw.FastForwardCurrent("refs/remotes/origin/main"); err != nil {
+		t.Fatalf("FastForwardCurrent() error: %v", err)
+	}
+	if got := local.Git(t, "rev-parse", "HEAD"); got != sha {
+		t.Fatalf("HEAD = %q, want %q", got, sha)
+	}
+}
+
+func TestFastForwardCurrent_Diverged(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	peer := remote.Clone(t)
+	local.Chdir(t)
+
+	peer.Commit(t, "upstream work")
+	peer.Push(t, "origin", "main")
+	local.Git(t, "fetch", "origin")
+	sha := local.Commit(t, "local work")
+
+	if err := gitw.FastForwardCurrent("refs/remotes/origin/main"); err == nil {
+		t.Fatal("FastForwardCurrent() error = nil, want error for diverged branch")
+	}
+	if got := local.Git(t, "rev-parse", "HEAD"); got != sha {
+		t.Fatalf("HEAD = %q, want unchanged %q", got, sha)
+	}
+}
+
+func TestUpdateRef(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	local.CreateBranch(t, "feature")
+	local.Checkout(t, "feature")
+	sha := local.Commit(t, "feature work")
+	local.Checkout(t, "main")
+
+	if err := gitw.UpdateRef("refs/heads/main", "refs/heads/feature"); err != nil {
+		t.Fatalf("UpdateRef() error: %v", err)
+	}
+	if got := local.Git(t, "rev-parse", "refs/heads/main"); got != sha {
+		t.Fatalf("main = %q, want %q", got, sha)
+	}
+}
+
+func TestUpdateRef_UnknownTarget(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	if err := gitw.UpdateRef("refs/heads/main", "refs/heads/does-not-exist"); err == nil {
+		t.Fatal("UpdateRef() error = nil, want error for unknown target")
+	}
+}
+
+func TestCheckout(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	local.CreateBranch(t, "feature")
+
+	if err := gitw.Checkout("feature"); err != nil {
+		t.Fatalf("Checkout() error: %v", err)
+	}
+	if got := local.Git(t, "rev-parse", "--abbrev-ref", "HEAD"); got != "feature" {
+		t.Fatalf("HEAD = %q, want %q", got, "feature")
+	}
+}
+
+func TestCheckout_UnknownBranch(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	if err := gitw.Checkout("does-not-exist"); err == nil {
+		t.Fatal("Checkout() error = nil, want error for unknown branch")
+	}
+}
+
+func TestDeleteBranch(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	local.CreateBranch(t, "feature")
+
+	if err := gitw.DeleteBranch("feature"); err != nil {
+		t.Fatalf("DeleteBranch() error: %v", err)
+	}
+	if got := local.Git(t, "for-each-ref", "refs/heads/feature"); got != "" {
+		t.Fatalf("refs/heads/feature still exists: %q", got)
+	}
+}
+
+func TestDeleteBranch_Unmerged(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	local.CreateBranch(t, "feature")
+	local.Checkout(t, "feature")
+	local.Commit(t, "unmerged work")
+	local.Checkout(t, "main")
+
+	if err := gitw.DeleteBranch("feature"); err != nil {
+		t.Fatalf("DeleteBranch() error: %v", err)
+	}
+	if got := local.Git(t, "for-each-ref", "refs/heads/feature"); got != "" {
+		t.Fatalf("refs/heads/feature still exists: %q", got)
+	}
+}
+
+func TestDeleteBranch_Current(t *testing.T) {
+	remote := gittest.NewBare(t)
+	local := remote.Clone(t)
+	local.Chdir(t)
+
+	if err := gitw.DeleteBranch("main"); err == nil {
+		t.Fatal("DeleteBranch() error = nil, want error for the checked out branch")
+	}
+}