package git

import (

"bytes"

"context"

"fmt"

"net/url"

"os"

"os/exec"

"path/filepath"

"strconv"

"strings"

"testing"

"github.com/MakeNowJust/heredoc"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

)

func TestClientCommand(t *testing.T) {

tests := []struct {

name string

repoDir string

gitPath string

wantExe string

wantArgs []string

}{

{

name: "creates command",

gitPath: "path/to/git",

wantExe: "path/to/git",

wantArgs: []string{"path/to/git", "ref-log"},

},

{

name: "adds repo directory configuration",

repoDir: "path/to/repo",

gitPath: "path/to/git",

wantExe: "path/to/git",

wantArgs: []string{"path/to/git", "-C", "path/to/repo", "ref-log"},

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

// Given a client with explicit executable, streams, and repository context

in, out, errOut := &bytes.Buffer{}, &bytes.Buffer{}, &bytes.Buffer{}

client := Client{

Stdin: in,

Stdout: out,

Stderr: errOut,

RepoDir: tt.repoDir,

GitPath: tt.gitPath,

}

// When a Git command is created

cmd, err := client.Command(t.Context(), "ref-log")

// Then the executable, repository arguments, and streams are wired

require.NoError(t, err)

assert.Equal(t, tt.wantExe, cmd.Path)

assert.Equal(t, tt.wantArgs, cmd.Args)

assert.Same(t, in, cmd.Stdin)

assert.Same(t, out, cmd.Stdout)

assert.Same(t, errOut, cmd.Stderr)

})

}

}

func TestClientAuthenticatedCommandScopesCredentialHelperToAllHosts(t *testing.T) {

// Given a client with an explicit gh executable

client := Client{

GhPath: "path/to/gh",

GitPath: "path/to/git",

}

// When an authenticated command is created for all hosts

cmd, err := client.AuthenticatedCommand(t.Context(), AllMatchingCredentialsPattern, "fetch")

// Then existing helpers are cleared and gh receives credentials for every host

require.NoError(t, err)

assert.Equal(t, []string{"path/to/git", "-c", "credential.helper=", "-c", `credential.helper=!"path/to/gh" auth git-credential`, "fetch"}, cmd.Args)

}

func TestClientAuthenticatedCommandScopesCredentialHelperToPattern(t *testing.T) {

// Given a client with an explicit gh executable

client := Client{

GhPath: "path/to/gh",

GitPath: "path/to/git",

}

// When an authenticated command is created for one credential pattern

cmd, err := client.AuthenticatedCommand(t.Context(), CredentialPattern{pattern: "https://github.com"}, "fetch")

// Then existing helpers are cleared and gh receives credentials only for that pattern

require.NoError(t, err)

assert.Equal(t, []string{"path/to/git", "-c", "credential.https://github.com.helper=", "-c", `credential.https://github.com.helper=!"path/to/gh" auth git-credential`, "fetch"}, cmd.Args)

}

func TestClientAuthenticatedCommandDefaultsToGhOnPath(t *testing.T) {

// Given a client without an explicit gh executable

client := Client{GitPath: "path/to/git"}

// When an authenticated command is created

cmd, err := client.AuthenticatedCommand(t.Context(), AllMatchingCredentialsPattern, "fetch")

// Then gh is resolved from PATH by the credential helper

require.NoError(t, err)

assert.Equal(t, []string{"path/to/git", "-c", "credential.helper=", "-c", `credential.helper=!"gh" auth git-credential`, "fetch"}, cmd.Args)

}

func TestClientAuthenticatedCommandRejectsEmptyCredentialPattern(t *testing.T) {

// Given a client and an empty host-scoped credential pattern

client := Client{GitPath: "path/to/git"}

// When an authenticated command is created

cmd, err := client.AuthenticatedCommand(t.Context(), CredentialPattern{}, "fetch")

// Then the insecure ambiguous scope is rejected

require.EqualError(t, err, "empty credential pattern is not allowed unless provided explicitly")

assert.Nil(t, cmd)

}

