BlueGit

timfa bluegit

Files

bluegit / internal / server / server_test.go

server_test.go

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