BlueGit

timfa bluegit

Files

bluegit / internal / server / extra_test.go

extra_test.go

extra_test.go 9.7 KiB Download Raw
1package server
2
3import (
4 "bytes"
5 "context"
6 "image"
7 "image/color"
8 "image/png"
9 "io"
10 "mime/multipart"
11 "net/http"
12 "net/http/cookiejar"
13 "net/http/httptest"
14 "net/url"
15 "os/exec"
16 "path/filepath"
17 "strings"
18 "testing"
19 "unicode/utf8"
20
21 "gitlab.com/Timfa/bluegit/internal/access"
22 "gitlab.com/Timfa/bluegit/internal/auth"
23 "gitlab.com/Timfa/bluegit/internal/config"
24 "gitlab.com/Timfa/bluegit/internal/store"
25)
26
27func TestSlugAvailabilityDefaultRoleLogoAndLanguage(t *testing.T) {
28 if _, err := exec.LookPath("git"); err != nil {
29 t.Skip("git ontbreekt")
30 }
31 storage := t.TempDir()
32 stateDir := t.TempDir()
33 st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32())
34 if err != nil {
35 t.Fatal(err)
36 }
37 t.Cleanup(func() { _ = st.Close() })
38 cfg := config.Config{
39 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
40 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
41 Git: config.Git{Binary: "git", DefaultBranch: "master"},
42 }
43 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
44 ts := httptest.NewServer(srv.Handler())
45 t.Cleanup(ts.Close)
46 jar, _ := cookiejar.New(nil)
47 client := &http.Client{Jar: jar}
48 res, err := client.Get(ts.URL + "/login")
49 if err != nil {
50 t.Fatal(err)
51 }
52 page := read(t, res)
53 ctx := context.Background()
54
55 res, err = client.PostForm(ts.URL+"/new/group", url.Values{
56 "csrf": {csrfOf(t, page)}, "name": {"Studio"}, "default_role": {"readonly"},
57 })
58 if err != nil {
59 t.Fatal(err)
60 }
61 page = read(t, res)
62 if !strings.Contains(page, ">Studio<") || !strings.Contains(page, "Repositories") {
63 t.Fatalf("groepspagina:\n%s", page)
64 }
65 ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
66 if err != nil {
67 t.Fatal(err)
68 }
69 g, err := st.GroupByPath(ctx, "studio")
70 if err != nil {
71 t.Fatal(err)
72 }
73 if g.DefaultRole != access.RoleReadonly {
74 t.Fatalf("standaardrol %s", g.DefaultRole)
75 }
76 if err := st.SetMember(ctx, "group", g.ID, "ada", access.RoleDeveloper); err != nil {
77 t.Fatal(err)
78 }
79 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
80 "csrf": {csrfOf(t, page)}, "name": {"alpha"}, "group": {"studio"}, "visibility": {"private"},
81 })
82 if err != nil {
83 t.Fatal(err)
84 }
85 page = read(t, res)
86 if !strings.Contains(page, "studio/alpha") {
87 t.Fatalf("repo:\n%s", page)
88 }
89 alpha, err := st.RepoByPath(ctx, "studio", "alpha")
90 if err != nil {
91 t.Fatal(err)
92 }
93 role, err := st.EffectiveRole(ctx, ada.ID, alpha.ID)
94 if err != nil || role != access.RoleReadonly {
95 t.Fatalf("snapshot rol %s %v", role, err)
96 }
97
98 free, err := client.Get(ts.URL + "/new/slug?kind=repo&name=gamma&owner=studio")
99 if err != nil {
100 t.Fatal(err)
101 }
102 freeBody := read(t, free)
103 if !strings.Contains(freeBody, `"available":true`) {
104 t.Fatalf("vrij: %s", freeBody)
105 }
106 taken, err := client.Get(ts.URL + "/new/slug?kind=repo&name=alpha&owner=studio")
107 if err != nil {
108 t.Fatal(err)
109 }
110 takenBody := read(t, taken)
111 if !strings.Contains(takenBody, `"available":false`) || !strings.Contains(takenBody, "studio/alpha") {
112 t.Fatalf("bezet: %s", takenBody)
113 }
114
115 res, err = client.Get(ts.URL + "/groups/studio?tab=settings")
116 if err != nil {
117 t.Fatal(err)
118 }
119 settings := read(t, res)
120 res, err = client.PostForm(ts.URL+"/groups/studio/settings", url.Values{
121 "csrf": {csrfOf(t, settings)}, "visibility": {"public"}, "default_role": {"maintainer"}, "description": {"Werk"},
122 })
123 if err != nil {
124 t.Fatal(err)
125 }
126 _ = read(t, res)
127 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
128 "csrf": {csrfOf(t, settings)}, "name": {"beta"}, "group": {"studio"}, "visibility": {"public"},
129 })
130 if err != nil {
131 t.Fatal(err)
132 }
133 if res.StatusCode >= 400 {
134 t.Fatalf("beta %d %s", res.StatusCode, read(t, res))
135 }
136 _ = res.Body.Close()
137 beta, err := st.RepoByPath(ctx, "studio", "beta")
138 if err != nil {
139 t.Fatal(err)
140 }
141 role, err = st.EffectiveRole(ctx, ada.ID, beta.ID)
142 if err != nil || role != access.RoleMaintainer {
143 t.Fatalf("nieuwe repo %s %v", role, err)
144 }
145 role, err = st.EffectiveRole(ctx, ada.ID, alpha.ID)
146 if err != nil || role != access.RoleReadonly {
147 t.Fatalf("oude repo veranderde naar %s %v", role, err)
148 }
149 bob, err := st.UpsertUser(ctx, 3, "bob", "", false)
150 if err != nil {
151 t.Fatal(err)
152 }
153 if err := st.SetMember(ctx, "group", g.ID, "bob", access.RoleDeveloper); err != nil {
154 t.Fatal(err)
155 }
156 role, err = st.EffectiveRole(ctx, bob.ID, alpha.ID)
157 if err != nil || role != access.RoleDeveloper {
158 t.Fatalf("later lid %s %v", role, err)
159 }
160
161 anon := &http.Client{}
162 res, err = anon.Get(ts.URL + "/groups/studio")
163 if err != nil {
164 t.Fatal(err)
165 }
166 pub := read(t, res)
167 if res.StatusCode != 200 || strings.Contains(pub, "alpha") || !strings.Contains(pub, "beta") {
168 t.Fatalf("openbare groep %d\n%s", res.StatusCode, pub)
169 }
170
171 res, err = client.Get(ts.URL + "/groups/studio")
172 if err != nil {
173 t.Fatal(err)
174 }
175 list := read(t, res)
176 if !strings.Contains(list, "Activity") || !strings.Contains(list, "Created ") || !strings.Contains(list, "starbtn") {
177 t.Fatalf("lijst:\n%s", list)
178 }
179 if strings.Contains(list, `class="rowmenu"`) || strings.Contains(list, "group.menu") {
180 t.Fatalf("groepslijst heeft nog een submenu:\n%s", list)
181 }
182 if !strings.Contains(list, `data-copy="http://127.0.0.1:9/studio/beta"`) {
183 t.Fatalf("kopieerknop mist absolute URL:\n%s", list)
184 }
185 res, err = client.PostForm(ts.URL+"/studio/beta/-/star", url.Values{
186 "csrf": {csrfOf(t, list)}, "back": {"/groups/studio"},
187 })
188 if err != nil {
189 t.Fatal(err)
190 }
191 starred := read(t, res)
192 if !strings.Contains(starred, `class="starcount">1<`) || !strings.Contains(starred, `aria-label="Remove star"`) {
193 t.Fatalf("ster:\n%s", starred)
194 }
195 res, err = client.Get(ts.URL + "/groups/studio?q=alp&dir=desc")
196 if err != nil {
197 t.Fatal(err)
198 }
199 filtered := read(t, res)
200 if !strings.Contains(filtered, "alpha") || strings.Contains(filtered, "beta") {
201 t.Fatalf("zoeken:\n%s", filtered)
202 }
203
204 var buf bytes.Buffer
205 img := image.NewRGBA(image.Rect(0, 0, 800, 400))
206 for y := 0; y < 400; y++ {
207 for x := 0; x < 800; x++ {
208 img.Set(x, y, color.RGBA{R: 20, G: 80, B: 200, A: 255})
209 }
210 }
211 if err := png.Encode(&buf, img); err != nil {
212 t.Fatal(err)
213 }
214 body, contentType := multipartLogo(t, csrfOf(t, settings), buf.Bytes(), "wide.png")
215 req, err := http.NewRequest(http.MethodPost, ts.URL+"/groups/studio/logo", body)
216 if err != nil {
217 t.Fatal(err)
218 }
219 req.Header.Set("Content-Type", contentType)
220 res, err = client.Do(req)
221 if err != nil {
222 t.Fatal(err)
223 }
224 if res.StatusCode >= 400 {
225 t.Fatalf("upload %d %s", res.StatusCode, read(t, res))
226 }
227 _ = res.Body.Close()
228 res, err = client.Get(ts.URL + "/groups/studio")
229 if err != nil {
230 t.Fatal(err)
231 }
232 withLogo := read(t, res)
233 if !strings.Contains(withLogo, `/groups/studio/logo`) {
234 t.Fatalf("logo ontbreekt:\n%s", withLogo)
235 }
236 res, err = client.Get(ts.URL + "/groups/studio/logo")
237 if err != nil {
238 t.Fatal(err)
239 }
240 raw, err := io.ReadAll(res.Body)
241 res.Body.Close()
242 if err != nil {
243 t.Fatal(err)
244 }
245 got, _, err := image.Decode(bytes.NewReader(raw))
246 if err != nil {
247 t.Fatal(err)
248 }
249 if got.Bounds().Dx() != 512 || got.Bounds().Dy() != 256 {
250 t.Fatalf("geschalen %dx%d", got.Bounds().Dx(), got.Bounds().Dy())
251 }
252 res, err = client.Get(ts.URL + "/studio/beta")
253 if err != nil {
254 t.Fatal(err)
255 }
256 repoPage := read(t, res)
257 repoBody, repoType := multipartLogo(t, csrfOf(t, repoPage), buf.Bytes(), "wide.png")
258 req, err = http.NewRequest(http.MethodPost, ts.URL+"/studio/beta/-/logo", repoBody)
259 if err != nil {
260 t.Fatal(err)
261 }
262 req.Header.Set("Content-Type", repoType)
263 res, err = client.Do(req)
264 if err != nil {
265 t.Fatal(err)
266 }
267 _ = read(t, res)
268 res, err = client.Get(ts.URL + "/studio/beta")
269 if err != nil {
270 t.Fatal(err)
271 }
272 repoPage = read(t, res)
273 if !strings.Contains(repoPage, `/studio/beta/-/logo`) || strings.Contains(repoPage, `class="tile">B`) {
274 t.Fatalf("repo-logo:\n%s", repoPage)
275 }
276
277 res, err = client.Get(ts.URL + "/settings")
278 if err != nil {
279 t.Fatal(err)
280 }
281 account := read(t, res)
282 for _, lang := range []string{"nl", "de", "fr", "cuneiform"} {
283 res, err = client.PostForm(ts.URL+"/settings/language", url.Values{
284 "csrf": {csrfOf(t, account)}, "language": {lang},
285 })
286 if err != nil {
287 t.Fatal(err)
288 }
289 switched := read(t, res)
290 account = switched
291 switch lang {
292 case "nl":
293 if !strings.Contains(switched, "Overzicht") || !strings.Contains(switched, "Taal opgeslagen") {
294 t.Fatalf("nl:\n%s", switched)
295 }
296 case "de":
297 if !strings.Contains(switched, "Übersicht") || !strings.Contains(switched, "Sprache gespeichert") {
298 t.Fatalf("de:\n%s", switched)
299 }
300 case "fr":
301 if !strings.Contains(switched, "Aperçu") || !strings.Contains(switched, "Langue enregistrée") {
302 t.Fatalf("fr:\n%s", switched)
303 }
304 case "cuneiform":
305 if !strings.Contains(switched, `class="cunei"`) {
306 t.Fatalf("lettertype:\n%s", switched)
307 }
308 found := false
309 for _, r := range switched {
310 if r >= 0x12000 && r <= 0x123FF {
311 found = true
312 break
313 }
314 }
315 if !found || !utf8.ValidString(switched) {
316 t.Fatal("geen spijkerschrift op de pagina")
317 }
318 }
319 }
320 res, err = client.PostForm(ts.URL+"/settings/language", url.Values{
321 "csrf": {csrfOf(t, account)}, "language": {"en"},
322 })
323 if err != nil {
324 t.Fatal(err)
325 }
326 back := read(t, res)
327 if !strings.Contains(back, "Overview") || !strings.Contains(back, "Language saved") {
328 t.Fatalf("en:\n%s", back)
329 }
330}
331
332func multipartLogo(t *testing.T, csrf string, data []byte, name string) (*bytes.Buffer, string) {
333 t.Helper()
334 var buf bytes.Buffer
335 w := multipart.NewWriter(&buf)
336 if err := w.WriteField("csrf", csrf); err != nil {
337 t.Fatal(err)
338 }
339 part, err := w.CreateFormFile("logo", name)
340 if err != nil {
341 t.Fatal(err)
342 }
343 if _, err := part.Write(data); err != nil {
344 t.Fatal(err)
345 }
346 if err := w.Close(); err != nil {
347 t.Fatal(err)
348 }
349 return &buf, w.FormDataContentType()
350}