package server
import (
"context"
"encoding/json"
"io"
"net/http"
"net/http/cookiejar"
"net/http/httptest"
"net/url"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
"gitlab.com/Timfa/bluegit/internal/auth"
"gitlab.com/Timfa/bluegit/internal/config"
"gitlab.com/Timfa/bluegit/internal/state"
"gitlab.com/Timfa/bluegit/internal/store"
)
func TestWebRepoPushAndSecretBoundary(t *testing.T) {
if _, err := exec.LookPath("git"); err != nil {
t.Skip("git ontbreekt")
}
storage := t.TempDir()
key := bytes32()
st, err := store.Open(filepath.Join(storage, "bluegit.db"), key)
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"},
SSH: config.SSH{Enabled: true, Listen: "0.0.0.0:2222", PublicHost: "git.timfalken.com", PublicPort: 22},
CI: config.CI{Enabled: false},
}
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)
jar, _ := cookiejar.New(nil)
client := &http.Client{Jar: jar}
res, err := client.Get(ts.URL + "/login")
if err != nil {
t.Fatal(err)
}
body := read(t, res)
if res.StatusCode != 200 || !strings.Contains(body, "Overview") {
t.Fatalf("login %d %s", res.StatusCode, body)
}
logo, err := client.Get(ts.URL + "/assets/logo.svg")
if err != nil {
t.Fatal(err)
}
wantLogo, err := os.ReadFile("../../assets/logo.svg")
if err != nil {
t.Fatal(err)
}
if logo.StatusCode != 200 || read(t, logo) != string(wantLogo) {
t.Fatalf("logo %d wijkt af van assets/logo.svg", logo.StatusCode)
}
if ct := logo.Header.Get("Content-Type"); !strings.Contains(ct, "image/svg+xml") {
t.Fatalf("favicon-type %s", ct)
}
csrf := csrfOf(t, body)
form := url.Values{"csrf": {csrf}, "name": {"demo"}, "description": {"eerste"}, "visibility": {"private"}}
res, err = client.PostForm(ts.URL+"/new/repo", form)
if err != nil {
t.Fatal(err)
}
body = read(t, res)
if !strings.Contains(body, "tim/demo") {
t.Fatalf("repo pagina:\n%s", body)
}
if !strings.Contains(body, "ssh://git@git.timfalken.com:22/tim/demo.git") {
t.Fatalf("clone-URL hoort de publieke SSH-poort te tonen:\n%s", body)
}
if strings.Contains(body, ":2222/") {
t.Fatalf("clone-URL toont de bindpoort:\n%s", body)
}
sshURL := "ssh://git@git.timfalken.com:22/tim/demo.git"
httpURL := "http://127.0.0.1:9/tim/demo.git"
assertCloneMenu(t, body, "overzicht", sshURL, httpURL)
res, err = client.Get(ts.URL + "/tim/demo/-/tree")
if err != nil {
t.Fatal(err)
}
if res.StatusCode != http.StatusOK {
t.Fatalf("bestanden %d", res.StatusCode)
}
assertCloneMenu(t, read(t, res), "bestanden", sshURL, httpURL)
res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, body)}, "name": {"test"}})
if err != nil {
t.Fatal(err)
}
body = read(t, res)
token := between(body, `
`, "
")
if !strings.HasPrefix(token, "bg_") {
t.Fatalf("token pagina:\n%s", body)
}
work := t.TempDir()
git(t, work, "init", "-b", "master")
git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
git(t, work, "config", "user.name", "tim")
if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("hallo bluegit\n"), 0o644); err != nil {
t.Fatal(err)
}
git(t, work, "add", "README.md")
git(t, work, "commit", "-m", "eerste commit")
remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/demo.git"
git(t, work, "remote", "add", "origin", remote)
git(t, work, "push", "-u", "origin", "master")
res, err = client.Get(ts.URL + "/tim/demo")
if err != nil {
t.Fatal(err)
}
body = read(t, res)
if !strings.Contains(body, "eerste commit") || !strings.Contains(body, "README.md") {
t.Fatalf("na push:\n%s", body)
}
res, err = client.Get(ts.URL + "/tim/demo/-/blob/README.md")
if err != nil {
t.Fatal(err)
}
body = read(t, res)
if !strings.Contains(body, "hallo bluegit") {
t.Fatalf("blob:\n%s", body)
}
ctx := context.Background()
ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
if err != nil {
t.Fatal(err)
}
repo, err := st.RepoByPath(ctx, "tim", "demo")
if err != nil {
t.Fatal(err)
}
if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
t.Fatal(err)
}
sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
if err != nil {
t.Fatal(err)
}
adaJar, _ := cookiejar.New(nil)
adaClient := &http.Client{Jar: adaJar}
u, _ := url.Parse(ts.URL)
adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
res, err = adaClient.Get(ts.URL + "/")
if err != nil {
t.Fatal(err)
}
adaCSRF := csrfOf(t, read(t, res))
res, err = adaClient.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
"csrf": {adaCSRF}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
})
if err != nil {
t.Fatal(err)
}
if res.StatusCode != http.StatusForbidden {
t.Fatalf("ontwikkelaar mocht een geheim schrijven: %d", res.StatusCode)
}
_ = res.Body.Close()
res, err = client.Get(ts.URL + "/tim/demo/-/settings?tab=geheimen")
if err != nil {
t.Fatal(err)
}
ownerPage := read(t, res)
res, err = client.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
"csrf": {csrfOf(t, ownerPage)}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
})
if err != nil {
t.Fatal(err)
}
saved := read(t, res)
if strings.Contains(saved, "super-geheim-waarde") {
t.Fatal("geheimwaarde staat op de pagina")
}
if !strings.Contains(saved, "TOKEN") {
t.Fatalf("naam ontbreekt:\n%s", saved)
}
res, err = client.PostForm(ts.URL+"/tim/demo/-/webhooks", url.Values{
"csrf": {csrfOf(t, saved)}, "name": {"kapot"}, "preset": {"generic"},
"url": {"https://example.test/hook"}, "branch_filter": {"re:("}, "event_push": {"1"},
})
if err != nil {
t.Fatal(err)
}
hookPage := read(t, res)
if !strings.Contains(hookPage, "branchfilter") && !strings.Contains(hookPage, "error") && !strings.Contains(strings.ToLower(hookPage), "regex") {
t.Fatalf("kapot filter:\n%s", hookPage)
}
}
func TestSetupChoosesStorage(t *testing.T) {
storage := t.TempDir()
stateDir := t.TempDir()
key := bytes32()
st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), key)
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",
Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
Git: config.Git{Binary: "git", DefaultBranch: "master"},
}
srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
ts := httptest.NewServer(srv.Handler())
t.Cleanup(ts.Close)
res, err := http.Get(ts.URL + "/tim/demo.git/info/refs?service=git-upload-pack")
if err != nil {
t.Fatal(err)
}
body := read(t, res)
if res.StatusCode != http.StatusServiceUnavailable || !strings.Contains(body, "not set up yet") {
t.Fatalf("git zonder opslag: %d %s", res.StatusCode, body)
}
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)
if res.StatusCode != 200 || !strings.Contains(page, "Choose storage") {
t.Fatalf("setup:\n%s", page)
}
res, err = client.PostForm(ts.URL+"/setup", url.Values{"csrf": {csrfOf(t, page)}, "path": {"relatief"}})
if err != nil {
t.Fatal(err)
}
page = read(t, res)
if !strings.Contains(page, "absolute") {
t.Fatalf("relatief pad:\n%s", page)
}
res, err = client.PostForm(ts.URL+"/setup", url.Values{"csrf": {csrfOf(t, page)}, "path": {storage}})
if err != nil {
t.Fatal(err)
}
page = read(t, res)
if !strings.Contains(page, "Overview") || !strings.Contains(page, "free.") {
t.Fatalf("na opslaan:\n%s", page)
}
if srv.StoragePath() != storage {
t.Fatalf("pad %s", srv.StoragePath())
}
saved, err := os.ReadFile(filepath.Join(stateDir, "storage_path"))
if err != nil || strings.TrimSpace(string(saved)) != storage {
t.Fatalf("bestand %q %v", saved, err)
}
res, err = client.Get(ts.URL + "/setup")
if err != nil {
t.Fatal(err)
}
page = read(t, res)
info, err := state.Inspect(storage)
if err != nil {
t.Fatal(err)
}
n, err := state.DirSize(context.Background(), storage)
if err != nil {
t.Fatal(err)
}
pct := state.Percent(info.Used(), info.Total)
for _, want := range []string{
"does not move",
"BlueGit uses " + state.Format(n),
"Disk: " + state.Format(info.Total),
state.Format(info.Used()) + " used",
state.Format(info.Free) + " free.",
`