BlueGit

timfa bluegit

Files

bluegit / internal / server / server_test.go

server_test.go

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