BlueGit

timfa bluegit

Files

bluegit / internal / server / server_test.go

server_test.go

feat: Tims ster als logo van BlueGit
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
628a993e History
server_test.go 9.9 KiB Download Raw
1package server
2
3import (
4 "context"
5 "io"
6 "net/http"
7 "net/http/cookiejar"
8 "net/http/httptest"
9 "net/url"
10 "os"
11 "os/exec"
12 "path/filepath"
13 "strings"
14 "testing"
15 "time"
16
17 "gitlab.com/Timfa/bluegit/internal/auth"
18 "gitlab.com/Timfa/bluegit/internal/config"
19 "gitlab.com/Timfa/bluegit/internal/store"
20)
21
22func TestWebRepoPushAndSecretBoundary(t *testing.T) {
23 if _, err := exec.LookPath("git"); err != nil {
24 t.Skip("git ontbreekt")
25 }
26 storage := t.TempDir()
27 key := bytes32()
28 st, err := store.Open(filepath.Join(storage, "bluegit.db"), key)
29 if err != nil {
30 t.Fatal(err)
31 }
32 t.Cleanup(func() { _ = st.Close() })
33 cfg := config.Config{
34 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
35 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
36 Git: config.Git{Binary: "git", DefaultBranch: "master"},
37 SSH: config.SSH{Enabled: true, Listen: "0.0.0.0:2222", PublicHost: "git.timfalken.com", PublicPort: 22},
38 CI: config.CI{Enabled: false},
39 }
40 cfg.Auth.BaseURL = "https://auth.timfalken.com"
41 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
42 ts := httptest.NewServer(srv.Handler())
43 t.Cleanup(ts.Close)
44
45 jar, _ := cookiejar.New(nil)
46 client := &http.Client{Jar: jar}
47 res, err := client.Get(ts.URL + "/login")
48 if err != nil {
49 t.Fatal(err)
50 }
51 body := read(t, res)
52 if res.StatusCode != 200 || !strings.Contains(body, "Overzicht") {
53 t.Fatalf("login %d %s", res.StatusCode, body)
54 }
55 logo, err := client.Get(ts.URL + "/assets/logo.svg")
56 if err != nil {
57 t.Fatal(err)
58 }
59 wantLogo, err := os.ReadFile("../../assets/logo.svg")
60 if err != nil {
61 t.Fatal(err)
62 }
63 if logo.StatusCode != 200 || read(t, logo) != string(wantLogo) {
64 t.Fatalf("logo %d wijkt af van assets/logo.svg", logo.StatusCode)
65 }
66 if ct := logo.Header.Get("Content-Type"); !strings.Contains(ct, "image/svg+xml") {
67 t.Fatalf("favicon-type %s", ct)
68 }
69 csrf := csrfOf(t, body)
70 form := url.Values{"csrf": {csrf}, "name": {"demo"}, "description": {"eerste"}, "visibility": {"private"}}
71 res, err = client.PostForm(ts.URL+"/new/repo", form)
72 if err != nil {
73 t.Fatal(err)
74 }
75 body = read(t, res)
76 if !strings.Contains(body, "tim/demo") {
77 t.Fatalf("repo pagina:\n%s", body)
78 }
79 if !strings.Contains(body, "ssh://git@git.timfalken.com:22/tim/demo.git") {
80 t.Fatalf("clone-URL hoort de publieke SSH-poort te tonen:\n%s", body)
81 }
82 if strings.Contains(body, ":2222/") {
83 t.Fatalf("clone-URL toont de bindpoort:\n%s", body)
84 }
85
86 res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, body)}, "name": {"test"}})
87 if err != nil {
88 t.Fatal(err)
89 }
90 body = read(t, res)
91 token := between(body, `<p class="code">`, "</p>")
92 if !strings.HasPrefix(token, "bg_") {
93 t.Fatalf("token pagina:\n%s", body)
94 }
95
96 work := t.TempDir()
97 git(t, work, "init", "-b", "master")
98 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
99 git(t, work, "config", "user.name", "tim")
100 if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("hallo bluegit\n"), 0o644); err != nil {
101 t.Fatal(err)
102 }
103 git(t, work, "add", "README.md")
104 git(t, work, "commit", "-m", "eerste commit")
105 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/demo.git"
106 git(t, work, "remote", "add", "origin", remote)
107 git(t, work, "push", "-u", "origin", "master")
108
109 res, err = client.Get(ts.URL + "/tim/demo")
110 if err != nil {
111 t.Fatal(err)
112 }
113 body = read(t, res)
114 if !strings.Contains(body, "eerste commit") || !strings.Contains(body, "README.md") {
115 t.Fatalf("na push:\n%s", body)
116 }
117 res, err = client.Get(ts.URL + "/tim/demo/-/blob/README.md")
118 if err != nil {
119 t.Fatal(err)
120 }
121 body = read(t, res)
122 if !strings.Contains(body, "hallo bluegit") {
123 t.Fatalf("blob:\n%s", body)
124 }
125
126 ctx := context.Background()
127 ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
128 if err != nil {
129 t.Fatal(err)
130 }
131 repo, err := st.RepoByPath(ctx, "tim", "demo")
132 if err != nil {
133 t.Fatal(err)
134 }
135 if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
136 t.Fatal(err)
137 }
138 sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
139 if err != nil {
140 t.Fatal(err)
141 }
142 adaJar, _ := cookiejar.New(nil)
143 adaClient := &http.Client{Jar: adaJar}
144 u, _ := url.Parse(ts.URL)
145 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
146 res, err = adaClient.Get(ts.URL + "/")
147 if err != nil {
148 t.Fatal(err)
149 }
150 adaCSRF := csrfOf(t, read(t, res))
151 res, err = adaClient.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
152 "csrf": {adaCSRF}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
153 })
154 if err != nil {
155 t.Fatal(err)
156 }
157 if res.StatusCode != http.StatusForbidden {
158 t.Fatalf("ontwikkelaar mocht een geheim schrijven: %d", res.StatusCode)
159 }
160 _ = res.Body.Close()
161
162 res, err = client.Get(ts.URL + "/tim/demo/-/settings?tab=geheimen")
163 if err != nil {
164 t.Fatal(err)
165 }
166 ownerPage := read(t, res)
167 res, err = client.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
168 "csrf": {csrfOf(t, ownerPage)}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
169 })
170 if err != nil {
171 t.Fatal(err)
172 }
173 saved := read(t, res)
174 if strings.Contains(saved, "super-geheim-waarde") {
175 t.Fatal("geheimwaarde staat op de pagina")
176 }
177 if !strings.Contains(saved, "TOKEN") {
178 t.Fatalf("naam ontbreekt:\n%s", saved)
179 }
180
181 res, err = client.PostForm(ts.URL+"/tim/demo/-/webhooks", url.Values{
182 "csrf": {csrfOf(t, saved)}, "name": {"kapot"}, "preset": {"generic"},
183 "url": {"https://example.test/hook"}, "branch_filter": {"re:("}, "event_push": {"1"},
184 })
185 if err != nil {
186 t.Fatal(err)
187 }
188 hookPage := read(t, res)
189 if !strings.Contains(hookPage, "branchfilter") && !strings.Contains(hookPage, "error") && !strings.Contains(strings.ToLower(hookPage), "regex") {
190 t.Fatalf("kapot filter:\n%s", hookPage)
191 }
192}
193
194func TestSetupChoosesStorage(t *testing.T) {
195 storage := t.TempDir()
196 stateDir := t.TempDir()
197 key := bytes32()
198 st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), key)
199 if err != nil {
200 t.Fatal(err)
201 }
202 t.Cleanup(func() { _ = st.Close() })
203 cfg := config.Config{
204 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0",
205 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
206 Git: config.Git{Binary: "git", DefaultBranch: "master"},
207 }
208 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
209 ts := httptest.NewServer(srv.Handler())
210 t.Cleanup(ts.Close)
211
212 res, err := http.Get(ts.URL + "/tim/demo.git/info/refs?service=git-upload-pack")
213 if err != nil {
214 t.Fatal(err)
215 }
216 body := read(t, res)
217 if res.StatusCode != http.StatusServiceUnavailable || !strings.Contains(body, "nog niet ingesteld") {
218 t.Fatalf("git zonder opslag: %d %s", res.StatusCode, body)
219 }
220
221 jar, _ := cookiejar.New(nil)
222 client := &http.Client{Jar: jar}
223 res, err = client.Get(ts.URL + "/login")
224 if err != nil {
225 t.Fatal(err)
226 }
227 page := read(t, res)
228 if res.StatusCode != 200 || !strings.Contains(page, "Opslag kiezen") {
229 t.Fatalf("setup:\n%s", page)
230 }
231 res, err = client.PostForm(ts.URL+"/setup", url.Values{"csrf": {csrfOf(t, page)}, "path": {"relatief"}})
232 if err != nil {
233 t.Fatal(err)
234 }
235 page = read(t, res)
236 if !strings.Contains(page, "absoluut") {
237 t.Fatalf("relatief pad:\n%s", page)
238 }
239 res, err = client.PostForm(ts.URL+"/setup", url.Values{"csrf": {csrfOf(t, page)}, "path": {storage}})
240 if err != nil {
241 t.Fatal(err)
242 }
243 page = read(t, res)
244 if !strings.Contains(page, "Overzicht") || !strings.Contains(page, "vrij") {
245 t.Fatalf("na opslaan:\n%s", page)
246 }
247 if srv.StoragePath() != storage {
248 t.Fatalf("pad %s", srv.StoragePath())
249 }
250 saved, err := os.ReadFile(filepath.Join(stateDir, "storage_path"))
251 if err != nil || strings.TrimSpace(string(saved)) != storage {
252 t.Fatalf("bestand %q %v", saved, err)
253 }
254 res, err = client.Get(ts.URL + "/setup")
255 if err != nil {
256 t.Fatal(err)
257 }
258 page = read(t, res)
259 if !strings.Contains(page, "verplaatst geen") || !strings.Contains(page, "Vrije ruimte") {
260 t.Fatalf("wijzigen:\n%s", page)
261 }
262 res, err = http.Get(ts.URL + "/tim/demo.git/info/refs?service=git-upload-pack")
263 if err != nil {
264 t.Fatal(err)
265 }
266 body = read(t, res)
267 if res.StatusCode == http.StatusServiceUnavailable {
268 t.Fatalf("git blijft geblokkeerd: %s", body)
269 }
270
271 ada, err := st.UpsertUser(context.Background(), 2, "ada", "", true)
272 if err != nil {
273 t.Fatal(err)
274 }
275 if ada.InstanceAdmin {
276 t.Fatal("is_admin werd installatiebeheerder")
277 }
278 sess, err := st.CreateSession(context.Background(), ada.ID, "dev", time.Now().Add(time.Hour))
279 if err != nil {
280 t.Fatal(err)
281 }
282 adaJar, _ := cookiejar.New(nil)
283 adaClient := &http.Client{Jar: adaJar}
284 u, _ := url.Parse(ts.URL)
285 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
286 res, err = adaClient.Get(ts.URL + "/setup")
287 if err != nil {
288 t.Fatal(err)
289 }
290 if res.StatusCode != http.StatusForbidden {
291 t.Fatalf("ada setup %d %s", res.StatusCode, read(t, res))
292 }
293 _ = res.Body.Close()
294}
295
296func csrfOf(t *testing.T, body string) string {
297 t.Helper()
298 const needle = `name="csrf" value="`
299 i := strings.Index(body, needle)
300 if i < 0 {
301 t.Fatalf("geen csrf in\n%s", body)
302 }
303 rest := body[i+len(needle):]
304 j := strings.Index(rest, `"`)
305 return rest[:j]
306}
307
308func between(s, a, b string) string {
309 i := strings.Index(s, a)
310 if i < 0 {
311 return ""
312 }
313 rest := s[i+len(a):]
314 j := strings.Index(rest, b)
315 if j < 0 {
316 return ""
317 }
318 return rest[:j]
319}
320
321func read(t *testing.T, res *http.Response) string {
322 t.Helper()
323 defer res.Body.Close()
324 b, err := io.ReadAll(res.Body)
325 if err != nil {
326 t.Fatal(err)
327 }
328 return string(b)
329}
330
331func git(t *testing.T, dir string, args ...string) {
332 t.Helper()
333 cmd := exec.Command("git", args...)
334 cmd.Dir = dir
335 out, err := cmd.CombinedOutput()
336 if err != nil {
337 t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
338 }
339}
340
341func bytes32() []byte {
342 b := make([]byte, 32)
343 for i := range b {
344 b[i] = byte(i + 3)
345 }
346 return b
347}