| 1 | package server |
| 2 | |
| 3 | import ( |
| 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 | |
| 21 | func 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 | |
| 279 | func 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 | |
| 288 | func 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 | |
| 306 | func 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 | |
| 316 | type pathSet map[string]bool |
| 317 | |
| 318 | func 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 | |
| 330 | func (p pathSet) has(want ...string) bool { |
| 331 | for _, w := range want { |
| 332 | if !p[w] { |
| 333 | return false |
| 334 | } |
| 335 | } |
| 336 | return true |
| 337 | } |