BlueGit

timfa bluegit

Files

bluegit / internal / gitrepo / refhold_test.go

refhold_test.go

refhold_test.go 8.0 KiB Download Raw
1package gitrepo
2
3import (
4 "context"
5 "errors"
6 "os"
7 "os/exec"
8 "path/filepath"
9 "strings"
10 "testing"
11 "time"
12)
13
14func TestResolveAndHoldTagRef(t *testing.T) {
15 if _, err := exec.LookPath("git"); err != nil {
16 t.Skip("git ontbreekt")
17 }
18 ctx := context.Background()
19 bare, work := testRepo(t)
20 sha := gitSHA(t, bare, "HEAD")
21 gitOK(t, bare, "tag", "lite", sha)
22 gitOK(t, bare, "tag", "-a", "ann", sha, "-m", "notitie")
23
24 lite, err := ResolveTag(ctx, "git", bare, "lite")
25 if err != nil {
26 t.Fatal(err)
27 }
28 if lite.ObjectOID != sha || lite.CommitOID != sha || lite.Ref != "refs/tags/lite" {
29 t.Fatalf("lightweight: %+v", lite)
30 }
31 ann, err := ResolveTag(ctx, "git", bare, "ann")
32 if err != nil {
33 t.Fatal(err)
34 }
35 if ann.ObjectOID == ann.CommitOID || ann.CommitOID != sha {
36 t.Fatalf("annotated: %+v", ann)
37 }
38 if _, err := ResolveTag(ctx, "git", bare, "weg"); !errors.Is(err, ErrTagMissing) {
39 t.Fatalf("ontbrekend: %v", err)
40 }
41 gitOK(t, bare, "symbolic-ref", "refs/tags/sym", "refs/heads/master")
42 if _, err := ResolveTag(ctx, "git", bare, "sym"); !errors.Is(err, ErrTagSymbolic) {
43 t.Fatalf("symbolisch: %v", err)
44 }
45 tree := gitSHA(t, bare, "HEAD^{tree}")
46 gitOK(t, bare, "update-ref", "refs/tags/boom", tree)
47 if _, err := ResolveTag(ctx, "git", bare, "boom"); !errors.Is(err, ErrTagNotCommit) {
48 t.Fatalf("boom: %v", err)
49 }
50
51 hold, err := HoldTagRef(ctx, "git", bare, "lite", lite.ObjectOID)
52 if err != nil {
53 t.Fatal(err)
54 }
55 if err := exec.Command("git", "-C", bare, "update-ref", "refs/heads/side", sha).Run(); err != nil {
56 t.Fatalf("andere ref: %v", err)
57 }
58 del := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/lite")
59 if err := del.Run(); err == nil {
60 t.Fatal("delete moest de lock zien")
61 }
62 if got := gitSHA(t, bare, "refs/tags/lite"); got != sha {
63 t.Fatalf("tag veranderde onder de lock: %s", got)
64 }
65 if err := hold.Release(); err != nil {
66 t.Fatal(err)
67 }
68 if _, err := os.Stat(filepath.Join(bare, "refs", "tags", "lite.lock")); !os.IsNotExist(err) {
69 t.Fatalf("lock bleef na abort: %v", err)
70 }
71 if err := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/lite").Run(); err != nil {
72 t.Fatalf("delete na abort: %v", err)
73 }
74 gitOK(t, bare, "tag", "lite", sha)
75
76 moved := commitNew(t, bare, sha)
77 if _, err := HoldTagRef(ctx, "git", bare, "lite", moved); !errors.Is(err, ErrTagMoved) {
78 t.Fatalf("verkeerde oid: %v", err)
79 }
80 if got := gitSHA(t, bare, "refs/tags/lite"); got != sha {
81 t.Fatalf("verify mocht de tag niet schrijven: %s", got)
82 }
83
84 gitOK(t, bare, "update-ref", "-d", "refs/tags/sym")
85 gitOK(t, bare, "update-ref", "-d", "refs/tags/boom")
86 gitOK(t, bare, "pack-refs", "--all")
87 packed, err := os.ReadFile(filepath.Join(bare, "packed-refs"))
88 if err != nil || !strings.Contains(string(packed), "refs/tags/ann") {
89 t.Fatalf("packed-refs: %v %s", err, packed)
90 }
91 hold, err = HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
92 if err != nil {
93 t.Fatal(err)
94 }
95 if err := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/ann").Run(); err == nil {
96 t.Fatal("packed delete moest falen")
97 }
98 if err := hold.Release(); err != nil {
99 t.Fatal(err)
100 }
101 if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID {
102 t.Fatalf("annotated object veranderde: %s", got)
103 }
104
105 // Tweede lock wacht tot de eerste abort, en krijgt hem dan.
106 first, err := HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
107 if err != nil {
108 t.Fatal(err)
109 }
110 gotHold := make(chan error, 1)
111 go func() {
112 second, err := HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
113 if err != nil {
114 gotHold <- err
115 return
116 }
117 gotHold <- second.Release()
118 }()
119 time.Sleep(40 * time.Millisecond)
120 select {
121 case err := <-gotHold:
122 t.Fatalf("tweede lock was te vroeg: %v", err)
123 default:
124 }
125 if err := first.Release(); err != nil {
126 t.Fatal(err)
127 }
128 select {
129 case err := <-gotHold:
130 if err != nil {
131 t.Fatal(err)
132 }
133 case <-time.After(3 * time.Second):
134 t.Fatal("tweede lock kwam niet vrij")
135 }
136
137 // receive-pack kan de ref niet verplaatsen zolang prepare vastzit.
138 gitOK(t, work, "fetch", "origin", "tag", "ann")
139 if err := os.WriteFile(filepath.Join(work, "f"), []byte("b\n"), 0o644); err != nil {
140 t.Fatal(err)
141 }
142 gitOK(t, work, "add", "f")
143 gitOK(t, work, "commit", "-qm", "verder")
144 hold, err = HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
145 if err != nil {
146 t.Fatal(err)
147 }
148 push := exec.Command("git", "-C", work, "push", "origin", ":refs/tags/ann")
149 if err := push.Run(); err == nil {
150 t.Fatal("receive-pack delete moest falen")
151 }
152 if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID {
153 t.Fatalf("tijdens push: %s", got)
154 }
155 force := exec.Command("git", "-C", work, "push", "--force", "origin", "HEAD:refs/tags/ann")
156 if err := force.Run(); err == nil {
157 t.Fatal("receive-pack force moest falen")
158 }
159 if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID {
160 t.Fatalf("na force: %s", got)
161 }
162 if err := hold.Release(); err != nil {
163 t.Fatal(err)
164 }
165 if err := exec.Command("git", "-C", work, "push", "origin", ":refs/tags/ann").Run(); err != nil {
166 t.Fatalf("delete na release: %v", err)
167 }
168}
169
170func TestTagRefKillDoesNotDeleteLockfile(t *testing.T) {
171 if _, err := exec.LookPath("git"); err != nil {
172 t.Skip("git ontbreekt")
173 }
174 bare, _ := testRepo(t)
175 sha := gitSHA(t, bare, "HEAD")
176 gitOK(t, bare, "tag", "v1", sha)
177 hold, err := HoldTagRef(context.Background(), "git", bare, "v1", sha)
178 if err != nil {
179 t.Fatal(err)
180 }
181 if proc, err := os.FindProcess(hold.inner.cmd.Process.Pid); err == nil {
182 _ = proc.Kill()
183 }
184 _ = hold.Release()
185 if _, err := os.Stat(filepath.Join(bare, "refs", "tags", "v1.lock")); err != nil {
186 t.Fatalf("SIGKILL laat de lock van git staan, die ruimen we niet zelf: %v", err)
187 }
188}
189
190func TestTagRefStuckProcessExits(t *testing.T) {
191 old := refHoldReplyTimeout
192 refHoldReplyTimeout = 200 * time.Millisecond
193 t.Cleanup(func() { refHoldReplyTimeout = old })
194 pidfile := filepath.Join(t.TempDir(), "pid")
195 script := filepath.Join(t.TempDir(), "git")
196 body := "#!/bin/sh\necho $$ > " + quoteSh(pidfile) + "\nexec sleep 30\n"
197 if err := os.WriteFile(script, []byte(body), 0o755); err != nil {
198 t.Fatal(err)
199 }
200 bare := t.TempDir()
201 _, err := HoldTagRef(context.Background(), script, bare, "v1", strings.Repeat("a", 40))
202 if err == nil {
203 t.Fatal("vastgelopen git moest falen")
204 }
205 raw, err := os.ReadFile(pidfile)
206 if err != nil {
207 t.Fatal(err)
208 }
209 pid := strings.TrimSpace(string(raw))
210 if err := exec.Command("ps", "-p", pid).Run(); err == nil {
211 t.Fatalf("proces %s leeft nog", pid)
212 }
213}
214
215func testRepo(t *testing.T) (bare, work string) {
216 t.Helper()
217 bare = filepath.Join(t.TempDir(), "repo.git")
218 if err := Init("git", bare, "master", "/bin/true"); err != nil {
219 t.Fatal(err)
220 }
221 work = t.TempDir()
222 gitOK(t, work, "init", "-q", "-b", "master")
223 if err := os.WriteFile(filepath.Join(work, "f"), []byte("a\n"), 0o644); err != nil {
224 t.Fatal(err)
225 }
226 gitOK(t, work, "add", "f")
227 gitOK(t, work, "commit", "-qm", "init")
228 gitOK(t, work, "remote", "add", "origin", bare)
229 gitOK(t, work, "push", "-q", "origin", "master")
230 return bare, work
231}
232
233func gitOK(t *testing.T, dir string, args ...string) {
234 t.Helper()
235 cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
236 cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@x", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@x")
237 if out, err := cmd.CombinedOutput(); err != nil {
238 t.Fatalf("git %v: %v %s", args, err, out)
239 }
240}
241
242func gitSHA(t *testing.T, dir, rev string) string {
243 t.Helper()
244 cmd := exec.Command("git", "-C", dir, "rev-parse", "--verify", rev)
245 out, err := cmd.Output()
246 if err != nil {
247 t.Fatalf("rev-parse %s: %v", rev, err)
248 }
249 return strings.TrimSpace(string(out))
250}
251
252func commitNew(t *testing.T, bare, parent string) string {
253 t.Helper()
254 tree := gitSHA(t, bare, parent+"^{tree}")
255 cmd := exec.Command("git", "-C", bare, "commit-tree", tree, "-p", parent, "-m", "verder")
256 cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@x", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@x")
257 out, err := cmd.Output()
258 if err != nil {
259 t.Fatal(err)
260 }
261 return strings.TrimSpace(string(out))
262}
263
264func quoteSh(s string) string {
265 return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
266}