Archived
simonfrankenandClaude Opus 5.5
651b0c2e69
A restored submodule whose pin is a branch tip ends on that branch instead of a detached HEAD: the local branch tracking the ref, else the ref created as a tracking branch, else another local branch, else another remote branch at the pin. No branch is moved; in-sync submodules are included (D28). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
462 lines
16 KiB
Go
462 lines
16 KiB
Go
package git
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"submarine/internal/submodule"
|
|
)
|
|
|
|
// out runs git and returns its trimmed stdout.
|
|
func out(t *testing.T, dir string, args ...string) string {
|
|
t.Helper()
|
|
b, err := exec.Command("git", append([]string{"-C", dir}, args...)...).Output()
|
|
if err != nil {
|
|
t.Fatalf("git %v: %v", args, err)
|
|
}
|
|
return strings.TrimSpace(string(b))
|
|
}
|
|
|
|
func exists(path string) bool { _, err := os.Stat(path); return err == nil }
|
|
|
|
// assertExact checks that the superproject at dir and every submodule below
|
|
// it is initialized, on its pin (staged ones included) and has no change
|
|
// besides staged pins.
|
|
func assertExact(t *testing.T, dir string) {
|
|
t.Helper()
|
|
if s := out(t, dir, "diff", "--name-only", "--ignore-submodules=dirty"); s != "" { // worktree vs index
|
|
t.Errorf("%s not clean:\n%s", dir, s)
|
|
}
|
|
if s := out(t, dir, "ls-files", "--others", "--exclude-standard"); s != "" {
|
|
t.Errorf("%s has untracked files:\n%s", dir, s)
|
|
}
|
|
raw, err := exec.Command("git", "-C", dir, "submodule", "status", "--recursive").Output() // the prefix is a leading space
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, line := range strings.Split(string(raw), "\n") {
|
|
if line == "" {
|
|
continue
|
|
}
|
|
if line[0] != ' ' {
|
|
t.Errorf("submodule not exact: %s", line)
|
|
continue
|
|
}
|
|
f := strings.Fields(line)
|
|
sub := filepath.Join(dir, f[1])
|
|
if s := out(t, sub, "diff", "--name-only", "--ignore-submodules=dirty"); s != "" {
|
|
t.Errorf("%s not clean:\n%s", f[1], s)
|
|
}
|
|
if s := out(t, sub, "ls-files", "--others", "--exclude-standard"); s != "" {
|
|
t.Errorf("%s has untracked files:\n%s", f[1], s)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRestoreSuperprojectMakesEverythingExact(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
ctx := context.Background()
|
|
|
|
// ignored files stay
|
|
if err := os.WriteFile(filepath.Join(super, ".git", "info", "exclude"), []byte("keep.log\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
keep := filepath.Join(super, "libs", "work", "keep.log")
|
|
// libs/work is a submodule: its own exclude file lives in its git dir
|
|
wkGit := out(t, filepath.Join(super, "libs", "work"), "rev-parse", "--absolute-git-dir")
|
|
if err := os.WriteFile(filepath.Join(wkGit, "info", "exclude"), []byte("keep.log\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(keep, []byte("x"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// a branch must not move
|
|
conflict := filepath.Join(super, "libs", "conflict")
|
|
mainTip := out(t, conflict, "rev-parse", "main")
|
|
|
|
if err := p.Restore(ctx, "", submodule.RestoreStaged); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertExact(t, super)
|
|
if got := out(t, conflict, "rev-parse", "main"); got != mainTip {
|
|
t.Errorf("branch main moved: %s -> %s", mainTip, got)
|
|
}
|
|
if !exists(keep) {
|
|
t.Error("ignored file was deleted")
|
|
}
|
|
if exists(filepath.Join(conflict, ".git", "MERGE_HEAD")) || exists(filepath.Join(out(t, conflict, "rev-parse", "--absolute-git-dir"), "MERGE_HEAD")) {
|
|
t.Error("merge still in progress")
|
|
}
|
|
if !exists(filepath.Join(super, "libs", "missing", ".git")) {
|
|
t.Error("libs/missing was not initialized")
|
|
}
|
|
// the fixture stages libs/staged and libs/conflict
|
|
if got := out(t, super, "diff", "--cached", "--name-only"); got != "libs/conflict\nlibs/staged" {
|
|
t.Errorf("staged = %q, want the staged pins kept", got)
|
|
}
|
|
}
|
|
|
|
func TestRestoreSubmoduleKeepsStagedPinAsTarget(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
staged := out(t, filepath.Join(super, "libs", "staged"), "rev-parse", "HEAD")
|
|
// the fixture staged the checked-out commit; move the checkout away
|
|
git(t, filepath.Join(super, "libs", "staged"), "checkout", "-q", "--detach", "HEAD~1")
|
|
|
|
if err := p.Restore(context.Background(), "libs/staged", submodule.RestoreStaged); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := out(t, filepath.Join(super, "libs", "staged"), "rev-parse", "HEAD"); got != staged {
|
|
t.Errorf("HEAD = %s, want the staged pin %s", got, staged)
|
|
}
|
|
if !strings.Contains(out(t, super, "diff", "--cached", "--name-only"), "libs/staged") {
|
|
t.Error("restoring a submodule must keep its staged pin")
|
|
}
|
|
}
|
|
|
|
func TestRestoreLoss(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
ctx := context.Background()
|
|
|
|
loss := func(path string) submodule.Loss {
|
|
t.Helper()
|
|
l, err := p.RestoreLoss(ctx, path, submodule.RestoreStaged)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return l
|
|
}
|
|
|
|
// off pin and missing lose nothing; neither does an unpushed pin
|
|
for _, path := range []string{"src/core", "libs/missing", "src/net", "libs/staged"} {
|
|
if l := loss(path); !l.Empty() {
|
|
t.Errorf("%s: loss %+v, want none", path, l)
|
|
}
|
|
}
|
|
|
|
// libs/work: 6 files and a directory, untracked and changed
|
|
if l := loss("libs/work"); l.Files < 6 || l.Modules != 1 {
|
|
t.Errorf("libs/work: %+v", l)
|
|
}
|
|
// a nested change counts for its ancestors
|
|
if l := loss("libs/log"); l.Files != 1 || l.Modules != 1 {
|
|
t.Errorf("libs/log: %+v, want the nested change", l)
|
|
}
|
|
// a merge in progress
|
|
if l := loss("libs/conflict"); l.Operations != 1 || l.Files == 0 {
|
|
t.Errorf("libs/conflict: %+v", l)
|
|
}
|
|
|
|
// commits: detached and unreachable are lost, on a branch they are not
|
|
ui := filepath.Join(super, "src", "ui")
|
|
git(t, ui, "checkout", "-q", "--detach")
|
|
git(t, ui, "commit", "-q", "--allow-empty", "-m", "detached work")
|
|
if l := loss("src/ui"); l.Commits != 1 {
|
|
t.Errorf("detached commit: %+v", l)
|
|
}
|
|
git(t, ui, "switch", "-q", "-c", "wip")
|
|
if l := loss("src/ui"); l.Commits != 0 {
|
|
t.Errorf("commit on a branch: %+v", l)
|
|
}
|
|
|
|
// a clone nobody added as a submodule
|
|
git(t, super, "clone", "-q", filepath.Join(root, "remotes", "core.git"), "stray")
|
|
if l := loss(""); l.Repositories != 1 {
|
|
t.Errorf("root: %+v, want one standalone repository", l)
|
|
}
|
|
}
|
|
|
|
func TestRestoreRemovesLeftoversAndEndsRebase(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
ctx := context.Background()
|
|
|
|
// a standalone clone is deleted
|
|
git(t, super, "clone", "-q", filepath.Join(root, "remotes", "core.git"), "stray")
|
|
|
|
// a submodule the branch no longer has leaves its directory behind
|
|
git(t, super, "rm", "-q", "--cached", "libs/topic")
|
|
git(t, super, "commit", "-q", "-m", "Drop topic")
|
|
|
|
// a rebase in progress in vendor; the branches must survive
|
|
v := filepath.Join(super, "vendor")
|
|
base := out(t, v, "rev-parse", "HEAD")
|
|
git(t, v, "switch", "-q", "-c", "x")
|
|
os.WriteFile(filepath.Join(v, "README"), []byte("x\n"), 0o644)
|
|
git(t, v, "commit", "-q", "-am", "x")
|
|
git(t, v, "switch", "-q", "-c", "y", base)
|
|
os.WriteFile(filepath.Join(v, "README"), []byte("y\n"), 0o644)
|
|
git(t, v, "commit", "-q", "-am", "y")
|
|
yTip := out(t, v, "rev-parse", "y")
|
|
_ = exec.Command("git", "-C", v, "rebase", "x").Run() // conflicts
|
|
if !exists(filepath.Join(out(t, v, "rev-parse", "--absolute-git-dir"), "rebase-merge")) {
|
|
t.Fatal("setup: no rebase in progress")
|
|
}
|
|
|
|
if err := p.Restore(ctx, "", submodule.RestoreStaged); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, gone := range []string{"stray", "libs/topic"} {
|
|
if exists(filepath.Join(super, gone)) {
|
|
t.Errorf("%s still exists", gone)
|
|
}
|
|
}
|
|
if exists(filepath.Join(out(t, v, "rev-parse", "--absolute-git-dir"), "rebase-merge")) {
|
|
t.Error("rebase still in progress")
|
|
}
|
|
if got := out(t, v, "rev-parse", "y"); got != yTip {
|
|
t.Errorf("branch y moved: %s -> %s", yTip, got)
|
|
}
|
|
assertExact(t, super)
|
|
}
|
|
|
|
func TestRestoreClonesAMissingSubmodule(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
p.extraEnv = []string{"GIT_CONFIG_COUNT=1", "GIT_CONFIG_KEY_0=protocol.file.allow", "GIT_CONFIG_VALUE_0=always"}
|
|
super := filepath.Join(root, "super")
|
|
|
|
// no object database left: it must be cloned again
|
|
if err := os.RemoveAll(filepath.Join(super, ".git", "modules", "libs", "missing")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := p.Restore(context.Background(), "libs/missing", submodule.RestoreStaged); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !exists(filepath.Join(super, "libs", "missing", ".git")) {
|
|
t.Error("not cloned")
|
|
}
|
|
if got, want := out(t, filepath.Join(super, "libs", "missing"), "rev-parse", "HEAD"), strings.Fields(out(t, super, "ls-files", "-s", "libs/missing"))[1]; got != want {
|
|
t.Errorf("HEAD = %s, want pin %s", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRestoreReportsAnUnavailablePin(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
// pin a commit that exists on no remote and not in the submodule
|
|
core := filepath.Join(super, "src", "core")
|
|
bogus := "0123456789abcdef0123456789abcdef01234567"
|
|
git(t, super, "update-index", "--cacheinfo", "160000,"+bogus+",src/core")
|
|
_ = core
|
|
err := p.Restore(context.Background(), "src/core", submodule.RestoreStaged)
|
|
if err == nil || !strings.Contains(err.Error(), "not available") {
|
|
t.Fatalf("err = %v, want a message about the unavailable commit", err)
|
|
}
|
|
}
|
|
|
|
func TestRestoreIgnoresUpdateNoneAndInactive(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
git(t, super, "config", "submodule.libs/missing.update", "none")
|
|
git(t, super, "config", "submodule.libs/missing.active", "false")
|
|
git(t, super, "config", "submodule.active", "src")
|
|
|
|
if err := p.Restore(context.Background(), "", submodule.RestoreStaged); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !exists(filepath.Join(super, "libs", "missing", ".git")) {
|
|
t.Error("libs/missing not initialized")
|
|
}
|
|
assertExact(t, super)
|
|
}
|
|
|
|
func TestRestoreKeepsNestedStagedPinAndResetsToIt(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
log := filepath.Join(super, "libs", "log")
|
|
nested := filepath.Join(log, "modules", "nested")
|
|
|
|
// stage a new pin of nested in libs/log, then change nested again
|
|
git(t, nested, "commit", "-q", "-am", "Nested work")
|
|
staged := out(t, nested, "rev-parse", "HEAD")
|
|
git(t, log, "add", "modules/nested")
|
|
os.WriteFile(filepath.Join(nested, "README"), []byte("more\n"), 0o644)
|
|
|
|
if l, err := p.RestoreLoss(context.Background(), "", submodule.RestoreStaged); err != nil || l.StagedPins != 0 || l.Files == 0 {
|
|
t.Fatalf("loss %+v, %v: want the change, not the staged pin", l, err)
|
|
}
|
|
if err := p.Restore(context.Background(), "", submodule.RestoreStaged); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := out(t, log, "diff", "--cached", "--name-only"); got != "modules/nested" {
|
|
t.Errorf("libs/log staged = %q, want the nested pin", got)
|
|
}
|
|
if got := out(t, nested, "rev-parse", "HEAD"); got != staged {
|
|
t.Errorf("nested HEAD = %s, want the staged pin %s", got, staged)
|
|
}
|
|
assertExact(t, super)
|
|
}
|
|
|
|
func TestRestoreCommittedUnstagesThePin(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
committed := strings.Fields(out(t, super, "ls-tree", "HEAD", "libs/staged"))[2]
|
|
|
|
if err := p.Restore(context.Background(), "libs/staged", submodule.RestoreCommitted); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := out(t, super, "diff", "--cached", "--name-only"); strings.Contains(got, "libs/staged") {
|
|
t.Errorf("still staged: %q", got)
|
|
}
|
|
if got := out(t, filepath.Join(super, "libs", "staged"), "rev-parse", "HEAD"); got != committed {
|
|
t.Errorf("HEAD = %s, want the committed pin %s", got, committed)
|
|
}
|
|
}
|
|
|
|
func TestRestoreLossCountsStagedPinsOfAMovingRepository(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
log := filepath.Join(super, "libs", "log")
|
|
nested := filepath.Join(log, "modules", "nested")
|
|
|
|
// libs/log moves on (off pin, on its branch) and stages a nested pin
|
|
git(t, nested, "commit", "-q", "-am", "Nested work")
|
|
git(t, log, "add", "modules/nested")
|
|
git(t, log, "commit", "-q", "--allow-empty", "-m", "Log work")
|
|
git(t, nested, "commit", "-q", "--allow-empty", "-m", "More nested work")
|
|
git(t, log, "add", "modules/nested")
|
|
|
|
l, err := p.RestoreLoss(context.Background(), "libs/log", submodule.RestoreStaged)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// the nested commits are on a detached HEAD that moves back: lost too
|
|
if l.StagedPins != 1 || l.Commits != 2 {
|
|
t.Errorf("loss %+v, want 1 staged pin and the 2 detached nested commits", l)
|
|
}
|
|
}
|
|
|
|
// restoreSub restores the submodule path and returns the branch its HEAD is
|
|
// on ("" if detached).
|
|
func restoreSub(t *testing.T, p *Provider, super, path string) string {
|
|
t.Helper()
|
|
if err := p.Restore(context.Background(), path, submodule.RestoreStaged); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return out(t, filepath.Join(super, filepath.FromSlash(path)), "branch", "--show-current")
|
|
}
|
|
|
|
func TestRestoreAttachesTheLocalBranchTrackingTheRef(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
// src/ui: in sync, the pin is behind origin/main, local main is at the pin
|
|
git(t, filepath.Join(super, "src", "ui"), "checkout", "-q", "--detach")
|
|
git(t, filepath.Join(super, "src", "ui"), "branch", "aaa") // alphabetically first, but no ref
|
|
|
|
if got := restoreSub(t, p, super, "src/ui"); got != "main" {
|
|
t.Errorf("branch = %q, want main", got)
|
|
}
|
|
}
|
|
|
|
func TestRestoreCreatesTheRefBranchBeforeOtherBranches(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
log := filepath.Join(super, "libs", "log")
|
|
// libs/log: the pin is the tip of origin/main and origin/archive
|
|
git(t, log, "checkout", "-q", "--detach")
|
|
git(t, log, "branch", "-D", "main")
|
|
|
|
if got := restoreSub(t, p, super, "libs/log"); got != "main" {
|
|
t.Errorf("branch = %q, want main", got)
|
|
}
|
|
if up := out(t, log, "rev-parse", "--abbrev-ref", "main@{upstream}"); up != "origin/main" {
|
|
t.Errorf("upstream = %q, want origin/main", up)
|
|
}
|
|
if out(t, log, "branch", "--list", "archive") != "" {
|
|
t.Error("archive must not be created")
|
|
}
|
|
}
|
|
|
|
func TestRestoreCreatesARemoteFeatureBranch(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
topic := filepath.Join(super, "libs", "topic")
|
|
mainTip := out(t, topic, "rev-parse", "main")
|
|
// libs/topic: detached at the tip of origin/feat/search, local main elsewhere
|
|
|
|
if got := restoreSub(t, p, super, "libs/topic"); got != "feat/search" {
|
|
t.Errorf("branch = %q, want feat/search", got)
|
|
}
|
|
if got := out(t, topic, "rev-parse", "main"); got != mainTip {
|
|
t.Errorf("main moved: %s -> %s", mainTip, got)
|
|
}
|
|
}
|
|
|
|
func TestRestorePrefersLocalBranchesAlphabetically(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
feature := filepath.Join(super, "libs", "feature")
|
|
// libs/feature: the pin is on no branch tip
|
|
git(t, feature, "branch", "zz")
|
|
git(t, feature, "branch", "aa")
|
|
|
|
if got := restoreSub(t, p, super, "libs/feature"); got != "aa" {
|
|
t.Errorf("branch = %q, want aa", got)
|
|
}
|
|
}
|
|
|
|
func TestRestoreNeverMovesALocalBranchToAttach(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
topic := filepath.Join(super, "libs", "topic")
|
|
git(t, topic, "branch", "feat/search", "origin/main") // same name, elsewhere
|
|
before := out(t, topic, "rev-parse", "feat/search")
|
|
|
|
if got := restoreSub(t, p, super, "libs/topic"); got != "" {
|
|
t.Errorf("branch = %q, want detached", got)
|
|
}
|
|
if after := out(t, topic, "rev-parse", "feat/search"); after != before {
|
|
t.Errorf("feat/search moved: %s -> %s", before, after)
|
|
}
|
|
}
|
|
|
|
func TestRestoreKeepsTheCheckedOutBranch(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
log := filepath.Join(super, "libs", "log")
|
|
git(t, log, "switch", "-q", "-c", "zz") // at the pin, like main
|
|
|
|
if got := restoreSub(t, p, super, "libs/log"); got != "zz" {
|
|
t.Errorf("branch = %q, want zz kept", got)
|
|
}
|
|
}
|
|
|
|
func TestRestoreSkipsABranchOfAnotherWorktree(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
log := filepath.Join(super, "libs", "log")
|
|
git(t, log, "checkout", "-q", "--detach")
|
|
git(t, log, "worktree", "add", "-q", filepath.Join(root, "wt"), "main")
|
|
|
|
if got := restoreSub(t, p, super, "libs/log"); got == "main" {
|
|
t.Error("main is checked out in another worktree")
|
|
}
|
|
}
|
|
|
|
func TestRestoreSuperprojectAttachesNestedSubmodules(t *testing.T) {
|
|
p, root := ownFixture(t)
|
|
super := filepath.Join(root, "super")
|
|
nested := filepath.Join(super, "libs", "log", "modules", "nested")
|
|
git(t, nested, "checkout", "-q", "--detach")
|
|
|
|
if err := p.Restore(context.Background(), "", submodule.RestoreStaged); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := out(t, nested, "branch", "--show-current"); got != "main" {
|
|
t.Errorf("nested branch = %q, want main", got)
|
|
}
|
|
if got := out(t, filepath.Join(super, "libs", "topic"), "branch", "--show-current"); got != "feat/search" {
|
|
t.Errorf("libs/topic branch = %q, want feat/search", got)
|
|
}
|
|
if got := out(t, super, "branch", "--show-current"); got != "main" {
|
|
t.Errorf("superproject branch = %q, want main", got)
|
|
}
|
|
}
|