BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / integration / harness_test.go

harness_test.go

harness_test.go 18.0 KiB Download Raw
1//go:build integration
2
3// Integratietests: elke test start een echte BlueGit, maakt daar een
4// beheerder, token en Backupserver-Key aan, en test de backup server
5// ertegen. TestMain bouwt BlueGit uit dezelfde checkout (./cmd/bluegit),
6// tenzij BLUEGIT_BIN al naar een binary wijst. Lukt de bouw niet, dan
7// falen alle tests; ze slaan niet over, zodat de release-jobs nooit op een
8// overgeslagen test kunnen leunen.
9package integration
10
11import (
12 "bytes"
13 "context"
14 "encoding/json"
15 "fmt"
16 "io"
17 "log/slog"
18 "net"
19 "net/http"
20 "net/http/cookiejar"
21 "net/url"
22 "os"
23 "os/exec"
24 "path/filepath"
25 "strings"
26 "sync"
27 "testing"
28 "time"
29
30 "gitlab.com/Timfa/bluegit/internal/backupserver/config"
31 "gitlab.com/Timfa/bluegit/internal/backupserver/server"
32 bgconfig "gitlab.com/Timfa/bluegit/internal/config"
33)
34
35// FutureProtocol is het protocol van de test-build bluegit-future.
36const FutureProtocol = 99
37
38// buildErr is de fout van TestMain bij het bouwen; elke test faalt dan.
39var buildErr error
40
41// TestMain bouwt bluegit en bluegit-future uit deze checkout, als
42// BLUEGIT_BIN niet gezet is. bluegit-future is dezelfde BlueGit met
43// protocol FutureProtocol, die alleen backup servers vanaf FutureProtocol
44// ondersteunt (de test "backup server te oud").
45func TestMain(m *testing.M) {
46 var tmp string
47 if os.Getenv("BLUEGIT_BIN") == "" {
48 var err error
49 tmp, err = os.MkdirTemp("", "bluegit-it-")
50 if err == nil {
51 err = buildBlueGit(tmp)
52 }
53 buildErr = err
54 }
55 code := m.Run()
56 if tmp != "" {
57 _ = os.RemoveAll(tmp)
58 }
59 os.Exit(code)
60}
61
62func buildBlueGit(dir string) error {
63 root, err := filepath.Abs(filepath.Join("..", "..", ".."))
64 if err != nil {
65 return err
66 }
67 bin := filepath.Join(dir, "bluegit")
68 pkg := "gitlab.com/Timfa/bluegit/internal/backup"
69 for _, b := range []struct{ out, ldflags string }{
70 {bin, ""},
71 {bin + "-future", fmt.Sprintf("-X %s.protocolVersion=%d -X %s.minBackupProtocol=%d", pkg, FutureProtocol, pkg, FutureProtocol)},
72 } {
73 cmd := exec.Command("go", "build", "-trimpath", "-ldflags", b.ldflags, "-o", b.out, "./cmd/bluegit")
74 cmd.Dir = root
75 cmd.Env = append(os.Environ(), "CGO_ENABLED=0")
76 if out, err := cmd.CombinedOutput(); err != nil {
77 return fmt.Errorf("go build %s: %v\n%s", filepath.Base(b.out), err, out)
78 }
79 }
80 return os.Setenv("BLUEGIT_BIN", bin)
81}
82
83func bluegitBin(t *testing.T) string {
84 t.Helper()
85 if buildErr != nil {
86 t.Fatalf("BlueGit bouwen: %v", buildErr)
87 }
88 bin := os.Getenv("BLUEGIT_BIN")
89 if bin == "" {
90 t.Fatal("BLUEGIT_BIN ontbreekt")
91 }
92 if _, err := os.Stat(bin); err != nil {
93 t.Fatalf("BLUEGIT_BIN: %v", err)
94 }
95 if _, err := exec.LookPath("git"); err != nil {
96 t.Fatal("git ontbreekt")
97 }
98 return bin
99}
100
101func freePort(t *testing.T) int {
102 t.Helper()
103 ln, err := net.Listen("tcp", "127.0.0.1:0")
104 if err != nil {
105 t.Fatal(err)
106 }
107 defer ln.Close()
108 return ln.Addr().(*net.TCPAddr).Port
109}
110
111// BlueGit is één lokaal opgespinde BlueGit.
112type BlueGit struct {
113 t *testing.T
114 Bin string
115 URL string
116 Config string
117 State string
118 Storage string
119 Token string
120 cmd *exec.Cmd
121 log *syncBuf
122 // Server is het id van de laatst toegevoegde backup server in BlueGit.
123 Server string
124}
125
126type syncBuf struct {
127 mu sync.Mutex
128 b bytes.Buffer
129}
130
131func (s *syncBuf) Write(p []byte) (int, error) {
132 s.mu.Lock()
133 defer s.mu.Unlock()
134 return s.b.Write(p)
135}
136
137func (s *syncBuf) String() string {
138 s.mu.Lock()
139 defer s.mu.Unlock()
140 return s.b.String()
141}
142
143func startBlueGit(t *testing.T) *BlueGit {
144 t.Helper()
145 return startBlueGitBin(t, bluegitBin(t))
146}
147
148// bluegitFutureBin is een test-build van dezelfde BlueGit met een hoger
149// protocol (TestMain bouwt hem naast BLUEGIT_BIN met -ldflags -X):
150// protocol FutureProtocol, en hij ondersteunt alleen backup servers vanaf
151// FutureProtocol.
152func bluegitFutureBin(t *testing.T) string {
153 t.Helper()
154 bin := os.Getenv("BLUEGIT_FUTURE_BIN")
155 if bin == "" {
156 bin = filepath.Join(filepath.Dir(bluegitBin(t)), "bluegit-future")
157 }
158 if _, err := os.Stat(bin); err != nil {
159 t.Fatalf("test-build met hoger protocol ontbreekt (BLUEGIT_FUTURE_BIN of bluegit-future naast BLUEGIT_BIN): %v", err)
160 }
161 return bin
162}
163
164func startBlueGitBin(t *testing.T, bin string) *BlueGit {
165 t.Helper()
166 dir := t.TempDir()
167 port := freePort(t)
168 g := &BlueGit{t: t, Bin: bin, URL: fmt.Sprintf("http://127.0.0.1:%d", port),
169 State: filepath.Join(dir, "state"), Storage: filepath.Join(dir, "storage"), Config: filepath.Join(dir, "bluegit.yml"), log: &syncBuf{}}
170 _ = os.MkdirAll(g.Storage, 0o750)
171 cfg := fmt.Sprintf(`base_url: %s
172listen: 127.0.0.1:%d
173state_path: %s
174storage_path: %s
175auth:
176 mode: dev
177 dev_user: tim
178 dev_auth_id: 1
179 user_agent: bluegit-backup-it
180git:
181 binary: git
182 default_branch: master
183ssh:
184 enabled: false
185ci:
186 enabled: false
187`, g.URL, port, g.State, g.Storage)
188 if err := os.WriteFile(g.Config, []byte(cfg), 0o600); err != nil {
189 t.Fatal(err)
190 }
191 g.cmd = exec.Command(bin, "serve", "--config", g.Config)
192 g.cmd.Stdout, g.cmd.Stderr = g.log, g.log
193 if err := g.cmd.Start(); err != nil {
194 t.Fatal(err)
195 }
196 t.Cleanup(func() {
197 _ = g.cmd.Process.Kill()
198 _, _ = g.cmd.Process.Wait()
199 if t.Failed() {
200 t.Logf("BlueGit-log %s:\n%s", g.URL, tail(g.log.String(), 60))
201 }
202 })
203 g.WaitUp(20 * time.Second)
204 // Aanmelden maakt de eerste gebruiker (beheerder) aan.
205 jar, _ := cookiejar.New(nil)
206 hc := &http.Client{Jar: jar}
207 res, err := hc.Get(g.URL + "/login")
208 if err != nil {
209 t.Fatal(err)
210 }
211 res.Body.Close()
212 out, err := exec.Command(bin, "token", "create", "--config", g.Config, "--user", "tim", "--name", "it").CombinedOutput()
213 if err != nil {
214 t.Fatalf("token: %v %s", err, out)
215 }
216 g.Token = strings.TrimSpace(string(out))
217 return g
218}
219
220func tail(s string, n int) string {
221 lines := strings.Split(s, "\n")
222 if len(lines) > n {
223 lines = lines[len(lines)-n:]
224 }
225 return strings.Join(lines, "\n")
226}
227
228// RestartAs herstart dezelfde BlueGit (zelfde gegevens) met een andere
229// dev-gebruiker. Zo is er een tweede gebruiker die geen beheerder is.
230func (g *BlueGit) RestartAs(user string, authID int) {
231 g.t.Helper()
232 _ = g.cmd.Process.Kill()
233 _, _ = g.cmd.Process.Wait()
234 b, err := os.ReadFile(g.Config)
235 if err != nil {
236 g.t.Fatal(err)
237 }
238 var out []string
239 for _, l := range strings.Split(string(b), "\n") {
240 switch {
241 case strings.HasPrefix(l, " dev_user:"):
242 l = " dev_user: " + user
243 case strings.HasPrefix(l, " dev_auth_id:"):
244 l = fmt.Sprintf(" dev_auth_id: %d", authID)
245 }
246 out = append(out, l)
247 }
248 if err := os.WriteFile(g.Config, []byte(strings.Join(out, "\n")), 0o600); err != nil {
249 g.t.Fatal(err)
250 }
251 // settings.yml wint na de eenmalige import; die moet mee.
252 if st, err := bgconfig.LoadSettings(g.State); err == nil && st != nil {
253 if st.Auth == nil {
254 st.Auth = &bgconfig.PersistedAuth{}
255 }
256 u := user
257 st.Auth.DevUser = &u
258 id := int64(authID)
259 st.Auth.DevAuthID = &id
260 if err := bgconfig.SaveSettings(g.State, *st); err != nil {
261 g.t.Fatal(err)
262 }
263 }
264 g.cmd = exec.Command(g.Bin, "serve", "--config", g.Config)
265 g.cmd.Stdout, g.cmd.Stderr = g.log, g.log
266 if err := g.cmd.Start(); err != nil {
267 g.t.Fatal(err)
268 }
269 g.WaitUp(20 * time.Second)
270}
271
272// Page haalt een HTML-pagina op met een sessie (dev-login van de huidige
273// dev-gebruiker).
274func (g *BlueGit) Page(hc *http.Client, p string) string {
275 g.t.Helper()
276 res, err := hc.Get(g.URL + p)
277 if err != nil {
278 g.t.Fatal(err)
279 }
280 defer res.Body.Close()
281 b, _ := io.ReadAll(res.Body)
282 return string(b)
283}
284
285// WaitUp wacht op /healthz.
286func (g *BlueGit) WaitUp(d time.Duration) {
287 g.t.Helper()
288 deadline := time.Now().Add(d)
289 for time.Now().Before(deadline) {
290 res, err := http.Get(g.URL + "/healthz")
291 if err == nil {
292 res.Body.Close()
293 if res.StatusCode == 200 {
294 return
295 }
296 }
297 time.Sleep(100 * time.Millisecond)
298 }
299 g.t.Fatalf("BlueGit %s kwam niet op:\n%s", g.URL, tail(g.log.String(), 40))
300}
301
302// API doet een verzoek met het token. path begint na /api/v1.
303func (g *BlueGit) API(method, path string, in any) (int, []byte) {
304 g.t.Helper()
305 return g.APIWith(g.Token, method, path, in)
306}
307
308// APIWith gebruikt een ander token.
309func (g *BlueGit) APIWith(tok, method, path string, in any) (int, []byte) {
310 g.t.Helper()
311 var body io.Reader
312 if in != nil {
313 b, _ := json.Marshal(in)
314 body = bytes.NewReader(b)
315 }
316 req, _ := http.NewRequest(method, g.URL+"/api/v1"+path, body)
317 req.Header.Set("Authorization", "Bearer "+tok)
318 if in != nil {
319 req.Header.Set("Content-Type", "application/json")
320 }
321 res, err := http.DefaultClient.Do(req)
322 if err != nil {
323 g.t.Fatalf("%s %s: %v", method, path, err)
324 }
325 defer res.Body.Close()
326 b, _ := io.ReadAll(res.Body)
327 return res.StatusCode, b
328}
329
330// MustAPI faalt bij een fout.
331func (g *BlueGit) MustAPI(method, path string, in any) []byte {
332 g.t.Helper()
333 code, b := g.API(method, path, in)
334 if code >= 300 {
335 g.t.Fatalf("%s %s: %d %s", method, path, code, b)
336 }
337 return b
338}
339
340// AddServer voegt een backup server toe in BlueGit en geeft id en key.
341func (g *BlueGit) AddServer(name string) (string, string) {
342 g.t.Helper()
343 var out struct{ ID, Key string }
344 _ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers", map[string]any{"name": name}), &out)
345 if !strings.HasPrefix(out.Key, "bgbk_") || out.ID == "" {
346 g.t.Fatalf("server %+v", out)
347 }
348 return out.ID, out.Key
349}
350
351// NewKey voegt een backup server toe en geeft zijn Backupserver-Key.
352func (g *BlueGit) NewKey() string {
353 g.t.Helper()
354 id, key := g.AddServer("test")
355 g.Server = id
356 return key
357}
358
359// RotateKey geeft de laatst toegevoegde backup server een nieuwe key.
360func (g *BlueGit) RotateKey() string {
361 g.t.Helper()
362 var out struct{ Key string }
363 _ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers/"+g.Server+"/key", nil), &out)
364 return out.Key
365}
366
367// Action voert een actie van backup server id uit via BlueGit.
368func (g *BlueGit) Action(id, name string, in any) (int, []byte) {
369 g.t.Helper()
370 return g.API("POST", "/admin/backup/servers/"+id+"/actions/"+name, in)
371}
372
373// Project maakt een project met één commit.
374func (g *BlueGit) Project(name, file, content string) {
375 g.t.Helper()
376 g.MustAPI("POST", "/projects", map[string]any{"name": name, "visibility": "private"})
377 g.Commit(strings.ToLower(name), file, content, "create")
378}
379
380// Commit schrijft één bestand op master.
381func (g *BlueGit) Commit(repo, file, content, action string) {
382 g.t.Helper()
383 g.MustAPI("POST", "/projects/tim/"+repo+"/repository/commits", map[string]any{
384 "branch": "master", "commit_message": "zet " + file,
385 "actions": []map[string]string{{"action": action, "file_path": file, "content": content}},
386 })
387}
388
389// File leest een bestand van master, of geeft de HTTP-code.
390func (g *BlueGit) File(repo, file string) (int, string) {
391 g.t.Helper()
392 req, _ := http.NewRequest("GET", g.URL+"/api/v1/projects/tim/"+repo+"/repository/files/"+file+"?ref=master", nil)
393 req.Header.Set("Authorization", "Bearer "+g.Token)
394 res, err := http.DefaultClient.Do(req)
395 if err != nil {
396 g.t.Fatal(err)
397 }
398 defer res.Body.Close()
399 b, _ := io.ReadAll(res.Body)
400 return res.StatusCode, string(b)
401}
402
403// Issue maakt een issue.
404func (g *BlueGit) Issue(repo, title string) {
405 g.t.Helper()
406 g.MustAPI("POST", "/repos/tim/"+repo+"/issues", map[string]any{"title": title})
407}
408
409// IssueTitles geeft alle issuetitels.
410func (g *BlueGit) IssueTitles(repo string) []string {
411 g.t.Helper()
412 code, b := g.API("GET", "/repos/tim/"+repo+"/issues?state=all", nil)
413 if code != 200 {
414 g.t.Fatalf("issues: %d %s", code, b)
415 }
416 var list struct {
417 Issues []struct{ Title string } `json:"issues"`
418 }
419 _ = json.Unmarshal(b, &list)
420 var out []string
421 for _, i := range list.Issues {
422 out = append(out, i.Title)
423 }
424 return out
425}
426
427// ProjectCode is de HTTP-code van GET project.
428func (g *BlueGit) ProjectCode(repo string) int {
429 g.t.Helper()
430 code, _ := g.API("GET", "/projects/tim/"+repo, nil)
431 return code
432}
433
434// BackupStatus is wat BlueGit over een backup server weet.
435type BackupStatus struct {
436 InstanceID string `json:"instance_id"`
437 HasKey bool `json:"-"`
438 Name string `json:"name"`
439 Connected bool `json:"connected"`
440 ServerURL string `json:"server_url"`
441 Archives []struct {
442 Name string `json:"name"`
443 Size int64 `json:"size"`
444 } `json:"archives"`
445 Config struct {
446 Fields []struct {
447 Key string `json:"key"`
448 Value string `json:"value"`
449 } `json:"fields"`
450 } `json:"config"`
451 RemoteError string `json:"remote_error"`
452 // Compat: "" (onbekend), ok, bluegit_too_old of backup_too_old.
453 Compat string `json:"compat"`
454 Protocol struct {
455 BlueGit int `json:"bluegit"`
456 BlueGitMin int `json:"bluegit_min"`
457 Backup int `json:"backup"`
458 BackupMin int `json:"backup_min"`
459 } `json:"protocol"`
460}
461
462// BackupStatus geeft de stand van de laatst toegevoegde backup server.
463func (g *BlueGit) BackupStatus() BackupStatus { return g.ServerStatus(g.Server) }
464
465// ServerStatus geeft de stand van backup server id ("" = de eerste).
466func (g *BlueGit) ServerStatus(id string) BackupStatus {
467 g.t.Helper()
468 var list struct {
469 InstanceID string `json:"instance_id"`
470 Servers []struct {
471 ID string `json:"id"`
472 } `json:"servers"`
473 }
474 _ = json.Unmarshal(g.MustAPI("GET", "/admin/backup", nil), &list)
475 st := BackupStatus{InstanceID: list.InstanceID}
476 if id == "" && len(list.Servers) > 0 {
477 id = list.Servers[0].ID
478 }
479 found := false
480 for _, s := range list.Servers {
481 found = found || s.ID == id
482 }
483 if !found {
484 return st
485 }
486 _ = json.Unmarshal(g.MustAPI("GET", "/admin/backup/servers/"+id, nil), &st)
487 st.HasKey = true
488 st.InstanceID = list.InstanceID
489 return st
490}
491
492// Session geeft een HTTP-client met sessiecookie (dev-login).
493func (g *BlueGit) Session() *http.Client {
494 g.t.Helper()
495 jar, _ := cookiejar.New(nil)
496 hc := &http.Client{Jar: jar}
497 res, err := hc.Get(g.URL + "/login")
498 if err != nil {
499 g.t.Fatal(err)
500 }
501 res.Body.Close()
502 return hc
503}
504
505// Git draait git met het token als wachtwoord.
506func (g *BlueGit) Git(dir string, args ...string) string {
507 g.t.Helper()
508 cmd := exec.Command("git", args...)
509 cmd.Dir = dir
510 cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_AUTHOR_NAME=it", "GIT_AUTHOR_EMAIL=it@example.invalid", "GIT_COMMITTER_NAME=it", "GIT_COMMITTER_EMAIL=it@example.invalid")
511 out, err := cmd.CombinedOutput()
512 if err != nil {
513 g.t.Fatalf("git %v: %v\n%s", args, err, out)
514 }
515 return string(out)
516}
517
518// RemoteURL is de clone-URL met token.
519func (g *BlueGit) RemoteURL(repo string) string {
520 u, _ := url.Parse(g.URL)
521 u.User = url.UserPassword("tim", g.Token)
522 u.Path = "/tim/" + repo + ".git"
523 return u.String()
524}
525
526// Backup is één backup server in dit proces.
527type Backup struct {
528 t *testing.T
529 Srv *server.Server
530 URL string
531 Dir string
532 Cfg config.Config
533}
534
535func startBackup(t *testing.T, mod func(*config.Config)) *Backup {
536 t.Helper()
537 port := freePort(t)
538 b := &Backup{t: t, URL: fmt.Sprintf("http://127.0.0.1:%d", port), Dir: t.TempDir()}
539 cfg := config.Config{Listen: fmt.Sprintf("127.0.0.1:%d", port), PublicURL: b.URL, DataDir: b.Dir}
540 // Snel genoeg voor tests; de standaardwaarden staan in config.Defaults.
541 cfg.MinSyncInterval.Duration = 50 * time.Millisecond
542 cfg.ArchiveInterval.Duration = time.Hour
543 cfg.FullSyncInterval.Duration = time.Hour
544 cfg.RateLimitKiB = -1
545 cfg.MinFreeMB = 1
546 if mod != nil {
547 mod(&cfg)
548 }
549 cfg.Defaults()
550 b.Cfg = cfg
551 srv, err := server.New(cfg, slog.New(slog.NewTextHandler(&testWriter{t}, &slog.HandlerOptions{Level: slog.LevelWarn})))
552 if err != nil {
553 t.Fatal(err)
554 }
555 b.Srv = srv
556 ln, err := net.Listen("tcp", cfg.Listen)
557 if err != nil {
558 t.Fatal(err)
559 }
560 hs := &http.Server{Handler: srv.Handler()}
561 ctx, cancel := context.WithCancel(context.Background())
562 go func() { _ = hs.Serve(ln) }()
563 srv.Run(ctx)
564 t.Cleanup(func() {
565 cancel()
566 _ = hs.Close()
567 })
568 return b
569}
570
571type testWriter struct{ t *testing.T }
572
573func (w *testWriter) Write(p []byte) (int, error) {
574 w.t.Log(strings.TrimRight(string(p), "\n"))
575 return len(p), nil
576}
577
578// Admin doet een verzoek op de lokale beheer-API.
579func (b *Backup) Admin(method, path string, in any) (int, []byte) {
580 b.t.Helper()
581 var body io.Reader
582 if in != nil {
583 raw, _ := json.Marshal(in)
584 body = bytes.NewReader(raw)
585 }
586 req, _ := http.NewRequest(method, b.URL+"/api/v1/admin"+path, body)
587 req.Header.Set("Authorization", "Bearer "+b.Srv.AdminToken())
588 res, err := http.DefaultClient.Do(req)
589 if err != nil {
590 b.t.Fatal(err)
591 }
592 defer res.Body.Close()
593 raw, _ := io.ReadAll(res.Body)
594 return res.StatusCode, raw
595}
596
597// Connect koppelt aan g zonder conflictkeuze; faalt bij een fout.
598func (b *Backup) Connect(g *BlueGit, key string) {
599 b.t.Helper()
600 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})
601 if code != 200 {
602 b.t.Fatalf("connect: %d %s", code, raw)
603 }
604}
605
606// Sync synchroniseert nu.
607func (b *Backup) Sync() {
608 b.t.Helper()
609 code, raw := b.Admin("POST", "/sync", nil)
610 if code != 200 {
611 b.t.Fatalf("sync: %d %s", code, raw)
612 }
613}
614
615// Archive maakt nu een archief en geeft de naam.
616func (b *Backup) Archive() string {
617 b.t.Helper()
618 code, raw := b.Admin("POST", "/archive", nil)
619 if code != 201 {
620 b.t.Fatalf("archive: %d %s", code, raw)
621 }
622 var a struct{ Name string }
623 _ = json.Unmarshal(raw, &a)
624 return a.Name
625}
626
627// Mirror is het pad van een logisch bestand in de kopie.
628func (b *Backup) Mirror(logical string) string {
629 return filepath.Join(b.Dir, "mirror", filepath.FromSlash(logical))
630}
631
632// Archives geeft de archiefnamen, nieuwste eerst.
633func (b *Backup) Archives() []string {
634 b.t.Helper()
635 _, raw := b.Admin("GET", "/archives", nil)
636 var out struct {
637 Archives []struct{ Name string }
638 }
639 _ = json.Unmarshal(raw, &out)
640 var names []string
641 for _, a := range out.Archives {
642 names = append(names, a.Name)
643 }
644 return names
645}
646
647// Status leest de status.
648func (b *Backup) Status() server.Status {
649 b.t.Helper()
650 _, raw := b.Admin("GET", "/status", nil)
651 var st server.Status
652 _ = json.Unmarshal(raw, &st)
653 return st
654}
655
656// Eventually herhaalt f tot hij true geeft.
657func Eventually(t *testing.T, d time.Duration, what string, f func() bool) {
658 t.Helper()
659 deadline := time.Now().Add(d)
660 for time.Now().Before(deadline) {
661 if f() {
662 return
663 }
664 time.Sleep(50 * time.Millisecond)
665 }
666 t.Fatalf("na %v nog steeds niet: %s", d, what)
667}
668
669// gitLog geeft de onderwerpen van een bare repo in de kopie.
670func gitLog(t *testing.T, gitDir string) string {
671 t.Helper()
672 out, err := exec.Command("git", "--git-dir", gitDir, "log", "--format=%s", "master").CombinedOutput()
673 if err != nil {
674 return "FOUT: " + string(out)
675 }
676 return string(out)
677}