BlueGit

timfa bluegit

Files

bluegit / internal / server / server_test.go

server_test.go

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