package server import ( "context" "encoding/json" "io" "net/http" "net/http/httptest" "net/url" "os" "path/filepath" "strings" "sync" "testing" "time" "gitlab.com/Timfa/bluegit/internal/auth" "gitlab.com/Timfa/bluegit/internal/backup" "gitlab.com/Timfa/bluegit/internal/config" "gitlab.com/Timfa/bluegit/internal/store" ) type backupEnv struct { srv *Server st *store.Store base string tim store.User tok string } func newBackupEnv(t *testing.T) *backupEnv { t.Helper() stateDir, storage := t.TempDir(), t.TempDir() st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32()) if err != nil { t.Fatal(err) } t.Cleanup(func() { _ = st.Close() }) _ = os.WriteFile(filepath.Join(stateDir, "secret.key"), bytes32(), 0o600) cfg := config.Config{ Listen: "127.0.0.1:0", StoragePath: storage, StatePath: stateDir, Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"}, Git: config.Git{Binary: "git", DefaultBranch: "master"}, } srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir} ts := httptest.NewServer(srv.Handler()) t.Cleanup(ts.Close) srv.Cfg.BaseURL = ts.URL tim, err := st.UpsertUser(context.Background(), 1, "tim", "", false) if err != nil { t.Fatal(err) } if !tim.InstanceAdmin { t.Skip("eerste gebruiker is geen beheerder") } _ = os.MkdirAll(filepath.Join(storage, "repos", "tim", "app.git"), 0o755) _ = os.WriteFile(filepath.Join(storage, "repos", "tim", "app.git", "HEAD"), []byte("ref: refs/heads/master\n"), 0o644) srv.backupInit() srv.backupNote.Delay = 20 * time.Millisecond return &backupEnv{srv: srv, st: st, base: ts.URL, tim: tim, tok: issue(t, st, tim.ID, "api")} } func keyed(t *testing.T, method, u, key string, body io.Reader) (int, []byte) { t.Helper() req, _ := http.NewRequest(method, u, body) if key != "" { req.Header.Set("Authorization", "Bearer "+key) } res, err := http.DefaultClient.Do(req) if err != nil { t.Fatal(err) } defer res.Body.Close() b, _ := io.ReadAll(res.Body) return res.StatusCode, b } // fakeBackup speelt de backup server: hij controleert elke handtekening. type fakeBackup struct { mu sync.Mutex secret string notifies int rollback []string calls []string bodies map[string]string badSig int ts *httptest.Server } func newFakeBackup(t *testing.T) *fakeBackup { f := &fakeBackup{} f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) f.mu.Lock() defer f.mu.Unlock() if err := backup.Verify(r, f.secret, body, time.Now()); err != nil { f.badSig++ http.Error(w, `{"error":"sig"}`, 401) return } switch r.URL.Path { case "/api/v1/notify": f.notifies++ w.WriteHeader(204) case "/api/v1/archives": _ = 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}}}) case "/api/v1/status": _, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`)) case "/api/v1/rollback": var in struct{ Archive string } _ = json.Unmarshal(body, &in) f.rollback = append(f.rollback, in.Archive) w.WriteHeader(202) case "/api/v1/admin/actions": _, _ = w.Write([]byte(`{"actions":[ {"name":"status","method":"GET","path":"/api/v1/admin/status","bluegit":true}, {"name":"config","method":"GET","path":"/api/v1/admin/config","bluegit":true}, {"name":"config.update","method":"PUT","path":"/api/v1/admin/config","bluegit":true}, {"name":"sync","method":"POST","path":"/api/v1/admin/sync","bluegit":true}, {"name":"archive.delete","method":"DELETE","path":"/api/v1/admin/archives/{name}","bluegit":true,"params":["name"]}, {"name":"archive.download","method":"GET","path":"/api/v1/admin/archives/{name}/download","params":["name"]}, {"name":"rollback","method":"POST","path":"/api/v1/admin/rollback","bluegit":true}, {"name":"disconnect","method":"POST","path":"/api/v1/admin/disconnect","bluegit":true}]}`)) case "/api/v1/admin/config": if r.Method == "PUT" { f.calls = append(f.calls, "PUT config") if f.bodies == nil { f.bodies = map[string]string{} } f.bodies["config"] = string(body) } _, _ = 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"}`)) case "/api/v1/admin/rollback": var in struct{ Archive, Confirm string } _ = json.Unmarshal(body, &in) if in.Confirm != in.Archive { http.Error(w, `{"error":"confirm"}`, 400) return } f.rollback = append(f.rollback, in.Archive) w.WriteHeader(202) default: if r.URL.Path == "/api/v1/admin/sync" || r.URL.Path == "/api/v1/admin/disconnect" || strings.HasPrefix(r.URL.Path, "/api/v1/admin/archives/") { f.calls = append(f.calls, r.Method+" "+r.URL.Path+" "+string(body)) _, _ = w.Write([]byte(`{}`)) return } http.NotFound(w, r) } })) t.Cleanup(f.ts.Close) return f } type addedServer struct { ID string `json:"id"` Key string `json:"key"` } func addBackupServer(t *testing.T, e *backupEnv, name string) addedServer { t.Helper() code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers", map[string]any{"name": name}) if code != 201 { t.Fatalf("server toevoegen: %d %s", code, b) } var a addedServer _ = json.Unmarshal(b, &a) if !strings.HasPrefix(a.Key, "bgbk_") || a.ID == "" { t.Fatalf("%s", b) } return a } func TestBackupKeyAndKeyedAPI(t *testing.T) { e := newBackupEnv(t) // Zonder key: 401. Met een gewoon toegangstoken: ook 401. if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 { t.Fatalf("zonder key: %d", code) } if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 { t.Fatalf("bg_-token: %d", code) } // Alleen een beheerder maakt een backup server. bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false) if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/servers", map[string]any{"name": "x"}); code != 403 { t.Fatalf("bob maakt server: %d", code) } k := addBackupServer(t, e, "nas") code, b := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil) var info struct { InstanceID string `json:"instance_id"` Name string `json:"name"` } _ = json.Unmarshal(b, &info) if code != 200 || info.InstanceID == "" || info.Name != "nas" { t.Fatalf("info: %d %s", code, b) } code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil) var m backup.Manifest _ = json.Unmarshal(b, &m) if code != 200 || m.Instance != info.InstanceID { t.Fatalf("manifest: %d %.300s", code, b) } have := map[string]bool{} for _, f := range m.Files { have[f.Path] = true } for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} { if !have[want] { t.Fatalf("manifest mist %s: %v", want, have) } } code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil) if code != 200 || string(b) != "ref: refs/heads/master\n" { t.Fatalf("file: %d %q", code, b) } code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil) if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") { t.Fatalf("db-kopie: %d %.20q", code, b) } for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} { if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 { t.Fatalf("%s: %d", bad, code) } } // Een tweede server met een eigen key; nieuwe key voor de eerste. k2 := addBackupServer(t, e, "offsite") code, b = rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+k.ID+"/key", nil) var rot addedServer _ = json.Unmarshal(b, &rot) if code != 201 || rot.Key == k.Key { t.Fatalf("nieuwe key: %d %s", code, b) } if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 { t.Fatalf("oude key werkt nog: %d", code) } if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 200 { t.Fatalf("nieuwe key: %d", code) } 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") { t.Fatalf("hernoemen: %d %s", code, b) } // Verwijderen: die key werkt niet meer, de andere wel. if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+k.ID, nil); code != 204 { t.Fatalf("verwijderen: %d", code) } if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 401 { t.Fatalf("na verwijderen: %d", code) } if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k2.Key, nil); code != 200 { t.Fatalf("andere server: %d", code) } if code, _ := rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/onbekend", nil); code != 404 { t.Fatalf("onbekend: %d", code) } } func TestBackupMultipleServersAndControl(t *testing.T) { e := newBackupEnv(t) fa, fb := newFakeBackup(t), newFakeBackup(t) ka, kb := addBackupServer(t, e, "nas"), addBackupServer(t, e, "offsite") fa.secret, fb.secret = backup.SigningSecret(ka.Key), backup.SigningSecret(kb.Key) for _, c := range []struct { key, url string }{{ka.Key, fa.ts.URL}, {kb.Key, fb.ts.URL}} { code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", c.key, strings.NewReader(`{"server_url":"`+c.url+`","server_id":"s"}`)) if code != 200 { t.Fatalf("connect: %d %s", code, b) } } if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", ka.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 { t.Fatalf("ftp-adres: %d", code) } // Een schrijvende actie geeft een ondertekende melding aan beide. if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 { t.Fatalf("project: %d %s", code, b) } deadline := time.Now().Add(5 * time.Second) for { fa.mu.Lock() na := fa.notifies fa.mu.Unlock() fb.mu.Lock() nb := fb.notifies fb.mu.Unlock() if na > 0 && nb > 0 { break } if time.Now().After(deadline) { t.Fatalf("meldingen: %d en %d", na, nb) } time.Sleep(20 * time.Millisecond) } // Lijst via de API en op de pagina. code, b := rapi(t, e.base, e.tok, "GET", "/admin/backup", nil) if code != 200 || strings.Count(string(b), `"connected":true`) != 2 { t.Fatalf("admin backup: %d %s", code, b) } code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/"+ka.ID, nil) if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"retention_days"`) { t.Fatalf("server: %d %s", code, b) } tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID) res, _ := tc.Get(e.base + "/admin/backup") page := body(t, res) for _, want := range []string{"nas", "offsite", `/admin/backup/s/` + ka.ID, `/admin/backup/s/` + kb.ID, `href="/admin/backup"`} { if !strings.Contains(page, want) { t.Fatalf("lijst mist %s: %.600s", want, page) } } res, _ = tc.Get(e.base + "/admin/backup/s/" + ka.ID) page = body(t, res) for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`, `act/config.update`, `name="retention_days" value="30"`, `act/sync`, `act/archive.delete`} { if !strings.Contains(page, want) { t.Fatalf("pagina mist %s: %.600s", want, page) } } // Instellingen en sync vanuit BlueGit (formulier en API). res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"9"}}) res.Body.Close() if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/sync", nil); code != 200 { t.Fatalf("sync: %d %s", code, b) } if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.download", map[string]any{"name": "x"}); code != 404 { t.Fatalf("niet-BlueGit-actie: %d", code) } 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 { t.Fatalf("archief verwijderen: %d", code) } fa.mu.Lock() if fa.bodies["config"] != `{"retention_days":"9"}` { t.Fatalf("config %q", fa.bodies["config"]) } calls := strings.Join(fa.calls, "|") fa.mu.Unlock() if !strings.Contains(calls, `POST /api/v1/admin/sync {"wait":"false"}`) || !strings.Contains(calls, "DELETE /api/v1/admin/archives/bluegit-20261115-120000.tar.gz") { t.Fatalf("calls %s", calls) } // Rollback: zonder vinkje niets, verkeerde bevestiging 400, dan goed. arch := "bluegit-20261115-120000.tar.gz" res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}}) res.Body.Close() 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 { t.Fatalf("verkeerde bevestiging: %d", code) } fa.mu.Lock() if len(fa.rollback) != 0 { t.Fatal("rollback zonder vinkje of bevestiging") } fa.mu.Unlock() res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}, "understood": {"1"}}) res.Body.Close() 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 { t.Fatalf("rollback api: %d %s", code, b) } // Verwijderen laat de backup server ontkoppelen. if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+kb.ID, nil); code != 204 { t.Fatalf("verwijderen: %d", code) } fb.mu.Lock() if !strings.Contains(strings.Join(fb.calls, "|"), "POST /api/v1/admin/disconnect") { t.Fatalf("geen disconnect: %v", fb.calls) } fb.mu.Unlock() fa.mu.Lock() defer fa.mu.Unlock() if len(fa.rollback) != 2 || fa.badSig != 0 { t.Fatalf("rollbacks %v, foute handtekeningen %d", fa.rollback, fa.badSig) } } func TestBackupRestoreStagesAndRestarts(t *testing.T) { e := newBackupEnv(t) restarted := make(chan struct{}, 1) e.srv.RequestRestart = func() { restarted <- struct{}{} } k := addBackupServer(t, e, "nas") // Ongeldig archief: 400, niets klaargezet. if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 { t.Fatalf("ongeldig: %d", code) } if backup.HasPending(e.srv.StateDir) { t.Fatal("READY na fout") } // Een archief uit het eigen manifest terugsturen. tarball := buildTarFromInstance(t, e, k.Key) code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball)) if code != 202 { t.Fatalf("restore: %d %s", code, b) } select { case <-restarted: case <-time.After(3 * time.Second): t.Fatal("geen herstart") } if !backup.HasPending(e.srv.StateDir) { t.Fatal("geen READY") } restoreBusy.Store(false) } func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string { t.Helper() _, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil) var m backup.Manifest _ = json.Unmarshal(b, &m) var sb strings.Builder files := map[string]string{} for _, f := range m.Files { _, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil) files[f.Path] = string(data) } writeTarGz(t, &sb, files) return sb.String() }