| 1 | //go:build integration |
| 2 | |
| 3 | package integration |
| 4 | |
| 5 | import ( |
| 6 | "encoding/json" |
| 7 | "io" |
| 8 | "net/http" |
| 9 | "net/http/cookiejar" |
| 10 | "net/url" |
| 11 | "os" |
| 12 | "path/filepath" |
| 13 | "sort" |
| 14 | "strings" |
| 15 | "testing" |
| 16 | "time" |
| 17 | ) |
| 18 | |
| 19 | // webUI is een browser op de webinterface van de backup server. |
| 20 | type webUI struct { |
| 21 | t *testing.T |
| 22 | b *Backup |
| 23 | hc *http.Client |
| 24 | csrf string |
| 25 | } |
| 26 | |
| 27 | func openUI(t *testing.T, b *Backup) *webUI { |
| 28 | t.Helper() |
| 29 | jar, _ := cookiejar.New(nil) |
| 30 | u := &webUI{t: t, b: b, hc: &http.Client{Jar: jar, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}} |
| 31 | res, err := u.hc.Get(b.URL + "/") |
| 32 | if err != nil { |
| 33 | t.Fatal(err) |
| 34 | } |
| 35 | res.Body.Close() |
| 36 | if res.StatusCode != 303 || res.Header.Get("Location") != "/login" { |
| 37 | t.Fatalf("zonder login: %d %s", res.StatusCode, res.Header.Get("Location")) |
| 38 | } |
| 39 | res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {"bba_fout"}}) |
| 40 | res.Body.Close() |
| 41 | if res.Header.Get("Location") != "/login?fout=1" { |
| 42 | t.Fatal("fout token geaccepteerd") |
| 43 | } |
| 44 | res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {b.Srv.AdminToken()}}) |
| 45 | res.Body.Close() |
| 46 | if res.StatusCode != 303 || res.Header.Get("Location") != "/" { |
| 47 | t.Fatalf("login: %d", res.StatusCode) |
| 48 | } |
| 49 | u.Page() |
| 50 | return u |
| 51 | } |
| 52 | |
| 53 | // Page haalt de hoofdpagina op en onthoudt het CSRF-token. |
| 54 | func (u *webUI) Page() string { |
| 55 | u.t.Helper() |
| 56 | res, err := u.hc.Get(u.b.URL + "/") |
| 57 | if err != nil { |
| 58 | u.t.Fatal(err) |
| 59 | } |
| 60 | b, _ := io.ReadAll(res.Body) |
| 61 | res.Body.Close() |
| 62 | if res.StatusCode != 200 { |
| 63 | u.t.Fatalf("pagina: %d", res.StatusCode) |
| 64 | } |
| 65 | u.csrf = between(string(b), `name="csrf" value="`, `"`) |
| 66 | return string(b) |
| 67 | } |
| 68 | |
| 69 | // Act verstuurt het formulier van een actie en geeft de melding erna. |
| 70 | func (u *webUI) Act(name string, form url.Values) string { |
| 71 | u.t.Helper() |
| 72 | if form == nil { |
| 73 | form = url.Values{} |
| 74 | } |
| 75 | form.Set("csrf", u.csrf) |
| 76 | res, err := u.hc.PostForm(u.b.URL+"/ui/act/"+name, form) |
| 77 | if err != nil { |
| 78 | u.t.Fatal(err) |
| 79 | } |
| 80 | res.Body.Close() |
| 81 | if res.StatusCode != 303 { |
| 82 | u.t.Fatalf("%s: %d", name, res.StatusCode) |
| 83 | } |
| 84 | return between(u.Page(), `role="status">`, `</div>`) |
| 85 | } |
| 86 | |
| 87 | func actionNames(t *testing.T, b *Backup, withGet bool) []string { |
| 88 | t.Helper() |
| 89 | code, raw := b.Admin("GET", "/actions", nil) |
| 90 | if code != 200 { |
| 91 | t.Fatalf("actions: %d", code) |
| 92 | } |
| 93 | var out struct { |
| 94 | Actions []struct{ Name, Method string } |
| 95 | } |
| 96 | _ = json.Unmarshal(raw, &out) |
| 97 | var names []string |
| 98 | for _, a := range out.Actions { |
| 99 | if withGet || a.Method != "GET" { |
| 100 | names = append(names, a.Name) |
| 101 | } |
| 102 | } |
| 103 | sort.Strings(names) |
| 104 | return names |
| 105 | } |
| 106 | |
| 107 | func requireAll(t *testing.T, what string, want []string, done map[string]bool) { |
| 108 | t.Helper() |
| 109 | for _, n := range want { |
| 110 | if !done[n] { |
| 111 | t.Errorf("%s: actie %s niet getest", what, n) |
| 112 | } |
| 113 | } |
| 114 | } |
| 115 | |
| 116 | // Feature: alles is in te stellen en te bedienen via de webinterface (poort 8080 standaard). |
| 117 | func TestWebUIConfiguresAndOperatesEverything(t *testing.T) { |
| 118 | g := startBlueGit(t) |
| 119 | g.Project("Alpha", "README.md", "v1") |
| 120 | b := startBackup(t, nil) |
| 121 | u := openUI(t, b) |
| 122 | done := map[string]bool{} |
| 123 | |
| 124 | // Instellingen. |
| 125 | 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}}) |
| 126 | if !strings.Contains(msg, "opgeslagen") { |
| 127 | t.Fatalf("instellingen: %q", msg) |
| 128 | } |
| 129 | done["config.update"] = true |
| 130 | st := b.Status() |
| 131 | if st.Interval != "3h0m0s" || st.RetentionDays != 5 || st.RateLimitKiB != 2048 { |
| 132 | t.Fatalf("niet toegepast: %+v", st) |
| 133 | } |
| 134 | if msg := u.Act("config.update", url.Values{"archive_interval": {"nooit"}}); !strings.Contains(msg, "mislukt") { |
| 135 | t.Fatalf("ongeldige waarde: %q", msg) |
| 136 | } |
| 137 | u.Act("config.update", url.Values{"rate_limit_kib": {"0"}}) |
| 138 | |
| 139 | // Koppelen met een key uit BlueGit. |
| 140 | if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {"bgbk_fout"}, "on_conflict": {""}}); !strings.Contains(msg, "mislukt") { |
| 141 | t.Fatalf("verkeerde key: %q", msg) |
| 142 | } |
| 143 | if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {g.NewKey()}, "on_conflict": {""}}); !strings.Contains(msg, "gelukt") { |
| 144 | t.Fatalf("koppelen: %q", msg) |
| 145 | } |
| 146 | done["connect"] = true |
| 147 | if st := g.BackupStatus(); !st.Connected || st.ServerURL != b.URL { |
| 148 | t.Fatalf("BlueGit ziet de koppeling niet: %+v", st) |
| 149 | } |
| 150 | |
| 151 | // Sync, archief, opruimen. |
| 152 | if msg := u.Act("sync", nil); !strings.Contains(msg, "gestart") { |
| 153 | t.Fatalf("sync: %q", msg) |
| 154 | } |
| 155 | done["sync"] = true |
| 156 | Eventually(t, 15*time.Second, "kopie na sync uit de webinterface", func() bool { |
| 157 | _, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD")) |
| 158 | return err == nil |
| 159 | }) |
| 160 | b.Sync() |
| 161 | if msg := u.Act("archive", nil); !strings.Contains(msg, "Archief gemaakt") { |
| 162 | t.Fatalf("archief: %q", msg) |
| 163 | } |
| 164 | done["archive"] = true |
| 165 | name := b.Archives()[0] |
| 166 | page := u.Page() |
| 167 | if !strings.Contains(page, name) || !strings.Contains(page, "gekoppeld") { |
| 168 | t.Fatal("pagina toont het archief of de koppeling niet") |
| 169 | } |
| 170 | // Download vanuit de pagina. |
| 171 | res, err := u.hc.Get(b.URL + "/api/v1/admin/archives/" + name + "/download") |
| 172 | if err != nil { |
| 173 | t.Fatal(err) |
| 174 | } |
| 175 | got, _ := io.ReadAll(res.Body) |
| 176 | res.Body.Close() |
| 177 | want, _ := os.ReadFile(filepath.Join(b.Dir, "archives", name)) |
| 178 | if res.StatusCode != 200 || len(got) == 0 || string(got) != string(want) { |
| 179 | t.Fatalf("download: %d %d bytes", res.StatusCode, len(got)) |
| 180 | } |
| 181 | if msg := u.Act("prune", nil); !strings.Contains(msg, "Opgeruimd") { |
| 182 | t.Fatalf("opruimen: %q", msg) |
| 183 | } |
| 184 | done["prune"] = true |
| 185 | |
| 186 | // Rollback vanuit de webinterface: zonder vinkje niets, daarna echt. |
| 187 | g.Commit("alpha", "README.md", "v2", "update") |
| 188 | b.Sync() |
| 189 | if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}}); !strings.Contains(msg, "Vink aan") { |
| 190 | t.Fatalf("zonder vinkje: %q", msg) |
| 191 | } |
| 192 | if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {"verkeerd"}, "understood": {"1"}}); !strings.Contains(msg, "mislukt") { |
| 193 | t.Fatalf("verkeerde bevestiging: %q", msg) |
| 194 | } |
| 195 | if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}, "understood": {"1"}}); !strings.Contains(msg, "Rollback gestart") { |
| 196 | t.Fatalf("rollback: %q", msg) |
| 197 | } |
| 198 | done["rollback"] = true |
| 199 | Eventually(t, 60*time.Second, "rollback klaar", func() bool { |
| 200 | st := b.Status().Rollback |
| 201 | if st.State == "failed" { |
| 202 | t.Fatalf("rollback mislukt: %s", st.Error) |
| 203 | } |
| 204 | return st.State == "done" |
| 205 | }) |
| 206 | g.WaitUp(30 * time.Second) |
| 207 | if _, s := g.File("alpha", "README.md"); s != "v1" { |
| 208 | t.Fatalf("README na rollback: %q", s) |
| 209 | } |
| 210 | |
| 211 | // Archief verwijderen en ontkoppelen. |
| 212 | if msg := u.Act("archive.delete", url.Values{"name": {name}}); !strings.Contains(msg, "gelukt") { |
| 213 | t.Fatalf("verwijderen: %q", msg) |
| 214 | } |
| 215 | done["archive.delete"] = true |
| 216 | if len(b.Archives()) != 0 { |
| 217 | t.Fatal("archief staat er nog") |
| 218 | } |
| 219 | if msg := u.Act("disconnect", nil); !strings.Contains(msg, "gelukt") { |
| 220 | t.Fatalf("ontkoppelen: %q", msg) |
| 221 | } |
| 222 | done["disconnect"] = true |
| 223 | if b.Status().Connected { |
| 224 | t.Fatal("nog gekoppeld") |
| 225 | } |
| 226 | requireAll(t, "webinterface", actionNames(t, b, false), done) |
| 227 | } |
| 228 | |
| 229 | // Feature: de API kan alles wat de webinterface kan, en andersom. |
| 230 | func TestAPIDoesEverythingTheUICan(t *testing.T) { |
| 231 | g := startBlueGit(t) |
| 232 | g.Project("Alpha", "README.md", "v1") |
| 233 | b := startBackup(t, nil) |
| 234 | done := map[string]bool{} |
| 235 | call := func(name, method, path string, in any, want int) []byte { |
| 236 | t.Helper() |
| 237 | code, raw := b.Admin(method, path, in) |
| 238 | if code != want { |
| 239 | t.Fatalf("%s %s: %d %s", method, path, code, raw) |
| 240 | } |
| 241 | done[name] = true |
| 242 | return raw |
| 243 | } |
| 244 | call("status", "GET", "/status", nil, 200) |
| 245 | call("actions", "GET", "/actions", nil, 200) |
| 246 | raw := call("config", "GET", "/config", nil, 200) |
| 247 | if !strings.Contains(string(raw), `"key":"listen"`) { |
| 248 | t.Fatalf("config: %s", raw) |
| 249 | } |
| 250 | call("config.update", "PUT", "/config", map[string]any{"retention_days": 7, "archive_interval": "6h"}, 200) |
| 251 | if b.Status().RetentionDays != 7 { |
| 252 | t.Fatal("config niet toegepast") |
| 253 | } |
| 254 | call("connect", "POST", "/connect", map[string]any{"url": g.URL, "key": g.NewKey()}, 200) |
| 255 | call("sync", "POST", "/sync", nil, 200) |
| 256 | raw = call("archive", "POST", "/archive", nil, 201) |
| 257 | var a struct{ Name string } |
| 258 | _ = json.Unmarshal(raw, &a) |
| 259 | raw = call("archives", "GET", "/archives", nil, 200) |
| 260 | if !strings.Contains(string(raw), a.Name) { |
| 261 | t.Fatalf("archives: %s", raw) |
| 262 | } |
| 263 | raw = call("archive.download", "GET", "/archives/"+a.Name+"/download", nil, 200) |
| 264 | if len(raw) < 100 || raw[0] != 0x1f || raw[1] != 0x8b { |
| 265 | t.Fatal("download is geen gzip") |
| 266 | } |
| 267 | call("prune", "POST", "/prune", nil, 200) |
| 268 | call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name}, 400) // bevestiging ontbreekt |
| 269 | call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name, "confirm": a.Name}, 202) |
| 270 | Eventually(t, 60*time.Second, "rollback klaar", func() bool { return b.Status().Rollback.State == "done" }) |
| 271 | g.WaitUp(30 * time.Second) |
| 272 | call("archive.delete", "DELETE", "/archives/"+a.Name, nil, 200) |
| 273 | call("disconnect", "POST", "/disconnect", nil, 200) |
| 274 | requireAll(t, "API", actionNames(t, b, true), done) |
| 275 | } |
| 276 | |
| 277 | // Feature: vanuit BlueGit is de backup server te bedienen zoals in zijn eigen webinterface. |
| 278 | func TestBlueGitControlsBackupServer(t *testing.T) { |
| 279 | g := startBlueGit(t) |
| 280 | g.Project("Alpha", "README.md", "v1") |
| 281 | b := startBackup(t, nil) |
| 282 | b.Connect(g, g.NewKey()) |
| 283 | b.Sync() |
| 284 | |
| 285 | // Instellingen lezen en wijzigen via de BlueGit-API. |
| 286 | st := g.BackupStatus() |
| 287 | if len(st.Config.Fields) == 0 { |
| 288 | t.Fatalf("BlueGit ziet geen instellingen: %+v", st) |
| 289 | } |
| 290 | if code, raw := g.Action(g.Server, "config.update", map[string]any{"retention_days": "11", "archive_interval": "5h"}); code != 200 { |
| 291 | t.Fatalf("config via BlueGit: %d %s", code, raw) |
| 292 | } |
| 293 | if s := b.Status(); s.RetentionDays != 11 || s.Interval != "5h0m0s" { |
| 294 | t.Fatalf("niet toegepast: %+v", s) |
| 295 | } |
| 296 | // Archief maken, synchroniseren en verwijderen via BlueGit. |
| 297 | if code, raw := g.Action(g.Server, "archive", nil); code != 201 { |
| 298 | t.Fatalf("archief via BlueGit: %d %s", code, raw) |
| 299 | } |
| 300 | name := b.Archives()[0] |
| 301 | g.Commit("alpha", "x.txt", "x", "create") |
| 302 | before := b.Status().Syncs |
| 303 | if code, raw := g.Action(g.Server, "sync", nil); code != 202 { |
| 304 | t.Fatalf("sync via BlueGit: %d %s", code, raw) |
| 305 | } |
| 306 | Eventually(t, 15*time.Second, "sync gestart door BlueGit", func() bool { return b.Status().Syncs > before }) |
| 307 | if code, raw := g.Action(g.Server, "archive.delete", map[string]any{"name": name}); code != 200 { |
| 308 | t.Fatalf("verwijderen via BlueGit: %d %s", code, raw) |
| 309 | } |
| 310 | if len(b.Archives()) != 0 { |
| 311 | t.Fatal("archief niet verwijderd") |
| 312 | } |
| 313 | // Koppelen kan BlueGit niet namens de backup server (alleen lokaal). |
| 314 | if code, _ := g.Action(g.Server, "connect", map[string]any{"url": g.URL, "key": "bgbk_x"}); code != 404 { |
| 315 | t.Fatalf("connect via BlueGit: %d", code) |
| 316 | } |
| 317 | |
| 318 | // Dezelfde bediening in de BlueGit-webinterface. |
| 319 | hc := g.Session() |
| 320 | hc.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse } |
| 321 | res, err := hc.Get(g.URL + "/admin/backup/s/" + g.Server) |
| 322 | if err != nil { |
| 323 | t.Fatal(err) |
| 324 | } |
| 325 | page, _ := io.ReadAll(res.Body) |
| 326 | res.Body.Close() |
| 327 | for _, want := range []string{`name="retention_days" value="11"`, "/act/sync", "/act/archive", "/act/prune", "/act/config.update"} { |
| 328 | if !strings.Contains(string(page), want) { |
| 329 | t.Fatalf("BlueGit-pagina mist %q", want) |
| 330 | } |
| 331 | } |
| 332 | csrf := between(string(page), `name="csrf" value="`, `"`) |
| 333 | res, err = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"12"}}) |
| 334 | if err != nil { |
| 335 | t.Fatal(err) |
| 336 | } |
| 337 | res.Body.Close() |
| 338 | if b.Status().RetentionDays != 12 { |
| 339 | t.Fatalf("formulier in BlueGit: %d", b.Status().RetentionDays) |
| 340 | } |
| 341 | res, _ = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/archive", url.Values{"csrf": {csrf}}) |
| 342 | res.Body.Close() |
| 343 | if len(b.Archives()) != 1 { |
| 344 | t.Fatal("archief via het BlueGit-formulier ontbreekt") |
| 345 | } |
| 346 | } |
| 347 | |
| 348 | // Feature: één BlueGit kan meerdere backup servers hebben; elke backup server hoort bij één BlueGit. |
| 349 | func TestMultipleBackupServers(t *testing.T) { |
| 350 | g := startBlueGit(t) |
| 351 | g.Project("Alpha", "README.md", "v1") |
| 352 | b1, b2 := startBackup(t, nil), startBackup(t, nil) |
| 353 | id1, key1 := g.AddServer("nas") |
| 354 | id2, key2 := g.AddServer("offsite") |
| 355 | b1.Connect(g, key1) |
| 356 | b2.Connect(g, key2) |
| 357 | for _, id := range []string{id1, id2} { |
| 358 | if st := g.ServerStatus(id); !st.Connected || st.RemoteError != "" { |
| 359 | t.Fatalf("%s: %+v", id, st) |
| 360 | } |
| 361 | } |
| 362 | if g.ServerStatus(id1).ServerURL != b1.URL || g.ServerStatus(id2).ServerURL != b2.URL { |
| 363 | t.Fatal("adressen verwisseld") |
| 364 | } |
| 365 | // Elke wijziging komt bij beide aan. |
| 366 | g.Commit("alpha", "beide.txt", "x", "create") |
| 367 | for _, b := range []*Backup{b1, b2} { |
| 368 | Eventually(t, 15*time.Second, "melding bij "+b.URL, func() bool { |
| 369 | return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet beide.txt") |
| 370 | }) |
| 371 | } |
| 372 | // Een key hoort bij één server: key1 werkt niet voor de tweede server. |
| 373 | b3 := startBackup(t, nil) |
| 374 | b3.Connect(g, key1) // dezelfde key: BlueGit verplaatst de koppeling van nas naar b3 |
| 375 | if st := g.ServerStatus(id1); st.ServerURL != b3.URL { |
| 376 | t.Fatalf("koppeling niet verplaatst: %+v", st) |
| 377 | } |
| 378 | // Verwijderen in BlueGit ontkoppelt alleen die server. |
| 379 | if code, raw := g.API("DELETE", "/admin/backup/servers/"+id2, nil); code != 204 { |
| 380 | t.Fatalf("verwijderen: %d %s", code, raw) |
| 381 | } |
| 382 | if b2.Status().Connected { |
| 383 | t.Fatal("verwijderde backup server is nog gekoppeld") |
| 384 | } |
| 385 | g.Commit("alpha", "daarna.txt", "x", "create") |
| 386 | Eventually(t, 15*time.Second, "overgebleven server krijgt meldingen", func() bool { |
| 387 | return strings.Contains(gitLog(t, b3.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt") |
| 388 | }) |
| 389 | time.Sleep(time.Second) |
| 390 | if strings.Contains(gitLog(t, b2.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt") { |
| 391 | t.Fatal("verwijderde server synchroniseert nog") |
| 392 | } |
| 393 | // Een backup server hoort bij één BlueGit: koppelen aan een andere vraagt om een keuze. |
| 394 | other := startBlueGit(t) |
| 395 | code, raw := b3.Admin("POST", "/connect", map[string]any{"url": other.URL, "key": other.NewKey()}) |
| 396 | if code != 409 || !strings.Contains(string(raw), `"choices":["wipe","restore"]`) { |
| 397 | t.Fatalf("tweede BlueGit: %d %s", code, raw) |
| 398 | } |
| 399 | } |