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 "syscall"
11 "testing"
12 "time"
13)
14
15func TestResolveAndHoldTagRef(t *testing.T) {
16 if _, err := exec.LookPath("git"); err != nil {
17 t.Skip("git ontbreekt")
18 }
19 ctx := context.Background()
20 bare, work := testRepo(t)
21 sha := gitSHA(t, bare, "HEAD")
22 gitOK(t, bare, "tag", "lite", sha)
23 gitOK(t, bare, "tag", "-a", "ann", sha, "-m", "notitie")
24
25 lite, err := ResolveTag(ctx, "git", bare, "lite")
26 if err != nil {
27 t.Fatal(err)
28 }
29 if lite.ObjectOID != sha || lite.CommitOID != sha || lite.Ref != "refs/tags/lite" {
30 t.Fatalf("lightweight: %+v", lite)
31 }
32 ann, err := ResolveTag(ctx, "git", bare, "ann")
33 if err != nil {
34 t.Fatal(err)
35 }
36 if ann.ObjectOID == ann.CommitOID || ann.CommitOID != sha {
37 t.Fatalf("annotated: %+v", ann)
38 }
39 if _, err := ResolveTag(ctx, "git", bare, "weg"); !errors.Is(err, ErrTagMissing) {
40 t.Fatalf("ontbrekend: %v", err)
41 }
42 gitOK(t, bare, "symbolic-ref", "refs/tags/sym", "refs/heads/master")
43 if _, err := ResolveTag(ctx, "git", bare, "sym"); !errors.Is(err, ErrTagSymbolic) {
44 t.Fatalf("symbolisch: %v", err)
45 }
46 tree := gitSHA(t, bare, "HEAD^{tree}")
47 gitOK(t, bare, "update-ref", "refs/tags/boom", tree)
48 if _, err := ResolveTag(ctx, "git", bare, "boom"); !errors.Is(err, ErrTagNotCommit) {
49 t.Fatalf("boom: %v", err)
50 }
51
52 hold, err := HoldTagRef(ctx, "git", bare, "lite", lite.ObjectOID)
53 if err != nil {
54 t.Fatal(err)
55 }
56 if err := exec.Command("git", "-C", bare, "update-ref", "refs/heads/side", sha).Run(); err != nil {
57 t.Fatalf("andere ref: %v", err)
58 }
59 del := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/lite")
60 if err := del.Run(); err == nil {
61 t.Fatal("delete moest de lock zien")
62 }
63 if got := gitSHA(t, bare, "refs/tags/lite"); got != sha {
64 t.Fatalf("tag veranderde onder de lock: %s", got)
65 }
66 if err := hold.Release(); err != nil {
67 t.Fatal(err)
68 }
69 if _, err := os.Stat(filepath.Join(bare, "refs", "tags", "lite.lock")); !os.IsNotExist(err) {
70 t.Fatalf("lock bleef na abort: %v", err)
71 }
72 if err := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/lite").Run(); err != nil {
73 t.Fatalf("delete na abort: %v", err)
74 }
75 gitOK(t, bare, "tag", "lite", sha)
76
77 moved := commitNew(t, bare, sha)
78 if _, err := HoldTagRef(ctx, "git", bare, "lite", moved); !errors.Is(err, ErrTagMoved) {
79 t.Fatalf("verkeerde oid: %v", err)
80 }
81 if got := gitSHA(t, bare, "refs/tags/lite"); got != sha {
82 t.Fatalf("verify mocht de tag niet schrijven: %s", got)
83 }
84
85 gitOK(t, bare, "update-ref", "-d", "refs/tags/sym")
86 gitOK(t, bare, "update-ref", "-d", "refs/tags/boom")
87 gitOK(t, bare, "pack-refs", "--all")
88 packed, err := os.ReadFile(filepath.Join(bare, "packed-refs"))
89 if err != nil || !strings.Contains(string(packed), "refs/tags/ann") {
90 t.Fatalf("packed-refs: %v %s", err, packed)
91 }
92 hold, err = HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
93 if err != nil {
94 t.Fatal(err)
95 }
96 if err := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/ann").Run(); err == nil {
97 t.Fatal("packed delete moest falen")
98 }
99 if err := hold.Release(); err != nil {
100 t.Fatal(err)
101 }
102 if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID {
103 t.Fatalf("annotated object veranderde: %s", got)
104 }
105
106 // Tweede lock wacht tot de eerste abort, en krijgt hem dan.
107 first, err := HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
108 if err != nil {
109 t.Fatal(err)
110 }
111 gotHold := make(chan error, 1)
112 go func() {
113 second, err := HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
114 if err != nil {
115 gotHold <- err
116 return
117 }
118 gotHold <- second.Release()
119 }()
120 time.Sleep(40 * time.Millisecond)
121 select {
122 case err := <-gotHold:
123 t.Fatalf("tweede lock was te vroeg: %v", err)
124 default:
125 }
126 if err := first.Release(); err != nil {
127 t.Fatal(err)
128 }
129 select {
130 case err := <-gotHold:
131 if err != nil {
132 t.Fatal(err)
133 }
134 case <-time.After(3 * time.Second):
135 t.Fatal("tweede lock kwam niet vrij")
136 }
137
138 // receive-pack kan de ref niet verplaatsen zolang prepare vastzit.
139 gitOK(t, work, "fetch", "origin", "tag", "ann")
140 if err := os.WriteFile(filepath.Join(work, "f"), []byte("b\n"), 0o644); err != nil {
141 t.Fatal(err)
142 }
143 gitOK(t, work, "add", "f")
144 gitOK(t, work, "commit", "-qm", "verder")
145 hold, err = HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
146 if err != nil {
147 t.Fatal(err)
148 }
149 push := exec.Command("git", "-C", work, "push", "origin", ":refs/tags/ann")
150 if err := push.Run(); err == nil {
151 t.Fatal("receive-pack delete moest falen")
152 }
153 if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID {
154 t.Fatalf("tijdens push: %s", got)
155 }
156 force := exec.Command("git", "-C", work, "push", "--force", "origin", "HEAD:refs/tags/ann")
157 if err := force.Run(); err == nil {
158 t.Fatal("receive-pack force moest falen")
159 }
160 if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID {
161 t.Fatalf("na force: %s", got)
162 }
163 if err := hold.Release(); err != nil {
164 t.Fatal(err)
165 }
166 if err := exec.Command("git", "-C", work, "push", "origin", ":refs/tags/ann").Run(); err != nil {
167 t.Fatalf("delete na release: %v", err)
168 }
169}
170
171func TestTagRefKillDoesNotDeleteLockfile(t *testing.T) {
172 if _, err := exec.LookPath("git"); err != nil {
173 t.Skip("git ontbreekt")
174 }
175 bare, _ := testRepo(t)
176 sha := gitSHA(t, bare, "HEAD")
177 gitOK(t, bare, "tag", "v1", sha)
178 hold, err := HoldTagRef(context.Background(), "git", bare, "v1", sha)
179 if err != nil {
180 t.Fatal(err)
181 }
182 pid := hold.inner.cmd.Process.Pid
183 _ = syscall.Kill(pid, syscall.SIGKILL)
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}