BlueGit

timfa bluegit

Files

bluegit / internal / server / profile_test.go

profile_test.go

profile_test.go 11.9 KiB Download Raw
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "net/http"
7 "net/http/cookiejar"
8 "net/http/httptest"
9 "net/url"
10 "path/filepath"
11 "strings"
12 "testing"
13 "time"
14
15 "gitlab.com/Timfa/bluegit/internal/access"
16 "gitlab.com/Timfa/bluegit/internal/auth"
17 "gitlab.com/Timfa/bluegit/internal/config"
18 "gitlab.com/Timfa/bluegit/internal/store"
19)
20
21func TestProfilePage(t *testing.T) {
22 storage := t.TempDir()
23 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
24 if err != nil {
25 t.Fatal(err)
26 }
27 t.Cleanup(func() { _ = st.Close() })
28 cfg := config.Config{
29 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
30 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
31 Git: config.Git{Binary: "git", DefaultBranch: "master"},
32 }
33 cfg.Auth.BaseURL = "https://auth.timfalken.com"
34 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
35 ts := httptest.NewServer(srv.Handler())
36 t.Cleanup(ts.Close)
37 srv.Cfg.BaseURL = ts.URL
38
39 jar, _ := cookiejar.New(nil)
40 client := &http.Client{Jar: jar}
41 res, err := client.Get(ts.URL + "/login")
42 if err != nil {
43 t.Fatal(err)
44 }
45 page := read(t, res)
46 ctx := context.Background()
47 tim, err := st.UserByUsername(ctx, "tim")
48 if err != nil {
49 t.Fatal(err)
50 }
51 ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
52 if err != nil {
53 t.Fatal(err)
54 }
55 plein, err := st.CreateGroup(ctx, tim.ID, "Plein", "plein", "open plein", access.RoleDeveloper)
56 if err != nil {
57 t.Fatal(err)
58 }
59 if err := st.UpdateGroup(ctx, plein.ID, "open plein", "public", access.RoleDeveloper); err != nil {
60 t.Fatal(err)
61 }
62 if err := st.SetLogoMIME(ctx, "group", plein.ID, "image/png"); err != nil {
63 t.Fatal(err)
64 }
65 kluis, err := st.CreateGroup(ctx, tim.ID, "Kluis", "kluis", "dichte kluis", access.RoleDeveloper)
66 if err != nil {
67 t.Fatal(err)
68 }
69 zichtbaar, err := st.CreateRepo(ctx, "user", tim.ID, "zichtbaar", "Zichtbare repo", "master", "public")
70 if err != nil {
71 t.Fatal(err)
72 }
73 if err := st.SetLogoMIME(ctx, "repo", zichtbaar.ID, "image/png"); err != nil {
74 t.Fatal(err)
75 }
76 geheim, err := st.CreateRepo(ctx, "user", tim.ID, "geheim", "Geheim project", "master", "private")
77 if err != nil {
78 t.Fatal(err)
79 }
80 if _, err := st.CreateRepo(ctx, "group", plein.ID, "gedeeld", "Groepsrepo", "master", "public"); err != nil {
81 t.Fatal(err)
82 }
83 if err := st.AddContributions(ctx, []store.Contribution{
84 {UserID: tim.ID, RepoID: zichtbaar.ID, Kind: "commit", Ref: "pub", At: time.Now()},
85 {UserID: tim.ID, RepoID: geheim.ID, Kind: "commit", Ref: "priv", At: time.Now()},
86 }); err != nil {
87 t.Fatal(err)
88 }
89 if err := st.SetMember(ctx, "repo", repoID(t, st, "tim", "geheim"), "ada", access.RoleDeveloper); err != nil {
90 t.Fatal(err)
91 }
92 if err := st.SetMember(ctx, "group", kluis.ID, "ada", access.RoleDeveloper); err != nil {
93 t.Fatal(err)
94 }
95
96 share := ts.URL + "/users/tim"
97 res, err = client.Get(ts.URL + "/")
98 if err != nil {
99 t.Fatal(err)
100 }
101 dash := read(t, res)
102 for _, want := range []string{
103 `class="usercard panel"`,
104 `<h2>tim</h2>`,
105 `@tim`,
106 `data-copy="` + share + `"`,
107 `href="/settings">Edit profile`,
108 `href="/users/tim"`,
109 `<strong>2</strong> <span>Repositories</span>`,
110 `<strong>2</strong> <span>Groups</span>`,
111 "plein/gedeeld",
112 "Activity",
113 } {
114 if !strings.Contains(dash, want) {
115 t.Fatalf("dashboard mist %q", want)
116 }
117 }
118 if strings.Index(dash, "Activity") > strings.Index(dash, "Repositories</span></h2>") {
119 t.Fatal("heatmap staat onder de repositorylijst")
120 }
121
122 anon := &http.Client{}
123 res, err = anon.Get(share)
124 if err != nil {
125 t.Fatal(err)
126 }
127 pub := read(t, res)
128 for _, want := range []string{
129 "<h1>tim</h1>",
130 `@tim`,
131 "Member since",
132 `data-copy="` + share + `"`,
133 `src="/tim/zichtbaar/-/logo"`,
134 `href="/tim/zichtbaar"`,
135 "Zichtbare repo",
136 `src="/groups/plein/logo"`,
137 `href="/groups/plein"`,
138 `<strong>1</strong> <span>Repositories</span>`,
139 `<strong>1</strong> <span>Groups</span>`,
140 `<strong>1</strong> <span>Contributions</span>`,
141 `class="repoacts"`,
142 `data-copy="` + ts.URL + `/tim/zichtbaar"`,
143 `class="starbtn"`,
144 } {
145 if !strings.Contains(pub, want) {
146 t.Fatalf("openbaar profiel mist %q", want)
147 }
148 }
149 if strings.Contains(pub, `action="/tim/zichtbaar/-/star"`) {
150 t.Fatal("anonieme bezoeker krijgt een ster-formulier")
151 }
152 for _, ban := range []string{"geheim", "Geheim project", "kluis", "Kluis", "Edit profile", "plein/gedeeld"} {
153 if strings.Contains(pub, ban) {
154 t.Fatalf("openbaar profiel toont %q", ban)
155 }
156 }
157
158 adaJar, _ := cookiejar.New(nil)
159 adaClient := &http.Client{Jar: adaJar}
160 sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
161 if err != nil {
162 t.Fatal(err)
163 }
164 u, _ := url.Parse(ts.URL)
165 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
166 res, err = adaClient.Get(share)
167 if err != nil {
168 t.Fatal(err)
169 }
170 adaPage := read(t, res)
171 for _, want := range []string{
172 `href="/tim/geheim"`,
173 "Geheim project",
174 `href="/groups/kluis"`,
175 `<strong>2</strong> <span>Repositories</span>`,
176 `<strong>2</strong> <span>Groups</span>`,
177 `<strong>2</strong> <span>Contributions</span>`,
178 } {
179 if !strings.Contains(adaPage, want) {
180 t.Fatalf("ada ziet niet %q", want)
181 }
182 }
183 if strings.Contains(adaPage, "Edit profile") || strings.Contains(adaPage, "plein/gedeeld") {
184 t.Fatal("ada ziet Tims bewerkknop of een groepsrepository")
185 }
186
187 res, err = client.Get(ts.URL + "/settings")
188 if err != nil {
189 t.Fatal(err)
190 }
191 settings := read(t, res)
192 if !strings.Contains(settings, "Display name") || !strings.Contains(settings, "Bio") {
193 t.Fatal("instellingen missen weergavenaam of bio")
194 }
195 res, err = client.PostForm(ts.URL+"/settings/profile", url.Values{
196 "csrf": {csrfOf(t, settings)}, "name": {"Regel\neen"}, "bio": {"nee"},
197 })
198 if err != nil {
199 t.Fatal(err)
200 }
201 bad := read(t, res)
202 if !strings.Contains(bad, "line break") {
203 t.Fatalf("ongeldige naam:\n%s", bad)
204 }
205 res, err = client.PostForm(ts.URL+"/settings/profile", url.Values{
206 "csrf": {csrfOf(t, bad)}, "name": {"Tim Falken"}, "bio": {"Bouwt BlueGit."},
207 })
208 if err != nil {
209 t.Fatal(err)
210 }
211 saved := read(t, res)
212 if !strings.Contains(saved, "Profile saved") || !strings.Contains(saved, `value="Tim Falken"`) {
213 t.Fatalf("profiel opslaan:\n%s", saved)
214 }
215 res, err = client.Get(share)
216 if err != nil {
217 t.Fatal(err)
218 }
219 named := read(t, res)
220 for _, want := range []string{"<h1>Tim Falken</h1>", "@tim", "Bouwt BlueGit.", "Edit profile"} {
221 if !strings.Contains(named, want) {
222 t.Fatalf("profiel na opslaan mist %q", want)
223 }
224 }
225
226 timToken, err := st.CreateToken(ctx, tim.ID, "tim")
227 if err != nil {
228 t.Fatal(err)
229 }
230 adaToken, err := st.CreateToken(ctx, ada.ID, "ada")
231 if err != nil {
232 t.Fatal(err)
233 }
234 mine := apiGet(t, ts.URL+"/api/v1/users/tim", timToken)
235 if mine["name"] != "Tim Falken" || mine["bio"] != "Bouwt BlueGit." || mine["web_url"] != share {
236 t.Fatalf("api zelf: %#v", mine)
237 }
238 if mine["instance_admin"] != true || mine["language"] != "en" {
239 t.Fatalf("api zelf mist eigen velden: %#v", mine)
240 }
241 counts := mine["counts"].(map[string]any)
242 if counts["repos"] != 2.0 || counts["groups"] != 2.0 || counts["contributions"] != 2.0 {
243 t.Fatalf("api tellingen: %#v", counts)
244 }
245 if !apiPaths(mine["repos"]).has("tim/zichtbaar", "tim/geheim") || apiPaths(mine["repos"]).has("plein/gedeeld") {
246 t.Fatalf("api repos: %#v", mine["repos"])
247 }
248 if !apiPaths(mine["groups"]).has("plein", "kluis") {
249 t.Fatalf("api groepen: %#v", mine["groups"])
250 }
251 other := apiGet(t, ts.URL+"/api/v1/users/tim", adaToken)
252 if _, ok := other["instance_admin"]; ok || other["language"] != nil {
253 t.Fatalf("api van ada toont Tims privévelden: %#v", other)
254 }
255 if !apiPaths(other["repos"]).has("tim/geheim") || !apiPaths(other["groups"]).has("kluis") {
256 t.Fatalf("api van ada mist privé: %#v %#v", other["repos"], other["groups"])
257 }
258 if other["counts"].(map[string]any)["contributions"] != 2.0 {
259 t.Fatalf("api van ada telt verborgen bijdragen niet mee: %#v", other["counts"])
260 }
261 pubAPI := apiGet(t, ts.URL+"/api/v1/users/tim", "")
262 if _, ok := pubAPI["instance_admin"]; ok || pubAPI["language"] != nil {
263 t.Fatalf("anonieme api toont privévelden: %#v", pubAPI)
264 }
265 if apiPaths(pubAPI["repos"]).has("tim/geheim") || apiPaths(pubAPI["groups"]).has("kluis") || !apiPaths(pubAPI["repos"]).has("tim/zichtbaar") {
266 t.Fatalf("anonieme api filter: %#v %#v", pubAPI["repos"], pubAPI["groups"])
267 }
268 if pubAPI["counts"].(map[string]any)["contributions"] != 1.0 {
269 t.Fatalf("anonieme api lekt privébijdragen: %#v", pubAPI["counts"])
270 }
271 badTok, err := http.NewRequest(http.MethodGet, ts.URL+"/api/v1/users/tim", nil)
272 if err != nil {
273 t.Fatal(err)
274 }
275 badTok.Header.Set("Authorization", "Bearer bg_nietgeldig")
276 res, err = http.DefaultClient.Do(badTok)
277 if err != nil {
278 t.Fatal(err)
279 }
280 if res.StatusCode != http.StatusUnauthorized {
281 t.Fatalf("ongeldig token %d", res.StatusCode)
282 }
283 _ = res.Body.Close()
284 req, err := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/user", strings.NewReader(`{"bio":"alleen bio"}`))
285 if err != nil {
286 t.Fatal(err)
287 }
288 req.Header.Set("Authorization", "Bearer "+timToken)
289 req.Header.Set("Content-Type", "application/json")
290 res, err = http.DefaultClient.Do(req)
291 if err != nil {
292 t.Fatal(err)
293 }
294 put := decodeJSON(t, res)
295 if put["bio"] != "alleen bio" || put["name"] != "Tim Falken" || put["language"] != "en" {
296 t.Fatalf("put bio: %#v", put)
297 }
298
299 noredir := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
300 res, err = noredir.Get(ts.URL + "/tim")
301 if err != nil {
302 t.Fatal(err)
303 }
304 loc := res.Header.Get("Location")
305 if res.StatusCode != http.StatusFound || loc != "/users/tim" {
306 t.Fatalf("/tim is %d locatie %q", res.StatusCode, loc)
307 }
308 _ = res.Body.Close()
309 res, err = noredir.Get(ts.URL + "/plein")
310 if err != nil {
311 t.Fatal(err)
312 }
313 if res.StatusCode != http.StatusNotFound || res.Header.Get("Location") != "" {
314 t.Fatalf("groepsnaam /plein is %d locatie %q", res.StatusCode, res.Header.Get("Location"))
315 }
316 _ = res.Body.Close()
317 res, err = noredir.Get(ts.URL + "/tim/zichtbaar")
318 if err != nil {
319 t.Fatal(err)
320 }
321 if res.StatusCode == http.StatusFound && strings.HasPrefix(res.Header.Get("Location"), "/users/") {
322 t.Fatalf("repositorypad wijst naar een profiel: %s", res.Header.Get("Location"))
323 }
324 _ = res.Body.Close()
325 res, err = noredir.Get(ts.URL + "/login")
326 if err != nil {
327 t.Fatal(err)
328 }
329 if strings.Contains(res.Header.Get("Location"), "/users/") {
330 t.Fatalf("login wijst naar een profiel: %s", res.Header.Get("Location"))
331 }
332 _ = res.Body.Close()
333 res, err = anon.Get(ts.URL + "/users/nobody")
334 if err != nil {
335 t.Fatal(err)
336 }
337 if res.StatusCode != http.StatusNotFound {
338 t.Fatalf("onbekend profiel %d", res.StatusCode)
339 }
340 _ = res.Body.Close()
341 _ = page
342}
343
344func repoID(t *testing.T, st *store.Store, owner, name string) int64 {
345 t.Helper()
346 repo, err := st.RepoByPath(context.Background(), owner, name)
347 if err != nil {
348 t.Fatal(err)
349 }
350 return repo.ID
351}
352
353func apiGet(t *testing.T, rawURL, token string) map[string]any {
354 t.Helper()
355 req, err := http.NewRequest(http.MethodGet, rawURL, nil)
356 if err != nil {
357 t.Fatal(err)
358 }
359 if token != "" {
360 req.Header.Set("Authorization", "Bearer "+token)
361 }
362 res, err := http.DefaultClient.Do(req)
363 if err != nil {
364 t.Fatal(err)
365 }
366 body := decodeJSON(t, res)
367 if res.StatusCode != http.StatusOK {
368 t.Fatalf("api %s: %d %#v", rawURL, res.StatusCode, body)
369 }
370 return body
371}
372
373func decodeJSON(t *testing.T, res *http.Response) map[string]any {
374 t.Helper()
375 defer res.Body.Close()
376 var body map[string]any
377 if err := json.NewDecoder(res.Body).Decode(&body); err != nil {
378 t.Fatal(err)
379 }
380 return body
381}
382
383type pathSet map[string]bool
384
385func apiPaths(v any) pathSet {
386 out := pathSet{}
387 list, _ := v.([]any)
388 for _, item := range list {
389 row, _ := item.(map[string]any)
390 if p, ok := row["path"].(string); ok {
391 out[p] = true
392 }
393 }
394 return out
395}
396
397func (p pathSet) has(want ...string) bool {
398 for _, w := range want {
399 if !p[w] {
400 return false
401 }
402 }
403 return true
404}