BlueGit

timfa bluegit

Files

bluegit / internal / server / backup_test.go

backup_test.go

backup_test.go 10.2 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 "strings"
13 "sync"
14 "testing"
15 "time"
16
17 "gitlab.com/Timfa/bluegit/internal/auth"
18 "gitlab.com/Timfa/bluegit/internal/backup"
19 "gitlab.com/Timfa/bluegit/internal/config"
20 "gitlab.com/Timfa/bluegit/internal/store"
21)
22
23type backupEnv struct {
24 srv *Server
25 st *store.Store
26 base string
27 tim store.User
28 tok string
29}
30
31func newBackupEnv(t *testing.T) *backupEnv {
32 t.Helper()
33 stateDir, storage := t.TempDir(), t.TempDir()
34 st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32())
35 if err != nil {
36 t.Fatal(err)
37 }
38 t.Cleanup(func() { _ = st.Close() })
39 _ = os.WriteFile(filepath.Join(stateDir, "secret.key"), bytes32(), 0o600)
40 cfg := config.Config{
41 Listen: "127.0.0.1:0", StoragePath: storage, StatePath: stateDir,
42 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
43 Git: config.Git{Binary: "git", DefaultBranch: "master"},
44 }
45 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
46 ts := httptest.NewServer(srv.Handler())
47 t.Cleanup(ts.Close)
48 srv.Cfg.BaseURL = ts.URL
49 tim, err := st.UpsertUser(context.Background(), 1, "tim", "", false)
50 if err != nil {
51 t.Fatal(err)
52 }
53 if !tim.InstanceAdmin {
54 t.Skip("eerste gebruiker is geen beheerder")
55 }
56 _ = os.MkdirAll(filepath.Join(storage, "repos", "tim", "app.git"), 0o755)
57 _ = os.WriteFile(filepath.Join(storage, "repos", "tim", "app.git", "HEAD"), []byte("ref: refs/heads/master\n"), 0o644)
58 srv.backupInit()
59 srv.backupNote.Delay = 20 * time.Millisecond
60 return &backupEnv{srv: srv, st: st, base: ts.URL, tim: tim, tok: issue(t, st, tim.ID, "api")}
61}
62
63func keyed(t *testing.T, method, u, key string, body io.Reader) (int, []byte) {
64 t.Helper()
65 req, _ := http.NewRequest(method, u, body)
66 if key != "" {
67 req.Header.Set("Authorization", "Bearer "+key)
68 }
69 res, err := http.DefaultClient.Do(req)
70 if err != nil {
71 t.Fatal(err)
72 }
73 defer res.Body.Close()
74 b, _ := io.ReadAll(res.Body)
75 return res.StatusCode, b
76}
77
78// fakeBackup speelt de backup server: hij controleert elke handtekening.
79type fakeBackup struct {
80 mu sync.Mutex
81 secret string
82 notifies int
83 rollback []string
84 badSig int
85 ts *httptest.Server
86}
87
88func newFakeBackup(t *testing.T) *fakeBackup {
89 f := &fakeBackup{}
90 f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
91 body, _ := io.ReadAll(r.Body)
92 f.mu.Lock()
93 defer f.mu.Unlock()
94 if err := backup.Verify(r, f.secret, body, time.Now()); err != nil {
95 f.badSig++
96 http.Error(w, `{"error":"sig"}`, 401)
97 return
98 }
99 switch r.URL.Path {
100 case "/api/v1/notify":
101 f.notifies++
102 w.WriteHeader(204)
103 case "/api/v1/archives":
104 _ = 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}}})
105 case "/api/v1/status":
106 _, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`))
107 case "/api/v1/rollback":
108 var in struct{ Archive string }
109 _ = json.Unmarshal(body, &in)
110 f.rollback = append(f.rollback, in.Archive)
111 w.WriteHeader(202)
112 default:
113 http.NotFound(w, r)
114 }
115 }))
116 t.Cleanup(f.ts.Close)
117 return f
118}
119
120func TestBackupKeyAndKeyedAPI(t *testing.T) {
121 e := newBackupEnv(t)
122 // Zonder key: 401. Met een gewoon toegangstoken: ook 401.
123 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 {
124 t.Fatalf("zonder key: %d", code)
125 }
126 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 {
127 t.Fatalf("bg_-token: %d", code)
128 }
129 // Alleen een beheerder maakt een key.
130 bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
131 if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/key", nil); code != 403 {
132 t.Fatalf("bob maakt key: %d", code)
133 }
134 code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
135 if code != 201 {
136 t.Fatalf("key: %d %s", code, b)
137 }
138 var k struct{ Key string }
139 _ = json.Unmarshal(b, &k)
140 if !strings.HasPrefix(k.Key, "bgbk_") {
141 t.Fatalf("key %q", k.Key)
142 }
143 code, b = keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil)
144 var info struct {
145 InstanceID string `json:"instance_id"`
146 }
147 _ = json.Unmarshal(b, &info)
148 if code != 200 || info.InstanceID == "" {
149 t.Fatalf("info: %d %s", code, b)
150 }
151 code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil)
152 var m backup.Manifest
153 _ = json.Unmarshal(b, &m)
154 if code != 200 || m.Instance != info.InstanceID {
155 t.Fatalf("manifest: %d %.300s", code, b)
156 }
157 have := map[string]bool{}
158 for _, f := range m.Files {
159 have[f.Path] = true
160 }
161 for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} {
162 if !have[want] {
163 t.Fatalf("manifest mist %s: %v", want, have)
164 }
165 }
166 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil)
167 if code != 200 || string(b) != "ref: refs/heads/master\n" {
168 t.Fatalf("file: %d %q", code, b)
169 }
170 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil)
171 if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") {
172 t.Fatalf("db-kopie: %d %.20q", code, b)
173 }
174 for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} {
175 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 {
176 t.Fatalf("%s: %d", bad, code)
177 }
178 }
179 // Intrekken: de key werkt niet meer.
180 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/key", nil); code != 204 {
181 t.Fatalf("revoke: %d", code)
182 }
183 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 {
184 t.Fatalf("na intrekken: %d", code)
185 }
186}
187
188func TestBackupConnectNotifyArchivesRollback(t *testing.T) {
189 e := newBackupEnv(t)
190 fb := newFakeBackup(t)
191 _, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
192 var k struct{ Key string }
193 _ = json.Unmarshal(b, &k)
194 fb.secret = backup.SigningSecret(k.Key)
195 code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"`+fb.ts.URL+`","server_id":"s1"}`))
196 if code != 200 {
197 t.Fatalf("connect: %d %s", code, b)
198 }
199 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 {
200 t.Fatalf("ftp-adres: %d", code)
201 }
202
203 // Een schrijvende actie geeft een ondertekende melding.
204 if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 {
205 t.Fatalf("project: %d %s", code, b)
206 }
207 deadline := time.Now().Add(5 * time.Second)
208 for {
209 fb.mu.Lock()
210 n := fb.notifies
211 fb.mu.Unlock()
212 if n > 0 {
213 break
214 }
215 if time.Now().After(deadline) {
216 t.Fatal("geen melding ontvangen")
217 }
218 time.Sleep(20 * time.Millisecond)
219 }
220
221 // Archieven via de API en op de beheerpagina, met de waarschuwing.
222 code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup", nil)
223 if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"connected":true`) {
224 t.Fatalf("admin backup: %d %s", code, b)
225 }
226 tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID)
227 res, _ := tc.Get(e.base + "/admin/backup")
228 page := body(t, res)
229 for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`, `href="/admin/backup"`} {
230 if !strings.Contains(page, want) {
231 t.Fatalf("pagina mist %s: %.600s", want, page)
232 }
233 }
234
235 // Rollback: verkeerde bevestiging, dan goed.
236 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 {
237 t.Fatalf("verkeerde bevestiging: %d", code)
238 }
239 res, _ = tc.PostForm(e.base+"/admin/backup/rollback", url.Values{"csrf": {csrf}, "archive": {"bluegit-20261115-120000.tar.gz"}, "confirm": {"bluegit-20261115-120000.tar.gz"}})
240 res.Body.Close()
241 fb.mu.Lock()
242 if len(fb.rollback) != 0 {
243 t.Fatal("rollback zonder vinkje")
244 }
245 fb.mu.Unlock()
246 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"}})
247 res.Body.Close()
248 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 {
249 t.Fatalf("rollback api: %d %s", code, b)
250 }
251 fb.mu.Lock()
252 defer fb.mu.Unlock()
253 if len(fb.rollback) != 2 || fb.badSig != 0 {
254 t.Fatalf("rollbacks %v, foute handtekeningen %d", fb.rollback, fb.badSig)
255 }
256}
257
258func TestBackupRestoreStagesAndRestarts(t *testing.T) {
259 e := newBackupEnv(t)
260 restarted := make(chan struct{}, 1)
261 e.srv.RequestRestart = func() { restarted <- struct{}{} }
262 _, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
263 var k struct{ Key string }
264 _ = json.Unmarshal(b, &k)
265 // Ongeldig archief: 400, niets klaargezet.
266 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 {
267 t.Fatalf("ongeldig: %d", code)
268 }
269 if backup.HasPending(e.srv.StateDir) {
270 t.Fatal("READY na fout")
271 }
272 // Een archief uit het eigen manifest terugsturen.
273 tarball := buildTarFromInstance(t, e, k.Key)
274 code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball))
275 if code != 202 {
276 t.Fatalf("restore: %d %s", code, b)
277 }
278 select {
279 case <-restarted:
280 case <-time.After(3 * time.Second):
281 t.Fatal("geen herstart")
282 }
283 if !backup.HasPending(e.srv.StateDir) {
284 t.Fatal("geen READY")
285 }
286 restoreBusy.Store(false)
287}
288
289func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string {
290 t.Helper()
291 _, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil)
292 var m backup.Manifest
293 _ = json.Unmarshal(b, &m)
294 var sb strings.Builder
295 files := map[string]string{}
296 for _, f := range m.Files {
297 _, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil)
298 files[f.Path] = string(data)
299 }
300 writeTarGz(t, &sb, files)
301 return sb.String()
302}