BlueGit

timfa bluegit

Files

bluegit / internal / server / secret_edit_test.go

secret_edit_test.go

fix: beschermde secrets alleen bekijken en bewerken als maintainer
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
be133ac8 History
secret_edit_test.go 18.4 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 "time"
16
17 "gitlab.com/Timfa/bluegit/internal/access"
18 "gitlab.com/Timfa/bluegit/internal/auth"
19 "gitlab.com/Timfa/bluegit/internal/config"
20 "gitlab.com/Timfa/bluegit/internal/store"
21)
22
23func TestSecretEditShowAndInvisible(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"},
36 Git: config.Git{Binary: "git", DefaultBranch: "master"},
37 }
38 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
39 ts := httptest.NewServer(srv.Handler())
40 t.Cleanup(ts.Close)
41
42 jar, _ := cookiejar.New(nil)
43 client := &http.Client{Jar: jar}
44 res, err := client.Get(ts.URL + "/login")
45 if err != nil {
46 t.Fatal(err)
47 }
48 page := read(t, res)
49 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
50 "csrf": {csrfOf(t, page)}, "name": {"secrets"}, "visibility": {"private"},
51 })
52 if err != nil {
53 t.Fatal(err)
54 }
55 _ = read(t, res)
56 res, err = client.Get(ts.URL + "/tim/secrets/-/settings?tab=secrets")
57 if err != nil {
58 t.Fatal(err)
59 }
60 page = read(t, res)
61 for _, needle := range []string{`name="invisible"`, "evgrid", "/assets/secrets.js", "An invisible secret"} {
62 if !strings.Contains(page, needle) {
63 t.Fatalf("formulier mist %q", needle)
64 }
65 }
66 post := func(values url.Values) string {
67 t.Helper()
68 values.Set("csrf", csrfOf(t, page))
69 res, err := client.PostForm(ts.URL+"/tim/secrets/-/secrets", values)
70 if err != nil {
71 t.Fatal(err)
72 }
73 page = read(t, res)
74 return page
75 }
76 post(url.Values{"name": {"SHOWN"}, "value": {"zichtbaar-waarde"}, "protected": {"1"}})
77 post(url.Values{"name": {"HIDDEN"}, "value": {"onzichtbare-waarde"}, "invisible": {"1"}})
78 if strings.Contains(page, "zichtbaar-waarde") || strings.Contains(page, "onzichtbare-waarde") {
79 t.Fatal("waarde staat in de eerste html")
80 }
81 if !strings.Contains(page, `data-reveal="SHOWN"`) || strings.Contains(page, `data-reveal="HIDDEN"`) {
82 t.Fatalf("toonknop:\n%s", page)
83 }
84 if !strings.Contains(page, `value="replace"`) || !strings.Contains(page, ">Show<") || !strings.Contains(page, ">Edit<") || !strings.Contains(page, ">Replace<") {
85 t.Fatalf("knoppen:\n%s", page)
86 }
87 res, err = client.PostForm(ts.URL+"/tim/secrets/-/secrets/reveal", url.Values{
88 "csrf": {csrfOf(t, page)}, "name": {"SHOWN"},
89 })
90 if err != nil {
91 t.Fatal(err)
92 }
93 shown := read(t, res)
94 if res.StatusCode != http.StatusOK || !strings.Contains(shown, "zichtbaar-waarde") {
95 t.Fatalf("toon %d %s", res.StatusCode, shown)
96 }
97 res, err = client.PostForm(ts.URL+"/tim/secrets/-/secrets/reveal", url.Values{
98 "csrf": {csrfOf(t, page)}, "name": {"HIDDEN"},
99 })
100 if err != nil {
101 t.Fatal(err)
102 }
103 hidden := read(t, res)
104 if res.StatusCode != http.StatusForbidden || strings.Contains(hidden, "onzichtbare-waarde") {
105 t.Fatalf("verborgen toon %d %s", res.StatusCode, hidden)
106 }
107 post(url.Values{"mode": {"update"}, "name": {"SHOWN"}, "value": {"nieuwe-waarde"}})
108 if !strings.Contains(page, "Secret saved") {
109 t.Fatalf("bewerken:\n%s", page)
110 }
111 post(url.Values{"mode": {"update"}, "name": {"HIDDEN"}, "value": {"mag-niet"}})
112 if !strings.Contains(page, "invisible") || strings.Contains(page, "mag-niet") {
113 t.Fatalf("bewerken van onzichtbaar:\n%s", page)
114 }
115 post(url.Values{"mode": {"replace"}, "name": {"HIDDEN"}, "value": {"vervangen-waarde"}, "protected": {"1"}})
116 if !strings.Contains(page, "Secret replaced") || strings.Contains(page, "vervangen-waarde") || strings.Contains(page, "onzichtbare-waarde") {
117 t.Fatalf("vervangen:\n%s", page)
118 }
119
120 ctx := context.Background()
121 tim, err := st.UserByUsername(ctx, "tim")
122 if err != nil {
123 t.Fatal(err)
124 }
125 repo, err := st.RepoByPath(ctx, "tim", "secrets")
126 if err != nil {
127 t.Fatal(err)
128 }
129 vals, err := st.SecretValues(ctx, "repo", repo.ID, true)
130 if err != nil || vals["SHOWN"] != "nieuwe-waarde" || vals["HIDDEN"] != "vervangen-waarde" {
131 t.Fatalf("opgeslagen %#v %v", vals, err)
132 }
133 list, err := st.ListSecrets(ctx, "repo", repo.ID)
134 if err != nil {
135 t.Fatal(err)
136 }
137 for _, m := range list {
138 if m.Name == "HIDDEN" && (!m.Invisible || !m.Protected) {
139 t.Fatalf("vlaggen %+v", m)
140 }
141 if m.Name == "SHOWN" && (m.Invisible || m.Protected) {
142 t.Fatalf("zichtbaar werd %+v", m)
143 }
144 }
145 token, err := st.CreateToken(ctx, tim.ID, "laptop")
146 if err != nil {
147 t.Fatal(err)
148 }
149 call := func(method, path, body string) (int, string) {
150 t.Helper()
151 req, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
152 if err != nil {
153 t.Fatal(err)
154 }
155 req.Header.Set("Authorization", "Bearer "+token)
156 req.Header.Set("Content-Type", "application/json")
157 res, err := client.Do(req)
158 if err != nil {
159 t.Fatal(err)
160 }
161 return res.StatusCode, read(t, res)
162 }
163 code, body := call(http.MethodGet, "/api/v1/repos/tim/secrets/secrets", "")
164 if code != http.StatusOK || strings.Contains(body, "nieuwe-waarde") || strings.Contains(body, "vervangen-waarde") || !strings.Contains(body, `"invisible":true`) {
165 t.Fatalf("lijst %d %s", code, body)
166 }
167 code, body = call(http.MethodGet, "/api/v1/repos/tim/secrets/secrets/SHOWN", "")
168 if code != http.StatusOK || !strings.Contains(body, "nieuwe-waarde") {
169 t.Fatalf("api toon %d %s", code, body)
170 }
171 code, body = call(http.MethodGet, "/api/v1/repos/tim/secrets/secrets/HIDDEN", "")
172 if code != http.StatusForbidden || strings.Contains(body, "vervangen-waarde") {
173 t.Fatalf("api verborgen %d %s", code, body)
174 }
175 code, body = call(http.MethodPut, "/api/v1/repos/tim/secrets/secrets/HIDDEN", `{"value":"nee","protected":false}`)
176 if code != http.StatusForbidden || strings.Contains(body, "nee") {
177 t.Fatalf("api bewerken %d %s", code, body)
178 }
179 code, body = call(http.MethodPost, "/api/v1/repos/tim/secrets/secrets/HIDDEN/replace", `{"value":"api-nieuw","protected":false}`)
180 if code != http.StatusOK || strings.Contains(body, "api-nieuw") || !strings.Contains(body, `"invisible":true`) {
181 t.Fatalf("api vervangen %d %s", code, body)
182 }
183 code, body = call(http.MethodPut, "/api/v1/repos/tim/secrets/secrets/SHOWN", `{"value":"api-zichtbaar","protected":true}`)
184 if code != http.StatusOK || strings.Contains(body, "api-zichtbaar") || !strings.Contains(body, `"protected":true`) {
185 t.Fatalf("api update %d %s", code, body)
186 }
187 code, body = call(http.MethodPost, "/api/v1/repos/tim/secrets/secrets", `{"name":"GROUPLESS","value":"x"}`)
188 if code != http.StatusCreated || strings.Contains(body, `"value"`) {
189 t.Fatalf("api aanmaken %d %s", code, body)
190 }
191 code, body = call(http.MethodPost, "/api/v1/repos/tim/secrets/secrets", `{"name":"SHOWN","value":"x","invisible":true}`)
192 if code != http.StatusConflict {
193 t.Fatalf("api dubbel %d %s", code, body)
194 }
195 code, body = call(http.MethodDelete, "/api/v1/repos/tim/secrets/secrets/HIDDEN", "")
196 if code != http.StatusNoContent {
197 t.Fatalf("api weg %d %s", code, body)
198 }
199 var listed struct {
200 Secrets []struct {
201 Name string `json:"name"`
202 Invisible bool `json:"invisible"`
203 } `json:"secrets"`
204 }
205 code, body = call(http.MethodGet, "/api/v1/repos/tim/secrets/secrets", "")
206 if err := json.Unmarshal([]byte(body), &listed); err != nil {
207 t.Fatal(err)
208 }
209 for _, m := range listed.Secrets {
210 if m.Name == "HIDDEN" {
211 t.Fatalf("verwijderd blijft in de lijst %s", body)
212 }
213 }
214 _ = code
215
216 g, err := st.CreateGroup(ctx, tim.ID, "Team", "team", "", "developer")
217 if err != nil {
218 t.Fatal(err)
219 }
220 if err := st.CreateSecret(ctx, "group", g.ID, "GROUP_HIDDEN", "groep-geheim", false, true); err != nil {
221 t.Fatal(err)
222 }
223 res, err = client.Get(ts.URL + "/groups/team?tab=settings")
224 if err != nil {
225 t.Fatal(err)
226 }
227 groupPage := read(t, res)
228 if strings.Contains(groupPage, "groep-geheim") || !strings.Contains(groupPage, "GROUP_HIDDEN") || !strings.Contains(groupPage, ">Replace<") || strings.Contains(groupPage, `data-reveal="GROUP_HIDDEN"`) {
229 t.Fatalf("groepsgeheim:\n%s", groupPage)
230 }
231 code, body = call(http.MethodGet, "/api/v1/groups/team/secrets/GROUP_HIDDEN", "")
232 if code != http.StatusForbidden || strings.Contains(body, "groep-geheim") {
233 t.Fatalf("groep api %d %s", code, body)
234 }
235}
236
237func TestWebhookTableAndEdit(t *testing.T) {
238 if _, err := exec.LookPath("git"); err != nil {
239 t.Skip("git ontbreekt")
240 }
241 storage := t.TempDir()
242 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
243 if err != nil {
244 t.Fatal(err)
245 }
246 t.Cleanup(func() { _ = st.Close() })
247 cfg := config.Config{
248 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
249 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
250 Git: config.Git{Binary: "git", DefaultBranch: "master"},
251 }
252 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
253 ts := httptest.NewServer(srv.Handler())
254 t.Cleanup(ts.Close)
255 jar, _ := cookiejar.New(nil)
256 client := &http.Client{Jar: jar}
257 res, err := client.Get(ts.URL + "/login")
258 if err != nil {
259 t.Fatal(err)
260 }
261 page := read(t, res)
262 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
263 "csrf": {csrfOf(t, page)}, "name": {"hooks"}, "visibility": {"private"},
264 })
265 if err != nil {
266 t.Fatal(err)
267 }
268 _ = read(t, res)
269 res, err = client.Get(ts.URL + "/tim/hooks/-/settings?tab=webhooks")
270 if err != nil {
271 t.Fatal(err)
272 }
273 page = read(t, res)
274 if !strings.Contains(page, "evgrid") || !strings.Contains(page, `data-preset="custom"`) {
275 t.Fatalf("compact formulier:\n%s", page)
276 }
277 res, err = client.PostForm(ts.URL+"/tim/hooks/-/webhooks", url.Values{
278 "csrf": {csrfOf(t, page)}, "name": {"ada"}, "preset": {"telegram"},
279 "token": {"BOT_TOKEN"}, "chat": {"100"}, "event_push": {"1"}, "event_pipeline_success": {"1"},
280 })
281 if err != nil {
282 t.Fatal(err)
283 }
284 page = read(t, res)
285 for _, needle := range []string{"hooktable", "urlclip", "data-tip=", ">Edit<", ">Remove<", "pipeline succeeded"} {
286 if !strings.Contains(page, needle) {
287 t.Fatalf("tabel mist %q\n%s", needle, page)
288 }
289 }
290 ctx := context.Background()
291 repo, err := st.RepoByPath(ctx, "tim", "hooks")
292 if err != nil {
293 t.Fatal(err)
294 }
295 hooks, err := st.ListWebhooks(ctx, "repo", repo.ID)
296 if err != nil || len(hooks) != 1 || !strings.Contains(hooks[0].Fields, `"chat":"100"`) {
297 t.Fatalf("velden %#v %v", hooks, err)
298 }
299 res, err = client.Get(ts.URL + "/tim/hooks/-/settings?tab=webhooks&hook=" + strconv.FormatInt(hooks[0].ID, 10))
300 if err != nil {
301 t.Fatal(err)
302 }
303 edit := read(t, res)
304 for _, needle := range []string{
305 `name="id"`, `value="ada"`, `value="100"`, `value="telegram" selected`,
306 "Edit webhook", `name="event_push" value="1" checked`,
307 } {
308 if !strings.Contains(edit, needle) {
309 t.Fatalf("bewerken mist %q\n%s", needle, edit)
310 }
311 }
312 res, err = client.PostForm(ts.URL+"/tim/hooks/-/webhooks", url.Values{
313 "csrf": {csrfOf(t, edit)}, "id": {strconv.FormatInt(hooks[0].ID, 10)}, "name": {"ada"},
314 "preset": {"telegram"}, "token": {"BOT_TOKEN"}, "chat": {"200"}, "event_push": {"1"},
315 })
316 if err != nil {
317 t.Fatal(err)
318 }
319 _ = read(t, res)
320 hooks, err = st.ListWebhooks(ctx, "repo", repo.ID)
321 if err != nil || len(hooks) != 1 || !strings.Contains(hooks[0].BodyTemplate, `"chat_id":"200"`) || strings.Contains(hooks[0].Fields, `"chat":"100"`) {
322 t.Fatalf("bijgewerkt %#v %v", hooks, err)
323 }
324 tim, err := st.UserByUsername(ctx, "tim")
325 if err != nil {
326 t.Fatal(err)
327 }
328 token, err := st.CreateToken(ctx, tim.ID, "laptop")
329 if err != nil {
330 t.Fatal(err)
331 }
332 raw, _ := json.Marshal(map[string]any{
333 "name": "ada", "preset": "telegram", "token": "BOT_TOKEN", "chat": "300", "events": []string{"push"},
334 })
335 req, err := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/repos/tim/hooks/webhooks/"+strconv.FormatInt(hooks[0].ID, 10), strings.NewReader(string(raw)))
336 if err != nil {
337 t.Fatal(err)
338 }
339 req.Header.Set("Authorization", "Bearer "+token)
340 req.Header.Set("Content-Type", "application/json")
341 res, err = client.Do(req)
342 if err != nil {
343 t.Fatal(err)
344 }
345 body := read(t, res)
346 if res.StatusCode != http.StatusOK {
347 t.Fatalf("api %d %s", res.StatusCode, body)
348 }
349 hooks, err = st.ListWebhooks(ctx, "repo", repo.ID)
350 if err != nil || len(hooks) != 1 || !strings.Contains(hooks[0].BodyTemplate, `"chat_id":"300"`) {
351 t.Fatalf("api bijgewerkt %#v %v", hooks, err)
352 }
353}
354
355func TestProtectedSecretRequiresMaintainer(t *testing.T) {
356 if _, err := exec.LookPath("git"); err != nil {
357 t.Skip("git ontbreekt")
358 }
359 storage := t.TempDir()
360 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
361 if err != nil {
362 t.Fatal(err)
363 }
364 t.Cleanup(func() { _ = st.Close() })
365 cfg := config.Config{
366 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
367 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
368 Git: config.Git{Binary: "git", DefaultBranch: "master"},
369 }
370 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
371 ts := httptest.NewServer(srv.Handler())
372 t.Cleanup(ts.Close)
373
374 jar, _ := cookiejar.New(nil)
375 client := &http.Client{Jar: jar}
376 res, err := client.Get(ts.URL + "/login")
377 if err != nil {
378 t.Fatal(err)
379 }
380 _ = read(t, res)
381
382 ctx := context.Background()
383 tim, err := st.UserByUsername(ctx, "tim")
384 if err != nil {
385 t.Fatal(err)
386 }
387 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
388 "csrf": {csrfOf(t, readBody(t, client, ts.URL+"/new"))}, "name": {"locked"}, "visibility": {"private"},
389 })
390 if err != nil {
391 t.Fatal(err)
392 }
393 _ = read(t, res)
394 repo, err := st.RepoByPath(ctx, "tim", "locked")
395 if err != nil {
396 t.Fatal(err)
397 }
398 const secretValue = "protected-waarde-99"
399 if err := st.CreateSecret(ctx, "repo", repo.ID, "DEPLOY_KEY", secretValue, true, false); err != nil {
400 t.Fatal(err)
401 }
402 ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
403 if err != nil {
404 t.Fatal(err)
405 }
406 if err := st.SetMember(ctx, "repo", repo.ID, "ada", access.RoleDeveloper); err != nil {
407 t.Fatal(err)
408 }
409 adaSess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
410 if err != nil {
411 t.Fatal(err)
412 }
413 adaJar, _ := cookiejar.New(nil)
414 adaClient := &http.Client{Jar: adaJar}
415 u, _ := url.Parse(ts.URL)
416 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: adaSess.ID, Path: "/"}})
417
418 page := readBody(t, adaClient, ts.URL+"/tim/locked/-/settings?tab=secrets")
419 if strings.Contains(page, secretValue) || strings.Contains(page, `data-reveal="DEPLOY_KEY"`) || strings.Contains(page, `value="update"`) {
420 t.Fatalf("ontwikkelaar ziet een protected secret:\n%s", page)
421 }
422 res, err = adaClient.PostForm(ts.URL+"/tim/locked/-/secrets/reveal", url.Values{
423 "csrf": {adaSess.CSRF}, "name": {"DEPLOY_KEY"},
424 })
425 if err != nil {
426 t.Fatal(err)
427 }
428 revealed := read(t, res)
429 if res.StatusCode != http.StatusForbidden || strings.Contains(revealed, secretValue) {
430 t.Fatalf("ui toon %d %s", res.StatusCode, revealed)
431 }
432 res, err = adaClient.PostForm(ts.URL+"/tim/locked/-/secrets", url.Values{
433 "csrf": {adaSess.CSRF}, "mode": {"update"}, "name": {"DEPLOY_KEY"}, "value": {"gekraakt"},
434 })
435 if err != nil {
436 t.Fatal(err)
437 }
438 edited := read(t, res)
439 if res.StatusCode != http.StatusForbidden || strings.Contains(edited, secretValue) || strings.Contains(edited, "gekraakt") {
440 t.Fatalf("ui bewerken %d %s", res.StatusCode, edited)
441 }
442
443 adaTok, err := st.CreateToken(ctx, ada.ID, "ada")
444 if err != nil {
445 t.Fatal(err)
446 }
447 timTok, err := st.CreateToken(ctx, tim.ID, "tim")
448 if err != nil {
449 t.Fatal(err)
450 }
451 call := func(tok, method, path, body string) (int, string) {
452 t.Helper()
453 req, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
454 if err != nil {
455 t.Fatal(err)
456 }
457 req.Header.Set("Authorization", "Bearer "+tok)
458 req.Header.Set("Content-Type", "application/json")
459 res, err := client.Do(req)
460 if err != nil {
461 t.Fatal(err)
462 }
463 return res.StatusCode, read(t, res)
464 }
465 for _, tc := range []struct{ method, path, body string }{
466 {http.MethodGet, "/api/v1/repos/tim/locked/secrets", ""},
467 {http.MethodGet, "/api/v1/repos/tim/locked/secrets/DEPLOY_KEY", ""},
468 {http.MethodPut, "/api/v1/repos/tim/locked/secrets/DEPLOY_KEY", `{"value":"gekraakt","protected":false}`},
469 {http.MethodPost, "/api/v1/repos/tim/locked/secrets/DEPLOY_KEY/replace", `{"value":"gekraakt","protected":true}`},
470 } {
471 code, body := call(adaTok, tc.method, tc.path, tc.body)
472 if code != http.StatusForbidden || strings.Contains(body, secretValue) || strings.Contains(body, "gekraakt") {
473 t.Fatalf("api %s %s %d %s", tc.method, tc.path, code, body)
474 }
475 }
476 vals, err := st.SecretValues(ctx, "repo", repo.ID, true)
477 if err != nil || vals["DEPLOY_KEY"] != secretValue {
478 t.Fatalf("waarde veranderde: %#v %v", vals, err)
479 }
480 code, body := call(timTok, http.MethodGet, "/api/v1/repos/tim/locked/secrets/DEPLOY_KEY", "")
481 if code != http.StatusOK || !strings.Contains(body, secretValue) {
482 t.Fatalf("maintainer toon %d %s", code, body)
483 }
484
485 g, err := st.CreateGroup(ctx, tim.ID, "Team", "team", "", "developer")
486 if err != nil {
487 t.Fatal(err)
488 }
489 if err := st.SetMember(ctx, "group", g.ID, "ada", access.RoleDeveloper); err != nil {
490 t.Fatal(err)
491 }
492 const groupValue = "groep-protected-waarde"
493 if err := st.CreateSecret(ctx, "group", g.ID, "GROUP_KEY", groupValue, true, false); err != nil {
494 t.Fatal(err)
495 }
496 groupPage := readBody(t, adaClient, ts.URL+"/groups/team?tab=settings")
497 if strings.Contains(groupPage, groupValue) || strings.Contains(groupPage, `data-reveal="GROUP_KEY"`) {
498 t.Fatalf("groepsontwikkelaar ziet het secret:\n%s", groupPage)
499 }
500 code, body = call(adaTok, http.MethodGet, "/api/v1/groups/team/secrets/GROUP_KEY", "")
501 if code != http.StatusForbidden || strings.Contains(body, groupValue) {
502 t.Fatalf("groep api toon %d %s", code, body)
503 }
504 code, body = call(adaTok, http.MethodPut, "/api/v1/groups/team/secrets/GROUP_KEY", `{"value":"gekraakt","protected":false}`)
505 if code != http.StatusForbidden || strings.Contains(body, groupValue) {
506 t.Fatalf("groep api bewerken %d %s", code, body)
507 }
508 code, body = call(timTok, http.MethodGet, "/api/v1/groups/team/secrets/GROUP_KEY", "")
509 if code != http.StatusOK || !strings.Contains(body, groupValue) {
510 t.Fatalf("groepseigenaar toon %d %s", code, body)
511 }
512}
513
514func readBody(t *testing.T, client *http.Client, rawURL string) string {
515 t.Helper()
516 res, err := client.Get(rawURL)
517 if err != nil {
518 t.Fatal(err)
519 }
520 return read(t, res)
521}