//go:build integration package integration import ( "crypto/rand" "encoding/json" "io" "net/http" "net/url" "os" "os/exec" "path/filepath" "strings" "testing" "time" "gitlab.com/Timfa/bluegit/internal/backupserver/config" "gitlab.com/Timfa/bluegit/internal/backupserver/server" ) // Feature: Backupserver-Key in BlueGit genereren en de backup server koppelen. func TestKeyGenerationAndConnect(t *testing.T) { g := startBlueGit(t) b := startBackup(t, nil) // Zonder key niets; een verkeerde key wordt geweigerd. if st := g.BackupStatus(); st.HasKey || st.Connected { t.Fatalf("vers BlueGit heeft al een key: %+v", st) } code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: "bgbk_verkeerd"}) if code != 401 { t.Fatalf("verkeerde key: %d %s", code, raw) } key := g.NewKey() b.Connect(g, key) st := g.BackupStatus() if !st.HasKey || !st.Connected || st.ServerURL != b.URL || st.RemoteError != "" { t.Fatalf("BlueGit ziet de koppeling niet: %+v", st) } bs := b.Status() if !bs.Connected || bs.InstanceID != st.InstanceID || bs.BlueGitURL != g.URL { t.Fatalf("backup status: %+v", bs) } // De key staat niet leesbaar in BlueGit. raw2, _ := os.ReadFile(filepath.Join(g.State, "backup.json")) if strings.Contains(string(raw2), key) { t.Fatal("BlueGit bewaart de key leesbaar") } // Een nieuwe key maakt de oude ongeldig: de backup server kan niet meer syncen. g.RotateKey() code, raw = b.Admin("POST", "/sync", nil) if code == 200 { t.Fatalf("sync met ingetrokken key gelukt: %s", raw) } } // Feature: alle gegevens en configuratie ophalen. func TestFullSyncCopiesAllData(t *testing.T) { g := startBlueGit(t) g.Project("Alpha", "README.md", "hallo alpha") g.Issue("alpha", "eerste issue") b := startBackup(t, nil) b.Connect(g, g.NewKey()) b.Sync() for _, p := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/alpha.git/HEAD"} { if _, err := os.Stat(b.Mirror(p)); err != nil { t.Fatalf("kopie mist %s: %v", p, err) } } if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); !strings.Contains(log, "zet README.md") { t.Fatalf("kopie van de repo is niet bruikbaar: %s", log) } db, _ := os.ReadFile(b.Mirror("state/bluegit.db")) if !strings.HasPrefix(string(db), "SQLite format 3") || !strings.Contains(string(db), "eerste issue") { t.Fatal("databasekopie mist het issue") } key1, _ := os.ReadFile(filepath.Join(g.State, "secret.key")) key2, _ := os.ReadFile(b.Mirror("state/secret.key")) if string(key1) != string(key2) { t.Fatal("secret.key wijkt af") } // Installatiegebonden bestanden gaan niet mee. for _, p := range []string{"state/backup.json", "state/instance_id", "state/storage_path"} { if _, err := os.Stat(b.Mirror(p)); err == nil { t.Fatalf("%s hoort niet in de kopie", p) } } // Een tweede sync zonder wijzigingen haalt (bijna) niets op. code, raw := b.Admin("POST", "/sync", nil) var st struct{ Downloaded int } _ = json.Unmarshal(raw, &st) if code != 200 || st.Downloaded > 1 { t.Fatalf("tweede sync haalde %d bestanden op: %s", st.Downloaded, raw) } } // Feature: BlueGit meldt elke wijziging; de backup server haalt hem op. func TestNotificationTriggersSync(t *testing.T) { g := startBlueGit(t) g.Project("Alpha", "README.md", "v1") b := startBackup(t, nil) // full sync pas na een uur: alleen meldingen tellen b.Connect(g, g.NewKey()) Eventually(t, 15*time.Second, "eerste sync na koppelen", func() bool { return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet README.md") }) before := b.Status().Notifies // Wijziging via de API. g.Commit("alpha", "CHANGELOG.md", "nieuw", "create") Eventually(t, 15*time.Second, "commit via API in de kopie", func() bool { return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet CHANGELOG.md") }) // Wijziging via git push over HTTP. work := t.TempDir() g.Git(work, "clone", "-q", g.RemoteURL("alpha"), "w") repo := filepath.Join(work, "w") _ = os.WriteFile(filepath.Join(repo, "pushed.txt"), []byte("via git"), 0o644) g.Git(repo, "add", ".") g.Git(repo, "commit", "-qm", "gepusht met git") g.Git(repo, "push", "-q", "origin", "master") Eventually(t, 15*time.Second, "git push in de kopie", func() bool { return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "gepusht met git") }) // Een issue staat alleen in de database. g.Issue("alpha", "issue-na-melding") Eventually(t, 15*time.Second, "issue in de databasekopie", func() bool { db, _ := os.ReadFile(b.Mirror("state/bluegit.db")) return strings.Contains(string(db), "issue-na-melding") }) if b.Status().Notifies <= before { t.Fatal("geen meldingen geteld") } } // Feature: downloaden op lage snelheid. func TestDownloadIsThrottled(t *testing.T) { g := startBlueGit(t) g.MustAPI("POST", "/projects", map[string]any{"name": "Big", "visibility": "private"}) work := t.TempDir() g.Git(work, "init", "-q", "-b", "master", "w") repo := filepath.Join(work, "w") blob := make([]byte, 1536<<10) // 1,5 MiB, niet te comprimeren _, _ = rand.Read(blob) _ = os.WriteFile(filepath.Join(repo, "random.bin"), blob, 0o644) g.Git(repo, "add", ".") g.Git(repo, "commit", "-qm", "groot bestand") g.Git(repo, "push", "-q", g.RemoteURL("big"), "master") b := startBackup(t, func(c *config.Config) { c.RateLimitKiB = 512 }) start := time.Now() b.Connect(g, g.NewKey()) b.Sync() took := time.Since(start) // 1,5 MiB tegen 512 KiB/s is minstens ~2,7 s (min de eerste burst). if took < 2500*time.Millisecond { t.Fatalf("sync duurde %v; de limiet van 512 KiB/s werkt niet", took) } if b.Status().RateLimitKiB != 512 { t.Fatal("limiet niet in de status") } if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/big.git")), "groot bestand") { t.Fatal("groot bestand niet gekopieerd") } } // Feature: op een interval archiveren; archieflijst in BlueGit. func TestArchiveIntervalAndListInBlueGit(t *testing.T) { g := startBlueGit(t) g.Project("Alpha", "README.md", "v1") b := startBackup(t, func(c *config.Config) { c.ArchiveInterval.Duration = 2 * time.Second }) if b.Status().Interval != "2s" { t.Fatalf("interval: %s", b.Status().Interval) } b.Connect(g, g.NewKey()) Eventually(t, 20*time.Second, "twee archieven door het interval", func() bool { return len(b.Archives()) >= 2 }) names := b.Archives() st := g.BackupStatus() if len(st.Archives) < 2 || st.Archives[0].Name != names[0] || st.Archives[0].Size == 0 { t.Fatalf("BlueGit toont de archieven niet: %+v vs %v", st.Archives, names) } // De beheerpagina toont de lijst met de grote waarschuwing. res, err := g.Session().Get(g.URL + "/admin/backup/s/" + g.Server) if err != nil { t.Fatal(err) } page, _ := io.ReadAll(res.Body) res.Body.Close() for _, want := range []string{names[0], `class="backup-danger"`, `name="understood"`, `name="confirm"`} { if !strings.Contains(string(page), want) { t.Fatalf("beheerpagina mist %q", want) } } // Het archief is een geldige tar.gz met de logische paden. out, err := exec.Command("tar", "-tzf", filepath.Join(b.Dir, "archives", names[0])).CombinedOutput() if err != nil || !strings.Contains(string(out), "state/bluegit.db") || !strings.Contains(string(out), "data/repos/tim/alpha.git/HEAD") { t.Fatalf("archief: %v %s", err, out) } } // Feature: archieven ouder dan x dagen, of de oudste bij een volle schijf, verdwijnen. func TestRetentionAndDiskFull(t *testing.T) { g := startBlueGit(t) g.Project("Alpha", "README.md", "v1") b := startBackup(t, func(c *config.Config) { c.RetentionDays = 7 }) b.Connect(g, g.NewKey()) b.Sync() var names []string for i := 0; i < 4; i++ { names = append(names, b.Archive()) time.Sleep(1100 * time.Millisecond) // namen hebben secondes } // De twee oudste zijn 10 en 8 dagen oud, de derde 6. ages := []int{10, 8, 6} for i, d := range ages { old := time.Now().Add(-time.Duration(d) * 24 * time.Hour) _ = os.Chtimes(filepath.Join(b.Dir, "archives", names[i]), old, old) } code, raw := b.Admin("POST", "/prune", nil) if code != 200 || !strings.Contains(string(raw), names[0]) || !strings.Contains(string(raw), names[1]) || strings.Contains(string(raw), names[2]) { t.Fatalf("prune op leeftijd: %d %s", code, raw) } if got := b.Archives(); len(got) != 2 { t.Fatalf("na leeftijd: %v", got) } // Schijf vol: de oudste gaat weg, het nieuwste blijft altijd. b.Srv.SetFree(func(string) (uint64, error) { return 0, nil }) code, raw = b.Admin("POST", "/prune", nil) if code != 200 || !strings.Contains(string(raw), names[2]) { t.Fatalf("prune schijf vol: %d %s", code, raw) } if got := b.Archives(); len(got) != 1 || got[0] != names[3] { t.Fatalf("na schijf vol: %v, wil alleen %s", got, names[3]) } // Ook een nieuw archief maakt eerst ruimte: het oude gaat weg, het nieuwe komt. b.Srv.SetFree(func(string) (uint64, error) { if len(b.Archives()) > 0 { return 0, nil } return 10 << 30, nil }) time.Sleep(1100 * time.Millisecond) newest := b.Archive() if got := b.Archives(); len(got) != 1 || got[0] != newest { t.Fatalf("na archief bij volle schijf: %v", got) } } // Feature: rollback vanuit BlueGit, met bevestiging; kopie en BlueGit gaan terug. func TestRollbackFromBlueGit(t *testing.T) { g := startBlueGit(t) g.Project("Alpha", "README.md", "versie 1") g.Issue("alpha", "voor het archief") b := startBackup(t, nil) b.Connect(g, g.NewKey()) b.Sync() archiveName := b.Archive() // Na het archief: alles verandert. g.Commit("alpha", "README.md", "versie 2", "update") g.Issue("alpha", "na het archief") g.Project("Beta", "b.txt", "nieuw project") b.Sync() if _, s := g.File("alpha", "README.md"); s != "versie 2" { t.Fatalf("voorbereiding: %q", s) } // Zonder juiste bevestiging gebeurt er niets. code, raw := g.Action(g.Server, "rollback", map[string]any{"archive": archiveName, "confirm": "ja"}) if code != 400 { t.Fatalf("rollback zonder bevestiging: %d %s", code, raw) } // Via het formulier zonder vinkje ook niet. if code := postRollbackForm(t, g, archiveName, false); code/100 != 3 { t.Fatalf("formulier zonder vinkje: %d", code) } time.Sleep(300 * time.Millisecond) if b.Status().Rollback.State != "idle" { t.Fatalf("rollback gestart zonder bevestiging: %+v", b.Status().Rollback) } // Echte rollback via de UI. if code := postRollbackForm(t, g, archiveName, true); code/100 != 3 { t.Fatalf("formulier: %d", code) } Eventually(t, 60*time.Second, "rollback klaar", func() bool { st := b.Status().Rollback if st.State == "failed" { t.Fatalf("rollback mislukt: %s", st.Error) } return st.State == "done" }) g.WaitUp(30 * time.Second) if code, s := g.File("alpha", "README.md"); code != 200 || s != "versie 1" { t.Fatalf("README na rollback: %d %q", code, s) } if code := g.ProjectCode("beta"); code != 404 { t.Fatalf("project beta bestaat na rollback nog: %d", code) } titles := strings.Join(g.IssueTitles("alpha"), "|") if !strings.Contains(titles, "voor het archief") || strings.Contains(titles, "na het archief") { t.Fatalf("issues na rollback: %s", titles) } // De koppeling overleeft de rollback: BlueGit ziet de server nog, en // de kopie loopt weer gelijk met BlueGit. if st := g.BackupStatus(); !st.Connected || st.RemoteError != "" { t.Fatalf("koppeling na rollback: %+v", st) } b.Sync() if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); strings.Count(log, "zet README.md") != 1 { t.Fatalf("kopie na rollback: %s", log) } if _, err := os.Stat(b.Mirror("data/repos/tim/beta.git/HEAD")); err == nil { t.Fatal("beta staat nog in de kopie") } // Na de rollback werkt BlueGit gewoon verder en blijft melden. g.Commit("alpha", "after.txt", "na rollback", "create") Eventually(t, 15*time.Second, "melding na rollback", func() bool { return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet after.txt") }) } func postRollbackForm(t *testing.T, g *BlueGit, archiveName string, understood bool) int { t.Helper() hc := g.Session() hc.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse } res, err := hc.Get(g.URL + "/admin/backup/s/" + g.Server) if err != nil { t.Fatal(err) } page, _ := io.ReadAll(res.Body) res.Body.Close() csrf := between(string(page), `name="csrf" value="`, `"`) if csrf == "" { t.Fatal("geen csrf op de beheerpagina") } form := url.Values{"csrf": {csrf}, "archive": {archiveName}, "confirm": {archiveName}} if understood { form.Set("understood", "1") } res, err = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/rollback", form) if err != nil { t.Fatal(err) } res.Body.Close() return res.StatusCode } func between(s, a, b string) string { i := strings.Index(s, a) if i < 0 { return "" } s = s[i+len(a):] j := strings.Index(s, b) if j < 0 { return "" } return s[:j] } // Feature: één BlueGit per backup server; keuze "oude backups verwijderen". func TestNewInstanceWipe(t *testing.T) { a := startBlueGit(t) a.Project("Alpha", "a.txt", "van A") b := startBackup(t, nil) b.Connect(a, a.NewKey()) b.Sync() b.Archive() other := startBlueGit(t) other.Project("Gamma", "g.txt", "van B") keyB := other.NewKey() code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB}) if code != 409 { t.Fatalf("tweede BlueGit zonder keuze: %d %s", code, raw) } var cf server.ConflictError _ = json.Unmarshal(raw, &cf) if !cf.Conflict || cf.PreviousURL != a.URL || cf.Archives != 1 || strings.Join(cf.Choices, ",") != "wipe,restore" { t.Fatalf("conflict: %+v", cf) } // Er is nog niets veranderd. if b.Status().BlueGitURL != a.URL || len(b.Archives()) != 1 { t.Fatal("conflict veranderde de koppeling") } code, raw = b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB, OnConflict: "wipe"}) if code != 200 { t.Fatalf("wipe: %d %s", code, raw) } if len(b.Archives()) != 0 { t.Fatal("oude archieven staan er nog") } b.Sync() if _, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD")); err == nil { t.Fatal("A staat nog in de kopie") } if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/gamma.git")), "zet g.txt") { t.Fatal("B staat niet in de kopie") } if st := other.BackupStatus(); !st.Connected || st.ServerURL != b.URL { t.Fatalf("B ziet de koppeling niet: %+v", st) } // A is los: zijn meldingen worden geweigerd (andere instantie). if b.Status().InstanceID == a.BackupStatus().InstanceID { t.Fatal("backup server hoort nog bij A") } } // Feature: keuze "nieuwe instantie terugzetten naar de gegevens in de backup server". func TestNewInstanceRestore(t *testing.T) { a := startBlueGit(t) a.Project("Alpha", "a.txt", "van A") a.Issue("alpha", "issue van A") b := startBackup(t, nil) b.Connect(a, a.NewKey()) b.Sync() fresh := startBlueGit(t) fresh.Project("Gamma", "g.txt", "van B") keyB := fresh.NewKey() freshID := fresh.BackupStatus().InstanceID code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: keyB, OnConflict: "restore"}) if code != 200 || !strings.Contains(string(raw), `"restored":true`) { t.Fatalf("restore: %d %s", code, raw) } fresh.WaitUp(30 * time.Second) // De nieuwe BlueGit heeft nu de database van A, dus ook A's token. fresh.Token = a.Token if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" { t.Fatalf("A's project op de nieuwe BlueGit: %d %q", code, s) } if code := fresh.ProjectCode("gamma"); code != 404 { t.Fatalf("B's eigen project bestaat nog: %d", code) } if titles := strings.Join(fresh.IssueTitles("alpha"), "|"); !strings.Contains(titles, "issue van A") { t.Fatalf("issues: %s", titles) } // De koppeling hoort bij de installatie, niet bij de gegevens. st := fresh.BackupStatus() if !st.Connected || st.InstanceID != freshID || st.ServerURL != b.URL { t.Fatalf("koppeling na restore: %+v", st) } if b.Status().InstanceID != freshID { t.Fatal("backup server hoort niet bij de nieuwe instantie") } b.Sync() if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet a.txt") { t.Fatal("kopie na restore") } } // Feature: de CLI vraagt de keuze bij een nieuwe verbinding. func TestCLIConnectAsksOnConflict(t *testing.T) { cli := filepath.Join(t.TempDir(), "bluegit-backup") if out, err := exec.Command("go", "build", "-o", cli, "../../../cmd/bluegit-backup").CombinedOutput(); err != nil { t.Fatalf("build: %v %s", err, out) } a := startBlueGit(t) a.Project("Alpha", "a.txt", "A") b := startBackup(t, nil) cfgPath := filepath.Join(t.TempDir(), "config.yml") _ = os.WriteFile(cfgPath, []byte("listen: "+b.Cfg.Listen+"\npublic_url: "+b.URL+"\ndata_dir: "+b.Dir+"\n"), 0o600) run := func(stdin string, args ...string) (string, error) { cmd := exec.Command(cli, append([]string{"connect", "--config", cfgPath}, args...)...) cmd.Stdin = strings.NewReader(stdin) out, err := cmd.CombinedOutput() return string(out), err } keyA := a.NewKey() cmd := exec.Command(cli, "connect", "--config", cfgPath, "--url", a.URL) cmd.Env = append(os.Environ(), "BLUEGIT_BACKUP_KEY="+keyA) if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("eerste connect: %v %s", err, out) } b.Sync() other := startBlueGit(t) keyB := other.NewKey() out, err := run("\n", "--url", other.URL, "--key", keyB) if err == nil || !strings.Contains(out, "Oude backups verwijderen") || !strings.Contains(out, "terugzetten") || !strings.Contains(out, "afgebroken") { t.Fatalf("afbreken: %v %s", err, out) } if b.Status().BlueGitURL != a.URL { t.Fatal("afbreken veranderde de koppeling") } out, err = run("1\n", "--url", other.URL, "--key", keyB) if err != nil || b.Status().BlueGitURL != other.URL { t.Fatalf("keuze 1: %v %s", err, out) } if out, err := exec.Command(cli, "status", "--config", cfgPath).CombinedOutput(); err != nil || !strings.Contains(string(out), other.URL) { t.Fatalf("status: %v %s", err, out) } }