internal/control/build_test.go
718 lines · 27828 bytes
1package control
2
3import (
4 "bytes"
5 "os"
6 "os/exec"
7 "path/filepath"
8 "strings"
9 "testing"
10 "time"
11
12 "gitbay.org/gitbay/internal/protocol"
13 "gitbay.org/gitbay/internal/store"
14)
15
16const testZeroSHA = "0000000000000000000000000000000000000000"
17
18// gitTestEnv sets up an isolated git identity so tests never touch a
19// developer's real config.
20func gitTestEnv() []string {
21 return append(os.Environ(),
22 "GIT_CONFIG_NOSYSTEM=1", "GIT_CONFIG_GLOBAL=/dev/null",
23 "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@example.test",
24 "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@example.test")
25}
26
27func gitRunner(t *testing.T) func(dir string, args ...string) string {
28 t.Helper()
29 env := gitTestEnv()
30 return func(dir string, args ...string) string {
31 t.Helper()
32 cmd := exec.Command("git", args...)
33 cmd.Dir = dir
34 cmd.Env = env
35 out, err := cmd.CombinedOutput()
36 if err != nil {
37 t.Fatalf("git %v: %v\n%s", args, err, out)
38 }
39 return string(out)
40 }
41}
42
43// newQueueTestRepo returns a store with one public repo (default branch
44// "main", matching the schema default) and the uid to queue builds as.
45//
46// A real file, not ":memory:": ":memory:" gives each connection its own
47// database, so a goroutine querying while another writes (build log
48// --follow) sees an empty schema (see internal/store/contention_test.go).
49func newQueueTestRepo(t *testing.T) (*store.Store, store.Repo, int64) {
50 t.Helper()
51 st, err := store.Open(filepath.Join(t.TempDir(), "gitbay.db"))
52 if err != nil {
53 t.Fatal(err)
54 }
55 t.Cleanup(func() { st.Close() })
56 if err := st.MigrateUp(); err != nil {
57 t.Fatal(err)
58 }
59 uid, err := st.CreateUser("alice", false)
60 if err != nil {
61 t.Fatal(err)
62 }
63 repoID, err := st.CreateRepo("user", uid, "app", "public")
64 if err != nil {
65 t.Fatal(err)
66 }
67 repo, err := st.RepoByID(repoID)
68 if err != nil {
69 t.Fatal(err)
70 }
71 return st, repo, uid
72}
73
74// A DiffFiles failure must not turn into a silent skip: when the old sha
75// on record cannot be diffed against, every job runs regardless of what
76// it names in paths, the same as when there is no diff base at all.
77func TestQueueBranchBuildsFailsOpenOnDiffFailure(t *testing.T) {
78 st, repo, uid := newQueueTestRepo(t)
79 git := gitRunner(t)
80
81 root := t.TempDir()
82
83 // A job whose paths would exclude a docs-only change, so the test
84 // proves something: without fail-open, the diff failure would leave
85 // the filter unevaluated and this build would never queue.
86 src := filepath.Join(root, "src")
87 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
88 os.MkdirAll(filepath.Join(src, "docs"), 0o755)
89 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
90 "jobs:\n unit:\n paths:\n - src/**\n steps:\n - echo hi\n"), 0o644)
91 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x\n"), 0o644)
92 git(root, "init", "-q", "-b", "main", "src")
93 git(src, "add", ".")
94 git(src, "commit", "-q", "-m", "base")
95 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x changed\n"), 0o644)
96 git(src, "add", ".")
97 git(src, "commit", "-q", "-m", "docs only")
98 newSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
99
100 dir := RepoDir(root, repo.OwnerName, repo.Name)
101 os.MkdirAll(filepath.Dir(dir), 0o755)
102 git(root, "clone", "-q", "--bare", src, dir)
103
104 // Well-formed but names no object in this repo: git diff itself
105 // fails, rather than the empty/all-zero short-circuit HasDiffBase
106 // already covers.
107 old := strings.Repeat("1", 40)
108
109 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", old, newSHA, time.Now())
110
111 builds, err := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
112 if err != nil || len(builds) != 1 {
113 t.Fatalf("builds after queue: %v %v", builds, err)
114 }
115 if builds[0].Job != "unit" || builds[0].Status != "pending" || builds[0].SHA != newSHA {
116 t.Fatalf("queued build wrong: %+v", builds[0])
117 }
118}
119
120// A new branch's first push carries no old sha, but a diff base still
121// exists: the merge base with the default branch. A push whose commits
122// only touch paths a job ignores must not queue that job, or path
123// filters never do anything on the ordinary branch-then-MR workflow.
124func TestQueueBranchBuildsNewBranchIgnoredPathSkips(t *testing.T) {
125 st, repo, uid := newQueueTestRepo(t)
126 git := gitRunner(t)
127 root := t.TempDir()
128
129 src := filepath.Join(root, "src")
130 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
131 os.MkdirAll(filepath.Join(src, "docs"), 0o755)
132 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
133 "jobs:\n unit:\n paths-ignore:\n - docs/**\n steps:\n - echo hi\n"), 0o644)
134 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x\n"), 0o644)
135 git(root, "init", "-q", "-b", "main", "src")
136 git(src, "add", ".")
137 git(src, "commit", "-q", "-m", "base")
138
139 git(src, "checkout", "-q", "-b", "feature")
140 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x changed\n"), 0o644)
141 git(src, "add", ".")
142 git(src, "commit", "-q", "-m", "docs only")
143 featureSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
144
145 dir := RepoDir(root, repo.OwnerName, repo.Name)
146 os.MkdirAll(filepath.Dir(dir), 0o755)
147 git(root, "clone", "-q", "--bare", src, dir)
148
149 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "feature", testZeroSHA, featureSHA, time.Now())
150
151 builds, err := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
152 if err != nil {
153 t.Fatal(err)
154 }
155 if len(builds) != 0 {
156 t.Fatalf("docs-only push on a new branch queued a build: %+v", builds)
157 }
158}
159
160// The same new-branch push, but touching a path the job cares about:
161// the merge-base diff must still let it through.
162func TestQueueBranchBuildsNewBranchMatchedPathQueues(t *testing.T) {
163 st, repo, uid := newQueueTestRepo(t)
164 git := gitRunner(t)
165 root := t.TempDir()
166
167 src := filepath.Join(root, "src")
168 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
169 os.MkdirAll(filepath.Join(src, "src"), 0o755)
170 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
171 "jobs:\n unit:\n paths:\n - src/**\n steps:\n - echo hi\n"), 0o644)
172 os.WriteFile(filepath.Join(src, "src", "x.go"), []byte("package x\n"), 0o644)
173 git(root, "init", "-q", "-b", "main", "src")
174 git(src, "add", ".")
175 git(src, "commit", "-q", "-m", "base")
176
177 git(src, "checkout", "-q", "-b", "feature")
178 os.WriteFile(filepath.Join(src, "src", "x.go"), []byte("package x\n\nvar y int\n"), 0o644)
179 git(src, "add", ".")
180 git(src, "commit", "-q", "-m", "src change")
181 featureSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
182
183 dir := RepoDir(root, repo.OwnerName, repo.Name)
184 os.MkdirAll(filepath.Dir(dir), 0o755)
185 git(root, "clone", "-q", "--bare", src, dir)
186
187 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "feature", testZeroSHA, featureSHA, time.Now())
188
189 builds, err := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
190 if err != nil || len(builds) != 1 {
191 t.Fatalf("builds after queue: %v %v", builds, err)
192 }
193 if builds[0].Job != "unit" || builds[0].SHA != featureSHA {
194 t.Fatalf("queued build wrong: %+v", builds[0])
195 }
196}
197
198// When the new branch shares no history with the default branch, the
199// merge base cannot be computed. That must fail open, same as any other
200// diff base that cannot be evaluated.
201func TestQueueBranchBuildsNewBranchFailsOpenWithoutMergeBase(t *testing.T) {
202 st, repo, uid := newQueueTestRepo(t)
203 git := gitRunner(t)
204 root := t.TempDir()
205
206 dir := RepoDir(root, repo.OwnerName, repo.Name)
207 os.MkdirAll(filepath.Dir(dir), 0o755)
208 git(root, "init", "-q", "--bare", dir)
209
210 mainSrc := filepath.Join(root, "main-src")
211 os.MkdirAll(filepath.Join(mainSrc, ".gitbay"), 0o755)
212 os.WriteFile(filepath.Join(mainSrc, ".gitbay", "ci.yml"), []byte(
213 "jobs:\n unit:\n paths-ignore:\n - docs/**\n steps:\n - echo hi\n"), 0o644)
214 git(root, "init", "-q", "-b", "main", "main-src")
215 git(mainSrc, "add", ".")
216 git(mainSrc, "commit", "-q", "-m", "base")
217 git(mainSrc, "push", "-q", dir, "main")
218
219 // An unrelated repository: no common commit with main.
220 otherSrc := filepath.Join(root, "other-src")
221 os.MkdirAll(filepath.Join(otherSrc, ".gitbay"), 0o755)
222 os.MkdirAll(filepath.Join(otherSrc, "docs"), 0o755)
223 os.WriteFile(filepath.Join(otherSrc, ".gitbay", "ci.yml"), []byte(
224 "jobs:\n unit:\n paths-ignore:\n - docs/**\n steps:\n - echo hi\n"), 0o644)
225 os.WriteFile(filepath.Join(otherSrc, "docs", "x.md"), []byte("# x\n"), 0o644)
226 git(root, "init", "-q", "-b", "feature", "other-src")
227 git(otherSrc, "add", ".")
228 git(otherSrc, "commit", "-q", "-m", "unrelated docs-only")
229 otherSHA := strings.TrimSpace(git(otherSrc, "rev-parse", "HEAD"))
230 git(otherSrc, "push", "-q", dir, "feature")
231
232 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "feature", testZeroSHA, otherSHA, time.Now())
233
234 builds, err := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
235 if err != nil || len(builds) != 1 {
236 t.Fatalf("expected fail-open to queue the job: %v %v", builds, err)
237 }
238}
239
240// The first push to a brand-new repository moves the default branch
241// itself with no prior commit: the merge base of the default branch
242// against its own tip is the tip, which carries no diff. That must
243// fail open rather than read as "nothing changed".
244func TestQueueBranchBuildsFreshDefaultBranchFailsOpen(t *testing.T) {
245 st, repo, uid := newQueueTestRepo(t)
246 git := gitRunner(t)
247 root := t.TempDir()
248
249 src := filepath.Join(root, "src")
250 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
251 os.MkdirAll(filepath.Join(src, "docs"), 0o755)
252 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
253 "jobs:\n unit:\n paths:\n - src/**\n steps:\n - echo hi\n"), 0o644)
254 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x\n"), 0o644)
255 git(root, "init", "-q", "-b", "main", "src")
256 git(src, "add", ".")
257 git(src, "commit", "-q", "-m", "initial")
258 sha := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
259
260 dir := RepoDir(root, repo.OwnerName, repo.Name)
261 os.MkdirAll(filepath.Dir(dir), 0o755)
262 git(root, "clone", "-q", "--bare", src, dir)
263
264 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", testZeroSHA, sha, time.Now())
265
266 builds, err := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
267 if err != nil || len(builds) != 1 {
268 t.Fatalf("expected fail-open on the repository's first commit: %v %v", builds, err)
269 }
270}
271
272// An ordinary push with a genuine old sha is unaffected by the
273// new-branch handling: filtering still works exactly as it did before.
274func TestQueueBranchBuildsOrdinaryPushStillFilters(t *testing.T) {
275 st, repo, uid := newQueueTestRepo(t)
276 git := gitRunner(t)
277 root := t.TempDir()
278
279 src := filepath.Join(root, "src")
280 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
281 os.MkdirAll(filepath.Join(src, "docs"), 0o755)
282 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
283 "jobs:\n unit:\n paths-ignore:\n - docs/**\n steps:\n - echo hi\n"), 0o644)
284 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x\n"), 0o644)
285 git(root, "init", "-q", "-b", "main", "src")
286 git(src, "add", ".")
287 git(src, "commit", "-q", "-m", "base")
288 oldSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
289
290 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x changed\n"), 0o644)
291 git(src, "add", ".")
292 git(src, "commit", "-q", "-m", "docs only")
293 newSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
294
295 dir := RepoDir(root, repo.OwnerName, repo.Name)
296 os.MkdirAll(filepath.Dir(dir), 0o755)
297 git(root, "clone", "-q", "--bare", src, dir)
298
299 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", oldSHA, newSHA, time.Now())
300
301 builds, err := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
302 if err != nil {
303 t.Fatal(err)
304 }
305 if len(builds) != 0 {
306 t.Fatalf("docs-only push with a real old sha queued a build: %+v", builds)
307 }
308}
309
310// A job a path filter excludes records a ci/<job> status of "skipped"
311// naming the reason, rather than leaving the commit with no status for
312// that job at all (#172).
313func TestQueueBranchBuildsFilteredJobRecordsSkippedStatus(t *testing.T) {
314 st, repo, uid := newQueueTestRepo(t)
315 git := gitRunner(t)
316 root := t.TempDir()
317
318 src := filepath.Join(root, "src")
319 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
320 os.MkdirAll(filepath.Join(src, "docs"), 0o755)
321 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
322 "jobs:\n unit:\n paths-ignore:\n - docs/**\n steps:\n - echo hi\n"), 0o644)
323 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x\n"), 0o644)
324 git(root, "init", "-q", "-b", "main", "src")
325 git(src, "add", ".")
326 git(src, "commit", "-q", "-m", "base")
327 oldSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
328
329 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x changed\n"), 0o644)
330 git(src, "add", ".")
331 git(src, "commit", "-q", "-m", "docs only")
332 newSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
333
334 dir := RepoDir(root, repo.OwnerName, repo.Name)
335 os.MkdirAll(filepath.Dir(dir), 0o755)
336 git(root, "clone", "-q", "--bare", src, dir)
337
338 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", oldSHA, newSHA, time.Now())
339
340 statuses, err := st.ListCommitStatuses(repo.ID, newSHA)
341 if err != nil {
342 t.Fatal(err)
343 }
344 if len(statuses) != 1 || statuses[0].Context != "ci/unit" {
345 t.Fatalf("statuses on %s: %+v", newSHA, statuses)
346 }
347 if statuses[0].State != "skipped" {
348 t.Fatalf("filtered job status: got %q, want skipped", statuses[0].State)
349 }
350 if statuses[0].Description == "" {
351 t.Fatal("skipped status carries no reason")
352 }
353}
354
355// A tag job and a scheduled job are not push jobs at all: neither records
356// a skipped status, filtered push or not. Only the ordinary job that a
357// path filter actually excluded does.
358func TestQueueBranchBuildsTagAndScheduledJobsRecordNoSkippedStatus(t *testing.T) {
359 st, repo, uid := newQueueTestRepo(t)
360 git := gitRunner(t)
361 root := t.TempDir()
362
363 src := filepath.Join(root, "src")
364 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
365 os.MkdirAll(filepath.Join(src, "docs"), 0o755)
366 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(strings.Join([]string{
367 "jobs:",
368 " unit:",
369 " paths-ignore:",
370 " - docs/**",
371 " steps:",
372 " - echo hi",
373 " release:",
374 " tags: 'v*'",
375 " steps:",
376 " - echo release",
377 " nightly:",
378 " schedule: '0 0 * * *'",
379 " steps:",
380 " - echo nightly",
381 "",
382 }, "\n")), 0o644)
383 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x\n"), 0o644)
384 git(root, "init", "-q", "-b", "main", "src")
385 git(src, "add", ".")
386 git(src, "commit", "-q", "-m", "base")
387 oldSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
388
389 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x changed\n"), 0o644)
390 git(src, "add", ".")
391 git(src, "commit", "-q", "-m", "docs only")
392 newSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
393
394 dir := RepoDir(root, repo.OwnerName, repo.Name)
395 os.MkdirAll(filepath.Dir(dir), 0o755)
396 git(root, "clone", "-q", "--bare", src, dir)
397
398 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", oldSHA, newSHA, time.Now())
399
400 statuses, err := st.ListCommitStatuses(repo.ID, newSHA)
401 if err != nil {
402 t.Fatal(err)
403 }
404 if len(statuses) != 1 || statuses[0].Context != "ci/unit" || statuses[0].State != "skipped" {
405 t.Fatalf("statuses on %s: %+v", newSHA, statuses)
406 }
407}
408
409// A job already built for this commit on another branch is a fact about
410// the commit, not something a filter excluded: it keeps whatever status
411// that build reported (or none, if the run is still queued elsewhere) and
412// must not be overwritten with "skipped".
413func TestQueueBranchBuildsAlreadyBuiltJobRecordsNoSkippedStatus(t *testing.T) {
414 st, repo, uid := newQueueTestRepo(t)
415 git := gitRunner(t)
416 root := t.TempDir()
417
418 src := filepath.Join(root, "src")
419 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
420 os.MkdirAll(filepath.Join(src, "docs"), 0o755)
421 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
422 "jobs:\n unit:\n paths-ignore:\n - docs/**\n steps:\n - echo hi\n"), 0o644)
423 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x\n"), 0o644)
424 git(root, "init", "-q", "-b", "main", "src")
425 git(src, "add", ".")
426 git(src, "commit", "-q", "-m", "base")
427 oldSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
428
429 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x changed\n"), 0o644)
430 git(src, "add", ".")
431 git(src, "commit", "-q", "-m", "docs only")
432 newSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
433
434 dir := RepoDir(root, repo.OwnerName, repo.Name)
435 os.MkdirAll(filepath.Dir(dir), 0o755)
436 git(root, "clone", "-q", "--bare", src, dir)
437
438 // The same commit already has a build for "unit" from another branch,
439 // still pending. Its filter would exclude this push too, so the only
440 // way to tell the two paths apart is that this one must record nothing.
441 if _, err := st.CreateBuild(repo.ID, "unit", newSHA, "other", `["echo hi"]`, "", "", true); err != nil {
442 t.Fatal(err)
443 }
444
445 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", oldSHA, newSHA, time.Now())
446
447 statuses, err := st.ListCommitStatuses(repo.ID, newSHA)
448 if err != nil {
449 t.Fatal(err)
450 }
451 if len(statuses) != 0 {
452 t.Fatalf("already-built job recorded a status: %+v", statuses)
453 }
454 builds, err := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
455 if err != nil || len(builds) != 1 {
456 t.Fatalf("expected only the pre-existing build: %v %v", builds, err)
457 }
458}
459
460// QueueMRBuilds keeps failing open with no diff base at all: deriving a
461// merge base for the MR head is deliberately out of scope here (#172 —
462// filtering a head down to zero jobs leaves it with no statuses, which
463// the require_checks gate reads as unmergeable). This test documents
464// and locks in that choice.
465func TestQueueMRBuildsStillFailsOpen(t *testing.T) {
466 st, repo, uid := newQueueTestRepo(t)
467 git := gitRunner(t)
468 root := t.TempDir()
469
470 src := filepath.Join(root, "src")
471 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
472 os.MkdirAll(filepath.Join(src, "docs"), 0o755)
473 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
474 "jobs:\n unit:\n paths-ignore:\n - docs/**\n steps:\n - echo hi\n"), 0o644)
475 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x\n"), 0o644)
476 git(root, "init", "-q", "-b", "main", "src")
477 git(src, "add", ".")
478 git(src, "commit", "-q", "-m", "base")
479
480 git(src, "checkout", "-q", "-b", "pr")
481 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x changed\n"), 0o644)
482 git(src, "add", ".")
483 git(src, "commit", "-q", "-m", "docs only")
484 prSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
485
486 dir := RepoDir(root, repo.OwnerName, repo.Name)
487 os.MkdirAll(filepath.Dir(dir), 0o755)
488 git(root, "clone", "-q", "--bare", src, dir)
489 git(dir, "update-ref", "refs/merge-requests/1/head", prSHA)
490
491 QueueMRBuilds(st, root, "https://x.test", repo, uid, 1, prSHA)
492
493 builds, err := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
494 if err != nil || len(builds) != 1 {
495 t.Fatalf("expected the MR head to fail open and queue a build: %v %v", builds, err)
496 }
497}
498
499// A force-push that rewrote the branch must not filter against the old
500// tip. After a rebase, old..new is the difference between two histories
501// — whatever the new base added — so a branch whose own commits touch
502// code looks like a docs-only push and its jobs are skipped. It then
503// reads as green without having run (#176).
504func TestQueueBranchBuildsRebaseFiltersAgainstMergeBase(t *testing.T) {
505 st, repo, uid := newQueueTestRepo(t)
506 git := gitRunner(t)
507 root := t.TempDir()
508
509 src := filepath.Join(root, "src")
510 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
511 os.MkdirAll(filepath.Join(src, "docs"), 0o755)
512 os.MkdirAll(filepath.Join(src, "app"), 0o755)
513 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
514 "jobs:\n unit:\n paths-ignore:\n - docs/**\n steps:\n - echo hi\n"), 0o644)
515 os.WriteFile(filepath.Join(src, "app", "a.go"), []byte("package a\n"), 0o644)
516 git(root, "init", "-q", "-b", "main", "src")
517 git(src, "add", ".")
518 git(src, "commit", "-q", "-m", "base")
519
520 // A branch that changes code — the kind of change the filter must
521 // never skip.
522 git(src, "checkout", "-q", "-b", "feat")
523 os.WriteFile(filepath.Join(src, "app", "a.go"), []byte("package a\n\nvar X = 1\n"), 0o644)
524 git(src, "add", ".")
525 git(src, "commit", "-q", "-m", "code change")
526 oldTip := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
527
528 // main moves on with a docs-only commit, and the branch is rebased
529 // onto it — exactly what a fast-forward-only repository forces.
530 git(src, "checkout", "-q", "main")
531 os.WriteFile(filepath.Join(src, "docs", "x.md"), []byte("# x\n"), 0o644)
532 git(src, "add", ".")
533 git(src, "commit", "-q", "-m", "docs only")
534 git(src, "checkout", "-q", "feat")
535 git(src, "rebase", "-q", "main")
536 newTip := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
537
538 // The trap: between the two tips lies only the docs commit.
539 if diff := git(src, "diff", "--name-only", oldTip, newTip); !strings.Contains(diff, "docs/x.md") ||
540 strings.Contains(diff, "app/a.go") {
541 t.Fatalf("fixture does not reproduce the trap; old..new = %q", diff)
542 }
543
544 dir := RepoDir(root, repo.OwnerName, repo.Name)
545 os.MkdirAll(filepath.Dir(dir), 0o755)
546 git(root, "clone", "-q", "--bare", src, dir)
547
548 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "feat", oldTip, newTip, time.Now())
549
550 builds, err := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
551 if err != nil {
552 t.Fatal(err)
553 }
554 if len(builds) == 0 {
555 t.Fatal("a rebased branch whose commits change code queued no build")
556 }
557}
558
559// A rebase gives a commit a new sha and the same tree. A job that
560// succeeded for that tree has nothing left to prove, so the new commit
561// gets the earlier result as its status instead of a new build (#177).
562func TestQueueBranchBuildsSameTreeReusesSuccess(t *testing.T) {
563 st, repo, uid := newQueueTestRepo(t)
564 git := gitRunner(t)
565 root := t.TempDir()
566
567 src := filepath.Join(root, "src")
568 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
569 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
570 "jobs:\n unit:\n steps:\n - echo hi\n"), 0o644)
571 git(root, "init", "-q", "-b", "main", "src")
572 git(src, "add", ".")
573 git(src, "commit", "-q", "-m", "base")
574 first := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
575 // Same tree, new sha: what a rebase onto an unrelated base produces.
576 git(src, "commit", "-q", "--allow-empty", "-m", "rewritten")
577 second := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
578 if git(src, "rev-parse", first+"^{tree}") != git(src, "rev-parse", second+"^{tree}") {
579 t.Fatal("fixture: trees differ")
580 }
581
582 dir := RepoDir(root, repo.OwnerName, repo.Name)
583 os.MkdirAll(filepath.Dir(dir), 0o755)
584 git(root, "clone", "-q", "--bare", src, dir)
585
586 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", "", first, time.Now())
587 builds, _ := st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
588 if len(builds) != 1 {
589 t.Fatalf("first commit queued %d builds, want 1", len(builds))
590 }
591 if _, ok, err := st.ClaimBuild([]int64{repo.ID}, false); err != nil || !ok {
592 t.Fatalf("claim: ok=%v err=%v", ok, err)
593 }
594 if err := st.FinishBuild(builds[0].ID, "success"); err != nil {
595 t.Fatal(err)
596 }
597
598 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", first, second, time.Now())
599 builds, _ = st.ListBuilds(repo.ID, store.BuildFilter{}, 10)
600 if len(builds) != 1 {
601 t.Fatalf("same tree queued a second build: %+v", builds)
602 }
603 statuses, _ := st.ListCommitStatuses(repo.ID, second)
604 found := false
605 for _, s := range statuses {
606 if s.Context == "ci/unit" && s.State == "success" && strings.Contains(s.Description, "same tree") {
607 found = true
608 }
609 }
610 if !found {
611 t.Fatalf("second commit has no success status from the first: %+v", statuses)
612 }
613}
614
615// build list's --ref, --status and --job flags narrow the CLI listing the
616// same way the store filter does, and combine when more than one is given.
617// An invalid --status is refused rather than silently matching nothing (#224).
618func TestBuildListFlagsFilter(t *testing.T) {
619 st, repo, uid := newQueueTestRepo(t)
620 if _, err := st.CreateBuild(repo.ID, "unit", "aaa", "main", `["true"]`, "", "", true); err != nil {
621 t.Fatal(err)
622 }
623 if _, err := st.CreateBuild(repo.ID, "lint", "bbb", "feature", `["true"]`, "", "", true); err != nil {
624 t.Fatal(err)
625 }
626 if _, ok, err := st.ClaimBuild([]int64{repo.ID}, false); err != nil || !ok {
627 t.Fatalf("claim: %v ok=%v", err, ok)
628 }
629 if err := st.FinishBuild(1, "failure"); err != nil {
630 t.Fatal(err)
631 }
632 c, errOut := pruneCtx(st, t.TempDir(), store.User{ID: uid})
633
634 run := func(args ...string) string {
635 t.Helper()
636 out := c.Stdout.(*bytes.Buffer)
637 out.Reset()
638 errOut.Reset()
639 argv := append([]string{"build", "list", repo.Path()}, args...)
640 if code := Dispatch(c, argv); code != protocol.ExitOK {
641 t.Fatalf("build list %v: exit %d: %s", args, code, errOut.String())
642 }
643 return out.String()
644 }
645
646 if out := run(); !strings.Contains(out, "unit") || !strings.Contains(out, "lint") {
647 t.Fatalf("unfiltered listing missing a build:\n%s", out)
648 }
649 if out := run("--ref", "main"); !strings.Contains(out, "unit") || strings.Contains(out, "lint") {
650 t.Fatalf("--ref main:\n%s", out)
651 }
652 if out := run("--job", "lint"); strings.Contains(out, "unit") || !strings.Contains(out, "lint") {
653 t.Fatalf("--job lint:\n%s", out)
654 }
655 if out := run("--status", "failure"); !strings.Contains(out, "unit") || strings.Contains(out, "lint") {
656 t.Fatalf("--status failure:\n%s", out)
657 }
658 if out := run("--ref", "main", "--status", "pending"); strings.TrimSpace(out) != "" {
659 t.Fatalf("non-matching combination returned rows:\n%s", out)
660 }
661
662 out := c.Stdout.(*bytes.Buffer)
663 out.Reset()
664 errOut.Reset()
665 if code := Dispatch(c, []string{"build", "list", repo.Path(), "--status", "bogus"}); code != protocol.ExitUsage {
666 t.Fatalf("bad --status: exit %d, want %d (usage)", code, protocol.ExitUsage)
667 }
668 if !strings.Contains(errOut.String(), "pending") || !strings.Contains(errOut.String(), "cancelled") {
669 t.Fatalf("bad --status error does not name the valid states: %s", errOut.String())
670 }
671}
672
673// A fork's green build of a commit does not stand for the repository's
674// own: the same commit landing on a branch, or a commit with the same
675// tree, is built again as trusted (#258).
676func TestQueueBranchBuildsRebuildsWhatOnlyAForkBuilt(t *testing.T) {
677 st, repo, uid := newQueueTestRepo(t)
678 git := gitRunner(t)
679 root := t.TempDir()
680
681 src := filepath.Join(root, "src")
682 os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
683 os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
684 "jobs:\n unit:\n steps:\n - echo hi\n"), 0o644)
685 git(root, "init", "-q", "-b", "main", "src")
686 git(src, "add", ".")
687 git(src, "commit", "-q", "-m", "base")
688 first := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
689 git(src, "commit", "-q", "--allow-empty", "-m", "same tree")
690 second := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
691
692 dir := RepoDir(root, repo.OwnerName, repo.Name)
693 os.MkdirAll(filepath.Dir(dir), 0o755)
694 git(root, "clone", "-q", "--bare", src, dir)
695
696 // A fork's merge request head, built untrusted and green.
697 QueueMRBuilds(st, root, "https://x.test", repo, uid, 1, first)
698 b, ok, err := st.ClaimBuild([]int64{repo.ID}, true)
699 if err != nil || !ok || b.Trusted {
700 t.Fatalf("claim: ok=%v trusted=%v err=%v", ok, b.Trusted, err)
701 }
702 if err := st.FinishBuild(b.ID, "success"); err != nil {
703 t.Fatal(err)
704 }
705
706 // The same commit lands on main, then a commit with the same tree.
707 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", "", first, time.Now())
708 QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", first, second, time.Now())
709 pending, _ := st.ListBuilds(repo.ID, store.BuildFilter{Status: "pending"}, 10)
710 if len(pending) != 2 {
711 t.Fatalf("queued %d builds, want 2 (one per commit): %+v", len(pending), pending)
712 }
713 for _, p := range pending {
714 if !p.Trusted {
715 t.Errorf("build %d queued untrusted on a branch push", p.Number)
716 }
717 }
718}