func TestClientRemotesReturnsSortedRemotesWithResolutions(t *testing.T) {

// Given remotes with resolution metadata

repo := newTestRepo(t)

repo.run(t, "remote", "add", "origin", "git@example.com:monalisa/origin.git")

repo.run(t, "remote", "add", "test", "git://github.com/hubot/test.git")

repo.run(t, "remote", "add", "upstream", "https://github.com/monalisa/upstream.git")

repo.run(t, "remote", "add", "github", "git@github.com:hubot/github.git")

repo.run(t, "config", "remote.test.gh-resolved", "other")

repo.run(t, "config", "remote.upstream.gh-resolved", "base")

// When the remotes are listed

remotes, err := repo.client.Remotes(t.Context())

// Then preferred names are sorted first and resolutions are associated by name

require.NoError(t, err)

require.Len(t, remotes, 4)

assert.Equal(t, "upstream", remotes[0].Name)

assert.Equal(t, "base", remotes[0].Resolved)

assert.Equal(t, "github", remotes[1].Name)

assert.Empty(t, remotes[1].Resolved)

assert.Equal(t, "origin", remotes[2].Name)

assert.Empty(t, remotes[2].Resolved)

assert.Equal(t, "test", remotes[3].Name)

assert.Equal(t, "other", remotes[3].Resolved)

}

func TestClientRemotesToleratesMissingResolutionConfig(t *testing.T) {

// Given a remote without resolution metadata

repo := newTestRepo(t)

repo.run(t, "remote", "add", "origin", "git@example.com:monalisa/origin.git")

// When the remotes are listed

remotes, err := repo.client.Remotes(t.Context())

// Then Git's no-matching-config status is treated as an empty resolution

require.NoError(t, err)

require.Len(t, remotes, 1)

assert.Equal(t, "origin", remotes[0].Name)

assert.Empty(t, remotes[0].Resolved)

}

func TestParseRemotes(t *testing.T) {

// Given remote output with fetch-only, push-only, paired, and mixed URL forms

remoteList := []string{

"mona\tgit@github.com:monalisa/myfork.git (fetch)",

"origin\thttps://github.com/monalisa/octo-cat.git (fetch)",

"origin\thttps://github.com/monalisa/octo-cat-push.git (push)",

"upstream\thttps://example.com/nowhere.git (fetch)",

"upstream\thttps://github.com/hubot/tools (push)",

"zardoz\thttps://example.com/zed.git (push)",

"koke\tgit://github.com/koke/grit.git (fetch)",

"koke\tgit://github.com/koke/grit.git (push)",

}

// When the output is parsed

remotes := parseRemotes(remoteList)

// Then each URL is associated with its named remote and direction

require.Len(t, remotes, 5)

assert.Equal(t, "mona", remotes[0].Name)

assert.Equal(t, "ssh://git@github.com/monalisa/myfork.git", remotes[0].FetchURL.String())

assert.Nil(t, remotes[0].PushURL)

assert.Equal(t, "origin", remotes[1].Name)

assert.Equal(t, "/monalisa/octo-cat.git", remotes[1].FetchURL.Path)

assert.Equal(t, "/monalisa/octo-cat-push.git", remotes[1].PushURL.Path)

assert.Equal(t, "upstream", remotes[2].Name)

assert.Equal(t, "example.com", remotes[2].FetchURL.Host)

assert.Equal(t, "github.com", remotes[2].PushURL.Host)

assert.Equal(t, "zardoz", remotes[3].Name)

assert.Nil(t, remotes[3].FetchURL)

assert.Equal(t, "https://example.com/zed.git", remotes[3].PushURL.String())

assert.Equal(t, "koke", remotes[4].Name)

assert.Equal(t, "/koke/grit.git", remotes[4].FetchURL.Path)

assert.Equal(t, "/koke/grit.git", remotes[4].PushURL.Path)

}

func TestClientUpdateRemoteURLUpdatesConfiguredRemote(t *testing.T) {

// Given a repository with a local remote

repo := newTestRepo(t)

original := newBareTestRepo(t)

replacement := newBareTestRepo(t)

repo.run(t, "remote", "add", "test", original.fileURL())

// When the remote URL is updated

err := repo.client.UpdateRemoteURL(t.Context(), "test", replacement.fileURL())

// Then Git stores the replacement URL

require.NoError(t, err)

assert.Equal(t, replacement.fileURL(), repo.run(t, "remote", "get-url", "test"))

}

func TestClientUpdateRemoteURLReportsMissingRemote(t *testing.T) {

// Given a repository without the named remote

repo := newTestRepo(t)

// When the remote URL is updated

err := repo.client.UpdateRemoteURL(t.Context(), "missing", newBareTestRepo(t).fileURL())

// Then Git reports a semantic command failure

require.Error(t, err)

var gitErr *GitError

require.ErrorAs(t, err, &gitErr)

assert.NotZero(t, gitErr.ExitCode)

}

