BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / integration / harness_test.go

harness_test.go

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