//go:build integration package integration import ( "encoding/json" "io" "net/http" "net/http/cookiejar" "net/url" "os" "path/filepath" "sort" "strings" "testing" "time" ) // webUI is een browser op de webinterface van de backup server. type webUI struct { t *testing.T b *Backup hc *http.Client csrf string } func openUI(t *testing.T, b *Backup) *webUI { t.Helper() jar, _ := cookiejar.New(nil) u := &webUI{t: t, b: b, hc: &http.Client{Jar: jar, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}} res, err := u.hc.Get(b.URL + "/") if err != nil { t.Fatal(err) } res.Body.Close() if res.StatusCode != 303 || res.Header.Get("Location") != "/login" { t.Fatalf("zonder login: %d %s", res.StatusCode, res.Header.Get("Location")) } res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {"bba_fout"}}) res.Body.Close() if res.Header.Get("Location") != "/login?fout=1" { t.Fatal("fout token geaccepteerd") } res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {b.Srv.AdminToken()}}) res.Body.Close() if res.StatusCode != 303 || res.Header.Get("Location") != "/" { t.Fatalf("login: %d", res.StatusCode) } u.Page() return u } // Page haalt de hoofdpagina op en onthoudt het CSRF-token. func (u *webUI) Page() string { u.t.Helper() res, err := u.hc.Get(u.b.URL + "/") if err != nil { u.t.Fatal(err) } b, _ := io.ReadAll(res.Body) res.Body.Close() if res.StatusCode != 200 { u.t.Fatalf("pagina: %d", res.StatusCode) } u.csrf = between(string(b), `name="csrf" value="`, `"`) return string(b) } // Act verstuurt het formulier van een actie en geeft de melding erna. func (u *webUI) Act(name string, form url.Values) string { u.t.Helper() if form == nil { form = url.Values{} } form.Set("csrf", u.csrf) res, err := u.hc.PostForm(u.b.URL+"/ui/act/"+name, form) if err != nil { u.t.Fatal(err) } res.Body.Close() if res.StatusCode != 303 { u.t.Fatalf("%s: %d", name, res.StatusCode) } return between(u.Page(), `role="status">`, ``) } func actionNames(t *testing.T, b *Backup, withGet bool) []string { t.Helper() code, raw := b.Admin("GET", "/actions", nil) if code != 200 { t.Fatalf("actions: %d", code) } var out struct { Actions []struct{ Name, Method string } } _ = json.Unmarshal(raw, &out) var names []string for _, a := range out.Actions { if withGet || a.Method != "GET" { names = append(names, a.Name) } } sort.Strings(names) return names } func requireAll(t *testing.T, what string, want []string, done map[string]bool) { t.Helper() for _, n := range want { if !done[n] { t.Errorf("%s: actie %s niet getest", what, n) } } } // Feature: alles is in te stellen en te bedienen via de webinterface (poort 8080 standaard). func TestWebUIConfiguresAndOperatesEverything(t *testing.T) { g := startBlueGit(t) g.Project("Alpha", "README.md", "v1") b := startBackup(t, nil) u := openUI(t, b) done := map[string]bool{} // Instellingen. msg := u.Act("config.update", url.Values{"archive_interval": {"3h"}, "retention_days": {"5"}, "rate_limit_kib": {"2048"}, "min_free_mb": {"2"}, "full_sync_interval": {"2h"}, "min_sync_interval": {"1s"}, "public_url": {b.URL}, "listen": {b.Cfg.Listen}}) if !strings.Contains(msg, "opgeslagen") { t.Fatalf("instellingen: %q", msg) } done["config.update"] = true st := b.Status() if st.Interval != "3h0m0s" || st.RetentionDays != 5 || st.RateLimitKiB != 2048 { t.Fatalf("niet toegepast: %+v", st) } if msg := u.Act("config.update", url.Values{"archive_interval": {"nooit"}}); !strings.Contains(msg, "mislukt") { t.Fatalf("ongeldige waarde: %q", msg) } u.Act("config.update", url.Values{"rate_limit_kib": {"0"}}) // Koppelen met een key uit BlueGit. if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {"bgbk_fout"}, "on_conflict": {""}}); !strings.Contains(msg, "mislukt") { t.Fatalf("verkeerde key: %q", msg) } if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {g.NewKey()}, "on_conflict": {""}}); !strings.Contains(msg, "gelukt") { t.Fatalf("koppelen: %q", msg) } done["connect"] = true if st := g.BackupStatus(); !st.Connected || st.ServerURL != b.URL { t.Fatalf("BlueGit ziet de koppeling niet: %+v", st) } // Sync, archief, opruimen. if msg := u.Act("sync", nil); !strings.Contains(msg, "gestart") { t.Fatalf("sync: %q", msg) } done["sync"] = true Eventually(t, 15*time.Second, "kopie na sync uit de webinterface", func() bool { _, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD")) return err == nil }) b.Sync() if msg := u.Act("archive", nil); !strings.Contains(msg, "Archief gemaakt") { t.Fatalf("archief: %q", msg) } done["archive"] = true name := b.Archives()[0] page := u.Page() if !strings.Contains(page, name) || !strings.Contains(page, "gekoppeld") { t.Fatal("pagina toont het archief of de koppeling niet") } // Download vanuit de pagina. res, err := u.hc.Get(b.URL + "/api/v1/admin/archives/" + name + "/download") if err != nil { t.Fatal(err) } got, _ := io.ReadAll(res.Body) res.Body.Close() want, _ := os.ReadFile(filepath.Join(b.Dir, "archives", name)) if res.StatusCode != 200 || len(got) == 0 || string(got) != string(want) { t.Fatalf("download: %d %d bytes", res.StatusCode, len(got)) } if msg := u.Act("prune", nil); !strings.Contains(msg, "Opgeruimd") { t.Fatalf("opruimen: %q", msg) } done["prune"] = true // Rollback vanuit de webinterface: zonder vinkje niets, daarna echt. g.Commit("alpha", "README.md", "v2", "update") b.Sync() if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}}); !strings.Contains(msg, "Vink aan") { t.Fatalf("zonder vinkje: %q", msg) } if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {"verkeerd"}, "understood": {"1"}}); !strings.Contains(msg, "mislukt") { t.Fatalf("verkeerde bevestiging: %q", msg) } if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}, "understood": {"1"}}); !strings.Contains(msg, "Rollback gestart") { t.Fatalf("rollback: %q", msg) } done["rollback"] = true 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 _, s := g.File("alpha", "README.md"); s != "v1" { t.Fatalf("README na rollback: %q", s) } // Archief verwijderen en ontkoppelen. if msg := u.Act("archive.delete", url.Values{"name": {name}}); !strings.Contains(msg, "gelukt") { t.Fatalf("verwijderen: %q", msg) } done["archive.delete"] = true if len(b.Archives()) != 0 { t.Fatal("archief staat er nog") } if msg := u.Act("disconnect", nil); !strings.Contains(msg, "gelukt") { t.Fatalf("ontkoppelen: %q", msg) } done["disconnect"] = true if b.Status().Connected { t.Fatal("nog gekoppeld") } requireAll(t, "webinterface", actionNames(t, b, false), done) } // Feature: de API kan alles wat de webinterface kan, en andersom. func TestAPIDoesEverythingTheUICan(t *testing.T) { g := startBlueGit(t) g.Project("Alpha", "README.md", "v1") b := startBackup(t, nil) done := map[string]bool{} call := func(name, method, path string, in any, want int) []byte { t.Helper() code, raw := b.Admin(method, path, in) if code != want { t.Fatalf("%s %s: %d %s", method, path, code, raw) } done[name] = true return raw } call("status", "GET", "/status", nil, 200) call("actions", "GET", "/actions", nil, 200) raw := call("config", "GET", "/config", nil, 200) if !strings.Contains(string(raw), `"key":"listen"`) { t.Fatalf("config: %s", raw) } call("config.update", "PUT", "/config", map[string]any{"retention_days": 7, "archive_interval": "6h"}, 200) if b.Status().RetentionDays != 7 { t.Fatal("config niet toegepast") } call("connect", "POST", "/connect", map[string]any{"url": g.URL, "key": g.NewKey()}, 200) call("sync", "POST", "/sync", nil, 200) raw = call("archive", "POST", "/archive", nil, 201) var a struct{ Name string } _ = json.Unmarshal(raw, &a) raw = call("archives", "GET", "/archives", nil, 200) if !strings.Contains(string(raw), a.Name) { t.Fatalf("archives: %s", raw) } raw = call("archive.download", "GET", "/archives/"+a.Name+"/download", nil, 200) if len(raw) < 100 || raw[0] != 0x1f || raw[1] != 0x8b { t.Fatal("download is geen gzip") } call("prune", "POST", "/prune", nil, 200) call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name}, 400) // bevestiging ontbreekt call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name, "confirm": a.Name}, 202) Eventually(t, 60*time.Second, "rollback klaar", func() bool { return b.Status().Rollback.State == "done" }) g.WaitUp(30 * time.Second) call("archive.delete", "DELETE", "/archives/"+a.Name, nil, 200) call("disconnect", "POST", "/disconnect", nil, 200) requireAll(t, "API", actionNames(t, b, true), done) } // Feature: vanuit BlueGit is de backup server te bedienen zoals in zijn eigen webinterface. func TestBlueGitControlsBackupServer(t *testing.T) { g := startBlueGit(t) g.Project("Alpha", "README.md", "v1") b := startBackup(t, nil) b.Connect(g, g.NewKey()) b.Sync() // Instellingen lezen en wijzigen via de BlueGit-API. st := g.BackupStatus() if len(st.Config.Fields) == 0 { t.Fatalf("BlueGit ziet geen instellingen: %+v", st) } if code, raw := g.Action(g.Server, "config.update", map[string]any{"retention_days": "11", "archive_interval": "5h"}); code != 200 { t.Fatalf("config via BlueGit: %d %s", code, raw) } if s := b.Status(); s.RetentionDays != 11 || s.Interval != "5h0m0s" { t.Fatalf("niet toegepast: %+v", s) } // Archief maken, synchroniseren en verwijderen via BlueGit. if code, raw := g.Action(g.Server, "archive", nil); code != 201 { t.Fatalf("archief via BlueGit: %d %s", code, raw) } name := b.Archives()[0] g.Commit("alpha", "x.txt", "x", "create") before := b.Status().Syncs if code, raw := g.Action(g.Server, "sync", nil); code != 202 { t.Fatalf("sync via BlueGit: %d %s", code, raw) } Eventually(t, 15*time.Second, "sync gestart door BlueGit", func() bool { return b.Status().Syncs > before }) if code, raw := g.Action(g.Server, "archive.delete", map[string]any{"name": name}); code != 200 { t.Fatalf("verwijderen via BlueGit: %d %s", code, raw) } if len(b.Archives()) != 0 { t.Fatal("archief niet verwijderd") } // Koppelen kan BlueGit niet namens de backup server (alleen lokaal). if code, _ := g.Action(g.Server, "connect", map[string]any{"url": g.URL, "key": "bgbk_x"}); code != 404 { t.Fatalf("connect via BlueGit: %d", code) } // Dezelfde bediening in de BlueGit-webinterface. 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() for _, want := range []string{`name="retention_days" value="11"`, "/act/sync", "/act/archive", "/act/prune", "/act/config.update"} { if !strings.Contains(string(page), want) { t.Fatalf("BlueGit-pagina mist %q", want) } } csrf := between(string(page), `name="csrf" value="`, `"`) res, err = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"12"}}) if err != nil { t.Fatal(err) } res.Body.Close() if b.Status().RetentionDays != 12 { t.Fatalf("formulier in BlueGit: %d", b.Status().RetentionDays) } res, _ = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/archive", url.Values{"csrf": {csrf}}) res.Body.Close() if len(b.Archives()) != 1 { t.Fatal("archief via het BlueGit-formulier ontbreekt") } } // Feature: één BlueGit kan meerdere backup servers hebben; elke backup server hoort bij één BlueGit. func TestMultipleBackupServers(t *testing.T) { g := startBlueGit(t) g.Project("Alpha", "README.md", "v1") b1, b2 := startBackup(t, nil), startBackup(t, nil) id1, key1 := g.AddServer("nas") id2, key2 := g.AddServer("offsite") b1.Connect(g, key1) b2.Connect(g, key2) for _, id := range []string{id1, id2} { if st := g.ServerStatus(id); !st.Connected || st.RemoteError != "" { t.Fatalf("%s: %+v", id, st) } } if g.ServerStatus(id1).ServerURL != b1.URL || g.ServerStatus(id2).ServerURL != b2.URL { t.Fatal("adressen verwisseld") } // Elke wijziging komt bij beide aan. g.Commit("alpha", "beide.txt", "x", "create") for _, b := range []*Backup{b1, b2} { Eventually(t, 15*time.Second, "melding bij "+b.URL, func() bool { return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet beide.txt") }) } // Een key hoort bij één server: key1 werkt niet voor de tweede server. b3 := startBackup(t, nil) b3.Connect(g, key1) // dezelfde key: BlueGit verplaatst de koppeling van nas naar b3 if st := g.ServerStatus(id1); st.ServerURL != b3.URL { t.Fatalf("koppeling niet verplaatst: %+v", st) } // Verwijderen in BlueGit ontkoppelt alleen die server. if code, raw := g.API("DELETE", "/admin/backup/servers/"+id2, nil); code != 204 { t.Fatalf("verwijderen: %d %s", code, raw) } if b2.Status().Connected { t.Fatal("verwijderde backup server is nog gekoppeld") } g.Commit("alpha", "daarna.txt", "x", "create") Eventually(t, 15*time.Second, "overgebleven server krijgt meldingen", func() bool { return strings.Contains(gitLog(t, b3.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt") }) time.Sleep(time.Second) if strings.Contains(gitLog(t, b2.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt") { t.Fatal("verwijderde server synchroniseert nog") } // Een backup server hoort bij één BlueGit: koppelen aan een andere vraagt om een keuze. other := startBlueGit(t) code, raw := b3.Admin("POST", "/connect", map[string]any{"url": other.URL, "key": other.NewKey()}) if code != 409 || !strings.Contains(string(raw), `"choices":["wipe","restore"]`) { t.Fatalf("tweede BlueGit: %d %s", code, raw) } }