func TestClientSetRemoteResolutionAddsResolution(t *testing.T) {

// Given a repository with an existing remote resolution

repo := newTestRepo(t)

repo.run(t, "config", "--add", "remote.origin.gh-resolved", "base")

// When another resolution is set

err := repo.client.SetRemoteResolution(t.Context(), "origin", "other")

// Then both resolutions are stored

require.NoError(t, err)

assert.Equal(t, "base\nother", repo.run(t, "config", "--get-all", "remote.origin.gh-resolved"))

}

func TestClientSetRemoteResolutionPropagatesGitError(t *testing.T) {

// Given a client whose repository directory does not exist

client := Client{RepoDir: filepath.Join(t.TempDir(), "missing")}

// When a remote resolution is set

err := client.SetRemoteResolution(t.Context(), "origin", "base")

// Then the Git error is returned

require.Error(t, err)

var gitErr *GitError

require.ErrorAs(t, err, &gitErr)

assert.NotZero(t, gitErr.ExitCode)

}

func TestClientCurrentBranchReturnsCurrentBranch(t *testing.T) {

// Given a repository checked out on a branch containing non-breaking spaces

repo := newTestRepo(t)

branchName := "branch\u00A0with\u00A0non\u00A0breaking\u00A0space"

repo.run(t, "checkout", "--quiet", "-b", branchName)

// When the current branch is requested

branch, err := repo.client.CurrentBranch(t.Context())

// Then the complete branch name is returned

require.NoError(t, err)

assert.Equal(t, branchName, branch)

}

func TestClientCurrentBranchReportsDetachedHead(t *testing.T) {

// Given a repository with a detached HEAD

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

repo.run(t, "checkout", "--quiet", "--detach")

// When the current branch is requested

branch, err := repo.client.CurrentBranch(t.Context())

// Then the detached HEAD error is returned

require.Error(t, err)

assert.ErrorIs(t, err, ErrNotOnAnyBranch)

assert.Empty(t, branch)

}

func TestClientShowRefsReturnsExistingRefsAlongsideMissingRefError(t *testing.T) {

// Given a repository with one requested branch and one missing branch

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

wantHash := repo.run(t, "rev-parse", "HEAD")

// When both refs are resolved

refs, err := repo.client.ShowRefs(t.Context(), []string{"refs/heads/trunk", "refs/heads/missing"})

// Then the existing ref and the semantic Git error are both returned

require.Error(t, err)

var gitError *GitError

require.ErrorAs(t, err, &gitError)

assert.NotZero(t, gitError.ExitCode)

assert.Equal(t, []Ref{{Hash: wantHash, Name: "refs/heads/trunk"}}, refs)

}

func TestClientShowRefsSeparatesRefsFromOptions(t *testing.T) {

// Given a repository with one branch

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

wantHash := repo.run(t, "rev-parse", "HEAD")

// When the branch and an option-like ref are resolved

refs, err := repo.client.ShowRefs(t.Context(), []string{"refs/heads/trunk", "--quiet"})

// Then an option separator protects the refs, so the branch resolves and the option-like ref is rejected

require.Error(t, err)

var gitError *GitError

require.ErrorAs(t, err, &gitError)

assert.NotZero(t, gitError.ExitCode)

assert.Equal(t, []Ref{{Hash: wantHash, Name: "refs/heads/trunk"}}, refs)

}

func TestClientConfigReturnsConfiguredValue(t *testing.T) {

// Given a repository with a configured credential helper

repo := newTestRepo(t)

repo.run(t, "config", "credential.helper", "test")

// When the configuration is read

value, err := repo.client.Config(t.Context(), "credential.helper")

// Then the configured value is returned

require.NoError(t, err)

assert.Equal(t, "test", value)

}

func TestClientConfigReportsUnknownKey(t *testing.T) {

// Given a repository without a credential helper

repo := newTestRepo(t)

// When the missing configuration is read

value, err := repo.client.Config(t.Context(), "credential.helper")

// Then the missing key is identified

require.Error(t, err)

assert.EqualError(t, err, "failed to run git: unknown config key credential.helper")

assert.Empty(t, value)

}

