Files
skillshare/internal/git/info_test.go
T
Willie 56766b024c fix(git): reject flag-smuggling remote URLs in SetRemoteURL/SetOrAddRemote
A remote URL beginning with '-' could be parsed by git as an option flag
(argv injection, e.g. --upload-pack=...). Validate the URL (reject a leading
dash) and pass '--' before positional args so git stops option parsing.
Covers both the new scope-switch remote path and the existing skill-repo
URL editor that funnels through SetRemoteURL.
2026-05-30 19:23:12 +08:00

724 lines
20 KiB
Go

package git
import (
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
)
// 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
}
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")
}
}
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)
}
}