package server import ( "context" "encoding/json" "net/http" "net/http/cookiejar" "net/http/httptest" "net/url" "os/exec" "path/filepath" "strconv" "strings" "testing" "time" "gitlab.com/Timfa/bluegit/internal/auth" "gitlab.com/Timfa/bluegit/internal/config" "gitlab.com/Timfa/bluegit/internal/store" "gitlab.com/Timfa/bluegit/internal/webhook" ) func TestWebhookPayloads(t *testing.T) { if _, err := exec.LookPath("git"); err != nil { t.Skip("git ontbreekt") } storage := t.TempDir() st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32()) if err != nil { t.Fatal(err) } t.Cleanup(func() { _ = st.Close() }) cfg := config.Config{ BaseURL: "http://git.example", Listen: "127.0.0.1:0", StoragePath: storage, Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"}, Git: config.Git{Binary: "git", DefaultBranch: "master"}, } var bodies [][]byte srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"} srv.hookSink = func(b []byte) { bodies = append(bodies, append([]byte(nil), b...)) } ts := httptest.NewServer(srv.Handler()) t.Cleanup(ts.Close) jar, _ := cookiejar.New(nil) tim := &http.Client{Jar: jar} page := read(t, mustGet(t, tim, ts.URL+"/login")) page = read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{ "csrf": {csrfOf(t, page)}, "name": {"hooks"}, "visibility": {"public"}, })) ctx := context.Background() repo, err := st.RepoByPath(ctx, "tim", "hooks") if err != nil { t.Fatal(err) } if _, err := st.CreateWebhook(ctx, store.Webhook{ ScopeKind: "repo", ScopeID: repo.ID, Name: "alles", Preset: "generic", URLTemplate: "https://example.test/hook", Events: []string{"push", "merge_request", "pipeline_failure", "release_published"}, }); err != nil { t.Fatal(err) } if err := st.PutSecret(ctx, "repo", repo.ID, "DEPLOY_TOKEN", "super-secret-token", true); err != nil { t.Fatal(err) } page = read(t, mustPost(t, tim, ts.URL+"/settings/tokens", url.Values{ "csrf": {csrfOf(t, page)}, "name": {"laptop"}, })) token := between(page, `

`, "

") remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/hooks.git" work := t.TempDir() git(t, work, "init", "-b", "master") git(t, work, "config", "user.email", "tim@users.git.timfalken.com") git(t, work, "config", "user.name", "tim") writeFile(t, filepath.Join(work, "README.md"), "a\n") git(t, work, "add", "README.md") git(t, work, "commit", "-m", "eerste regel", "-m", "meer tekst") writeFile(t, filepath.Join(work, "README.md"), "b\n") git(t, work, "add", "README.md") git(t, work, "commit", "-m", "tweede") git(t, work, "remote", "add", "origin", remote) git(t, work, "push", "-u", "origin", "master") push := decodeKind(t, bodies, "push") if push["ref"] != "refs/heads/master" || push["before"] != strings.Repeat("0", 40) { t.Fatalf("push ref/before %v", push) } commits := push["commits"].([]any) if len(commits) != 2 { t.Fatalf("commits %d %s", len(commits), mustJSON(t, push)) } first := commits[0].(map[string]any) second := commits[1].(map[string]any) if first["message"] != "eerste regel\n\nmeer tekst" || second["message"] != "tweede" { t.Fatalf("berichten %v %v", first["message"], second["message"]) } if first["author"] != "tim " || !strings.Contains(first["url"].(string), "/tim/hooks/-/commit/") { t.Fatalf("auteur of url %v", first) } if push["after"] != second["sha"] { t.Fatalf("after %v tip %v", push["after"], second["sha"]) } if strings.Contains(mustJSON(t, push), "diff --git") { t.Fatal("push bevat een diff") } if _, err := time.Parse(time.RFC3339, first["timestamp"].(string)); err != nil { t.Fatalf("timestamp %v", first["timestamp"]) } readme := fileByPath(t, first["files"].([]any), "README.md") if readme["status"] != "added" || readme["additions"] != float64(1) || readme["deletions"] != float64(0) { t.Fatalf("eerste bestand %v", readme) } changed := fileByPath(t, second["files"].([]any), "README.md") if changed["status"] != "modified" || changed["additions"] != float64(1) || changed["deletions"] != float64(1) { t.Fatalf("tweede bestand %v", changed) } diffPath := mustParse(t, first["diff_url"].(string)).Path if !strings.Contains(diffPath, "/api/v1/repos/tim/hooks/commits/") || !strings.HasSuffix(diffPath, "/diff") { t.Fatalf("diff_url %s", diffPath) } noDiff := mustGet(t, http.DefaultClient, ts.URL+diffPath) if noDiff.StatusCode != http.StatusUnauthorized { t.Fatalf("diff zonder token %d", noDiff.StatusCode) } noDiff.Body.Close() diffRes := getBearer(t, ts.URL+diffPath, token) if diffRes.StatusCode != http.StatusOK || !strings.HasPrefix(diffRes.Header.Get("Content-Type"), "text/plain") { t.Fatalf("commitdiff %d %s", diffRes.StatusCode, diffRes.Header.Get("Content-Type")) } diffText := read(t, diffRes) if !strings.Contains(diffText, "diff --git") || !strings.Contains(diffText, "README.md") || !strings.Contains(diffText, "+a") { t.Fatalf("commitdiff tekst %s", diffText) } git(t, work, "checkout", "-b", "topic") writeFile(t, filepath.Join(work, "extra.txt"), "c\n") git(t, work, "add", "extra.txt") git(t, work, "commit", "-m", "derde") git(t, work, "push", "-u", "origin", "topic") page = read(t, mustGet(t, tim, ts.URL+"/tim/hooks/-/merge-requests/new?source=topic&target=master")) page = read(t, mustPost(t, tim, ts.URL+"/tim/hooks/-/merge-requests", url.Values{ "csrf": {csrfOf(t, page)}, "source": {"topic"}, "target": {"master"}, "title": {"Toon de kloon-URL"}, "description": {"SSH en HTTPS."}, })) opened := decodeAction(t, bodies, "opened") mr := opened["merge_request"].(map[string]any) if mr["title"] != "Toon de kloon-URL" || mr["description"] != "SSH en HTTPS." || mr["source_branch"] != "topic" || mr["target_branch"] != "master" || mr["status"] != "open" || mr["author"] != "tim" || mr["id"] != float64(1) { t.Fatalf("opened %s", mustJSON(t, mr)) } if _, ok := opened["comment"]; ok { t.Fatalf("opened heeft een comment: %s", mustJSON(t, opened)) } if strings.Contains(mustJSON(t, opened), "diff --git") { t.Fatal("merge request bevat een diff") } if len(mr["reviewers"].([]any)) != 0 || len(mr["comments"].([]any)) != 0 { t.Fatalf("opened heeft al reviewers of comments: %s", mustJSON(t, mr)) } mrCommits := mr["commits"].([]any) if len(mrCommits) != 1 || mrCommits[0].(map[string]any)["message"] != "derde" { t.Fatalf("mr commits %s", mustJSON(t, mrCommits)) } extra := fileByPath(t, mrCommits[0].(map[string]any)["files"].([]any), "extra.txt") if extra["status"] != "added" || extra["additions"] != float64(1) { t.Fatalf("mr bestand %v", extra) } stats := mr["diff_stats"].(map[string]any) statFile := fileByPath(t, stats["files"].([]any), "extra.txt") if stats["additions"] != float64(1) || stats["deletions"] != float64(0) || statFile["status"] != "added" { t.Fatalf("diff_stats %s", mustJSON(t, stats)) } mrDiffPath := mustParse(t, mr["diff_url"].(string)).Path if mrDiffPath != "/api/v1/repos/tim/hooks/merge-requests/1/diff" { t.Fatalf("mr diff_url %s", mrDiffPath) } timUser, err := st.UserByUsername(ctx, "tim") if err != nil { t.Fatal(err) } storedMR, err := st.MergeRequestByNumber(ctx, repo.ID, 1) if err != nil { t.Fatal(err) } if err := st.UpsertReview(ctx, repo.ID, storedMR.ID, timUser.ID, "approved"); err != nil { t.Fatal(err) } page = read(t, mustPost(t, tim, ts.URL+"/tim/hooks/-/merge-requests/1/notes", url.Values{ "csrf": {csrfOf(t, page)}, "body": {"dit is het commentaar"}, })) commented := decodeAction(t, bodies, "commented") if commented["comment"] != "dit is het commentaar" { t.Fatalf("comment %s", mustJSON(t, commented)) } commentedMR := commented["merge_request"].(map[string]any) reviewers := commentedMR["reviewers"].([]any) if len(reviewers) != 1 || reviewers[0].(map[string]any)["username"] != "tim" || reviewers[0].(map[string]any)["status"] != "approved" { t.Fatalf("reviewers %s", mustJSON(t, reviewers)) } notes := commentedMR["comments"].([]any) if len(notes) != 1 || notes[0].(map[string]any)["body"] != "dit is het commentaar" || notes[0].(map[string]any)["author"] != "tim" { t.Fatalf("comments %s", mustJSON(t, notes)) } mrDiff := getBearer(t, ts.URL+mrDiffPath, token) if mrDiff.StatusCode != http.StatusOK || !strings.HasPrefix(mrDiff.Header.Get("Content-Type"), "text/plain") { t.Fatalf("mr diff %d", mrDiff.StatusCode) } mrDiffText := read(t, mrDiff) if !strings.Contains(mrDiffText, "diff --git") || !strings.Contains(mrDiffText, "extra.txt") { t.Fatalf("mr diff tekst %s", mrDiffText) } page = read(t, mustPost(t, tim, ts.URL+"/tim/hooks/-/merge-requests/1/merge", url.Values{ "csrf": {csrfOf(t, page)}, })) if strings.Contains(page, "flash") && strings.Contains(strings.ToLower(page), "error") { t.Fatalf("merge pagina:\n%s", page) } merged := decodeAction(t, bodies, "merged") if merged["merge_request"].(map[string]any)["status"] != "merged" { t.Fatalf("merged %s", mustJSON(t, merged)) } sha := second["sha"].(string) id, err := st.CreatePipeline(ctx, repo.ID, sha, "refs/heads/master", "push", "tim", "tweede", []store.NewJob{ {Name: "test", Stage: "test", Script: "exit 1"}, {Name: "build", Stage: "build", Script: "echo ok"}, {Name: "soft", Stage: "test", Script: "exit 1", AllowFailure: true}, }) if err != nil { t.Fatal(err) } jobs, err := st.JobsByPipeline(ctx, id) if err != nil { t.Fatal(err) } var lines []string for i := 0; i < webhook.LogMaxLines+40; i++ { lines = append(lines, "regel") } lines = append(lines, "token super-secret-token") log := strings.Join(lines, "\n") for _, j := range jobs { if _, err := st.MarkJobRunning(ctx, j.ID); err != nil { t.Fatal(err) } switch j.Name { case "test": if err := st.AppendJobLog(ctx, j.ID, log); err != nil { t.Fatal(err) } if err := st.FinishJob(ctx, j.ID, "failed", ""); err != nil { t.Fatal(err) } case "soft": if err := st.AppendJobLog(ctx, j.ID, "zacht super-secret-token\n"); err != nil { t.Fatal(err) } if err := st.FinishJob(ctx, j.ID, "failed", ""); err != nil { t.Fatal(err) } default: if err := st.AppendJobLog(ctx, j.ID, "gebouwd\n"); err != nil { t.Fatal(err) } if err := st.FinishJob(ctx, j.ID, "success", ""); err != nil { t.Fatal(err) } } } if _, err := st.RefreshPipelineStatus(ctx, id); err != nil { t.Fatal(err) } before := len(bodies) srv.Dispatch(repo.ID, webhook.Event{ Type: webhook.EventPipelineFailure, PipelineID: strconv.FormatInt(id, 10), }) if len(bodies) == before { t.Fatal("geen pipeline-payload") } var pipe map[string]any if err := json.Unmarshal(bodies[len(bodies)-1], &pipe); err != nil { t.Fatal(err) } if pipe["object_kind"] != "pipeline" || pipe["type"] != "pipeline_failure" { t.Fatalf("pipeline %s", bodies[len(bodies)-1]) } detail := pipe["pipeline"].(map[string]any) if detail["id"] != float64(id) || detail["status"] != "failed" || detail["ref"] != "refs/heads/master" || detail["sha"] != sha || detail["author"] != "tim" { t.Fatalf("detail %s", mustJSON(t, detail)) } if !strings.Contains(detail["commit_message"].(string), "tweede") { t.Fatalf("commit_message %v", detail["commit_message"]) } if _, ok := detail["duration"]; !ok { t.Fatal("duur ontbreekt") } var fullLogURL string for _, item := range pipe["jobs"].([]any) { job := item.(map[string]any) raw, _ := json.Marshal(job) if strings.Contains(string(raw), "super-secret-token") { t.Fatalf("geheim in job %s", raw) } if _, ok := job["log"]; !ok { t.Fatalf("elke job heeft een log: %s", raw) } if _, ok := job["log_truncated"]; !ok { t.Fatalf("elke job heeft log_truncated: %s", raw) } switch job["name"] { case "test": if job["log_truncated"] != true || job["allow_failure"] != false { t.Fatalf("test %s", raw) } text := job["log"].(string) if !strings.Contains(text, "[MASKED]") || len(strings.Split(text, "\n")) != webhook.LogMaxLines { t.Fatalf("log %d regels, staart %q", len(strings.Split(text, "\n")), text[max(0, len(text)-40):]) } fullLogURL, _ = job["log_url"].(string) if !strings.Contains(fullLogURL, "/api/v1/repos/tim/hooks/jobs/") || !strings.HasSuffix(fullLogURL, "/log") || !strings.Contains(job["web_url"].(string), "/jobs/") { t.Fatalf("urls %s", raw) } case "build": if job["status"] != "success" || job["log"] != "gebouwd\n" || job["log_truncated"] != false { t.Fatalf("build %s", raw) } if _, ok := job["log_url"]; ok { t.Fatalf("korte geslaagde log heeft een url: %s", raw) } case "soft": if job["allow_failure"] != true || job["log_truncated"] != false || !strings.Contains(job["log"].(string), "[MASKED]") { t.Fatalf("soft %s", raw) } if _, ok := job["log_url"]; ok { t.Fatalf("korte log heeft een url: %s", raw) } } } if fullLogURL == "" { t.Fatal("geen log_url") } logPath := mustParse(t, fullLogURL).Path noAuth := mustGet(t, http.DefaultClient, ts.URL+logPath) if noAuth.StatusCode != http.StatusUnauthorized { t.Fatalf("zonder token %d", noAuth.StatusCode) } noAuth.Body.Close() full := getBearer(t, ts.URL+logPath, token) if full.StatusCode != http.StatusOK || !strings.HasPrefix(full.Header.Get("Content-Type"), "text/plain") { t.Fatalf("volle log %d %s", full.StatusCode, full.Header.Get("Content-Type")) } fullText := read(t, full) if strings.Contains(fullText, "super-secret-token") || !strings.Contains(fullText, "[MASKED]") { t.Fatal("volle log maskeert het geheim niet") } if n := len(strings.Split(fullText, "\n")); n <= webhook.LogMaxLines { t.Fatalf("volle log heeft %d regels", n) } bad := getBearer(t, ts.URL+logPath, "bgj_geen-job") if bad.StatusCode != http.StatusUnauthorized { t.Fatalf("job-token %d", bad.StatusCode) } bad.Body.Close() rel := srv.releaseEvent(repo, "v1.2.0", "BlueGit 1.2.0", sha, []store.ReleaseAsset{{Name: "blue git", Size: 9}}) raw, err := webhook.RenderBody("", rel, nil) if err != nil { t.Fatal(err) } var release map[string]any if err := json.Unmarshal(raw, &release); err != nil { t.Fatal(err) } info := release["release"].(map[string]any) asset := info["assets"].([]any)[0].(map[string]any) if info["tag"] != "v1.2.0" || info["name"] != "BlueGit 1.2.0" || info["commit"] != sha || !strings.Contains(asset["url"].(string), "/-/releases/v1.2.0/assets/blue%20git") { t.Fatalf("release %s", raw) } if elapsedSeconds(time.Unix(10, 0), time.Unix(12, 0)) != 2 { t.Fatal("duur") } infoPage := read(t, mustGet(t, tim, ts.URL+"/-/info")) for _, want := range []string{"Webhook payloads", "log_truncated", "log_url", "/api/v1/webhooks/openapi.json", "/api/v1/repos/{owner}/{repo}/jobs/{id}/log", "diff_url", "reviewers", "commit_message", "source_branch"} { if !strings.Contains(infoPage, want) { t.Errorf("infopagina mist %q", want) } } specRes, err := http.Get(ts.URL + "/api/v1/webhooks/openapi.json") if err != nil { t.Fatal(err) } spec := read(t, specRes) if specRes.StatusCode != 200 || !strings.Contains(spec, `"openapi": "3.1.0"`) || !strings.Contains(spec, "log_truncated") || !strings.Contains(spec, "/repos/{owner}/{repo}/jobs/{id}/log") { t.Fatalf("spec %d %s", specRes.StatusCode, spec[:min(200, len(spec))]) } } func decodeKind(t *testing.T, bodies [][]byte, kind string) map[string]any { t.Helper() for i := len(bodies) - 1; i >= 0; i-- { var doc map[string]any if err := json.Unmarshal(bodies[i], &doc); err != nil { continue } if doc["object_kind"] == kind { return doc } } t.Fatalf("geen %s in %d payloads", kind, len(bodies)) return nil } func decodeAction(t *testing.T, bodies [][]byte, action string) map[string]any { t.Helper() for i := len(bodies) - 1; i >= 0; i-- { var doc map[string]any if err := json.Unmarshal(bodies[i], &doc); err != nil { continue } mr, _ := doc["merge_request"].(map[string]any) if mr != nil && mr["action"] == action { return doc } } t.Fatalf("geen actie %s", action) return nil } func TestJobLogAPI(t *testing.T) { storage := t.TempDir() st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32()) if err != nil { t.Fatal(err) } t.Cleanup(func() { _ = st.Close() }) ctx := context.Background() tim, err := st.UpsertUser(ctx, 1, "tim", "", false) if err != nil { t.Fatal(err) } ada, err := st.UpsertUser(ctx, 2, "ada", "", false) if err != nil { t.Fatal(err) } priv, err := st.CreateRepo(ctx, "user", tim.ID, "priv", "", "master", "private") if err != nil { t.Fatal(err) } open, err := st.CreateRepo(ctx, "user", tim.ID, "open", "", "master", "public") if err != nil { t.Fatal(err) } if err := st.PutSecret(ctx, "repo", priv.ID, "DEPLOY_TOKEN", "super-secret-token", true); err != nil { t.Fatal(err) } if err := st.PutSecret(ctx, "repo", open.ID, "DEPLOY_TOKEN", "super-secret-token", true); err != nil { t.Fatal(err) } privJob := seedJobLog(t, st, priv.ID, "regel\nsuper-secret-token\n") openJob := seedJobLog(t, st, open.ID, "publiek super-secret-token\n") ownerTok, err := st.CreateToken(ctx, tim.ID, "laptop") if err != nil { t.Fatal(err) } adaTok, err := st.CreateToken(ctx, ada.ID, "ada") if err != nil { t.Fatal(err) } cfg := config.Config{ BaseURL: "http://git.example", Listen: "127.0.0.1:0", StoragePath: storage, Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"}, Git: config.Git{Binary: "git", DefaultBranch: "master"}, } srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git"} ts := httptest.NewServer(srv.Handler()) t.Cleanup(ts.Close) privPath := ts.URL + "/api/v1/repos/tim/priv/jobs/" + strconv.FormatInt(privJob, 10) + "/log" openPath := ts.URL + "/api/v1/repos/tim/open/jobs/" + strconv.FormatInt(openJob, 10) + "/log" missing := mustGet(t, http.DefaultClient, privPath) if missing.StatusCode != http.StatusUnauthorized { t.Fatalf("zonder token %d", missing.StatusCode) } missing.Body.Close() for _, tok := range []string{"nope", "bg_onbekend", "bgj_job"} { res := getBearer(t, privPath, tok) if res.StatusCode != http.StatusUnauthorized { t.Fatalf("token %s geeft %d", tok, res.StatusCode) } res.Body.Close() } stranger := getBearer(t, privPath, adaTok) if stranger.StatusCode != http.StatusForbidden { t.Fatalf("vreemde op prive %d", stranger.StatusCode) } stranger.Body.Close() other := getBearer(t, ts.URL+"/api/v1/repos/tim/priv/jobs/"+strconv.FormatInt(openJob, 10)+"/log", ownerTok) if other.StatusCode != http.StatusNotFound { t.Fatalf("job van andere repo %d", other.StatusCode) } other.Body.Close() own := getBearer(t, privPath, ownerTok) if own.StatusCode != http.StatusOK || !strings.HasPrefix(own.Header.Get("Content-Type"), "text/plain") { t.Fatalf("eigenaar %d %s", own.StatusCode, own.Header.Get("Content-Type")) } body := read(t, own) if body != "regel\n[MASKED]\n" { t.Fatalf("prive log %q", body) } pub := getBearer(t, openPath, adaTok) if pub.StatusCode != http.StatusOK { t.Fatalf("publiek met vreemd token %d", pub.StatusCode) } if got := read(t, pub); got != "publiek [MASKED]\n" { t.Fatalf("publieke log %q", got) } } func fileByPath(t *testing.T, files []any, path string) map[string]any { t.Helper() for _, item := range files { file := item.(map[string]any) if file["path"] == path { return file } } t.Fatalf("geen bestand %s in %v", path, files) return nil } func seedJobLog(t *testing.T, st *store.Store, repoID int64, log string) int64 { t.Helper() ctx := context.Background() id, err := st.CreatePipeline(ctx, repoID, strings.Repeat("a", 40), "refs/heads/master", "push", "tim", "titel", []store.NewJob{ {Name: "build", Stage: "build", Script: "echo ok"}, }) if err != nil { t.Fatal(err) } jobs, err := st.JobsByPipeline(ctx, id) if err != nil || len(jobs) != 1 { t.Fatal(err) } if err := st.AppendJobLog(ctx, jobs[0].ID, log); err != nil { t.Fatal(err) } return jobs[0].ID } func getBearer(t *testing.T, raw, token string) *http.Response { t.Helper() req, err := http.NewRequest(http.MethodGet, raw, nil) if err != nil { t.Fatal(err) } req.Header.Set("Authorization", "Bearer "+token) res, err := http.DefaultClient.Do(req) if err != nil { t.Fatal(err) } return res } func mustParse(t *testing.T, raw string) *url.URL { t.Helper() u, err := url.Parse(raw) if err != nil { t.Fatal(err) } return u } func mustJSON(t *testing.T, v any) string { t.Helper() b, err := json.Marshal(v) if err != nil { t.Fatal(err) } return string(b) }