package server
import (
"context"
"encoding/json"
"net/http"
"net/http/cookiejar"
"net/http/httptest"
"net/url"
"path/filepath"
"strings"
"testing"
"time"
"gitlab.com/Timfa/bluegit/internal/access"
"gitlab.com/Timfa/bluegit/internal/auth"
"gitlab.com/Timfa/bluegit/internal/config"
"gitlab.com/Timfa/bluegit/internal/store"
)
func TestProfilePage(t *testing.T) {
storage := t.TempDir()
st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = st.Close() })
cfg := config.Config{
BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
Git: config.Git{Binary: "git", DefaultBranch: "master"},
}
cfg.Auth.BaseURL = "https://auth.timfalken.com"
srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
ts := httptest.NewServer(srv.Handler())
t.Cleanup(ts.Close)
srv.Cfg.BaseURL = ts.URL
jar, _ := cookiejar.New(nil)
client := &http.Client{Jar: jar}
res, err := client.Get(ts.URL + "/login")
if err != nil {
t.Fatal(err)
}
page := read(t, res)
ctx := context.Background()
tim, err := st.UserByUsername(ctx, "tim")
if err != nil {
t.Fatal(err)
}
ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
if err != nil {
t.Fatal(err)
}
plein, err := st.CreateGroup(ctx, tim.ID, "Plein", "plein", "open plein", access.RoleDeveloper)
if err != nil {
t.Fatal(err)
}
if err := st.UpdateGroup(ctx, plein.ID, "open plein", "public", access.RoleDeveloper); err != nil {
t.Fatal(err)
}
if err := st.SetLogoMIME(ctx, "group", plein.ID, "image/png"); err != nil {
t.Fatal(err)
}
kluis, err := st.CreateGroup(ctx, tim.ID, "Kluis", "kluis", "dichte kluis", access.RoleDeveloper)
if err != nil {
t.Fatal(err)
}
zichtbaar, err := st.CreateRepo(ctx, "user", tim.ID, "zichtbaar", "Zichtbare repo", "master", "public")
if err != nil {
t.Fatal(err)
}
if err := st.SetLogoMIME(ctx, "repo", zichtbaar.ID, "image/png"); err != nil {
t.Fatal(err)
}
geheim, err := st.CreateRepo(ctx, "user", tim.ID, "geheim", "Geheim project", "master", "private")
if err != nil {
t.Fatal(err)
}
if _, err := st.CreateRepo(ctx, "group", plein.ID, "gedeeld", "Groepsrepo", "master", "public"); err != nil {
t.Fatal(err)
}
if err := st.AddContributions(ctx, []store.Contribution{
{UserID: tim.ID, RepoID: zichtbaar.ID, Kind: "commit", Ref: "pub", At: time.Now()},
{UserID: tim.ID, RepoID: geheim.ID, Kind: "commit", Ref: "priv", At: time.Now()},
}); err != nil {
t.Fatal(err)
}
if err := st.SetMember(ctx, "repo", repoID(t, st, "tim", "geheim"), "ada", access.RoleDeveloper); err != nil {
t.Fatal(err)
}
if err := st.SetMember(ctx, "group", kluis.ID, "ada", access.RoleDeveloper); err != nil {
t.Fatal(err)
}
share := ts.URL + "/users/tim"
res, err = client.Get(ts.URL + "/")
if err != nil {
t.Fatal(err)
}
dash := read(t, res)
for _, want := range []string{
`class="usercard panel"`,
`
tim
`,
`@tim`,
`data-copy="` + share + `"`,
`href="/settings">Edit profile`,
`href="/users/tim"`,
`2 Repositories`,
`2 Groups`,
"plein/gedeeld",
"Activity",
} {
if !strings.Contains(dash, want) {
t.Fatalf("dashboard mist %q", want)
}
}
if strings.Index(dash, "Activity") > strings.Index(dash, "Repositories") {
t.Fatal("heatmap staat onder de repositorylijst")
}
anon := &http.Client{}
res, err = anon.Get(share)
if err != nil {
t.Fatal(err)
}
pub := read(t, res)
for _, want := range []string{
"tim
",
`@tim`,
"Member since",
`data-copy="` + share + `"`,
`src="/tim/zichtbaar/-/logo"`,
`href="/tim/zichtbaar"`,
"Zichtbare repo",
`src="/groups/plein/logo"`,
`href="/groups/plein"`,
`1 Repositories`,
`1 Groups`,
`1 Contributions`,
} {
if !strings.Contains(pub, want) {
t.Fatalf("openbaar profiel mist %q", want)
}
}
for _, ban := range []string{"geheim", "Geheim project", "kluis", "Kluis", "Edit profile", "plein/gedeeld"} {
if strings.Contains(pub, ban) {
t.Fatalf("openbaar profiel toont %q", ban)
}
}
adaJar, _ := cookiejar.New(nil)
adaClient := &http.Client{Jar: adaJar}
sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
if err != nil {
t.Fatal(err)
}
u, _ := url.Parse(ts.URL)
adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
res, err = adaClient.Get(share)
if err != nil {
t.Fatal(err)
}
adaPage := read(t, res)
for _, want := range []string{
`href="/tim/geheim"`,
"Geheim project",
`href="/groups/kluis"`,
`2 Repositories`,
`2 Groups`,
`2 Contributions`,
} {
if !strings.Contains(adaPage, want) {
t.Fatalf("ada ziet niet %q", want)
}
}
if strings.Contains(adaPage, "Edit profile") || strings.Contains(adaPage, "plein/gedeeld") {
t.Fatal("ada ziet Tims bewerkknop of een groepsrepository")
}
res, err = client.Get(ts.URL + "/settings")
if err != nil {
t.Fatal(err)
}
settings := read(t, res)
if !strings.Contains(settings, "Display name") || !strings.Contains(settings, "Bio") {
t.Fatal("instellingen missen weergavenaam of bio")
}
res, err = client.PostForm(ts.URL+"/settings/profile", url.Values{
"csrf": {csrfOf(t, settings)}, "name": {"Regel\neen"}, "bio": {"nee"},
})
if err != nil {
t.Fatal(err)
}
bad := read(t, res)
if !strings.Contains(bad, "line break") {
t.Fatalf("ongeldige naam:\n%s", bad)
}
res, err = client.PostForm(ts.URL+"/settings/profile", url.Values{
"csrf": {csrfOf(t, bad)}, "name": {"Tim Falken"}, "bio": {"Bouwt BlueGit."},
})
if err != nil {
t.Fatal(err)
}
saved := read(t, res)
if !strings.Contains(saved, "Profile saved") || !strings.Contains(saved, `value="Tim Falken"`) {
t.Fatalf("profiel opslaan:\n%s", saved)
}
res, err = client.Get(share)
if err != nil {
t.Fatal(err)
}
named := read(t, res)
for _, want := range []string{"Tim Falken
", "@tim", "Bouwt BlueGit.", "Edit profile"} {
if !strings.Contains(named, want) {
t.Fatalf("profiel na opslaan mist %q", want)
}
}
timToken, err := st.CreateToken(ctx, tim.ID, "tim")
if err != nil {
t.Fatal(err)
}
adaToken, err := st.CreateToken(ctx, ada.ID, "ada")
if err != nil {
t.Fatal(err)
}
mine := apiGet(t, ts.URL+"/api/v1/users/tim", timToken)
if mine["name"] != "Tim Falken" || mine["bio"] != "Bouwt BlueGit." || mine["web_url"] != share {
t.Fatalf("api zelf: %#v", mine)
}
if mine["instance_admin"] != true || mine["language"] != "en" {
t.Fatalf("api zelf mist eigen velden: %#v", mine)
}
counts := mine["counts"].(map[string]any)
if counts["repos"] != 2.0 || counts["groups"] != 2.0 || counts["contributions"] != 2.0 {
t.Fatalf("api tellingen: %#v", counts)
}
if !apiPaths(mine["repos"]).has("tim/zichtbaar", "tim/geheim") || apiPaths(mine["repos"]).has("plein/gedeeld") {
t.Fatalf("api repos: %#v", mine["repos"])
}
if !apiPaths(mine["groups"]).has("plein", "kluis") {
t.Fatalf("api groepen: %#v", mine["groups"])
}
other := apiGet(t, ts.URL+"/api/v1/users/tim", adaToken)
if _, ok := other["instance_admin"]; ok || other["language"] != nil {
t.Fatalf("api van ada toont Tims privévelden: %#v", other)
}
if !apiPaths(other["repos"]).has("tim/geheim") || !apiPaths(other["groups"]).has("kluis") {
t.Fatalf("api van ada mist privé: %#v %#v", other["repos"], other["groups"])
}
if other["counts"].(map[string]any)["contributions"] != 2.0 {
t.Fatalf("api van ada telt verborgen bijdragen niet mee: %#v", other["counts"])
}
pubAPI := apiGet(t, ts.URL+"/api/v1/users/tim", "")
if _, ok := pubAPI["instance_admin"]; ok || pubAPI["language"] != nil {
t.Fatalf("anonieme api toont privévelden: %#v", pubAPI)
}
if apiPaths(pubAPI["repos"]).has("tim/geheim") || apiPaths(pubAPI["groups"]).has("kluis") || !apiPaths(pubAPI["repos"]).has("tim/zichtbaar") {
t.Fatalf("anonieme api filter: %#v %#v", pubAPI["repos"], pubAPI["groups"])
}
if pubAPI["counts"].(map[string]any)["contributions"] != 1.0 {
t.Fatalf("anonieme api lekt privébijdragen: %#v", pubAPI["counts"])
}
badTok, err := http.NewRequest(http.MethodGet, ts.URL+"/api/v1/users/tim", nil)
if err != nil {
t.Fatal(err)
}
badTok.Header.Set("Authorization", "Bearer bg_nietgeldig")
res, err = http.DefaultClient.Do(badTok)
if err != nil {
t.Fatal(err)
}
if res.StatusCode != http.StatusUnauthorized {
t.Fatalf("ongeldig token %d", res.StatusCode)
}
_ = res.Body.Close()
req, err := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/user", strings.NewReader(`{"bio":"alleen bio"}`))
if err != nil {
t.Fatal(err)
}
req.Header.Set("Authorization", "Bearer "+timToken)
req.Header.Set("Content-Type", "application/json")
res, err = http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
put := decodeJSON(t, res)
if put["bio"] != "alleen bio" || put["name"] != "Tim Falken" || put["language"] != "en" {
t.Fatalf("put bio: %#v", put)
}
noredir := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
res, err = noredir.Get(ts.URL + "/tim")
if err != nil {
t.Fatal(err)
}
loc := res.Header.Get("Location")
if res.StatusCode != http.StatusFound || loc != "/users/tim" {
t.Fatalf("/tim is %d locatie %q", res.StatusCode, loc)
}
_ = res.Body.Close()
res, err = noredir.Get(ts.URL + "/plein")
if err != nil {
t.Fatal(err)
}
if res.StatusCode != http.StatusNotFound || res.Header.Get("Location") != "" {
t.Fatalf("groepsnaam /plein is %d locatie %q", res.StatusCode, res.Header.Get("Location"))
}
_ = res.Body.Close()
res, err = noredir.Get(ts.URL + "/tim/zichtbaar")
if err != nil {
t.Fatal(err)
}
if res.StatusCode == http.StatusFound && strings.HasPrefix(res.Header.Get("Location"), "/users/") {
t.Fatalf("repositorypad wijst naar een profiel: %s", res.Header.Get("Location"))
}
_ = res.Body.Close()
res, err = noredir.Get(ts.URL + "/login")
if err != nil {
t.Fatal(err)
}
if strings.Contains(res.Header.Get("Location"), "/users/") {
t.Fatalf("login wijst naar een profiel: %s", res.Header.Get("Location"))
}
_ = res.Body.Close()
res, err = anon.Get(ts.URL + "/users/nobody")
if err != nil {
t.Fatal(err)
}
if res.StatusCode != http.StatusNotFound {
t.Fatalf("onbekend profiel %d", res.StatusCode)
}
_ = res.Body.Close()
_ = page
}
func repoID(t *testing.T, st *store.Store, owner, name string) int64 {
t.Helper()
repo, err := st.RepoByPath(context.Background(), owner, name)
if err != nil {
t.Fatal(err)
}
return repo.ID
}
func apiGet(t *testing.T, rawURL, token string) map[string]any {
t.Helper()
req, err := http.NewRequest(http.MethodGet, rawURL, nil)
if err != nil {
t.Fatal(err)
}
if token != "" {
req.Header.Set("Authorization", "Bearer "+token)
}
res, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
body := decodeJSON(t, res)
if res.StatusCode != http.StatusOK {
t.Fatalf("api %s: %d %#v", rawURL, res.StatusCode, body)
}
return body
}
func decodeJSON(t *testing.T, res *http.Response) map[string]any {
t.Helper()
defer res.Body.Close()
var body map[string]any
if err := json.NewDecoder(res.Body).Decode(&body); err != nil {
t.Fatal(err)
}
return body
}
type pathSet map[string]bool
func apiPaths(v any) pathSet {
out := pathSet{}
list, _ := v.([]any)
for _, item := range list {
row, _ := item.(map[string]any)
if p, ok := row["path"].(string); ok {
out[p] = true
}
}
return out
}
func (p pathSet) has(want ...string) bool {
for _, w := range want {
if !p[w] {
return false
}
}
return true
}