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 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) default: http.NotFound(w, r) } })) t.Cleanup(f.ts.Close) return f } 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 key. 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/key", nil); code != 403 { t.Fatalf("bob maakt key: %d", code) } code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil) if code != 201 { t.Fatalf("key: %d %s", code, b) } var k struct{ Key string } _ = json.Unmarshal(b, &k) if !strings.HasPrefix(k.Key, "bgbk_") { t.Fatalf("key %q", k.Key) } code, b = keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil) var info struct { InstanceID string `json:"instance_id"` } _ = json.Unmarshal(b, &info) if code != 200 || info.InstanceID == "" { 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) } } // Intrekken: de key werkt niet meer. if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/key", nil); code != 204 { t.Fatalf("revoke: %d", code) } if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 { t.Fatalf("na intrekken: %d", code) } } func TestBackupConnectNotifyArchivesRollback(t *testing.T) { e := newBackupEnv(t) fb := newFakeBackup(t) _, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil) var k struct{ Key string } _ = json.Unmarshal(b, &k) fb.secret = backup.SigningSecret(k.Key) code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"`+fb.ts.URL+`","server_id":"s1"}`)) if code != 200 { t.Fatalf("connect: %d %s", code, b) } if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 { t.Fatalf("ftp-adres: %d", code) } // Een schrijvende actie geeft een ondertekende melding. 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 { fb.mu.Lock() n := fb.notifies fb.mu.Unlock() if n > 0 { break } if time.Now().After(deadline) { t.Fatal("geen melding ontvangen") } time.Sleep(20 * time.Millisecond) } // Archieven via de API en op de beheerpagina, met de waarschuwing. code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup", nil) if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"connected":true`) { t.Fatalf("admin backup: %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{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`, `href="/admin/backup"`} { if !strings.Contains(page, want) { t.Fatalf("pagina mist %s: %.600s", want, page) } } // Rollback: verkeerde bevestiging, dan goed. if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/rollback", map[string]any{"archive": "bluegit-20261115-120000.tar.gz", "confirm": "ja"}); code != 400 { t.Fatalf("verkeerde bevestiging: %d", code) } res, _ = tc.PostForm(e.base+"/admin/backup/rollback", url.Values{"csrf": {csrf}, "archive": {"bluegit-20261115-120000.tar.gz"}, "confirm": {"bluegit-20261115-120000.tar.gz"}}) res.Body.Close() fb.mu.Lock() if len(fb.rollback) != 0 { t.Fatal("rollback zonder vinkje") } fb.mu.Unlock() res, _ = tc.PostForm(e.base+"/admin/backup/rollback", url.Values{"csrf": {csrf}, "archive": {"bluegit-20261115-120000.tar.gz"}, "confirm": {"bluegit-20261115-120000.tar.gz"}, "understood": {"1"}}) res.Body.Close() if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/rollback", map[string]any{"archive": "bluegit-20261115-120000.tar.gz", "confirm": "bluegit-20261115-120000.tar.gz"}); code != 202 { t.Fatalf("rollback api: %d %s", code, b) } fb.mu.Lock() defer fb.mu.Unlock() if len(fb.rollback) != 2 || fb.badSig != 0 { t.Fatalf("rollbacks %v, foute handtekeningen %d", fb.rollback, fb.badSig) } } func TestBackupRestoreStagesAndRestarts(t *testing.T) { e := newBackupEnv(t) restarted := make(chan struct{}, 1) e.srv.RequestRestart = func() { restarted <- struct{}{} } _, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil) var k struct{ Key string } _ = json.Unmarshal(b, &k) // 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() }