func TestClientConfigPropagatesGitError(t *testing.T) {

// Given a client whose repository directory does not exist

client := Client{RepoDir: filepath.Join(t.TempDir(), "missing")}

// When configuration is read

value, err := client.Config(t.Context(), "credential.helper")

// Then the Git error is returned unchanged

require.Error(t, err)

var gitErr *GitError

require.ErrorAs(t, err, &gitErr)

assert.NotZero(t, gitErr.ExitCode)

assert.Contains(t, gitErr.Stderr, client.RepoDir)

assert.Empty(t, value)

}

func TestClientUncommittedChangeCountReturnsZeroForCleanRepository(t *testing.T) {

// Given a clean repository

repo := newTestRepo(t)

// When uncommitted changes are counted

count, err := repo.client.UncommittedChangeCount(t.Context())

// Then no changes are reported

require.NoError(t, err)

assert.Equal(t, 0, count)

}

func TestClientUncommittedChangeCountIncludesTrackedAndUntrackedFiles(t *testing.T) {

// Given a repository with one modified file and one untracked file

repo := newTestRepo(t)

trackedFile := filepath.Join(repo.dir, "tracked.txt")

require.NoError(t, os.WriteFile(trackedFile, []byte("tracked\n"), 0600))

repo.run(t, "add", "tracked.txt")

repo.run(t, "commit", "--quiet", "-m", "add tracked file")

require.NoError(t, os.WriteFile(trackedFile, []byte("modified\n"), 0600))

require.NoError(t, os.WriteFile(filepath.Join(repo.dir, "untracked.txt"), []byte("untracked\n"), 0600))

// When uncommitted changes are counted

count, err := repo.client.UncommittedChangeCount(t.Context())

// Then both changes are reported

require.NoError(t, err)

assert.Equal(t, 2, count)

}

func TestClientCommitsReturnsCommitMetadata(t *testing.T) {

// Given a branch with commits containing empty and multiline bodies

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "base")

baseRef := repo.run(t, "rev-parse", "HEAD")

repo.run(t, "checkout", "--quiet", "-b", "feature")

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "first commit")

firstSHA := repo.run(t, "rev-parse", "HEAD")

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "second commit", "-m", "first line\nsecond line")

secondSHA := repo.run(t, "rev-parse", "HEAD")

// When commits unique to the feature branch are requested

commits, err := repo.client.Commits(t.Context(), baseRef, "feature")

// Then each commit's repository metadata is returned newest first

require.NoError(t, err)

assert.Equal(t, []*Commit{

{Sha: secondSHA, Title: "second commit", Body: "first line\nsecond line\n"},

{Sha: firstSHA, Title: "first commit"},

}, commits)

}

func TestClientCommitsReportsNoCommitsBetweenRefs(t *testing.T) {

// Given two refs that identify the same commit

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

// When commits between the refs are requested

commits, err := repo.client.Commits(t.Context(), "trunk", "trunk")

// Then the empty comparison is reported

require.EqualError(t, err, "could not find any commits between trunk and trunk")

assert.Nil(t, commits)

}

func TestClientCommitsExcludesBaseSideCommits(t *testing.T) {

// Given divergent branches with patch-equivalent commits and one unique feature commit

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

repo.run(t, "checkout", "--quiet", "-b", "feature")

require.NoError(t, os.WriteFile(filepath.Join(repo.dir, "shared.txt"), []byte("shared\n"), 0600))

repo.run(t, "add", "shared.txt")

t.Setenv("GIT_COMMITTER_DATE", "2000-01-01T00:00:00Z")

repo.run(t, "commit", "--quiet", "-m", "feature shared change")

sharedCommit := repo.run(t, "rev-parse", "HEAD")

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "feature-only commit")

uniqueCommit := repo.run(t, "rev-parse", "HEAD")

repo.run(t, "checkout", "--quiet", "trunk")

// A different committer date gives the cherry-picked commit a distinct hash.

t.Setenv("GIT_COMMITTER_DATE", "2001-01-01T00:00:00Z")

repo.run(t, "cherry-pick", sharedCommit)

// When commits unique to the feature branch are requested

commits, err := repo.client.Commits(t.Context(), "trunk", "feature")

// Then only the feature side of the symmetric difference is returned

require.NoError(t, err)

assert.Equal(t, []*Commit{

{Sha: uniqueCommit, Title: "feature-only commit"},

{Sha: sharedCommit, Title: "feature shared change"},

}, commits)

}

