package gitrepo import ( "context" "errors" "os" "os/exec" "path/filepath" "strings" "testing" "time" ) func TestResolveAndHoldTagRef(t *testing.T) { if _, err := exec.LookPath("git"); err != nil { t.Skip("git ontbreekt") } ctx := context.Background() bare, work := testRepo(t) sha := gitSHA(t, bare, "HEAD") gitOK(t, bare, "tag", "lite", sha) gitOK(t, bare, "tag", "-a", "ann", sha, "-m", "notitie") lite, err := ResolveTag(ctx, "git", bare, "lite") if err != nil { t.Fatal(err) } if lite.ObjectOID != sha || lite.CommitOID != sha || lite.Ref != "refs/tags/lite" { t.Fatalf("lightweight: %+v", lite) } ann, err := ResolveTag(ctx, "git", bare, "ann") if err != nil { t.Fatal(err) } if ann.ObjectOID == ann.CommitOID || ann.CommitOID != sha { t.Fatalf("annotated: %+v", ann) } if _, err := ResolveTag(ctx, "git", bare, "weg"); !errors.Is(err, ErrTagMissing) { t.Fatalf("ontbrekend: %v", err) } gitOK(t, bare, "symbolic-ref", "refs/tags/sym", "refs/heads/master") if _, err := ResolveTag(ctx, "git", bare, "sym"); !errors.Is(err, ErrTagSymbolic) { t.Fatalf("symbolisch: %v", err) } tree := gitSHA(t, bare, "HEAD^{tree}") gitOK(t, bare, "update-ref", "refs/tags/boom", tree) if _, err := ResolveTag(ctx, "git", bare, "boom"); !errors.Is(err, ErrTagNotCommit) { t.Fatalf("boom: %v", err) } hold, err := HoldTagRef(ctx, "git", bare, "lite", lite.ObjectOID) if err != nil { t.Fatal(err) } if err := exec.Command("git", "-C", bare, "update-ref", "refs/heads/side", sha).Run(); err != nil { t.Fatalf("andere ref: %v", err) } del := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/lite") if err := del.Run(); err == nil { t.Fatal("delete moest de lock zien") } if got := gitSHA(t, bare, "refs/tags/lite"); got != sha { t.Fatalf("tag veranderde onder de lock: %s", got) } if err := hold.Release(); err != nil { t.Fatal(err) } if _, err := os.Stat(filepath.Join(bare, "refs", "tags", "lite.lock")); !os.IsNotExist(err) { t.Fatalf("lock bleef na abort: %v", err) } if err := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/lite").Run(); err != nil { t.Fatalf("delete na abort: %v", err) } gitOK(t, bare, "tag", "lite", sha) moved := commitNew(t, bare, sha) if _, err := HoldTagRef(ctx, "git", bare, "lite", moved); !errors.Is(err, ErrTagMoved) { t.Fatalf("verkeerde oid: %v", err) } if got := gitSHA(t, bare, "refs/tags/lite"); got != sha { t.Fatalf("verify mocht de tag niet schrijven: %s", got) } gitOK(t, bare, "update-ref", "-d", "refs/tags/sym") gitOK(t, bare, "update-ref", "-d", "refs/tags/boom") gitOK(t, bare, "pack-refs", "--all") packed, err := os.ReadFile(filepath.Join(bare, "packed-refs")) if err != nil || !strings.Contains(string(packed), "refs/tags/ann") { t.Fatalf("packed-refs: %v %s", err, packed) } hold, err = HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID) if err != nil { t.Fatal(err) } if err := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/ann").Run(); err == nil { t.Fatal("packed delete moest falen") } if err := hold.Release(); err != nil { t.Fatal(err) } if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID { t.Fatalf("annotated object veranderde: %s", got) } // Tweede lock wacht tot de eerste abort, en krijgt hem dan. first, err := HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID) if err != nil { t.Fatal(err) } gotHold := make(chan error, 1) go func() { second, err := HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID) if err != nil { gotHold <- err return } gotHold <- second.Release() }() time.Sleep(40 * time.Millisecond) select { case err := <-gotHold: t.Fatalf("tweede lock was te vroeg: %v", err) default: } if err := first.Release(); err != nil { t.Fatal(err) } select { case err := <-gotHold: if err != nil { t.Fatal(err) } case <-time.After(3 * time.Second): t.Fatal("tweede lock kwam niet vrij") } // receive-pack kan de ref niet verplaatsen zolang prepare vastzit. gitOK(t, work, "fetch", "origin", "tag", "ann") if err := os.WriteFile(filepath.Join(work, "f"), []byte("b\n"), 0o644); err != nil { t.Fatal(err) } gitOK(t, work, "add", "f") gitOK(t, work, "commit", "-qm", "verder") hold, err = HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID) if err != nil { t.Fatal(err) } push := exec.Command("git", "-C", work, "push", "origin", ":refs/tags/ann") if err := push.Run(); err == nil { t.Fatal("receive-pack delete moest falen") } if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID { t.Fatalf("tijdens push: %s", got) } force := exec.Command("git", "-C", work, "push", "--force", "origin", "HEAD:refs/tags/ann") if err := force.Run(); err == nil { t.Fatal("receive-pack force moest falen") } if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID { t.Fatalf("na force: %s", got) } if err := hold.Release(); err != nil { t.Fatal(err) } if err := exec.Command("git", "-C", work, "push", "origin", ":refs/tags/ann").Run(); err != nil { t.Fatalf("delete na release: %v", err) } } func TestTagRefKillDoesNotDeleteLockfile(t *testing.T) { if _, err := exec.LookPath("git"); err != nil { t.Skip("git ontbreekt") } bare, _ := testRepo(t) sha := gitSHA(t, bare, "HEAD") gitOK(t, bare, "tag", "v1", sha) hold, err := HoldTagRef(context.Background(), "git", bare, "v1", sha) if err != nil { t.Fatal(err) } if proc, err := os.FindProcess(hold.inner.cmd.Process.Pid); err == nil { _ = proc.Kill() } _ = hold.Release() if _, err := os.Stat(filepath.Join(bare, "refs", "tags", "v1.lock")); err != nil { t.Fatalf("SIGKILL laat de lock van git staan, die ruimen we niet zelf: %v", err) } } func TestTagRefStuckProcessExits(t *testing.T) { old := refHoldReplyTimeout refHoldReplyTimeout = 200 * time.Millisecond t.Cleanup(func() { refHoldReplyTimeout = old }) pidfile := filepath.Join(t.TempDir(), "pid") script := filepath.Join(t.TempDir(), "git") body := "#!/bin/sh\necho $$ > " + quoteSh(pidfile) + "\nexec sleep 30\n" if err := os.WriteFile(script, []byte(body), 0o755); err != nil { t.Fatal(err) } bare := t.TempDir() _, err := HoldTagRef(context.Background(), script, bare, "v1", strings.Repeat("a", 40)) if err == nil { t.Fatal("vastgelopen git moest falen") } raw, err := os.ReadFile(pidfile) if err != nil { t.Fatal(err) } pid := strings.TrimSpace(string(raw)) if err := exec.Command("ps", "-p", pid).Run(); err == nil { t.Fatalf("proces %s leeft nog", pid) } } func testRepo(t *testing.T) (bare, work string) { t.Helper() bare = filepath.Join(t.TempDir(), "repo.git") if err := Init("git", bare, "master", "/bin/true"); err != nil { t.Fatal(err) } work = t.TempDir() gitOK(t, work, "init", "-q", "-b", "master") if err := os.WriteFile(filepath.Join(work, "f"), []byte("a\n"), 0o644); err != nil { t.Fatal(err) } gitOK(t, work, "add", "f") gitOK(t, work, "commit", "-qm", "init") gitOK(t, work, "remote", "add", "origin", bare) gitOK(t, work, "push", "-q", "origin", "master") return bare, work } func gitOK(t *testing.T, dir string, args ...string) { t.Helper() cmd := exec.Command("git", append([]string{"-C", dir}, args...)...) cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@x", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@x") if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("git %v: %v %s", args, err, out) } } func gitSHA(t *testing.T, dir, rev string) string { t.Helper() cmd := exec.Command("git", "-C", dir, "rev-parse", "--verify", rev) out, err := cmd.Output() if err != nil { t.Fatalf("rev-parse %s: %v", rev, err) } return strings.TrimSpace(string(out)) } func commitNew(t *testing.T, bare, parent string) string { t.Helper() tree := gitSHA(t, bare, parent+"^{tree}") cmd := exec.Command("git", "-C", bare, "commit-tree", tree, "-p", parent, "-m", "verder") cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@x", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@x") out, err := cmd.Output() if err != nil { t.Fatal(err) } return strings.TrimSpace(string(out)) } func quoteSh(s string) string { return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'" }