BlueGit

timfa bluegit

Files

bluegit / internal / server / secret_edit_test.go

secret_edit_test.go

feat: toon webhooks in een tabel en maak secrets bewerkbaar
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
89b83b18 History
secret_edit_test.go 12.3 KiB Download Raw
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "net/http"
7 "net/http/cookiejar"
8 "net/http/httptest"
9 "net/url"
10 "os/exec"
11 "path/filepath"
12 "strconv"
13 "strings"
14 "testing"
15
16 "gitlab.com/Timfa/bluegit/internal/auth"
17 "gitlab.com/Timfa/bluegit/internal/config"
18 "gitlab.com/Timfa/bluegit/internal/store"
19)
20
21func TestSecretEditShowAndInvisible(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"},
34 Git: config.Git{Binary: "git", DefaultBranch: "master"},
35 }
36 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
37 ts := httptest.NewServer(srv.Handler())
38 t.Cleanup(ts.Close)
39
40 jar, _ := cookiejar.New(nil)
41 client := &http.Client{Jar: jar}
42 res, err := client.Get(ts.URL + "/login")
43 if err != nil {
44 t.Fatal(err)
45 }
46 page := read(t, res)
47 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
48 "csrf": {csrfOf(t, page)}, "name": {"secrets"}, "visibility": {"private"},
49 })
50 if err != nil {
51 t.Fatal(err)
52 }
53 _ = read(t, res)
54 res, err = client.Get(ts.URL + "/tim/secrets/-/settings?tab=secrets")
55 if err != nil {
56 t.Fatal(err)
57 }
58 page = read(t, res)
59 for _, needle := range []string{`name="invisible"`, "evgrid", "/assets/secrets.js", "An invisible secret"} {
60 if !strings.Contains(page, needle) {
61 t.Fatalf("formulier mist %q", needle)
62 }
63 }
64 post := func(values url.Values) string {
65 t.Helper()
66 values.Set("csrf", csrfOf(t, page))
67 res, err := client.PostForm(ts.URL+"/tim/secrets/-/secrets", values)
68 if err != nil {
69 t.Fatal(err)
70 }
71 page = read(t, res)
72 return page
73 }
74 post(url.Values{"name": {"SHOWN"}, "value": {"zichtbaar-waarde"}, "protected": {"1"}})
75 post(url.Values{"name": {"HIDDEN"}, "value": {"onzichtbare-waarde"}, "invisible": {"1"}})
76 if strings.Contains(page, "zichtbaar-waarde") || strings.Contains(page, "onzichtbare-waarde") {
77 t.Fatal("waarde staat in de eerste html")
78 }
79 if !strings.Contains(page, `data-reveal="SHOWN"`) || strings.Contains(page, `data-reveal="HIDDEN"`) {
80 t.Fatalf("toonknop:\n%s", page)
81 }
82 if !strings.Contains(page, `value="replace"`) || !strings.Contains(page, ">Show<") || !strings.Contains(page, ">Edit<") || !strings.Contains(page, ">Replace<") {
83 t.Fatalf("knoppen:\n%s", page)
84 }
85 res, err = client.PostForm(ts.URL+"/tim/secrets/-/secrets/reveal", url.Values{
86 "csrf": {csrfOf(t, page)}, "name": {"SHOWN"},
87 })
88 if err != nil {
89 t.Fatal(err)
90 }
91 shown := read(t, res)
92 if res.StatusCode != http.StatusOK || !strings.Contains(shown, "zichtbaar-waarde") {
93 t.Fatalf("toon %d %s", res.StatusCode, shown)
94 }
95 res, err = client.PostForm(ts.URL+"/tim/secrets/-/secrets/reveal", url.Values{
96 "csrf": {csrfOf(t, page)}, "name": {"HIDDEN"},
97 })
98 if err != nil {
99 t.Fatal(err)
100 }
101 hidden := read(t, res)
102 if res.StatusCode != http.StatusForbidden || strings.Contains(hidden, "onzichtbare-waarde") {
103 t.Fatalf("verborgen toon %d %s", res.StatusCode, hidden)
104 }
105 post(url.Values{"mode": {"update"}, "name": {"SHOWN"}, "value": {"nieuwe-waarde"}})
106 if !strings.Contains(page, "Secret saved") {
107 t.Fatalf("bewerken:\n%s", page)
108 }
109 post(url.Values{"mode": {"update"}, "name": {"HIDDEN"}, "value": {"mag-niet"}})
110 if !strings.Contains(page, "invisible") || strings.Contains(page, "mag-niet") {
111 t.Fatalf("bewerken van onzichtbaar:\n%s", page)
112 }
113 post(url.Values{"mode": {"replace"}, "name": {"HIDDEN"}, "value": {"vervangen-waarde"}, "protected": {"1"}})
114 if !strings.Contains(page, "Secret replaced") || strings.Contains(page, "vervangen-waarde") || strings.Contains(page, "onzichtbare-waarde") {
115 t.Fatalf("vervangen:\n%s", page)
116 }
117
118 ctx := context.Background()
119 tim, err := st.UserByUsername(ctx, "tim")
120 if err != nil {
121 t.Fatal(err)
122 }
123 repo, err := st.RepoByPath(ctx, "tim", "secrets")
124 if err != nil {
125 t.Fatal(err)
126 }
127 vals, err := st.SecretValues(ctx, "repo", repo.ID, true)
128 if err != nil || vals["SHOWN"] != "nieuwe-waarde" || vals["HIDDEN"] != "vervangen-waarde" {
129 t.Fatalf("opgeslagen %#v %v", vals, err)
130 }
131 list, err := st.ListSecrets(ctx, "repo", repo.ID)
132 if err != nil {
133 t.Fatal(err)
134 }
135 for _, m := range list {
136 if m.Name == "HIDDEN" && (!m.Invisible || !m.Protected) {
137 t.Fatalf("vlaggen %+v", m)
138 }
139 if m.Name == "SHOWN" && (m.Invisible || m.Protected) {
140 t.Fatalf("zichtbaar werd %+v", m)
141 }
142 }
143 token, err := st.CreateToken(ctx, tim.ID, "laptop")
144 if err != nil {
145 t.Fatal(err)
146 }
147 call := func(method, path, body string) (int, string) {
148 t.Helper()
149 req, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
150 if err != nil {
151 t.Fatal(err)
152 }
153 req.Header.Set("Authorization", "Bearer "+token)
154 req.Header.Set("Content-Type", "application/json")
155 res, err := client.Do(req)
156 if err != nil {
157 t.Fatal(err)
158 }
159 return res.StatusCode, read(t, res)
160 }
161 code, body := call(http.MethodGet, "/api/v1/repos/tim/secrets/secrets", "")
162 if code != http.StatusOK || strings.Contains(body, "nieuwe-waarde") || strings.Contains(body, "vervangen-waarde") || !strings.Contains(body, `"invisible":true`) {
163 t.Fatalf("lijst %d %s", code, body)
164 }
165 code, body = call(http.MethodGet, "/api/v1/repos/tim/secrets/secrets/SHOWN", "")
166 if code != http.StatusOK || !strings.Contains(body, "nieuwe-waarde") {
167 t.Fatalf("api toon %d %s", code, body)
168 }
169 code, body = call(http.MethodGet, "/api/v1/repos/tim/secrets/secrets/HIDDEN", "")
170 if code != http.StatusForbidden || strings.Contains(body, "vervangen-waarde") {
171 t.Fatalf("api verborgen %d %s", code, body)
172 }
173 code, body = call(http.MethodPut, "/api/v1/repos/tim/secrets/secrets/HIDDEN", `{"value":"nee","protected":false}`)
174 if code != http.StatusForbidden || strings.Contains(body, "nee") {
175 t.Fatalf("api bewerken %d %s", code, body)
176 }
177 code, body = call(http.MethodPost, "/api/v1/repos/tim/secrets/secrets/HIDDEN/replace", `{"value":"api-nieuw","protected":false}`)
178 if code != http.StatusOK || strings.Contains(body, "api-nieuw") || !strings.Contains(body, `"invisible":true`) {
179 t.Fatalf("api vervangen %d %s", code, body)
180 }
181 code, body = call(http.MethodPut, "/api/v1/repos/tim/secrets/secrets/SHOWN", `{"value":"api-zichtbaar","protected":true}`)
182 if code != http.StatusOK || strings.Contains(body, "api-zichtbaar") || !strings.Contains(body, `"protected":true`) {
183 t.Fatalf("api update %d %s", code, body)
184 }
185 code, body = call(http.MethodPost, "/api/v1/repos/tim/secrets/secrets", `{"name":"GROUPLESS","value":"x"}`)
186 if code != http.StatusCreated || strings.Contains(body, `"value"`) {
187 t.Fatalf("api aanmaken %d %s", code, body)
188 }
189 code, body = call(http.MethodPost, "/api/v1/repos/tim/secrets/secrets", `{"name":"SHOWN","value":"x","invisible":true}`)
190 if code != http.StatusConflict {
191 t.Fatalf("api dubbel %d %s", code, body)
192 }
193 code, body = call(http.MethodDelete, "/api/v1/repos/tim/secrets/secrets/HIDDEN", "")
194 if code != http.StatusNoContent {
195 t.Fatalf("api weg %d %s", code, body)
196 }
197 var listed struct {
198 Secrets []struct {
199 Name string `json:"name"`
200 Invisible bool `json:"invisible"`
201 } `json:"secrets"`
202 }
203 code, body = call(http.MethodGet, "/api/v1/repos/tim/secrets/secrets", "")
204 if err := json.Unmarshal([]byte(body), &listed); err != nil {
205 t.Fatal(err)
206 }
207 for _, m := range listed.Secrets {
208 if m.Name == "HIDDEN" {
209 t.Fatalf("verwijderd blijft in de lijst %s", body)
210 }
211 }
212 _ = code
213
214 g, err := st.CreateGroup(ctx, tim.ID, "Team", "team", "", "developer")
215 if err != nil {
216 t.Fatal(err)
217 }
218 if err := st.CreateSecret(ctx, "group", g.ID, "GROUP_HIDDEN", "groep-geheim", false, true); err != nil {
219 t.Fatal(err)
220 }
221 res, err = client.Get(ts.URL + "/groups/team?tab=settings")
222 if err != nil {
223 t.Fatal(err)
224 }
225 groupPage := read(t, res)
226 if strings.Contains(groupPage, "groep-geheim") || !strings.Contains(groupPage, "GROUP_HIDDEN") || !strings.Contains(groupPage, ">Replace<") || strings.Contains(groupPage, `data-reveal="GROUP_HIDDEN"`) {
227 t.Fatalf("groepsgeheim:\n%s", groupPage)
228 }
229 code, body = call(http.MethodGet, "/api/v1/groups/team/secrets/GROUP_HIDDEN", "")
230 if code != http.StatusForbidden || strings.Contains(body, "groep-geheim") {
231 t.Fatalf("groep api %d %s", code, body)
232 }
233}
234
235func TestWebhookTableAndEdit(t *testing.T) {
236 if _, err := exec.LookPath("git"); err != nil {
237 t.Skip("git ontbreekt")
238 }
239 storage := t.TempDir()
240 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
241 if err != nil {
242 t.Fatal(err)
243 }
244 t.Cleanup(func() { _ = st.Close() })
245 cfg := config.Config{
246 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
247 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
248 Git: config.Git{Binary: "git", DefaultBranch: "master"},
249 }
250 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
251 ts := httptest.NewServer(srv.Handler())
252 t.Cleanup(ts.Close)
253 jar, _ := cookiejar.New(nil)
254 client := &http.Client{Jar: jar}
255 res, err := client.Get(ts.URL + "/login")
256 if err != nil {
257 t.Fatal(err)
258 }
259 page := read(t, res)
260 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
261 "csrf": {csrfOf(t, page)}, "name": {"hooks"}, "visibility": {"private"},
262 })
263 if err != nil {
264 t.Fatal(err)
265 }
266 _ = read(t, res)
267 res, err = client.Get(ts.URL + "/tim/hooks/-/settings?tab=webhooks")
268 if err != nil {
269 t.Fatal(err)
270 }
271 page = read(t, res)
272 if !strings.Contains(page, "evgrid") || !strings.Contains(page, `data-preset="custom"`) {
273 t.Fatalf("compact formulier:\n%s", page)
274 }
275 res, err = client.PostForm(ts.URL+"/tim/hooks/-/webhooks", url.Values{
276 "csrf": {csrfOf(t, page)}, "name": {"ada"}, "preset": {"telegram"},
277 "token": {"BOT_TOKEN"}, "chat": {"100"}, "event_push": {"1"}, "event_pipeline_success": {"1"},
278 })
279 if err != nil {
280 t.Fatal(err)
281 }
282 page = read(t, res)
283 for _, needle := range []string{"hooktable", "urlclip", "data-tip=", ">Edit<", ">Remove<", "pipeline succeeded"} {
284 if !strings.Contains(page, needle) {
285 t.Fatalf("tabel mist %q\n%s", needle, page)
286 }
287 }
288 ctx := context.Background()
289 repo, err := st.RepoByPath(ctx, "tim", "hooks")
290 if err != nil {
291 t.Fatal(err)
292 }
293 hooks, err := st.ListWebhooks(ctx, "repo", repo.ID)
294 if err != nil || len(hooks) != 1 || !strings.Contains(hooks[0].Fields, `"chat":"100"`) {
295 t.Fatalf("velden %#v %v", hooks, err)
296 }
297 res, err = client.Get(ts.URL + "/tim/hooks/-/settings?tab=webhooks&hook=" + strconv.FormatInt(hooks[0].ID, 10))
298 if err != nil {
299 t.Fatal(err)
300 }
301 edit := read(t, res)
302 for _, needle := range []string{
303 `name="id"`, `value="ada"`, `value="100"`, `value="telegram" selected`,
304 "Edit webhook", `name="event_push" value="1" checked`,
305 } {
306 if !strings.Contains(edit, needle) {
307 t.Fatalf("bewerken mist %q\n%s", needle, edit)
308 }
309 }
310 res, err = client.PostForm(ts.URL+"/tim/hooks/-/webhooks", url.Values{
311 "csrf": {csrfOf(t, edit)}, "id": {strconv.FormatInt(hooks[0].ID, 10)}, "name": {"ada"},
312 "preset": {"telegram"}, "token": {"BOT_TOKEN"}, "chat": {"200"}, "event_push": {"1"},
313 })
314 if err != nil {
315 t.Fatal(err)
316 }
317 _ = read(t, res)
318 hooks, err = st.ListWebhooks(ctx, "repo", repo.ID)
319 if err != nil || len(hooks) != 1 || !strings.Contains(hooks[0].BodyTemplate, `"chat_id":"200"`) || strings.Contains(hooks[0].Fields, `"chat":"100"`) {
320 t.Fatalf("bijgewerkt %#v %v", hooks, err)
321 }
322 tim, err := st.UserByUsername(ctx, "tim")
323 if err != nil {
324 t.Fatal(err)
325 }
326 token, err := st.CreateToken(ctx, tim.ID, "laptop")
327 if err != nil {
328 t.Fatal(err)
329 }
330 raw, _ := json.Marshal(map[string]any{
331 "name": "ada", "preset": "telegram", "token": "BOT_TOKEN", "chat": "300", "events": []string{"push"},
332 })
333 req, err := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/repos/tim/hooks/webhooks/"+strconv.FormatInt(hooks[0].ID, 10), strings.NewReader(string(raw)))
334 if err != nil {
335 t.Fatal(err)
336 }
337 req.Header.Set("Authorization", "Bearer "+token)
338 req.Header.Set("Content-Type", "application/json")
339 res, err = client.Do(req)
340 if err != nil {
341 t.Fatal(err)
342 }
343 body := read(t, res)
344 if res.StatusCode != http.StatusOK {
345 t.Fatalf("api %d %s", res.StatusCode, body)
346 }
347 hooks, err = st.ListWebhooks(ctx, "repo", repo.ID)
348 if err != nil || len(hooks) != 1 || !strings.Contains(hooks[0].BodyTemplate, `"chat_id":"300"`) {
349 t.Fatalf("api bijgewerkt %#v %v", hooks, err)
350 }
351}