package e2e import ( "bytes" "context" "encoding/json" "io" "net/http" "net/http/cookiejar" "net/http/httptest" "net/url" "strings" "testing" "time" "gitea.mynodes.xyz/ilker/llmgw/internal/config" "gitea.mynodes.xyz/ilker/llmgw/internal/control/adminapi" "gitea.mynodes.xyz/ilker/llmgw/internal/store" ) // browser is a client that keeps cookies and does not follow redirects, so a // test can see them. type browser struct { t *testing.T base string c *http.Client } func newBrowser(t *testing.T, base string) *browser { t.Helper() jar, err := cookiejar.New(nil) if err != nil { t.Fatal(err) } return &browser{t: t, base: base, c: &http.Client{ Jar: jar, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }, }} } func (b *browser) get(path string) (int, string) { b.t.Helper() req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, b.base+path, nil) resp, err := b.c.Do(req) if err != nil { b.t.Fatal(err) } defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) return resp.StatusCode, string(body) } func (b *browser) post(path string, form url.Values) (int, string, string) { b.t.Helper() // The sign-in form carries a token its page set, as a browser's would. if path == "/login" && form.Get("csrf") == "" { _, page := b.get("/login") form = cloneValues(form) form.Set("csrf", csrf(b.t, page)) } req, _ := http.NewRequestWithContext(context.Background(), http.MethodPost, b.base+path, strings.NewReader(form.Encode())) req.Header.Set("Content-Type", "application/x-www-form-urlencoded") resp, err := b.c.Do(req) if err != nil { b.t.Fatal(err) } defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) return resp.StatusCode, string(body), resp.Header.Get("Location") } // csrf pulls the token the server put in the page, from a form field or the // meta tag the JSON-posting pages use. func csrf(t *testing.T, body string) string { t.Helper() for _, marker := range []string{`name="csrf" value="`, `name="csrf" content="`} { if i := strings.Index(body, marker); i >= 0 { rest := body[i+len(marker):] return rest[:strings.IndexByte(rest, '"')] } } t.Fatal("no csrf token in the page") return "" } func signupHarness(t *testing.T) (*harness, string) { t.Helper() path, _ := provision(t) h := start(t, 2, func(c *config.Server) { c.Auth = config.Auth{ Enabled: true, Store: path, SignupOpen: true, CacheTTL: 50 * time.Millisecond, } }) return h, path } const password = "a long enough passphrase" func TestAnAccountIsUselessUntilItIsApproved(t *testing.T) { // The whole reason a public signup form is safe: it produces something that // cannot do anything. h, path := signupHarness(t) b := newBrowser(t, h.router.URL) code, body, _ := b.post("/signup", url.Values{ "email": {"ayse@example.com"}, "name": {"Ayse"}, "password": {password}, }) if code != http.StatusOK || !strings.Contains(body, "waiting for approval") { t.Fatalf("signup returned %d: %s", code, body) } code, body, _ = b.post("/login", url.Values{ "email": {"ayse@example.com"}, "password": {password}, }) if code != http.StatusUnauthorized || !strings.Contains(body, "waiting for approval") { t.Fatalf("a pending account signed in: %d", code) } // The profile page is not reachable either. if code, _ := b.get("/profile"); code != http.StatusSeeOther { t.Errorf("an unauthenticated visit to /profile returned %d", code) } // Approve, and it all works. withStore(t, path, func(s *store.DB) { users, err := s.Users(context.Background(), store.UserPending) if err != nil || len(users) != 1 { t.Fatalf("pending users: %v %v", users, err) } if err := s.ApproveUser(context.Background(), users[0].ID, "proj", "test", time.Now()); err != nil { t.Fatal(err) } }) code, _, loc := b.post("/login", url.Values{ "email": {"ayse@example.com"}, "password": {password}, }) if code != http.StatusSeeOther || loc != "/profile" { t.Fatalf("sign-in after approval returned %d to %q", code, loc) } } func TestAUserIssuesTheirOwnKeyAndItWorks(t *testing.T) { h, path := signupHarness(t) b := newBrowser(t, h.router.URL) signUpAndApprove(t, b, path, "ayse@example.com") _, profile := b.get("/profile") token := csrf(t, profile) code, body, _ := b.post("/profile/keys", url.Values{ "csrf": {token}, "name": {"laptop"}, }) if code != http.StatusOK { t.Fatalf("creating a key returned %d", code) } key := extractKey(t, body) // The key the person made for themselves is a real key. if code, msg := h.call(t, key, testModel); code != http.StatusOK { t.Fatalf("a self-issued key does not work: %d %s", code, msg) } // And it is listed afterwards, without the secret. _, profile = b.get("/profile") if !strings.Contains(profile, "laptop") { t.Error("the key is not listed") } if strings.Contains(profile, key) { t.Error("the profile page shows the key again; it is meant to be shown once") } } func TestAUserCannotRevokeSomeoneElsesKey(t *testing.T) { // The ownership check is in the statement rather than a prior read, so a // guessed id from another account changes nothing. h, path := signupHarness(t) ayse := newBrowser(t, h.router.URL) signUpAndApprove(t, ayse, path, "ayse@example.com") _, p1 := ayse.get("/profile") _, body, _ := ayse.post("/profile/keys", url.Values{"csrf": {csrf(t, p1)}, "name": {"ayse-key"}}) ayseKey := extractKey(t, body) var ayseKeyID string withStore(t, path, func(s *store.DB) { users, _ := s.Users(context.Background(), store.UserActive) for _, u := range users { if u.Email == "ayse@example.com" { keys, _ := s.KeysForUser(context.Background(), u.ID) if len(keys) != 1 { t.Fatalf("ayse has %d keys", len(keys)) } ayseKeyID = keys[0].ID } } }) mehmet := newBrowser(t, h.router.URL) signUpAndApprove(t, mehmet, path, "mehmet@example.com") _, p2 := mehmet.get("/profile") if code, _, _ := mehmet.post("/profile/keys/"+ayseKeyID+"/revoke", url.Values{"csrf": {csrf(t, p2)}}); code != http.StatusSeeOther { t.Fatalf("status %d", code) } // It must still work. if code, msg := h.call(t, ayseKey, testModel); code != http.StatusOK { t.Errorf("someone else revoked this key: %d %s", code, msg) } } func TestAFormWithoutItsTokenIsRefused(t *testing.T) { // A cookie authenticates the browser, not the page that asked. Without this, // any site the person visits can post here and have the browser attach the // session for it. h, path := signupHarness(t) b := newBrowser(t, h.router.URL) signUpAndApprove(t, b, path, "ayse@example.com") for _, bad := range []url.Values{ {"name": {"x"}}, {"csrf": {""}, "name": {"x"}}, {"csrf": {"forged"}, "name": {"x"}}, } { if code, _, _ := b.post("/profile/keys", bad); code != http.StatusBadRequest { t.Errorf("a form with csrf=%q was accepted: %d", bad.Get("csrf"), code) } } } func TestSigningOutEndsTheSession(t *testing.T) { h, path := signupHarness(t) b := newBrowser(t, h.router.URL) signUpAndApprove(t, b, path, "ayse@example.com") _, profile := b.get("/profile") if _, _, _ = b.post("/logout", url.Values{"csrf": {csrf(t, profile)}}); false { t.Fatal("unreachable") } if code, _ := b.get("/profile"); code != http.StatusSeeOther { t.Errorf("the profile was still reachable after signing out: %d", code) } } func TestSuspensionClosesOpenSessions(t *testing.T) { h, path := signupHarness(t) b := newBrowser(t, h.router.URL) id := signUpAndApprove(t, b, path, "ayse@example.com") if code, _ := b.get("/profile"); code != http.StatusOK { t.Fatalf("profile before suspension: %d", code) } withStore(t, path, func(s *store.DB) { if err := s.SetUserState(context.Background(), id, store.UserSuspended); err != nil { t.Fatal(err) } }) if code, _ := b.get("/profile"); code != http.StatusSeeOther { t.Errorf("a suspended account kept its session: %d", code) } } func TestSignupCanBeClosed(t *testing.T) { path, _ := provision(t) h := start(t, 2, func(c *config.Server) { c.Auth = config.Auth{Enabled: true, Store: path, SignupOpen: false} }) b := newBrowser(t, h.router.URL) if code, body := b.get("/signup"); code == http.StatusOK && strings.Contains(body, "