BlueGit

timfa bluegit

Files

bluegit / internal / server / extra_test.go

extra_test.go

feat: nieuw-formulier, groepsoverzicht, logo's en talen
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed d1203d3b History
extra_test.go 9.4 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, "★") {
177 t.Fatalf("lijst:\n%s", list)
178 }
179 res, err = client.PostForm(ts.URL+"/studio/beta/-/star", url.Values{
180 "csrf": {csrfOf(t, list)}, "back": {"/groups/studio"},
181 })
182 if err != nil {
183 t.Fatal(err)
184 }
185 starred := read(t, res)
186 if !strings.Contains(starred, "★ 1") {
187 t.Fatalf("ster:\n%s", starred)
188 }
189 res, err = client.Get(ts.URL + "/groups/studio?q=alp&dir=desc")
190 if err != nil {
191 t.Fatal(err)
192 }
193 filtered := read(t, res)
194 if !strings.Contains(filtered, "alpha") || strings.Contains(filtered, "beta") {
195 t.Fatalf("zoeken:\n%s", filtered)
196 }
197
198 var buf bytes.Buffer
199 img := image.NewRGBA(image.Rect(0, 0, 800, 400))
200 for y := 0; y < 400; y++ {
201 for x := 0; x < 800; x++ {
202 img.Set(x, y, color.RGBA{R: 20, G: 80, B: 200, A: 255})
203 }
204 }
205 if err := png.Encode(&buf, img); err != nil {
206 t.Fatal(err)
207 }
208 body, contentType := multipartLogo(t, csrfOf(t, settings), buf.Bytes(), "wide.png")
209 req, err := http.NewRequest(http.MethodPost, ts.URL+"/groups/studio/logo", body)
210 if err != nil {
211 t.Fatal(err)
212 }
213 req.Header.Set("Content-Type", contentType)
214 res, err = client.Do(req)
215 if err != nil {
216 t.Fatal(err)
217 }
218 if res.StatusCode >= 400 {
219 t.Fatalf("upload %d %s", res.StatusCode, read(t, res))
220 }
221 _ = res.Body.Close()
222 res, err = client.Get(ts.URL + "/groups/studio")
223 if err != nil {
224 t.Fatal(err)
225 }
226 withLogo := read(t, res)
227 if !strings.Contains(withLogo, `/groups/studio/logo`) {
228 t.Fatalf("logo ontbreekt:\n%s", withLogo)
229 }
230 res, err = client.Get(ts.URL + "/groups/studio/logo")
231 if err != nil {
232 t.Fatal(err)
233 }
234 raw, err := io.ReadAll(res.Body)
235 res.Body.Close()
236 if err != nil {
237 t.Fatal(err)
238 }
239 got, _, err := image.Decode(bytes.NewReader(raw))
240 if err != nil {
241 t.Fatal(err)
242 }
243 if got.Bounds().Dx() != 512 || got.Bounds().Dy() != 256 {
244 t.Fatalf("geschalen %dx%d", got.Bounds().Dx(), got.Bounds().Dy())
245 }
246 res, err = client.Get(ts.URL + "/studio/beta")
247 if err != nil {
248 t.Fatal(err)
249 }
250 repoPage := read(t, res)
251 repoBody, repoType := multipartLogo(t, csrfOf(t, repoPage), buf.Bytes(), "wide.png")
252 req, err = http.NewRequest(http.MethodPost, ts.URL+"/studio/beta/-/logo", repoBody)
253 if err != nil {
254 t.Fatal(err)
255 }
256 req.Header.Set("Content-Type", repoType)
257 res, err = client.Do(req)
258 if err != nil {
259 t.Fatal(err)
260 }
261 _ = read(t, res)
262 res, err = client.Get(ts.URL + "/studio/beta")
263 if err != nil {
264 t.Fatal(err)
265 }
266 repoPage = read(t, res)
267 if !strings.Contains(repoPage, `/studio/beta/-/logo`) || strings.Contains(repoPage, `class="tile">B`) {
268 t.Fatalf("repo-logo:\n%s", repoPage)
269 }
270
271 res, err = client.Get(ts.URL + "/settings")
272 if err != nil {
273 t.Fatal(err)
274 }
275 account := read(t, res)
276 for _, lang := range []string{"nl", "de", "fr", "cuneiform"} {
277 res, err = client.PostForm(ts.URL+"/settings/language", url.Values{
278 "csrf": {csrfOf(t, account)}, "language": {lang},
279 })
280 if err != nil {
281 t.Fatal(err)
282 }
283 switched := read(t, res)
284 account = switched
285 switch lang {
286 case "nl":
287 if !strings.Contains(switched, "Overzicht") || !strings.Contains(switched, "Taal opgeslagen") {
288 t.Fatalf("nl:\n%s", switched)
289 }
290 case "de":
291 if !strings.Contains(switched, "Übersicht") || !strings.Contains(switched, "Sprache gespeichert") {
292 t.Fatalf("de:\n%s", switched)
293 }
294 case "fr":
295 if !strings.Contains(switched, "Aperçu") || !strings.Contains(switched, "Langue enregistrée") {
296 t.Fatalf("fr:\n%s", switched)
297 }
298 case "cuneiform":
299 if !strings.Contains(switched, `class="cunei"`) {
300 t.Fatalf("lettertype:\n%s", switched)
301 }
302 found := false
303 for _, r := range switched {
304 if r >= 0x12000 && r <= 0x123FF {
305 found = true
306 break
307 }
308 }
309 if !found || !utf8.ValidString(switched) {
310 t.Fatal("geen spijkerschrift op de pagina")
311 }
312 }
313 }
314 res, err = client.PostForm(ts.URL+"/settings/language", url.Values{
315 "csrf": {csrfOf(t, account)}, "language": {"en"},
316 })
317 if err != nil {
318 t.Fatal(err)
319 }
320 back := read(t, res)
321 if !strings.Contains(back, "Overview") || !strings.Contains(back, "Language saved") {
322 t.Fatalf("en:\n%s", back)
323 }
324}
325
326func multipartLogo(t *testing.T, csrf string, data []byte, name string) (*bytes.Buffer, string) {
327 t.Helper()
328 var buf bytes.Buffer
329 w := multipart.NewWriter(&buf)
330 if err := w.WriteField("csrf", csrf); err != nil {
331 t.Fatal(err)
332 }
333 part, err := w.CreateFormFile("logo", name)
334 if err != nil {
335 t.Fatal(err)
336 }
337 if _, err := part.Write(data); err != nil {
338 t.Fatal(err)
339 }
340 if err := w.Close(); err != nil {
341 t.Fatal(err)
342 }
343 return &buf, w.FormDataContentType()
344}