mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
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.
936 lines
27 KiB
Go
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)
|
|
}
|
|
}
|