BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / integration / harness_test.go

harness_test.go

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