func TestClientCommitsReturnsOnlyOrdinaryFeatureSideCommits(t *testing.T) {

// Given a feature branch that merges a side branch

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

repo.run(t, "checkout", "--quiet", "-b", "feature")

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "feature work")

featureSHA := repo.run(t, "rev-parse", "HEAD")

repo.run(t, "checkout", "--quiet", "-b", "side", "trunk")

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "side work")

sideSHA := repo.run(t, "rev-parse", "HEAD")

repo.run(t, "checkout", "--quiet", "feature")

repo.run(t, "merge", "--no-ff", "side", "-m", "merge side")

// When commits unique to the feature branch are requested

commits, err := repo.client.Commits(t.Context(), "trunk", "feature")

// Then the merge commit is excluded and both ordinary feature-side commits are returned

require.NoError(t, err)

assert.ElementsMatch(t, []*Commit{

{Sha: featureSHA, Title: "feature work"},

{Sha: sideSHA, Title: "side work"},

}, commits)

}

func TestClientCommitsReportsInvalidRef(t *testing.T) {

// Given a repository without the requested head ref

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

// When commits for the missing ref are requested

commits, err := repo.client.Commits(t.Context(), "trunk", "missing")

// Then Git's invalid revision error is returned

require.Error(t, err)

var gitError *GitError

require.ErrorAs(t, err, &gitError)

assert.NotZero(t, gitError.ExitCode)

assert.Contains(t, gitError.Stderr, "trunk...missing")

assert.Nil(t, commits)

}

func TestClientLastCommit(t *testing.T) {

// Given a repository fixture with two commits

IsolateConfig(t)

client := Client{RepoDir: "./fixtures/simple.git"}

// When its last commit is requested

commit, err := client.LastCommit(t.Context())

// Then the commit identity and title are returned

require.NoError(t, err)

assert.Equal(t, "6f1a2405cace1633d89a79c74c65f22fe78f9659", commit.Sha)

assert.Equal(t, "Second commit", commit.Title)

}

func TestClientCommitBody(t *testing.T) {

// Given a repository fixture with a commit body

IsolateConfig(t)

client := Client{RepoDir: "./fixtures/simple.git"}

// When the body is requested

body, err := client.CommitBody(t.Context(), "6f1a2405cace1633d89a79c74c65f22fe78f9659")

// Then the complete body is returned

require.NoError(t, err)

assert.Equal(t, "I'm starting to get the hang of things\n", body)

}

func TestClientReadBranchConfigReturnsEmptyConfigWhenUnset(t *testing.T) {

// Given a repository without branch configuration

repo := newTestRepo(t)

// When the branch configuration is read

branchConfig, err := repo.client.ReadBranchConfig(t.Context(), "trunk")

// Then an empty configuration is returned without error

require.NoError(t, err)

assert.Equal(t, BranchConfig{}, branchConfig)

}

func TestClientReadBranchConfigReturnsConfiguredValues(t *testing.T) {

// Given all supported branch configuration values set through the client

repo := newTestRepo(t)

require.NoError(t, repo.client.SetBranchConfig(t.Context(), "trunk", "remote", "upstream"))

require.NoError(t, repo.client.SetBranchConfig(t.Context(), "trunk", "merge", "refs/heads/trunk"))

require.NoError(t, repo.client.SetBranchConfig(t.Context(), "trunk", "pushremote", "origin"))

require.NoError(t, repo.client.SetBranchConfig(t.Context(), "trunk", MergeBaseConfig, "release"))

// When the branch configuration is read

branchConfig, err := repo.client.ReadBranchConfig(t.Context(), "trunk")

// Then the persisted configuration is returned

require.NoError(t, err)

assert.Equal(t, BranchConfig{

RemoteName: "upstream",

PushRemoteName: "origin",

MergeRef: "refs/heads/trunk",

MergeBase: "release",

}, branchConfig)

}

func TestClientReadBranchConfigPropagatesGitError(t *testing.T) {

// Given a client whose repository directory no longer exists

repo := newTestRepo(t)

require.NoError(t, os.RemoveAll(repo.dir))

// When branch configuration is read

branchConfig, err := repo.client.ReadBranchConfig(t.Context(), "trunk")

// Then the repository error is preserved

require.Error(t, err)

var gitError *GitError

require.ErrorAs(t, err, &gitError)

assert.Equal(t, 128, gitError.ExitCode)

assert.Empty(t, branchConfig)

}

