BlueGit

timfa bluegit

Files

bluegit / internal / server / server_test.go

server_test.go

feat: toon map- en schijfverbruik op het opslagtabblad
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed 54b73354 History
server_test.go 23.9 KiB Download Raw
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "io"
7 "net/http"
8 "net/http/cookiejar"
9 "net/http/httptest"
10 "net/url"
11 "os"
12 "os/exec"
13 "path/filepath"
14 "strconv"
15 "strings"
16 "testing"
17 "time"
18
19 "gitlab.com/Timfa/bluegit/internal/auth"
20 "gitlab.com/Timfa/bluegit/internal/config"
21 "gitlab.com/Timfa/bluegit/internal/state"
22 "gitlab.com/Timfa/bluegit/internal/store"
23)
24
25func TestWebRepoPushAndSecretBoundary(t *testing.T) {
26 if _, err := exec.LookPath("git"); err != nil {
27 t.Skip("git ontbreekt")
28 }
29 storage := t.TempDir()
30 key := bytes32()
31 st, err := store.Open(filepath.Join(storage, "bluegit.db"), key)
32 if err != nil {
33 t.Fatal(err)
34 }
35 t.Cleanup(func() { _ = st.Close() })
36 cfg := config.Config{
37 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
38 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
39 Git: config.Git{Binary: "git", DefaultBranch: "master"},
40 SSH: config.SSH{Enabled: true, Listen: "0.0.0.0:2222", PublicHost: "git.timfalken.com", PublicPort: 22},
41 CI: config.CI{Enabled: false},
42 }
43 cfg.Auth.BaseURL = "https://auth.timfalken.com"
44 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
45 ts := httptest.NewServer(srv.Handler())
46 t.Cleanup(ts.Close)
47
48 jar, _ := cookiejar.New(nil)
49 client := &http.Client{Jar: jar}
50 res, err := client.Get(ts.URL + "/login")
51 if err != nil {
52 t.Fatal(err)
53 }
54 body := read(t, res)
55 if res.StatusCode != 200 || !strings.Contains(body, "Overview") {
56 t.Fatalf("login %d %s", res.StatusCode, body)
57 }
58 logo, err := client.Get(ts.URL + "/assets/logo.svg")
59 if err != nil {
60 t.Fatal(err)
61 }
62 wantLogo, err := os.ReadFile("../../assets/logo.svg")
63 if err != nil {
64 t.Fatal(err)
65 }
66 if logo.StatusCode != 200 || read(t, logo) != string(wantLogo) {
67 t.Fatalf("logo %d wijkt af van assets/logo.svg", logo.StatusCode)
68 }
69 if ct := logo.Header.Get("Content-Type"); !strings.Contains(ct, "image/svg+xml") {
70 t.Fatalf("favicon-type %s", ct)
71 }
72 csrf := csrfOf(t, body)
73 form := url.Values{"csrf": {csrf}, "name": {"demo"}, "description": {"eerste"}, "visibility": {"private"}}
74 res, err = client.PostForm(ts.URL+"/new/repo", form)
75 if err != nil {
76 t.Fatal(err)
77 }
78 body = read(t, res)
79 if !strings.Contains(body, "tim/demo") {
80 t.Fatalf("repo pagina:\n%s", body)
81 }
82 if !strings.Contains(body, "ssh://git@git.timfalken.com:22/tim/demo.git") {
83 t.Fatalf("clone-URL hoort de publieke SSH-poort te tonen:\n%s", body)
84 }
85 if strings.Contains(body, ":2222/") {
86 t.Fatalf("clone-URL toont de bindpoort:\n%s", body)
87 }
88 sshURL := "ssh://git@git.timfalken.com:22/tim/demo.git"
89 httpURL := "http://127.0.0.1:9/tim/demo.git"
90 assertCloneMenu(t, body, "overzicht", sshURL, httpURL)
91 res, err = client.Get(ts.URL + "/tim/demo/-/tree")
92 if err != nil {
93 t.Fatal(err)
94 }
95 if res.StatusCode != http.StatusOK {
96 t.Fatalf("bestanden %d", res.StatusCode)
97 }
98 assertCloneMenu(t, read(t, res), "bestanden", sshURL, httpURL)
99
100 res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, body)}, "name": {"test"}})
101 if err != nil {
102 t.Fatal(err)
103 }
104 body = read(t, res)
105 token := between(body, `<p class="code">`, "</p>")
106 if !strings.HasPrefix(token, "bg_") {
107 t.Fatalf("token pagina:\n%s", body)
108 }
109
110 work := t.TempDir()
111 git(t, work, "init", "-b", "master")
112 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
113 git(t, work, "config", "user.name", "tim")
114 if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("hallo bluegit\n"), 0o644); err != nil {
115 t.Fatal(err)
116 }
117 git(t, work, "add", "README.md")
118 git(t, work, "commit", "-m", "eerste commit")
119 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/demo.git"
120 git(t, work, "remote", "add", "origin", remote)
121 git(t, work, "push", "-u", "origin", "master")
122
123 res, err = client.Get(ts.URL + "/tim/demo")
124 if err != nil {
125 t.Fatal(err)
126 }
127 body = read(t, res)
128 if !strings.Contains(body, "eerste commit") || !strings.Contains(body, "README.md") {
129 t.Fatalf("na push:\n%s", body)
130 }
131 res, err = client.Get(ts.URL + "/tim/demo/-/blob/README.md")
132 if err != nil {
133 t.Fatal(err)
134 }
135 body = read(t, res)
136 if !strings.Contains(body, "hallo bluegit") {
137 t.Fatalf("blob:\n%s", body)
138 }
139
140 ctx := context.Background()
141 ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
142 if err != nil {
143 t.Fatal(err)
144 }
145 repo, err := st.RepoByPath(ctx, "tim", "demo")
146 if err != nil {
147 t.Fatal(err)
148 }
149 if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
150 t.Fatal(err)
151 }
152 sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
153 if err != nil {
154 t.Fatal(err)
155 }
156 adaJar, _ := cookiejar.New(nil)
157 adaClient := &http.Client{Jar: adaJar}
158 u, _ := url.Parse(ts.URL)
159 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
160 res, err = adaClient.Get(ts.URL + "/")
161 if err != nil {
162 t.Fatal(err)
163 }
164 adaCSRF := csrfOf(t, read(t, res))
165 res, err = adaClient.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
166 "csrf": {adaCSRF}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
167 })
168 if err != nil {
169 t.Fatal(err)
170 }
171 if res.StatusCode != http.StatusForbidden {
172 t.Fatalf("ontwikkelaar mocht een geheim schrijven: %d", res.StatusCode)
173 }
174 _ = res.Body.Close()
175
176 res, err = client.Get(ts.URL + "/tim/demo/-/settings?tab=geheimen")
177 if err != nil {
178 t.Fatal(err)
179 }
180 ownerPage := read(t, res)
181 res, err = client.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
182 "csrf": {csrfOf(t, ownerPage)}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
183 })
184 if err != nil {
185 t.Fatal(err)
186 }
187 saved := read(t, res)
188 if strings.Contains(saved, "super-geheim-waarde") {
189 t.Fatal("geheimwaarde staat op de pagina")
190 }
191 if !strings.Contains(saved, "TOKEN") {
192 t.Fatalf("naam ontbreekt:\n%s", saved)
193 }
194
195 res, err = client.PostForm(ts.URL+"/tim/demo/-/webhooks", url.Values{
196 "csrf": {csrfOf(t, saved)}, "name": {"kapot"}, "preset": {"generic"},
197 "url": {"https://example.test/hook"}, "branch_filter": {"re:("}, "event_push": {"1"},
198 })
199 if err != nil {
200 t.Fatal(err)
201 }
202 hookPage := read(t, res)
203 if !strings.Contains(hookPage, "branchfilter") && !strings.Contains(hookPage, "error") && !strings.Contains(strings.ToLower(hookPage), "regex") {
204 t.Fatalf("kapot filter:\n%s", hookPage)
205 }
206}
207
208func TestSetupChoosesStorage(t *testing.T) {
209 storage := t.TempDir()
210 stateDir := t.TempDir()
211 key := bytes32()
212 st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), key)
213 if err != nil {
214 t.Fatal(err)
215 }
216 t.Cleanup(func() { _ = st.Close() })
217 cfg := config.Config{
218 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0",
219 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
220 Git: config.Git{Binary: "git", DefaultBranch: "master"},
221 }
222 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
223 ts := httptest.NewServer(srv.Handler())
224 t.Cleanup(ts.Close)
225
226 res, err := http.Get(ts.URL + "/tim/demo.git/info/refs?service=git-upload-pack")
227 if err != nil {
228 t.Fatal(err)
229 }
230 body := read(t, res)
231 if res.StatusCode != http.StatusServiceUnavailable || !strings.Contains(body, "not set up yet") {
232 t.Fatalf("git zonder opslag: %d %s", res.StatusCode, body)
233 }
234
235 jar, _ := cookiejar.New(nil)
236 client := &http.Client{Jar: jar}
237 res, err = client.Get(ts.URL + "/login")
238 if err != nil {
239 t.Fatal(err)
240 }
241 page := read(t, res)
242 if res.StatusCode != 200 || !strings.Contains(page, "Choose storage") {
243 t.Fatalf("setup:\n%s", page)
244 }
245 res, err = client.PostForm(ts.URL+"/setup", url.Values{"csrf": {csrfOf(t, page)}, "path": {"relatief"}})
246 if err != nil {
247 t.Fatal(err)
248 }
249 page = read(t, res)
250 if !strings.Contains(page, "absolute") {
251 t.Fatalf("relatief pad:\n%s", page)
252 }
253 res, err = client.PostForm(ts.URL+"/setup", url.Values{"csrf": {csrfOf(t, page)}, "path": {storage}})
254 if err != nil {
255 t.Fatal(err)
256 }
257 page = read(t, res)
258 if !strings.Contains(page, "Overview") || !strings.Contains(page, "free.") {
259 t.Fatalf("na opslaan:\n%s", page)
260 }
261 if srv.StoragePath() != storage {
262 t.Fatalf("pad %s", srv.StoragePath())
263 }
264 saved, err := os.ReadFile(filepath.Join(stateDir, "storage_path"))
265 if err != nil || strings.TrimSpace(string(saved)) != storage {
266 t.Fatalf("bestand %q %v", saved, err)
267 }
268 res, err = client.Get(ts.URL + "/setup")
269 if err != nil {
270 t.Fatal(err)
271 }
272 page = read(t, res)
273 info, err := state.Inspect(storage)
274 if err != nil {
275 t.Fatal(err)
276 }
277 n, err := state.DirSize(context.Background(), storage)
278 if err != nil {
279 t.Fatal(err)
280 }
281 pct := state.Percent(info.Used(), info.Total)
282 for _, want := range []string{
283 "does not move",
284 "BlueGit uses " + state.Format(n),
285 "Disk: " + state.Format(info.Total),
286 state.Format(info.Used()) + " used",
287 state.Format(info.Free) + " free.",
288 `<svg class="diskbar-svg"`,
289 `class="fill" width="` + strconv.Itoa(pct) + `"`,
290 } {
291 if !strings.Contains(page, want) {
292 t.Fatalf("mist %q\n%s", want, page)
293 }
294 }
295 if strings.Contains(page, "Count stopped early") {
296 t.Fatal("kleine map hoort volledig geteld")
297 }
298 res, err = http.Get(ts.URL + "/tim/demo.git/info/refs?service=git-upload-pack")
299 if err != nil {
300 t.Fatal(err)
301 }
302 body = read(t, res)
303 if res.StatusCode == http.StatusServiceUnavailable {
304 t.Fatalf("git blijft geblokkeerd: %s", body)
305 }
306
307 ada, err := st.UpsertUser(context.Background(), 2, "ada", "", true)
308 if err != nil {
309 t.Fatal(err)
310 }
311 if ada.InstanceAdmin {
312 t.Fatal("is_admin werd installatiebeheerder")
313 }
314 sess, err := st.CreateSession(context.Background(), ada.ID, "dev", time.Now().Add(time.Hour))
315 if err != nil {
316 t.Fatal(err)
317 }
318 adaJar, _ := cookiejar.New(nil)
319 adaClient := &http.Client{Jar: adaJar}
320 u, _ := url.Parse(ts.URL)
321 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
322 res, err = adaClient.Get(ts.URL + "/setup")
323 if err != nil {
324 t.Fatal(err)
325 }
326 if res.StatusCode != http.StatusForbidden {
327 t.Fatalf("ada setup %d %s", res.StatusCode, read(t, res))
328 }
329 _ = res.Body.Close()
330}
331
332func TestNameBecomesSlug(t *testing.T) {
333 if _, err := exec.LookPath("git"); err != nil {
334 t.Skip("git ontbreekt")
335 }
336 storage := t.TempDir()
337 st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), bytes32())
338 if err != nil {
339 t.Fatal(err)
340 }
341 t.Cleanup(func() { _ = st.Close() })
342 cfg := config.Config{
343 BaseURL: "http://git.timfalken.com", Listen: "127.0.0.1:0", StoragePath: storage,
344 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
345 Git: config.Git{Binary: "git", DefaultBranch: "master"},
346 }
347 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
348 ts := httptest.NewServer(srv.Handler())
349 t.Cleanup(ts.Close)
350 jar, _ := cookiejar.New(nil)
351 client := &http.Client{Jar: jar}
352 res, err := client.Get(ts.URL + "/login")
353 if err != nil {
354 t.Fatal(err)
355 }
356 _ = read(t, res)
357 res, err = client.Get(ts.URL + "/new")
358 if err != nil {
359 t.Fatal(err)
360 }
361 page := read(t, res)
362 if !strings.Contains(page, `data-kind="repo"`) || !strings.Contains(page, "/assets/slug.js") {
363 t.Fatalf("formulier:\n%s", page)
364 }
365 if strings.Contains(page, `pattern=`) {
366 t.Fatalf("het naamveld blokkeert spaties in de browser:\n%s", page)
367 }
368
369 prev, err := client.Get(ts.URL + "/new/slug?kind=repo&name=test+repo")
370 if err != nil {
371 t.Fatal(err)
372 }
373 var body struct {
374 Name string `json:"name"`
375 URL string `json:"url"`
376 }
377 if err := json.NewDecoder(prev.Body).Decode(&body); err != nil {
378 t.Fatal(err)
379 }
380 prev.Body.Close()
381 if body.Name != "test-repo" || body.URL != "git.timfalken.com/tim/test-repo" {
382 t.Fatalf("preview %+v", body)
383 }
384 prev, err = client.Get(ts.URL + "/new/slug?kind=group&name=Test+Groep")
385 if err != nil {
386 t.Fatal(err)
387 }
388 if err := json.NewDecoder(prev.Body).Decode(&body); err != nil {
389 t.Fatal(err)
390 }
391 prev.Body.Close()
392 if body.Name != "test-groep" || body.URL != "git.timfalken.com/groups/test-groep" {
393 t.Fatalf("groep-preview %+v", body)
394 }
395 prev, err = client.Get(ts.URL + "/new/slug?kind=repo&name=foo.git")
396 if err != nil {
397 t.Fatal(err)
398 }
399 if err := json.NewDecoder(prev.Body).Decode(&body); err != nil {
400 t.Fatal(err)
401 }
402 prev.Body.Close()
403 if body.Name != "" || body.URL != "" {
404 t.Fatalf("ongeldige preview %+v", body)
405 }
406
407 csrf := csrfOf(t, page)
408 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{"csrf": {csrf}, "name": {"test repo"}, "visibility": {"private"}})
409 if err != nil {
410 t.Fatal(err)
411 }
412 page = read(t, res)
413 if !strings.Contains(page, "tim/test-repo") || strings.Contains(page, "test repo") {
414 t.Fatalf("repository:\n%s", page)
415 }
416 res, err = client.PostForm(ts.URL+"/new/group", url.Values{"csrf": {csrfOf(t, page)}, "name": {"Test Groep"}})
417 if err != nil {
418 t.Fatal(err)
419 }
420 page = read(t, res)
421 if !strings.Contains(page, ">Test Groep<") || !strings.Contains(page, "test-groep") {
422 t.Fatalf("groep:\n%s", page)
423 }
424 prev, err = client.Get(ts.URL + "/new/slug?kind=repo&name=test+repo&owner=test-groep")
425 if err != nil {
426 t.Fatal(err)
427 }
428 if err := json.NewDecoder(prev.Body).Decode(&body); err != nil {
429 t.Fatal(err)
430 }
431 prev.Body.Close()
432 if body.URL != "git.timfalken.com/test-groep/test-repo" {
433 t.Fatalf("preview met groep %+v", body)
434 }
435 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{"csrf": {csrfOf(t, page)}, "name": {"foo.git"}})
436 if err != nil {
437 t.Fatal(err)
438 }
439 page = read(t, res)
440 if !strings.Contains(page, "This name cannot be used.") {
441 t.Fatalf("weigering:\n%s", page)
442 }
443}
444
445func TestProjectOverviewAndFiles(t *testing.T) {
446 if _, err := exec.LookPath("git"); err != nil {
447 t.Skip("git ontbreekt")
448 }
449 hook := filepath.Join(t.TempDir(), "bluegit")
450 build := exec.Command("go", "build", "-buildvcs=false", "-o", hook, "gitlab.com/Timfa/bluegit/cmd/bluegit")
451 build.Env = append(os.Environ(), "CGO_ENABLED=0")
452 if out, err := build.CombinedOutput(); err != nil {
453 t.Fatalf("hook bouwen: %v\n%s", err, out)
454 }
455
456 storage := t.TempDir()
457 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
458 if err != nil {
459 t.Fatal(err)
460 }
461 t.Cleanup(func() { _ = st.Close() })
462 cfg := config.Config{
463 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
464 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
465 Git: config.Git{Binary: "git", DefaultBranch: "master"},
466 SSH: config.SSH{Enabled: true, Listen: "0.0.0.0:2222", PublicHost: "git.timfalken.com", PublicPort: 22},
467 }
468 cfg.Auth.BaseURL = "https://auth.timfalken.com"
469 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: hook}
470 ts := httptest.NewServer(srv.Handler())
471 t.Cleanup(ts.Close)
472
473 jar, _ := cookiejar.New(nil)
474 client := &http.Client{Jar: jar}
475 res, err := client.Get(ts.URL + "/login")
476 if err != nil {
477 t.Fatal(err)
478 }
479 csrf := csrfOf(t, read(t, res))
480 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
481 "csrf": {csrf}, "name": {"legacy cycles"}, "description": {"Simulatie"}, "visibility": {"public"},
482 })
483 if err != nil {
484 t.Fatal(err)
485 }
486 created := read(t, res)
487 if !strings.Contains(created, "tim/legacy-cycles") || !strings.Contains(created, "No commits yet.") {
488 t.Fatalf("lege repo:\n%s", created)
489 }
490 ctx := context.Background()
491 repo, err := st.RepoByPath(ctx, "tim", "legacy-cycles")
492 if err != nil {
493 t.Fatal(err)
494 }
495 pats, err := st.ProtectedPatterns(ctx, repo.ID)
496 if err != nil || len(pats) != 1 || pats[0] != "master" {
497 t.Fatalf("master hoort beschermd te zijn: %v %v", pats, err)
498 }
499
500 res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, created)}, "name": {"laptop"}})
501 if err != nil {
502 t.Fatal(err)
503 }
504 token := between(read(t, res), `<p class="code">`, "</p>")
505 work := t.TempDir()
506 git(t, work, "init", "-b", "master")
507 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
508 git(t, work, "config", "user.name", "tim")
509 readme := "# Legacy Cycles\n\nEen kleine simulatie.\n\n| Sleutel | Waarde |\n| --- | --- |\n| Taal | Rust |\n| Netwerk | UDP |\n\nZie [regels](docs/regels.md).\n"
510 writeFile(t, filepath.Join(work, "README.md"), readme)
511 writeFile(t, filepath.Join(work, "LICENSE"), "MIT\n")
512 writeFile(t, filepath.Join(work, "Cargo.toml"), "[package]\nname = \"legacy-cycles\"\nversion = \"0.1.0\"\n\n# debug\n[profile.dev]\nopt-level = 1\n")
513 writeFile(t, filepath.Join(work, "src", "main.go"), "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"hallo\")\n}\n")
514 writeFile(t, filepath.Join(work, "crates", "sim", "lib.rs"), "pub fn tick() {}\n")
515 git(t, work, "add", ".")
516 git(t, work, "commit", "-m", "eerste commit")
517 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/legacy-cycles.git"
518 git(t, work, "remote", "add", "origin", remote)
519 git(t, work, "push", "-u", "origin", "master")
520
521 res, err = client.Get(ts.URL + "/tim/legacy-cycles")
522 if err != nil {
523 t.Fatal(err)
524 }
525 body := read(t, res)
526 for _, want := range []string{
527 `class="on">Overview`,
528 `/-/tree?rev=master">Files`,
529 "Project information",
530 "Last commit",
531 "Last update",
532 "eerste commit",
533 "Find file",
534 `aria-label="Protected"`,
535 "Created on ",
536 "1 commit",
537 "<table class=\"md\">",
538 "<th>Sleutel</th>",
539 "<td>Rust</td>",
540 "/tim/legacy-cycles/-/blob/docs/regels.md?rev=master",
541 "/-/blob/README.md?rev=master\">README",
542 "/-/blob/LICENSE?rev=master\">LICENSE",
543 "/-/tree/crates?rev=master",
544 "/-/tree/src?rev=master",
545 "Simulatie",
546 "ssh://git@git.timfalken.com:22/tim/legacy-cycles.git",
547 } {
548 if !strings.Contains(body, want) {
549 t.Fatalf("overzicht mist %q\n%s", want, body)
550 }
551 }
552 crates := strings.Index(body, "/-/tree/crates")
553 cargo := strings.Index(body, "Cargo.toml")
554 if crates < 0 || cargo < 0 || crates > cargo {
555 t.Fatal("mappen horen voor bestanden")
556 }
557
558 res, err = client.Get(ts.URL + "/tim/legacy-cycles/-/tree")
559 if err != nil {
560 t.Fatal(err)
561 }
562 tree := read(t, res)
563 for _, want := range []string{
564 `class="on">Files`,
565 `data-tree-filter`,
566 `data-path="src/main.go"`,
567 `data-path="crates/sim"`,
568 `data-repo="tim/legacy-cycles"`,
569 `class="fill"`,
570 `class="filepane"`,
571 `class="twist"`,
572 `aria-expanded="false"`,
573 "This directory is empty.",
574 } {
575 if want == "This directory is empty." {
576 if strings.Contains(tree, want) {
577 t.Fatalf("root is niet leeg:\n%s", tree)
578 }
579 continue
580 }
581 if !strings.Contains(tree, want) {
582 t.Fatalf("bestanden mist %q\n%s", want, tree)
583 }
584 }
585 if strings.Contains(tree, `aria-expanded="true"`) || strings.Contains(tree, ` dir open`) {
586 t.Fatalf("root hoort dichtgeklapt:\n%s", tree)
587 }
588
589 res, err = client.Get(ts.URL + "/tim/legacy-cycles/-/blob/src/main.go")
590 if err != nil {
591 t.Fatal(err)
592 }
593 blob := read(t, res)
594 for _, want := range []string{
595 `class="on">Files`,
596 `class="depth-1 active"`,
597 `class="depth-0 dir open active"`,
598 `data-dir="1"`,
599 `aria-expanded="true"`,
600 `data-path="src"`,
601 `data-repo="tim/legacy-cycles"`,
602 `class="fill"`,
603 `class="filepane"`,
604 `class="chevron"`,
605 `<span class="hl-k">func</span>`,
606 `<span class="hl-s">&#34;fmt&#34;</span>`,
607 `class="ln">1`,
608 `<span>src</span>`,
609 `<span>main.go</span>`,
610 `main.go <span class="muted">`,
611 "Copy",
612 } {
613 if !strings.Contains(blob, want) {
614 t.Fatalf("blob mist %q\n%s", want, blob)
615 }
616 }
617
618 res, err = client.Get(ts.URL + "/tim/legacy-cycles/-/blob/Cargo.toml")
619 if err != nil {
620 t.Fatal(err)
621 }
622 toml := read(t, res)
623 if !strings.Contains(toml, `class="hl-s">&#34;legacy-cycles&#34;`) || !strings.Contains(toml, `class="hl-c"># debug`) || !strings.Contains(toml, `class="hl-n">1`) {
624 t.Fatalf("toml-kleuring:\n%s", toml)
625 }
626
627 ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
628 if err != nil {
629 t.Fatal(err)
630 }
631 if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
632 t.Fatal(err)
633 }
634 adaToken, err := st.CreateToken(ctx, ada.ID, "ada")
635 if err != nil {
636 t.Fatal(err)
637 }
638 adaWork := t.TempDir()
639 adaRemote := strings.Replace(ts.URL, "http://", "http://ada:"+adaToken+"@", 1) + "/tim/legacy-cycles.git"
640 git(t, adaWork, "clone", adaRemote, ".")
641 git(t, adaWork, "config", "user.email", "ada@users.git.timfalken.com")
642 git(t, adaWork, "config", "user.name", "ada")
643 writeFile(t, filepath.Join(adaWork, "README.md"), readme+"\nextra\n")
644 git(t, adaWork, "add", "README.md")
645 git(t, adaWork, "commit", "-m", "ada op master")
646 if out, err := gitOut(adaWork, "push", "origin", "master"); err == nil {
647 t.Fatalf("ontwikkelaar pushte master:\n%s", out)
648 } else if !strings.Contains(out, "protected") {
649 t.Fatalf("weigering zonder beschermd: %v\n%s", err, out)
650 }
651 git(t, adaWork, "checkout", "-b", "feature")
652 git(t, adaWork, "push", "-u", "origin", "feature")
653}
654
655func writeFile(t *testing.T, path, body string) {
656 t.Helper()
657 if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
658 t.Fatal(err)
659 }
660 if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
661 t.Fatal(err)
662 }
663}
664
665func gitOut(dir string, args ...string) (string, error) {
666 cmd := exec.Command("git", args...)
667 cmd.Dir = dir
668 out, err := cmd.CombinedOutput()
669 return string(out), err
670}
671
672func csrfOf(t *testing.T, body string) string {
673 t.Helper()
674 const needle = `name="csrf" value="`
675 i := strings.Index(body, needle)
676 if i < 0 {
677 t.Fatalf("geen csrf in\n%s", body)
678 }
679 rest := body[i+len(needle):]
680 j := strings.Index(rest, `"`)
681 return rest[:j]
682}
683
684// assertCloneMenu faalt als de Code-dropdown de werkbalk verlaat.
685// De SSH-URL gebruikt ssh.public_host en ssh.public_port, niet de bindpoort.
686func assertCloneMenu(t *testing.T, body, where, sshURL, httpURL string) {
687 t.Helper()
688 tool := strings.Index(body, `<div class="toolbar">`)
689 clone := strings.Index(body, `data-clone`)
690 if tool < 0 || clone < tool {
691 t.Fatalf("%s: clone-knop hoort in de werkbalk", where)
692 }
693 end := strings.Index(body[clone:], `</details>`)
694 if end < 0 {
695 t.Fatalf("%s: clone-menu niet gesloten", where)
696 }
697 menu := body[clone : clone+end]
698 for _, want := range []string{
699 `popover="manual"`,
700 `class="menu-panel"`,
701 `>Code</summary>`,
702 `value="` + sshURL + `"`,
703 `data-copy="` + sshURL + `"`,
704 `value="` + httpURL + `"`,
705 `data-copy="` + httpURL + `"`,
706 } {
707 if !strings.Contains(menu, want) {
708 t.Fatalf("%s: clone-menu mist %q:\n%s", where, want, menu)
709 }
710 }
711 if strings.Count(menu, `data-copy="`) != 2 {
712 t.Fatalf("%s: clone-menu hoort twee kopieerknoppen te hebben:\n%s", where, menu)
713 }
714 if strings.Contains(menu, ":2222/") {
715 t.Fatalf("%s: clone-menu toont de bindpoort:\n%s", where, menu)
716 }
717}
718
719func between(s, a, b string) string {
720 i := strings.Index(s, a)
721 if i < 0 {
722 return ""
723 }
724 rest := s[i+len(a):]
725 j := strings.Index(rest, b)
726 if j < 0 {
727 return ""
728 }
729 return rest[:j]
730}
731
732func read(t *testing.T, res *http.Response) string {
733 t.Helper()
734 defer res.Body.Close()
735 b, err := io.ReadAll(res.Body)
736 if err != nil {
737 t.Fatal(err)
738 }
739 return string(b)
740}
741
742func git(t *testing.T, dir string, args ...string) {
743 t.Helper()
744 if len(args) > 0 && (args[0] == "push" || args[0] == "clone" || args[0] == "fetch" || args[0] == "pull") {
745 if why := gitHTTPGap(); why != "" {
746 t.Skip(why)
747 }
748 }
749 cmd := exec.Command("git", args...)
750 cmd.Dir = dir
751 out, err := cmd.CombinedOutput()
752 if err != nil {
753 if strings.Contains(string(out), "git-http-push") || strings.Contains(string(out), "return code 22") {
754 t.Skipf("git valt terug op dumb HTTP (smart HTTP ontbreekt): %s", out)
755 }
756 t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
757 }
758}
759
760// gitHTTPGap meldt een git zonder smart HTTP. Alpine levert git-http-backend
761// via git-daemon en git-remote-http via git. Zonder die helpers faalt
762// git push met "git-http-push failed, return code 22".
763func gitHTTPGap() string {
764 out, err := exec.Command("git", "--exec-path").Output()
765 if err != nil {
766 return "git --exec-path faalt: " + err.Error()
767 }
768 dir := strings.TrimSpace(string(out))
769 if _, err := os.Stat(filepath.Join(dir, "git-http-backend")); err != nil {
770 return "git-http-backend ontbreekt (pakket git-daemon); git push over HTTP valt terug op dumb HTTP"
771 }
772 if _, err := os.Stat(filepath.Join(dir, "git-remote-http")); err != nil {
773 return "git-remote-http ontbreekt; git kan niet via smart HTTP pushen"
774 }
775 return ""
776}
777
778func bytes32() []byte {
779 b := make([]byte, 32)
780 for i := range b {
781 b[i] = byte(i + 3)
782 }
783 return b
784}