| 1 | package server |
| 2 | |
| 3 | import ( |
| 4 | "context" |
| 5 | "net/http" |
| 6 | "net/http/cookiejar" |
| 7 | "net/http/httptest" |
| 8 | "net/url" |
| 9 | "os/exec" |
| 10 | "path/filepath" |
| 11 | "strings" |
| 12 | "testing" |
| 13 | "time" |
| 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 | |
| 21 | const receiveYML = "stages:\n - test\nunit:\n stage: test\n image: alpine:3.20\n script:\n - echo ok\n" |
| 22 | |
| 23 | func TestPostReceiveStartsPipeline(t *testing.T) { |
| 24 | if _, err := exec.LookPath("git"); err != nil { |
| 25 | t.Skip("git ontbreekt") |
| 26 | } |
| 27 | storage := t.TempDir() |
| 28 | st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32()) |
| 29 | if err != nil { |
| 30 | t.Fatal(err) |
| 31 | } |
| 32 | t.Cleanup(func() { _ = st.Close() }) |
| 33 | cfg := config.Config{ |
| 34 | BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage, |
| 35 | Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"}, |
| 36 | Git: config.Git{Binary: "git", DefaultBranch: "master"}, |
| 37 | CI: config.CI{Enabled: true, Docker: "docker"}, |
| 38 | } |
| 39 | srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"} |
| 40 | ts := httptest.NewServer(srv.Handler()) |
| 41 | t.Cleanup(ts.Close) |
| 42 | jar, _ := cookiejar.New(nil) |
| 43 | tim := &http.Client{Jar: jar} |
| 44 | res, err := tim.Get(ts.URL + "/login") |
| 45 | if err != nil { |
| 46 | t.Fatal(err) |
| 47 | } |
| 48 | page := read(t, res) |
| 49 | res, err = tim.PostForm(ts.URL+"/new/repo", url.Values{ |
| 50 | "csrf": {csrfOf(t, page)}, "name": {"ontvangen"}, "visibility": {"public"}, |
| 51 | }) |
| 52 | if err != nil { |
| 53 | t.Fatal(err) |
| 54 | } |
| 55 | page = read(t, res) |
| 56 | ctx := context.Background() |
| 57 | repo, err := st.RepoByPath(ctx, "tim", "ontvangen") |
| 58 | if err != nil { |
| 59 | t.Fatal(err) |
| 60 | } |
| 61 | user, err := st.UserByUsername(ctx, "tim") |
| 62 | if err != nil { |
| 63 | t.Fatal(err) |
| 64 | } |
| 65 | hookID, err := st.CreateWebhook(ctx, store.Webhook{ |
| 66 | ScopeKind: "repo", ScopeID: repo.ID, Name: "push", Preset: "generic", |
| 67 | URLTemplate: "http://127.0.0.1:9/hook", Events: []string{"push"}, |
| 68 | }) |
| 69 | if err != nil { |
| 70 | t.Fatal(err) |
| 71 | } |
| 72 | res, err = tim.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"laptop"}}) |
| 73 | if err != nil { |
| 74 | t.Fatal(err) |
| 75 | } |
| 76 | token := between(read(t, res), `<p class="code">`, "</p>") |
| 77 | remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/ontvangen.git" |
| 78 | work := t.TempDir() |
| 79 | git(t, work, "init", "-b", "master") |
| 80 | git(t, work, "config", "user.email", "tim@users.git.timfalken.com") |
| 81 | git(t, work, "config", "user.name", "tim") |
| 82 | writeFile(t, filepath.Join(work, "README.md"), "hallo\n") |
| 83 | git(t, work, "add", "README.md") |
| 84 | git(t, work, "commit", "-m", "leesmij") |
| 85 | git(t, work, "remote", "add", "origin", remote) |
| 86 | git(t, work, "push", "-u", "origin", "master") |
| 87 | |
| 88 | if n := pipelineCount(t, st, repo.ID); n != 0 { |
| 89 | t.Fatalf("readme zonder yml startte %d pipelines", n) |
| 90 | } |
| 91 | pushes := pushDeliveries(t, st, hookID) |
| 92 | acts := contribCount(t, st, user.ID, repo.ID) |
| 93 | if pushes < 1 || acts < 1 { |
| 94 | t.Fatalf("git push: webhooks %d activity %d", pushes, acts) |
| 95 | } |
| 96 | |
| 97 | res, err = tim.Get(ts.URL + "/tim/ontvangen/-/ci/editor?ref=master") |
| 98 | if err != nil { |
| 99 | t.Fatal(err) |
| 100 | } |
| 101 | editor := read(t, res) |
| 102 | res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/ci/editor", url.Values{ |
| 103 | "csrf": {csrfOf(t, editor)}, "base": {"master"}, "branch": {"master"}, |
| 104 | "message": {"voeg blue-ci-cd.yml toe"}, "body": {receiveYML}, |
| 105 | }) |
| 106 | if err != nil { |
| 107 | t.Fatal(err) |
| 108 | } |
| 109 | if saved := read(t, res); !strings.Contains(saved, "Committed.") { |
| 110 | t.Fatalf("editor:\n%s", saved) |
| 111 | } |
| 112 | dir := gitrepo.Dir(storage, "tim", "ontvangen") |
| 113 | master := strings.TrimSpace(mustGit(t, dir, "rev-parse", "refs/heads/master")) |
| 114 | pipe := pipelineFor(t, st, repo.ID, master, "refs/heads/master") |
| 115 | if pipe.Source != "push" || pipe.Status != "queued" { |
| 116 | t.Fatalf("editor-pipeline: %+v", pipe) |
| 117 | } |
| 118 | if jobs, err := st.JobsByPipeline(ctx, pipe.ID); err != nil || len(jobs) != 1 || jobs[0].Name != "unit" || jobs[0].Status != "queued" { |
| 119 | t.Fatalf("editor-jobs: %v %+v", err, jobs) |
| 120 | } |
| 121 | if pushDeliveries(t, st, hookID) < pushes+1 { |
| 122 | t.Fatal("editor startte geen webhook") |
| 123 | } |
| 124 | if contribCount(t, st, user.ID, repo.ID) < acts+1 { |
| 125 | t.Fatal("editor startte geen activity") |
| 126 | } |
| 127 | pushes = pushDeliveries(t, st, hookID) |
| 128 | acts = contribCount(t, st, user.ID, repo.ID) |
| 129 | |
| 130 | list := read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen/-/pipelines")) |
| 131 | for _, want := range []string{`data-live-on="1"`, `class="stage-dot pending"`, "Pending"} { |
| 132 | if !strings.Contains(list, want) { |
| 133 | t.Errorf("lijst mist %q", want) |
| 134 | } |
| 135 | } |
| 136 | home := read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen")) |
| 137 | if !strings.Contains(home, `class="status pending"`) || !strings.Contains(home, "Pending") { |
| 138 | t.Fatalf("overzicht mist pending:\n%s", home) |
| 139 | } |
| 140 | css := read(t, mustGet(t, tim, ts.URL+"/assets/style.css")) |
| 141 | for _, want := range []string{"@keyframes spin", ".stage-dot.pending .mark", "border-right-color: transparent"} { |
| 142 | if !strings.Contains(css, want) { |
| 143 | t.Errorf("css mist %q", want) |
| 144 | } |
| 145 | } |
| 146 | |
| 147 | jobs, err := st.JobsByPipeline(ctx, pipe.ID) |
| 148 | if err != nil { |
| 149 | t.Fatal(err) |
| 150 | } |
| 151 | if ok, err := st.MarkJobRunning(ctx, jobs[0].ID); err != nil || !ok { |
| 152 | t.Fatalf("running: %v %v", ok, err) |
| 153 | } |
| 154 | home = read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen")) |
| 155 | if !strings.Contains(home, `class="status running"`) || !strings.Contains(home, "Running") { |
| 156 | t.Fatalf("overzicht mist running:\n%s", home) |
| 157 | } |
| 158 | list = read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen/-/pipelines")) |
| 159 | if !strings.Contains(list, `class="stage-dot running"`) || !strings.Contains(list, `class="status running"`) { |
| 160 | t.Fatal("lijst mist het lopende icoon") |
| 161 | } |
| 162 | |
| 163 | res, err = tim.Get(ts.URL + "/tim/ontvangen/-/tags") |
| 164 | if err != nil { |
| 165 | t.Fatal(err) |
| 166 | } |
| 167 | tags := read(t, res) |
| 168 | res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/tags", url.Values{ |
| 169 | "csrf": {csrfOf(t, tags)}, "name": {"v1"}, "target": {"master"}, "message": {"eerste"}, |
| 170 | }) |
| 171 | if err != nil { |
| 172 | t.Fatal(err) |
| 173 | } |
| 174 | if page = read(t, res); !strings.Contains(page, "v1") { |
| 175 | t.Fatalf("tag:\n%s", page) |
| 176 | } |
| 177 | tagged := pipelineFor(t, st, repo.ID, master, "refs/tags/v1") |
| 178 | if tagged.Status != "queued" { |
| 179 | t.Fatalf("tag-pipeline: %+v", tagged) |
| 180 | } |
| 181 | if pushDeliveries(t, st, hookID) < pushes+1 || contribCount(t, st, user.ID, repo.ID) < acts+1 { |
| 182 | t.Fatal("tag mist webhook of activity") |
| 183 | } |
| 184 | |
| 185 | res, err = tim.Get(ts.URL + "/tim/ontvangen/-/ci/editor?ref=master") |
| 186 | if err != nil { |
| 187 | t.Fatal(err) |
| 188 | } |
| 189 | editor = read(t, res) |
| 190 | featureYML := strings.Replace(receiveYML, "echo ok", "echo feature", 1) |
| 191 | res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/ci/editor", url.Values{ |
| 192 | "csrf": {csrfOf(t, editor)}, "base": {"master"}, "branch": {"feature"}, |
| 193 | "message": {"feature yml"}, "body": {featureYML}, |
| 194 | }) |
| 195 | if err != nil { |
| 196 | t.Fatal(err) |
| 197 | } |
| 198 | if saved := read(t, res); !strings.Contains(saved, "Committed.") { |
| 199 | t.Fatalf("feature:\n%s", saved) |
| 200 | } |
| 201 | feature := strings.TrimSpace(mustGit(t, dir, "rev-parse", "refs/heads/feature")) |
| 202 | _ = pipelineFor(t, st, repo.ID, feature, "refs/heads/feature") |
| 203 | |
| 204 | res, err = tim.Get(ts.URL + "/tim/ontvangen/-/merge-requests") |
| 205 | if err != nil { |
| 206 | t.Fatal(err) |
| 207 | } |
| 208 | page = read(t, res) |
| 209 | res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/merge-requests", url.Values{ |
| 210 | "csrf": {csrfOf(t, page)}, "title": {"feature"}, "source": {"feature"}, "target": {"master"}, |
| 211 | }) |
| 212 | if err != nil { |
| 213 | t.Fatal(err) |
| 214 | } |
| 215 | page = read(t, res) |
| 216 | res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/merge-requests/1/notes", url.Values{ |
| 217 | "csrf": {csrfOf(t, page)}, "path": {"blue-ci-cd.yml"}, "line_start": {"7"}, "line_end": {"7"}, |
| 218 | "body": {"```suggestion\n - echo toegepast\n```"}, |
| 219 | }) |
| 220 | if err != nil { |
| 221 | t.Fatal(err) |
| 222 | } |
| 223 | page = read(t, res) |
| 224 | ids := suggestionIDs(page) |
| 225 | if len(ids) != 1 { |
| 226 | t.Fatalf("suggestie-ids %v", ids) |
| 227 | } |
| 228 | beforeFeature := feature |
| 229 | res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/merge-requests/1/suggestions", url.Values{ |
| 230 | "csrf": {csrfOf(t, page)}, "id": {ids[0]}, "title": {"pas de regel aan"}, |
| 231 | }) |
| 232 | if err != nil { |
| 233 | t.Fatal(err) |
| 234 | } |
| 235 | if applied := read(t, res); !strings.Contains(applied, "Suggestions applied") { |
| 236 | t.Fatalf("suggestie:\n%s", applied) |
| 237 | } |
| 238 | feature = strings.TrimSpace(mustGit(t, dir, "rev-parse", "refs/heads/feature")) |
| 239 | if feature == beforeFeature { |
| 240 | t.Fatal("suggestie maakte geen commit") |
| 241 | } |
| 242 | _ = pipelineFor(t, st, repo.ID, feature, "refs/heads/feature") |
| 243 | |
| 244 | if err := st.UpsertReview(ctx, repo.ID, 1, user.ID, "approved"); err != nil { |
| 245 | t.Fatal(err) |
| 246 | } |
| 247 | passPipelines(t, st, repo.ID) |
| 248 | res, err = tim.Get(ts.URL + "/tim/ontvangen/-/merge-requests/1") |
| 249 | if err != nil { |
| 250 | t.Fatal(err) |
| 251 | } |
| 252 | page = read(t, res) |
| 253 | res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/merge-requests/1/merge", url.Values{"csrf": {csrfOf(t, page)}}) |
| 254 | if err != nil { |
| 255 | t.Fatal(err) |
| 256 | } |
| 257 | if merged := read(t, res); !strings.Contains(merged, "Merged") && !strings.Contains(merged, "samengevoegd") && !strings.Contains(merged, "merged") { |
| 258 | t.Fatalf("merge:\n%s", merged) |
| 259 | } |
| 260 | mergedSHA := strings.TrimSpace(mustGit(t, dir, "rev-parse", "refs/heads/master")) |
| 261 | if mergedSHA == master { |
| 262 | t.Fatal("merge verschoof master niet") |
| 263 | } |
| 264 | _ = pipelineFor(t, st, repo.ID, mergedSHA, "refs/heads/master") |
| 265 | passPipelines(t, st, repo.ID) |
| 266 | |
| 267 | quiet := read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen/-/pipelines")) |
| 268 | if strings.Contains(quiet, `data-live-on="1"`) { |
| 269 | t.Fatal("afgeronde lijst blijft pollen") |
| 270 | } |
| 271 | } |
| 272 | |
| 273 | func pipelineCount(t *testing.T, st *store.Store, repoID int64) int { |
| 274 | t.Helper() |
| 275 | pipes, err := st.ListPipelines(context.Background(), repoID) |
| 276 | if err != nil { |
| 277 | t.Fatal(err) |
| 278 | } |
| 279 | return len(pipes) |
| 280 | } |
| 281 | |
| 282 | func pipelineFor(t *testing.T, st *store.Store, repoID int64, sha, ref string) store.Pipeline { |
| 283 | t.Helper() |
| 284 | pipes, err := st.ListPipelines(context.Background(), repoID) |
| 285 | if err != nil { |
| 286 | t.Fatal(err) |
| 287 | } |
| 288 | for _, p := range pipes { |
| 289 | if p.CommitSHA == sha && p.Ref == ref { |
| 290 | return p |
| 291 | } |
| 292 | } |
| 293 | t.Fatalf("geen pipeline voor %s %s in %d stuks", ref, sha, len(pipes)) |
| 294 | return store.Pipeline{} |
| 295 | } |
| 296 | |
| 297 | func pushDeliveries(t *testing.T, st *store.Store, hookID int64) int { |
| 298 | t.Helper() |
| 299 | rows, err := st.RecentDeliveries(context.Background(), hookID) |
| 300 | if err != nil { |
| 301 | t.Fatal(err) |
| 302 | } |
| 303 | n := 0 |
| 304 | for _, row := range rows { |
| 305 | if row.EventType == "push" { |
| 306 | n++ |
| 307 | } |
| 308 | } |
| 309 | return n |
| 310 | } |
| 311 | |
| 312 | func contribCount(t *testing.T, st *store.Store, userID, repoID int64) int { |
| 313 | t.Helper() |
| 314 | times, err := st.ContributionTimes(context.Background(), userID, []int64{repoID}, time.Unix(0, 0)) |
| 315 | if err != nil { |
| 316 | t.Fatal(err) |
| 317 | } |
| 318 | return len(times) |
| 319 | } |
| 320 | |
| 321 | func passPipelines(t *testing.T, st *store.Store, repoID int64) { |
| 322 | t.Helper() |
| 323 | ctx := context.Background() |
| 324 | pipes, err := st.ListPipelines(ctx, repoID) |
| 325 | if err != nil { |
| 326 | t.Fatal(err) |
| 327 | } |
| 328 | for _, p := range pipes { |
| 329 | jobs, err := st.JobsByPipeline(ctx, p.ID) |
| 330 | if err != nil { |
| 331 | t.Fatal(err) |
| 332 | } |
| 333 | for _, j := range jobs { |
| 334 | if j.Status == "success" || j.Status == "failed" || j.Status == "canceled" || j.Status == "skipped" { |
| 335 | continue |
| 336 | } |
| 337 | if err := st.FinishJob(ctx, j.ID, "success", ""); err != nil { |
| 338 | t.Fatal(err) |
| 339 | } |
| 340 | } |
| 341 | if _, err := st.RefreshPipelineStatus(ctx, p.ID); err != nil { |
| 342 | t.Fatal(err) |
| 343 | } |
| 344 | } |
| 345 | } |