func TestParseBranchConfig(t *testing.T) {

tests := []struct {

name string

configLines []string

wantBranchConfig BranchConfig

}{

{

name: "remote branch",

configLines: []string{"branch.trunk.remote origin"},

wantBranchConfig: BranchConfig{

RemoteName: "origin",

},

},

{

name: "merge ref",

configLines: []string{"branch.trunk.merge refs/heads/trunk"},

wantBranchConfig: BranchConfig{

MergeRef: "refs/heads/trunk",

},

},

{

name: "merge base",

configLines: []string{"branch.trunk.gh-merge-base gh-merge-base"},

wantBranchConfig: BranchConfig{

MergeBase: "gh-merge-base",

},

},

{

name: "pushremote",

configLines: []string{"branch.trunk.pushremote pushremote"},

wantBranchConfig: BranchConfig{

PushRemoteName: "pushremote",

},

},

{

name: "remote and pushremote are specified by name",

configLines: []string{

"branch.trunk.remote upstream",

"branch.trunk.pushremote origin",

},

wantBranchConfig: BranchConfig{

RemoteName: "upstream",

PushRemoteName: "origin",

},

},

{

name: "remote and pushremote are specified by url",

configLines: []string{

"branch.trunk.remote git@github.com:UPSTREAMOWNER/REPO.git",

"branch.trunk.pushremote git@github.com:ORIGINOWNER/REPO.git",

},

wantBranchConfig: BranchConfig{

RemoteURL: &url.URL{

Scheme: "ssh",

User: url.User("git"),

Host: "github.com",

Path: "/UPSTREAMOWNER/REPO.git",

},

PushRemoteURL: &url.URL{

Scheme: "ssh",

User: url.User("git"),

Host: "github.com",

Path: "/ORIGINOWNER/REPO.git",

},

},

},

{

name: "remote, pushremote, gh-merge-base, and merge ref all specified",

configLines: []string{

"branch.trunk.remote remote",

"branch.trunk.pushremote pushremote",

"branch.trunk.gh-merge-base gh-merge-base",

"branch.trunk.merge refs/heads/trunk",

},

wantBranchConfig: BranchConfig{

RemoteName: "remote",

PushRemoteName: "pushremote",

MergeBase: "gh-merge-base",

MergeRef: "refs/heads/trunk",

},

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

// Given branch configuration output

configLines := tt.configLines

// When the output is parsed

branchConfig := parseBranchConfig(configLines)

// Then each supported key is mapped to its typed field

assert.Equal(t, tt.wantBranchConfig, branchConfig)

})

}

}

func TestParseRemoteURLOrName(t *testing.T) {

tests := []struct {

name string

value string

wantRemoteURL *url.URL

wantRemoteName string

}{

{

name: "empty value",

value: "",

wantRemoteURL: nil,

wantRemoteName: "",

},

{

name: "remote URL",

value: "git@github.com:foo/bar.git",

wantRemoteURL: &url.URL{

Scheme: "ssh",

User: url.User("git"),

Host: "github.com",

Path: "/foo/bar.git",

},

wantRemoteName: "",

},

{

name: "remote name",

value: "origin",

wantRemoteURL: nil,

wantRemoteName: "origin",

},

{

name: "remote name is from filesystem",

value: "./path/to/repo",

wantRemoteURL: nil,

wantRemoteName: "",

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

// Given a configured branch remote value

value := tt.value

// When it is classified

remoteURL, remoteName := parseRemoteURLOrName(value)

// Then URLs and names are returned through their distinct fields

assert.Equal(t, tt.wantRemoteURL, remoteURL)

assert.Equal(t, tt.wantRemoteName, remoteName)

})

}

}

func TestClientPushDefaultReturnsGitDefaultWhenUnset(t *testing.T) {

// Given a repository without push.default

repo := newTestRepo(t)

// When push.default is read

pushDefault, err := repo.client.PushDefault(t.Context())

// Then Git's default behavior is returned

require.NoError(t, err)

assert.Equal(t, PushDefaultSimple, pushDefault)

}

func TestClientPushDefaultReturnsConfiguredValue(t *testing.T) {

// Given a repository configured to push the current branch

repo := newTestRepo(t)

repo.run(t, "config", "push.default", "current")

// When push.default is read

pushDefault, err := repo.client.PushDefault(t.Context())

// Then the configured behavior is returned

require.NoError(t, err)

assert.Equal(t, PushDefaultCurrent, pushDefault)

}

