BlueGit

timfa bluegit

Files

bluegit / internal / server / server_test.go

server_test.go

feat: eerste basis van BlueGit
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
151aa352 History
server_test.go 6.1 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: "main"},
37 CI: config.CI{Enabled: false},
38 }
39 cfg.Auth.BaseURL = "https://auth.timfalken.com"
40 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
41 ts := httptest.NewServer(srv.Handler())
42 t.Cleanup(ts.Close)
43
44 jar, _ := cookiejar.New(nil)
45 client := &http.Client{Jar: jar}
46 res, err := client.Get(ts.URL + "/login")
47 if err != nil {
48 t.Fatal(err)
49 }
50 body := read(t, res)
51 if res.StatusCode != 200 || !strings.Contains(body, "Overzicht") {
52 t.Fatalf("login %d %s", res.StatusCode, body)
53 }
54 logo, err := client.Get(ts.URL + "/assets/logo.svg")
55 if err != nil {
56 t.Fatal(err)
57 }
58 if logo.StatusCode != 200 || !strings.Contains(read(t, logo), "<svg") {
59 t.Fatalf("logo %d", logo.StatusCode)
60 }
61 csrf := csrfOf(t, body)
62 form := url.Values{"csrf": {csrf}, "name": {"demo"}, "description": {"eerste"}, "visibility": {"private"}}
63 res, err = client.PostForm(ts.URL+"/new/repo", form)
64 if err != nil {
65 t.Fatal(err)
66 }
67 body = read(t, res)
68 if !strings.Contains(body, "tim/demo") {
69 t.Fatalf("repo pagina:\n%s", body)
70 }
71
72 res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, body)}, "name": {"test"}})
73 if err != nil {
74 t.Fatal(err)
75 }
76 body = read(t, res)
77 token := between(body, `<p class="code">`, "</p>")
78 if !strings.HasPrefix(token, "bg_") {
79 t.Fatalf("token pagina:\n%s", body)
80 }
81
82 work := t.TempDir()
83 git(t, work, "init", "-b", "main")
84 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
85 git(t, work, "config", "user.name", "tim")
86 if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("hallo bluegit\n"), 0o644); err != nil {
87 t.Fatal(err)
88 }
89 git(t, work, "add", "README.md")
90 git(t, work, "commit", "-m", "eerste commit")
91 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/demo.git"
92 git(t, work, "remote", "add", "origin", remote)
93 git(t, work, "push", "-u", "origin", "main")
94
95 res, err = client.Get(ts.URL + "/tim/demo")
96 if err != nil {
97 t.Fatal(err)
98 }
99 body = read(t, res)
100 if !strings.Contains(body, "eerste commit") || !strings.Contains(body, "README.md") {
101 t.Fatalf("na push:\n%s", body)
102 }
103 res, err = client.Get(ts.URL + "/tim/demo/-/blob/README.md")
104 if err != nil {
105 t.Fatal(err)
106 }
107 body = read(t, res)
108 if !strings.Contains(body, "hallo bluegit") {
109 t.Fatalf("blob:\n%s", body)
110 }
111
112 ctx := context.Background()
113 ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
114 if err != nil {
115 t.Fatal(err)
116 }
117 repo, err := st.RepoByPath(ctx, "tim", "demo")
118 if err != nil {
119 t.Fatal(err)
120 }
121 if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
122 t.Fatal(err)
123 }
124 sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
125 if err != nil {
126 t.Fatal(err)
127 }
128 adaJar, _ := cookiejar.New(nil)
129 adaClient := &http.Client{Jar: adaJar}
130 u, _ := url.Parse(ts.URL)
131 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
132 res, err = adaClient.Get(ts.URL + "/")
133 if err != nil {
134 t.Fatal(err)
135 }
136 adaCSRF := csrfOf(t, read(t, res))
137 res, err = adaClient.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
138 "csrf": {adaCSRF}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
139 })
140 if err != nil {
141 t.Fatal(err)
142 }
143 if res.StatusCode != http.StatusForbidden {
144 t.Fatalf("ontwikkelaar mocht een geheim schrijven: %d", res.StatusCode)
145 }
146 _ = res.Body.Close()
147
148 res, err = client.Get(ts.URL + "/tim/demo/-/settings?tab=geheimen")
149 if err != nil {
150 t.Fatal(err)
151 }
152 ownerPage := read(t, res)
153 res, err = client.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
154 "csrf": {csrfOf(t, ownerPage)}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
155 })
156 if err != nil {
157 t.Fatal(err)
158 }
159 saved := read(t, res)
160 if strings.Contains(saved, "super-geheim-waarde") {
161 t.Fatal("geheimwaarde staat op de pagina")
162 }
163 if !strings.Contains(saved, "TOKEN") {
164 t.Fatalf("naam ontbreekt:\n%s", saved)
165 }
166
167 res, err = client.PostForm(ts.URL+"/tim/demo/-/webhooks", url.Values{
168 "csrf": {csrfOf(t, saved)}, "name": {"kapot"}, "preset": {"generic"},
169 "url": {"https://example.test/hook"}, "branch_filter": {"re:("}, "event_push": {"1"},
170 })
171 if err != nil {
172 t.Fatal(err)
173 }
174 hookPage := read(t, res)
175 if !strings.Contains(hookPage, "branchfilter") && !strings.Contains(hookPage, "error") && !strings.Contains(strings.ToLower(hookPage), "regex") {
176 t.Fatalf("kapot filter:\n%s", hookPage)
177 }
178}
179
180func csrfOf(t *testing.T, body string) string {
181 t.Helper()
182 const needle = `name="csrf" value="`
183 i := strings.Index(body, needle)
184 if i < 0 {
185 t.Fatalf("geen csrf in\n%s", body)
186 }
187 rest := body[i+len(needle):]
188 j := strings.Index(rest, `"`)
189 return rest[:j]
190}
191
192func between(s, a, b string) string {
193 i := strings.Index(s, a)
194 if i < 0 {
195 return ""
196 }
197 rest := s[i+len(a):]
198 j := strings.Index(rest, b)
199 if j < 0 {
200 return ""
201 }
202 return rest[:j]
203}
204
205func read(t *testing.T, res *http.Response) string {
206 t.Helper()
207 defer res.Body.Close()
208 b, err := io.ReadAll(res.Body)
209 if err != nil {
210 t.Fatal(err)
211 }
212 return string(b)
213}
214
215func git(t *testing.T, dir string, args ...string) {
216 t.Helper()
217 cmd := exec.Command("git", args...)
218 cmd.Dir = dir
219 out, err := cmd.CombinedOutput()
220 if err != nil {
221 t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
222 }
223}
224
225func bytes32() []byte {
226 b := make([]byte, 32)
227 for i := range b {
228 b[i] = byte(i + 3)
229 }
230 return b
231}