BlueGit

timfa bluegit

Files

bluegit / internal / server / mr_pipeline_test.go

mr_pipeline_test.go

fix: start per sha geen dubbele push- en mr-pipeline
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Passed 6a8f3828 History
mr_pipeline_test.go 12.7 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "net/http/cookiejar"
7 "net/http/httptest"
8 "net/url"
9 "os/exec"
10 "path/filepath"
11 "strconv"
12 "strings"
13 "testing"
14
15 "gitlab.com/Timfa/bluegit/internal/auth"
16 "gitlab.com/Timfa/bluegit/internal/config"
17 "gitlab.com/Timfa/bluegit/internal/gitrepo"
18 "gitlab.com/Timfa/bluegit/internal/store"
19)
20
21func TestMergeRequestPipelineBlocksUntilFinished(t *testing.T) {
22 if _, err := exec.LookPath("git"); err != nil {
23 t.Skip("git ontbreekt")
24 }
25 storage := t.TempDir()
26 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
27 if err != nil {
28 t.Fatal(err)
29 }
30 t.Cleanup(func() { _ = st.Close() })
31 cfg := config.Config{
32 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
33 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
34 Git: config.Git{Binary: "git", DefaultBranch: "master"},
35 CI: config.CI{Enabled: true, Docker: "docker"},
36 }
37 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
38 ts := httptest.NewServer(srv.Handler())
39 t.Cleanup(ts.Close)
40 jar, _ := cookiejar.New(nil)
41 tim := &http.Client{Jar: jar}
42 res, err := tim.Get(ts.URL + "/login")
43 if err != nil {
44 t.Fatal(err)
45 }
46 page := read(t, res)
47 res, err = tim.PostForm(ts.URL+"/new/repo", url.Values{"csrf": {csrfOf(t, page)}, "name": {"mrpipes"}, "visibility": {"public"}})
48 if err != nil {
49 t.Fatal(err)
50 }
51 page = read(t, res)
52 res, err = tim.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"laptop"}})
53 if err != nil {
54 t.Fatal(err)
55 }
56 token := between(read(t, res), `<p class="code">`, "</p>")
57 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/mrpipes.git"
58 work := t.TempDir()
59 git(t, work, "init", "-b", "master")
60 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
61 git(t, work, "config", "user.name", "tim")
62 yml := `stages: [test]
63push_job:
64 stage: test
65 image: alpine:3.20
66 script: ["echo push"]
67mr_job:
68 stage: test
69 image: alpine:3.20
70 script: ["echo mr"]
71 rules:
72 - if: $CI_PIPELINE_SOURCE == "merge_request_event"
73soft:
74 stage: test
75 image: alpine:3.20
76 script: ["echo soft"]
77 allow_failure: true
78 rules:
79 - if: $CI_PIPELINE_SOURCE == "merge_request_event"
80`
81 writeFile(t, filepath.Join(work, "blue-ci-cd.yml"), yml)
82 git(t, work, "add", "blue-ci-cd.yml")
83 git(t, work, "commit", "-m", "ci")
84 git(t, work, "remote", "add", "origin", remote)
85 git(t, work, "push", "-u", "origin", "master")
86 git(t, work, "checkout", "-b", "feature")
87 writeFile(t, filepath.Join(work, "README.md"), "feature\n")
88 git(t, work, "add", "README.md")
89 git(t, work, "commit", "-m", "feature")
90 git(t, work, "push", "-u", "origin", "feature")
91
92 res, err = tim.Get(ts.URL + "/tim/mrpipes/-/merge-requests")
93 if err != nil {
94 t.Fatal(err)
95 }
96 page = read(t, res)
97 res, err = tim.PostForm(ts.URL+"/tim/mrpipes/-/merge-requests", url.Values{
98 "csrf": {csrfOf(t, page)}, "title": {"voeg samen"}, "source": {"feature"}, "target": {"master"},
99 })
100 if err != nil {
101 t.Fatal(err)
102 }
103 page = read(t, res)
104 if !strings.Contains(page, "mr_job") || !strings.Contains(page, "soft") || strings.Contains(page, "push_job") {
105 t.Fatalf("mr-pipeline op de pagina:\n%s", page)
106 }
107 if !strings.Contains(page, "The pipeline is still running.") || !strings.Contains(page, "Merge anyway") || !strings.Contains(page, "cannot be merged yet") {
108 t.Fatalf("merge hoort geblokkeerd:\n%s", page)
109 }
110
111 ctx := context.Background()
112 repo, err := st.RepoByPath(ctx, "tim", "mrpipes")
113 if err != nil {
114 t.Fatal(err)
115 }
116 pipes, err := st.ListPipelines(ctx, repo.ID)
117 if err != nil {
118 t.Fatal(err)
119 }
120 var mrPipe store.Pipeline
121 pushNames := map[string]bool{}
122 for _, p := range pipes {
123 jobs, err := st.JobsByPipeline(ctx, p.ID)
124 if err != nil {
125 t.Fatal(err)
126 }
127 if p.Source == "push" {
128 for _, j := range jobs {
129 pushNames[j.Name] = true
130 }
131 continue
132 }
133 if p.Source == "merge_request_event" && (mrPipe.ID == 0 || p.ID > mrPipe.ID) {
134 mrPipe = p
135 }
136 }
137 if pushNames["mr_job"] || pushNames["soft"] || !pushNames["push_job"] {
138 t.Fatalf("push-jobs: %v", pushNames)
139 }
140 if mrPipe.ID == 0 || mrPipe.MRID == 0 {
141 t.Fatalf("mr-pipeline: %+v", mrPipe)
142 }
143 nBefore := len(pipes)
144 user, err := st.UserByUsername(ctx, "tim")
145 if err != nil {
146 t.Fatal(err)
147 }
148 dir := gitrepo.Dir(storage, "tim", "mrpipes")
149 after, err := gitrepo.Refs(ctx, "git", dir)
150 if err != nil {
151 t.Fatal(err)
152 }
153 before := map[string]string{}
154 for ref, sha := range after {
155 before[ref] = sha
156 }
157 before["refs/heads/feature"] = strings.Repeat("a", 40)
158 srv.AfterPush(repo, user, before, after)
159 srv.rerunMergeRequestsOnTarget(ctx, repo, "master", "tim")
160 pipes, err = st.ListPipelines(ctx, repo.ID)
161 if err != nil {
162 t.Fatal(err)
163 }
164 if len(pipes) != nBefore {
165 t.Fatalf("dezelfde push nog eens: %d pipelines, was %d", len(pipes), nBefore)
166 }
167 list := read(t, mustGet(t, tim, ts.URL+"/tim/mrpipes/-/pipelines"))
168 if !strings.Contains(list, "Merge request !1") {
169 t.Fatalf("lijst mist het mr-label:\n%s", list)
170 }
171 detail := read(t, mustGet(t, tim, ts.URL+"/tim/mrpipes/-/pipelines/"+strconv.FormatInt(mrPipe.ID, 10)))
172 if !strings.Contains(detail, "Merge request !1") {
173 t.Fatalf("detail mist het mr-label:\n%s", detail)
174 }
175 res, err = tim.PostForm(ts.URL+"/tim/mrpipes/-/merge-requests/1/merge", url.Values{"csrf": {csrfOf(t, page)}})
176 if err != nil {
177 t.Fatal(err)
178 }
179 if body := read(t, res); !strings.Contains(body, "The pipeline is still running.") || !strings.Contains(body, ">open<") && !strings.Contains(body, "open") {
180 t.Fatalf("merge tijdens de run:\n%s", body)
181 }
182 mr, err := st.MergeRequestByNumber(ctx, repo.ID, 1)
183 if err != nil || mr.Status != "open" {
184 t.Fatalf("status %v %v", mr.Status, err)
185 }
186
187 jobs, _ := st.JobsByPipeline(ctx, mrPipe.ID)
188 for _, j := range jobs {
189 if j.Name == "mr_job" {
190 if err := st.FinishJob(ctx, j.ID, "success", "mr ok\n"); err != nil {
191 t.Fatal(err)
192 }
193 }
194 }
195 res, err = tim.Get(ts.URL + "/tim/mrpipes/-/merge-requests/1")
196 if err != nil {
197 t.Fatal(err)
198 }
199 if body := read(t, res); !strings.Contains(body, "The pipeline is still running.") {
200 t.Fatalf("allow_failure loopt nog:\n%s", body)
201 }
202 jobs, _ = st.JobsByPipeline(ctx, mrPipe.ID)
203 for _, j := range jobs {
204 if j.Name == "soft" {
205 if err := st.FinishJob(ctx, j.ID, "failed", "zacht\n"); err != nil {
206 t.Fatal(err)
207 }
208 }
209 }
210 if _, err := st.RefreshPipelineStatus(ctx, mrPipe.ID); err != nil {
211 t.Fatal(err)
212 }
213 res, err = tim.Get(ts.URL + "/tim/mrpipes/-/merge-requests/1")
214 if err != nil {
215 t.Fatal(err)
216 }
217 page = read(t, res)
218 if strings.Contains(page, "The pipeline is still running.") || strings.Contains(page, "Merge anyway") {
219 t.Fatalf("merge hoort open:\n%s", page)
220 }
221 if !strings.Contains(page, "Warning") && !strings.Contains(page, "Passed") {
222 t.Fatalf("status na allow_failure:\n%s", page)
223 }
224
225 git(t, work, "checkout", "master")
226 writeFile(t, filepath.Join(work, "README.md"), "target\n")
227 git(t, work, "add", "README.md")
228 git(t, work, "commit", "-m", "target")
229 git(t, work, "push", "origin", "master")
230 pipes, err = st.ListPipelines(ctx, repo.ID)
231 if err != nil {
232 t.Fatal(err)
233 }
234 var newest int64
235 for _, p := range pipes {
236 if p.Source == "merge_request_event" && p.ID > newest {
237 newest = p.ID
238 if p.CommitSHA == mrPipe.CommitSHA && p.MRID == mrPipe.MRID {
239 continue
240 }
241 t.Fatalf("nieuwe mr-pipeline hoort op de broncommit: %+v", p)
242 }
243 }
244 if newest <= mrPipe.ID {
245 t.Fatalf("push naar de doelbranch start geen nieuwe mr-pipeline: %d", newest)
246 }
247}
248
249func TestSameJobPushAndMRShareOnePipeline(t *testing.T) {
250 if _, err := exec.LookPath("git"); err != nil {
251 t.Skip("git ontbreekt")
252 }
253 storage := t.TempDir()
254 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
255 if err != nil {
256 t.Fatal(err)
257 }
258 t.Cleanup(func() { _ = st.Close() })
259 cfg := config.Config{
260 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
261 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
262 Git: config.Git{Binary: "git", DefaultBranch: "master"},
263 CI: config.CI{Enabled: true, Docker: "docker"},
264 }
265 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
266 ts := httptest.NewServer(srv.Handler())
267 t.Cleanup(ts.Close)
268 jar, _ := cookiejar.New(nil)
269 tim := &http.Client{Jar: jar}
270 res, err := tim.Get(ts.URL + "/login")
271 if err != nil {
272 t.Fatal(err)
273 }
274 page := read(t, res)
275 res, err = tim.PostForm(ts.URL+"/new/repo", url.Values{"csrf": {csrfOf(t, page)}, "name": {"samepipe"}, "visibility": {"public"}})
276 if err != nil {
277 t.Fatal(err)
278 }
279 page = read(t, res)
280 res, err = tim.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"laptop"}})
281 if err != nil {
282 t.Fatal(err)
283 }
284 token := between(read(t, res), `<p class="code">`, "</p>")
285 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/samepipe.git"
286 work := t.TempDir()
287 git(t, work, "init", "-b", "master")
288 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
289 git(t, work, "config", "user.name", "tim")
290 yml := `stages: [test]
291check:
292 stage: test
293 image: alpine:3.20
294 script: ["echo check"]
295 rules:
296 - if: $CI_PIPELINE_SOURCE == "merge_request_event"
297 - if: $CI_COMMIT_BRANCH
298`
299 writeFile(t, filepath.Join(work, "blue-ci-cd.yml"), yml)
300 git(t, work, "add", "blue-ci-cd.yml")
301 git(t, work, "commit", "-m", "ci")
302 git(t, work, "remote", "add", "origin", remote)
303 git(t, work, "push", "-u", "origin", "master")
304 git(t, work, "checkout", "-b", "feature")
305 writeFile(t, filepath.Join(work, "README.md"), "feature\n")
306 git(t, work, "add", "README.md")
307 git(t, work, "commit", "-m", "feature")
308 git(t, work, "push", "-u", "origin", "feature")
309 first := strings.TrimSpace(gitOutOK(t, work, "rev-parse", "HEAD"))
310
311 ctx := context.Background()
312 repo, err := st.RepoByPath(ctx, "tim", "samepipe")
313 if err != nil {
314 t.Fatal(err)
315 }
316 if n := len(pipelinesForSHA(t, st, repo.ID, first)); n != 1 {
317 t.Fatalf("push zonder mr: %d pipelines voor %s", n, first)
318 }
319
320 res, err = tim.Get(ts.URL + "/tim/samepipe/-/merge-requests")
321 if err != nil {
322 t.Fatal(err)
323 }
324 page = read(t, res)
325 res, err = tim.PostForm(ts.URL+"/tim/samepipe/-/merge-requests", url.Values{
326 "csrf": {csrfOf(t, page)}, "title": {"voeg samen"}, "source": {"feature"}, "target": {"master"},
327 })
328 if err != nil {
329 t.Fatal(err)
330 }
331 _ = read(t, res)
332 opened := pipelinesForSHA(t, st, repo.ID, first)
333 if len(opened) != 1 || opened[0].MRID == 0 {
334 t.Fatalf("mr openen hoort de push te hergebruiken: %+v", opened)
335 }
336
337 writeFile(t, filepath.Join(work, "README.md"), "nog een\n")
338 git(t, work, "add", "README.md")
339 git(t, work, "commit", "-m", "nog een")
340 git(t, work, "push", "origin", "feature")
341 second := strings.TrimSpace(gitOutOK(t, work, "rev-parse", "HEAD"))
342 shared := pipelinesForSHA(t, st, repo.ID, second)
343 if len(shared) != 1 || shared[0].MRID == 0 {
344 t.Fatalf("push met open mr: %+v", shared)
345 }
346 user, err := st.UserByUsername(ctx, "tim")
347 if err != nil {
348 t.Fatal(err)
349 }
350 dir := gitrepo.Dir(storage, "tim", "samepipe")
351 after, err := gitrepo.Refs(ctx, "git", dir)
352 if err != nil {
353 t.Fatal(err)
354 }
355 before := map[string]string{}
356 for ref, sha := range after {
357 before[ref] = sha
358 }
359 before["refs/heads/feature"] = first
360 srv.AfterPush(repo, user, before, after)
361 if n := len(pipelinesForSHA(t, st, repo.ID, second)); n != 1 {
362 t.Fatalf("zelfde push nog eens: %d", n)
363 }
364 list := read(t, mustGet(t, tim, ts.URL+"/tim/samepipe/-/pipelines"))
365 if !strings.Contains(list, "Merge request !1") {
366 t.Fatalf("lijst mist het mr-label:\n%s", list)
367 }
368 detail := read(t, mustGet(t, tim, ts.URL+"/tim/samepipe/-/pipelines/"+strconv.FormatInt(shared[0].ID, 10)))
369 if !strings.Contains(detail, "Merge request !1") {
370 t.Fatalf("detail mist het mr-label:\n%s", detail)
371 }
372
373 git(t, work, "checkout", "master")
374 writeFile(t, filepath.Join(work, "README.md"), "target\n")
375 git(t, work, "add", "README.md")
376 git(t, work, "commit", "-m", "target")
377 git(t, work, "push", "origin", "master")
378 afterTarget := pipelinesForSHA(t, st, repo.ID, second)
379 if len(afterTarget) != 2 {
380 t.Fatalf("nieuwe doelcommit hoort een mr-pipeline toe te voegen: %+v", afterTarget)
381 }
382 var newest store.Pipeline
383 for _, p := range afterTarget {
384 if p.ID > newest.ID {
385 newest = p
386 }
387 }
388 if newest.ID <= shared[0].ID || newest.Source != "merge_request_event" || newest.MRID == 0 || newest.CommitSHA != second {
389 t.Fatalf("nieuwe mr-pipeline: %+v", newest)
390 }
391}
392
393func pipelinesForSHA(t *testing.T, st *store.Store, repoID int64, sha string) []store.Pipeline {
394 t.Helper()
395 all, err := st.ListPipelines(context.Background(), repoID)
396 if err != nil {
397 t.Fatal(err)
398 }
399 var out []store.Pipeline
400 for _, p := range all {
401 if p.CommitSHA == sha {
402 out = append(out, p)
403 }
404 }
405 return out
406}