func TestClientPushDefaultPropagatesGitError(t *testing.T) {

// Given a client whose repository directory no longer exists

repo := newTestRepo(t)

require.NoError(t, os.RemoveAll(repo.dir))

// When push.default is read

pushDefault, err := repo.client.PushDefault(t.Context())

// Then the repository error is preserved

require.Error(t, err)

var gitError *GitError

require.ErrorAs(t, err, &gitError)

assert.Equal(t, 128, gitError.ExitCode)

assert.Empty(t, pushDefault)

}

func TestClientRemotePushDefaultReturnsEmptyWhenUnset(t *testing.T) {

// Given a repository without remote.pushDefault

repo := newTestRepo(t)

// When remote.pushDefault is read

remote, err := repo.client.RemotePushDefault(t.Context())

// Then no preferred remote is returned

require.NoError(t, err)

assert.Empty(t, remote)

}

func TestClientRemotePushDefaultReturnsConfiguredRemote(t *testing.T) {

// Given a repository with a preferred push remote

repo := newTestRepo(t)

repo.run(t, "config", "remote.pushDefault", "origin")

// When remote.pushDefault is read

remote, err := repo.client.RemotePushDefault(t.Context())

// Then the configured remote is returned

require.NoError(t, err)

assert.Equal(t, "origin", remote)

}

func TestClientRemotePushDefaultPropagatesGitError(t *testing.T) {

// Given a client whose repository directory no longer exists

repo := newTestRepo(t)

require.NoError(t, os.RemoveAll(repo.dir))

// When remote.pushDefault is read

remote, err := repo.client.RemotePushDefault(t.Context())

// Then the repository error is preserved

require.Error(t, err)

var gitError *GitError

require.ErrorAs(t, err, &gitError)

assert.Equal(t, 128, gitError.ExitCode)

assert.Empty(t, remote)

}

func TestClientPushRevisionReturnsPushRemoteTrackingRef(t *testing.T) {

// Given a branch that fetches from upstream but pushes to origin

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

repo.run(t, "remote", "add", "upstream", filepath.Join(t.TempDir(), "upstream.git"))

repo.run(t, "remote", "add", "origin", filepath.Join(t.TempDir(), "remote.git"))

repo.run(t, "config", "branch.trunk.remote", "upstream")

repo.run(t, "config", "branch.trunk.merge", "refs/heads/main")

repo.run(t, "config", "branch.trunk.pushremote", "origin")

repo.run(t, "config", "push.default", "current")

repo.run(t, "update-ref", "refs/remotes/upstream/main", "HEAD")

repo.run(t, "update-ref", "refs/remotes/origin/trunk", "HEAD")

// When the branch's push revision is resolved

trackingRef, err := repo.client.PushRevision(t.Context(), "trunk")

// Then the push remote's current-branch tracking ref is returned rather than the upstream's

require.NoError(t, err)

assert.Equal(t, RemoteTrackingRef{Remote: "origin", Branch: "trunk"}, trackingRef)

}

func TestClientPushRevisionReportsUnresolvedBranch(t *testing.T) {

// Given a repository without the requested branch

repo := newTestRepo(t)

// When its push revision is resolved

trackingRef, err := repo.client.PushRevision(t.Context(), "missing")

// Then Git's revision error is returned

require.Error(t, err)

var gitError *GitError

require.ErrorAs(t, err, &gitError)

assert.NotZero(t, gitError.ExitCode)

assert.Empty(t, trackingRef)

}

func TestParsePushRevisionReportsMalformedSymbolicRef(t *testing.T) {

// Given Git returns a symbolic push ref outside refs/remotes

output := []byte("not/a/valid/remote/ref")

// When the push revision is parsed

trackingRef, err := parsePushRevision(output)

// Then the malformed ref is reported with context

require.EqualError(t, err, "could not parse push revision: remote tracking branch must have format refs/remotes/<remote>/<branch> but was: not/a/valid/remote/ref")

assert.Empty(t, trackingRef)

}

