BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / server / ui_test.go

ui_test.go

ui_test.go 9.1 KiB Download Raw
1package server
2
3import (
4 "bytes"
5 "encoding/json"
6 "net/http"
7 "net/http/httptest"
8 "net/url"
9 "os"
10 "path/filepath"
11 "regexp"
12 "strings"
13 "testing"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/backupserver/config"
17 "gitlab.com/Timfa/bluegit/internal/backupserver/protocol"
18)
19
20// uiClient is een browser met een cookie.
21type uiClient struct {
22 t *testing.T
23 h http.Handler
24 cookie *http.Cookie
25}
26
27func (c *uiClient) do(method, p string, form url.Values) *httptest.ResponseRecorder {
28 var body *strings.Reader
29 if form != nil {
30 body = strings.NewReader(form.Encode())
31 } else {
32 body = strings.NewReader("")
33 }
34 r := httptest.NewRequest(method, p, body)
35 if form != nil {
36 r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
37 }
38 if c.cookie != nil {
39 r.AddCookie(c.cookie)
40 }
41 w := httptest.NewRecorder()
42 c.h.ServeHTTP(w, r)
43 for _, ck := range w.Result().Cookies() {
44 if ck.Name == sessionCookie {
45 c.cookie = ck
46 }
47 }
48 return w
49}
50
51var csrfRE = regexp.MustCompile(`name="csrf" value="([0-9a-f]+)"`)
52
53func login(t *testing.T, s *Server) (*uiClient, string) {
54 c := &uiClient{t: t, h: s.Handler()}
55 if w := c.do("GET", "/", nil); w.Code != 303 || w.Header().Get("Location") != "/login" {
56 t.Fatalf("zonder sessie: %d %s", w.Code, w.Header().Get("Location"))
57 }
58 if w := c.do("POST", "/login", url.Values{"token": {"fout"}}); w.Header().Get("Location") != "/login?fout=1" {
59 t.Fatalf("fout token: %s", w.Header().Get("Location"))
60 }
61 if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 303 || c.cookie == nil {
62 t.Fatalf("login %d", w.Code)
63 }
64 if !c.cookie.HttpOnly || c.cookie.SameSite != http.SameSiteStrictMode {
65 t.Fatalf("cookie %+v", c.cookie)
66 }
67 w := c.do("GET", "/", nil)
68 if w.Code != 200 {
69 t.Fatalf("index %d", w.Code)
70 }
71 m := csrfRE.FindStringSubmatch(w.Body.String())
72 if m == nil {
73 t.Fatal("geen csrf")
74 }
75 return c, m[1]
76}
77
78// Elke wijzigende actie heeft een formulier in de webinterface, elke
79// beheerroute zit in Actions, en elk formulier hoort bij een actie.
80func TestUIAndAPIParity(t *testing.T) {
81 f := newFake(t)
82 s := newTestServer(t)
83 if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
84 t.Fatal(w.Body)
85 }
86 if _, err := s.SyncNow(t.Context()); err != nil {
87 t.Fatal(err)
88 }
89 if _, err := s.ArchiveNow(); err != nil {
90 t.Fatal(err)
91 }
92 c, _ := login(t, s)
93 page := c.do("GET", "/", nil).Body.String()
94 // Het koppelformulier staat in een uitklapper zodra er gekoppeld is; het
95 // moet er nog steeds zijn.
96 forms := map[string]bool{}
97 for _, m := range regexp.MustCompile(`action="/ui/act/([a-z.]+)"`).FindAllStringSubmatch(page, -1) {
98 forms[m[1]] = true
99 }
100 for _, a := range s.Actions() {
101 switch a.Method {
102 case "GET":
103 // Getoond op de pagina; download als link.
104 if a.Name == "archive.download" && !strings.Contains(page, "/download\">Downloaden") {
105 t.Errorf("geen downloadlink")
106 }
107 default:
108 if !forms[a.Name] {
109 t.Errorf("actie %s (%s %s) heeft geen formulier in de webinterface", a.Name, a.Method, a.Path)
110 }
111 delete(forms, a.Name)
112 }
113 }
114 for f := range forms {
115 t.Errorf("formulier %s hoort bij geen API-actie", f)
116 }
117 // Alle GET-acties geven hun gegevens ook op de pagina.
118 for _, want := range []string{"Overzicht", "cfg-archive_interval", "cfg-listen", "bluegit-", "/api/v1/admin/config"} {
119 if !strings.Contains(page, want) {
120 t.Errorf("pagina mist %q", want)
121 }
122 }
123 // De API geeft dezelfde actielijst.
124 w := adminReq(s, "GET", "/api/v1/admin/actions", "")
125 var al struct {
126 Actions []Action `json:"actions"`
127 }
128 _ = json.Unmarshal(w.Body.Bytes(), &al)
129 if len(al.Actions) != len(s.Actions()) {
130 t.Fatalf("actions %d", len(al.Actions))
131 }
132}
133
134func TestUISettingsAndCSRF(t *testing.T) {
135 s := newTestServer(t)
136 c, csrf := login(t, s)
137 form := url.Values{"csrf": {csrf}, "retention_days": {"9"}, "archive_interval": {"12h"}, "rate_limit_kib": {"300"}, "listen": {"127.0.0.1:9999"}}
138 if w := c.do("POST", "/ui/act/config.update", form); w.Code != 303 {
139 t.Fatalf("opslaan %d %s", w.Code, w.Body)
140 }
141 page := c.do("GET", "/", nil).Body.String()
142 if !strings.Contains(page, "Instellingen opgeslagen") || !strings.Contains(page, "herstart") {
143 t.Fatalf("melding ontbreekt")
144 }
145 cv := s.ConfigView()
146 get := func(k string) string {
147 for _, f := range cv.Fields {
148 if f.Key == k {
149 return f.Value
150 }
151 }
152 return ""
153 }
154 if get("retention_days") != "9" || get("archive_interval") != "12h" || get("listen") != "127.0.0.1:9999" || !cv.Restart {
155 t.Fatalf("%+v", cv)
156 }
157 if s.limiter.Rate() != 300<<10 {
158 t.Fatalf("rate %d", s.limiter.Rate())
159 }
160 if s.cfg().Listen == "127.0.0.1:9999" {
161 t.Fatal("listen hoort pas na herstart te gelden")
162 }
163 // Bewaard: een nieuwe server leest het.
164 s2, err := New(s.Cfg, nil)
165 if err != nil {
166 t.Fatal(err)
167 }
168 if s2.cfg().RetentionDays != 9 || s2.cfg().Listen != "127.0.0.1:9999" {
169 t.Fatalf("na herstart %+v", s2.cfg())
170 }
171 // Zonder of met fout CSRF-token: geweigerd.
172 if w := c.do("POST", "/ui/act/config.update", url.Values{"retention_days": {"1"}}); w.Code != 403 {
173 t.Fatalf("zonder csrf %d", w.Code)
174 }
175 // Ongeldige waarde: foutmelding, niets veranderd.
176 c.do("POST", "/ui/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"-1"}})
177 if !strings.Contains(c.do("GET", "/", nil).Body.String(), "mislukt") || s.cfg().RetentionDays != 9 {
178 t.Fatal("ongeldige waarde")
179 }
180 // API met sessiecookie vraagt X-CSRF-Token.
181 r := httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`))
182 r.AddCookie(c.cookie)
183 w := httptest.NewRecorder()
184 s.Handler().ServeHTTP(w, r)
185 if w.Code != 403 {
186 t.Fatalf("cookie zonder csrf-header %d", w.Code)
187 }
188 r = httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`))
189 r.AddCookie(c.cookie)
190 r.Header.Set("X-CSRF-Token", csrf)
191 w = httptest.NewRecorder()
192 s.Handler().ServeHTTP(w, r)
193 if w.Code != 200 || s.cfg().RetentionDays != 3 {
194 t.Fatalf("cookie met csrf-header %d %s", w.Code, w.Body)
195 }
196 // Uitloggen.
197 c.do("POST", "/logout", url.Values{"csrf": {csrf}})
198 if w := c.do("GET", "/", nil); w.Code != 303 {
199 t.Fatalf("na uitloggen %d", w.Code)
200 }
201 // Webinterface mag niet in een iframe van een ander.
202 if h := c.do("GET", "/login", nil).Header(); h.Get("X-Frame-Options") != "DENY" {
203 t.Fatal("frame")
204 }
205}
206
207func TestLoginRateLimit(t *testing.T) {
208 s := newTestServer(t)
209 c := &uiClient{t: t, h: s.Handler()}
210 for i := 0; i < 5; i++ {
211 c.do("POST", "/login", url.Values{"token": {"fout"}})
212 }
213 if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 429 {
214 t.Fatalf("na 5 fouten %d", w.Code)
215 }
216}
217
218func TestAPIConfig(t *testing.T) {
219 s := newTestServer(t)
220 w := adminReq(s, "PUT", "/api/v1/admin/config", `{"min_free_mb":2048,"full_sync_interval":"30m"}`)
221 if w.Code != 200 {
222 t.Fatalf("%d %s", w.Code, w.Body)
223 }
224 if s.cfg().MinFreeMB != 2048 || s.cfg().FullSyncInterval.Duration != 30*time.Minute {
225 t.Fatalf("%+v", s.cfg())
226 }
227 if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, config.SettingsFile)); err != nil {
228 t.Fatal(err)
229 }
230 for _, body := range []string{`{"data_dir":"/tmp"}`, `{"onbekend":1}`, `{"archive_interval":"0s"}`, `{}`, `[1]`} {
231 if w := adminReq(s, "PUT", "/api/v1/admin/config", body); w.Code != 400 {
232 t.Errorf("%s: %d", body, w.Code)
233 }
234 }
235 w = adminReq(s, "GET", "/api/v1/admin/config", "")
236 var cv ConfigView
237 _ = json.Unmarshal(w.Body.Bytes(), &cv)
238 if len(cv.Fields) != len(config.Fields) {
239 t.Fatalf("%s", w.Body)
240 }
241}
242
243func TestSignedAdminActions(t *testing.T) {
244 f := newFake(t)
245 s := newTestServer(t)
246 if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
247 t.Fatal(w.Body)
248 }
249 good := protocol.SigningSecret("bgbk_test")
250 call := func(method, p, body string) *httptest.ResponseRecorder {
251 r := httptest.NewRequest(method, p, bytes.NewReader([]byte(body)))
252 protocol.Sign(r, good, "inst-1", []byte(body), time.Now())
253 w := httptest.NewRecorder()
254 s.Handler().ServeHTTP(w, r)
255 return w
256 }
257 if w := call("PUT", "/api/v1/admin/config", `{"retention_days":"4"}`); w.Code != 200 || s.cfg().RetentionDays != 4 {
258 t.Fatalf("config via BlueGit %d %s", w.Code, w.Body)
259 }
260 if w := call("GET", "/api/v1/admin/config", ""); w.Code != 200 {
261 t.Fatalf("config lezen %d", w.Code)
262 }
263 if w := call("POST", "/api/v1/admin/connect", `{}`); w.Code != 403 {
264 t.Fatalf("connect via BlueGit %d", w.Code)
265 }
266 if w := call("POST", "/api/v1/admin/rollback", `{"archive":"bluegit-20261115-120000.tar.gz"}`); w.Code != 400 {
267 t.Fatalf("rollback zonder confirm %d", w.Code)
268 }
269 // Handtekening over een ander pad: geweigerd.
270 r := httptest.NewRequest("POST", "/api/v1/admin/sync", nil)
271 protocol.Sign(r, good, "inst-1", nil, time.Now())
272 r.URL.Path = "/api/v1/admin/disconnect"
273 w := httptest.NewRecorder()
274 s.Handler().ServeHTTP(w, r)
275 if w.Code != 401 {
276 t.Fatalf("ander pad %d", w.Code)
277 }
278 if w := call("POST", "/api/v1/admin/disconnect", ``); w.Code != 200 || s.getState().Connected() {
279 t.Fatalf("disconnect %d", w.Code)
280 }
281 // Ontkoppeld: BlueGit kan niets meer.
282 if w := call("GET", "/api/v1/admin/status", ""); w.Code != 401 {
283 t.Fatalf("na ontkoppelen %d", w.Code)
284 }
285}