BlueGit

timfa bluegit

Files

bluegit / internal / server / backup_test.go

backup_test.go

backup_test.go 20.9 KiB Download Raw
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "io"
7 "net/http"
8 "net/http/httptest"
9 "net/url"
10 "os"
11 "path/filepath"
12 "strconv"
13 "strings"
14 "sync"
15 "testing"
16 "time"
17
18 "gitlab.com/Timfa/bluegit/internal/auth"
19 "gitlab.com/Timfa/bluegit/internal/backup"
20 "gitlab.com/Timfa/bluegit/internal/config"
21 "gitlab.com/Timfa/bluegit/internal/store"
22)
23
24type backupEnv struct {
25 srv *Server
26 st *store.Store
27 base string
28 tim store.User
29 tok string
30}
31
32func newBackupEnv(t *testing.T) *backupEnv {
33 t.Helper()
34 stateDir, storage := t.TempDir(), t.TempDir()
35 st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32())
36 if err != nil {
37 t.Fatal(err)
38 }
39 t.Cleanup(func() { _ = st.Close() })
40 _ = os.WriteFile(filepath.Join(stateDir, "secret.key"), bytes32(), 0o600)
41 cfg := config.Config{
42 Listen: "127.0.0.1:0", StoragePath: storage, StatePath: stateDir,
43 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
44 Git: config.Git{Binary: "git", DefaultBranch: "master"},
45 }
46 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
47 ts := httptest.NewServer(srv.Handler())
48 t.Cleanup(ts.Close)
49 srv.Cfg.BaseURL = ts.URL
50 tim, err := st.UpsertUser(context.Background(), 1, "tim", "", false)
51 if err != nil {
52 t.Fatal(err)
53 }
54 if !tim.InstanceAdmin {
55 t.Skip("eerste gebruiker is geen beheerder")
56 }
57 _ = os.MkdirAll(filepath.Join(storage, "repos", "tim", "app.git"), 0o755)
58 _ = os.WriteFile(filepath.Join(storage, "repos", "tim", "app.git", "HEAD"), []byte("ref: refs/heads/master\n"), 0o644)
59 srv.backupInit()
60 srv.backupNote.Delay = 20 * time.Millisecond
61 return &backupEnv{srv: srv, st: st, base: ts.URL, tim: tim, tok: issue(t, st, tim.ID, "api")}
62}
63
64func keyed(t *testing.T, method, u, key string, body io.Reader) (int, []byte) {
65 t.Helper()
66 req, _ := http.NewRequest(method, u, body)
67 if key != "" {
68 req.Header.Set("Authorization", "Bearer "+key)
69 }
70 res, err := http.DefaultClient.Do(req)
71 if err != nil {
72 t.Fatal(err)
73 }
74 defer res.Body.Close()
75 b, _ := io.ReadAll(res.Body)
76 return res.StatusCode, b
77}
78
79// fakeBackup speelt de backup server: hij controleert elke handtekening.
80type fakeBackup struct {
81 mu sync.Mutex
82 secret string
83 notifies int
84 rollback []string
85 calls []string
86 bodies map[string]string
87 badSig int
88 ts *httptest.Server
89}
90
91func newFakeBackup(t *testing.T) *fakeBackup {
92 f := &fakeBackup{}
93 f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
94 body, _ := io.ReadAll(r.Body)
95 f.mu.Lock()
96 defer f.mu.Unlock()
97 if err := backup.Verify(r, f.secret, body, time.Now()); err != nil {
98 f.badSig++
99 http.Error(w, `{"error":"sig"}`, 401)
100 return
101 }
102 switch r.URL.Path {
103 case "/api/v1/notify":
104 f.notifies++
105 w.WriteHeader(204)
106 case "/api/v1/archives":
107 _ = json.NewEncoder(w).Encode(map[string]any{"archives": []backup.Archive{{Name: "bluegit-20261115-120000.tar.gz", CreatedAt: time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC), Size: 3 << 20}}})
108 case "/api/v1/status":
109 _, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`))
110 case "/api/v1/rollback":
111 var in struct{ Archive string }
112 _ = json.Unmarshal(body, &in)
113 f.rollback = append(f.rollback, in.Archive)
114 w.WriteHeader(202)
115 case "/api/v1/admin/actions":
116 _, _ = w.Write([]byte(`{"actions":[
117 {"name":"status","method":"GET","path":"/api/v1/admin/status","bluegit":true},
118 {"name":"config","method":"GET","path":"/api/v1/admin/config","bluegit":true},
119 {"name":"config.update","method":"PUT","path":"/api/v1/admin/config","bluegit":true},
120 {"name":"sync","method":"POST","path":"/api/v1/admin/sync","bluegit":true},
121 {"name":"archive.delete","method":"DELETE","path":"/api/v1/admin/archives/{name}","bluegit":true,"params":["name"]},
122 {"name":"archive.download","method":"GET","path":"/api/v1/admin/archives/{name}/download","params":["name"]},
123 {"name":"rollback","method":"POST","path":"/api/v1/admin/rollback","bluegit":true},
124 {"name":"disconnect","method":"POST","path":"/api/v1/admin/disconnect","bluegit":true}]}`))
125 case "/api/v1/admin/config":
126 if r.Method == "PUT" {
127 f.calls = append(f.calls, "PUT config")
128 if f.bodies == nil {
129 f.bodies = map[string]string{}
130 }
131 f.bodies["config"] = string(body)
132 }
133 _, _ = w.Write([]byte(`{"fields":[{"key":"archive_interval","label":"Archiefinterval","kind":"duration","value":"24h"},{"key":"retention_days","label":"Bewaartermijn","kind":"int","value":"30"}],"data_dir":"/var/lib/bluegit-backup"}`))
134 case "/api/v1/admin/rollback":
135 var in struct{ Archive, Confirm string }
136 _ = json.Unmarshal(body, &in)
137 if in.Confirm != in.Archive {
138 http.Error(w, `{"error":"confirm"}`, 400)
139 return
140 }
141 f.rollback = append(f.rollback, in.Archive)
142 w.WriteHeader(202)
143 default:
144 if r.URL.Path == "/api/v1/admin/sync" || r.URL.Path == "/api/v1/admin/disconnect" || strings.HasPrefix(r.URL.Path, "/api/v1/admin/archives/") {
145 f.calls = append(f.calls, r.Method+" "+r.URL.Path+" "+string(body))
146 _, _ = w.Write([]byte(`{}`))
147 return
148 }
149 http.NotFound(w, r)
150 }
151 }))
152 t.Cleanup(f.ts.Close)
153 return f
154}
155
156type addedServer struct {
157 ID string `json:"id"`
158 Key string `json:"key"`
159}
160
161func addBackupServer(t *testing.T, e *backupEnv, name string) addedServer {
162 t.Helper()
163 code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers", map[string]any{"name": name})
164 if code != 201 {
165 t.Fatalf("server toevoegen: %d %s", code, b)
166 }
167 var a addedServer
168 _ = json.Unmarshal(b, &a)
169 if !strings.HasPrefix(a.Key, "bgbk_") || a.ID == "" {
170 t.Fatalf("%s", b)
171 }
172 return a
173}
174
175func TestBackupKeyAndKeyedAPI(t *testing.T) {
176 e := newBackupEnv(t)
177 // Zonder key: 401. Met een gewoon toegangstoken: ook 401.
178 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 {
179 t.Fatalf("zonder key: %d", code)
180 }
181 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 {
182 t.Fatalf("bg_-token: %d", code)
183 }
184 // Alleen een beheerder maakt een backup server.
185 bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
186 if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/servers", map[string]any{"name": "x"}); code != 403 {
187 t.Fatalf("bob maakt server: %d", code)
188 }
189 k := addBackupServer(t, e, "nas")
190 code, b := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil)
191 var info struct {
192 InstanceID string `json:"instance_id"`
193 Name string `json:"name"`
194 }
195 _ = json.Unmarshal(b, &info)
196 if code != 200 || info.InstanceID == "" || info.Name != "nas" {
197 t.Fatalf("info: %d %s", code, b)
198 }
199 code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil)
200 var m backup.Manifest
201 _ = json.Unmarshal(b, &m)
202 if code != 200 || m.Instance != info.InstanceID {
203 t.Fatalf("manifest: %d %.300s", code, b)
204 }
205 have := map[string]bool{}
206 for _, f := range m.Files {
207 have[f.Path] = true
208 }
209 for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} {
210 if !have[want] {
211 t.Fatalf("manifest mist %s: %v", want, have)
212 }
213 }
214 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil)
215 if code != 200 || string(b) != "ref: refs/heads/master\n" {
216 t.Fatalf("file: %d %q", code, b)
217 }
218 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil)
219 if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") {
220 t.Fatalf("db-kopie: %d %.20q", code, b)
221 }
222 for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} {
223 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 {
224 t.Fatalf("%s: %d", bad, code)
225 }
226 }
227 // Een tweede server met een eigen key; nieuwe key voor de eerste.
228 k2 := addBackupServer(t, e, "offsite")
229 code, b = rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+k.ID+"/key", nil)
230 var rot addedServer
231 _ = json.Unmarshal(b, &rot)
232 if code != 201 || rot.Key == k.Key {
233 t.Fatalf("nieuwe key: %d %s", code, b)
234 }
235 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 {
236 t.Fatalf("oude key werkt nog: %d", code)
237 }
238 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 200 {
239 t.Fatalf("nieuwe key: %d", code)
240 }
241 if code, b := rapi(t, e.base, e.tok, "PUT", "/admin/backup/servers/"+k2.ID, map[string]any{"name": "Offsite 2"}); code != 200 || !strings.Contains(string(b), "Offsite 2") {
242 t.Fatalf("hernoemen: %d %s", code, b)
243 }
244 // Verwijderen: die key werkt niet meer, de andere wel.
245 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+k.ID, nil); code != 204 {
246 t.Fatalf("verwijderen: %d", code)
247 }
248 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 401 {
249 t.Fatalf("na verwijderen: %d", code)
250 }
251 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k2.Key, nil); code != 200 {
252 t.Fatalf("andere server: %d", code)
253 }
254 if code, _ := rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/onbekend", nil); code != 404 {
255 t.Fatalf("onbekend: %d", code)
256 }
257}
258
259func TestBackupMultipleServersAndControl(t *testing.T) {
260 e := newBackupEnv(t)
261 fa, fb := newFakeBackup(t), newFakeBackup(t)
262 ka, kb := addBackupServer(t, e, "nas"), addBackupServer(t, e, "offsite")
263 fa.secret, fb.secret = backup.SigningSecret(ka.Key), backup.SigningSecret(kb.Key)
264 for _, c := range []struct {
265 key, url string
266 }{{ka.Key, fa.ts.URL}, {kb.Key, fb.ts.URL}} {
267 code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", c.key, strings.NewReader(`{"server_url":"`+c.url+`","server_id":"s"}`))
268 if code != 200 {
269 t.Fatalf("connect: %d %s", code, b)
270 }
271 }
272 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", ka.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 {
273 t.Fatalf("ftp-adres: %d", code)
274 }
275
276 // Een schrijvende actie geeft een ondertekende melding aan beide.
277 if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 {
278 t.Fatalf("project: %d %s", code, b)
279 }
280 deadline := time.Now().Add(5 * time.Second)
281 for {
282 fa.mu.Lock()
283 na := fa.notifies
284 fa.mu.Unlock()
285 fb.mu.Lock()
286 nb := fb.notifies
287 fb.mu.Unlock()
288 if na > 0 && nb > 0 {
289 break
290 }
291 if time.Now().After(deadline) {
292 t.Fatalf("meldingen: %d en %d", na, nb)
293 }
294 time.Sleep(20 * time.Millisecond)
295 }
296
297 // Lijst via de API en op de pagina.
298 code, b := rapi(t, e.base, e.tok, "GET", "/admin/backup", nil)
299 if code != 200 || strings.Count(string(b), `"connected":true`) != 2 {
300 t.Fatalf("admin backup: %d %s", code, b)
301 }
302 code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/"+ka.ID, nil)
303 if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"retention_days"`) {
304 t.Fatalf("server: %d %s", code, b)
305 }
306 tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID)
307 res, _ := tc.Get(e.base + "/admin/backup")
308 page := body(t, res)
309 for _, want := range []string{"nas", "offsite", `/admin/backup/s/` + ka.ID, `/admin/backup/s/` + kb.ID, `href="/admin/backup"`} {
310 if !strings.Contains(page, want) {
311 t.Fatalf("lijst mist %s: %.600s", want, page)
312 }
313 }
314 res, _ = tc.Get(e.base + "/admin/backup/s/" + ka.ID)
315 page = body(t, res)
316 for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`,
317 `act/config.update`, `name="retention_days" value="30"`, `act/sync`, `act/archive.delete`} {
318 if !strings.Contains(page, want) {
319 t.Fatalf("pagina mist %s: %.600s", want, page)
320 }
321 }
322
323 // Instellingen en sync vanuit BlueGit (formulier en API).
324 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"9"}})
325 res.Body.Close()
326 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/sync", nil); code != 200 {
327 t.Fatalf("sync: %d %s", code, b)
328 }
329 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.download", map[string]any{"name": "x"}); code != 404 {
330 t.Fatalf("niet-BlueGit-actie: %d", code)
331 }
332 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.delete", map[string]any{"name": "bluegit-20261115-120000.tar.gz"}); code != 200 {
333 t.Fatalf("archief verwijderen: %d", code)
334 }
335 fa.mu.Lock()
336 if fa.bodies["config"] != `{"retention_days":"9"}` {
337 t.Fatalf("config %q", fa.bodies["config"])
338 }
339 calls := strings.Join(fa.calls, "|")
340 fa.mu.Unlock()
341 if !strings.Contains(calls, `POST /api/v1/admin/sync {"wait":"false"}`) || !strings.Contains(calls, "DELETE /api/v1/admin/archives/bluegit-20261115-120000.tar.gz") {
342 t.Fatalf("calls %s", calls)
343 }
344
345 // Rollback: zonder vinkje niets, verkeerde bevestiging 400, dan goed.
346 arch := "bluegit-20261115-120000.tar.gz"
347 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}})
348 res.Body.Close()
349 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": "ja"}); code != 400 {
350 t.Fatalf("verkeerde bevestiging: %d", code)
351 }
352 fa.mu.Lock()
353 if len(fa.rollback) != 0 {
354 t.Fatal("rollback zonder vinkje of bevestiging")
355 }
356 fa.mu.Unlock()
357 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}, "understood": {"1"}})
358 res.Body.Close()
359 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": arch}); code != 202 {
360 t.Fatalf("rollback api: %d %s", code, b)
361 }
362 // Verwijderen laat de backup server ontkoppelen.
363 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+kb.ID, nil); code != 204 {
364 t.Fatalf("verwijderen: %d", code)
365 }
366 fb.mu.Lock()
367 if !strings.Contains(strings.Join(fb.calls, "|"), "POST /api/v1/admin/disconnect") {
368 t.Fatalf("geen disconnect: %v", fb.calls)
369 }
370 fb.mu.Unlock()
371 fa.mu.Lock()
372 defer fa.mu.Unlock()
373 if len(fa.rollback) != 2 || fa.badSig != 0 {
374 t.Fatalf("rollbacks %v, foute handtekeningen %d", fa.rollback, fa.badSig)
375 }
376}
377
378func TestBackupRestoreStagesAndRestarts(t *testing.T) {
379 e := newBackupEnv(t)
380 restarted := make(chan struct{}, 1)
381 e.srv.RequestRestart = func() { restarted <- struct{}{} }
382 k := addBackupServer(t, e, "nas")
383 // Ongeldig archief: 400, niets klaargezet.
384 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 {
385 t.Fatalf("ongeldig: %d", code)
386 }
387 if backup.HasPending(e.srv.StateDir) {
388 t.Fatal("READY na fout")
389 }
390 // Een archief uit het eigen manifest terugsturen.
391 tarball := buildTarFromInstance(t, e, k.Key)
392 code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball))
393 if code != 202 {
394 t.Fatalf("restore: %d %s", code, b)
395 }
396 select {
397 case <-restarted:
398 case <-time.After(3 * time.Second):
399 t.Fatal("geen herstart")
400 }
401 if !backup.HasPending(e.srv.StateDir) {
402 t.Fatal("geen READY")
403 }
404 restoreBusy.Store(false)
405}
406
407func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string {
408 t.Helper()
409 _, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil)
410 var m backup.Manifest
411 _ = json.Unmarshal(b, &m)
412 var sb strings.Builder
413 files := map[string]string{}
414 for _, f := range m.Files {
415 _, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil)
416 files[f.Path] = string(data)
417 }
418 writeTarGz(t, &sb, files)
419 return sb.String()
420}
421
422// Feature: beheerders zien bovenaan elke pagina een banner als een backup
423// server niet bij deze BlueGit past; BlueGit weigert dan gegevens uit te
424// wisselen (426), maar info en connect blijven werken.
425func TestBackupCompatBanner(t *testing.T) {
426 e := newBackupEnv(t)
427 k := addBackupServer(t, e, "nas")
428 call := func(method, path, proto, min string, body io.Reader) (int, []byte, http.Header) {
429 req, _ := http.NewRequest(method, e.base+path, body)
430 req.Header.Set("Authorization", "Bearer "+k.Key)
431 if proto != "" {
432 req.Header.Set(backup.HeaderBackupProtocol, proto)
433 req.Header.Set(backup.HeaderBackupMinProtocol, min)
434 req.Header.Set(backup.HeaderBackupVersion, "v9.9.9")
435 }
436 res, err := http.DefaultClient.Do(req)
437 if err != nil {
438 t.Fatal(err)
439 }
440 defer res.Body.Close()
441 b, _ := io.ReadAll(res.Body)
442 return res.StatusCode, b, res.Header
443 }
444 // Een backup server zonder koppen (v0.1.0) spreekt protocol 1: past.
445 if code, b, h := call("POST", "/api/v1/backup/connect", "", "", strings.NewReader(`{"server_url":"http://127.0.0.1:9","server_id":"s"}`)); code != 200 || h.Get(backup.HeaderBlueGitProtocol) != strconv.Itoa(backup.Protocol()) {
446 t.Fatalf("connect: %d %s %v", code, b, h)
447 }
448 if code, _, _ := call("GET", "/api/v1/backup/manifest", "", "", nil); code != 200 {
449 t.Fatalf("manifest v1: %d", code)
450 }
451 tim, _ := sessionClient(t, e.st, e.base, e.tim.ID)
452 bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
453 bobc, _ := sessionClient(t, e.st, e.base, bob.ID)
454 page := func(c *http.Client, p string) string {
455 res, err := c.Get(e.base + p)
456 if err != nil {
457 t.Fatal(err)
458 }
459 return body(t, res)
460 }
461 if strings.Contains(page(tim, "/"), "compat-banner") {
462 t.Fatal("banner terwijl alles past")
463 }
464
465 // De backup server vraagt minstens protocol 9: BlueGit is te oud.
466 code, b, _ := call("GET", "/api/v1/backup/info", "9", "9", nil)
467 if code != 200 || !strings.Contains(string(b), `"compat":"bluegit_too_old"`) || !strings.Contains(string(b), `"protocol":2`) {
468 t.Fatalf("info: %d %s", code, b)
469 }
470 code, b, _ = call("GET", "/api/v1/backup/manifest", "9", "9", nil)
471 if code != http.StatusUpgradeRequired || !strings.Contains(string(b), "bluegit_too_old") {
472 t.Fatalf("manifest bij te oude BlueGit: %d %s", code, b)
473 }
474 for _, p := range []string{"/", "/users/tim", "/admin/backup", "/-/info", "/help"} {
475 html := page(tim, p)
476 if !strings.Contains(html, `class="compat-banner"`) || !strings.Contains(html, "nas") || !strings.Contains(html, `href="/admin/backup"`) || !strings.Contains(html, "Update BlueGit") {
477 t.Fatalf("%s: geen banner voor de beheerder:\n%.2000s", p, html)
478 }
479 }
480 if html := page(bobc, "/"); strings.Contains(html, "compat-banner") || strings.Contains(html, "nas") {
481 t.Fatal("niet-beheerder ziet de banner")
482 }
483 // Ook in de API voor beheerders.
484 if code, b := rapi(t, e.base, e.tok, "GET", "/admin/backup", nil); code != 200 || !strings.Contains(string(b), `"compat":"bluegit_too_old"`) {
485 t.Fatalf("api: %d %s", code, b)
486 }
487
488 // BlueGit vraagt minstens protocol 3; de backup server spreekt 2.
489 restore := backup.OverrideProtocol("4", "3")
490 defer restore()
491 code, b, _ = call("GET", "/api/v1/backup/manifest", "2", "1", nil)
492 if code != http.StatusUpgradeRequired || !strings.Contains(string(b), "backup_too_old") {
493 t.Fatalf("manifest bij te oude backup server: %d %s", code, b)
494 }
495 if html := page(tim, "/"); !strings.Contains(html, "The backup server is out of date") {
496 t.Fatalf("banner zegt niet dat de backup server te oud is:\n%.2000s", html)
497 }
498 // Bijgewerkt: de banner verdwijnt.
499 if code, _, _ := call("GET", "/api/v1/backup/manifest", "4", "1", nil); code != 200 {
500 t.Fatalf("na update: %d", code)
501 }
502 if strings.Contains(page(tim, "/"), "compat-banner") {
503 t.Fatal("banner blijft na de update")
504 }
505}
506
507func TestBackupConnectAcceptsIPURLs(t *testing.T) {
508 e := newBackupEnv(t)
509 k := addBackupServer(t, e, "ip")
510 for _, u := range []string{"http://192.168.1.50:8080", "http://[2001:db8::1]:8080", "http://127.0.0.1:8080"} {
511 code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"`+u+`","server_id":"s"}`))
512 if code != 200 {
513 t.Fatalf("%s: %d %s", u, code, b)
514 }
515 want := strings.TrimRight(u, "/")
516 if !strings.Contains(string(b), want) {
517 t.Fatalf("%s niet opgeslagen: %s", u, b)
518 }
519 }
520}
521
522func TestBackupProgressIsRecordedAndShown(t *testing.T) {
523 e := newBackupEnv(t)
524 k := addBackupServer(t, e, "nas")
525 // Eerst koppelen met een IP-URL (werkte al) zodat de server "connected" is.
526 if code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"http://192.168.1.50:8080","server_id":"s"}`)); code != 200 {
527 t.Fatalf("connect: %d %s", code, b)
528 }
529 payload := `{"known":true,"percent":42,"done_bytes":42,"total_bytes":100,"done_files":1,"total_files":3}`
530 code, b := keyed(t, "POST", e.base+"/api/v1/backup/progress", k.Key, strings.NewReader(payload))
531 if code != 200 {
532 t.Fatalf("progress: %d %s", code, b)
533 }
534 c, ok := e.srv.backupMgr.Get(k.ID)
535 if !ok || !c.Sync.Known || c.Sync.Percent != 42 || c.Sync.TotalBytes != 100 {
536 t.Fatalf("niet bewaard: %+v", c.Sync)
537 }
538 tc, _ := sessionClient(t, e.st, e.base, e.tim.ID)
539 res, err := tc.Get(e.base + "/admin/backup")
540 if err != nil {
541 t.Fatal(err)
542 }
543 html := body(t, res)
544 if !strings.Contains(html, "42%") && !strings.Contains(html, `value="42"`) {
545 t.Fatalf("lijst toont geen voortgang:\n%s", html)
546 }
547}