func TestParseRemoteTrackingRef(t *testing.T) {

tests := []struct {

name string

ref string

want RemoteTrackingRef

}{

{

name: "branch without slash",

ref: "refs/remotes/origin/branchName",

want: RemoteTrackingRef{Remote: "origin", Branch: "branchName"},

},

{

name: "branch with slash",

ref: "refs/remotes/origin/branch/name",

want: RemoteTrackingRef{Remote: "origin", Branch: "branch/name"},

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

// Given a qualified remote-tracking ref

ref := tt.ref

// When it is parsed

trackingRef, err := ParseRemoteTrackingRef(ref)

// Then the remote and complete branch name are returned

require.NoError(t, err)

assert.Equal(t, tt.want, trackingRef)

})

}

}

func TestParseRemoteTrackingRefReportsMalformedInput(t *testing.T) {

tests := []struct {

name string

ref string

}{

{name: "missing branch", ref: "refs/remotes/origin"},

{name: "incorrect refs prefix", ref: "invalid/remotes/origin/branchName"},

{name: "incorrect ref type", ref: "refs/invalid/origin/branchName"},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

// Given a string outside the remote-tracking ref grammar

ref := tt.ref

// When it is parsed

trackingRef, err := ParseRemoteTrackingRef(ref)

// Then the invalid value is included in the format diagnostic

require.EqualError(t, err, "remote tracking branch must have format refs/remotes/<remote>/<branch> but was: "+ref)

assert.Empty(t, trackingRef)

})

}

}

func TestRemoteTrackingRefString(t *testing.T) {

// Given a remote and branch name

trackingRef := RemoteTrackingRef{Remote: "origin", Branch: "branchName"}

// When the tracking ref is formatted

ref := trackingRef.String()

// Then a qualified remote-tracking ref is returned

assert.Equal(t, "refs/remotes/origin/branchName", ref)

}

func TestClientDeleteLocalTagRemovesTag(t *testing.T) {

// Given a repository with a local tag

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

repo.run(t, "tag", "v1.0")

// When the tag is deleted

err := repo.client.DeleteLocalTag(t.Context(), "v1.0")

// Then the tag no longer resolves

require.NoError(t, err)

assert.Empty(t, repo.run(t, "tag", "--list", "v1.0"))

}

func TestClientDeleteLocalTagReportsMissingTag(t *testing.T) {

// Given a repository without the requested tag

repo := newTestRepo(t)

// When the missing tag is deleted

err := repo.client.DeleteLocalTag(t.Context(), "missing")

// Then Git's missing tag error is returned

require.Error(t, err)

var gitError *GitError

require.ErrorAs(t, err, &gitError)

assert.NotZero(t, gitError.ExitCode)

}

func TestClientDeleteLocalBranchRemovesUnmergedBranch(t *testing.T) {

// Given a feature branch with a commit that is not merged into trunk

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

repo.run(t, "checkout", "--quiet", "-b", "feature")

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "unmerged feature work")

repo.run(t, "checkout", "--quiet", "trunk")

// When the branch is deleted

err := repo.client.DeleteLocalBranch(t.Context(), "feature")

// Then the branch no longer exists

require.NoError(t, err)

assert.False(t, repo.client.HasLocalBranch(t.Context(), "feature"), "deleted branch should not resolve")

}

func TestClientDeleteLocalBranchReportsCheckedOutBranch(t *testing.T) {

// Given a repository whose trunk branch is checked out

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

// When the checked out branch is deleted

err := repo.client.DeleteLocalBranch(t.Context(), "trunk")

// Then Git rejects the deletion and the branch remains

require.Error(t, err)

var gitError *GitError

require.ErrorAs(t, err, &gitError)

assert.NotZero(t, gitError.ExitCode)

assert.True(t, repo.client.HasLocalBranch(t.Context(), "trunk"), "checked out branch should remain")

}

func TestClientHasLocalBranchFindsExistingBranch(t *testing.T) {

// Given a repository with a trunk commit

repo := newTestRepo(t)

repo.run(t, "commit", "--quiet", "--allow-empty", "-m", "initial commit")

// When the local branch is checked

exists := repo.client.HasLocalBranch(t.Context(), "trunk")

// Then the branch is found

assert.True(t, exists, "trunk should resolve as a local branch")

}

func TestClientHasLocalBranchRejectsMissingBranch(t *testing.T) {

// Given a repository without a feature branch

repo := newTestRepo(t)

// When the local branch is checked

exists := repo.client.HasLocalBranch(t.Context(), "feature")

// Then the branch is not found

assert.False(t, exists, "missing branch should not resolve")