Files
skillshare/internal/git/info_test.go
T
Willie bf32112032 feat(git): show pending remote commits and auto-merge metadata conflicts
Two machines sharing a source repo kept stopping at the same two places.
The Git page had no way to know the remote moved until a push bounced, so
it now fetches once on open and labels Pull with the commit count (status
itself stays offline because the sidebar polls it). And both machines
rewrite .metadata.json on every install or update, so nearly every
diverged pull conflicted there; those conflicts are now merged per entry,
keeping the later installed_at, while any other conflict still stops the
pull and names the files.
2026-09-25 02:22:35 +08:00

936 lines
27 KiB
Go

package git
import (
"errors"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"skillshare/internal/install"
)
// initTestRepo creates a temporary git repo with one commit
func initTestRepo(t *testing.T) string {
t.Helper()
dir := t.TempDir()
run := func(args ...string) {
t.Helper()
cmd := exec.Command("git", args...)
cmd.Dir = dir
cmd.Env = append(os.Environ(),
"GIT_AUTHOR_NAME=test",
"GIT_AUTHOR_EMAIL=test@test.com",
"GIT_COMMITTER_NAME=test",
"GIT_COMMITTER_EMAIL=test@test.com",
)
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("git %v failed: %s\n%s", args, err, out)
}
}
run("init")
run("config", "user.email", "test@test.com")
run("config", "user.name", "test")
os.WriteFile(filepath.Join(dir, "README.md"), []byte("# test"), 0644)
run("add", "-A")
run("commit", "-m", "initial")
return dir
}
// TestPushRemoteWithEnv_TokenNotInError uses a fake git executable to verify
// that PushRemoteWithEnv sanitizes credential-bearing content from git error
// output. This does not assume every real git failure prints credentials; it
// verifies that this wrapper does not return sensitive subprocess output
// verbatim when such output is present.
func TestPushRemoteWithEnv_TokenNotInError(t *testing.T) {
const token = "ghp_test_token_12345_redact"
const fakeGitErr = "fatal: unable to access 'https://x-access-token:" + token + "@github.com/org/repo.git/': Could not resolve host: github.com"
fakeBin := t.TempDir()
fakeGit := filepath.Join(fakeBin, "git")
script := "#!/bin/sh\n" +
"echo \"" + fakeGitErr + "\" >&2\n" +
"exit 128\n"
if err := os.WriteFile(fakeGit, []byte(script), 0755); err != nil {
t.Fatal(err)
}
t.Setenv("PATH", fakeBin+string(os.PathListSeparator)+os.Getenv("PATH"))
t.Setenv("GITHUB_TOKEN", token)
extraEnv := []string{
"GIT_CONFIG_COUNT=1",
"GIT_CONFIG_KEY_0=url.https://x-access-token:" + token + "@github.com/.insteadOf",
"GIT_CONFIG_VALUE_0=https://github.com/",
}
err := PushRemoteWithEnv(t.TempDir(), extraEnv)
if err == nil {
t.Fatal("expected git push to fail")
}
msg := err.Error()
// Token must not appear in error output.
if strings.Contains(msg, token) {
t.Fatalf("token leaked in error: %v", err)
}
// Useful diagnostic text should survive sanitization.
if !strings.Contains(msg, "Could not resolve host") && !strings.Contains(msg, "unable to access") {
t.Fatalf("expected useful diagnostic in error, got: %v", err)
}
}
func TestPushRemoteWithEnv_PreservesStdoutDiagnostics(t *testing.T) {
const token = "ghp_stdout_token_12345_redact"
const stdoutDiagnostic = "pre-push hook rejected branch https://x-access-token:" + token + "@github.com/org/repo.git/"
fakeBin := t.TempDir()
fakeGit := filepath.Join(fakeBin, "git")
script := "#!/bin/sh\n" +
"echo \"" + stdoutDiagnostic + "\"\n" +
"echo \"error: failed to push some refs to 'https://github.com/org/repo.git'\" >&2\n" +
"exit 1\n"
if err := os.WriteFile(fakeGit, []byte(script), 0755); err != nil {
t.Fatal(err)
}
t.Setenv("PATH", fakeBin+string(os.PathListSeparator)+os.Getenv("PATH"))
t.Setenv("GITHUB_TOKEN", token)
extraEnv := []string{
"GIT_CONFIG_COUNT=1",
"GIT_CONFIG_KEY_0=url.https://x-access-token:" + token + "@github.com/.insteadOf",
"GIT_CONFIG_VALUE_0=https://github.com/",
}
err := PushRemoteWithEnv(t.TempDir(), extraEnv)
if err == nil {
t.Fatal("expected git push to fail")
}
msg := err.Error()
if strings.Contains(msg, token) {
t.Fatalf("token leaked in error: %v", err)
}
if !strings.Contains(msg, "pre-push hook rejected branch") {
t.Fatalf("expected stdout diagnostic in error, got: %v", err)
}
if !strings.Contains(msg, "failed to push some refs") {
t.Fatalf("expected stderr diagnostic in error, got: %v", err)
}
}
func TestIsRepo(t *testing.T) {
repo := initTestRepo(t)
if !IsRepo(repo) {
t.Error("expected IsRepo to return true for a git repo")
}
notRepo := t.TempDir()
if IsRepo(notRepo) {
t.Error("expected IsRepo to return false for a non-repo dir")
}
}
func TestHasRemote(t *testing.T) {
repo := initTestRepo(t)
if HasRemote(repo) {
t.Error("expected HasRemote to return false for repo without remote")
}
// Add a remote
cmd := exec.Command("git", "remote", "add", "origin", "https://example.com/repo.git")
cmd.Dir = repo
if err := cmd.Run(); err != nil {
t.Fatal(err)
}
if !HasRemote(repo) {
t.Error("expected HasRemote to return true after adding remote")
}
}
func TestGetCurrentBranch(t *testing.T) {
repo := initTestRepo(t)
branch, err := GetCurrentBranch(repo)
if err != nil {
t.Fatal(err)
}
// Default branch could be main or master depending on git config
if branch != "main" && branch != "master" {
t.Errorf("unexpected branch name: %s", branch)
}
}
func TestStageAndCommit(t *testing.T) {
repo := initTestRepo(t)
// Create a new file
os.WriteFile(filepath.Join(repo, "new.txt"), []byte("hello"), 0644)
// Stage all
if err := StageAll(repo); err != nil {
t.Fatalf("StageAll failed: %v", err)
}
// Commit
if err := Commit(repo, "add new file"); err != nil {
t.Fatalf("Commit failed: %v", err)
}
// Should be clean now
dirty, err := IsDirty(repo)
if err != nil {
t.Fatal(err)
}
if dirty {
t.Error("expected repo to be clean after commit")
}
}
func TestGetStatus(t *testing.T) {
repo := initTestRepo(t)
// Clean repo
status, err := GetStatus(repo)
if err != nil {
t.Fatal(err)
}
if status != "" {
t.Errorf("expected empty status for clean repo, got: %q", status)
}
// Create untracked file
os.WriteFile(filepath.Join(repo, "untracked.txt"), []byte("x"), 0644)
status, err = GetStatus(repo)
if err != nil {
t.Fatal(err)
}
if status == "" {
t.Error("expected non-empty status after adding untracked file")
}
}
func TestIsDirtyAndGetDirtyFiles(t *testing.T) {
repo := initTestRepo(t)
dirty, err := IsDirty(repo)
if err != nil {
t.Fatal(err)
}
if dirty {
t.Error("expected clean repo")
}
// Modify a file
os.WriteFile(filepath.Join(repo, "README.md"), []byte("# modified"), 0644)
dirty, err = IsDirty(repo)
if err != nil {
t.Fatal(err)
}
if !dirty {
t.Error("expected dirty repo")
}
files, err := GetDirtyFiles(repo)
if err != nil {
t.Fatal(err)
}
if len(files) == 0 {
t.Error("expected at least one dirty file")
}
}
func addRemote(t *testing.T, repoPath, remoteURL string) {
t.Helper()
cmd := exec.Command("git", "remote", "add", "origin", remoteURL)
cmd.Dir = repoPath
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("failed to add remote: %v (%s)", err, strings.TrimSpace(string(out)))
}
}
func TestAuthEnvForRepo_UsesGitHubToken(t *testing.T) {
repo := initTestRepo(t)
addRemote(t, repo, "https://github.com/org/private-repo.git")
t.Setenv("GITHUB_TOKEN", "ghp_test_token_123")
env := AuthEnvForRepo(repo)
if len(env) != 3 {
t.Fatalf("expected auth env with 3 entries, got %d: %v", len(env), env)
}
if !strings.Contains(env[1], "url.https://x-access-token:ghp_test_token_123@github.com/.insteadOf") {
t.Fatalf("unexpected auth key env: %q", env[1])
}
if !strings.Contains(env[2], "https://github.com/") {
t.Fatalf("unexpected auth value env: %q", env[2])
}
}
func TestAuthEnvForRepo_UsesGitLabToken(t *testing.T) {
repo := initTestRepo(t)
addRemote(t, repo, "https://gitlab.com/group/private-repo.git")
t.Setenv("GITLAB_TOKEN", "glpat_test_token_123")
env := AuthEnvForRepo(repo)
if len(env) != 3 {
t.Fatalf("expected auth env with 3 entries, got %d: %v", len(env), env)
}
if !strings.Contains(env[1], "url.https://oauth2:glpat_test_token_123@gitlab.com/.insteadOf") {
t.Fatalf("unexpected auth key env: %q", env[1])
}
if !strings.Contains(env[2], "https://gitlab.com/") {
t.Fatalf("unexpected auth value env: %q", env[2])
}
}
func TestAuthEnvForRepo_NoTokenReturnsNil(t *testing.T) {
repo := initTestRepo(t)
addRemote(t, repo, "https://github.com/org/private-repo.git")
t.Setenv("GITHUB_TOKEN", "")
t.Setenv("SKILLSHARE_GIT_TOKEN", "")
env := AuthEnvForRepo(repo)
if env != nil {
t.Fatalf("expected nil auth env without tokens, got: %v", env)
}
}
func TestAuthEnvForRepo_SSHRemote_ReturnsNil(t *testing.T) {
repo := initTestRepo(t)
addRemote(t, repo, "git@github.com:org/private-repo.git")
t.Setenv("GITHUB_TOKEN", "ghp_test_token_123")
t.Setenv("SKILLSHARE_GIT_TOKEN", "generic-token")
env := AuthEnvForRepo(repo)
if env != nil {
t.Fatalf("expected nil auth env for SSH remote, got: %v", env)
}
}
func TestGetRemoteDefaultBranch_UsesOriginHEAD(t *testing.T) {
remote := createBareRemoteWithBranch(t, "trunk", map[string]string{
"README.md": "# trunk\n",
})
repo := cloneRepo(t, remote)
branch, err := GetRemoteDefaultBranch(repo)
if err != nil {
t.Fatalf("GetRemoteDefaultBranch failed: %v", err)
}
if branch != "trunk" {
t.Fatalf("expected trunk, got %q", branch)
}
}
func TestGetRemoteDefaultBranch_FallbackMainMaster(t *testing.T) {
for _, wantBranch := range []string{"main", "master"} {
t.Run(wantBranch, func(t *testing.T) {
remote := createBareRemoteWithBranch(t, wantBranch, map[string]string{
"README.md": "# " + wantBranch + "\n",
})
repo := cloneRepo(t, remote)
runGit(t, repo, "update-ref", "-d", "refs/remotes/origin/HEAD")
branch, err := GetRemoteDefaultBranch(repo)
if err != nil {
t.Fatalf("GetRemoteDefaultBranch failed: %v", err)
}
if branch != wantBranch {
t.Fatalf("expected %s, got %q", wantBranch, branch)
}
})
}
}
func TestGetRemoteDefaultBranch_FallbackFirstRemoteBranch(t *testing.T) {
remote := createBareRemoteWithBranch(t, "release", map[string]string{
"README.md": "# release\n",
})
repo := cloneRepo(t, remote)
runGit(t, repo, "update-ref", "-d", "refs/remotes/origin/HEAD")
branch, err := GetRemoteDefaultBranch(repo)
if err != nil {
t.Fatalf("GetRemoteDefaultBranch failed: %v", err)
}
if branch != "release" {
t.Fatalf("expected release, got %q", branch)
}
}
func TestHasRemoteSkillDirs(t *testing.T) {
remote := createBareRemoteWithBranch(t, "main", map[string]string{
"README.md": "# docs\n",
"skill-one/SKILL.md": "# one\n",
"skill-two/README.txt": "x\n",
})
repo := cloneRepo(t, remote)
hasSkills, err := HasRemoteSkillDirs(repo, "main")
if err != nil {
t.Fatalf("HasRemoteSkillDirs failed: %v", err)
}
if !hasSkills {
t.Fatal("expected remote to have skill directories")
}
}
func TestHasLocalSkillDirs(t *testing.T) {
repo := initTestRepo(t)
hasSkills, err := HasLocalSkillDirs(repo)
if err != nil {
t.Fatalf("HasLocalSkillDirs failed: %v", err)
}
if hasSkills {
t.Fatal("expected no local skill directories in fresh repo")
}
if err := os.MkdirAll(filepath.Join(repo, "my-skill"), 0o755); err != nil {
t.Fatalf("failed to create local skill dir: %v", err)
}
hasSkills, err = HasLocalSkillDirs(repo)
if err != nil {
t.Fatalf("HasLocalSkillDirs failed: %v", err)
}
if !hasSkills {
t.Fatal("expected local skill directory to be detected")
}
}
func TestGetChangedFiles_Rename(t *testing.T) {
repo := initTestRepo(t)
// Record the starting commit
fromHash := runGit(t, repo, "rev-parse", "HEAD")
// Rename README.md → GUIDE.md (keep content similar for rename detection)
os.Rename(filepath.Join(repo, "README.md"), filepath.Join(repo, "GUIDE.md"))
runGit(t, repo, "add", "-A")
runGit(t, repo, "commit", "-m", "rename file")
toHash := runGit(t, repo, "rev-parse", "HEAD")
changes, err := GetChangedFiles(repo, fromHash, toHash)
if err != nil {
t.Fatalf("GetChangedFiles failed: %v", err)
}
// Should have at least one rename entry
var found bool
for _, c := range changes {
if c.Status == "R" && c.Path == "GUIDE.md" {
found = true
if c.OldPath != "README.md" {
t.Errorf("expected OldPath=README.md, got %q", c.OldPath)
}
break
}
}
if !found {
t.Errorf("expected rename entry for GUIDE.md, got: %+v", changes)
}
}
func TestGetChangedFiles_AddModifyDelete(t *testing.T) {
repo := initTestRepo(t)
// Add a file to delete later
os.WriteFile(filepath.Join(repo, "to-delete.txt"), []byte("delete me"), 0644)
runGit(t, repo, "add", "-A")
runGit(t, repo, "commit", "-m", "add to-delete")
fromHash := runGit(t, repo, "rev-parse", "HEAD")
// Add new, modify existing, delete file
os.WriteFile(filepath.Join(repo, "new.txt"), []byte("new file"), 0644)
os.WriteFile(filepath.Join(repo, "README.md"), []byte("# modified"), 0644)
os.Remove(filepath.Join(repo, "to-delete.txt"))
runGit(t, repo, "add", "-A")
runGit(t, repo, "commit", "-m", "mixed changes")
toHash := runGit(t, repo, "rev-parse", "HEAD")
changes, err := GetChangedFiles(repo, fromHash, toHash)
if err != nil {
t.Fatalf("GetChangedFiles failed: %v", err)
}
statuses := map[string]string{}
for _, c := range changes {
statuses[c.Path] = c.Status
}
if statuses["new.txt"] != "A" {
t.Errorf("expected new.txt=A, got %q", statuses["new.txt"])
}
if statuses["README.md"] != "M" {
t.Errorf("expected README.md=M, got %q", statuses["README.md"])
}
if statuses["to-delete.txt"] != "D" {
t.Errorf("expected to-delete.txt=D, got %q", statuses["to-delete.txt"])
}
}
func TestPullWithProgress(t *testing.T) {
remote := createBareRemoteWithBranch(t, "main", map[string]string{
"README.md": "# v1\n",
})
repo := cloneRepo(t, remote)
updater := filepath.Join(t.TempDir(), "updater")
runGit(t, "", "clone", remote, updater)
runGit(t, updater, "config", "user.email", "test@test.com")
runGit(t, updater, "config", "user.name", "test")
if err := os.WriteFile(filepath.Join(updater, "README.md"), []byte("# v2\n"), 0644); err != nil {
t.Fatalf("failed writing update: %v", err)
}
runGit(t, updater, "add", "-A")
runGit(t, updater, "commit", "-m", "update")
runGit(t, updater, "push", "origin", "HEAD:main")
info, err := PullWithProgress(repo, nil, func(string) {})
if err != nil {
t.Fatalf("PullWithProgress failed: %v", err)
}
if info.UpToDate {
t.Fatalf("expected update to pull new commit")
}
if info.AfterHash == info.BeforeHash {
t.Fatalf("expected before/after hash to differ")
}
}
// divergeFromRemote commits remoteFile on another clone and pushes it, then
// commits localFile in repo without pushing, as two machines syncing would.
func divergeFromRemote(t *testing.T, remote, repo string, remoteFile, localFile [2]string) {
t.Helper()
other := cloneRepo(t, remote)
for _, c := range []struct {
dir string
file [2]string
}{{other, remoteFile}, {repo, localFile}} {
runGit(t, c.dir, "config", "user.email", "test@test.com")
runGit(t, c.dir, "config", "user.name", "test")
if err := os.WriteFile(filepath.Join(c.dir, c.file[0]), []byte(c.file[1]), 0644); err != nil {
t.Fatal(err)
}
runGit(t, c.dir, "add", "-A")
runGit(t, c.dir, "commit", "-m", "edit "+c.file[0])
}
runGit(t, other, "push", "origin", "HEAD:main")
}
func TestPullWithProgress_MergesDivergedHistory(t *testing.T) {
remote := createBareRemoteWithBranch(t, "main", map[string]string{"README.md": "# v1\n"})
repo := cloneRepo(t, remote)
divergeFromRemote(t, remote, repo, [2]string{"remote.md", "r\n"}, [2]string{"local.md", "l\n"})
if _, err := PullWithProgress(repo, nil, nil); err != nil {
t.Fatalf("expected diverged pull to merge, got: %v", err)
}
for _, f := range []string{"remote.md", "local.md"} {
if _, err := os.Stat(filepath.Join(repo, f)); err != nil {
t.Errorf("expected %s after merge: %v", f, err)
}
}
}
func TestPullWithProgress_ConflictLeavesRepoClean(t *testing.T) {
remote := createBareRemoteWithBranch(t, "main", map[string]string{"README.md": "# v1\n"})
repo := cloneRepo(t, remote)
divergeFromRemote(t, remote, repo, [2]string{"README.md", "# remote\n"}, [2]string{"README.md", "# local\n"})
if _, err := PullWithProgress(repo, nil, nil); err == nil {
t.Fatal("expected a conflicting pull to fail")
}
if status := runGit(t, repo, "status", "--porcelain"); status != "" {
t.Fatalf("expected the merge to be aborted, got status:\n%s", status)
}
}
func TestPullWithProgress_ResolvesMetadataConflict(t *testing.T) {
meta := func(entries string) string {
return `{"version": 1, "entries": {` + entries + `}}` + "\n"
}
shared := func(at string) string {
return `"shared": {"source": "github.com/o/r/shared", "installed_at": "` + at + `"}`
}
remote := createBareRemoteWithBranch(t, "main", map[string]string{
".metadata.json": meta(shared("2026-01-01T00:00:00Z")),
})
repo := cloneRepo(t, remote)
divergeFromRemote(t, remote, repo,
[2]string{".metadata.json", meta(shared("2026-03-01T00:00:00Z") + `, "remote-only": {"source": "r"}`)},
[2]string{".metadata.json", meta(shared("2026-02-01T00:00:00Z") + `, "local-only": {"source": "l"}`)})
if _, err := PullWithProgress(repo, nil, nil); err != nil {
t.Fatalf("expected a metadata-only conflict to resolve, got: %v", err)
}
store, err := install.LoadMetadata(repo)
if err != nil {
t.Fatal(err)
}
for _, name := range []string{"remote-only", "local-only"} {
if !store.Has(name) {
t.Errorf("expected entry %q after merge", name)
}
}
if got := store.Get("shared").InstalledAt.Format("2006-01-02"); got != "2026-03-01" {
t.Errorf("expected the later installed_at to win, got %s", got)
}
if status := runGit(t, repo, "status", "--porcelain"); status != "" {
t.Fatalf("expected the merge to be committed, got status:\n%s", status)
}
}
func TestForcePullWithProgress(t *testing.T) {
remote := createBareRemoteWithBranch(t, "main", map[string]string{
"README.md": "# v1\n",
})
repo := cloneRepo(t, remote)
runGit(t, repo, "config", "user.email", "test@test.com")
runGit(t, repo, "config", "user.name", "test")
// Add remote commit.
updater := filepath.Join(t.TempDir(), "updater")
runGit(t, "", "clone", remote, updater)
runGit(t, updater, "config", "user.email", "test@test.com")
runGit(t, updater, "config", "user.name", "test")
if err := os.WriteFile(filepath.Join(updater, "README.md"), []byte("# remote\n"), 0644); err != nil {
t.Fatalf("failed writing remote update: %v", err)
}
runGit(t, updater, "add", "-A")
runGit(t, updater, "commit", "-m", "remote update")
runGit(t, updater, "push", "origin", "HEAD:main")
// Create divergent local commit.
if err := os.WriteFile(filepath.Join(repo, "local.txt"), []byte("local"), 0644); err != nil {
t.Fatalf("failed writing local update: %v", err)
}
runGit(t, repo, "add", "-A")
runGit(t, repo, "commit", "-m", "local change")
info, err := ForcePullWithProgress(repo, nil, func(string) {})
if err != nil {
t.Fatalf("ForcePullWithProgress failed: %v", err)
}
if info.UpToDate {
t.Fatalf("expected force pull to change local hash")
}
if info.AfterHash == info.BeforeHash {
t.Fatalf("expected before/after hash to differ")
}
content, err := os.ReadFile(filepath.Join(repo, "README.md"))
if err != nil {
t.Fatalf("failed reading README after force pull: %v", err)
}
if !strings.Contains(string(content), "remote") {
t.Fatalf("expected repo to reset to remote content, got: %s", content)
}
}
func TestListLocalBranches(t *testing.T) {
repo := initTestRepo(t)
branches, err := ListLocalBranches(repo)
if err != nil {
t.Fatalf("ListLocalBranches failed: %v", err)
}
if len(branches) != 1 {
t.Fatalf("expected 1 branch, got %d: %v", len(branches), branches)
}
// Create another branch
runGit(t, repo, "branch", "feature-x")
branches, err = ListLocalBranches(repo)
if err != nil {
t.Fatalf("ListLocalBranches failed: %v", err)
}
if len(branches) != 2 {
t.Fatalf("expected 2 branches, got %d: %v", len(branches), branches)
}
found := false
for _, b := range branches {
if b == "feature-x" {
found = true
}
}
if !found {
t.Errorf("expected to find feature-x in %v", branches)
}
}
func TestListRemoteBranches(t *testing.T) {
remote := createBareRemoteWithBranch(t, "main", map[string]string{
"README.md": "# test\n",
})
repo := cloneRepo(t, remote)
// Push a second branch to remote
updater := filepath.Join(t.TempDir(), "updater")
runGit(t, "", "clone", remote, updater)
runGit(t, updater, "config", "user.email", "test@test.com")
runGit(t, updater, "config", "user.name", "test")
runGit(t, updater, "checkout", "-b", "develop")
os.WriteFile(filepath.Join(updater, "dev.txt"), []byte("dev"), 0644)
runGit(t, updater, "add", "-A")
runGit(t, updater, "commit", "-m", "dev branch")
runGit(t, updater, "push", "origin", "develop")
// Fetch so repo knows about remote develop
runGit(t, repo, "fetch")
remoteBranches, err := ListRemoteBranches(repo)
if err != nil {
t.Fatalf("ListRemoteBranches failed: %v", err)
}
// "main" is local, so only "develop" should appear as remote-only
found := false
for _, b := range remoteBranches {
if b == "main" {
t.Error("main should not be in remote-only list (it exists locally)")
}
if b == "develop" {
found = true
}
}
if !found {
t.Errorf("expected develop in remote branches, got: %v", remoteBranches)
}
}
func TestCheckout_LocalBranch(t *testing.T) {
repo := initTestRepo(t)
// Create a local branch and switch back
runGit(t, repo, "branch", "feature-a")
if err := Checkout(repo, "feature-a"); err != nil {
t.Fatalf("Checkout local branch failed: %v", err)
}
branch, _ := GetCurrentBranch(repo)
if branch != "feature-a" {
t.Errorf("expected branch feature-a, got %s", branch)
}
}
func TestCheckout_RemoteBranch(t *testing.T) {
remote := createBareRemoteWithBranch(t, "main", map[string]string{
"README.md": "# test\n",
})
repo := cloneRepo(t, remote)
// Push a develop branch to remote via another clone
updater := filepath.Join(t.TempDir(), "updater")
runGit(t, "", "clone", remote, updater)
runGit(t, updater, "config", "user.email", "test@test.com")
runGit(t, updater, "config", "user.name", "test")
runGit(t, updater, "checkout", "-b", "develop")
os.WriteFile(filepath.Join(updater, "dev.txt"), []byte("dev"), 0644)
runGit(t, updater, "add", "-A")
runGit(t, updater, "commit", "-m", "dev branch")
runGit(t, updater, "push", "origin", "develop")
// Fetch so repo sees origin/develop
runGit(t, repo, "fetch")
// Checkout remote-only branch
if err := Checkout(repo, "develop"); err != nil {
t.Fatalf("Checkout remote branch failed: %v", err)
}
branch, _ := GetCurrentBranch(repo)
if branch != "develop" {
t.Errorf("expected branch develop, got %s", branch)
}
}
func TestCheckout_NonexistentBranch(t *testing.T) {
repo := initTestRepo(t)
err := Checkout(repo, "does-not-exist")
if err == nil {
t.Error("expected error for non-existent branch")
}
}
func TestGetRemoteURL(t *testing.T) {
dir := initTestRepo(t)
// No remote → error (git exits non-zero when no remote configured)
url, err := GetRemoteURL(dir)
if err == nil {
t.Fatal("GetRemoteURL() expected error for repo with no remote, got nil")
}
if url != "" {
t.Errorf("GetRemoteURL() = %q, want empty on error", url)
}
// Add remote
addRemote(t, dir, "https://github.com/test/repo.git")
url, err = GetRemoteURL(dir)
if err != nil {
t.Fatalf("GetRemoteURL() error: %v", err)
}
if url != "https://github.com/test/repo.git" {
t.Errorf("GetRemoteURL() = %q, want %q", url, "https://github.com/test/repo.git")
}
}
func TestGetHeadMessage(t *testing.T) {
dir := initTestRepo(t) // commits "initial"
msg, err := GetHeadMessage(dir)
if err != nil {
t.Fatalf("GetHeadMessage() error: %v", err)
}
if msg != "initial" {
t.Errorf("GetHeadMessage() = %q, want %q", msg, "initial")
}
}
func TestGetTrackingBranch(t *testing.T) {
dir := initTestRepo(t)
// No upstream → empty string, no error
branch, err := GetTrackingBranch(dir)
if err != nil {
t.Fatalf("GetTrackingBranch() error: %v", err)
}
if branch != "" {
t.Errorf("GetTrackingBranch() = %q, want empty", branch)
}
}
func runGit(t *testing.T, dir string, args ...string) string {
t.Helper()
cmd := exec.Command("git", args...)
if dir != "" {
cmd.Dir = dir
}
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("git %v failed: %v (%s)", args, err, strings.TrimSpace(string(out)))
}
return strings.TrimSpace(string(out))
}
func createBareRemoteWithBranch(t *testing.T, branch string, files map[string]string) string {
t.Helper()
root := t.TempDir()
remote := filepath.Join(root, "remote.git")
runGit(t, "", "init", "--bare", remote)
seed := filepath.Join(root, "seed")
runGit(t, "", "clone", remote, seed)
runGit(t, seed, "config", "user.email", "test@test.com")
runGit(t, seed, "config", "user.name", "test")
for rel, content := range files {
path := filepath.Join(seed, rel)
if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
t.Fatalf("failed to create dir for %s: %v", rel, err)
}
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
t.Fatalf("failed to write %s: %v", rel, err)
}
}
runGit(t, seed, "add", "-A")
runGit(t, seed, "commit", "-m", "seed "+branch)
runGit(t, seed, "push", "origin", "HEAD:"+branch)
runGit(t, remote, "symbolic-ref", "HEAD", "refs/heads/"+branch)
return remote
}
func cloneRepo(t *testing.T, remote string) string {
t.Helper()
repo := filepath.Join(t.TempDir(), "repo")
runGit(t, "", "clone", remote, repo)
return repo
}
func TestSetOrAddRemote(t *testing.T) {
repo := initTestRepo(t)
// Adds origin when absent.
if err := SetOrAddRemote(repo, "https://example.com/a.git"); err != nil {
t.Fatalf("add origin: %v", err)
}
if got, _ := GetRemoteURL(repo); got != "https://example.com/a.git" {
t.Errorf("origin = %q, want a.git", got)
}
// Updates the URL when origin already exists.
if err := SetOrAddRemote(repo, "https://example.com/b.git"); err != nil {
t.Fatalf("update origin: %v", err)
}
if got, _ := GetRemoteURL(repo); got != "https://example.com/b.git" {
t.Errorf("origin = %q, want b.git", got)
}
// Rejects flag-smuggling URLs (argv injection) without invoking git.
if err := SetOrAddRemote(repo, "--upload-pack=touch /tmp/pwned"); err == nil {
t.Error("expected dash-prefixed remote URL to be rejected")
}
if got, _ := GetRemoteURL(repo); got != "https://example.com/b.git" {
t.Errorf("origin changed after rejected input: %q", got)
}
}
func TestAheadCount_CountsUnpushedCommits(t *testing.T) {
repo := cloneRepo(t, createBareRemoteWithBranch(t, "main", map[string]string{"a/SKILL.md": "# a\n"}))
runGit(t, repo, "-c", "user.name=test", "-c", "user.email=test@test.com", "commit", "--allow-empty", "-m", "local")
if got := AheadCount(repo); got != 1 {
t.Fatalf("AheadCount() = %d, want 1", got)
}
}
func TestFirstPull_MergesUnrelatedRemoteHistory(t *testing.T) {
remote := createBareRemoteWithBranch(t, "main", map[string]string{"remote-skill/SKILL.md": "# remote\n"})
repo := initTestRepo(t)
if err := os.MkdirAll(filepath.Join(repo, "local-skill"), 0o755); err != nil {
t.Fatal(err)
}
runGit(t, repo, "remote", "add", "origin", remote)
if _, err := FirstPull(repo, false); err != nil {
t.Fatalf("FirstPull() error: %v", err)
}
_, statErr := os.Stat(filepath.Join(repo, "remote-skill", "SKILL.md"))
if statErr != nil || !HasUpstream(repo) {
t.Fatalf("expected remote files merged and upstream set (stat err: %v, upstream: %v)", statErr, HasUpstream(repo))
}
}
func TestFirstPull_EmptyRemoteReportsNoBranches(t *testing.T) {
remote := filepath.Join(t.TempDir(), "remote.git")
runGit(t, "", "init", "--bare", remote)
repo := initTestRepo(t)
runGit(t, repo, "remote", "add", "origin", remote)
if _, err := FirstPull(repo, false); !errors.Is(err, ErrNoRemoteBranches) {
t.Fatalf("FirstPull() error = %v, want ErrNoRemoteBranches", err)
}
}