BlueGit

timfa bluegit

Files

bluegit / internal / server / profile_test.go

profile_test.go

feat: toon repositories en groepen op het profiel
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Passed 69db8c2f History
profile_test.go 9.4 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 if _, err := st.CreateRepo(ctx, "user", tim.ID, "geheim", "Geheim project", "master", "private"); err != nil {
77 t.Fatal(err)
78 }
79 if _, err := st.CreateRepo(ctx, "group", plein.ID, "gedeeld", "Groepsrepo", "master", "public"); err != nil {
80 t.Fatal(err)
81 }
82 if err := st.SetMember(ctx, "repo", repoID(t, st, "tim", "geheim"), "ada", access.RoleDeveloper); err != nil {
83 t.Fatal(err)
84 }
85 if err := st.SetMember(ctx, "group", kluis.ID, "ada", access.RoleDeveloper); err != nil {
86 t.Fatal(err)
87 }
88
89 share := ts.URL + "/users/tim"
90 res, err = client.Get(ts.URL + "/")
91 if err != nil {
92 t.Fatal(err)
93 }
94 dash := read(t, res)
95 for _, want := range []string{
96 `class="usercard panel"`,
97 `<h2>tim</h2>`,
98 `@tim`,
99 `data-copy="` + share + `"`,
100 `href="/settings">Edit profile`,
101 `href="/users/tim"`,
102 `<strong>2</strong> <span>Repositories</span>`,
103 `<strong>2</strong> <span>Groups</span>`,
104 "plein/gedeeld",
105 "Activity",
106 } {
107 if !strings.Contains(dash, want) {
108 t.Fatalf("dashboard mist %q", want)
109 }
110 }
111 if strings.Index(dash, "Activity") > strings.Index(dash, "<h2>Repositories</h2>") {
112 t.Fatal("heatmap staat onder de repositorylijst")
113 }
114
115 anon := &http.Client{}
116 res, err = anon.Get(share)
117 if err != nil {
118 t.Fatal(err)
119 }
120 pub := read(t, res)
121 for _, want := range []string{
122 "<h1>tim</h1>",
123 `@tim`,
124 "Member since",
125 `data-copy="` + share + `"`,
126 `src="/tim/zichtbaar/-/logo"`,
127 `href="/tim/zichtbaar"`,
128 "Zichtbare repo",
129 `src="/groups/plein/logo"`,
130 `href="/groups/plein"`,
131 `<strong>1</strong> <span>Repositories</span>`,
132 `<strong>1</strong> <span>Groups</span>`,
133 } {
134 if !strings.Contains(pub, want) {
135 t.Fatalf("openbaar profiel mist %q", want)
136 }
137 }
138 for _, ban := range []string{"geheim", "Geheim project", "kluis", "Kluis", "Edit profile", "plein/gedeeld"} {
139 if strings.Contains(pub, ban) {
140 t.Fatalf("openbaar profiel toont %q", ban)
141 }
142 }
143
144 adaJar, _ := cookiejar.New(nil)
145 adaClient := &http.Client{Jar: adaJar}
146 sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
147 if err != nil {
148 t.Fatal(err)
149 }
150 u, _ := url.Parse(ts.URL)
151 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
152 res, err = adaClient.Get(share)
153 if err != nil {
154 t.Fatal(err)
155 }
156 adaPage := read(t, res)
157 for _, want := range []string{
158 `href="/tim/geheim"`,
159 "Geheim project",
160 `href="/groups/kluis"`,
161 `<strong>2</strong> <span>Repositories</span>`,
162 `<strong>2</strong> <span>Groups</span>`,
163 } {
164 if !strings.Contains(adaPage, want) {
165 t.Fatalf("ada ziet niet %q", want)
166 }
167 }
168 if strings.Contains(adaPage, "Edit profile") || strings.Contains(adaPage, "plein/gedeeld") {
169 t.Fatal("ada ziet Tims bewerkknop of een groepsrepository")
170 }
171
172 res, err = client.Get(ts.URL + "/settings")
173 if err != nil {
174 t.Fatal(err)
175 }
176 settings := read(t, res)
177 if !strings.Contains(settings, "Display name") || !strings.Contains(settings, "Bio") {
178 t.Fatal("instellingen missen weergavenaam of bio")
179 }
180 res, err = client.PostForm(ts.URL+"/settings/profile", url.Values{
181 "csrf": {csrfOf(t, settings)}, "name": {"Regel\neen"}, "bio": {"nee"},
182 })
183 if err != nil {
184 t.Fatal(err)
185 }
186 bad := read(t, res)
187 if !strings.Contains(bad, "line break") {
188 t.Fatalf("ongeldige naam:\n%s", bad)
189 }
190 res, err = client.PostForm(ts.URL+"/settings/profile", url.Values{
191 "csrf": {csrfOf(t, bad)}, "name": {"Tim Falken"}, "bio": {"Bouwt BlueGit."},
192 })
193 if err != nil {
194 t.Fatal(err)
195 }
196 saved := read(t, res)
197 if !strings.Contains(saved, "Profile saved") || !strings.Contains(saved, `value="Tim Falken"`) {
198 t.Fatalf("profiel opslaan:\n%s", saved)
199 }
200 res, err = client.Get(share)
201 if err != nil {
202 t.Fatal(err)
203 }
204 named := read(t, res)
205 for _, want := range []string{"<h1>Tim Falken</h1>", "@tim", "Bouwt BlueGit.", "Edit profile"} {
206 if !strings.Contains(named, want) {
207 t.Fatalf("profiel na opslaan mist %q", want)
208 }
209 }
210
211 timToken, err := st.CreateToken(ctx, tim.ID, "tim")
212 if err != nil {
213 t.Fatal(err)
214 }
215 adaToken, err := st.CreateToken(ctx, ada.ID, "ada")
216 if err != nil {
217 t.Fatal(err)
218 }
219 mine := apiGet(t, ts.URL+"/api/v1/users/tim", timToken)
220 if mine["name"] != "Tim Falken" || mine["bio"] != "Bouwt BlueGit." || mine["web_url"] != share {
221 t.Fatalf("api zelf: %#v", mine)
222 }
223 if mine["instance_admin"] != true || mine["language"] != "en" {
224 t.Fatalf("api zelf mist eigen velden: %#v", mine)
225 }
226 counts := mine["counts"].(map[string]any)
227 if counts["repos"] != 2.0 || counts["groups"] != 2.0 || counts["contributions"] != 0.0 {
228 t.Fatalf("api tellingen: %#v", counts)
229 }
230 if !apiPaths(mine["repos"]).has("tim/zichtbaar", "tim/geheim") || apiPaths(mine["repos"]).has("plein/gedeeld") {
231 t.Fatalf("api repos: %#v", mine["repos"])
232 }
233 if !apiPaths(mine["groups"]).has("plein", "kluis") {
234 t.Fatalf("api groepen: %#v", mine["groups"])
235 }
236 other := apiGet(t, ts.URL+"/api/v1/users/tim", adaToken)
237 if _, ok := other["instance_admin"]; ok || other["language"] != nil {
238 t.Fatalf("api van ada toont Tims privévelden: %#v", other)
239 }
240 if !apiPaths(other["repos"]).has("tim/geheim") || !apiPaths(other["groups"]).has("kluis") {
241 t.Fatalf("api van ada mist privé: %#v %#v", other["repos"], other["groups"])
242 }
243 req, err := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/user", strings.NewReader(`{"bio":"alleen bio"}`))
244 if err != nil {
245 t.Fatal(err)
246 }
247 req.Header.Set("Authorization", "Bearer "+timToken)
248 req.Header.Set("Content-Type", "application/json")
249 res, err = http.DefaultClient.Do(req)
250 if err != nil {
251 t.Fatal(err)
252 }
253 put := decodeJSON(t, res)
254 if put["bio"] != "alleen bio" || put["name"] != "Tim Falken" || put["language"] != "en" {
255 t.Fatalf("put bio: %#v", put)
256 }
257
258 noredir := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
259 res, err = noredir.Get(ts.URL + "/tim")
260 if err != nil {
261 t.Fatal(err)
262 }
263 loc := res.Header.Get("Location")
264 if res.StatusCode != http.StatusNotFound || loc != "" {
265 t.Fatalf("/tim is %d locatie %q", res.StatusCode, loc)
266 }
267 _ = res.Body.Close()
268 res, err = anon.Get(ts.URL + "/users/nobody")
269 if err != nil {
270 t.Fatal(err)
271 }
272 if res.StatusCode != http.StatusNotFound {
273 t.Fatalf("onbekend profiel %d", res.StatusCode)
274 }
275 _ = res.Body.Close()
276 _ = page
277}
278
279func repoID(t *testing.T, st *store.Store, owner, name string) int64 {
280 t.Helper()
281 repo, err := st.RepoByPath(context.Background(), owner, name)
282 if err != nil {
283 t.Fatal(err)
284 }
285 return repo.ID
286}
287
288func apiGet(t *testing.T, rawURL, token string) map[string]any {
289 t.Helper()
290 req, err := http.NewRequest(http.MethodGet, rawURL, nil)
291 if err != nil {
292 t.Fatal(err)
293 }
294 req.Header.Set("Authorization", "Bearer "+token)
295 res, err := http.DefaultClient.Do(req)
296 if err != nil {
297 t.Fatal(err)
298 }
299 body := decodeJSON(t, res)
300 if res.StatusCode != http.StatusOK {
301 t.Fatalf("api %s: %d %#v", rawURL, res.StatusCode, body)
302 }
303 return body
304}
305
306func decodeJSON(t *testing.T, res *http.Response) map[string]any {
307 t.Helper()
308 defer res.Body.Close()
309 var body map[string]any
310 if err := json.NewDecoder(res.Body).Decode(&body); err != nil {
311 t.Fatal(err)
312 }
313 return body
314}
315
316type pathSet map[string]bool
317
318func apiPaths(v any) pathSet {
319 out := pathSet{}
320 list, _ := v.([]any)
321 for _, item := range list {
322 row, _ := item.(map[string]any)
323 if p, ok := row["path"].(string); ok {
324 out[p] = true
325 }
326 }
327 return out
328}
329
330func (p pathSet) has(want ...string) bool {
331 for _, w := range want {
332 if !p[w] {
333 return false
334 }
335 }
336 return true
337}