//go:build integration // Integratietests: elke test start een echte BlueGit, maakt daar een // beheerder, token en Backupserver-Key aan, en test de backup server // ertegen. TestMain bouwt BlueGit uit dezelfde checkout (./cmd/bluegit), // tenzij BLUEGIT_BIN al naar een binary wijst. Lukt de bouw niet, dan // falen alle tests; ze slaan niet over, zodat de release-jobs nooit op een // overgeslagen test kunnen leunen. package integration import ( "bytes" "context" "encoding/json" "fmt" "io" "log/slog" "net" "net/http" "net/http/cookiejar" "net/url" "os" "os/exec" "path/filepath" "strings" "sync" "testing" "time" "gitlab.com/Timfa/bluegit/internal/backupserver/config" "gitlab.com/Timfa/bluegit/internal/backupserver/server" ) // FutureProtocol is het protocol van de test-build bluegit-future. const FutureProtocol = 99 // buildErr is de fout van TestMain bij het bouwen; elke test faalt dan. var buildErr error // TestMain bouwt bluegit en bluegit-future uit deze checkout, als // BLUEGIT_BIN niet gezet is. bluegit-future is dezelfde BlueGit met // protocol FutureProtocol, die alleen backup servers vanaf FutureProtocol // ondersteunt (de test "backup server te oud"). func TestMain(m *testing.M) { var tmp string if os.Getenv("BLUEGIT_BIN") == "" { var err error tmp, err = os.MkdirTemp("", "bluegit-it-") if err == nil { err = buildBlueGit(tmp) } buildErr = err } code := m.Run() if tmp != "" { _ = os.RemoveAll(tmp) } os.Exit(code) } func buildBlueGit(dir string) error { root, err := filepath.Abs(filepath.Join("..", "..", "..")) if err != nil { return err } bin := filepath.Join(dir, "bluegit") pkg := "gitlab.com/Timfa/bluegit/internal/backup" for _, b := range []struct{ out, ldflags string }{ {bin, ""}, {bin + "-future", fmt.Sprintf("-X %s.protocolVersion=%d -X %s.minBackupProtocol=%d", pkg, FutureProtocol, pkg, FutureProtocol)}, } { cmd := exec.Command("go", "build", "-trimpath", "-ldflags", b.ldflags, "-o", b.out, "./cmd/bluegit") cmd.Dir = root cmd.Env = append(os.Environ(), "CGO_ENABLED=0") if out, err := cmd.CombinedOutput(); err != nil { return fmt.Errorf("go build %s: %v\n%s", filepath.Base(b.out), err, out) } } return os.Setenv("BLUEGIT_BIN", bin) } func bluegitBin(t *testing.T) string { t.Helper() if buildErr != nil { t.Fatalf("BlueGit bouwen: %v", buildErr) } bin := os.Getenv("BLUEGIT_BIN") if bin == "" { t.Fatal("BLUEGIT_BIN ontbreekt") } if _, err := os.Stat(bin); err != nil { t.Fatalf("BLUEGIT_BIN: %v", err) } if _, err := exec.LookPath("git"); err != nil { t.Fatal("git ontbreekt") } return bin } func freePort(t *testing.T) int { t.Helper() ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } defer ln.Close() return ln.Addr().(*net.TCPAddr).Port } // BlueGit is één lokaal opgespinde BlueGit. type BlueGit struct { t *testing.T Bin string URL string Config string State string Storage string Token string cmd *exec.Cmd log *syncBuf // Server is het id van de laatst toegevoegde backup server in BlueGit. Server string } type syncBuf struct { mu sync.Mutex b bytes.Buffer } func (s *syncBuf) Write(p []byte) (int, error) { s.mu.Lock() defer s.mu.Unlock() return s.b.Write(p) } func (s *syncBuf) String() string { s.mu.Lock() defer s.mu.Unlock() return s.b.String() } func startBlueGit(t *testing.T) *BlueGit { t.Helper() return startBlueGitBin(t, bluegitBin(t)) } // bluegitFutureBin is een test-build van dezelfde BlueGit met een hoger // protocol (TestMain bouwt hem naast BLUEGIT_BIN met -ldflags -X): // protocol FutureProtocol, en hij ondersteunt alleen backup servers vanaf // FutureProtocol. func bluegitFutureBin(t *testing.T) string { t.Helper() bin := os.Getenv("BLUEGIT_FUTURE_BIN") if bin == "" { bin = filepath.Join(filepath.Dir(bluegitBin(t)), "bluegit-future") } if _, err := os.Stat(bin); err != nil { t.Fatalf("test-build met hoger protocol ontbreekt (BLUEGIT_FUTURE_BIN of bluegit-future naast BLUEGIT_BIN): %v", err) } return bin } func startBlueGitBin(t *testing.T, bin string) *BlueGit { t.Helper() dir := t.TempDir() port := freePort(t) g := &BlueGit{t: t, Bin: bin, URL: fmt.Sprintf("http://127.0.0.1:%d", port), State: filepath.Join(dir, "state"), Storage: filepath.Join(dir, "storage"), Config: filepath.Join(dir, "bluegit.yml"), log: &syncBuf{}} _ = os.MkdirAll(g.Storage, 0o750) cfg := fmt.Sprintf(`base_url: %s listen: 127.0.0.1:%d state_path: %s storage_path: %s auth: mode: dev dev_user: tim dev_auth_id: 1 user_agent: bluegit-backup-it git: binary: git default_branch: master ssh: enabled: false ci: enabled: false `, g.URL, port, g.State, g.Storage) if err := os.WriteFile(g.Config, []byte(cfg), 0o600); err != nil { t.Fatal(err) } g.cmd = exec.Command(bin, "serve", "--config", g.Config) g.cmd.Stdout, g.cmd.Stderr = g.log, g.log if err := g.cmd.Start(); err != nil { t.Fatal(err) } t.Cleanup(func() { _ = g.cmd.Process.Kill() _, _ = g.cmd.Process.Wait() if t.Failed() { t.Logf("BlueGit-log %s:\n%s", g.URL, tail(g.log.String(), 60)) } }) g.WaitUp(20 * time.Second) // Aanmelden maakt de eerste gebruiker (beheerder) aan. jar, _ := cookiejar.New(nil) hc := &http.Client{Jar: jar} res, err := hc.Get(g.URL + "/login") if err != nil { t.Fatal(err) } res.Body.Close() out, err := exec.Command(bin, "token", "create", "--config", g.Config, "--user", "tim", "--name", "it").CombinedOutput() if err != nil { t.Fatalf("token: %v %s", err, out) } g.Token = strings.TrimSpace(string(out)) return g } func tail(s string, n int) string { lines := strings.Split(s, "\n") if len(lines) > n { lines = lines[len(lines)-n:] } return strings.Join(lines, "\n") } // RestartAs herstart dezelfde BlueGit (zelfde gegevens) met een andere // dev-gebruiker. Zo is er een tweede gebruiker die geen beheerder is. func (g *BlueGit) RestartAs(user string, authID int) { g.t.Helper() _ = g.cmd.Process.Kill() _, _ = g.cmd.Process.Wait() b, err := os.ReadFile(g.Config) if err != nil { g.t.Fatal(err) } var out []string for _, l := range strings.Split(string(b), "\n") { switch { case strings.HasPrefix(l, " dev_user:"): l = " dev_user: " + user case strings.HasPrefix(l, " dev_auth_id:"): l = fmt.Sprintf(" dev_auth_id: %d", authID) } out = append(out, l) } if err := os.WriteFile(g.Config, []byte(strings.Join(out, "\n")), 0o600); err != nil { g.t.Fatal(err) } g.cmd = exec.Command(g.Bin, "serve", "--config", g.Config) g.cmd.Stdout, g.cmd.Stderr = g.log, g.log if err := g.cmd.Start(); err != nil { g.t.Fatal(err) } g.WaitUp(20 * time.Second) } // Page haalt een HTML-pagina op met een sessie (dev-login van de huidige // dev-gebruiker). func (g *BlueGit) Page(hc *http.Client, p string) string { g.t.Helper() res, err := hc.Get(g.URL + p) if err != nil { g.t.Fatal(err) } defer res.Body.Close() b, _ := io.ReadAll(res.Body) return string(b) } // WaitUp wacht op /healthz. func (g *BlueGit) WaitUp(d time.Duration) { g.t.Helper() deadline := time.Now().Add(d) for time.Now().Before(deadline) { res, err := http.Get(g.URL + "/healthz") if err == nil { res.Body.Close() if res.StatusCode == 200 { return } } time.Sleep(100 * time.Millisecond) } g.t.Fatalf("BlueGit %s kwam niet op:\n%s", g.URL, tail(g.log.String(), 40)) } // API doet een verzoek met het token. path begint na /api/v1. func (g *BlueGit) API(method, path string, in any) (int, []byte) { g.t.Helper() return g.APIWith(g.Token, method, path, in) } // APIWith gebruikt een ander token. func (g *BlueGit) APIWith(tok, method, path string, in any) (int, []byte) { g.t.Helper() var body io.Reader if in != nil { b, _ := json.Marshal(in) body = bytes.NewReader(b) } req, _ := http.NewRequest(method, g.URL+"/api/v1"+path, body) req.Header.Set("Authorization", "Bearer "+tok) if in != nil { req.Header.Set("Content-Type", "application/json") } res, err := http.DefaultClient.Do(req) if err != nil { g.t.Fatalf("%s %s: %v", method, path, err) } defer res.Body.Close() b, _ := io.ReadAll(res.Body) return res.StatusCode, b } // MustAPI faalt bij een fout. func (g *BlueGit) MustAPI(method, path string, in any) []byte { g.t.Helper() code, b := g.API(method, path, in) if code >= 300 { g.t.Fatalf("%s %s: %d %s", method, path, code, b) } return b } // AddServer voegt een backup server toe in BlueGit en geeft id en key. func (g *BlueGit) AddServer(name string) (string, string) { g.t.Helper() var out struct{ ID, Key string } _ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers", map[string]any{"name": name}), &out) if !strings.HasPrefix(out.Key, "bgbk_") || out.ID == "" { g.t.Fatalf("server %+v", out) } return out.ID, out.Key } // NewKey voegt een backup server toe en geeft zijn Backupserver-Key. func (g *BlueGit) NewKey() string { g.t.Helper() id, key := g.AddServer("test") g.Server = id return key } // RotateKey geeft de laatst toegevoegde backup server een nieuwe key. func (g *BlueGit) RotateKey() string { g.t.Helper() var out struct{ Key string } _ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers/"+g.Server+"/key", nil), &out) return out.Key } // Action voert een actie van backup server id uit via BlueGit. func (g *BlueGit) Action(id, name string, in any) (int, []byte) { g.t.Helper() return g.API("POST", "/admin/backup/servers/"+id+"/actions/"+name, in) } // Project maakt een project met één commit. func (g *BlueGit) Project(name, file, content string) { g.t.Helper() g.MustAPI("POST", "/projects", map[string]any{"name": name, "visibility": "private"}) g.Commit(strings.ToLower(name), file, content, "create") } // Commit schrijft één bestand op master. func (g *BlueGit) Commit(repo, file, content, action string) { g.t.Helper() g.MustAPI("POST", "/projects/tim/"+repo+"/repository/commits", map[string]any{ "branch": "master", "commit_message": "zet " + file, "actions": []map[string]string{{"action": action, "file_path": file, "content": content}}, }) } // File leest een bestand van master, of geeft de HTTP-code. func (g *BlueGit) File(repo, file string) (int, string) { g.t.Helper() req, _ := http.NewRequest("GET", g.URL+"/api/v1/projects/tim/"+repo+"/repository/files/"+file+"?ref=master", nil) req.Header.Set("Authorization", "Bearer "+g.Token) res, err := http.DefaultClient.Do(req) if err != nil { g.t.Fatal(err) } defer res.Body.Close() b, _ := io.ReadAll(res.Body) return res.StatusCode, string(b) } // Issue maakt een issue. func (g *BlueGit) Issue(repo, title string) { g.t.Helper() g.MustAPI("POST", "/repos/tim/"+repo+"/issues", map[string]any{"title": title}) } // IssueTitles geeft alle issuetitels. func (g *BlueGit) IssueTitles(repo string) []string { g.t.Helper() code, b := g.API("GET", "/repos/tim/"+repo+"/issues?state=all", nil) if code != 200 { g.t.Fatalf("issues: %d %s", code, b) } var list struct { Issues []struct{ Title string } `json:"issues"` } _ = json.Unmarshal(b, &list) var out []string for _, i := range list.Issues { out = append(out, i.Title) } return out } // ProjectCode is de HTTP-code van GET project. func (g *BlueGit) ProjectCode(repo string) int { g.t.Helper() code, _ := g.API("GET", "/projects/tim/"+repo, nil) return code } // BackupStatus is wat BlueGit over een backup server weet. type BackupStatus struct { InstanceID string `json:"instance_id"` HasKey bool `json:"-"` Name string `json:"name"` Connected bool `json:"connected"` ServerURL string `json:"server_url"` Archives []struct { Name string `json:"name"` Size int64 `json:"size"` } `json:"archives"` Config struct { Fields []struct { Key string `json:"key"` Value string `json:"value"` } `json:"fields"` } `json:"config"` RemoteError string `json:"remote_error"` // Compat: "" (onbekend), ok, bluegit_too_old of backup_too_old. Compat string `json:"compat"` Protocol struct { BlueGit int `json:"bluegit"` BlueGitMin int `json:"bluegit_min"` Backup int `json:"backup"` BackupMin int `json:"backup_min"` } `json:"protocol"` } // BackupStatus geeft de stand van de laatst toegevoegde backup server. func (g *BlueGit) BackupStatus() BackupStatus { return g.ServerStatus(g.Server) } // ServerStatus geeft de stand van backup server id ("" = de eerste). func (g *BlueGit) ServerStatus(id string) BackupStatus { g.t.Helper() var list struct { InstanceID string `json:"instance_id"` Servers []struct { ID string `json:"id"` } `json:"servers"` } _ = json.Unmarshal(g.MustAPI("GET", "/admin/backup", nil), &list) st := BackupStatus{InstanceID: list.InstanceID} if id == "" && len(list.Servers) > 0 { id = list.Servers[0].ID } found := false for _, s := range list.Servers { found = found || s.ID == id } if !found { return st } _ = json.Unmarshal(g.MustAPI("GET", "/admin/backup/servers/"+id, nil), &st) st.HasKey = true st.InstanceID = list.InstanceID return st } // Session geeft een HTTP-client met sessiecookie (dev-login). func (g *BlueGit) Session() *http.Client { g.t.Helper() jar, _ := cookiejar.New(nil) hc := &http.Client{Jar: jar} res, err := hc.Get(g.URL + "/login") if err != nil { g.t.Fatal(err) } res.Body.Close() return hc } // Git draait git met het token als wachtwoord. func (g *BlueGit) Git(dir string, args ...string) string { g.t.Helper() cmd := exec.Command("git", args...) cmd.Dir = dir 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") out, err := cmd.CombinedOutput() if err != nil { g.t.Fatalf("git %v: %v\n%s", args, err, out) } return string(out) } // RemoteURL is de clone-URL met token. func (g *BlueGit) RemoteURL(repo string) string { u, _ := url.Parse(g.URL) u.User = url.UserPassword("tim", g.Token) u.Path = "/tim/" + repo + ".git" return u.String() } // Backup is één backup server in dit proces. type Backup struct { t *testing.T Srv *server.Server URL string Dir string Cfg config.Config } func startBackup(t *testing.T, mod func(*config.Config)) *Backup { t.Helper() port := freePort(t) b := &Backup{t: t, URL: fmt.Sprintf("http://127.0.0.1:%d", port), Dir: t.TempDir()} cfg := config.Config{Listen: fmt.Sprintf("127.0.0.1:%d", port), PublicURL: b.URL, DataDir: b.Dir} // Snel genoeg voor tests; de standaardwaarden staan in config.Defaults. cfg.MinSyncInterval.Duration = 50 * time.Millisecond cfg.ArchiveInterval.Duration = time.Hour cfg.FullSyncInterval.Duration = time.Hour cfg.RateLimitKiB = -1 cfg.MinFreeMB = 1 if mod != nil { mod(&cfg) } cfg.Defaults() b.Cfg = cfg srv, err := server.New(cfg, slog.New(slog.NewTextHandler(&testWriter{t}, &slog.HandlerOptions{Level: slog.LevelWarn}))) if err != nil { t.Fatal(err) } b.Srv = srv ln, err := net.Listen("tcp", cfg.Listen) if err != nil { t.Fatal(err) } hs := &http.Server{Handler: srv.Handler()} ctx, cancel := context.WithCancel(context.Background()) go func() { _ = hs.Serve(ln) }() srv.Run(ctx) t.Cleanup(func() { cancel() _ = hs.Close() }) return b } type testWriter struct{ t *testing.T } func (w *testWriter) Write(p []byte) (int, error) { w.t.Log(strings.TrimRight(string(p), "\n")) return len(p), nil } // Admin doet een verzoek op de lokale beheer-API. func (b *Backup) Admin(method, path string, in any) (int, []byte) { b.t.Helper() var body io.Reader if in != nil { raw, _ := json.Marshal(in) body = bytes.NewReader(raw) } req, _ := http.NewRequest(method, b.URL+"/api/v1/admin"+path, body) req.Header.Set("Authorization", "Bearer "+b.Srv.AdminToken()) res, err := http.DefaultClient.Do(req) if err != nil { b.t.Fatal(err) } defer res.Body.Close() raw, _ := io.ReadAll(res.Body) return res.StatusCode, raw } // Connect koppelt aan g zonder conflictkeuze; faalt bij een fout. func (b *Backup) Connect(g *BlueGit, key string) { b.t.Helper() code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key}) if code != 200 { b.t.Fatalf("connect: %d %s", code, raw) } } // Sync synchroniseert nu. func (b *Backup) Sync() { b.t.Helper() code, raw := b.Admin("POST", "/sync", nil) if code != 200 { b.t.Fatalf("sync: %d %s", code, raw) } } // Archive maakt nu een archief en geeft de naam. func (b *Backup) Archive() string { b.t.Helper() code, raw := b.Admin("POST", "/archive", nil) if code != 201 { b.t.Fatalf("archive: %d %s", code, raw) } var a struct{ Name string } _ = json.Unmarshal(raw, &a) return a.Name } // Mirror is het pad van een logisch bestand in de kopie. func (b *Backup) Mirror(logical string) string { return filepath.Join(b.Dir, "mirror", filepath.FromSlash(logical)) } // Archives geeft de archiefnamen, nieuwste eerst. func (b *Backup) Archives() []string { b.t.Helper() _, raw := b.Admin("GET", "/archives", nil) var out struct { Archives []struct{ Name string } } _ = json.Unmarshal(raw, &out) var names []string for _, a := range out.Archives { names = append(names, a.Name) } return names } // Status leest de status. func (b *Backup) Status() server.Status { b.t.Helper() _, raw := b.Admin("GET", "/status", nil) var st server.Status _ = json.Unmarshal(raw, &st) return st } // Eventually herhaalt f tot hij true geeft. func Eventually(t *testing.T, d time.Duration, what string, f func() bool) { t.Helper() deadline := time.Now().Add(d) for time.Now().Before(deadline) { if f() { return } time.Sleep(50 * time.Millisecond) } t.Fatalf("na %v nog steeds niet: %s", d, what) } // gitLog geeft de onderwerpen van een bare repo in de kopie. func gitLog(t *testing.T, gitDir string) string { t.Helper() out, err := exec.Command("git", "--git-dir", gitDir, "log", "--format=%s", "master").CombinedOutput() if err != nil { return "FOUT: " + string(out) } return string(out) }