BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / integration / ui_test.go

ui_test.go

ui_test.go 13.7 KiB Download Raw
1//go:build integration
2
3package integration
4
5import (
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.
20type webUI struct {
21 t *testing.T
22 b *Backup
23 hc *http.Client
24 csrf string
25}
26
27func 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.
54func (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.
70func (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
87func 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
107func 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).
117func 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.
230func 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.
278func 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.
349func 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}