BlueGit

timfa bluegit

Files

bluegit / internal / server / webhook_copy_test.go

webhook_copy_test.go

webhook_copy_test.go 7.0 KiB Download Raw
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "fmt"
7 "net/http"
8 "net/http/cookiejar"
9 "net/http/httptest"
10 "net/url"
11 "os/exec"
12 "path/filepath"
13 "strings"
14 "testing"
15 "time"
16
17 "gitlab.com/Timfa/bluegit/internal/auth"
18 "gitlab.com/Timfa/bluegit/internal/config"
19 "gitlab.com/Timfa/bluegit/internal/store"
20)
21
22func TestWebhookPatchCopyKeepsSecretsServerSide(t *testing.T) {
23 if _, err := exec.LookPath("git"); err != nil {
24 t.Skip("git ontbreekt")
25 }
26 storage := t.TempDir()
27 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
28 if err != nil {
29 t.Fatal(err)
30 }
31 t.Cleanup(func() { _ = st.Close() })
32 ctx := context.Background()
33 ada, err := st.UpsertUser(ctx, 1, "ada", "", false)
34 if err != nil {
35 t.Fatal(err)
36 }
37 dev, err := st.UpsertUser(ctx, 2, "dev", "", false)
38 if err != nil {
39 t.Fatal(err)
40 }
41 issue := func(u store.User) string {
42 plain, _, err := st.IssueToken(ctx, u.ID, store.TokenRequest{Name: u.Username, Scopes: "api", ExpiresAt: time.Time{}})
43 if err != nil {
44 t.Fatal(err)
45 }
46 return plain
47 }
48 adaTok, devTok := issue(ada), issue(dev)
49 cfg := config.Config{
50 BaseURL: "http://127.0.0.1:9", StoragePath: storage,
51 Auth: config.Auth{Mode: "dev", DevUser: "ada", DevAuthID: 1},
52 Git: config.Git{Binary: "git", DefaultBranch: "master"},
53 }
54 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "ada", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: t.TempDir()}
55 ts := httptest.NewServer(srv.Handler())
56 t.Cleanup(ts.Close)
57
58 const secretVal = "geheim-waarde-1234567890"
59 var all strings.Builder
60 call := func(method, path, token, body string) (int, string) {
61 t.Helper()
62 req, _ := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
63 if body != "" {
64 req.Header.Set("Content-Type", "application/json")
65 }
66 req.Header.Set("Authorization", "Bearer "+token)
67 res, err := http.DefaultClient.Do(req)
68 if err != nil {
69 t.Fatal(err)
70 }
71 out := read(t, res)
72 all.WriteString(out)
73 return res.StatusCode, out
74 }
75 want := func(code int, body string, label string, status int, contains string) {
76 t.Helper()
77 if code != status || (contains != "" && !strings.Contains(body, contains)) {
78 t.Fatalf("%s: status %d body %s", label, code, body)
79 }
80 }
81 for _, n := range []string{"Src", "Dst"} {
82 code, body := call(http.MethodPost, "/api/v1/projects", adaTok, `{"name":"`+n+`","visibility":"private"}`)
83 want(code, body, "project "+n, 201, "")
84 }
85 code, body := call(http.MethodPost, "/api/v1/groups", adaTok, `{"name":"Team"}`)
86 want(code, body, "groep", 201, `"path":"team"`)
87 src, _ := st.RepoByPath(ctx, "ada", "src")
88 dst, _ := st.RepoByPath(ctx, "ada", "dst")
89 team, _ := st.GroupByPath(ctx, "team")
90 if err := st.PutSecret(ctx, "repo", src.ID, "GROK_TOKEN", secretVal, false); err != nil {
91 t.Fatal(err)
92 }
93
94 code, body = call(http.MethodPost, "/api/v1/projects/ada/src/webhooks", adaTok,
95 `{"name":"Ada","preset":"custom","url":"https://example.test/hook","events":["push"],"headers":"Authorization: Bearer {{secret.GROK_TOKEN}}\nX-Missing: {{secret.NOPE}}"}`)
96 want(code, body, "maken", 201, `"id"`)
97 var made struct{ ID int64 }
98 _ = json.Unmarshal([]byte(body), &made)
99 base := fmt.Sprintf("/api/v1/projects/ada/src/webhooks/%d", made.ID)
100
101 code, body = call(http.MethodPatch, base, adaTok, `{"name":"Ada 2","token":"","events":["push","pipeline_success"]}`)
102 want(code, body, "patch", 200, `"name":"Ada 2"`)
103 h, err := st.Webhook(ctx, "repo", src.ID, made.ID)
104 if err != nil || !strings.Contains(h.Headers["Authorization"], "{{secret.GROK_TOKEN}}") || len(h.Events) != 2 {
105 t.Fatalf("patch verloor velden: %+v %v", h, err)
106 }
107 code, body = call(http.MethodPatch, base, adaTok, `{"active":false}`)
108 want(code, body, "uit", 200, `"active":false`)
109 code, body = call(http.MethodPatch, base, adaTok, `{"active":true}`)
110 want(code, body, "aan", 200, `"active":true`)
111 code, body = call(http.MethodPatch, base, devTok, `{"name":"x"}`)
112 if code != 403 && code != 404 {
113 t.Fatalf("dev mag niet patchen: %d %s", code, body)
114 }
115
116 code, body = call(http.MethodPost, base+"/copy", adaTok, `{"target_type":"project","target":"ada/dst","name":"Kopie"}`)
117 want(code, body, "kopie project", 201, `"copied_secrets":["GROK_TOKEN"]`)
118 want(code, body, "ontbrekend", 201, `"missing_secrets":["NOPE"]`)
119 vals, err := st.SecretValues(ctx, "repo", dst.ID, true)
120 if err != nil || vals["GROK_TOKEN"] != secretVal {
121 t.Fatalf("geheim niet server-side gekopieerd: %v", err)
122 }
123 used, err := srv.hookSecrets(ctx, "repo", dst.ID, true, dst)
124 if err != nil || used["GROK_TOKEN"] != secretVal {
125 t.Fatalf("kopie gebruikt het geheim niet: %v", err)
126 }
127 hooks, _ := st.ListWebhooks(ctx, "repo", dst.ID)
128 if len(hooks) != 1 || hooks[0].Name != "Kopie" || !strings.Contains(hooks[0].Headers["Authorization"], "{{secret.GROK_TOKEN}}") {
129 t.Fatalf("kopie klopt niet: %+v", hooks)
130 }
131 code, body = call(http.MethodPost, base+"/copy", adaTok, `{"target_type":"project","target":"ada/dst"}`)
132 want(code, body, "tweede kopie", 201, `"copied_secrets":[]`)
133 code, body = call(http.MethodPost, base+"/copy", adaTok, `{"target_type":"group","target":"team","events":["release_published"]}`)
134 want(code, body, "kopie groep", 201, `"scope":"group"`)
135 gv, _ := st.SecretValues(ctx, "group", team.ID, true)
136 if gv["GROK_TOKEN"] != secretVal {
137 t.Fatal("groepsgeheim ontbreekt")
138 }
139 code, body = call(http.MethodPost, base+"/copy", devTok, `{"target_type":"group","target":"team"}`)
140 if code != 403 && code != 404 {
141 t.Fatalf("dev mag niet kopiëren: %d %s", code, body)
142 }
143 code, body = call(http.MethodPost, base+"/copy", adaTok, `{"target_type":"project","target":"ada/bestaatniet"}`)
144 want(code, body, "onbekend doel", 404, "")
145 code, body = call(http.MethodGet, "/api/v1/projects/ada/dst/webhooks", adaTok, "")
146 want(code, body, "lijst", 200, "Kopie")
147 code, body = call(http.MethodDelete, fmt.Sprintf("/api/v1/projects/ada/dst/webhooks/%d", hooks[0].ID), adaTok, "")
148 want(code, body, "verwijderen", 204, "")
149 code, body = call(http.MethodGet, "/api/v1/openapi.json", "", "")
150 want(code, body, "openapi", 200, "/webhooks/{id}/copy")
151
152 jar, _ := cookiejar.New(nil)
153 client := &http.Client{Jar: jar}
154 res, err := client.Get(ts.URL + "/login")
155 if err != nil {
156 t.Fatal(err)
157 }
158 _ = read(t, res)
159 res, err = client.Get(ts.URL + "/ada/src/-/settings?tab=webhooks")
160 if err != nil {
161 t.Fatal(err)
162 }
163 page := read(t, res)
164 all.WriteString(page)
165 if !strings.Contains(page, "data-hookcopy-open") || !strings.Contains(page, `value="group:team"`) || !strings.Contains(page, `value="project:ada/dst"`) {
166 t.Fatalf("kopieerknop of doelen ontbreken")
167 }
168 res, err = client.PostForm(ts.URL+"/ada/src/-/webhooks/copy", url.Values{
169 "csrf": {csrfOf(t, page)}, "id": {fmt.Sprint(made.ID)}, "target": {"project:ada/dst"}, "name": {"Via UI"},
170 })
171 if err != nil {
172 t.Fatal(err)
173 }
174 all.WriteString(read(t, res))
175 hooks, _ = st.ListWebhooks(ctx, "repo", dst.ID)
176 found := false
177 for _, h := range hooks {
178 found = found || h.Name == "Via UI"
179 }
180 if !found {
181 t.Fatalf("UI-kopie ontbreekt: %+v", hooks)
182 }
183
184 if strings.Contains(all.String(), secretVal) {
185 t.Fatal("geheime waarde in een API-respons")
186 }
187}