BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / integration / backup_test.go

backup_test.go

backup_test.go 17.7 KiB Download Raw
1//go:build integration
2
3package integration
4
5import (
6 "crypto/rand"
7 "encoding/json"
8 "io"
9 "net/http"
10 "net/url"
11 "os"
12 "os/exec"
13 "path/filepath"
14 "strings"
15 "testing"
16 "time"
17
18 "gitlab.com/Timfa/bluegit/internal/backupserver/config"
19 "gitlab.com/Timfa/bluegit/internal/backupserver/server"
20)
21
22// Feature: Backupserver-Key in BlueGit genereren en de backup server koppelen.
23func TestKeyGenerationAndConnect(t *testing.T) {
24 g := startBlueGit(t)
25 b := startBackup(t, nil)
26
27 // Zonder key niets; een verkeerde key wordt geweigerd.
28 if st := g.BackupStatus(); st.HasKey || st.Connected {
29 t.Fatalf("vers BlueGit heeft al een key: %+v", st)
30 }
31 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: "bgbk_verkeerd"})
32 if code != 401 {
33 t.Fatalf("verkeerde key: %d %s", code, raw)
34 }
35 key := g.NewKey()
36 b.Connect(g, key)
37
38 st := g.BackupStatus()
39 if !st.HasKey || !st.Connected || st.ServerURL != b.URL || st.RemoteError != "" {
40 t.Fatalf("BlueGit ziet de koppeling niet: %+v", st)
41 }
42 bs := b.Status()
43 if !bs.Connected || bs.InstanceID != st.InstanceID || bs.BlueGitURL != g.URL {
44 t.Fatalf("backup status: %+v", bs)
45 }
46 // De key staat niet leesbaar in BlueGit.
47 raw2, _ := os.ReadFile(filepath.Join(g.State, "backup.json"))
48 if strings.Contains(string(raw2), key) {
49 t.Fatal("BlueGit bewaart de key leesbaar")
50 }
51 // Een nieuwe key maakt de oude ongeldig: de backup server kan niet meer syncen.
52 g.RotateKey()
53 code, raw = b.Admin("POST", "/sync", nil)
54 if code == 200 {
55 t.Fatalf("sync met ingetrokken key gelukt: %s", raw)
56 }
57}
58
59// Feature: alle gegevens en configuratie ophalen.
60func TestFullSyncCopiesAllData(t *testing.T) {
61 g := startBlueGit(t)
62 g.Project("Alpha", "README.md", "hallo alpha")
63 g.Issue("alpha", "eerste issue")
64 b := startBackup(t, nil)
65 b.Connect(g, g.NewKey())
66 b.Sync()
67
68 for _, p := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/alpha.git/HEAD"} {
69 if _, err := os.Stat(b.Mirror(p)); err != nil {
70 t.Fatalf("kopie mist %s: %v", p, err)
71 }
72 }
73 if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); !strings.Contains(log, "zet README.md") {
74 t.Fatalf("kopie van de repo is niet bruikbaar: %s", log)
75 }
76 db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))
77 if !strings.HasPrefix(string(db), "SQLite format 3") || !strings.Contains(string(db), "eerste issue") {
78 t.Fatal("databasekopie mist het issue")
79 }
80 key1, _ := os.ReadFile(filepath.Join(g.State, "secret.key"))
81 key2, _ := os.ReadFile(b.Mirror("state/secret.key"))
82 if string(key1) != string(key2) {
83 t.Fatal("secret.key wijkt af")
84 }
85 // Installatiegebonden bestanden gaan niet mee.
86 for _, p := range []string{"state/backup.json", "state/instance_id", "state/storage_path"} {
87 if _, err := os.Stat(b.Mirror(p)); err == nil {
88 t.Fatalf("%s hoort niet in de kopie", p)
89 }
90 }
91 // Een tweede sync zonder wijzigingen haalt (bijna) niets op.
92 code, raw := b.Admin("POST", "/sync", nil)
93 var st struct{ Downloaded int }
94 _ = json.Unmarshal(raw, &st)
95 if code != 200 || st.Downloaded > 1 {
96 t.Fatalf("tweede sync haalde %d bestanden op: %s", st.Downloaded, raw)
97 }
98 prog := b.Status().Sync
99 if !prog.Known || prog.Percent != 100 || prog.Syncing || prog.DoneFiles != prog.TotalFiles {
100 t.Fatalf("na volledige sync verwacht 100%%: %+v", prog)
101 }
102}
103
104// Feature: BlueGit meldt elke wijziging; de backup server haalt hem op.
105func TestNotificationTriggersSync(t *testing.T) {
106 g := startBlueGit(t)
107 g.Project("Alpha", "README.md", "v1")
108 b := startBackup(t, nil) // full sync pas na een uur: alleen meldingen tellen
109 b.Connect(g, g.NewKey())
110 Eventually(t, 15*time.Second, "eerste sync na koppelen", func() bool {
111 return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet README.md")
112 })
113 before := b.Status().Notifies
114
115 // Wijziging via de API.
116 g.Commit("alpha", "CHANGELOG.md", "nieuw", "create")
117 Eventually(t, 15*time.Second, "commit via API in de kopie", func() bool {
118 return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet CHANGELOG.md")
119 })
120 // Wijziging via git push over HTTP.
121 work := t.TempDir()
122 g.Git(work, "clone", "-q", g.RemoteURL("alpha"), "w")
123 repo := filepath.Join(work, "w")
124 _ = os.WriteFile(filepath.Join(repo, "pushed.txt"), []byte("via git"), 0o644)
125 g.Git(repo, "add", ".")
126 g.Git(repo, "commit", "-qm", "gepusht met git")
127 g.Git(repo, "push", "-q", "origin", "master")
128 Eventually(t, 15*time.Second, "git push in de kopie", func() bool {
129 return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "gepusht met git")
130 })
131 // Een issue staat alleen in de database.
132 g.Issue("alpha", "issue-na-melding")
133 Eventually(t, 15*time.Second, "issue in de databasekopie", func() bool {
134 db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))
135 return strings.Contains(string(db), "issue-na-melding")
136 })
137 if b.Status().Notifies <= before {
138 t.Fatal("geen meldingen geteld")
139 }
140}
141
142// Feature: downloaden op lage snelheid.
143func TestDownloadIsThrottled(t *testing.T) {
144 g := startBlueGit(t)
145 g.MustAPI("POST", "/projects", map[string]any{"name": "Big", "visibility": "private"})
146 work := t.TempDir()
147 g.Git(work, "init", "-q", "-b", "master", "w")
148 repo := filepath.Join(work, "w")
149 blob := make([]byte, 1536<<10) // 1,5 MiB, niet te comprimeren
150 _, _ = rand.Read(blob)
151 _ = os.WriteFile(filepath.Join(repo, "random.bin"), blob, 0o644)
152 g.Git(repo, "add", ".")
153 g.Git(repo, "commit", "-qm", "groot bestand")
154 g.Git(repo, "push", "-q", g.RemoteURL("big"), "master")
155
156 b := startBackup(t, func(c *config.Config) { c.RateLimitKiB = 512 })
157 start := time.Now()
158 b.Connect(g, g.NewKey())
159 b.Sync()
160 took := time.Since(start)
161 // 1,5 MiB tegen 512 KiB/s is minstens ~2,7 s (min de eerste burst).
162 if took < 2500*time.Millisecond {
163 t.Fatalf("sync duurde %v; de limiet van 512 KiB/s werkt niet", took)
164 }
165 if b.Status().RateLimitKiB != 512 {
166 t.Fatal("limiet niet in de status")
167 }
168 if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/big.git")), "groot bestand") {
169 t.Fatal("groot bestand niet gekopieerd")
170 }
171}
172
173// Feature: op een interval archiveren; archieflijst in BlueGit.
174func TestArchiveIntervalAndListInBlueGit(t *testing.T) {
175 g := startBlueGit(t)
176 g.Project("Alpha", "README.md", "v1")
177 b := startBackup(t, func(c *config.Config) { c.ArchiveInterval.Duration = 2 * time.Second })
178 if b.Status().Interval != "2s" {
179 t.Fatalf("interval: %s", b.Status().Interval)
180 }
181 b.Connect(g, g.NewKey())
182 Eventually(t, 20*time.Second, "twee archieven door het interval", func() bool { return len(b.Archives()) >= 2 })
183
184 names := b.Archives()
185 st := g.BackupStatus()
186 if len(st.Archives) < 2 || st.Archives[0].Name != names[0] || st.Archives[0].Size == 0 {
187 t.Fatalf("BlueGit toont de archieven niet: %+v vs %v", st.Archives, names)
188 }
189 // De beheerpagina toont de lijst met de grote waarschuwing.
190 res, err := g.Session().Get(g.URL + "/admin/backup/s/" + g.Server)
191 if err != nil {
192 t.Fatal(err)
193 }
194 page, _ := io.ReadAll(res.Body)
195 res.Body.Close()
196 for _, want := range []string{names[0], `class="backup-danger"`, `name="understood"`, `name="confirm"`} {
197 if !strings.Contains(string(page), want) {
198 t.Fatalf("beheerpagina mist %q", want)
199 }
200 }
201 // Het archief is een geldige tar.gz met de logische paden.
202 out, err := exec.Command("tar", "-tzf", filepath.Join(b.Dir, "archives", names[0])).CombinedOutput()
203 if err != nil || !strings.Contains(string(out), "state/bluegit.db") || !strings.Contains(string(out), "data/repos/tim/alpha.git/HEAD") {
204 t.Fatalf("archief: %v %s", err, out)
205 }
206}
207
208// Feature: archieven ouder dan x dagen, of de oudste bij een volle schijf, verdwijnen.
209func TestRetentionAndDiskFull(t *testing.T) {
210 g := startBlueGit(t)
211 g.Project("Alpha", "README.md", "v1")
212 b := startBackup(t, func(c *config.Config) { c.RetentionDays = 7 })
213 b.Connect(g, g.NewKey())
214 b.Sync()
215 var names []string
216 for i := 0; i < 4; i++ {
217 names = append(names, b.Archive())
218 time.Sleep(1100 * time.Millisecond) // namen hebben secondes
219 }
220 // De twee oudste zijn 10 en 8 dagen oud, de derde 6.
221 ages := []int{10, 8, 6}
222 for i, d := range ages {
223 old := time.Now().Add(-time.Duration(d) * 24 * time.Hour)
224 _ = os.Chtimes(filepath.Join(b.Dir, "archives", names[i]), old, old)
225 }
226 code, raw := b.Admin("POST", "/prune", nil)
227 if code != 200 || !strings.Contains(string(raw), names[0]) || !strings.Contains(string(raw), names[1]) || strings.Contains(string(raw), names[2]) {
228 t.Fatalf("prune op leeftijd: %d %s", code, raw)
229 }
230 if got := b.Archives(); len(got) != 2 {
231 t.Fatalf("na leeftijd: %v", got)
232 }
233 // Schijf vol: de oudste gaat weg, het nieuwste blijft altijd.
234 b.Srv.SetFree(func(string) (uint64, error) { return 0, nil })
235 code, raw = b.Admin("POST", "/prune", nil)
236 if code != 200 || !strings.Contains(string(raw), names[2]) {
237 t.Fatalf("prune schijf vol: %d %s", code, raw)
238 }
239 if got := b.Archives(); len(got) != 1 || got[0] != names[3] {
240 t.Fatalf("na schijf vol: %v, wil alleen %s", got, names[3])
241 }
242 // Ook een nieuw archief maakt eerst ruimte: het oude gaat weg, het nieuwe komt.
243 b.Srv.SetFree(func(string) (uint64, error) {
244 if len(b.Archives()) > 0 {
245 return 0, nil
246 }
247 return 10 << 30, nil
248 })
249 time.Sleep(1100 * time.Millisecond)
250 newest := b.Archive()
251 if got := b.Archives(); len(got) != 1 || got[0] != newest {
252 t.Fatalf("na archief bij volle schijf: %v", got)
253 }
254}
255
256// Feature: rollback vanuit BlueGit, met bevestiging; kopie en BlueGit gaan terug.
257func TestRollbackFromBlueGit(t *testing.T) {
258 g := startBlueGit(t)
259 g.Project("Alpha", "README.md", "versie 1")
260 g.Issue("alpha", "voor het archief")
261 b := startBackup(t, nil)
262 b.Connect(g, g.NewKey())
263 b.Sync()
264 archiveName := b.Archive()
265
266 // Na het archief: alles verandert.
267 g.Commit("alpha", "README.md", "versie 2", "update")
268 g.Issue("alpha", "na het archief")
269 g.Project("Beta", "b.txt", "nieuw project")
270 b.Sync()
271 if _, s := g.File("alpha", "README.md"); s != "versie 2" {
272 t.Fatalf("voorbereiding: %q", s)
273 }
274
275 // Zonder juiste bevestiging gebeurt er niets.
276 code, raw := g.Action(g.Server, "rollback", map[string]any{"archive": archiveName, "confirm": "ja"})
277 if code != 400 {
278 t.Fatalf("rollback zonder bevestiging: %d %s", code, raw)
279 }
280 // Via het formulier zonder vinkje ook niet.
281 if code := postRollbackForm(t, g, archiveName, false); code/100 != 3 {
282 t.Fatalf("formulier zonder vinkje: %d", code)
283 }
284 time.Sleep(300 * time.Millisecond)
285 if b.Status().Rollback.State != "idle" {
286 t.Fatalf("rollback gestart zonder bevestiging: %+v", b.Status().Rollback)
287 }
288
289 // Echte rollback via de UI.
290 if code := postRollbackForm(t, g, archiveName, true); code/100 != 3 {
291 t.Fatalf("formulier: %d", code)
292 }
293 Eventually(t, 60*time.Second, "rollback klaar", func() bool {
294 st := b.Status().Rollback
295 if st.State == "failed" {
296 t.Fatalf("rollback mislukt: %s", st.Error)
297 }
298 return st.State == "done"
299 })
300 g.WaitUp(30 * time.Second)
301
302 if code, s := g.File("alpha", "README.md"); code != 200 || s != "versie 1" {
303 t.Fatalf("README na rollback: %d %q", code, s)
304 }
305 if code := g.ProjectCode("beta"); code != 404 {
306 t.Fatalf("project beta bestaat na rollback nog: %d", code)
307 }
308 titles := strings.Join(g.IssueTitles("alpha"), "|")
309 if !strings.Contains(titles, "voor het archief") || strings.Contains(titles, "na het archief") {
310 t.Fatalf("issues na rollback: %s", titles)
311 }
312 // De koppeling overleeft de rollback: BlueGit ziet de server nog, en
313 // de kopie loopt weer gelijk met BlueGit.
314 if st := g.BackupStatus(); !st.Connected || st.RemoteError != "" {
315 t.Fatalf("koppeling na rollback: %+v", st)
316 }
317 b.Sync()
318 if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); strings.Count(log, "zet README.md") != 1 {
319 t.Fatalf("kopie na rollback: %s", log)
320 }
321 if _, err := os.Stat(b.Mirror("data/repos/tim/beta.git/HEAD")); err == nil {
322 t.Fatal("beta staat nog in de kopie")
323 }
324 // Na de rollback werkt BlueGit gewoon verder en blijft melden.
325 g.Commit("alpha", "after.txt", "na rollback", "create")
326 Eventually(t, 15*time.Second, "melding na rollback", func() bool {
327 return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet after.txt")
328 })
329}
330
331func postRollbackForm(t *testing.T, g *BlueGit, archiveName string, understood bool) int {
332 t.Helper()
333 hc := g.Session()
334 hc.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
335 res, err := hc.Get(g.URL + "/admin/backup/s/" + g.Server)
336 if err != nil {
337 t.Fatal(err)
338 }
339 page, _ := io.ReadAll(res.Body)
340 res.Body.Close()
341 csrf := between(string(page), `name="csrf" value="`, `"`)
342 if csrf == "" {
343 t.Fatal("geen csrf op de beheerpagina")
344 }
345 form := url.Values{"csrf": {csrf}, "archive": {archiveName}, "confirm": {archiveName}}
346 if understood {
347 form.Set("understood", "1")
348 }
349 res, err = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/rollback", form)
350 if err != nil {
351 t.Fatal(err)
352 }
353 res.Body.Close()
354 return res.StatusCode
355}
356
357func between(s, a, b string) string {
358 i := strings.Index(s, a)
359 if i < 0 {
360 return ""
361 }
362 s = s[i+len(a):]
363 j := strings.Index(s, b)
364 if j < 0 {
365 return ""
366 }
367 return s[:j]
368}
369
370// Feature: één BlueGit per backup server; keuze "oude backups verwijderen".
371func TestNewInstanceWipe(t *testing.T) {
372 a := startBlueGit(t)
373 a.Project("Alpha", "a.txt", "van A")
374 b := startBackup(t, nil)
375 b.Connect(a, a.NewKey())
376 b.Sync()
377 b.Archive()
378
379 other := startBlueGit(t)
380 other.Project("Gamma", "g.txt", "van B")
381 keyB := other.NewKey()
382 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB})
383 if code != 409 {
384 t.Fatalf("tweede BlueGit zonder keuze: %d %s", code, raw)
385 }
386 var cf server.ConflictError
387 _ = json.Unmarshal(raw, &cf)
388 if !cf.Conflict || cf.PreviousURL != a.URL || cf.Archives != 1 || strings.Join(cf.Choices, ",") != "wipe,restore" {
389 t.Fatalf("conflict: %+v", cf)
390 }
391 // Er is nog niets veranderd.
392 if b.Status().BlueGitURL != a.URL || len(b.Archives()) != 1 {
393 t.Fatal("conflict veranderde de koppeling")
394 }
395 code, raw = b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB, OnConflict: "wipe"})
396 if code != 200 {
397 t.Fatalf("wipe: %d %s", code, raw)
398 }
399 if len(b.Archives()) != 0 {
400 t.Fatal("oude archieven staan er nog")
401 }
402 b.Sync()
403 if _, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD")); err == nil {
404 t.Fatal("A staat nog in de kopie")
405 }
406 if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/gamma.git")), "zet g.txt") {
407 t.Fatal("B staat niet in de kopie")
408 }
409 if st := other.BackupStatus(); !st.Connected || st.ServerURL != b.URL {
410 t.Fatalf("B ziet de koppeling niet: %+v", st)
411 }
412 // A is los: zijn meldingen worden geweigerd (andere instantie).
413 if b.Status().InstanceID == a.BackupStatus().InstanceID {
414 t.Fatal("backup server hoort nog bij A")
415 }
416}
417
418// Feature: keuze "nieuwe instantie terugzetten naar de gegevens in de backup server".
419func TestNewInstanceRestore(t *testing.T) {
420 a := startBlueGit(t)
421 a.Project("Alpha", "a.txt", "van A")
422 a.Issue("alpha", "issue van A")
423 b := startBackup(t, nil)
424 b.Connect(a, a.NewKey())
425 b.Sync()
426
427 fresh := startBlueGit(t)
428 fresh.Project("Gamma", "g.txt", "van B")
429 keyB := fresh.NewKey()
430 freshID := fresh.BackupStatus().InstanceID
431 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: keyB, OnConflict: "restore"})
432 if code != 200 || !strings.Contains(string(raw), `"restored":true`) {
433 t.Fatalf("restore: %d %s", code, raw)
434 }
435 fresh.WaitUp(30 * time.Second)
436 // De nieuwe BlueGit heeft nu de database van A, dus ook A's token.
437 fresh.Token = a.Token
438 if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" {
439 t.Fatalf("A's project op de nieuwe BlueGit: %d %q", code, s)
440 }
441 if code := fresh.ProjectCode("gamma"); code != 404 {
442 t.Fatalf("B's eigen project bestaat nog: %d", code)
443 }
444 if titles := strings.Join(fresh.IssueTitles("alpha"), "|"); !strings.Contains(titles, "issue van A") {
445 t.Fatalf("issues: %s", titles)
446 }
447 // De koppeling hoort bij de installatie, niet bij de gegevens.
448 st := fresh.BackupStatus()
449 if !st.Connected || st.InstanceID != freshID || st.ServerURL != b.URL {
450 t.Fatalf("koppeling na restore: %+v", st)
451 }
452 if b.Status().InstanceID != freshID {
453 t.Fatal("backup server hoort niet bij de nieuwe instantie")
454 }
455 b.Sync()
456 if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet a.txt") {
457 t.Fatal("kopie na restore")
458 }
459}
460
461// Feature: de CLI vraagt de keuze bij een nieuwe verbinding.
462func TestCLIConnectAsksOnConflict(t *testing.T) {
463 cli := filepath.Join(t.TempDir(), "bluegit-backup")
464 if out, err := exec.Command("go", "build", "-o", cli, "../../../cmd/bluegit-backup").CombinedOutput(); err != nil {
465 t.Fatalf("build: %v %s", err, out)
466 }
467 a := startBlueGit(t)
468 a.Project("Alpha", "a.txt", "A")
469 b := startBackup(t, nil)
470 cfgPath := filepath.Join(t.TempDir(), "config.yml")
471 _ = os.WriteFile(cfgPath, []byte("listen: "+b.Cfg.Listen+"\npublic_url: "+b.URL+"\ndata_dir: "+b.Dir+"\n"), 0o600)
472 run := func(stdin string, args ...string) (string, error) {
473 cmd := exec.Command(cli, append([]string{"connect", "--config", cfgPath}, args...)...)
474 cmd.Stdin = strings.NewReader(stdin)
475 out, err := cmd.CombinedOutput()
476 return string(out), err
477 }
478 keyA := a.NewKey()
479 cmd := exec.Command(cli, "connect", "--config", cfgPath, "--url", a.URL)
480 cmd.Env = append(os.Environ(), "BLUEGIT_BACKUP_KEY="+keyA)
481 if out, err := cmd.CombinedOutput(); err != nil {
482 t.Fatalf("eerste connect: %v %s", err, out)
483 }
484 b.Sync()
485
486 other := startBlueGit(t)
487 keyB := other.NewKey()
488 out, err := run("\n", "--url", other.URL, "--key", keyB)
489 if err == nil || !strings.Contains(out, "Oude backups verwijderen") || !strings.Contains(out, "terugzetten") || !strings.Contains(out, "afgebroken") {
490 t.Fatalf("afbreken: %v %s", err, out)
491 }
492 if b.Status().BlueGitURL != a.URL {
493 t.Fatal("afbreken veranderde de koppeling")
494 }
495 out, err = run("1\n", "--url", other.URL, "--key", keyB)
496 if err != nil || b.Status().BlueGitURL != other.URL {
497 t.Fatalf("keuze 1: %v %s", err, out)
498 }
499 if out, err := exec.Command(cli, "status", "--config", cfgPath).CombinedOutput(); err != nil || !strings.Contains(string(out), other.URL) {
500 t.Fatalf("status: %v %s", err, out)
501 }
502}