From d00fb954194f36f8a128fba4c8e6160cf8fe2022 Mon Sep 17 00:00:00 2001 From: Thomas Rooney Date: Sat, 21 Nov 2026 08:06:28 +0000 Subject: [PATCH 1/4] chore: add a non-production end-to-end test control surface --- dev-idp/internal/modes/mockworkos/workos.go | 14 + mise.toml | 6 + server/cmd/gram/deps_e2e.go | 102 +++++ server/cmd/gram/start.go | 29 ++ server/internal/demoseed/demoseed.go | 5 +- server/internal/e2econtrol/e2econtrol.go | 355 ++++++++++++++++++ server/internal/e2econtrol/e2econtrol_test.go | 306 +++++++++++++++ server/internal/e2econtrol/openapi.yaml | 194 ++++++++++ 8 files changed, 1010 insertions(+), 1 deletion(-) create mode 100644 server/cmd/gram/deps_e2e.go create mode 100644 server/internal/e2econtrol/e2econtrol.go create mode 100644 server/internal/e2econtrol/e2econtrol_test.go create mode 100644 server/internal/e2econtrol/openapi.yaml diff --git a/dev-idp/internal/modes/mockworkos/workos.go b/dev-idp/internal/modes/mockworkos/workos.go index 6bb156e0d61..61c57d5b843 100644 --- a/dev-idp/internal/modes/mockworkos/workos.go +++ b/dev-idp/internal/modes/mockworkos/workos.go @@ -67,6 +67,9 @@ const invitationLifetime = 30 * 24 * time.Hour const ( magicAuthGrantType = "urn:workos:oauth:grant-type:magic-auth:code" magicAuthLifetime = 10 * time.Minute + // defaultUserMode is the mode whose currentUser the default-user bootstrap + // records (oauth21.Mode; that package is not imported here). + defaultUserMode = "oauth2-1" ) // defaultPageSize / maxPageSize match WorkOS's documented limits closely @@ -146,6 +149,17 @@ func (h *Handler) handleWorkosCreateMagicAuth(w http.ResponseWriter, r *http.Req return } + // The default developer is a member of the default organization only once + // something has bootstrapped it, which until now was the first hosted + // login. A Magic Auth sign-in for that developer (the end-to-end test + // sign-in) must see the same memberships, or the server's membership sync + // reads "none" and removes the developer from their own organization. + if committer, err := defaultuser.GitCommitter(ctx); err == nil && strings.EqualFold(committer.Email, body.Email) { + if _, err := defaultuser.BootstrapLocalUser(ctx, h.db, defaultUserMode); err != nil { + h.logger.WarnContext(ctx, "magic auth: bootstrap default user", slog.Any("error", err)) + } + } + user, err := repo.New(h.db).UpsertUserByEmail(ctx, repo.UpsertUserByEmailParams{ ID: defaultuser.DeterministicUserID(body.Email), Email: body.Email, diff --git a/mise.toml b/mise.toml index 37bcff22027..8fc6b8ccbad 100644 --- a/mise.toml +++ b/mise.toml @@ -174,6 +174,12 @@ GRAM_REDIS_ENABLE_TRACING = "false" ## back into mise.local.toml after a seed run — a fresh clone is configured ## before it is ever seeded. Keep in sync with server/internal/demoseed/local.go. GRAM_API_KEY = "gram_local_5eed10ca15eed10ca15eed10ca15eed10ca15eed10ca15eed10ca15eed10ca11" +## End-to-end test control surface (server/internal/e2econtrol): lets a test run +## reseed the local organization and sign in as you without driving the dev-idp. +## A fixed, well-known local-only value like GRAM_API_KEY above. Deployed +## non-production environments inject their own from secrets; production +## refuses to start with one set. +GRAM_E2E_CONTROL_TOKEN = "gram_local_e2e_5eed10ca15eed10ca15eed10ca15eed10ca1" ## Local-only value; real deployments inject this via secrets. GRAM_TUNNEL_FORWARD_TOKEN = "local-dev-tunnel-forward-token" diff --git a/server/cmd/gram/deps_e2e.go b/server/cmd/gram/deps_e2e.go new file mode 100644 index 00000000000..a25303f260c --- /dev/null +++ b/server/cmd/gram/deps_e2e.go @@ -0,0 +1,102 @@ +package gram + +import ( + "context" + "errors" + "fmt" + "log/slog" + "net/url" + "os/exec" + "strings" + + "github.com/ClickHouse/clickhouse-go/v2/lib/driver" + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" + + "github.com/speakeasy-api/gram/server/internal/assets" + "github.com/speakeasy-api/gram/server/internal/demoseed" + "github.com/speakeasy-api/gram/server/internal/e2econtrol" + "github.com/speakeasy-api/gram/server/internal/encryption" +) + +// e2eUserEmail is the identity the control surface signs in. Locally it +// defaults to the developer the dev-idp and the local seed both derive from +// `git config user.email`, so a fresh clone needs no extra setting. +func e2eUserEmail(ctx context.Context, environment, configured string) string { + if configured != "" || environment != "local" { + return configured + } + out, err := exec.CommandContext(ctx, "git", "config", "--get", "user.email").Output() + if err != nil { + return "" + } + return strings.TrimSpace(string(out)) +} + +// newE2EReseeder returns what e2e.reseed runs in this environment, or nil when +// none is wired, in which case e2e.reseed and e2e.tenant answer 501. +// +// Locally the test organization is the local development organization: the +// reseed is the demo seed retargeted at demoseed.LocalSpec plus the local +// fixtures, the same Go that `mise run seed` runs. +// +// Deployed environments are not wired in this proposal. They need a Spec for +// a dedicated test organization (derived from its WorkOS organization id, as +// LocalSpec is from the dev-idp's) and the member-adoption half of the local +// fixtures generalized beyond LocalSpec. +func newE2EReseeder(environment string, logger *slog.Logger, db *pgxpool.Pool, ch driver.Conn, blob assets.BlobStore, enc *encryption.Client, cache *redis.Client, issuerURL string, siteURL, serverURL *url.URL, userEmail string) e2econtrol.Reseeder { + if environment != "local" { + return nil + } + return &localE2EReseeder{logger: logger, db: db, ch: ch, blob: blob, enc: enc, cache: cache, issuerURL: issuerURL, siteURL: siteURL, serverURL: serverURL, userEmail: userEmail} +} + +type localE2EReseeder struct { + logger *slog.Logger + db *pgxpool.Pool + ch driver.Conn + blob assets.BlobStore + enc *encryption.Client + cache *redis.Client + issuerURL string + siteURL *url.URL + serverURL *url.URL + userEmail string +} + +func (r *localE2EReseeder) Tenant() e2econtrol.Tenant { + spec := demoseed.LocalSpec() + return e2econtrol.Tenant{ + OrganizationID: spec.OrgID, + OrganizationSlug: spec.OrgSlug, + ProjectSlug: "default", + SeededUserPrefix: spec.UserPrefix, + APIKeyName: demoseed.LocalAPIKeyName, + } +} + +func (r *localE2EReseeder) Reseed(ctx context.Context) error { + if err := demoseed.Run(ctx, r.logger, r.db, r.ch, r.blob, r.enc, r.issuerURL, r.serverURL.String(), demoseed.LocalSpec()); err != nil { + if errors.Is(err, demoseed.ErrSeedLocked) { + return e2econtrol.ErrSeedBusy + } + return fmt.Errorf("apply seed: %w", err) + } + // The developer-machine upstreams (Enterprise Sign-In through the dev-idp, + // the Linear and Notion clients) and the Slack test app are left as the + // shared seed set them: `mise run seed` wires those from the developer's + // environment, which a request handler does not read. + if err := demoseed.RunLocalFixtures(ctx, r.logger, r.db, r.blob, r.cache, demoseed.LocalFixturesOptions{ + SiteURL: r.siteURL, + DeveloperEmail: r.userEmail, + Environment: "local", + ObservedEnv: nil, + Slack: demoseed.LocalSlackOptions{BotToken: "", SlackEmail: "", Encryption: nil, Slack: nil}, + Upstreams: demoseed.LocalUpstreamOptions{ServerURL: nil, Encryption: nil, DevIDPURL: "", DevIDPClientID: "", HTTPClient: nil, Policy: nil, CacheDir: ""}, + ClickHouse: nil, + MockMCPURL: "", + }); err != nil { + return fmt.Errorf("apply local fixtures: %w", err) + } + return nil +} diff --git a/server/cmd/gram/start.go b/server/cmd/gram/start.go index b008604a442..baca0569ca1 100644 --- a/server/cmd/gram/start.go +++ b/server/cmd/gram/start.go @@ -74,6 +74,7 @@ import ( "github.com/speakeasy-api/gram/server/internal/deployments" "github.com/speakeasy-api/gram/server/internal/deviceagentversions" "github.com/speakeasy-api/gram/server/internal/deviceintegrations" + "github.com/speakeasy-api/gram/server/internal/e2econtrol" "github.com/speakeasy-api/gram/server/internal/encryption" "github.com/speakeasy-api/gram/server/internal/environments" "github.com/speakeasy-api/gram/server/internal/external" @@ -463,6 +464,16 @@ func mcpRuntimeFlags() []cli.Flag { EnvVars: []string{"GRAM_DEVIDP_BACKEND"}, Hidden: true, }, + &cli.StringFlag{ + Name: "e2e-control-token", + Usage: "Shared secret that enables the end-to-end test control surface (/rpc/e2e.*). Empty leaves it off; the server refuses to start with it set in production.", + EnvVars: []string{"GRAM_E2E_CONTROL_TOKEN"}, + }, + &cli.StringFlag{ + Name: "e2e-user-email", + Usage: "The one identity the end-to-end test control surface signs in. Required with e2e-control-token.", + EnvVars: []string{"GRAM_E2E_USER_EMAIL"}, + }, &cli.StringFlag{ Name: "demoseed-fixture-devidp-url", Usage: "Local dev-idp URL whose tokens the demo seed MCP fixture's Enterprise Sign-In endpoint takes (empty: not served)", @@ -1707,6 +1718,24 @@ func newStartCommand() *cli.Command { ) authService.SetTokenRevoker(chatSessionsManager, meterProvider) auth.Attach(mux, authService) + // End-to-end test control surface: off unless a token is configured, + // and New refuses production, so a stray secret fails the boot loudly + // instead of opening a sign-in route. + if e2eConfig := (e2econtrol.Config{ + Environment: c.String("environment"), + Token: c.String("e2e-control-token"), + UserEmail: e2eUserEmail(ctx, c.String("environment"), c.String("e2e-user-email")), + SiteURL: siteURL.String(), + ServerURL: serverURL.String(), + Build: GitSHA, + }); e2eConfig.Enabled() { + e2eService, err := e2econtrol.New(logger, e2eConfig, identityResolver, sessionManager, cache.NewRedisCacheAdapter(redisClient), + newE2EReseeder(c.String("environment"), logger, db, chDB, assetStorage, encryptionClient, redisClient, c.String("authz-issuer-url"), siteURL, serverURL, e2eConfig.UserEmail)) + if err != nil { + return fmt.Errorf("end-to-end test control surface: %w", err) + } + e2econtrol.Attach(mux, e2eService) + } // The support matrix is seeded here as well as in the admin server, since // the step mirror needs its integration methods and either process may // start first. diff --git a/server/internal/demoseed/demoseed.go b/server/internal/demoseed/demoseed.go index 9371a1d4313..b4961dc452f 100644 --- a/server/internal/demoseed/demoseed.go +++ b/server/internal/demoseed/demoseed.go @@ -42,6 +42,9 @@ const ( demoSeedLockCleanupTimeout = 5 * time.Second ) +// ErrSeedLocked reports that another seed run holds the shared advisory lock. +var ErrSeedLocked = errors.New("another demo seed run holds the advisory lock; refusing to run concurrently") + // Run replaces the data for spec's tenant while holding the shared advisory // lock. The Postgres seed runs in one transaction, so a failed run leaves the // previous data in place; each statement in it gets its own statement @@ -109,7 +112,7 @@ func withSeedLock(ctx context.Context, logger *slog.Logger, db *pgxpool.Pool, fn } if !locked { conn.Release() - return errors.New("another demo seed run holds the advisory lock; refusing to run concurrently") + return ErrSeedLocked } defer func() { unlockCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), demoSeedLockCleanupTimeout) diff --git a/server/internal/e2econtrol/e2econtrol.go b/server/internal/e2econtrol/e2econtrol.go new file mode 100644 index 00000000000..934acac84d4 --- /dev/null +++ b/server/internal/e2econtrol/e2econtrol.go @@ -0,0 +1,355 @@ +// Package e2econtrol is a control surface for end-to-end tests that run +// against a deployed, non-production environment (a per-PR preview or dev) and +// against a local stack through the same calls. +// +// It gives a test run two things it cannot get through the product: +// +// - a signed-in dashboard session for the one configured test identity, +// without driving the identity provider's hosted pages (e2e.signInLink, +// then e2e.signIn in the browser); +// - a known starting state for the one test organization (e2e.reseed), and +// that organization's identifiers (e2e.tenant) so a test names nothing +// environment-specific. +// +// It is off unless a control token is configured, and New refuses to build it +// in production whatever the configuration says. +package e2econtrol + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "crypto/subtle" + "encoding/base64" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "log/slog" + "net/http" + "net/url" + "strings" + "time" + + goahttp "goa.design/goa/v3/http" + + "github.com/speakeasy-api/gram/server/internal/attr" + "github.com/speakeasy-api/gram/server/internal/auth/identity" + "github.com/speakeasy-api/gram/server/internal/auth/sessions" + "github.com/speakeasy-api/gram/server/internal/constants" + "github.com/speakeasy-api/gram/server/internal/o11y" +) + +const ( + // TokenHeader carries the control token on every call except e2e.signIn, + // which a browser opens and which is authorized by its one-time ticket. + TokenHeader = "Gram-E2E-Token" //nolint:gosec // G101: a header name, not a credential + + // productionEnvironment is the one environment this surface never exists in. + productionEnvironment = "prod" + + // ticketTTL is how long a sign-in link stays redeemable. The test opens it + // in the step after it asks for it. + ticketTTL = 60 * time.Second + + minTokenLength = 32 +) + +// ErrNotConfigured reports that no reseeder is wired for this environment. +var ErrNotConfigured = errors.New("e2e reseed is not configured for this environment") + +// ErrSeedBusy reports that another seed run holds the seed lock. +var ErrSeedBusy = errors.New("another seed run is in progress") + +// Config is the surface's configuration. A zero Token disables it. +type Config struct { + // Environment is the deployment environment (GRAM_ENVIRONMENT). + Environment string + // Token is the shared control secret (GRAM_E2E_CONTROL_TOKEN). + Token string + // UserEmail is the only identity e2e.signIn signs in (GRAM_E2E_USER_EMAIL). + UserEmail string + // SiteURL is the dashboard origin the browser lands on after sign-in. + SiteURL string + // ServerURL is this server's own origin, the base of sign-in links. + ServerURL string + // Build is the commit this server was built from. A test run reads it from + // e2e.tenant to wait until a deployment serves the commit under test. + Build string +} + +// Enabled reports whether the surface should be mounted. +func (c Config) Enabled() bool { return c.Token != "" } + +// Tenant identifies the organization end-to-end tests run in. Tests read it +// from e2e.tenant instead of hard-coding slugs or seeded ids. +type Tenant struct { + OrganizationID string `json:"organization_id"` + OrganizationSlug string `json:"organization_slug"` + ProjectSlug string `json:"project_slug"` + // SeededUserPrefix prefixes the ids of the seeded fictional members. + SeededUserPrefix string `json:"seeded_user_prefix"` + // APIKeyName is the name of the seeded API key. + APIKeyName string `json:"api_key_name"` +} + +// Identity is the part of identity.Resolver the sign-in needs. It is the same +// pair the invitation callback uses: a server-created Magic Auth code, then +// the bootstrap every identity-provider login runs. +type Identity interface { + AuthenticateWithMagicAuth(ctx context.Context, email string) (*identity.IDPUserInfo, error) + CompleteIDPLogin(ctx context.Context, idpUser *identity.IDPUserInfo, opts identity.IDPLoginOptions) (identity.IDPLoginResult, error) +} + +// SessionStore stores the dashboard session. Implemented by sessions.Manager. +type SessionStore interface { + StoreSessionIssuedAt(ctx context.Context, session sessions.Session, issuedAt time.Time) error +} + +// TicketStore holds one-time sign-in tickets. Implemented by cache.Cache. +type TicketStore interface { + Set(ctx context.Context, key string, value any, ttl time.Duration) error + GetAndDelete(ctx context.Context, key string, value any) error +} + +// Reseeder brings the test organization to its known state and names it. +type Reseeder interface { + // Reseed replaces the organization's data. It returns ErrSeedBusy when + // another seed run holds the lock. + Reseed(ctx context.Context) error + // Tenant returns the organization's identifiers. It does not write. + Tenant() Tenant +} + +// Service serves the control surface. +type Service struct { + logger *slog.Logger + cfg Config + identity Identity + sessions SessionStore + tickets TicketStore + reseeder Reseeder + now func() time.Time +} + +// New builds the service. It returns an error, which the server treats as a +// refusal to start, when the configuration would enable the surface in +// production or leave it guessable. +func New(logger *slog.Logger, cfg Config, idp Identity, sessionStore SessionStore, tickets TicketStore, reseeder Reseeder) (*Service, error) { + if !cfg.Enabled() { + return nil, errors.New("e2e control: no control token configured") + } + if cfg.Environment == productionEnvironment || cfg.Environment == "" { + return nil, fmt.Errorf("e2e control: refusing to enable in environment %q", cfg.Environment) + } + if len(cfg.Token) < minTokenLength { + return nil, fmt.Errorf("e2e control: the control token must be at least %d characters", minTokenLength) + } + if !strings.Contains(cfg.UserEmail, "@") { + return nil, errors.New("e2e control: a test user email is required") + } + for name, raw := range map[string]string{"site URL": cfg.SiteURL, "server URL": cfg.ServerURL} { + u, err := url.Parse(raw) + if err != nil || u.Host == "" || (u.Scheme != "https" && u.Scheme != "http") { + return nil, fmt.Errorf("e2e control: %s %q is not an absolute http(s) URL", name, raw) + } + } + return &Service{ + logger: logger.With(attr.SlogComponent("e2econtrol")), + cfg: cfg, + identity: idp, + sessions: sessionStore, + tickets: tickets, + reseeder: reseeder, + now: time.Now, + }, nil +} + +// Attach mounts the routes. +func Attach(mux goahttp.Muxer, s *Service) { + o11y.AttachHandler(mux, http.MethodPost, "/rpc/e2e.reseed", s.authorized(s.handleReseed)) + o11y.AttachHandler(mux, http.MethodGet, "/rpc/e2e.tenant", s.authorized(s.handleTenant)) + o11y.AttachHandler(mux, http.MethodPost, "/rpc/e2e.signInLink", s.authorized(s.handleSignInLink)) + o11y.AttachHandler(mux, http.MethodGet, "/rpc/e2e.signIn", s.handleSignIn) +} + +func (s *Service) authorized(next http.HandlerFunc) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + got := sha256.Sum256([]byte(r.Header.Get(TokenHeader))) + want := sha256.Sum256([]byte(s.cfg.Token)) + if subtle.ConstantTimeCompare(got[:], want[:]) != 1 { + writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "unauthorized"}) + return + } + next(w, r) + } +} + +type tenantResponse struct { + Tenant + Environment string `json:"environment"` + Build string `json:"build"` + UserEmail string `json:"user_email"` +} + +type reseedResponse struct { + tenantResponse + DurationMS int64 `json:"duration_ms"` +} + +func (s *Service) tenant() (tenantResponse, bool) { + if s.reseeder == nil { + return tenantResponse{Tenant: Tenant{OrganizationID: "", OrganizationSlug: "", ProjectSlug: "", SeededUserPrefix: "", APIKeyName: ""}, Environment: "", Build: "", UserEmail: ""}, false + } + return tenantResponse{Tenant: s.reseeder.Tenant(), Environment: s.cfg.Environment, Build: s.cfg.Build, UserEmail: s.cfg.UserEmail}, true +} + +func (s *Service) handleTenant(w http.ResponseWriter, _ *http.Request) { + tenant, ok := s.tenant() + if !ok { + writeJSON(w, http.StatusNotImplemented, map[string]string{"error": ErrNotConfigured.Error()}) + return + } + writeJSON(w, http.StatusOK, tenant) +} + +func (s *Service) handleReseed(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + tenant, ok := s.tenant() + if !ok { + writeJSON(w, http.StatusNotImplemented, map[string]string{"error": ErrNotConfigured.Error()}) + return + } + started := s.now() + if err := s.reseeder.Reseed(ctx); err != nil { + if errors.Is(err, ErrSeedBusy) { + writeJSON(w, http.StatusConflict, map[string]string{"error": ErrSeedBusy.Error()}) + return + } + s.logger.ErrorContext(ctx, "e2e reseed failed", attr.SlogError(err)) + writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "reseed failed"}) + return + } + elapsed := s.now().Sub(started) + s.logger.InfoContext(ctx, "e2e tenant reseeded", attr.SlogOrganizationID(tenant.OrganizationID)) + writeJSON(w, http.StatusOK, reseedResponse{tenantResponse: tenant, DurationMS: elapsed.Milliseconds()}) +} + +type signInLinkResponse struct { + // URL is opened once by the test's browser. It is spent on first use and + // expires after ExpiresInSeconds, so it is safe to appear in test evidence. + URL string `json:"url"` + // Path is URL without its origin, for a browser already aimed at the + // dashboard: every environment serves /rpc on the dashboard origin. + Path string `json:"path"` + ExpiresInSeconds int `json:"expires_in_seconds"` +} + +func (s *Service) handleSignInLink(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + raw := make([]byte, 32) + if _, err := rand.Read(raw); err != nil { + writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "could not create a ticket"}) + return + } + ticket := base64.RawURLEncoding.EncodeToString(raw) + if err := s.tickets.Set(ctx, ticketKey(ticket), true, ticketTTL); err != nil { + s.logger.ErrorContext(ctx, "store e2e sign-in ticket", attr.SlogError(err)) + writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "could not store the ticket"}) + return + } + path := "/rpc/e2e.signIn?ticket=" + url.QueryEscape(ticket) + writeJSON(w, http.StatusOK, signInLinkResponse{URL: strings.TrimRight(s.cfg.ServerURL, "/") + path, Path: path, ExpiresInSeconds: int(ticketTTL.Seconds())}) +} + +func (s *Service) handleSignIn(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + ticket := r.URL.Query().Get("ticket") + var live bool + if ticket == "" || s.tickets.GetAndDelete(ctx, ticketKey(ticket), &live) != nil || !live { + http.Error(w, "sign-in link is spent, expired or unknown", http.StatusForbidden) + return + } + + // Taken before authenticating so a sign-out everywhere that lands + // meanwhile still ends this session. + authenticatedAt := s.now() + idpUser, err := s.identity.AuthenticateWithMagicAuth(ctx, s.cfg.UserEmail) + if err != nil || idpUser == nil { + s.logger.ErrorContext(ctx, "e2e sign-in: identity provider refused the test user", attr.SlogError(err)) + http.Error(w, "the identity provider refused the test user", http.StatusBadGateway) + return + } + login, err := s.identity.CompleteIDPLogin(ctx, idpUser, identity.IDPLoginOptions{SkipMembershipSync: false, Attribution: nil}) + if err != nil || login.UserInfo == nil { + s.logger.ErrorContext(ctx, "e2e sign-in: login bootstrap failed", attr.SlogError(err)) + http.Error(w, "could not complete the login", http.StatusInternalServerError) + return + } + + // The session only ever enters the test organization. A test user who is + // not a member of it gets no session at all. + var active *sessions.Organization + if tenant, ok := s.tenant(); ok { + for i := range login.UserInfo.Organizations { + if login.UserInfo.Organizations[i].ID == tenant.OrganizationID { + active = &login.UserInfo.Organizations[i] + } + } + } else if len(login.UserInfo.Organizations) == 1 { + active = &login.UserInfo.Organizations[0] + } + if active == nil { + http.Error(w, "the test user is not a member of the test organization", http.StatusConflict) + return + } + + sessionID, err := sessions.NewSessionID() + if err != nil { + http.Error(w, "could not create a session", http.StatusInternalServerError) + return + } + session := sessions.Session{ + SessionID: sessionID, + UserID: login.UserID, + ActiveOrganizationID: active.ID, + WorkOSSessionID: idpUser.WorkOSSessionID, + ImpersonatorEmail: "", + SupportOrganizationID: "", + SupportExpiresAt: time.Time{}, + } + if err := s.sessions.StoreSessionIssuedAt(ctx, session, authenticatedAt); err != nil { + s.logger.ErrorContext(ctx, "e2e sign-in: store session", attr.SlogError(err)) + http.Error(w, "could not store the session", http.StatusInternalServerError) + return + } + + //nolint:exhaustruct_v5 // only desired fields, as the login callback sets them + http.SetCookie(w, &http.Cookie{ + Name: constants.SessionCookie, + Value: sessionID, + MaxAge: constants.SessionCookieMaxAgeSeconds, + Path: "/", + Secure: s.cfg.Environment != "local", + HttpOnly: true, + SameSite: http.SameSiteLaxMode, + }) + s.logger.InfoContext(ctx, "e2e sign-in complete", attr.SlogUserID(login.UserID), attr.SlogOrganizationID(active.ID)) + http.Redirect(w, r, strings.TrimRight(s.cfg.SiteURL, "/")+"/"+url.PathEscape(active.Slug), http.StatusSeeOther) +} + +// ticketKey stores a ticket under its hash, so the cache never holds a value +// that would sign anyone in. +func ticketKey(ticket string) string { + sum := sha256.Sum256([]byte(ticket)) + return "e2econtrol:signin:" + hex.EncodeToString(sum[:]) +} + +func writeJSON(w http.ResponseWriter, status int, body any) { + w.Header().Set("Content-Type", "application/json") + w.Header().Set("Cache-Control", "no-store") + w.WriteHeader(status) + if err := json.NewEncoder(w).Encode(body); err != nil { + return + } +} diff --git a/server/internal/e2econtrol/e2econtrol_test.go b/server/internal/e2econtrol/e2econtrol_test.go new file mode 100644 index 00000000000..2f67e834007 --- /dev/null +++ b/server/internal/e2econtrol/e2econtrol_test.go @@ -0,0 +1,306 @@ +package e2econtrol_test + +import ( + "context" + "encoding/json" + "errors" + "io" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "github.com/stretchr/testify/require" + goahttp "goa.design/goa/v3/http" + + "github.com/speakeasy-api/gram/server/internal/auth/identity" + "github.com/speakeasy-api/gram/server/internal/auth/sessions" + "github.com/speakeasy-api/gram/server/internal/constants" + "github.com/speakeasy-api/gram/server/internal/e2econtrol" + "github.com/speakeasy-api/gram/server/internal/testenv" +) + +const ( + testToken = "zz-e2e-not-a-secret-zz-e2e-not-a-secret" + testEmail = "e2e@example.test" + testOrgID = "org-e2e" +) + +type fakeIdentity struct { + emails []string + organizations []sessions.Organization +} + +func (f *fakeIdentity) AuthenticateWithMagicAuth(_ context.Context, email string) (*identity.IDPUserInfo, error) { + f.emails = append(f.emails, email) + return &identity.IDPUserInfo{Sub: "user_idp", Email: email, WorkOSSessionID: "session_idp"}, nil +} + +func (f *fakeIdentity) CompleteIDPLogin(_ context.Context, idpUser *identity.IDPUserInfo, _ identity.IDPLoginOptions) (identity.IDPLoginResult, error) { + return identity.IDPLoginResult{ + UserID: "user-gram", + UserInfo: &sessions.CachedUserInfo{UserID: "user-gram", Email: idpUser.Email, Organizations: f.organizations}, + }, nil +} + +type fakeSessions struct{ stored []sessions.Session } + +func (f *fakeSessions) StoreSessionIssuedAt(_ context.Context, session sessions.Session, _ time.Time) error { + f.stored = append(f.stored, session) + return nil +} + +type fakeTickets struct { + mu sync.Mutex + keys map[string]bool +} + +func (f *fakeTickets) Set(_ context.Context, key string, _ any, _ time.Duration) error { + f.mu.Lock() + defer f.mu.Unlock() + f.keys[key] = true + return nil +} + +func (f *fakeTickets) GetAndDelete(_ context.Context, key string, value any) error { + f.mu.Lock() + defer f.mu.Unlock() + if !f.keys[key] { + return errors.New("not found") + } + delete(f.keys, key) + if live, ok := value.(*bool); ok { + *live = true + } + return nil +} + +type fakeReseeder struct { + err error + calls int +} + +func (f *fakeReseeder) Reseed(context.Context) error { + f.calls++ + return f.err +} + +func (f *fakeReseeder) Tenant() e2econtrol.Tenant { + return e2econtrol.Tenant{OrganizationID: testOrgID, OrganizationSlug: "e2e-org", ProjectSlug: "default", SeededUserPrefix: "user_e2e_", APIKeyName: "seed-key"} +} + +type harness struct { + server *httptest.Server + identity *fakeIdentity + sessions *fakeSessions + reseeder *fakeReseeder +} + +// reply is what a test reads from one response, after its body is closed. +type reply struct { + status int + location string + cookies []*http.Cookie + body []byte +} + +func validConfig(serverURL string) e2econtrol.Config { + return e2econtrol.Config{Environment: "dev", Token: testToken, UserEmail: testEmail, SiteURL: "https://site.example.test", ServerURL: serverURL, Build: "0123abc"} +} + +func newHarness(t *testing.T) *harness { + t.Helper() + mux := goahttp.NewMuxer() + server := httptest.NewServer(mux) + t.Cleanup(server.Close) + + h := &harness{ + server: server, + identity: &fakeIdentity{emails: nil, organizations: []sessions.Organization{ + {ID: "org-other", Slug: "other"}, + {ID: testOrgID, Slug: "e2e-org"}, + }}, + sessions: &fakeSessions{stored: nil}, + reseeder: &fakeReseeder{err: nil, calls: 0}, + } + service, err := e2econtrol.New(testenv.NewLogger(t), validConfig(server.URL), h.identity, h.sessions, &fakeTickets{mu: sync.Mutex{}, keys: map[string]bool{}}, h.reseeder) + require.NoError(t, err) + e2econtrol.Attach(mux, service) + return h +} + +func (h *harness) do(t *testing.T, method, path, token string) reply { + t.Helper() + req, err := http.NewRequestWithContext(t.Context(), method, h.server.URL+path, nil) + require.NoError(t, err) + if token != "" { + req.Header.Set(e2econtrol.TokenHeader, token) + } + // Redirects are asserted, not followed. + client := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }} + res, err := client.Do(req) + require.NoError(t, err) + defer func() { require.NoError(t, res.Body.Close()) }() + body, err := io.ReadAll(res.Body) + require.NoError(t, err) + return reply{status: res.StatusCode, location: res.Header.Get("Location"), cookies: res.Cookies(), body: body} +} + +func TestNewRefusesUnsafeConfiguration(t *testing.T) { + t.Parallel() + + cases := map[string]func(*e2econtrol.Config){ + "production": func(c *e2econtrol.Config) { c.Environment = "prod" }, + "unnamed environment": func(c *e2econtrol.Config) { c.Environment = "" }, + "no token": func(c *e2econtrol.Config) { c.Token = "" }, + "guessable token": func(c *e2econtrol.Config) { c.Token = "short" }, + "no test user": func(c *e2econtrol.Config) { c.UserEmail = "" }, + "relative site URL": func(c *e2econtrol.Config) { c.SiteURL = "/dashboard" }, + "server URL not a URL": func(c *e2econtrol.Config) { c.ServerURL = "localhost" }, + } + for name, mutate := range cases { + t.Run(name, func(t *testing.T) { + t.Parallel() + cfg := validConfig("https://server.example.test") + mutate(&cfg) + _, err := e2econtrol.New(testenv.NewLogger(t), cfg, nil, nil, nil, nil) + require.Error(t, err) + }) + } +} + +func TestControlCallsNeedTheToken(t *testing.T) { + t.Parallel() + h := newHarness(t) + + for _, call := range []struct{ method, path string }{ + {http.MethodPost, "/rpc/e2e.reseed"}, + {http.MethodGet, "/rpc/e2e.tenant"}, + {http.MethodPost, "/rpc/e2e.signInLink"}, + } { + for _, token := range []string{"", "wrong-token-wrong-token-wrong-token-wrong"} { + got := h.do(t, call.method, call.path, token) + require.Equal(t, http.StatusUnauthorized, got.status, "%s %s with token %q", call.method, call.path, token) + } + } + require.Zero(t, h.reseeder.calls) +} + +func TestTenantNamesTheTestOrganization(t *testing.T) { + t.Parallel() + h := newHarness(t) + + res := h.do(t, http.MethodGet, "/rpc/e2e.tenant", testToken) + require.Equal(t, http.StatusOK, res.status) + var got map[string]any + require.NoError(t, json.Unmarshal(res.body, &got)) + require.Equal(t, "e2e-org", got["organization_slug"]) + require.Equal(t, "default", got["project_slug"]) + require.Equal(t, "user_e2e_", got["seeded_user_prefix"]) + require.Equal(t, "dev", got["environment"]) + require.Equal(t, "0123abc", got["build"]) + require.Zero(t, h.reseeder.calls, "reading the tenant must not reseed") +} + +func TestReseed(t *testing.T) { + t.Parallel() + + t.Run("replaces the tenant's data and names it", func(t *testing.T) { + t.Parallel() + h := newHarness(t) + res := h.do(t, http.MethodPost, "/rpc/e2e.reseed", testToken) + require.Equal(t, http.StatusOK, res.status) + require.Equal(t, 1, h.reseeder.calls) + var got map[string]any + require.NoError(t, json.Unmarshal(res.body, &got)) + require.Equal(t, "e2e-org", got["organization_slug"]) + }) + + t.Run("reports a seed already in progress as a conflict", func(t *testing.T) { + t.Parallel() + h := newHarness(t) + h.reseeder.err = e2econtrol.ErrSeedBusy + res := h.do(t, http.MethodPost, "/rpc/e2e.reseed", testToken) + require.Equal(t, http.StatusConflict, res.status) + }) + + t.Run("hides the cause of a failed seed", func(t *testing.T) { + t.Parallel() + h := newHarness(t) + h.reseeder.err = errors.New("postgres: connection string with a password") + res := h.do(t, http.MethodPost, "/rpc/e2e.reseed", testToken) + require.Equal(t, http.StatusInternalServerError, res.status) + require.NotContains(t, string(res.body), "password") + }) +} + +func signInLink(t *testing.T, h *harness) string { + t.Helper() + res := h.do(t, http.MethodPost, "/rpc/e2e.signInLink", testToken) + require.Equal(t, http.StatusOK, res.status) + var link struct { + URL string `json:"url"` + Path string `json:"path"` + } + require.NoError(t, json.Unmarshal(res.body, &link)) + require.True(t, strings.HasPrefix(link.Path, "/rpc/e2e.signIn?ticket="), "path %q", link.Path) + require.Equal(t, h.server.URL+link.Path, link.URL) + return link.Path +} + +func TestSignInLinkSignsTheTestUserIntoTheTestOrganizationOnce(t *testing.T) { + t.Parallel() + h := newHarness(t) + path := signInLink(t, h) + + res := h.do(t, http.MethodGet, path, "") + require.Equal(t, http.StatusSeeOther, res.status) + require.Equal(t, "https://site.example.test/e2e-org", res.location) + require.Equal(t, []string{testEmail}, h.identity.emails, "only the configured identity is ever signed in") + + require.Len(t, h.sessions.stored, 1) + session := h.sessions.stored[0] + require.Equal(t, "user-gram", session.UserID) + require.Equal(t, testOrgID, session.ActiveOrganizationID) + require.Equal(t, "session_idp", session.WorkOSSessionID) + + var cookie *http.Cookie + for _, c := range res.cookies { + if c.Name == constants.SessionCookie { + cookie = c + } + } + require.NotNil(t, cookie) + require.Equal(t, session.SessionID, cookie.Value) + require.True(t, cookie.HttpOnly) + require.True(t, cookie.Secure) + + again := h.do(t, http.MethodGet, path, "") + require.Equal(t, http.StatusForbidden, again.status, "a link is spent on first use") + require.Len(t, h.sessions.stored, 1) +} + +func TestSignInRefusesUnknownTickets(t *testing.T) { + t.Parallel() + h := newHarness(t) + + for _, path := range []string{"/rpc/e2e.signIn", "/rpc/e2e.signIn?ticket=", "/rpc/e2e.signIn?ticket=made-up"} { + res := h.do(t, http.MethodGet, path, testToken) + require.Equal(t, http.StatusForbidden, res.status, path) + } + require.Empty(t, h.identity.emails) + require.Empty(t, h.sessions.stored) +} + +func TestSignInGivesNoSessionOutsideTheTestOrganization(t *testing.T) { + t.Parallel() + h := newHarness(t) + h.identity.organizations = []sessions.Organization{{ID: "org-other", Slug: "other"}} + + res := h.do(t, http.MethodGet, signInLink(t, h), "") + require.Equal(t, http.StatusConflict, res.status) + require.Empty(t, h.sessions.stored) + require.Empty(t, res.cookies) +} diff --git a/server/internal/e2econtrol/openapi.yaml b/server/internal/e2econtrol/openapi.yaml new file mode 100644 index 00000000000..cf96015e299 --- /dev/null +++ b/server/internal/e2econtrol/openapi.yaml @@ -0,0 +1,194 @@ +openapi: 3.1.0 +info: + title: Speakeasy end-to-end test contract + version: "1" + description: >- + The operations an end-to-end test run calls outside the browser: the + non-production control surface (server/internal/e2econtrol) and the few + public API reads the suite's root uses to check the seeded state. A test + tool pins this file by its SHA-256, so changing it re-plans the flows that + name it. It is hand-written and deliberately small; the full public API is + server/gen/http/openapi3.yaml. +security: + - control: [] +paths: + /rpc/e2e.reseed: + post: + operationId: e2eReseed + description: Replace the test organization's data with the seed. 409 while another seed run holds the lock. + responses: + "200": + description: The test organization was reseeded + content: + application/json: + schema: + $ref: "#/components/schemas/Reseeded" + "409": + description: Another seed run is in progress + content: + application/json: + schema: + $ref: "#/components/schemas/Problem" + /rpc/e2e.tenant: + get: + operationId: e2eTenant + description: Identify the test organization. Reads only. + responses: + "200": + description: The test organization + content: + application/json: + schema: + $ref: "#/components/schemas/Tenant" + /rpc/e2e.signInLink: + post: + operationId: e2eSignInLink + description: Mint a link that signs a browser in as the test user, once, within a minute. + responses: + "200": + description: A one-time sign-in link + content: + application/json: + schema: + type: object + required: [url, path, expires_in_seconds] + properties: + url: + type: string + path: + type: string + expires_in_seconds: + type: integer + /rpc/toolsets.get: + get: + operationId: getToolset + security: + - apiKey: [] + project: [] + parameters: + - name: slug + in: query + required: true + schema: + type: string + responses: + "200": + description: The MCP server (toolset) + content: + application/json: + schema: + type: object + properties: + name: + type: string + slug: + type: string + tools: + type: array + items: + type: object + "404": + description: No such toolset + content: + application/json: + schema: + $ref: "#/components/schemas/Problem" + /rpc/access.listRoles: + get: + operationId: listRoles + security: + - apiKey: [] + project: [] + responses: + "200": + description: The organization's roles + content: + application/json: + schema: + type: object + properties: + roles: + type: array + items: + type: object + properties: + name: + type: string + slug: + type: string + is_system: + type: boolean +components: + securitySchemes: + control: + type: apiKey + in: header + name: Gram-E2E-Token + apiKey: + type: apiKey + in: header + name: Gram-Key + project: + type: apiKey + in: header + name: Gram-Project + schemas: + Tenant: + type: object + required: + [ + organization_id, + organization_slug, + project_slug, + seeded_user_prefix, + environment, + build, + ] + properties: + organization_id: + type: string + organization_slug: + type: string + project_slug: + type: string + seeded_user_prefix: + type: string + api_key_name: + type: string + environment: + type: string + build: + type: string + user_email: + type: string + Reseeded: + type: object + required: [organization_slug, project_slug, duration_ms] + properties: + organization_id: + type: string + organization_slug: + type: string + project_slug: + type: string + seeded_user_prefix: + type: string + api_key_name: + type: string + environment: + type: string + build: + type: string + user_email: + type: string + duration_ms: + type: integer + Problem: + type: object + properties: + error: + type: string + name: + type: string + message: + type: string From d1c77e4532de4130aedad796cba1ae5ab9b8af19 Mon Sep 17 00:00:00 2001 From: Thomas Rooney Date: Sat, 21 Nov 2026 10:55:20 +0000 Subject: [PATCH 2/4] chore: narrow the end-to-end test control surface to an opt-in local stack --- dev-idp/internal/modes/mockworkos/workos.go | 14 - mise.toml | 6 - server/cmd/gram/deps_e2e.go | 147 ++++--- server/cmd/gram/deps_e2e_test.go | 134 ++++++ server/cmd/gram/start.go | 52 +-- server/internal/e2econtrol/e2econtrol.go | 392 +++++++---------- server/internal/e2econtrol/e2econtrol_test.go | 415 +++++++++++------- server/internal/e2econtrol/openapi.yaml | 125 ++---- 8 files changed, 703 insertions(+), 582 deletions(-) create mode 100644 server/cmd/gram/deps_e2e_test.go diff --git a/dev-idp/internal/modes/mockworkos/workos.go b/dev-idp/internal/modes/mockworkos/workos.go index 61c57d5b843..6bb156e0d61 100644 --- a/dev-idp/internal/modes/mockworkos/workos.go +++ b/dev-idp/internal/modes/mockworkos/workos.go @@ -67,9 +67,6 @@ const invitationLifetime = 30 * 24 * time.Hour const ( magicAuthGrantType = "urn:workos:oauth:grant-type:magic-auth:code" magicAuthLifetime = 10 * time.Minute - // defaultUserMode is the mode whose currentUser the default-user bootstrap - // records (oauth21.Mode; that package is not imported here). - defaultUserMode = "oauth2-1" ) // defaultPageSize / maxPageSize match WorkOS's documented limits closely @@ -149,17 +146,6 @@ func (h *Handler) handleWorkosCreateMagicAuth(w http.ResponseWriter, r *http.Req return } - // The default developer is a member of the default organization only once - // something has bootstrapped it, which until now was the first hosted - // login. A Magic Auth sign-in for that developer (the end-to-end test - // sign-in) must see the same memberships, or the server's membership sync - // reads "none" and removes the developer from their own organization. - if committer, err := defaultuser.GitCommitter(ctx); err == nil && strings.EqualFold(committer.Email, body.Email) { - if _, err := defaultuser.BootstrapLocalUser(ctx, h.db, defaultUserMode); err != nil { - h.logger.WarnContext(ctx, "magic auth: bootstrap default user", slog.Any("error", err)) - } - } - user, err := repo.New(h.db).UpsertUserByEmail(ctx, repo.UpsertUserByEmailParams{ ID: defaultuser.DeterministicUserID(body.Email), Email: body.Email, diff --git a/mise.toml b/mise.toml index 8fc6b8ccbad..37bcff22027 100644 --- a/mise.toml +++ b/mise.toml @@ -174,12 +174,6 @@ GRAM_REDIS_ENABLE_TRACING = "false" ## back into mise.local.toml after a seed run — a fresh clone is configured ## before it is ever seeded. Keep in sync with server/internal/demoseed/local.go. GRAM_API_KEY = "gram_local_5eed10ca15eed10ca15eed10ca15eed10ca15eed10ca15eed10ca15eed10ca11" -## End-to-end test control surface (server/internal/e2econtrol): lets a test run -## reseed the local organization and sign in as you without driving the dev-idp. -## A fixed, well-known local-only value like GRAM_API_KEY above. Deployed -## non-production environments inject their own from secrets; production -## refuses to start with one set. -GRAM_E2E_CONTROL_TOKEN = "gram_local_e2e_5eed10ca15eed10ca15eed10ca15eed10ca1" ## Local-only value; real deployments inject this via secrets. GRAM_TUNNEL_FORWARD_TOKEN = "local-dev-tunnel-forward-token" diff --git a/server/cmd/gram/deps_e2e.go b/server/cmd/gram/deps_e2e.go index a25303f260c..7ab8d25ea3b 100644 --- a/server/cmd/gram/deps_e2e.go +++ b/server/cmd/gram/deps_e2e.go @@ -12,84 +12,101 @@ import ( "github.com/ClickHouse/clickhouse-go/v2/lib/driver" "github.com/jackc/pgx/v5/pgxpool" "github.com/redis/go-redis/v9" + goahttp "goa.design/goa/v3/http" "github.com/speakeasy-api/gram/server/internal/assets" + "github.com/speakeasy-api/gram/server/internal/cache" "github.com/speakeasy-api/gram/server/internal/demoseed" "github.com/speakeasy-api/gram/server/internal/e2econtrol" "github.com/speakeasy-api/gram/server/internal/encryption" ) -// e2eUserEmail is the identity the control surface signs in. Locally it -// defaults to the developer the dev-idp and the local seed both derive from -// `git config user.email`, so a fresh clone needs no extra setting. -func e2eUserEmail(ctx context.Context, environment, configured string) string { - if configured != "" || environment != "local" { - return configured - } - out, err := exec.CommandContext(ctx, "git", "config", "--get", "user.email").Output() - if err != nil { - return "" - } - return strings.TrimSpace(string(out)) +// e2eControlTokenFlag belongs to the API server only (serverFlags): no other +// command mounts the surface, so no other command accepts its token. +const e2eControlTokenFlag = "e2e-control-token" //nolint:gosec // G101: a flag name, not a credential + +// e2eControlDeps is what the end-to-end test control surface is built from. +type e2eControlDeps struct { + environment string + // identityBackend is GRAM_DEVIDP_BACKEND: "local" is the dev-idp's own + // emulator, anything else forwards sign-ins to a real identity provider. + identityBackend string + // identityEndpoint is where Magic Auth is sent (WORKOS_API_URL; empty is + // the real provider) and devIDPURL is this stack's dev-idp origin. + identityEndpoint string + devIDPURL string + token string + // developerEmail names the local developer, who is the test user. + developerEmail func(ctx context.Context) string + siteURL *url.URL + serverURL *url.URL + issuerURL string + db *pgxpool.Pool + clickhouse driver.Conn + blob assets.BlobStore + encryption *encryption.Client + redis *redis.Client + identity e2econtrol.Identity + sessions e2econtrol.SessionStore } -// newE2EReseeder returns what e2e.reseed runs in this environment, or nil when -// none is wired, in which case e2e.reseed and e2e.tenant answer 501. -// -// Locally the test organization is the local development organization: the -// reseed is the demo seed retargeted at demoseed.LocalSpec plus the local -// fixtures, the same Go that `mise run seed` runs. +// attachE2EControl mounts the end-to-end test control surface (/rpc/e2e.*) +// when a control token is configured, and mounts nothing otherwise. A token +// configured anywhere but a local stack (e2econtrol.New), or on a local stack +// that signs in through a real identity provider, is an error, which stops +// the server from starting. // -// Deployed environments are not wired in this proposal. They need a Spec for -// a dedicated test organization (derived from its WorkOS organization id, as -// LocalSpec is from the dev-idp's) and the member-adoption half of the local -// fixtures generalized beyond LocalSpec. -func newE2EReseeder(environment string, logger *slog.Logger, db *pgxpool.Pool, ch driver.Conn, blob assets.BlobStore, enc *encryption.Client, cache *redis.Client, issuerURL string, siteURL, serverURL *url.URL, userEmail string) e2econtrol.Reseeder { - if environment != "local" { +// The test organization is the local development organization and the test +// user is the developer the local seed adopts into it (`git config +// user.email`), so e2e.reseed is the Go that `mise run seed` runs for that +// organization. +func attachE2EControl(ctx context.Context, logger *slog.Logger, mux goahttp.Muxer, d e2eControlDeps) error { + if d.token == "" { return nil } - return &localE2EReseeder{logger: logger, db: db, ch: ch, blob: blob, enc: enc, cache: cache, issuerURL: issuerURL, siteURL: siteURL, serverURL: serverURL, userEmail: userEmail} -} - -type localE2EReseeder struct { - logger *slog.Logger - db *pgxpool.Pool - ch driver.Conn - blob assets.BlobStore - enc *encryption.Client - cache *redis.Client - issuerURL string - siteURL *url.URL - serverURL *url.URL - userEmail string -} - -func (r *localE2EReseeder) Tenant() e2econtrol.Tenant { spec := demoseed.LocalSpec() - return e2econtrol.Tenant{ - OrganizationID: spec.OrgID, - OrganizationSlug: spec.OrgSlug, - ProjectSlug: "default", - SeededUserPrefix: spec.UserPrefix, - APIKeyName: demoseed.LocalAPIKeyName, + email := d.developerEmail(ctx) + service, err := e2econtrol.New(logger, e2econtrol.Config{ + Environment: d.environment, + Token: d.token, + UserEmail: email, + SiteURL: d.siteURL, + Build: GitSHA, + Tenant: e2econtrol.Tenant{ + OrganizationID: spec.OrgID, + OrganizationSlug: spec.OrgSlug, + ProjectSlug: "default", + SeededUserPrefix: spec.UserPrefix, + }, + Reseed: func(ctx context.Context) error { return reseedLocalOrganization(ctx, logger, d, spec, email) }, + }, d.identity, d.sessions, cache.NewRedisCacheAdapter(d.redis)) + if err != nil { + return fmt.Errorf("end-to-end test control surface: %w", err) + } + if d.identityBackend != "local" || d.devIDPURL == "" || d.identityEndpoint != d.devIDPURL+"/workos" { + return errors.New("end-to-end test control surface: it signs in through this stack's dev-idp emulator only (GRAM_DEVIDP_BACKEND=local, WORKOS_API_URL at the dev-idp)") } + e2econtrol.Attach(mux, service) + logger.WarnContext(ctx, "end-to-end test control surface is enabled (/rpc/e2e.*)") + return nil } -func (r *localE2EReseeder) Reseed(ctx context.Context) error { - if err := demoseed.Run(ctx, r.logger, r.db, r.ch, r.blob, r.enc, r.issuerURL, r.serverURL.String(), demoseed.LocalSpec()); err != nil { - if errors.Is(err, demoseed.ErrSeedLocked) { - return e2econtrol.ErrSeedBusy - } +// reseedLocalOrganization replaces the local organization's data with the +// shared seed, then applies the local fixtures that restore the developer's +// membership and the seeded API key. +// +// The developer-machine upstreams (Enterprise Sign-In through the dev-idp, the +// Linear and Notion clients) and the Slack test app are left as the seed set +// them: `mise run seed` wires those from the developer's environment, which a +// request handler does not read. +func reseedLocalOrganization(ctx context.Context, logger *slog.Logger, d e2eControlDeps, spec demoseed.Spec, email string) error { + if err := demoseed.Run(ctx, logger, d.db, d.clickhouse, d.blob, d.encryption, d.issuerURL, d.serverURL.String(), spec); err != nil { return fmt.Errorf("apply seed: %w", err) } - // The developer-machine upstreams (Enterprise Sign-In through the dev-idp, - // the Linear and Notion clients) and the Slack test app are left as the - // shared seed set them: `mise run seed` wires those from the developer's - // environment, which a request handler does not read. - if err := demoseed.RunLocalFixtures(ctx, r.logger, r.db, r.blob, r.cache, demoseed.LocalFixturesOptions{ - SiteURL: r.siteURL, - DeveloperEmail: r.userEmail, - Environment: "local", + if err := demoseed.RunLocalFixtures(ctx, logger, d.db, d.blob, d.redis, demoseed.LocalFixturesOptions{ + SiteURL: d.siteURL, + DeveloperEmail: email, + Environment: d.environment, ObservedEnv: nil, Slack: demoseed.LocalSlackOptions{BotToken: "", SlackEmail: "", Encryption: nil, Slack: nil}, Upstreams: demoseed.LocalUpstreamOptions{ServerURL: nil, Encryption: nil, DevIDPURL: "", DevIDPClientID: "", HTTPClient: nil, Policy: nil, CacheDir: ""}, @@ -100,3 +117,13 @@ func (r *localE2EReseeder) Reseed(ctx context.Context) error { } return nil } + +// gitUserEmail is the address the dev-idp and the local seed both identify the +// developer by. Empty when git has none, which e2econtrol.New refuses. +func gitUserEmail(ctx context.Context) string { + out, err := exec.CommandContext(ctx, "git", "config", "--get", "user.email").Output() + if err != nil { + return "" + } + return strings.TrimSpace(string(out)) +} diff --git a/server/cmd/gram/deps_e2e_test.go b/server/cmd/gram/deps_e2e_test.go new file mode 100644 index 00000000000..83febb95488 --- /dev/null +++ b/server/cmd/gram/deps_e2e_test.go @@ -0,0 +1,134 @@ +package gram + +import ( + "context" + "net/http" + "net/http/httptest" + "net/url" + "slices" + "testing" + + "github.com/alicebob/miniredis/v2" + "github.com/redis/go-redis/v9" + "github.com/stretchr/testify/require" + "github.com/urfave/cli/v2" + goahttp "goa.design/goa/v3/http" + + "github.com/speakeasy-api/gram/server/internal/e2econtrol" + "github.com/speakeasy-api/gram/server/internal/testenv" +) + +const ( + testE2EControlToken = "zz-e2e-not-a-secret-zz-e2e-not-a-secret" + testDevIDPURL = "http://localhost:35291" + testEmulatorURL = testDevIDPURL + "/workos" +) + +// attachTestE2EControl runs the startup decision with no database or identity +// provider behind it (neither is touched by the calls below) and reports the +// status each route then answers. +func attachTestE2EControl(t *testing.T, environment, identityBackend, identityEndpoint, token string) (map[string]int, error) { + t.Helper() + siteURL, err := url.Parse("https://site.example.test") + require.NoError(t, err) + redisClient := redis.NewClient(&redis.Options{Addr: miniredis.RunT(t).Addr()}) + t.Cleanup(func() { require.NoError(t, redisClient.Close()) }) + mux := goahttp.NewMuxer() + err = attachE2EControl(t.Context(), testenv.NewLogger(t), mux, e2eControlDeps{ + environment: environment, + identityBackend: identityBackend, + identityEndpoint: identityEndpoint, + devIDPURL: testDevIDPURL, + token: token, + developerEmail: func(context.Context) string { return "developer@example.test" }, + siteURL: siteURL, + serverURL: siteURL, + issuerURL: "", + db: nil, + clickhouse: nil, + blob: nil, + encryption: nil, + redis: redisClient, + identity: nil, + sessions: nil, + }) + statuses := map[string]int{} + for _, route := range []struct{ method, path string }{ + {http.MethodGet, "/rpc/e2e.tenant"}, + {http.MethodGet, "/rpc/e2e.signIn"}, + // Asked without the token, so a mounted route answers 401 and nothing runs. + {http.MethodPost, "/rpc/e2e.reseed"}, + {http.MethodPost, "/rpc/e2e.signInLink"}, + } { + req := httptest.NewRequestWithContext(t.Context(), route.method, route.path, nil) + if route.method == http.MethodGet { + req.Header.Set(e2econtrol.TokenHeader, testE2EControlToken) + } + rec := httptest.NewRecorder() + mux.ServeHTTP(rec, req) + statuses[route.path] = rec.Code + } + return statuses, err +} + +var e2eControlNotMounted = map[string]int{ + "/rpc/e2e.tenant": http.StatusNotFound, + "/rpc/e2e.signIn": http.StatusNotFound, + "/rpc/e2e.reseed": http.StatusNotFound, + "/rpc/e2e.signInLink": http.StatusNotFound, +} + +func TestE2EControlIsOffWithoutAToken(t *testing.T) { + t.Parallel() + for _, environment := range []string{"local", "dev", "prod"} { + statuses, err := attachTestE2EControl(t, environment, "local", testEmulatorURL, "") + require.NoError(t, err, environment) + require.Equal(t, e2eControlNotMounted, statuses, environment) + } +} + +func TestE2EControlTokenStopsStartupOutsideLocal(t *testing.T) { + t.Parallel() + for _, environment := range []string{"prod", "production", "dev", "preview", "staging", "Local", ""} { + statuses, err := attachTestE2EControl(t, environment, "local", testEmulatorURL, testE2EControlToken) + require.ErrorContains(t, err, "exists only in", environment) + require.Equal(t, e2eControlNotMounted, statuses, environment) + } +} + +func TestE2EControlTokenStopsStartupWithARealIdentityProvider(t *testing.T) { + t.Parallel() + for name, identity := range map[string]struct{ backend, endpoint string }{ + "the dev-idp forwarding to a real provider": {"workos", testEmulatorURL}, + "no backend named": {"", testEmulatorURL}, + "no endpoint, so the provider's own": {"local", ""}, + "an endpoint that is not the dev-idp": {"local", "https://api.example.test"}, + } { + statuses, err := attachTestE2EControl(t, "local", identity.backend, identity.endpoint, testE2EControlToken) + require.ErrorContains(t, err, "dev-idp emulator only", name) + require.Equal(t, e2eControlNotMounted, statuses, name) + } +} + +func TestE2EControlIsMountedLocallyBehindTheToken(t *testing.T) { + t.Parallel() + statuses, err := attachTestE2EControl(t, "local", "local", testEmulatorURL, testE2EControlToken) + require.NoError(t, err) + require.Equal(t, map[string]int{ + "/rpc/e2e.tenant": http.StatusOK, + "/rpc/e2e.signIn": http.StatusForbidden, // no code + "/rpc/e2e.reseed": http.StatusUnauthorized, + "/rpc/e2e.signInLink": http.StatusUnauthorized, + }, statuses) +} + +// Only the API server takes the token: a command that accepted it without +// mounting the surface could not refuse to start with it. +func TestE2EControlTokenFlagBelongsToTheServerOnly(t *testing.T) { + t.Parallel() + has := func(flags []cli.Flag) bool { + return slices.ContainsFunc(flags, func(f cli.Flag) bool { return slices.Contains(f.Names(), e2eControlTokenFlag) }) + } + require.True(t, has(serverFlags())) + require.False(t, has(mcpRuntimeFlags())) +} diff --git a/server/cmd/gram/start.go b/server/cmd/gram/start.go index baca0569ca1..36c8766952d 100644 --- a/server/cmd/gram/start.go +++ b/server/cmd/gram/start.go @@ -74,7 +74,6 @@ import ( "github.com/speakeasy-api/gram/server/internal/deployments" "github.com/speakeasy-api/gram/server/internal/deviceagentversions" "github.com/speakeasy-api/gram/server/internal/deviceintegrations" - "github.com/speakeasy-api/gram/server/internal/e2econtrol" "github.com/speakeasy-api/gram/server/internal/encryption" "github.com/speakeasy-api/gram/server/internal/environments" "github.com/speakeasy-api/gram/server/internal/external" @@ -464,16 +463,6 @@ func mcpRuntimeFlags() []cli.Flag { EnvVars: []string{"GRAM_DEVIDP_BACKEND"}, Hidden: true, }, - &cli.StringFlag{ - Name: "e2e-control-token", - Usage: "Shared secret that enables the end-to-end test control surface (/rpc/e2e.*). Empty leaves it off; the server refuses to start with it set in production.", - EnvVars: []string{"GRAM_E2E_CONTROL_TOKEN"}, - }, - &cli.StringFlag{ - Name: "e2e-user-email", - Usage: "The one identity the end-to-end test control surface signs in. Required with e2e-control-token.", - EnvVars: []string{"GRAM_E2E_USER_EMAIL"}, - }, &cli.StringFlag{ Name: "demoseed-fixture-devidp-url", Usage: "Local dev-idp URL whose tokens the demo seed MCP fixture's Enterprise Sign-In endpoint takes (empty: not served)", @@ -706,6 +695,11 @@ func serverFlags() []cli.Flag { &cli.StringFlag{Name: "ssl-key-file", Usage: "The SSL key file path to use for the server", EnvVars: []string{"GRAM_SSL_KEY_FILE"}}, &cli.StringFlag{Name: "ssl-cert-file", Usage: "The SSL certificate file path to use for the server", EnvVars: []string{"GRAM_SSL_CERT_FILE"}}, &cli.StringFlag{Name: "github-evidence-token", Usage: "GitHub API token for MCP evidence repository lookups", EnvVars: []string{"GRAM_GITHUB_EVIDENCE_TOKEN"}}, + &cli.StringFlag{ + Name: e2eControlTokenFlag, + Usage: "Secret that enables the end-to-end test control surface (/rpc/e2e.*) on a local stack. Unset leaves it off. The server refuses to start with it set in any other environment.", + EnvVars: []string{"GRAM_E2E_CONTROL_TOKEN"}, + }, &cli.StringFlag{ Name: "loops-api-key", Usage: "Loops API key for workflows, contacts, and legacy transactional delivery.", @@ -1718,23 +1712,25 @@ func newStartCommand() *cli.Command { ) authService.SetTokenRevoker(chatSessionsManager, meterProvider) auth.Attach(mux, authService) - // End-to-end test control surface: off unless a token is configured, - // and New refuses production, so a stray secret fails the boot loudly - // instead of opening a sign-in route. - if e2eConfig := (e2econtrol.Config{ - Environment: c.String("environment"), - Token: c.String("e2e-control-token"), - UserEmail: e2eUserEmail(ctx, c.String("environment"), c.String("e2e-user-email")), - SiteURL: siteURL.String(), - ServerURL: serverURL.String(), - Build: GitSHA, - }); e2eConfig.Enabled() { - e2eService, err := e2econtrol.New(logger, e2eConfig, identityResolver, sessionManager, cache.NewRedisCacheAdapter(redisClient), - newE2EReseeder(c.String("environment"), logger, db, chDB, assetStorage, encryptionClient, redisClient, c.String("authz-issuer-url"), siteURL, serverURL, e2eConfig.UserEmail)) - if err != nil { - return fmt.Errorf("end-to-end test control surface: %w", err) - } - e2econtrol.Attach(mux, e2eService) + if err := attachE2EControl(ctx, logger, mux, e2eControlDeps{ + environment: c.String("environment"), + identityBackend: c.String("devidp-backend"), + identityEndpoint: c.String("workos-endpoint"), + devIDPURL: fixtureDevIDPURL, + token: c.String(e2eControlTokenFlag), + developerEmail: gitUserEmail, + siteURL: siteURL, + serverURL: serverURL, + issuerURL: c.String("authz-issuer-url"), + db: db, + clickhouse: chDB, + blob: assetStorage, + encryption: encryptionClient, + redis: redisClient, + identity: identityResolver, + sessions: sessionManager, + }); err != nil { + return err } // The support matrix is seeded here as well as in the admin server, since // the step mirror needs its integration methods and either process may diff --git a/server/internal/e2econtrol/e2econtrol.go b/server/internal/e2econtrol/e2econtrol.go index 934acac84d4..78fcc7e9a5f 100644 --- a/server/internal/e2econtrol/e2econtrol.go +++ b/server/internal/e2econtrol/e2econtrol.go @@ -1,26 +1,22 @@ -// Package e2econtrol is a control surface for end-to-end tests that run -// against a deployed, non-production environment (a per-PR preview or dev) and -// against a local stack through the same calls. +// Package e2econtrol is a control surface for end-to-end tests. It gives a test +// run two things it cannot get through the product: // -// It gives a test run two things it cannot get through the product: -// -// - a signed-in dashboard session for the one configured test identity, -// without driving the identity provider's hosted pages (e2e.signInLink, -// then e2e.signIn in the browser); // - a known starting state for the one test organization (e2e.reseed), and -// that organization's identifiers (e2e.tenant) so a test names nothing -// environment-specific. +// the names a test needs to address it (e2e.tenant); +// - a signed-in dashboard session for the one test user, without driving the +// identity provider's pages (e2e.signInLink, then e2e.signIn in the browser). +// +// No route takes an organization, a user or a destination from its caller: all +// three are fixed when the server starts. // -// It is off unless a control token is configured, and New refuses to build it -// in production whatever the configuration says. +// It exists only on a local stack. New refuses every other environment, so a +// control token configured anywhere else stops the server from starting. package e2econtrol import ( "context" - "crypto/rand" "crypto/sha256" "crypto/subtle" - "encoding/base64" "encoding/hex" "encoding/json" "errors" @@ -28,74 +24,74 @@ import ( "log/slog" "net/http" "net/url" + "slices" "strings" + "sync" "time" + redisCache "github.com/go-redis/cache/v9" goahttp "goa.design/goa/v3/http" "github.com/speakeasy-api/gram/server/internal/attr" "github.com/speakeasy-api/gram/server/internal/auth/identity" "github.com/speakeasy-api/gram/server/internal/auth/sessions" + "github.com/speakeasy-api/gram/server/internal/cache" "github.com/speakeasy-api/gram/server/internal/constants" + "github.com/speakeasy-api/gram/server/internal/conv" + "github.com/speakeasy-api/gram/server/internal/demoseed" "github.com/speakeasy-api/gram/server/internal/o11y" + "github.com/speakeasy-api/gram/server/internal/oops" ) const ( // TokenHeader carries the control token on every call except e2e.signIn, - // which a browser opens and which is authorized by its one-time ticket. + // which a browser opens and which its one-time code authorizes. TokenHeader = "Gram-E2E-Token" //nolint:gosec // G101: a header name, not a credential - // productionEnvironment is the one environment this surface never exists in. - productionEnvironment = "prod" + // allowedEnvironment is the only environment the surface exists in. + allowedEnvironment = "local" - // ticketTTL is how long a sign-in link stays redeemable. The test opens it - // in the step after it asks for it. - ticketTTL = 60 * time.Second + // linkTTL is how long a sign-in link stays redeemable. The test opens it in + // the step after it asks for it. + linkTTL = 60 * time.Second minTokenLength = 32 ) -// ErrNotConfigured reports that no reseeder is wired for this environment. -var ErrNotConfigured = errors.New("e2e reseed is not configured for this environment") - -// ErrSeedBusy reports that another seed run holds the seed lock. -var ErrSeedBusy = errors.New("another seed run is in progress") +// Tenant is the one organization end-to-end tests run in. +type Tenant struct { + OrganizationID string `json:"-"` + OrganizationSlug string `json:"organization_slug"` + ProjectSlug string `json:"project_slug"` + // SeededUserPrefix prefixes the ids of the seeded fictional members. + SeededUserPrefix string `json:"seeded_user_prefix"` +} -// Config is the surface's configuration. A zero Token disables it. +// Config fixes everything the surface acts on. type Config struct { // Environment is the deployment environment (GRAM_ENVIRONMENT). Environment string - // Token is the shared control secret (GRAM_E2E_CONTROL_TOKEN). + // Token is the control secret (GRAM_E2E_CONTROL_TOKEN). Token string - // UserEmail is the only identity e2e.signIn signs in (GRAM_E2E_USER_EMAIL). + // UserEmail is the only identity e2e.signIn signs in, spelled as the + // reseed adopts it: the identity provider derives the user from it. UserEmail string - // SiteURL is the dashboard origin the browser lands on after sign-in. - SiteURL string - // ServerURL is this server's own origin, the base of sign-in links. - ServerURL string - // Build is the commit this server was built from. A test run reads it from - // e2e.tenant to wait until a deployment serves the commit under test. + // SiteURL is the dashboard origin: sign-in links are bound to it, and the + // browser lands on it. + SiteURL *url.URL + // Build is the commit the server was built from. A test run reads it to + // wait until a host serves the commit under test. Build string + // Tenant is the organization Reseed resets and e2e.signIn signs in to. + Tenant Tenant + // Reseed replaces the tenant's data with the seed. It returns + // demoseed.ErrSeedLocked while another seed run holds the seed lock. + Reseed func(ctx context.Context) error } -// Enabled reports whether the surface should be mounted. -func (c Config) Enabled() bool { return c.Token != "" } - -// Tenant identifies the organization end-to-end tests run in. Tests read it -// from e2e.tenant instead of hard-coding slugs or seeded ids. -type Tenant struct { - OrganizationID string `json:"organization_id"` - OrganizationSlug string `json:"organization_slug"` - ProjectSlug string `json:"project_slug"` - // SeededUserPrefix prefixes the ids of the seeded fictional members. - SeededUserPrefix string `json:"seeded_user_prefix"` - // APIKeyName is the name of the seeded API key. - APIKeyName string `json:"api_key_name"` -} - -// Identity is the part of identity.Resolver the sign-in needs. It is the same -// pair the invitation callback uses: a server-created Magic Auth code, then -// the bootstrap every identity-provider login runs. +// Identity is the part of identity.Resolver the sign-in needs: the +// server-created Magic Auth code the invitation callback also uses, then the +// user bootstrap of the login callback. type Identity interface { AuthenticateWithMagicAuth(ctx context.Context, email string) (*identity.IDPUserInfo, error) CompleteIDPLogin(ctx context.Context, idpUser *identity.IDPUserInfo, opts identity.IDPLoginOptions) (identity.IDPLoginResult, error) @@ -103,253 +99,193 @@ type Identity interface { // SessionStore stores the dashboard session. Implemented by sessions.Manager. type SessionStore interface { + SignInEnforced(ctx context.Context, organizationID string) bool StoreSessionIssuedAt(ctx context.Context, session sessions.Session, issuedAt time.Time) error } -// TicketStore holds one-time sign-in tickets. Implemented by cache.Cache. -type TicketStore interface { - Set(ctx context.Context, key string, value any, ttl time.Duration) error - GetAndDelete(ctx context.Context, key string, value any) error -} - -// Reseeder brings the test organization to its known state and names it. -type Reseeder interface { - // Reseed replaces the organization's data. It returns ErrSeedBusy when - // another seed run holds the lock. - Reseed(ctx context.Context) error - // Tenant returns the organization's identifiers. It does not write. - Tenant() Tenant -} - // Service serves the control surface. type Service struct { - logger *slog.Logger - cfg Config - identity Identity - sessions SessionStore - tickets TicketStore - reseeder Reseeder - now func() time.Time + logger *slog.Logger + cfg Config + tokenDigest [sha256.Size]byte + identity Identity + sessions SessionStore + links cache.Cache + reseeding sync.Mutex } -// New builds the service. It returns an error, which the server treats as a -// refusal to start, when the configuration would enable the surface in -// production or leave it guessable. -func New(logger *slog.Logger, cfg Config, idp Identity, sessionStore SessionStore, tickets TicketStore, reseeder Reseeder) (*Service, error) { - if !cfg.Enabled() { - return nil, errors.New("e2e control: no control token configured") - } - if cfg.Environment == productionEnvironment || cfg.Environment == "" { - return nil, fmt.Errorf("e2e control: refusing to enable in environment %q", cfg.Environment) - } - if len(cfg.Token) < minTokenLength { - return nil, fmt.Errorf("e2e control: the control token must be at least %d characters", minTokenLength) - } - if !strings.Contains(cfg.UserEmail, "@") { - return nil, errors.New("e2e control: a test user email is required") - } - for name, raw := range map[string]string{"site URL": cfg.SiteURL, "server URL": cfg.ServerURL} { - u, err := url.Parse(raw) - if err != nil || u.Host == "" || (u.Scheme != "https" && u.Scheme != "http") { - return nil, fmt.Errorf("e2e control: %s %q is not an absolute http(s) URL", name, raw) - } +// New builds the service. Its error is a refusal to start the server: the +// surface is being enabled outside a local stack, or its token is guessable, +// or it has no fixed target to act on. +func New(logger *slog.Logger, cfg Config, idp Identity, sessionStore SessionStore, links cache.Cache) (*Service, error) { + switch { + case cfg.Environment != allowedEnvironment: + return nil, fmt.Errorf("e2e control: exists only in the %q environment, refusing to enable it in %q", allowedEnvironment, cfg.Environment) + case len(cfg.Token) < minTokenLength: + return nil, fmt.Errorf("e2e control: the control token must be at least %d bytes", minTokenLength) + case cfg.UserEmail == "": + return nil, errors.New("e2e control: no test user") + case cfg.SiteURL == nil || cfg.Tenant.OrganizationID == "" || cfg.Tenant.OrganizationSlug == "" || cfg.Reseed == nil: + return nil, errors.New("e2e control: no test organization, dashboard origin or reseed") } return &Service{ - logger: logger.With(attr.SlogComponent("e2econtrol")), - cfg: cfg, - identity: idp, - sessions: sessionStore, - tickets: tickets, - reseeder: reseeder, - now: time.Now, + logger: logger.With(attr.SlogComponent("e2econtrol")), + cfg: cfg, + tokenDigest: sha256.Sum256([]byte(cfg.Token)), + identity: idp, + sessions: sessionStore, + links: links, + reseeding: sync.Mutex{}, }, nil } // Attach mounts the routes. func Attach(mux goahttp.Muxer, s *Service) { - o11y.AttachHandler(mux, http.MethodPost, "/rpc/e2e.reseed", s.authorized(s.handleReseed)) - o11y.AttachHandler(mux, http.MethodGet, "/rpc/e2e.tenant", s.authorized(s.handleTenant)) - o11y.AttachHandler(mux, http.MethodPost, "/rpc/e2e.signInLink", s.authorized(s.handleSignInLink)) - o11y.AttachHandler(mux, http.MethodGet, "/rpc/e2e.signIn", s.handleSignIn) + o11y.AttachHandler(mux, http.MethodGet, "/rpc/e2e.tenant", oops.ErrHandle(s.logger, s.withToken(s.handleTenant)).ServeHTTP) + o11y.AttachHandler(mux, http.MethodPost, "/rpc/e2e.reseed", oops.ErrHandle(s.logger, s.withToken(s.handleReseed)).ServeHTTP) + o11y.AttachHandler(mux, http.MethodPost, "/rpc/e2e.signInLink", oops.ErrHandle(s.logger, s.withToken(s.handleSignInLink)).ServeHTTP) + o11y.AttachHandler(mux, http.MethodGet, "/rpc/e2e.signIn", oops.ErrHandle(s.logger, s.handleSignIn).ServeHTTP) } -func (s *Service) authorized(next http.HandlerFunc) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { +func (s *Service) withToken(next func(http.ResponseWriter, *http.Request) error) func(http.ResponseWriter, *http.Request) error { + return func(w http.ResponseWriter, r *http.Request) error { got := sha256.Sum256([]byte(r.Header.Get(TokenHeader))) - want := sha256.Sum256([]byte(s.cfg.Token)) - if subtle.ConstantTimeCompare(got[:], want[:]) != 1 { - writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "unauthorized"}) - return + if subtle.ConstantTimeCompare(got[:], s.tokenDigest[:]) != 1 { + return oops.C(oops.CodeUnauthorized) } - next(w, r) + return next(w, r) } } -type tenantResponse struct { - Tenant - Environment string `json:"environment"` - Build string `json:"build"` - UserEmail string `json:"user_email"` -} - -type reseedResponse struct { - tenantResponse - DurationMS int64 `json:"duration_ms"` -} - -func (s *Service) tenant() (tenantResponse, bool) { - if s.reseeder == nil { - return tenantResponse{Tenant: Tenant{OrganizationID: "", OrganizationSlug: "", ProjectSlug: "", SeededUserPrefix: "", APIKeyName: ""}, Environment: "", Build: "", UserEmail: ""}, false - } - return tenantResponse{Tenant: s.reseeder.Tenant(), Environment: s.cfg.Environment, Build: s.cfg.Build, UserEmail: s.cfg.UserEmail}, true -} - -func (s *Service) handleTenant(w http.ResponseWriter, _ *http.Request) { - tenant, ok := s.tenant() - if !ok { - writeJSON(w, http.StatusNotImplemented, map[string]string{"error": ErrNotConfigured.Error()}) - return - } - writeJSON(w, http.StatusOK, tenant) +func (s *Service) handleTenant(w http.ResponseWriter, _ *http.Request) error { + return writeJSON(w, struct { + Tenant + Build string `json:"build"` + }{Tenant: s.cfg.Tenant, Build: s.cfg.Build}) } -func (s *Service) handleReseed(w http.ResponseWriter, r *http.Request) { +func (s *Service) handleReseed(w http.ResponseWriter, r *http.Request) error { ctx := r.Context() - tenant, ok := s.tenant() - if !ok { - writeJSON(w, http.StatusNotImplemented, map[string]string{"error": ErrNotConfigured.Error()}) - return + // The seed lock covers the seed but not the fixtures that follow it, so + // this process also runs one reseed at a time. + if !s.reseeding.TryLock() { + return oops.E(oops.CodeConflict, nil, "another reseed is in progress") } - started := s.now() - if err := s.reseeder.Reseed(ctx); err != nil { - if errors.Is(err, ErrSeedBusy) { - writeJSON(w, http.StatusConflict, map[string]string{"error": ErrSeedBusy.Error()}) - return + defer s.reseeding.Unlock() + + if err := s.cfg.Reseed(ctx); err != nil { + if errors.Is(err, demoseed.ErrSeedLocked) { + return oops.E(oops.CodeConflict, err, "another seed run is in progress") } - s.logger.ErrorContext(ctx, "e2e reseed failed", attr.SlogError(err)) - writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "reseed failed"}) - return + // Not shareable: the caller learns only that it failed. + return fmt.Errorf("e2e reseed: %w", err) } - elapsed := s.now().Sub(started) - s.logger.InfoContext(ctx, "e2e tenant reseeded", attr.SlogOrganizationID(tenant.OrganizationID)) - writeJSON(w, http.StatusOK, reseedResponse{tenantResponse: tenant, DurationMS: elapsed.Milliseconds()}) -} - -type signInLinkResponse struct { - // URL is opened once by the test's browser. It is spent on first use and - // expires after ExpiresInSeconds, so it is safe to appear in test evidence. - URL string `json:"url"` - // Path is URL without its origin, for a browser already aimed at the - // dashboard: every environment serves /rpc on the dashboard origin. - Path string `json:"path"` - ExpiresInSeconds int `json:"expires_in_seconds"` + s.logger.InfoContext(ctx, "e2e test organization reseeded", attr.SlogOrganizationID(s.cfg.Tenant.OrganizationID)) + w.WriteHeader(http.StatusNoContent) + return nil } -func (s *Service) handleSignInLink(w http.ResponseWriter, r *http.Request) { +func (s *Service) handleSignInLink(w http.ResponseWriter, r *http.Request) error { ctx := r.Context() - raw := make([]byte, 32) - if _, err := rand.Read(raw); err != nil { - writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "could not create a ticket"}) - return + code, err := sessions.NewSessionID() + if err != nil { + return fmt.Errorf("e2e sign-in link: %w", err) } - ticket := base64.RawURLEncoding.EncodeToString(raw) - if err := s.tickets.Set(ctx, ticketKey(ticket), true, ticketTTL); err != nil { - s.logger.ErrorContext(ctx, "store e2e sign-in ticket", attr.SlogError(err)) - writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "could not store the ticket"}) - return + if err := s.links.Set(ctx, s.linkKey(code), true, linkTTL); err != nil { + return fmt.Errorf("e2e sign-in link: store: %w", err) } - path := "/rpc/e2e.signIn?ticket=" + url.QueryEscape(ticket) - writeJSON(w, http.StatusOK, signInLinkResponse{URL: strings.TrimRight(s.cfg.ServerURL, "/") + path, Path: path, ExpiresInSeconds: int(ticketTTL.Seconds())}) + s.logger.InfoContext(ctx, "e2e sign-in link minted") + // A path, not a URL: every environment serves /rpc on the dashboard origin, + // which the test's browser is already aimed at. "code" is a query + // parameter the request log redacts. + return writeJSON(w, map[string]string{"path": "/rpc/e2e.signIn?code=" + url.QueryEscape(code)}) } -func (s *Service) handleSignIn(w http.ResponseWriter, r *http.Request) { +func (s *Service) handleSignIn(w http.ResponseWriter, r *http.Request) error { ctx := r.Context() - ticket := r.URL.Query().Get("ticket") - var live bool - if ticket == "" || s.tickets.GetAndDelete(ctx, ticketKey(ticket), &live) != nil || !live { - http.Error(w, "sign-in link is spent, expired or unknown", http.StatusForbidden) - return + w.Header().Set("Cache-Control", "no-store") + w.Header().Set("Referrer-Policy", "no-referrer") + + var minted bool + err := s.links.GetAndDelete(ctx, s.linkKey(r.URL.Query().Get("code")), &minted) + switch { + case errors.Is(err, redisCache.ErrCacheMiss), err == nil && !minted: + return oops.E(oops.CodeForbidden, nil, "sign-in link is spent, expired or unknown") + case err != nil: + return fmt.Errorf("e2e sign-in: redeem link: %w", err) + } + // This sign-in is not recorded the way the login and invitation callbacks + // record theirs (signins.RecordExchange), so it gives no session where an + // organization requires recorded sign-ins. + if s.sessions.SignInEnforced(ctx, s.cfg.Tenant.OrganizationID) { + return oops.E(oops.CodeForbidden, nil, "the test organization enforces recorded sign-ins, which this sign-in is not") } // Taken before authenticating so a sign-out everywhere that lands // meanwhile still ends this session. - authenticatedAt := s.now() + authenticatedAt := time.Now() idpUser, err := s.identity.AuthenticateWithMagicAuth(ctx, s.cfg.UserEmail) - if err != nil || idpUser == nil { - s.logger.ErrorContext(ctx, "e2e sign-in: identity provider refused the test user", attr.SlogError(err)) - http.Error(w, "the identity provider refused the test user", http.StatusBadGateway) - return + if err != nil { + return oops.E(oops.CodeGatewayError, err, "the identity provider refused the test user").LogError(ctx, s.logger) } - login, err := s.identity.CompleteIDPLogin(ctx, idpUser, identity.IDPLoginOptions{SkipMembershipSync: false, Attribution: nil}) - if err != nil || login.UserInfo == nil { - s.logger.ErrorContext(ctx, "e2e sign-in: login bootstrap failed", attr.SlogError(err)) - http.Error(w, "could not complete the login", http.StatusInternalServerError) - return + if idpUser == nil || conv.NormalizeEmail(idpUser.Email) != conv.NormalizeEmail(s.cfg.UserEmail) { + return oops.E(oops.CodeForbidden, nil, "the identity provider returned a different user").LogError(ctx, s.logger) } - - // The session only ever enters the test organization. A test user who is - // not a member of it gets no session at all. - var active *sessions.Organization - if tenant, ok := s.tenant(); ok { - for i := range login.UserInfo.Organizations { - if login.UserInfo.Organizations[i].ID == tenant.OrganizationID { - active = &login.UserInfo.Organizations[i] - } - } - } else if len(login.UserInfo.Organizations) == 1 { - active = &login.UserInfo.Organizations[0] + // Memberships are not synced from the identity provider: the reseed is + // what makes the test user a member, and the check below reads that. + login, err := s.identity.CompleteIDPLogin(ctx, idpUser, identity.IDPLoginOptions{SkipMembershipSync: true, Attribution: nil}) + if err != nil { + return fmt.Errorf("e2e sign-in: complete login: %w", err) } - if active == nil { - http.Error(w, "the test user is not a member of the test organization", http.StatusConflict) - return + if login.UserInfo == nil || !slices.ContainsFunc(login.UserInfo.Organizations, func(o sessions.Organization) bool { return o.ID == s.cfg.Tenant.OrganizationID }) { + return oops.E(oops.CodeForbidden, nil, "the test user is not a member of the test organization; reseed it first") } sessionID, err := sessions.NewSessionID() if err != nil { - http.Error(w, "could not create a session", http.StatusInternalServerError) - return + return fmt.Errorf("e2e sign-in: %w", err) } - session := sessions.Session{ + if err := s.sessions.StoreSessionIssuedAt(ctx, sessions.Session{ SessionID: sessionID, UserID: login.UserID, - ActiveOrganizationID: active.ID, + ActiveOrganizationID: s.cfg.Tenant.OrganizationID, WorkOSSessionID: idpUser.WorkOSSessionID, ImpersonatorEmail: "", SupportOrganizationID: "", SupportExpiresAt: time.Time{}, - } - if err := s.sessions.StoreSessionIssuedAt(ctx, session, authenticatedAt); err != nil { - s.logger.ErrorContext(ctx, "e2e sign-in: store session", attr.SlogError(err)) - http.Error(w, "could not store the session", http.StatusInternalServerError) - return + }, authenticatedAt); err != nil { + return fmt.Errorf("e2e sign-in: store session: %w", err) } - //nolint:exhaustruct_v5 // only desired fields, as the login callback sets them + //nolint:exhaustruct_v5 // only desired fields, as the invitation callback sets them http.SetCookie(w, &http.Cookie{ Name: constants.SessionCookie, Value: sessionID, MaxAge: constants.SessionCookieMaxAgeSeconds, Path: "/", - Secure: s.cfg.Environment != "local", + Secure: true, HttpOnly: true, SameSite: http.SameSiteLaxMode, }) - s.logger.InfoContext(ctx, "e2e sign-in complete", attr.SlogUserID(login.UserID), attr.SlogOrganizationID(active.ID)) - http.Redirect(w, r, strings.TrimRight(s.cfg.SiteURL, "/")+"/"+url.PathEscape(active.Slug), http.StatusSeeOther) + s.logger.InfoContext(ctx, "e2e sign-in complete", attr.SlogUserID(login.UserID), attr.SlogOrganizationID(s.cfg.Tenant.OrganizationID)) + http.Redirect(w, r, s.cfg.SiteURL.JoinPath(s.cfg.Tenant.OrganizationSlug).String(), http.StatusSeeOther) + return nil } -// ticketKey stores a ticket under its hash, so the cache never holds a value -// that would sign anyone in. -func ticketKey(ticket string) string { - sum := sha256.Sum256([]byte(ticket)) +// linkKey is where a sign-in code's marker lives. The code is hashed, so the +// cache never holds a value that would sign anyone in, together with what it +// was minted for (dashboard origin, organization, user), so a server +// configured for anything else does not know it. +func (s *Service) linkKey(code string) string { + sum := sha256.Sum256([]byte(strings.Join([]string{s.cfg.SiteURL.String(), s.cfg.Tenant.OrganizationID, s.cfg.UserEmail, code}, "\n"))) return "e2econtrol:signin:" + hex.EncodeToString(sum[:]) } -func writeJSON(w http.ResponseWriter, status int, body any) { +func writeJSON(w http.ResponseWriter, body any) error { w.Header().Set("Content-Type", "application/json") w.Header().Set("Cache-Control", "no-store") - w.WriteHeader(status) if err := json.NewEncoder(w).Encode(body); err != nil { - return + return fmt.Errorf("encode response: %w", err) } + return nil } diff --git a/server/internal/e2econtrol/e2econtrol_test.go b/server/internal/e2econtrol/e2econtrol_test.go index 2f67e834007..02daea4ec13 100644 --- a/server/internal/e2econtrol/e2econtrol_test.go +++ b/server/internal/e2econtrol/e2econtrol_test.go @@ -4,20 +4,23 @@ import ( "context" "encoding/json" "errors" - "io" "net/http" "net/http/httptest" + "net/url" "strings" - "sync" "testing" "time" + "github.com/alicebob/miniredis/v2" + "github.com/redis/go-redis/v9" "github.com/stretchr/testify/require" goahttp "goa.design/goa/v3/http" "github.com/speakeasy-api/gram/server/internal/auth/identity" "github.com/speakeasy-api/gram/server/internal/auth/sessions" + "github.com/speakeasy-api/gram/server/internal/cache" "github.com/speakeasy-api/gram/server/internal/constants" + "github.com/speakeasy-api/gram/server/internal/demoseed" "github.com/speakeasy-api/gram/server/internal/e2econtrol" "github.com/speakeasy-api/gram/server/internal/testenv" ) @@ -26,146 +29,161 @@ const ( testToken = "zz-e2e-not-a-secret-zz-e2e-not-a-secret" testEmail = "e2e@example.test" testOrgID = "org-e2e" + testSite = "https://site.example.test" ) type fakeIdentity struct { - emails []string + asked []string + returnedEmail string organizations []sessions.Organization + options []identity.IDPLoginOptions } func (f *fakeIdentity) AuthenticateWithMagicAuth(_ context.Context, email string) (*identity.IDPUserInfo, error) { - f.emails = append(f.emails, email) + f.asked = append(f.asked, email) + if f.returnedEmail != "" { + email = f.returnedEmail + } return &identity.IDPUserInfo{Sub: "user_idp", Email: email, WorkOSSessionID: "session_idp"}, nil } -func (f *fakeIdentity) CompleteIDPLogin(_ context.Context, idpUser *identity.IDPUserInfo, _ identity.IDPLoginOptions) (identity.IDPLoginResult, error) { +func (f *fakeIdentity) CompleteIDPLogin(_ context.Context, idpUser *identity.IDPUserInfo, opts identity.IDPLoginOptions) (identity.IDPLoginResult, error) { + f.options = append(f.options, opts) return identity.IDPLoginResult{ UserID: "user-gram", UserInfo: &sessions.CachedUserInfo{UserID: "user-gram", Email: idpUser.Email, Organizations: f.organizations}, }, nil } -type fakeSessions struct{ stored []sessions.Session } - -func (f *fakeSessions) StoreSessionIssuedAt(_ context.Context, session sessions.Session, _ time.Time) error { - f.stored = append(f.stored, session) - return nil -} - -type fakeTickets struct { - mu sync.Mutex - keys map[string]bool +type fakeSessions struct { + stored []sessions.Session + enforced bool } -func (f *fakeTickets) Set(_ context.Context, key string, _ any, _ time.Duration) error { - f.mu.Lock() - defer f.mu.Unlock() - f.keys[key] = true - return nil -} +func (f *fakeSessions) SignInEnforced(context.Context, string) bool { return f.enforced } -func (f *fakeTickets) GetAndDelete(_ context.Context, key string, value any) error { - f.mu.Lock() - defer f.mu.Unlock() - if !f.keys[key] { - return errors.New("not found") - } - delete(f.keys, key) - if live, ok := value.(*bool); ok { - *live = true - } +func (f *fakeSessions) StoreSessionIssuedAt(_ context.Context, session sessions.Session, _ time.Time) error { + f.stored = append(f.stored, session) return nil } -type fakeReseeder struct { - err error - calls int -} - -func (f *fakeReseeder) Reseed(context.Context) error { - f.calls++ - return f.err -} - -func (f *fakeReseeder) Tenant() e2econtrol.Tenant { - return e2econtrol.Tenant{OrganizationID: testOrgID, OrganizationSlug: "e2e-org", ProjectSlug: "default", SeededUserPrefix: "user_e2e_", APIKeyName: "seed-key"} -} - type harness struct { - server *httptest.Server + mux goahttp.Muxer + redis *miniredis.Miniredis + links cache.Cache identity *fakeIdentity sessions *fakeSessions - reseeder *fakeReseeder -} - -// reply is what a test reads from one response, after its body is closed. -type reply struct { - status int - location string - cookies []*http.Cookie - body []byte + reseeds int + reseed func(context.Context) error } -func validConfig(serverURL string) e2econtrol.Config { - return e2econtrol.Config{Environment: "dev", Token: testToken, UserEmail: testEmail, SiteURL: "https://site.example.test", ServerURL: serverURL, Build: "0123abc"} +func validConfig(t *testing.T, h *harness, site string) e2econtrol.Config { + t.Helper() + siteURL, err := url.Parse(site) + require.NoError(t, err) + return e2econtrol.Config{ + Environment: "local", + Token: testToken, + UserEmail: testEmail, + SiteURL: siteURL, + Build: "0123abc", + Tenant: e2econtrol.Tenant{OrganizationID: testOrgID, OrganizationSlug: "e2e-org", ProjectSlug: "default", SeededUserPrefix: "user_e2e_"}, + Reseed: func(ctx context.Context) error { + h.reseeds++ + return h.reseed(ctx) + }, + } } +// newHarness serves the surface for the dashboard origin site, with sign-in +// links kept in a real Redis adapter so single use and expiry are the store's. func newHarness(t *testing.T) *harness { t.Helper() - mux := goahttp.NewMuxer() - server := httptest.NewServer(mux) - t.Cleanup(server.Close) + mr := miniredis.RunT(t) + client := redis.NewClient(&redis.Options{Addr: mr.Addr()}) + t.Cleanup(func() { require.NoError(t, client.Close()) }) h := &harness{ - server: server, - identity: &fakeIdentity{emails: nil, organizations: []sessions.Organization{ + mux: nil, + redis: mr, + links: cache.NewRedisCacheAdapter(client), + identity: &fakeIdentity{asked: nil, returnedEmail: "", options: nil, organizations: []sessions.Organization{ {ID: "org-other", Slug: "other"}, {ID: testOrgID, Slug: "e2e-org"}, }}, - sessions: &fakeSessions{stored: nil}, - reseeder: &fakeReseeder{err: nil, calls: 0}, + sessions: &fakeSessions{stored: nil, enforced: false}, + reseeds: 0, + reseed: func(context.Context) error { return nil }, } - service, err := e2econtrol.New(testenv.NewLogger(t), validConfig(server.URL), h.identity, h.sessions, &fakeTickets{mu: sync.Mutex{}, keys: map[string]bool{}}, h.reseeder) - require.NoError(t, err) - e2econtrol.Attach(mux, service) + h.mux = h.serve(t, nil) return h } -func (h *harness) do(t *testing.T, method, path, token string) reply { +// serve mounts one more server on the harness's cache, identity provider and +// session store, configured as the default one except for what mutate changes. +func (h *harness) serve(t *testing.T, mutate func(*e2econtrol.Config)) goahttp.Muxer { t.Helper() - req, err := http.NewRequestWithContext(t.Context(), method, h.server.URL+path, nil) + cfg := validConfig(t, h, testSite) + if mutate != nil { + mutate(&cfg) + } + service, err := e2econtrol.New(testenv.NewLogger(t), cfg, h.identity, h.sessions, h.links) require.NoError(t, err) + mux := goahttp.NewMuxer() + e2econtrol.Attach(mux, service) + return mux +} + +func do(t *testing.T, mux http.Handler, method, target, token string) *httptest.ResponseRecorder { + t.Helper() + req := httptest.NewRequestWithContext(t.Context(), method, target, nil) if token != "" { req.Header.Set(e2econtrol.TokenHeader, token) } - // Redirects are asserted, not followed. - client := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }} - res, err := client.Do(req) - require.NoError(t, err) - defer func() { require.NoError(t, res.Body.Close()) }() - body, err := io.ReadAll(res.Body) - require.NoError(t, err) - return reply{status: res.StatusCode, location: res.Header.Get("Location"), cookies: res.Cookies(), body: body} + rec := httptest.NewRecorder() + mux.ServeHTTP(rec, req) + return rec +} + +func signInLink(t *testing.T, mux goahttp.Muxer) string { + t.Helper() + res := do(t, mux, http.MethodPost, "/rpc/e2e.signInLink", testToken) + require.Equal(t, http.StatusOK, res.Code) + var link map[string]string + require.NoError(t, json.Unmarshal(res.Body.Bytes(), &link)) + require.Len(t, link, 1, "a link is a path and nothing else") + require.True(t, strings.HasPrefix(link["path"], "/rpc/e2e.signIn?code="), "path %q", link["path"]) + return link["path"] +} + +func TestNewRefusesEveryEnvironmentButLocal(t *testing.T) { + t.Parallel() + + for _, environment := range []string{"prod", "production", "Prod", "dev", "preview", "staging", "test", "Local", " local", ""} { + cfg := validConfig(t, nil, testSite) + cfg.Environment = environment + _, err := e2econtrol.New(testenv.NewLogger(t), cfg, nil, nil, nil) + require.ErrorContains(t, err, "exists only in", "environment %q", environment) + } } -func TestNewRefusesUnsafeConfiguration(t *testing.T) { +func TestNewRefusesIncompleteConfiguration(t *testing.T) { t.Parallel() cases := map[string]func(*e2econtrol.Config){ - "production": func(c *e2econtrol.Config) { c.Environment = "prod" }, - "unnamed environment": func(c *e2econtrol.Config) { c.Environment = "" }, - "no token": func(c *e2econtrol.Config) { c.Token = "" }, - "guessable token": func(c *e2econtrol.Config) { c.Token = "short" }, - "no test user": func(c *e2econtrol.Config) { c.UserEmail = "" }, - "relative site URL": func(c *e2econtrol.Config) { c.SiteURL = "/dashboard" }, - "server URL not a URL": func(c *e2econtrol.Config) { c.ServerURL = "localhost" }, + "no token": func(c *e2econtrol.Config) { c.Token = "" }, + "guessable token": func(c *e2econtrol.Config) { c.Token = "short" }, + "no test user": func(c *e2econtrol.Config) { c.UserEmail = "" }, + "no dashboard": func(c *e2econtrol.Config) { c.SiteURL = nil }, + "no organization id": func(c *e2econtrol.Config) { c.Tenant.OrganizationID = "" }, + "no reseed": func(c *e2econtrol.Config) { c.Reseed = nil }, } for name, mutate := range cases { t.Run(name, func(t *testing.T) { t.Parallel() - cfg := validConfig("https://server.example.test") + cfg := validConfig(t, nil, testSite) mutate(&cfg) - _, err := e2econtrol.New(testenv.NewLogger(t), cfg, nil, nil, nil, nil) + _, err := e2econtrol.New(testenv.NewLogger(t), cfg, nil, nil, nil) require.Error(t, err) }) } @@ -180,117 +198,202 @@ func TestControlCallsNeedTheToken(t *testing.T) { {http.MethodGet, "/rpc/e2e.tenant"}, {http.MethodPost, "/rpc/e2e.signInLink"}, } { - for _, token := range []string{"", "wrong-token-wrong-token-wrong-token-wrong"} { - got := h.do(t, call.method, call.path, token) - require.Equal(t, http.StatusUnauthorized, got.status, "%s %s with token %q", call.method, call.path, token) + for _, token := range []string{"", "wrong-token-wrong-token-wrong-token-wrong", testToken + "x", testToken[:len(testToken)-1]} { + res := do(t, h.mux, call.method, call.path, token) + require.Equal(t, http.StatusUnauthorized, res.Code, "%s %s with token %q", call.method, call.path, token) } } - require.Zero(t, h.reseeder.calls) + require.Zero(t, h.reseeds) + require.Empty(t, h.redis.Keys(), "no sign-in link is minted without the token") } -func TestTenantNamesTheTestOrganization(t *testing.T) { +func TestTenantNamesTheTestOrganizationAndTheBuild(t *testing.T) { t.Parallel() h := newHarness(t) - res := h.do(t, http.MethodGet, "/rpc/e2e.tenant", testToken) - require.Equal(t, http.StatusOK, res.status) - var got map[string]any - require.NoError(t, json.Unmarshal(res.body, &got)) - require.Equal(t, "e2e-org", got["organization_slug"]) - require.Equal(t, "default", got["project_slug"]) - require.Equal(t, "user_e2e_", got["seeded_user_prefix"]) - require.Equal(t, "dev", got["environment"]) - require.Equal(t, "0123abc", got["build"]) - require.Zero(t, h.reseeder.calls, "reading the tenant must not reseed") + res := do(t, h.mux, http.MethodGet, "/rpc/e2e.tenant", testToken) + require.Equal(t, http.StatusOK, res.Code) + require.JSONEq(t, `{"organization_slug":"e2e-org","project_slug":"default","seeded_user_prefix":"user_e2e_","build":"0123abc"}`, res.Body.String()) + require.Zero(t, h.reseeds, "reading the tenant must not reseed") } func TestReseed(t *testing.T) { t.Parallel() - t.Run("replaces the tenant's data and names it", func(t *testing.T) { + t.Run("runs the one configured reseed, whatever the caller sends", func(t *testing.T) { t.Parallel() h := newHarness(t) - res := h.do(t, http.MethodPost, "/rpc/e2e.reseed", testToken) - require.Equal(t, http.StatusOK, res.status) - require.Equal(t, 1, h.reseeder.calls) - var got map[string]any - require.NoError(t, json.Unmarshal(res.body, &got)) - require.Equal(t, "e2e-org", got["organization_slug"]) + res := do(t, h.mux, http.MethodPost, "/rpc/e2e.reseed?organization_id=org-other&slug=other", testToken) + require.Equal(t, http.StatusNoContent, res.Code) + require.Equal(t, 1, h.reseeds) }) - t.Run("reports a seed already in progress as a conflict", func(t *testing.T) { + t.Run("answers 409 while a seed run holds the seed lock", func(t *testing.T) { t.Parallel() h := newHarness(t) - h.reseeder.err = e2econtrol.ErrSeedBusy - res := h.do(t, http.MethodPost, "/rpc/e2e.reseed", testToken) - require.Equal(t, http.StatusConflict, res.status) + h.reseed = func(context.Context) error { return demoseed.ErrSeedLocked } + require.Equal(t, http.StatusConflict, do(t, h.mux, http.MethodPost, "/rpc/e2e.reseed", testToken).Code) }) - t.Run("hides the cause of a failed seed", func(t *testing.T) { + t.Run("answers 409 while another reseed is running in this process", func(t *testing.T) { t.Parallel() h := newHarness(t) - h.reseeder.err = errors.New("postgres: connection string with a password") - res := h.do(t, http.MethodPost, "/rpc/e2e.reseed", testToken) - require.Equal(t, http.StatusInternalServerError, res.status) - require.NotContains(t, string(res.body), "password") + running, release := make(chan struct{}), make(chan struct{}) + h.reseed = func(context.Context) error { + close(running) + <-release + return nil + } + first := make(chan int) + go func() { first <- do(t, h.mux, http.MethodPost, "/rpc/e2e.reseed", testToken).Code }() + <-running + require.Equal(t, http.StatusConflict, do(t, h.mux, http.MethodPost, "/rpc/e2e.reseed", testToken).Code) + close(release) + require.Equal(t, http.StatusNoContent, <-first) }) -} -func signInLink(t *testing.T, h *harness) string { - t.Helper() - res := h.do(t, http.MethodPost, "/rpc/e2e.signInLink", testToken) - require.Equal(t, http.StatusOK, res.status) - var link struct { - URL string `json:"url"` - Path string `json:"path"` - } - require.NoError(t, json.Unmarshal(res.body, &link)) - require.True(t, strings.HasPrefix(link.Path, "/rpc/e2e.signIn?ticket="), "path %q", link.Path) - require.Equal(t, h.server.URL+link.Path, link.URL) - return link.Path + t.Run("hides the cause of a failed seed", func(t *testing.T) { + t.Parallel() + h := newHarness(t) + h.reseed = func(context.Context) error { return errors.New("postgres: connection string with a password") } + res := do(t, h.mux, http.MethodPost, "/rpc/e2e.reseed", testToken) + require.Equal(t, http.StatusInternalServerError, res.Code) + require.NotContains(t, res.Body.String(), "password") + }) } func TestSignInLinkSignsTheTestUserIntoTheTestOrganizationOnce(t *testing.T) { t.Parallel() h := newHarness(t) - path := signInLink(t, h) + path := signInLink(t, h.mux) - res := h.do(t, http.MethodGet, path, "") - require.Equal(t, http.StatusSeeOther, res.status) - require.Equal(t, "https://site.example.test/e2e-org", res.location) - require.Equal(t, []string{testEmail}, h.identity.emails, "only the configured identity is ever signed in") + res := do(t, h.mux, http.MethodGet, path, "") + require.Equal(t, http.StatusSeeOther, res.Code) + require.Equal(t, testSite+"/e2e-org", res.Header().Get("Location")) + require.Equal(t, "no-store", res.Header().Get("Cache-Control")) + require.Equal(t, "no-referrer", res.Header().Get("Referrer-Policy")) + require.Equal(t, []string{testEmail}, h.identity.asked, "only the configured identity is ever signed in") + require.Equal(t, []identity.IDPLoginOptions{{SkipMembershipSync: true, Attribution: nil}}, h.identity.options) require.Len(t, h.sessions.stored, 1) session := h.sessions.stored[0] require.Equal(t, "user-gram", session.UserID) require.Equal(t, testOrgID, session.ActiveOrganizationID) require.Equal(t, "session_idp", session.WorkOSSessionID) + require.Empty(t, session.ImpersonatorEmail) + require.Empty(t, session.SupportOrganizationID) + + cookies := res.Result().Cookies() + require.Len(t, cookies, 1) + require.Equal(t, constants.SessionCookie, cookies[0].Name) + require.Equal(t, session.SessionID, cookies[0].Value) + require.True(t, cookies[0].HttpOnly) + require.True(t, cookies[0].Secure) + require.Equal(t, http.SameSiteLaxMode, cookies[0].SameSite) + + again := do(t, h.mux, http.MethodGet, path, "") + require.Equal(t, http.StatusForbidden, again.Code, "a link is spent on first use") + require.Len(t, h.sessions.stored, 1) +} - var cookie *http.Cookie - for _, c := range res.cookies { - if c.Name == constants.SessionCookie { - cookie = c - } - } - require.NotNil(t, cookie) - require.Equal(t, session.SessionID, cookie.Value) - require.True(t, cookie.HttpOnly) - require.True(t, cookie.Secure) +func TestSignInLinkExpiresAfterAMinute(t *testing.T) { + t.Parallel() + h := newHarness(t) + + path := signInLink(t, h.mux) + h.redis.FastForward(59 * time.Second) + require.Equal(t, http.StatusSeeOther, do(t, h.mux, http.MethodGet, path, "").Code) - again := h.do(t, http.MethodGet, path, "") - require.Equal(t, http.StatusForbidden, again.status, "a link is spent on first use") + path = signInLink(t, h.mux) + h.redis.FastForward(61 * time.Second) + require.Equal(t, http.StatusForbidden, do(t, h.mux, http.MethodGet, path, "").Code) require.Len(t, h.sessions.stored, 1) } -func TestSignInRefusesUnknownTickets(t *testing.T) { +func TestSignInLinkStoresNoRedeemableValue(t *testing.T) { t.Parallel() h := newHarness(t) - for _, path := range []string{"/rpc/e2e.signIn", "/rpc/e2e.signIn?ticket=", "/rpc/e2e.signIn?ticket=made-up"} { - res := h.do(t, http.MethodGet, path, testToken) - require.Equal(t, http.StatusForbidden, res.status, path) + code := strings.TrimPrefix(signInLink(t, h.mux), "/rpc/e2e.signIn?code=") + keys := h.redis.Keys() + require.Len(t, keys, 1) + require.NotContains(t, keys[0], code) + stored, err := h.redis.Get(keys[0]) + require.NoError(t, err) + require.NotContains(t, stored, code) +} + +// A second server sharing the first one's cache does not know a code minted +// for a different dashboard origin, organization or user. +func TestSignInLinkIsBoundToWhatItWasMintedFor(t *testing.T) { + t.Parallel() + + otherSite, err := url.Parse("https://other.example.test") + require.NoError(t, err) + cases := map[string]func(*e2econtrol.Config){ + "another dashboard origin": func(c *e2econtrol.Config) { c.SiteURL = otherSite }, + "another organization": func(c *e2econtrol.Config) { c.Tenant.OrganizationID = "org-other" }, + "another user": func(c *e2econtrol.Config) { c.UserEmail = "someone-else@example.test" }, + } + for name, mutate := range cases { + t.Run(name, func(t *testing.T) { + t.Parallel() + h := newHarness(t) + other := h.serve(t, mutate) + + path := signInLink(t, h.mux) + require.Equal(t, http.StatusForbidden, do(t, other, http.MethodGet, path, "").Code) + require.Empty(t, h.identity.asked) + require.Equal(t, http.StatusSeeOther, do(t, h.mux, http.MethodGet, path, "").Code, "the refusal elsewhere did not spend it") + }) } - require.Empty(t, h.identity.emails) +} + +func TestSignInRefusesUnknownCodes(t *testing.T) { + t.Parallel() + h := newHarness(t) + + for _, path := range []string{"/rpc/e2e.signIn", "/rpc/e2e.signIn?code=", "/rpc/e2e.signIn?code=made-up"} { + // The control token is no substitute for a code. + require.Equal(t, http.StatusForbidden, do(t, h.mux, http.MethodGet, path, testToken).Code, path) + } + require.Empty(t, h.identity.asked) + require.Empty(t, h.sessions.stored) +} + +func TestSignInGivesNoSessionToAnotherIdentity(t *testing.T) { + t.Parallel() + h := newHarness(t) + h.identity.returnedEmail = "someone-else@example.test" + + res := do(t, h.mux, http.MethodGet, signInLink(t, h.mux), "") + require.Equal(t, http.StatusForbidden, res.Code) + require.Empty(t, h.identity.options, "the login bootstrap never ran for the other identity") + require.Empty(t, h.sessions.stored) + require.Empty(t, res.Result().Cookies()) +} + +// The identity provider derives the user from the address as spelled, so the +// spelling the reseed adopted is the one asked for; only the comparison of +// what comes back ignores case. +func TestSignInAsksForTheTestUserAsSpelled(t *testing.T) { + t.Parallel() + h := newHarness(t) + mixed := h.serve(t, func(c *e2econtrol.Config) { c.UserEmail = "Dev.Eloper@Example.test" }) + h.identity.returnedEmail = "dev.eloper@example.test" + + require.Equal(t, http.StatusSeeOther, do(t, mixed, http.MethodGet, signInLink(t, mixed), "").Code) + require.Equal(t, []string{"Dev.Eloper@Example.test"}, h.identity.asked) +} + +func TestSignInGivesNoSessionWhereSignInsMustBeRecorded(t *testing.T) { + t.Parallel() + h := newHarness(t) + h.sessions.enforced = true + + res := do(t, h.mux, http.MethodGet, signInLink(t, h.mux), "") + require.Equal(t, http.StatusForbidden, res.Code) + require.Empty(t, h.identity.asked) require.Empty(t, h.sessions.stored) } @@ -299,8 +402,8 @@ func TestSignInGivesNoSessionOutsideTheTestOrganization(t *testing.T) { h := newHarness(t) h.identity.organizations = []sessions.Organization{{ID: "org-other", Slug: "other"}} - res := h.do(t, http.MethodGet, signInLink(t, h), "") - require.Equal(t, http.StatusConflict, res.status) + res := do(t, h.mux, http.MethodGet, signInLink(t, h.mux), "") + require.Equal(t, http.StatusForbidden, res.Code) require.Empty(t, h.sessions.stored) - require.Empty(t, res.cookies) + require.Empty(t, res.Result().Cookies()) } diff --git a/server/internal/e2econtrol/openapi.yaml b/server/internal/e2econtrol/openapi.yaml index cf96015e299..b4007641b22 100644 --- a/server/internal/e2econtrol/openapi.yaml +++ b/server/internal/e2econtrol/openapi.yaml @@ -1,64 +1,68 @@ openapi: 3.1.0 info: title: Speakeasy end-to-end test contract - version: "1" + version: "2" description: >- - The operations an end-to-end test run calls outside the browser: the - non-production control surface (server/internal/e2econtrol) and the few - public API reads the suite's root uses to check the seeded state. A test - tool pins this file by its SHA-256, so changing it re-plans the flows that - name it. It is hand-written and deliberately small; the full public API is - server/gen/http/openapi3.yaml. + The operations an end-to-end test run calls outside the browser: the control + surface (server/internal/e2econtrol, local stacks only) and the two public + API reads the suite's root uses to check the seeded state. A test tool pins + this file by its SHA-256, so changing it re-plans the flows that name it. It + is hand-written because the control surface is deliberately absent from the + public API (server/gen/http/openapi3.yaml); the two public reads are the + subset of that file the root needs, kept here so the tool has one contract. security: - control: [] paths: - /rpc/e2e.reseed: - post: - operationId: e2eReseed - description: Replace the test organization's data with the seed. 409 while another seed run holds the lock. + /rpc/e2e.tenant: + get: + operationId: e2eTenant + description: Name the test organization and the build being served. Reads only. responses: "200": - description: The test organization was reseeded + description: The test organization content: application/json: schema: - $ref: "#/components/schemas/Reseeded" + type: object + required: + [organization_slug, project_slug, seeded_user_prefix, build] + properties: + organization_slug: + type: string + project_slug: + type: string + seeded_user_prefix: + type: string + build: + type: string + /rpc/e2e.reseed: + post: + operationId: e2eReseed + description: Replace the test organization's data with the seed. Takes no input. + responses: + "204": + description: The test organization was reseeded "409": description: Another seed run is in progress content: application/json: schema: $ref: "#/components/schemas/Problem" - /rpc/e2e.tenant: - get: - operationId: e2eTenant - description: Identify the test organization. Reads only. - responses: - "200": - description: The test organization - content: - application/json: - schema: - $ref: "#/components/schemas/Tenant" /rpc/e2e.signInLink: post: operationId: e2eSignInLink - description: Mint a link that signs a browser in as the test user, once, within a minute. + description: Mint a path that signs a browser in as the test user, once, within a minute. responses: "200": - description: A one-time sign-in link + description: A one-time sign-in path on the dashboard origin content: application/json: schema: type: object - required: [url, path, expires_in_seconds] + required: [path] properties: - url: - type: string path: type: string - expires_in_seconds: - type: integer /rpc/toolsets.get: get: operationId: getToolset @@ -87,18 +91,11 @@ paths: type: array items: type: object - "404": - description: No such toolset - content: - application/json: - schema: - $ref: "#/components/schemas/Problem" /rpc/access.listRoles: get: operationId: listRoles security: - apiKey: [] - project: [] responses: "200": description: The organization's roles @@ -133,61 +130,9 @@ components: in: header name: Gram-Project schemas: - Tenant: - type: object - required: - [ - organization_id, - organization_slug, - project_slug, - seeded_user_prefix, - environment, - build, - ] - properties: - organization_id: - type: string - organization_slug: - type: string - project_slug: - type: string - seeded_user_prefix: - type: string - api_key_name: - type: string - environment: - type: string - build: - type: string - user_email: - type: string - Reseeded: - type: object - required: [organization_slug, project_slug, duration_ms] - properties: - organization_id: - type: string - organization_slug: - type: string - project_slug: - type: string - seeded_user_prefix: - type: string - api_key_name: - type: string - environment: - type: string - build: - type: string - user_email: - type: string - duration_ms: - type: integer Problem: type: object properties: - error: - type: string name: type: string message: From 1961567b376fea82f08bfd5d9970d43e12f1b0da Mon Sep 17 00:00:00 2001 From: Thomas Rooney Date: Sat, 21 Nov 2026 13:25:42 +0000 Subject: [PATCH 3/4] chore: let the end-to-end test control surface run on a pull request preview --- server/cmd/gram/deps_e2e.go | 221 +++++++++++++++--- server/cmd/gram/deps_e2e_preview_test.go | 144 ++++++++++++ server/cmd/gram/deps_e2e_test.go | 201 +++++++++++----- server/cmd/gram/start.go | 32 ++- server/internal/auth/sessions/issue.go | 43 ++++ server/internal/auth/sessions/issue_test.go | 110 +++++++++ server/internal/auth/sessions/sessions.go | 7 + server/internal/demoseed/demoseed.go | 8 +- server/internal/demoseed/preview.go | 131 +++++++++++ server/internal/demoseed/preview_test.go | 121 ++++++++++ server/internal/demoseed/queries/preview.sql | 18 ++ server/internal/demoseed/repo/preview.sql.go | 55 +++++ server/internal/demoseed/spec.go | 30 +++ server/internal/demoseed/spec_test.go | 52 +++++ server/internal/e2econtrol/e2econtrol.go | 115 +++++---- server/internal/e2econtrol/e2econtrol_test.go | 188 +++++++-------- server/internal/e2econtrol/openapi.yaml | 75 +----- server/internal/organizations/impl.go | 13 +- 18 files changed, 1216 insertions(+), 348 deletions(-) create mode 100644 server/cmd/gram/deps_e2e_preview_test.go create mode 100644 server/internal/auth/sessions/issue.go create mode 100644 server/internal/auth/sessions/issue_test.go create mode 100644 server/internal/demoseed/preview.go create mode 100644 server/internal/demoseed/preview_test.go create mode 100644 server/internal/demoseed/queries/preview.sql create mode 100644 server/internal/demoseed/repo/preview.sql.go diff --git a/server/cmd/gram/deps_e2e.go b/server/cmd/gram/deps_e2e.go index 7ab8d25ea3b..8ae780fd9b3 100644 --- a/server/cmd/gram/deps_e2e.go +++ b/server/cmd/gram/deps_e2e.go @@ -7,36 +7,47 @@ import ( "log/slog" "net/url" "os/exec" + "regexp" + "strconv" "strings" + "time" "github.com/ClickHouse/clickhouse-go/v2/lib/driver" + "github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5/pgxpool" "github.com/redis/go-redis/v9" goahttp "goa.design/goa/v3/http" "github.com/speakeasy-api/gram/server/internal/assets" + "github.com/speakeasy-api/gram/server/internal/attr" + "github.com/speakeasy-api/gram/server/internal/auth/sessions" "github.com/speakeasy-api/gram/server/internal/cache" + "github.com/speakeasy-api/gram/server/internal/conv" "github.com/speakeasy-api/gram/server/internal/demoseed" "github.com/speakeasy-api/gram/server/internal/e2econtrol" "github.com/speakeasy-api/gram/server/internal/encryption" + orgrepo "github.com/speakeasy-api/gram/server/internal/organizations/repo" + userrepo "github.com/speakeasy-api/gram/server/internal/users/repo" ) // e2eControlTokenFlag belongs to the API server only (serverFlags): no other // command mounts the surface, so no other command accepts its token. const e2eControlTokenFlag = "e2e-control-token" //nolint:gosec // G101: a flag name, not a credential +// previewDatabase is the name of a pull request preview's own database, the +// throwaway clone its deployment creates for it. Nothing else has that name: +// an environment's own database does not carry a pull request number. +var previewDatabase = regexp.MustCompile(`^gram_preview_pr_([1-9][0-9]*)$`) + // e2eControlDeps is what the end-to-end test control surface is built from. type e2eControlDeps struct { environment string - // identityBackend is GRAM_DEVIDP_BACKEND: "local" is the dev-idp's own - // emulator, anything else forwards sign-ins to a real identity provider. - identityBackend string - // identityEndpoint is where Magic Auth is sent (WORKOS_API_URL; empty is - // the real provider) and devIDPURL is this stack's dev-idp origin. - identityEndpoint string - devIDPURL string - token string - // developerEmail names the local developer, who is the test user. + token string + // databaseName asks the database the reseed will write to for its own + // name (current_database()). + databaseName func(ctx context.Context) (string, error) + // developerEmail names the local developer, who is the test user on a + // local stack. developerEmail func(ctx context.Context) string siteURL *url.URL serverURL *url.URL @@ -46,51 +57,132 @@ type e2eControlDeps struct { blob assets.BlobStore encryption *encryption.Client redis *redis.Client - identity e2econtrol.Identity - sessions e2econtrol.SessionStore + users e2econtrol.Users + sessions e2eSessions +} + +// e2eSessions is what the surface needs from sessions.Manager. +type e2eSessions interface { + e2econtrol.SessionStore + ConfineUser(userID, organizationID string) + RaiseUserEpoch(ctx context.Context, userID string, at time.Time) error } // attachE2EControl mounts the end-to-end test control surface (/rpc/e2e.*) // when a control token is configured, and mounts nothing otherwise. A token -// configured anywhere but a local stack (e2econtrol.New), or on a local stack -// that signs in through a real identity provider, is an error, which stops -// the server from starting. +// configured anywhere the surface may not exist is an error, which stops the +// server from starting. It may exist in two places: // -// The test organization is the local development organization and the test -// user is the developer the local seed adopts into it (`git config -// user.email`), so e2e.reseed is the Go that `mise run seed` runs for that -// organization. +// - a local stack (environment "local"). The test organization is the local +// development organization and the test user is the developer the local +// seed adopts into it (`git config user.email`), so e2e.reseed is the Go +// that `mise run seed` runs for that organization. +// - a pull request preview: environment "dev", connected to that preview's +// own database (gram_preview_pr_) and served at pr-. The test +// organization and its one test user are synthetic, exist only in that +// database, and are named after N (demoseed.PreviewSpec). +// +// The environment's own deployment is connected to the environment's database, +// so it is refused whatever else it is given, as is every other environment. func attachE2EControl(ctx context.Context, logger *slog.Logger, mux goahttp.Muxer, d e2eControlDeps) error { if d.token == "" { return nil } - spec := demoseed.LocalSpec() - email := d.developerEmail(ctx) - service, err := e2econtrol.New(logger, e2econtrol.Config{ - Environment: d.environment, - Token: d.token, - UserEmail: email, - SiteURL: d.siteURL, - Build: GitSHA, - Tenant: e2econtrol.Tenant{ - OrganizationID: spec.OrgID, - OrganizationSlug: spec.OrgSlug, - ProjectSlug: "default", - SeededUserPrefix: spec.UserPrefix, - }, - Reseed: func(ctx context.Context) error { return reseedLocalOrganization(ctx, logger, d, spec, email) }, - }, d.identity, d.sessions, cache.NewRedisCacheAdapter(d.redis)) + cfg, err := e2eControlTarget(ctx, logger, d) + if err != nil { + return fmt.Errorf("end-to-end test control surface: %w", err) + } + cfg.Token = d.token + cfg.SiteURL = d.siteURL + cfg.Build = GitSHA + service, err := e2econtrol.New(logger, cfg, d.users, d.sessions, cache.NewRedisCacheAdapter(d.redis)) if err != nil { return fmt.Errorf("end-to-end test control surface: %w", err) } - if d.identityBackend != "local" || d.devIDPURL == "" || d.identityEndpoint != d.devIDPURL+"/workos" { - return errors.New("end-to-end test control surface: it signs in through this stack's dev-idp emulator only (GRAM_DEVIDP_BACKEND=local, WORKOS_API_URL at the dev-idp)") + if cfg.Confined { + d.sessions.ConfineUser(cfg.UserID, cfg.Tenant.OrganizationID) } e2econtrol.Attach(mux, service) - logger.WarnContext(ctx, "end-to-end test control surface is enabled (/rpc/e2e.*)") + logger.WarnContext(ctx, "end-to-end test control surface is enabled (/rpc/e2e.*)", attr.SlogOrganizationID(cfg.Tenant.OrganizationID)) return nil } +// e2eControlTarget decides where this server is and returns the organization, +// user and reseed the surface is fixed to there, or the refusal. +func e2eControlTarget(ctx context.Context, logger *slog.Logger, d e2eControlDeps) (e2econtrol.Config, error) { + var none e2econtrol.Config + switch d.environment { + case "local": + spec := demoseed.LocalSpec() + email := d.developerEmail(ctx) + return e2econtrol.Config{ + Token: "", + UserEmail: email, + UserID: "", + Confined: false, + SiteURL: nil, + Build: "", + Tenant: e2eTenant(spec), + Reseed: func(ctx context.Context) error { return reseedLocalOrganization(ctx, logger, d, spec, email) }, + }, nil + case "dev": + database, err := d.databaseName(ctx) + if err != nil { + return none, fmt.Errorf("read the database's name: %w", err) + } + pullRequest, err := previewPullRequest(database, d.siteURL, d.serverURL) + if err != nil { + return none, err + } + spec, err := demoseed.PreviewSpec(pullRequest) + if err != nil { + return none, fmt.Errorf("preview test organization: %w", err) + } + runner := spec.PreviewRunner() + return e2econtrol.Config{ + Token: "", + UserEmail: runner.Email, + UserID: runner.ID, + Confined: true, + SiteURL: nil, + Build: "", + Tenant: e2eTenant(spec), + Reseed: func(ctx context.Context) error { return reseedPreviewOrganization(ctx, logger, d, spec) }, + }, nil + default: + return none, fmt.Errorf("it exists only on a local stack or a pull request preview, refusing to enable it in the %q environment", d.environment) + } +} + +// previewPullRequest is the pull request whose preview this server is: the +// number in its database's name, which the dashboard and server hosts must +// both carry too. Any disagreement is a refusal. +func previewPullRequest(database string, siteURL, serverURL *url.URL) (int, error) { + match := previewDatabase.FindStringSubmatch(database) + if match == nil { + return 0, errors.New("in the \"dev\" environment it exists only on a pull request preview, and this server's database is not a preview's") + } + pullRequest, err := strconv.Atoi(match[1]) + if err != nil { + return 0, fmt.Errorf("preview database number: %w", err) + } + for _, u := range []*url.URL{siteURL, serverURL} { + if u == nil || u.Hostname() != siteURL.Hostname() || !strings.HasPrefix(u.Hostname(), "pr-"+match[1]+".") { + return 0, fmt.Errorf("this server's database is pull request %d's preview, but its dashboard and server are not both served at one pr-%d host", pullRequest, pullRequest) + } + } + return pullRequest, nil +} + +func e2eTenant(spec demoseed.Spec) e2econtrol.Tenant { + return e2econtrol.Tenant{ + OrganizationID: spec.OrgID, + OrganizationSlug: spec.OrgSlug, + ProjectSlug: "default", + SeededUserPrefix: spec.UserPrefix, + } +} + // reseedLocalOrganization replaces the local organization's data with the // shared seed, then applies the local fixtures that restore the developer's // membership and the seeded API key. @@ -118,6 +210,61 @@ func reseedLocalOrganization(ctx context.Context, logger *slog.Logger, d e2eCont return nil } +// reseedPreviewOrganization replaces the preview's test organization with the +// shared seed in the preview's own Postgres database, then restores the test +// user's membership. It writes no telemetry: a preview shares its +// environment's ClickHouse, so the organization's telemetry pages stay empty. +// Every session the test user was issued before the reset ends with it. +func reseedPreviewOrganization(ctx context.Context, logger *slog.Logger, d e2eControlDeps, spec demoseed.Spec) error { + started := time.Now() + if err := demoseed.Run(ctx, logger, d.db, nil, d.blob, d.encryption, d.issuerURL, d.serverURL.String(), spec); err != nil { + return fmt.Errorf("apply seed: %w", err) + } + if err := demoseed.RunPreviewFixtures(ctx, logger, d.db, d.redis, spec); err != nil { + return fmt.Errorf("apply preview fixtures: %w", err) + } + if err := d.sessions.RaiseUserEpoch(ctx, spec.PreviewRunner().ID, started); err != nil { + return fmt.Errorf("end the test user's earlier sessions: %w", err) + } + return nil +} + +// currentDatabase asks db which database it is connected to. +func currentDatabase(ctx context.Context, db *pgxpool.Pool) (string, error) { + name, err := demoseed.CurrentDatabase(ctx, db) + if err != nil { + return "", fmt.Errorf("current database: %w", err) + } + return name, nil +} + +// e2eUsers reads the test user for the control surface, from the database. +type e2eUsers struct { + db *pgxpool.Pool +} + +func (u e2eUsers) UserByEmail(ctx context.Context, email string) (*sessions.CachedUserInfo, error) { + user, err := userrepo.New(u.db).GetUserByEmail(ctx, email) + switch { + case errors.Is(err, pgx.ErrNoRows), err == nil && user.DeletedAt.Valid: + return nil, nil //nolint:nilnil // a user that does not exist is not an error + case err != nil: + return nil, fmt.Errorf("get user by email: %w", err) + } + // Live memberships of enabled organizations, the list a session can reach. + rows, err := orgrepo.New(u.db).ListOrganizationsForUser(ctx, conv.ToPGText(user.ID)) + if err != nil { + return nil, fmt.Errorf("list organizations for user: %w", err) + } + organizations := make([]sessions.Organization, 0, len(rows)) + for _, row := range rows { + //nolint:exhaustruct_v5 // the surface reads only which organizations these are + organizations = append(organizations, sessions.Organization{ID: row.ID, Name: row.Name, Slug: row.Slug}) + } + //nolint:exhaustruct_v5 // the surface reads only identity, staff bit and organizations + return &sessions.CachedUserInfo{UserID: user.ID, Email: user.Email, Admin: user.Admin, Organizations: organizations}, nil +} + // gitUserEmail is the address the dev-idp and the local seed both identify the // developer by. Empty when git has none, which e2econtrol.New refuses. func gitUserEmail(ctx context.Context) string { diff --git a/server/cmd/gram/deps_e2e_preview_test.go b/server/cmd/gram/deps_e2e_preview_test.go new file mode 100644 index 00000000000..e3ee48329d3 --- /dev/null +++ b/server/cmd/gram/deps_e2e_preview_test.go @@ -0,0 +1,144 @@ +package gram + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "net/url" + "testing" + + "github.com/stretchr/testify/require" + goahttp "goa.design/goa/v3/http" + + mockidp "github.com/speakeasy-api/gram/dev-idp/pkg/testidp" + "github.com/speakeasy-api/gram/server/internal/assets/assetstest" + "github.com/speakeasy-api/gram/server/internal/authz" + "github.com/speakeasy-api/gram/server/internal/cache" + "github.com/speakeasy-api/gram/server/internal/constants" + "github.com/speakeasy-api/gram/server/internal/contextvalues" + "github.com/speakeasy-api/gram/server/internal/conv" + "github.com/speakeasy-api/gram/server/internal/e2econtrol" + "github.com/speakeasy-api/gram/server/internal/oops" + orgrepo "github.com/speakeasy-api/gram/server/internal/organizations/repo" + "github.com/speakeasy-api/gram/server/internal/testenv" +) + +// The preview path end to end against a real database, cache and session +// manager: the reset creates the pull request's own organization and runner +// beside another tenant, the link signs that runner in, the session cannot +// leave the organization, and the next reset ends it. +func TestE2EControlOnAPreviewResetsAndSignsInToItsOwnTenantOnly(t *testing.T) { + t.Parallel() + ctx := t.Context() + logger := testenv.NewLogger(t) + + infra, cleanup, err := testenv.Launch(ctx, testenv.LaunchOptions{Postgres: true, Redis: true, ClickHouse: false, Temporal: false, Presidio: false}) + require.NoError(t, err) + t.Cleanup(func() { require.NoError(t, cleanup()) }) + db, err := infra.CloneTestDatabase(t, "e2e_control_preview") + require.NoError(t, err) + redisClient, err := infra.NewRedisClient(t, 0) + require.NoError(t, err) + manager := testenv.NewTestManager(t, logger, testenv.NewTracerProvider(t), db, redisClient, cache.Suffix("e2e-control-preview"), nil) + + // Another tenant with a signed-in member, and the built-in roles a + // preview's database has from its environment. + neighbour := testenv.InitAuthContext(t, ctx, db, manager) + neighbourAuth, ok := contextvalues.GetAuthContext(neighbour) + require.True(t, ok) + require.NoError(t, authz.SeedSystemRoleGrants(ctx, db, mockidp.MockOrgID)) + + siteURL, err := url.Parse("https://pr-4242.dev.example.test") + require.NoError(t, err) + mux := goahttp.NewMuxer() + require.NoError(t, attachE2EControl(ctx, logger, mux, e2eControlDeps{ + environment: "dev", + token: testE2EControlToken, + // The clone has a generated name; a preview's is its pull request's. + databaseName: func(context.Context) (string, error) { return "gram_preview_pr_4242", nil }, + developerEmail: nil, + siteURL: siteURL, + serverURL: siteURL, + issuerURL: "https://issuer.example.test", + db: db, + clickhouse: nil, + blob: assetstest.NewTestBlobStore(t), + encryption: testenv.NewEncryptionClient(t), + redis: redisClient, + users: e2eUsers{db: db}, + sessions: manager, + })) + + call := func(method, target string) *httptest.ResponseRecorder { + req := httptest.NewRequestWithContext(ctx, method, target, nil) + req.Header.Set(e2econtrol.TokenHeader, testE2EControlToken) + rec := httptest.NewRecorder() + mux.ServeHTTP(rec, req) + return rec + } + signIn := func() *httptest.ResponseRecorder { + res := call(http.MethodPost, "/rpc/e2e.signInLink") + require.Equal(t, http.StatusOK, res.Code) + var link struct { + Path string `json:"path"` + } + require.NoError(t, json.Unmarshal(res.Body.Bytes(), &link)) + return call(http.MethodGet, link.Path) + } + + // Before the first reset the runner does not exist, so nobody is signed in. + require.Equal(t, http.StatusForbidden, signIn().Code) + + // The reset is repeatable. + for range 2 { + require.Equal(t, http.StatusNoContent, call(http.MethodPost, "/rpc/e2e.reseed").Code) + } + + res := signIn() + require.Equal(t, http.StatusSeeOther, res.Code) + require.Equal(t, "https://pr-4242.dev.example.test/e2e-pr-4242", res.Header().Get("Location")) + cookies := res.Result().Cookies() + require.Len(t, cookies, 1) + require.Equal(t, constants.SessionCookie, cookies[0].Name) + sessionID := cookies[0].Value + + // The cookie is an ordinary dashboard session for the runner: a member of + // the preview's organization, not platform staff. + authenticated, err := manager.Authenticate(ctx, sessionID) + require.NoError(t, err) + auth, ok := contextvalues.GetAuthContext(authenticated) + require.True(t, ok) + require.Equal(t, "org_e2e_pr_4242", auth.ActiveOrganizationID) + require.Equal(t, "user_e2e4242_e2e-runner", auth.UserID) + require.False(t, auth.IsAdmin) + require.Equal(t, "e2e-pr-4242", auth.OrganizationSlug) + + // It cannot be moved to the shared demo organization or to the neighbour's, + // the two things auth.enterDemo and auth.switchScopes would do. + session, err := manager.GetSession(ctx, sessionID) + require.NoError(t, err) + for _, organizationID := range []string{constants.DemoOrganizationID, neighbourAuth.ActiveOrganizationID} { + moved := session + moved.ActiveOrganizationID = organizationID + require.ErrorContains(t, manager.UpdateSession(ctx, session, moved), "confined") + } + // The neighbour's member is not confined, and still a member of only theirs. + neighbourSession, err := manager.GetSession(ctx, *neighbourAuth.SessionID) + require.NoError(t, err) + demo := neighbourSession + demo.ActiveOrganizationID = constants.DemoOrganizationID + require.NoError(t, manager.UpdateSession(ctx, neighbourSession, demo)) + organizations, err := orgrepo.New(db).ListOrganizationsForUser(ctx, conv.ToPGText(neighbourAuth.UserID)) + require.NoError(t, err) + require.Len(t, organizations, 1) + require.Equal(t, mockidp.MockOrgID, organizations[0].ID) + + // The next reset ends the runner's earlier sessions. + require.Equal(t, http.StatusNoContent, call(http.MethodPost, "/rpc/e2e.reseed").Code) + _, err = manager.Authenticate(ctx, sessionID) + var shareable *oops.ShareableError + require.ErrorAs(t, err, &shareable) + require.Equal(t, oops.CodeUnauthorized, shareable.Code) + require.Equal(t, http.StatusSeeOther, signIn().Code, "and a new link signs in again") +} diff --git a/server/cmd/gram/deps_e2e_test.go b/server/cmd/gram/deps_e2e_test.go index 83febb95488..0271c932b04 100644 --- a/server/cmd/gram/deps_e2e_test.go +++ b/server/cmd/gram/deps_e2e_test.go @@ -2,11 +2,13 @@ package gram import ( "context" + "errors" "net/http" "net/http/httptest" "net/url" "slices" "testing" + "time" "github.com/alicebob/miniredis/v2" "github.com/redis/go-redis/v9" @@ -14,43 +16,83 @@ import ( "github.com/urfave/cli/v2" goahttp "goa.design/goa/v3/http" + "github.com/speakeasy-api/gram/server/internal/auth/sessions" "github.com/speakeasy-api/gram/server/internal/e2econtrol" "github.com/speakeasy-api/gram/server/internal/testenv" ) -const ( - testE2EControlToken = "zz-e2e-not-a-secret-zz-e2e-not-a-secret" - testDevIDPURL = "http://localhost:35291" - testEmulatorURL = testDevIDPURL + "/workos" -) +const testE2EControlToken = "zz-e2e-not-a-secret-zz-e2e-not-a-secret" + +// e2eStartup is one server as its deployment configures it. +type e2eStartup struct { + environment string + token string + database string + site string + server string +} + +// A pull request preview as the preview chart renders it. +func previewStartup() e2eStartup { + return e2eStartup{ + environment: "dev", + token: testE2EControlToken, + database: "gram_preview_pr_123", + site: "https://pr-123.dev.example.test", + server: "https://pr-123.dev.example.test", + } +} + +// recordingSessions records which user the surface confined. +type recordingSessions struct { + confined map[string]string +} + +func (recordingSessions) SignInEnforced(context.Context, string) bool { return false } -// attachTestE2EControl runs the startup decision with no database or identity -// provider behind it (neither is touched by the calls below) and reports the -// status each route then answers. -func attachTestE2EControl(t *testing.T, environment, identityBackend, identityEndpoint, token string) (map[string]int, error) { +func (recordingSessions) Issue(context.Context, http.ResponseWriter, sessions.Session, time.Time) error { + return nil +} + +func (recordingSessions) RaiseUserEpoch(context.Context, string, time.Time) error { return nil } + +func (r recordingSessions) ConfineUser(userID, organizationID string) { + r.confined[userID] = organizationID +} + +// attachTestE2EControl runs the startup decision with no database or session +// store behind it (neither is touched by the calls below) and reports the +// status each route then answers, and whom the surface confined. +func attachTestE2EControl(t *testing.T, s e2eStartup) (map[string]int, map[string]string, error) { t.Helper() - siteURL, err := url.Parse("https://site.example.test") + siteURL, err := url.Parse(s.site) + require.NoError(t, err) + serverURL, err := url.Parse(s.server) require.NoError(t, err) redisClient := redis.NewClient(&redis.Options{Addr: miniredis.RunT(t).Addr()}) t.Cleanup(func() { require.NoError(t, redisClient.Close()) }) mux := goahttp.NewMuxer() + confined := map[string]string{} err = attachE2EControl(t.Context(), testenv.NewLogger(t), mux, e2eControlDeps{ - environment: environment, - identityBackend: identityBackend, - identityEndpoint: identityEndpoint, - devIDPURL: testDevIDPURL, - token: token, - developerEmail: func(context.Context) string { return "developer@example.test" }, - siteURL: siteURL, - serverURL: siteURL, - issuerURL: "", - db: nil, - clickhouse: nil, - blob: nil, - encryption: nil, - redis: redisClient, - identity: nil, - sessions: nil, + environment: s.environment, + token: s.token, + databaseName: func(context.Context) (string, error) { + if s.database == "" { + return "", errors.New("the database did not answer") + } + return s.database, nil + }, + developerEmail: func(context.Context) string { return "developer@example.test" }, + siteURL: siteURL, + serverURL: serverURL, + issuerURL: "", + db: nil, + clickhouse: nil, + blob: nil, + encryption: nil, + redis: redisClient, + users: nil, + sessions: recordingSessions{confined: confined}, }) statuses := map[string]int{} for _, route := range []struct{ method, path string }{ @@ -68,58 +110,109 @@ func attachTestE2EControl(t *testing.T, environment, identityBackend, identityEn mux.ServeHTTP(rec, req) statuses[route.path] = rec.Code } - return statuses, err + return statuses, confined, err } -var e2eControlNotMounted = map[string]int{ - "/rpc/e2e.tenant": http.StatusNotFound, - "/rpc/e2e.signIn": http.StatusNotFound, - "/rpc/e2e.reseed": http.StatusNotFound, - "/rpc/e2e.signInLink": http.StatusNotFound, -} +var ( + e2eControlNotMounted = map[string]int{ + "/rpc/e2e.tenant": http.StatusNotFound, + "/rpc/e2e.signIn": http.StatusNotFound, + "/rpc/e2e.reseed": http.StatusNotFound, + "/rpc/e2e.signInLink": http.StatusNotFound, + } + e2eControlMounted = map[string]int{ + "/rpc/e2e.tenant": http.StatusOK, + "/rpc/e2e.signIn": http.StatusForbidden, // no code + "/rpc/e2e.reseed": http.StatusUnauthorized, + "/rpc/e2e.signInLink": http.StatusUnauthorized, + } +) func TestE2EControlIsOffWithoutAToken(t *testing.T) { t.Parallel() for _, environment := range []string{"local", "dev", "prod"} { - statuses, err := attachTestE2EControl(t, environment, "local", testEmulatorURL, "") + s := previewStartup() + s.environment, s.token = environment, "" + statuses, confined, err := attachTestE2EControl(t, s) require.NoError(t, err, environment) require.Equal(t, e2eControlNotMounted, statuses, environment) + require.Empty(t, confined, environment) } } -func TestE2EControlTokenStopsStartupOutsideLocal(t *testing.T) { +// Every environment but local and dev refuses, even one that is otherwise +// configured exactly as a preview. +func TestE2EControlTokenStopsStartupInOtherEnvironments(t *testing.T) { t.Parallel() - for _, environment := range []string{"prod", "production", "dev", "preview", "staging", "Local", ""} { - statuses, err := attachTestE2EControl(t, environment, "local", testEmulatorURL, testE2EControlToken) - require.ErrorContains(t, err, "exists only in", environment) + for _, environment := range []string{"prod", "production", "preview", "staging", "Local", "Dev", " dev", ""} { + s := previewStartup() + s.environment = environment + statuses, _, err := attachTestE2EControl(t, s) + require.ErrorContains(t, err, "exists only on a local stack or a pull request preview", environment) require.Equal(t, e2eControlNotMounted, statuses, environment) } } -func TestE2EControlTokenStopsStartupWithARealIdentityProvider(t *testing.T) { +// In the dev environment the surface exists only where the server is connected +// to a preview's own database and served at that preview's host. +func TestE2EControlTokenStopsStartupInDevUnlessItIsAPreview(t *testing.T) { t.Parallel() - for name, identity := range map[string]struct{ backend, endpoint string }{ - "the dev-idp forwarding to a real provider": {"workos", testEmulatorURL}, - "no backend named": {"", testEmulatorURL}, - "no endpoint, so the provider's own": {"local", ""}, - "an endpoint that is not the dev-idp": {"local", "https://api.example.test"}, - } { - statuses, err := attachTestE2EControl(t, "local", identity.backend, identity.endpoint, testE2EControlToken) - require.ErrorContains(t, err, "dev-idp emulator only", name) + cases := map[string]func(*e2eStartup){ + "the environment's own database": func(s *e2eStartup) { s.database = "gram" }, + "the environment's own deployment": func(s *e2eStartup) { + s.database, s.site, s.server = "gram", "https://dev.example.test", "https://dev.example.test" + }, + "a database that does not answer": func(s *e2eStartup) { s.database = "" }, + "a database named like a preview's": func(s *e2eStartup) { s.database = "gram_preview_pr_123_copy" }, + "a prefix before the name": func(s *e2eStartup) { s.database = "x_gram_preview_pr_123" }, + "no pull request number": func(s *e2eStartup) { s.database = "gram_preview_pr_" }, + "pull request zero": func(s *e2eStartup) { s.database = "gram_preview_pr_0" }, + "a number with a leading zero": func(s *e2eStartup) { s.database = "gram_preview_pr_0123" }, + "a number too large to name": func(s *e2eStartup) { s.database = "gram_preview_pr_268435456" }, + "another preview's database": func(s *e2eStartup) { s.database = "gram_preview_pr_124" }, + "a longer number in the host": func(s *e2eStartup) { + s.site, s.server = "https://pr-1234.dev.example.test", "https://pr-1234.dev.example.test" + }, + "the environment's dashboard host": func(s *e2eStartup) { s.site = "https://dev.example.test" }, + "the environment's server host": func(s *e2eStartup) { s.server = "https://dev.example.test" }, + "two different preview hosts": func(s *e2eStartup) { s.server = "https://pr-123.other.example.test" }, + "the number later in the host": func(s *e2eStartup) { + s.site, s.server = "https://dev.pr-123.example.test", "https://dev.pr-123.example.test" + }, + "a loopback host": func(s *e2eStartup) { s.site, s.server = "http://localhost:5173", "http://localhost:8080" }, + } + for name, mutate := range cases { + s := previewStartup() + mutate(&s) + statuses, confined, err := attachTestE2EControl(t, s) + require.Error(t, err, name) require.Equal(t, e2eControlNotMounted, statuses, name) + require.Empty(t, confined, name) } } +func TestE2EControlIsMountedOnAPreviewBehindTheToken(t *testing.T) { + t.Parallel() + statuses, confined, err := attachTestE2EControl(t, previewStartup()) + require.NoError(t, err) + require.Equal(t, e2eControlMounted, statuses) + // The synthetic test user of pull request 123, and nobody else, is pinned + // to pull request 123's test organization. + require.Equal(t, map[string]string{"user_e2e123_e2e-runner": "org_e2e_pr_123"}, confined) +} + func TestE2EControlIsMountedLocallyBehindTheToken(t *testing.T) { t.Parallel() - statuses, err := attachTestE2EControl(t, "local", "local", testEmulatorURL, testE2EControlToken) + statuses, confined, err := attachTestE2EControl(t, e2eStartup{ + environment: "local", + token: testE2EControlToken, + database: "gram", + site: "https://localhost:5173", + server: "https://localhost:8080", + }) require.NoError(t, err) - require.Equal(t, map[string]int{ - "/rpc/e2e.tenant": http.StatusOK, - "/rpc/e2e.signIn": http.StatusForbidden, // no code - "/rpc/e2e.reseed": http.StatusUnauthorized, - "/rpc/e2e.signInLink": http.StatusUnauthorized, - }, statuses) + require.Equal(t, e2eControlMounted, statuses) + require.Empty(t, confined, "the developer keeps the run of their own stack") } // Only the API server takes the token: a command that accepted it without diff --git a/server/cmd/gram/start.go b/server/cmd/gram/start.go index 36c8766952d..458261511b6 100644 --- a/server/cmd/gram/start.go +++ b/server/cmd/gram/start.go @@ -697,7 +697,7 @@ func serverFlags() []cli.Flag { &cli.StringFlag{Name: "github-evidence-token", Usage: "GitHub API token for MCP evidence repository lookups", EnvVars: []string{"GRAM_GITHUB_EVIDENCE_TOKEN"}}, &cli.StringFlag{ Name: e2eControlTokenFlag, - Usage: "Secret that enables the end-to-end test control surface (/rpc/e2e.*) on a local stack. Unset leaves it off. The server refuses to start with it set in any other environment.", + Usage: "Secret that enables the end-to-end test control surface (/rpc/e2e.*) on a local stack or a pull request preview. Unset leaves it off. The server refuses to start with it set anywhere else.", EnvVars: []string{"GRAM_E2E_CONTROL_TOKEN"}, }, &cli.StringFlag{ @@ -1713,22 +1713,20 @@ func newStartCommand() *cli.Command { authService.SetTokenRevoker(chatSessionsManager, meterProvider) auth.Attach(mux, authService) if err := attachE2EControl(ctx, logger, mux, e2eControlDeps{ - environment: c.String("environment"), - identityBackend: c.String("devidp-backend"), - identityEndpoint: c.String("workos-endpoint"), - devIDPURL: fixtureDevIDPURL, - token: c.String(e2eControlTokenFlag), - developerEmail: gitUserEmail, - siteURL: siteURL, - serverURL: serverURL, - issuerURL: c.String("authz-issuer-url"), - db: db, - clickhouse: chDB, - blob: assetStorage, - encryption: encryptionClient, - redis: redisClient, - identity: identityResolver, - sessions: sessionManager, + environment: c.String("environment"), + token: c.String(e2eControlTokenFlag), + databaseName: func(ctx context.Context) (string, error) { return currentDatabase(ctx, db) }, + developerEmail: gitUserEmail, + siteURL: siteURL, + serverURL: serverURL, + issuerURL: c.String("authz-issuer-url"), + db: db, + clickhouse: chDB, + blob: assetStorage, + encryption: encryptionClient, + redis: redisClient, + users: e2eUsers{db: db}, + sessions: sessionManager, }); err != nil { return err } diff --git a/server/internal/auth/sessions/issue.go b/server/internal/auth/sessions/issue.go new file mode 100644 index 00000000000..d470da39639 --- /dev/null +++ b/server/internal/auth/sessions/issue.go @@ -0,0 +1,43 @@ +package sessions + +import ( + "context" + "net/http" + "time" + + "github.com/speakeasy-api/gram/server/internal/constants" +) + +// Issue stores a new dashboard session for a subject the caller has already +// authenticated, then writes its cookie. The cookie is written only once the +// session is stored. issuedAt is when authentication started, for the +// sign-out-everywhere epoch (see StoreSessionIssuedAt). +func (s *Manager) Issue(ctx context.Context, w http.ResponseWriter, session Session, issuedAt time.Time) error { + if err := s.StoreSessionIssuedAt(ctx, session, issuedAt); err != nil { + return err + } + //nolint:exhaustruct_v5 // only desired fields — avoid unexpected zero-value behavior + http.SetCookie(w, &http.Cookie{ + Name: constants.SessionCookie, + Value: session.SessionID, + MaxAge: constants.SessionCookieMaxAgeSeconds, + Path: "/", + Secure: true, + HttpOnly: true, + SameSite: http.SameSiteLaxMode, + }) + return nil +} + +// ConfineUser pins every session of userID to organizationID in this process: +// UpdateSession then refuses to move one to any other organization, which is +// how auth.switchScopes and auth.enterDemo change a session's organization. +// The end-to-end test control surface confines its test user on a pull request +// preview, so a session it issues never names an organization that exists +// outside that preview. Call it before the server starts serving. +func (s *Manager) ConfineUser(userID, organizationID string) { + if s.confined == nil { + s.confined = map[string]string{} + } + s.confined[userID] = organizationID +} diff --git a/server/internal/auth/sessions/issue_test.go b/server/internal/auth/sessions/issue_test.go new file mode 100644 index 00000000000..e33e054fe64 --- /dev/null +++ b/server/internal/auth/sessions/issue_test.go @@ -0,0 +1,110 @@ +package sessions_test + +import ( + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/alicebob/miniredis/v2" + "github.com/redis/go-redis/v9" + "github.com/stretchr/testify/require" + + "github.com/speakeasy-api/gram/server/internal/auth/sessions" + "github.com/speakeasy-api/gram/server/internal/cache" + "github.com/speakeasy-api/gram/server/internal/constants" + "github.com/speakeasy-api/gram/server/internal/testenv" +) + +func newIssueTestManager(t *testing.T) (*sessions.Manager, *miniredis.Miniredis) { + t.Helper() + mr := miniredis.RunT(t) + redisClient := redis.NewClient(&redis.Options{Addr: mr.Addr()}) + t.Cleanup(func() { _ = redisClient.Close() }) + return sessions.NewManager(testenv.NewLogger(t), testenv.NewTracerProvider(t), nil, redisClient, cache.SuffixNone, nil, nil, nil), mr +} + +func issueTestSession(id string) sessions.Session { + return sessions.Session{ + SessionID: id, + UserID: "user-1", + ActiveOrganizationID: "org-1", + WorkOSSessionID: "", + ImpersonatorEmail: "", + SupportOrganizationID: "", + SupportExpiresAt: time.Time{}, + } +} + +func TestIssueStoresTheSessionThenWritesItsCookie(t *testing.T) { + t.Parallel() + manager, _ := newIssueTestManager(t) + issuedAt := time.Now().Add(-time.Second).Truncate(time.Microsecond) + + rec := httptest.NewRecorder() + require.NoError(t, manager.Issue(t.Context(), rec, issueTestSession("session-1"), issuedAt)) + + stored, err := manager.GetSession(t.Context(), "session-1") + require.NoError(t, err) + require.Equal(t, issueTestSession("session-1"), stored) + recorded, known, err := manager.IssuedAt(t.Context(), "session-1") + require.NoError(t, err) + require.True(t, known) + require.True(t, issuedAt.Equal(recorded)) + + cookies := rec.Result().Cookies() + require.Len(t, cookies, 1) + require.Equal(t, constants.SessionCookie, cookies[0].Name) + require.Equal(t, "session-1", cookies[0].Value) + require.Equal(t, "/", cookies[0].Path) + require.Empty(t, cookies[0].Domain, "host-only") + require.True(t, cookies[0].HttpOnly) + require.True(t, cookies[0].Secure) + require.Equal(t, http.SameSiteLaxMode, cookies[0].SameSite) +} + +func TestIssueWritesNoCookieWhenTheSessionIsNotStored(t *testing.T) { + t.Parallel() + manager, mr := newIssueTestManager(t) + mr.Close() + + rec := httptest.NewRecorder() + require.Error(t, manager.Issue(t.Context(), rec, issueTestSession("session-1"), time.Now())) + require.Empty(t, rec.Result().Cookies()) +} + +func TestConfinedUsersSessionCannotMoveToAnotherOrganization(t *testing.T) { + t.Parallel() + manager, _ := newIssueTestManager(t) + manager.ConfineUser("user-1", "org-1") + + session := issueTestSession("session-1") + require.NoError(t, manager.Issue(t.Context(), httptest.NewRecorder(), session, time.Now())) + + // auth.switchScopes to another organization, and auth.enterDemo. + for _, organizationID := range []string{"org-2", constants.DemoOrganizationID, ""} { + moved := session + moved.ActiveOrganizationID = organizationID + require.ErrorContains(t, manager.UpdateSession(t.Context(), session, moved), "confined", organizationID) + } + stored, err := manager.GetSession(t.Context(), "session-1") + require.NoError(t, err) + require.Equal(t, "org-1", stored.ActiveOrganizationID) + + // Selecting the organization it is already in changes nothing and succeeds. + require.NoError(t, manager.UpdateSession(t.Context(), session, session)) +} + +func TestOtherUsersSessionsMoveFreely(t *testing.T) { + t.Parallel() + manager, _ := newIssueTestManager(t) + manager.ConfineUser("user-1", "org-1") + + session := issueTestSession("session-2") + session.UserID = "user-2" + require.NoError(t, manager.Issue(t.Context(), httptest.NewRecorder(), session, time.Now())) + + moved := session + moved.ActiveOrganizationID = constants.DemoOrganizationID + require.NoError(t, manager.UpdateSession(t.Context(), session, moved)) +} diff --git a/server/internal/auth/sessions/sessions.go b/server/internal/auth/sessions/sessions.go index e67b0f83121..0a01c7afcd4 100644 --- a/server/internal/auth/sessions/sessions.go +++ b/server/internal/auth/sessions/sessions.go @@ -79,6 +79,9 @@ type Manager struct { userRepo *userRepo.Queries billingRepo billing.Repository identity UserResolver + // confined maps a user to the only organization their sessions may name + // (ConfineUser). Written before the server serves, read-only after. + confined map[string]string } func NewManager( @@ -104,6 +107,7 @@ func NewManager( userRepo: userRepo.New(db), billingRepo: billingRepo, identity: identity, + confined: nil, } } @@ -301,6 +305,9 @@ func (s *Manager) StoreSessionIssuedAt(ctx context.Context, session Session, iss } func (s *Manager) UpdateSession(ctx context.Context, expected, replacement Session) error { + if organizationID, ok := s.confined[replacement.UserID]; ok && replacement.ActiveOrganizationID != organizationID { + return errors.New("update session: this user's sessions are confined to one organization") + } updated, err := s.sessionCache.CompareAndSwap(ctx, expected, replacement) if err != nil { return fmt.Errorf("update session: %w", err) diff --git a/server/internal/demoseed/demoseed.go b/server/internal/demoseed/demoseed.go index b4961dc452f..26017fe902b 100644 --- a/server/internal/demoseed/demoseed.go +++ b/server/internal/demoseed/demoseed.go @@ -54,7 +54,9 @@ var ErrSeedLocked = errors.New("another demo seed run holds the advisory lock; r // materialized-view targets before its inserts incrementally repopulate the // summaries. // -// Pass DefaultSpec() for the shared production demo org. +// Pass DefaultSpec() for the shared production demo org. A nil ch skips the +// ClickHouse seed entirely, deletes included: a pull request preview shares its +// environment's ClickHouse and owns only its Postgres database. func Run(ctx context.Context, logger *slog.Logger, db *pgxpool.Pool, ch driver.Conn, blob assets.BlobStore, enc *encryption.Client, assistantIssuerURL, serverURL string, spec Spec) error { logger = logger.With(attr.SlogComponent("demoseed"), attr.SlogOrganizationID(spec.OrgID)) @@ -80,6 +82,10 @@ func Run(ctx context.Context, logger *slog.Logger, db *pgxpool.Pool, ch driver.C } logger.InfoContext(ctx, "demo seed upstream auth migrated") + if ch == nil { + logger.InfoContext(ctx, "demo seed skipped clickhouse") + return nil + } if err := s.runClickHouse(ctx, ch); err != nil { return fmt.Errorf("apply demo seed to clickhouse: %w", err) } diff --git a/server/internal/demoseed/preview.go b/server/internal/demoseed/preview.go new file mode 100644 index 00000000000..ad609c48c69 --- /dev/null +++ b/server/internal/demoseed/preview.go @@ -0,0 +1,131 @@ +package demoseed + +import ( + "context" + "errors" + "fmt" + "log/slog" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" + + "github.com/speakeasy-api/gram/server/internal/attr" + "github.com/speakeasy-api/gram/server/internal/authz" + "github.com/speakeasy-api/gram/server/internal/demoseed/repo" +) + +// PreviewRunner is the one account end-to-end tests sign in as on a pull +// request preview: a member of the preview's test organization and of nothing +// else, outside the fictional roster, never platform staff. No identity +// provider knows it and its address is on a reserved domain that receives no +// mail, so it cannot log in, be invited, or have memberships synced to it. +type PreviewRunner struct { + ID string + Email string + Name string +} + +// PreviewRunner is the runner of this Spec's organization. +func (s Spec) PreviewRunner() PreviewRunner { + return PreviewRunner{ + ID: s.UserPrefix + "e2e-runner", + Email: "e2e-runner" + s.EmailDomain, + Name: "End-to-end test runner", + } +} + +// CurrentDatabase is the name of the database db is connected to, as the +// database reports it. +func CurrentDatabase(ctx context.Context, db *pgxpool.Pool) (string, error) { + name, err := repo.New(db).PreviewCurrentDatabase(ctx) + if err != nil { + return "", fmt.Errorf("read current database: %w", err) + } + return name, nil +} + +// RunPreviewFixtures adds what a preview's test organization needs on top of +// the seeded data: its role grants, the grants and settings the local +// development organization also gets, and the runner as a member with the Admin +// role. Call it only after Run has completed with spec: the seed deletes the +// organization's memberships. +// +// Everything is written in one transaction and every write is scoped to spec's +// organization, except the runner's own user row. The membership is written +// last, so a failed run leaves an organization nobody can sign in to. Unlike +// RunLocalFixtures it makes nobody platform staff, creates no API key and +// writes no registry or catalog rows. +func RunPreviewFixtures(ctx context.Context, logger *slog.Logger, db *pgxpool.Pool, cache *redis.Client, spec Spec) error { + logger = logger.With(attr.SlogComponent("demoseed.preview"), attr.SlogOrganizationID(spec.OrgID)) + runner := spec.PreviewRunner() + workosID := "workos_" + runner.ID + projectID := uuid.MustParse(spec.ProjectID()) + + tx, err := db.Begin(ctx) + if err != nil { + return fmt.Errorf("begin preview fixtures transaction: %w", err) + } + defer func() { + if err := tx.Rollback(ctx); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + logger.ErrorContext(ctx, "roll back preview fixtures", attr.SlogError(err)) + } + }() + + q := repo.New(tx) + for _, step := range []struct { + name string + run func() error + }{ + // A preview's database is a clone of its environment's, which has the + // built-in roles. Their absence is a refusal: the grant seeder below + // would otherwise create them, a write that reaches every organization. + {"built-in roles", func() error { + for _, slug := range []string{authz.SystemRoleAdmin, authz.SystemRoleMember} { + if _, err := q.OrgGlobalRoleURN(ctx, slug); err != nil { + return fmt.Errorf("built-in role %q: %w", slug, err) + } + } + return nil + }}, + {"system role grants", func() error { return authz.SeedSystemRoleGrantsTx(ctx, tx, spec.OrgID) }}, + {"personal auth client default", func() error { return authz.SeedPersonalAuthClientDefaultTx(ctx, tx, spec.OrgID) }}, + {"grant session visibility", func() error { + return q.LocalGrantSessionVisibility(ctx, repo.LocalGrantSessionVisibilityParams{OrganizationID: spec.OrgID, UserID: runner.ID}) + }}, + {"grant Channels administration", func() error { + if _, err := tx.Exec(ctx, localChannelsAccessSQL, spec.OrgID, runner.ID, spec.ProjectID()); err != nil { + return fmt.Errorf("grant Channels access: %w", err) + } + return nil + }}, + {"grant tool log visibility", func() error { + return q.LocalGrantToolLogVisibility(ctx, repo.LocalGrantToolLogVisibilityParams{OrganizationID: spec.OrgID, UserID: runner.ID}) + }}, + {"enable platform mcp", func() error { return q.LocalEnablePlatformMCPFeature(ctx, spec.OrgID) }}, + {"approve tool calls", func() error { + return q.LocalAddToolApprover(ctx, repo.LocalAddToolApproverParams{OrganizationID: spec.OrgID, PolicyID: uuid.MustParse(spec.FixedUUID(approvalPolicyFixedID)), Approver: "user:" + runner.ID}) + }}, + {"default environment", func() error { + return q.LocalUpsertEnvironment(ctx, repo.LocalUpsertEnvironmentParams{ID: uuid.MustParse(spec.FixedUUID("0000-4000-a000-000000007004")), OrganizationID: spec.OrgID, ProjectID: projectID}) + }}, + {"runner", func() error { + return q.PreviewUpsertRunner(ctx, repo.PreviewUpsertRunnerParams{ID: runner.ID, Email: runner.Email, DisplayName: runner.Name, WorkosID: workosID}) + }}, + {"runner membership", func() error { + return q.LocalAdoptDeveloper(ctx, repo.LocalAdoptDeveloperParams{OrganizationID: spec.OrgID, UserID: runner.ID, WorkosUserID: workosID}) + }}, + } { + if err := step.run(); err != nil { + return fmt.Errorf("preview fixture %q: %w", step.name, err) + } + } + if err := tx.Commit(ctx); err != nil { + return fmt.Errorf("commit preview fixtures: %w", err) + } + + bustLocalCaches(ctx, logger, cache, spec.OrgID, runner.ID) + logger.InfoContext(ctx, "preview fixtures applied") + return nil +} diff --git a/server/internal/demoseed/preview_test.go b/server/internal/demoseed/preview_test.go new file mode 100644 index 00000000000..a70b2970553 --- /dev/null +++ b/server/internal/demoseed/preview_test.go @@ -0,0 +1,121 @@ +//go:build demoseed_safety + +package demoseed + +import ( + "testing" + + "github.com/jackc/pgx/v5" + "github.com/stretchr/testify/require" + + "github.com/speakeasy-api/gram/server/internal/assets/assetstest" + "github.com/speakeasy-api/gram/server/internal/conv" + "github.com/speakeasy-api/gram/server/internal/demoseed/demoseedtest" + orgrepo "github.com/speakeasy-api/gram/server/internal/organizations/repo" + "github.com/speakeasy-api/gram/server/internal/testenv" + userrepo "github.com/speakeasy-api/gram/server/internal/users/repo" +) + +// A preview reset is the seed run with no ClickHouse connection, followed by +// the preview fixtures. Run twice beside another tenant, it leaves one +// non-staff runner whose only membership is the preview's organization, and +// the other tenant as it was. +func TestPreviewFixturesAdoptOnlyTheRunner(t *testing.T) { + t.Parallel() + + ctx := t.Context() + logger := testenv.NewLogger(t) + spec, err := PreviewSpec(123) + require.NoError(t, err) + runner := spec.PreviewRunner() + + db, err := infra.CloneTestDatabase(t, "testdb") + require.NoError(t, err) + + // The neighbour: a developer's organization, whose fixtures also create the + // built-in roles a preview's database has from its environment. + neighbour := LocalSpec() + seedLocalPostgres(ctx, t, db, neighbour) + require.NoError(t, RunLocalFixtures(ctx, logger, db, assetstest.NewTestBlobStore(t), nil, LocalFixturesOptions{DeveloperEmail: testDeveloperEmail, Environment: "local"})) + neighbourBefore, err := demoseedtest.ReadDeveloperState(ctx, db, neighbour.OrgID, testDeveloperEmail) + require.NoError(t, err) + require.Equal(t, 1, neighbourBefore.Memberships) + + for range 2 { + // No ClickHouse connection: the seed must not reach for one. + require.NoError(t, Run(ctx, logger, db, nil, assetstest.NewTestBlobStore(t), testenv.NewEncryptionClient(t), testAssistantIssuerURL, testServerURL, spec)) + require.NoError(t, RunPreviewFixtures(ctx, logger, db, nil, spec)) + } + + state, err := demoseedtest.ReadDeveloperState(ctx, db, spec.OrgID, runner.Email) + require.NoError(t, err) + require.Equal(t, demoseedtest.DeveloperState{ + Users: 1, + UserID: runner.ID, + WorkOSID: "workos_" + runner.ID, + Whitelisted: state.Whitelisted, + OrgWorkOSID: "", // no identity provider organization stands behind it + Memberships: 1, + RoleAssignments: 1, + }, state) + + user, err := userrepo.New(db).GetUserByEmail(ctx, runner.Email) + require.NoError(t, err) + require.False(t, user.Admin, "the runner is never platform staff") + organizations, err := orgrepo.New(db).ListOrganizationsForUser(ctx, conv.ToPGText(runner.ID)) + require.NoError(t, err) + require.Len(t, organizations, 1) + require.Equal(t, spec.OrgID, organizations[0].ID) + + neighbourAfter, err := demoseedtest.ReadDeveloperState(ctx, db, neighbour.OrgID, testDeveloperEmail) + require.NoError(t, err) + require.Equal(t, neighbourBefore, neighbourAfter) +} + +// Creating a built-in role would reach every organization in the database, so +// a database without them is refused, and nobody can sign in to the half-made +// organization: the runner is written last. +func TestPreviewFixturesRefuseADatabaseWithoutBuiltInRoles(t *testing.T) { + t.Parallel() + + ctx := t.Context() + spec, err := PreviewSpec(124) + require.NoError(t, err) + + db, err := infra.CloneTestDatabase(t, "testdb") + require.NoError(t, err) + seedLocalPostgres(ctx, t, db, spec) + + require.ErrorContains(t, RunPreviewFixtures(ctx, testenv.NewLogger(t), db, nil, spec), "built-in role") + _, err = userrepo.New(db).GetUserByEmail(ctx, spec.PreviewRunner().Email) + require.ErrorIs(t, err, pgx.ErrNoRows) +} + +// The runner's address already belonging to someone is a refusal, not an +// adoption: that user keeps their id and gains no membership. +func TestPreviewFixturesDoNotAdoptAnotherUsersAddress(t *testing.T) { + t.Parallel() + + ctx := t.Context() + logger := testenv.NewLogger(t) + spec, err := PreviewSpec(125) + require.NoError(t, err) + runner := spec.PreviewRunner() + + db, err := infra.CloneTestDatabase(t, "testdb") + require.NoError(t, err) + neighbour := LocalSpec() + seedLocalPostgres(ctx, t, db, neighbour) + require.NoError(t, RunLocalFixtures(ctx, logger, db, assetstest.NewTestBlobStore(t), nil, LocalFixturesOptions{DeveloperEmail: runner.Email, Environment: "local"})) + seedLocalPostgres(ctx, t, db, spec) + + require.Error(t, RunPreviewFixtures(ctx, logger, db, nil, spec)) + + user, err := userrepo.New(db).GetUserByEmail(ctx, runner.Email) + require.NoError(t, err) + require.NotEqual(t, runner.ID, user.ID) + organizations, err := orgrepo.New(db).ListOrganizationsForUser(ctx, conv.ToPGText(user.ID)) + require.NoError(t, err) + require.Len(t, organizations, 1) + require.Equal(t, neighbour.OrgID, organizations[0].ID) +} diff --git a/server/internal/demoseed/queries/preview.sql b/server/internal/demoseed/queries/preview.sql new file mode 100644 index 00000000000..27601d95a0a --- /dev/null +++ b/server/internal/demoseed/queries/preview.sql @@ -0,0 +1,18 @@ +-- Pull request preview fixtures (RunPreviewFixtures). Never part of the tenant +-- seed phases. + +-- name: PreviewCurrentDatabase :one +-- The name of the database this connection writes to. A preview's is +-- gram_preview_pr_; the server decides from it whether it is a preview. +SELECT current_database()::text; + +-- name: PreviewUpsertRunner :exec +-- The one account an end-to-end test run signs in as. Never platform staff, +-- and keyed on id only: an address that already belongs to another user is a +-- unique violation, which aborts the fixtures instead of adopting that user. +INSERT INTO users (id, email, display_name, workos_id, admin) +VALUES (@id::text, @email::text, @display_name::text, @workos_id::text, FALSE) +ON CONFLICT (id) DO UPDATE + SET email = EXCLUDED.email, display_name = EXCLUDED.display_name, + workos_id = EXCLUDED.workos_id, admin = FALSE, deleted_at = NULL, + updated_at = clock_timestamp(); diff --git a/server/internal/demoseed/repo/preview.sql.go b/server/internal/demoseed/repo/preview.sql.go new file mode 100644 index 00000000000..a6798d57326 --- /dev/null +++ b/server/internal/demoseed/repo/preview.sql.go @@ -0,0 +1,55 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: preview.sql + +package repo + +import ( + "context" +) + +const previewCurrentDatabase = `-- name: PreviewCurrentDatabase :one + +SELECT current_database()::text +` + +// Pull request preview fixtures (RunPreviewFixtures). Never part of the tenant +// seed phases. +// The name of the database this connection writes to. A preview's is +// gram_preview_pr_; the server decides from it whether it is a preview. +func (q *Queries) PreviewCurrentDatabase(ctx context.Context) (string, error) { + row := q.db.QueryRow(ctx, previewCurrentDatabase) + var column_1 string + err := row.Scan(&column_1) + return column_1, err +} + +const previewUpsertRunner = `-- name: PreviewUpsertRunner :exec +INSERT INTO users (id, email, display_name, workos_id, admin) +VALUES ($1::text, $2::text, $3::text, $4::text, FALSE) +ON CONFLICT (id) DO UPDATE + SET email = EXCLUDED.email, display_name = EXCLUDED.display_name, + workos_id = EXCLUDED.workos_id, admin = FALSE, deleted_at = NULL, + updated_at = clock_timestamp() +` + +type PreviewUpsertRunnerParams struct { + ID string + Email string + DisplayName string + WorkosID string +} + +// The one account an end-to-end test run signs in as. Never platform staff, +// and keyed on id only: an address that already belongs to another user is a +// unique violation, which aborts the fixtures instead of adopting that user. +func (q *Queries) PreviewUpsertRunner(ctx context.Context, arg PreviewUpsertRunnerParams) error { + _, err := q.db.Exec(ctx, previewUpsertRunner, + arg.ID, + arg.Email, + arg.DisplayName, + arg.WorkosID, + ) + return err +} diff --git a/server/internal/demoseed/spec.go b/server/internal/demoseed/spec.go index 05c6d2da0a6..3e7636cfc57 100644 --- a/server/internal/demoseed/spec.go +++ b/server/internal/demoseed/spec.go @@ -2,6 +2,7 @@ package demoseed import ( "fmt" + "strconv" "strings" "github.com/speakeasy-api/gram/dev-idp/pkg/devidentity" @@ -104,6 +105,35 @@ func LocalSpec() Spec { } } +// maxPreviewNumber is the largest pull request number whose fixed uuid prefix +// fits: one reserved hex digit, then seven for the number. +const maxPreviewNumber = 1<<28 - 1 + +// PreviewSpec is the end-to-end test organization of one pull request's preview +// environment. Every identifier family carries the pull request number, so +// previews, which share a cache with each other and with their environment, +// never share an organization or a user id. Like the demo organization it has +// no WorkOS counterpart: its WorkOSOrgID is an inert placeholder. +func PreviewSpec(pullRequest int) (Spec, error) { + if pullRequest < 1 || pullRequest > maxPreviewNumber { + return Spec{}, fmt.Errorf("preview seed spec: pull request number %d is out of range", pullRequest) + } + n := strconv.Itoa(pullRequest) + return Spec{ + CustomDomain: "mcp.e2e-pr-" + n + ".example.com", + OrgID: "org_e2e_pr_" + n, + WorkOSOrgID: "workos_e2e_pr_" + n + "_unlinked", + OrgSlug: "e2e-pr-" + n, + OrgName: "End-to-end tests (preview " + n + ")", + UUIDPrefix: fmt.Sprintf("e%07x", pullRequest), + UserPrefix: "user_e2e" + n + "_", + EmailDomain: "@pr-" + n + ".e2e.invalid", + NameSeed: "gram-e2e-" + n + "-", + GroupPrefix: "e2e" + n + "_grp_", + Marker: "e2e-preview-" + n, + }, nil +} + // ProjectID is the seed's single project, derived from UUIDPrefix. func (s Spec) ProjectID() string { return s.FixedUUID("0000-4000-a000-000000000001") diff --git a/server/internal/demoseed/spec_test.go b/server/internal/demoseed/spec_test.go index 6c3875c587c..816e05d8a98 100644 --- a/server/internal/demoseed/spec_test.go +++ b/server/internal/demoseed/spec_test.go @@ -3,9 +3,11 @@ package demoseed import ( "os" "path/filepath" + "strconv" "strings" "testing" + "github.com/google/uuid" "github.com/stretchr/testify/require" "github.com/speakeasy-api/gram/server/internal/constants" @@ -55,6 +57,56 @@ func TestSpecValidateRejectsCollisions(t *testing.T) { require.NoError(t, DefaultSpec().Validate()) } +// Previews share a cache with each other and with their environment, so two +// pull requests must never share an organization, a user or any other +// identifier family, and none may fall in the demo or local tenant's. +func TestPreviewSpecsShareNoIdentifierFamily(t *testing.T) { + t.Parallel() + + // The families the seed builds ids from by prefixing must not nest either: + // pull request 1's must not be the start of pull request 12's. + prefixes := func(s Spec) []string { return []string{s.UUIDPrefix, s.UserPrefix, s.NameSeed, s.GroupPrefix} } + seen := map[string]string{} + var seenPrefixes []string + for _, spec := range []Spec{DefaultSpec(), LocalSpec()} { + for _, id := range spec.Identifiers() { + seen[id] = "a checked-in tenant" + } + seenPrefixes = append(seenPrefixes, prefixes(spec)...) + } + for _, pullRequest := range []int{1, 12, 123, 9441, 94410, maxPreviewNumber} { + spec, err := PreviewSpec(pullRequest) + require.NoError(t, err) + require.NoError(t, spec.Validate()) + require.Len(t, spec.UUIDPrefix, 8) + require.NotPanics(t, func() { _ = uuid.MustParse(spec.ProjectID()) }) + + ids := append(spec.Identifiers(), spec.PreviewRunner().ID, spec.PreviewRunner().Email) + for _, id := range ids { + require.NotContains(t, seen, id, "pull request %d shares %q with %s", pullRequest, id, seen[id]) + } + for _, prefix := range prefixes(spec) { + for _, other := range seenPrefixes { + require.False(t, strings.HasPrefix(prefix, other) || strings.HasPrefix(other, prefix), + "pull request %d: prefix %q nests with %q", pullRequest, prefix, other) + } + } + for _, id := range ids { + seen[id] = "pull request " + strconv.Itoa(pullRequest) + } + seenPrefixes = append(seenPrefixes, prefixes(spec)...) + } +} + +func TestPreviewSpecRefusesNumbersItCannotName(t *testing.T) { + t.Parallel() + + for _, pullRequest := range []int{-1, 0, maxPreviewNumber + 1} { + _, err := PreviewSpec(pullRequest) + require.Error(t, err, pullRequest) + } +} + // seedSourceFiles lists the seed's own code: the Go files that write rows and // the sqlc query files. Excluded: spec.go, which defines the identifiers; // demoseed.go, the runner, whose advisory lock name every tenant shares on diff --git a/server/internal/e2econtrol/e2econtrol.go b/server/internal/e2econtrol/e2econtrol.go index 78fcc7e9a5f..c68bab59c87 100644 --- a/server/internal/e2econtrol/e2econtrol.go +++ b/server/internal/e2econtrol/e2econtrol.go @@ -7,10 +7,11 @@ // identity provider's pages (e2e.signInLink, then e2e.signIn in the browser). // // No route takes an organization, a user or a destination from its caller: all -// three are fixed when the server starts. +// three are fixed when the server starts. No route calls an identity provider. // -// It exists only on a local stack. New refuses every other environment, so a -// control token configured anywhere else stops the server from starting. +// Where the surface may exist, and which organization and user it is fixed to +// there, is decided by its caller (attachE2EControl in server/cmd/gram): a +// local stack, or a pull request preview connected to its own database. package e2econtrol import ( @@ -33,11 +34,8 @@ import ( goahttp "goa.design/goa/v3/http" "github.com/speakeasy-api/gram/server/internal/attr" - "github.com/speakeasy-api/gram/server/internal/auth/identity" "github.com/speakeasy-api/gram/server/internal/auth/sessions" "github.com/speakeasy-api/gram/server/internal/cache" - "github.com/speakeasy-api/gram/server/internal/constants" - "github.com/speakeasy-api/gram/server/internal/conv" "github.com/speakeasy-api/gram/server/internal/demoseed" "github.com/speakeasy-api/gram/server/internal/o11y" "github.com/speakeasy-api/gram/server/internal/oops" @@ -48,9 +46,6 @@ const ( // which a browser opens and which its one-time code authorizes. TokenHeader = "Gram-E2E-Token" //nolint:gosec // G101: a header name, not a credential - // allowedEnvironment is the only environment the surface exists in. - allowedEnvironment = "local" - // linkTTL is how long a sign-in link stays redeemable. The test opens it in // the step after it asks for it. linkTTL = 60 * time.Second @@ -69,13 +64,15 @@ type Tenant struct { // Config fixes everything the surface acts on. type Config struct { - // Environment is the deployment environment (GRAM_ENVIRONMENT). - Environment string // Token is the control secret (GRAM_E2E_CONTROL_TOKEN). Token string - // UserEmail is the only identity e2e.signIn signs in, spelled as the - // reseed adopts it: the identity provider derives the user from it. + // UserEmail is the only user e2e.signIn signs in. UserEmail string + // UserID, when set, is the id that user must have. + UserID string + // Confined requires the user to be no platform admin and a member of the + // tenant alone. Set wherever the tenant is not the developer's own. + Confined bool // SiteURL is the dashboard origin: sign-in links are bound to it, and the // browser lands on it. SiteURL *url.URL @@ -89,18 +86,17 @@ type Config struct { Reseed func(ctx context.Context) error } -// Identity is the part of identity.Resolver the sign-in needs: the -// server-created Magic Auth code the invitation callback also uses, then the -// user bootstrap of the login callback. -type Identity interface { - AuthenticateWithMagicAuth(ctx context.Context, email string) (*identity.IDPUserInfo, error) - CompleteIDPLogin(ctx context.Context, idpUser *identity.IDPUserInfo, opts identity.IDPLoginOptions) (identity.IDPLoginResult, error) +// Users reads a user as the database has them now, never from a cache: who +// they are, whether they are a platform admin, and the enabled organizations +// they belong to. A user that does not exist is (nil, nil). +type Users interface { + UserByEmail(ctx context.Context, email string) (*sessions.CachedUserInfo, error) } -// SessionStore stores the dashboard session. Implemented by sessions.Manager. +// SessionStore issues the dashboard session. Implemented by sessions.Manager. type SessionStore interface { SignInEnforced(ctx context.Context, organizationID string) bool - StoreSessionIssuedAt(ctx context.Context, session sessions.Session, issuedAt time.Time) error + Issue(ctx context.Context, w http.ResponseWriter, session sessions.Session, issuedAt time.Time) error } // Service serves the control surface. @@ -108,19 +104,16 @@ type Service struct { logger *slog.Logger cfg Config tokenDigest [sha256.Size]byte - identity Identity + users Users sessions SessionStore links cache.Cache reseeding sync.Mutex } // New builds the service. Its error is a refusal to start the server: the -// surface is being enabled outside a local stack, or its token is guessable, -// or it has no fixed target to act on. -func New(logger *slog.Logger, cfg Config, idp Identity, sessionStore SessionStore, links cache.Cache) (*Service, error) { +// token is guessable, or the surface has no fixed target to act on. +func New(logger *slog.Logger, cfg Config, users Users, sessionStore SessionStore, links cache.Cache) (*Service, error) { switch { - case cfg.Environment != allowedEnvironment: - return nil, fmt.Errorf("e2e control: exists only in the %q environment, refusing to enable it in %q", allowedEnvironment, cfg.Environment) case len(cfg.Token) < minTokenLength: return nil, fmt.Errorf("e2e control: the control token must be at least %d bytes", minTokenLength) case cfg.UserEmail == "": @@ -132,7 +125,7 @@ func New(logger *slog.Logger, cfg Config, idp Identity, sessionStore SessionStor logger: logger.With(attr.SlogComponent("e2econtrol")), cfg: cfg, tokenDigest: sha256.Sum256([]byte(cfg.Token)), - identity: idp, + users: users, sessions: sessionStore, links: links, reseeding: sync.Mutex{}, @@ -214,64 +207,64 @@ func (s *Service) handleSignIn(w http.ResponseWriter, r *http.Request) error { case err != nil: return fmt.Errorf("e2e sign-in: redeem link: %w", err) } - // This sign-in is not recorded the way the login and invitation callbacks - // record theirs (signins.RecordExchange), so it gives no session where an - // organization requires recorded sign-ins. + // No identity provider authenticated this sign-in, so there is nothing to + // record the way the login and invitation callbacks record theirs + // (signins.RecordExchange). It gives no session where an organization + // requires recorded sign-ins. if s.sessions.SignInEnforced(ctx, s.cfg.Tenant.OrganizationID) { return oops.E(oops.CodeForbidden, nil, "the test organization enforces recorded sign-ins, which this sign-in is not") } - // Taken before authenticating so a sign-out everywhere that lands + // Taken before reading the user so a sign-out everywhere that lands // meanwhile still ends this session. authenticatedAt := time.Now() - idpUser, err := s.identity.AuthenticateWithMagicAuth(ctx, s.cfg.UserEmail) + user, err := s.users.UserByEmail(ctx, s.cfg.UserEmail) if err != nil { - return oops.E(oops.CodeGatewayError, err, "the identity provider refused the test user").LogError(ctx, s.logger) - } - if idpUser == nil || conv.NormalizeEmail(idpUser.Email) != conv.NormalizeEmail(s.cfg.UserEmail) { - return oops.E(oops.CodeForbidden, nil, "the identity provider returned a different user").LogError(ctx, s.logger) + return fmt.Errorf("e2e sign-in: read test user: %w", err) } - // Memberships are not synced from the identity provider: the reseed is - // what makes the test user a member, and the check below reads that. - login, err := s.identity.CompleteIDPLogin(ctx, idpUser, identity.IDPLoginOptions{SkipMembershipSync: true, Attribution: nil}) - if err != nil { - return fmt.Errorf("e2e sign-in: complete login: %w", err) - } - if login.UserInfo == nil || !slices.ContainsFunc(login.UserInfo.Organizations, func(o sessions.Organization) bool { return o.ID == s.cfg.Tenant.OrganizationID }) { - return oops.E(oops.CodeForbidden, nil, "the test user is not a member of the test organization; reseed it first") + if reason := s.refusal(user); reason != "" { + return oops.E(oops.CodeForbidden, nil, "%s", reason).LogError(ctx, s.logger) } sessionID, err := sessions.NewSessionID() if err != nil { return fmt.Errorf("e2e sign-in: %w", err) } - if err := s.sessions.StoreSessionIssuedAt(ctx, sessions.Session{ + if err := s.sessions.Issue(ctx, w, sessions.Session{ SessionID: sessionID, - UserID: login.UserID, + UserID: user.UserID, ActiveOrganizationID: s.cfg.Tenant.OrganizationID, - WorkOSSessionID: idpUser.WorkOSSessionID, + WorkOSSessionID: "", ImpersonatorEmail: "", SupportOrganizationID: "", SupportExpiresAt: time.Time{}, }, authenticatedAt); err != nil { - return fmt.Errorf("e2e sign-in: store session: %w", err) + return fmt.Errorf("e2e sign-in: issue session: %w", err) } - - //nolint:exhaustruct_v5 // only desired fields, as the invitation callback sets them - http.SetCookie(w, &http.Cookie{ - Name: constants.SessionCookie, - Value: sessionID, - MaxAge: constants.SessionCookieMaxAgeSeconds, - Path: "/", - Secure: true, - HttpOnly: true, - SameSite: http.SameSiteLaxMode, - }) - s.logger.InfoContext(ctx, "e2e sign-in complete", attr.SlogUserID(login.UserID), attr.SlogOrganizationID(s.cfg.Tenant.OrganizationID)) + s.logger.InfoContext(ctx, "e2e sign-in complete", attr.SlogUserID(user.UserID), attr.SlogOrganizationID(s.cfg.Tenant.OrganizationID)) http.Redirect(w, r, s.cfg.SiteURL.JoinPath(s.cfg.Tenant.OrganizationSlug).String(), http.StatusSeeOther) return nil } +// refusal says why user gets no session, or "" when they do. The reseed is +// what creates the test user and makes them a member, so each reason is also +// what a reseed repairs. +func (s *Service) refusal(user *sessions.CachedUserInfo) string { + switch { + case user == nil: + return "the test user does not exist; reseed first" + case s.cfg.UserID != "" && user.UserID != s.cfg.UserID: + return "the test user's address belongs to another user" + case !slices.ContainsFunc(user.Organizations, func(o sessions.Organization) bool { return o.ID == s.cfg.Tenant.OrganizationID }): + return "the test user is not a member of the test organization; reseed first" + case s.cfg.Confined && user.Admin: + return "the test user is a platform admin, which it must never be here" + case s.cfg.Confined && len(user.Organizations) != 1: + return "the test user belongs to more than the test organization" + } + return "" +} + // linkKey is where a sign-in code's marker lives. The code is hashed, so the // cache never holds a value that would sign anyone in, together with what it // was minted for (dashboard origin, organization, user), so a server diff --git a/server/internal/e2econtrol/e2econtrol_test.go b/server/internal/e2econtrol/e2econtrol_test.go index 02daea4ec13..9b68b74162b 100644 --- a/server/internal/e2econtrol/e2econtrol_test.go +++ b/server/internal/e2econtrol/e2econtrol_test.go @@ -16,54 +16,48 @@ import ( "github.com/stretchr/testify/require" goahttp "goa.design/goa/v3/http" - "github.com/speakeasy-api/gram/server/internal/auth/identity" "github.com/speakeasy-api/gram/server/internal/auth/sessions" "github.com/speakeasy-api/gram/server/internal/cache" - "github.com/speakeasy-api/gram/server/internal/constants" "github.com/speakeasy-api/gram/server/internal/demoseed" "github.com/speakeasy-api/gram/server/internal/e2econtrol" "github.com/speakeasy-api/gram/server/internal/testenv" ) const ( - testToken = "zz-e2e-not-a-secret-zz-e2e-not-a-secret" - testEmail = "e2e@example.test" - testOrgID = "org-e2e" - testSite = "https://site.example.test" + testToken = "zz-e2e-not-a-secret-zz-e2e-not-a-secret" + testEmail = "e2e@example.test" + testUserID = "user-e2e" + testOrgID = "org-e2e" + testSite = "https://site.example.test" ) -type fakeIdentity struct { - asked []string - returnedEmail string - organizations []sessions.Organization - options []identity.IDPLoginOptions -} +var ( + testOrg = sessions.Organization{ID: testOrgID, Slug: "e2e-org"} + otherOrg = sessions.Organization{ID: "org-other", Slug: "other"} +) -func (f *fakeIdentity) AuthenticateWithMagicAuth(_ context.Context, email string) (*identity.IDPUserInfo, error) { - f.asked = append(f.asked, email) - if f.returnedEmail != "" { - email = f.returnedEmail - } - return &identity.IDPUserInfo{Sub: "user_idp", Email: email, WorkOSSessionID: "session_idp"}, nil +// fakeUsers is the database: the users it holds, by address. +type fakeUsers struct { + asked []string + users map[string]*sessions.CachedUserInfo } -func (f *fakeIdentity) CompleteIDPLogin(_ context.Context, idpUser *identity.IDPUserInfo, opts identity.IDPLoginOptions) (identity.IDPLoginResult, error) { - f.options = append(f.options, opts) - return identity.IDPLoginResult{ - UserID: "user-gram", - UserInfo: &sessions.CachedUserInfo{UserID: "user-gram", Email: idpUser.Email, Organizations: f.organizations}, - }, nil +func (f *fakeUsers) UserByEmail(_ context.Context, email string) (*sessions.CachedUserInfo, error) { + f.asked = append(f.asked, email) + return f.users[email], nil } type fakeSessions struct { - stored []sessions.Session + issued []sessions.Session enforced bool } func (f *fakeSessions) SignInEnforced(context.Context, string) bool { return f.enforced } -func (f *fakeSessions) StoreSessionIssuedAt(_ context.Context, session sessions.Session, _ time.Time) error { - f.stored = append(f.stored, session) +func (f *fakeSessions) Issue(_ context.Context, w http.ResponseWriter, session sessions.Session, _ time.Time) error { + f.issued = append(f.issued, session) + // The real cookie's attributes are sessions.Manager's, and tested there. + http.SetCookie(w, &http.Cookie{Name: "issued", Value: session.SessionID}) return nil } @@ -71,7 +65,7 @@ type harness struct { mux goahttp.Muxer redis *miniredis.Miniredis links cache.Cache - identity *fakeIdentity + users *fakeUsers sessions *fakeSessions reseeds int reseed func(context.Context) error @@ -82,12 +76,13 @@ func validConfig(t *testing.T, h *harness, site string) e2econtrol.Config { siteURL, err := url.Parse(site) require.NoError(t, err) return e2econtrol.Config{ - Environment: "local", - Token: testToken, - UserEmail: testEmail, - SiteURL: siteURL, - Build: "0123abc", - Tenant: e2econtrol.Tenant{OrganizationID: testOrgID, OrganizationSlug: "e2e-org", ProjectSlug: "default", SeededUserPrefix: "user_e2e_"}, + Token: testToken, + UserEmail: testEmail, + UserID: "", + Confined: false, + SiteURL: siteURL, + Build: "0123abc", + Tenant: e2econtrol.Tenant{OrganizationID: testOrgID, OrganizationSlug: "e2e-org", ProjectSlug: "default", SeededUserPrefix: "user_e2e_"}, Reseed: func(ctx context.Context) error { h.reseeds++ return h.reseed(ctx) @@ -97,6 +92,8 @@ func validConfig(t *testing.T, h *harness, site string) e2econtrol.Config { // newHarness serves the surface for the dashboard origin site, with sign-in // links kept in a real Redis adapter so single use and expiry are the store's. +// Its test user is a platform admin with a second organization, which is what +// a developer is on their own stack. func newHarness(t *testing.T) *harness { t.Helper() mr := miniredis.RunT(t) @@ -107,11 +104,10 @@ func newHarness(t *testing.T) *harness { mux: nil, redis: mr, links: cache.NewRedisCacheAdapter(client), - identity: &fakeIdentity{asked: nil, returnedEmail: "", options: nil, organizations: []sessions.Organization{ - {ID: "org-other", Slug: "other"}, - {ID: testOrgID, Slug: "e2e-org"}, + users: &fakeUsers{asked: nil, users: map[string]*sessions.CachedUserInfo{ + testEmail: {UserID: testUserID, Email: testEmail, Admin: true, Organizations: []sessions.Organization{otherOrg, testOrg}}, }}, - sessions: &fakeSessions{stored: nil, enforced: false}, + sessions: &fakeSessions{issued: nil, enforced: false}, reseeds: 0, reseed: func(context.Context) error { return nil }, } @@ -119,15 +115,15 @@ func newHarness(t *testing.T) *harness { return h } -// serve mounts one more server on the harness's cache, identity provider and -// session store, configured as the default one except for what mutate changes. +// serve mounts one more server on the harness's cache, users and session +// store, configured as the default one except for what mutate changes. func (h *harness) serve(t *testing.T, mutate func(*e2econtrol.Config)) goahttp.Muxer { t.Helper() cfg := validConfig(t, h, testSite) if mutate != nil { mutate(&cfg) } - service, err := e2econtrol.New(testenv.NewLogger(t), cfg, h.identity, h.sessions, h.links) + service, err := e2econtrol.New(testenv.NewLogger(t), cfg, h.users, h.sessions, h.links) require.NoError(t, err) mux := goahttp.NewMuxer() e2econtrol.Attach(mux, service) @@ -156,17 +152,6 @@ func signInLink(t *testing.T, mux goahttp.Muxer) string { return link["path"] } -func TestNewRefusesEveryEnvironmentButLocal(t *testing.T) { - t.Parallel() - - for _, environment := range []string{"prod", "production", "Prod", "dev", "preview", "staging", "test", "Local", " local", ""} { - cfg := validConfig(t, nil, testSite) - cfg.Environment = environment - _, err := e2econtrol.New(testenv.NewLogger(t), cfg, nil, nil, nil) - require.ErrorContains(t, err, "exists only in", "environment %q", environment) - } -} - func TestNewRefusesIncompleteConfiguration(t *testing.T) { t.Parallel() @@ -272,28 +257,23 @@ func TestSignInLinkSignsTheTestUserIntoTheTestOrganizationOnce(t *testing.T) { require.Equal(t, testSite+"/e2e-org", res.Header().Get("Location")) require.Equal(t, "no-store", res.Header().Get("Cache-Control")) require.Equal(t, "no-referrer", res.Header().Get("Referrer-Policy")) - require.Equal(t, []string{testEmail}, h.identity.asked, "only the configured identity is ever signed in") - require.Equal(t, []identity.IDPLoginOptions{{SkipMembershipSync: true, Attribution: nil}}, h.identity.options) + require.Equal(t, []string{testEmail}, h.users.asked, "only the configured user is ever signed in") - require.Len(t, h.sessions.stored, 1) - session := h.sessions.stored[0] - require.Equal(t, "user-gram", session.UserID) + require.Len(t, h.sessions.issued, 1) + session := h.sessions.issued[0] + require.Equal(t, testUserID, session.UserID) require.Equal(t, testOrgID, session.ActiveOrganizationID) - require.Equal(t, "session_idp", session.WorkOSSessionID) + require.Empty(t, session.WorkOSSessionID, "no identity provider took part") require.Empty(t, session.ImpersonatorEmail) require.Empty(t, session.SupportOrganizationID) cookies := res.Result().Cookies() require.Len(t, cookies, 1) - require.Equal(t, constants.SessionCookie, cookies[0].Name) require.Equal(t, session.SessionID, cookies[0].Value) - require.True(t, cookies[0].HttpOnly) - require.True(t, cookies[0].Secure) - require.Equal(t, http.SameSiteLaxMode, cookies[0].SameSite) again := do(t, h.mux, http.MethodGet, path, "") require.Equal(t, http.StatusForbidden, again.Code, "a link is spent on first use") - require.Len(t, h.sessions.stored, 1) + require.Len(t, h.sessions.issued, 1) } func TestSignInLinkExpiresAfterAMinute(t *testing.T) { @@ -307,7 +287,7 @@ func TestSignInLinkExpiresAfterAMinute(t *testing.T) { path = signInLink(t, h.mux) h.redis.FastForward(61 * time.Second) require.Equal(t, http.StatusForbidden, do(t, h.mux, http.MethodGet, path, "").Code) - require.Len(t, h.sessions.stored, 1) + require.Len(t, h.sessions.issued, 1) } func TestSignInLinkStoresNoRedeemableValue(t *testing.T) { @@ -324,7 +304,8 @@ func TestSignInLinkStoresNoRedeemableValue(t *testing.T) { } // A second server sharing the first one's cache does not know a code minted -// for a different dashboard origin, organization or user. +// for a different dashboard origin, organization or user. Previews share one +// cache with each other and with their environment. func TestSignInLinkIsBoundToWhatItWasMintedFor(t *testing.T) { t.Parallel() @@ -343,7 +324,7 @@ func TestSignInLinkIsBoundToWhatItWasMintedFor(t *testing.T) { path := signInLink(t, h.mux) require.Equal(t, http.StatusForbidden, do(t, other, http.MethodGet, path, "").Code) - require.Empty(t, h.identity.asked) + require.Empty(t, h.users.asked) require.Equal(t, http.StatusSeeOther, do(t, h.mux, http.MethodGet, path, "").Code, "the refusal elsewhere did not spend it") }) } @@ -357,53 +338,62 @@ func TestSignInRefusesUnknownCodes(t *testing.T) { // The control token is no substitute for a code. require.Equal(t, http.StatusForbidden, do(t, h.mux, http.MethodGet, path, testToken).Code, path) } - require.Empty(t, h.identity.asked) - require.Empty(t, h.sessions.stored) + require.Empty(t, h.users.asked) + require.Empty(t, h.sessions.issued) } -func TestSignInGivesNoSessionToAnotherIdentity(t *testing.T) { +func TestSignInGivesNoSessionWhereSignInsMustBeRecorded(t *testing.T) { t.Parallel() h := newHarness(t) - h.identity.returnedEmail = "someone-else@example.test" + h.sessions.enforced = true res := do(t, h.mux, http.MethodGet, signInLink(t, h.mux), "") require.Equal(t, http.StatusForbidden, res.Code) - require.Empty(t, h.identity.options, "the login bootstrap never ran for the other identity") - require.Empty(t, h.sessions.stored) - require.Empty(t, res.Result().Cookies()) + require.Empty(t, h.users.asked) + require.Empty(t, h.sessions.issued) } -// The identity provider derives the user from the address as spelled, so the -// spelling the reseed adopted is the one asked for; only the comparison of -// what comes back ignores case. -func TestSignInAsksForTheTestUserAsSpelled(t *testing.T) { +// The user is read when the link is redeemed, so each case is the database as +// it stands then, whatever it was when the server started. +func TestSignInGivesNoSessionUnlessTheUserIsTheTestOrganizationsMember(t *testing.T) { t.Parallel() - h := newHarness(t) - mixed := h.serve(t, func(c *e2econtrol.Config) { c.UserEmail = "Dev.Eloper@Example.test" }) - h.identity.returnedEmail = "dev.eloper@example.test" - - require.Equal(t, http.StatusSeeOther, do(t, mixed, http.MethodGet, signInLink(t, mixed), "").Code) - require.Equal(t, []string{"Dev.Eloper@Example.test"}, h.identity.asked) -} -func TestSignInGivesNoSessionWhereSignInsMustBeRecorded(t *testing.T) { - t.Parallel() - h := newHarness(t) - h.sessions.enforced = true - - res := do(t, h.mux, http.MethodGet, signInLink(t, h.mux), "") - require.Equal(t, http.StatusForbidden, res.Code) - require.Empty(t, h.identity.asked) - require.Empty(t, h.sessions.stored) + cases := map[string]*sessions.CachedUserInfo{ + "no such user": nil, + "not a member": {UserID: testUserID, Email: testEmail, Organizations: []sessions.Organization{otherOrg}}, + "a member of nothing": {UserID: testUserID, Email: testEmail, Organizations: nil}, + "the address of another": {UserID: "user-someone-else", Email: testEmail, Organizations: []sessions.Organization{testOrg}}, + "confined: platform admin": {UserID: testUserID, Email: testEmail, Admin: true, Organizations: []sessions.Organization{testOrg}}, + "confined: a second org": {UserID: testUserID, Email: testEmail, Organizations: []sessions.Organization{testOrg, otherOrg}}, + } + for name, user := range cases { + t.Run(name, func(t *testing.T) { + t.Parallel() + h := newHarness(t) + h.users.users[testEmail] = user + confined := h.serve(t, func(c *e2econtrol.Config) { + c.UserID = testUserID + c.Confined = true + }) + + res := do(t, confined, http.MethodGet, signInLink(t, confined), "") + require.Equal(t, http.StatusForbidden, res.Code) + require.Empty(t, h.sessions.issued) + require.Empty(t, res.Result().Cookies()) + }) + } } -func TestSignInGivesNoSessionOutsideTheTestOrganization(t *testing.T) { +func TestConfinedSignInSignsInTheSoleMember(t *testing.T) { t.Parallel() h := newHarness(t) - h.identity.organizations = []sessions.Organization{{ID: "org-other", Slug: "other"}} + h.users.users[testEmail] = &sessions.CachedUserInfo{UserID: testUserID, Email: testEmail, Organizations: []sessions.Organization{testOrg}} + confined := h.serve(t, func(c *e2econtrol.Config) { + c.UserID = testUserID + c.Confined = true + }) - res := do(t, h.mux, http.MethodGet, signInLink(t, h.mux), "") - require.Equal(t, http.StatusForbidden, res.Code) - require.Empty(t, h.sessions.stored) - require.Empty(t, res.Result().Cookies()) + require.Equal(t, http.StatusSeeOther, do(t, confined, http.MethodGet, signInLink(t, confined), "").Code) + require.Len(t, h.sessions.issued, 1) + require.Equal(t, testOrgID, h.sessions.issued[0].ActiveOrganizationID) } diff --git a/server/internal/e2econtrol/openapi.yaml b/server/internal/e2econtrol/openapi.yaml index b4007641b22..bdb9093ca9e 100644 --- a/server/internal/e2econtrol/openapi.yaml +++ b/server/internal/e2econtrol/openapi.yaml @@ -1,15 +1,16 @@ openapi: 3.1.0 info: title: Speakeasy end-to-end test contract - version: "2" + version: "3" description: >- The operations an end-to-end test run calls outside the browser: the control - surface (server/internal/e2econtrol, local stacks only) and the two public - API reads the suite's root uses to check the seeded state. A test tool pins - this file by its SHA-256, so changing it re-plans the flows that name it. It - is hand-written because the control surface is deliberately absent from the - public API (server/gen/http/openapi3.yaml); the two public reads are the - subset of that file the root needs, kept here so the tool has one contract. + surface (server/internal/e2econtrol), which exists only on a local stack or + a pull request preview that opted in. A test tool pins this file by its + SHA-256, so changing it re-plans the flows that name it. It is hand-written + because the control surface is deliberately absent from the public API + (server/gen/http/openapi3.yaml). One credential, the control token, is all + a run holds: the seeded state is asserted in the dashboard, signed in + through e2e.signInLink. security: - control: [] paths: @@ -63,72 +64,12 @@ paths: properties: path: type: string - /rpc/toolsets.get: - get: - operationId: getToolset - security: - - apiKey: [] - project: [] - parameters: - - name: slug - in: query - required: true - schema: - type: string - responses: - "200": - description: The MCP server (toolset) - content: - application/json: - schema: - type: object - properties: - name: - type: string - slug: - type: string - tools: - type: array - items: - type: object - /rpc/access.listRoles: - get: - operationId: listRoles - security: - - apiKey: [] - responses: - "200": - description: The organization's roles - content: - application/json: - schema: - type: object - properties: - roles: - type: array - items: - type: object - properties: - name: - type: string - slug: - type: string - is_system: - type: boolean components: securitySchemes: control: type: apiKey in: header name: Gram-E2E-Token - apiKey: - type: apiKey - in: header - name: Gram-Key - project: - type: apiKey - in: header - name: Gram-Project schemas: Problem: type: object diff --git a/server/internal/organizations/impl.go b/server/internal/organizations/impl.go index d85a6a1143b..7adf253b9c4 100644 --- a/server/internal/organizations/impl.go +++ b/server/internal/organizations/impl.go @@ -40,7 +40,6 @@ import ( "github.com/speakeasy-api/gram/server/internal/auth/sessions" "github.com/speakeasy-api/gram/server/internal/authz" "github.com/speakeasy-api/gram/server/internal/billing" - "github.com/speakeasy-api/gram/server/internal/constants" "github.com/speakeasy-api/gram/server/internal/contextvalues" "github.com/speakeasy-api/gram/server/internal/conv" "github.com/speakeasy-api/gram/server/internal/email" @@ -1980,7 +1979,7 @@ func (s *Service) handleInviteCallback(w http.ResponseWriter, r *http.Request) { SupportOrganizationID: "", SupportExpiresAt: time.Time{}, } - if err := s.sessions.StoreSessionIssuedAt(ctx, session, authenticatedAt); err != nil { + if err := s.sessions.Issue(ctx, w, session, authenticatedAt); err != nil { s.logger.ErrorContext(ctx, "invite callback: failed to store session", attr.SlogError(err)) span.RecordError(err) redirectError("failed to create session") @@ -1996,16 +1995,6 @@ func (s *Service) handleInviteCallback(w http.ResponseWriter, r *http.Request) { s.logger.WarnContext(ctx, "invite callback: failed to invalidate user info cache", attr.SlogError(err)) } - //nolint:exhaustruct_v5 // only desired fields — avoid unexpected zero-value behavior - http.SetCookie(w, &http.Cookie{ - Name: constants.SessionCookie, - Value: sessionID, - MaxAge: constants.SessionCookieMaxAgeSeconds, - Path: "/", - Secure: true, - HttpOnly: true, - SameSite: http.SameSiteLaxMode, - }) span.AddEvent("invite.callback.cookie_set") s.logger.InfoContext(ctx, "invite callback: complete", attr.SlogUserID(gramUserID), From fdb56b2a56d1917885fd3a8b03676ecbefb71858 Mon Sep 17 00:00:00 2001 From: Thomas Rooney Date: Sat, 21 Nov 2026 13:44:04 +0000 Subject: [PATCH 4/4] chore: end a preview test session at reset commit and never rewrite another user --- server/cmd/gram/deps_e2e.go | 5 ++- server/cmd/gram/deps_e2e_test.go | 2 + server/internal/demoseed/preview.go | 9 ++++- server/internal/demoseed/preview_test.go | 39 +++++++++++++++++++ server/internal/demoseed/queries/preview.sql | 16 ++++---- server/internal/demoseed/repo/preview.sql.go | 25 +++++++----- server/internal/e2econtrol/e2econtrol.go | 6 +++ server/internal/e2econtrol/e2econtrol_test.go | 16 ++++++-- 8 files changed, 95 insertions(+), 23 deletions(-) diff --git a/server/cmd/gram/deps_e2e.go b/server/cmd/gram/deps_e2e.go index 8ae780fd9b3..08c05fd2af9 100644 --- a/server/cmd/gram/deps_e2e.go +++ b/server/cmd/gram/deps_e2e.go @@ -216,14 +216,15 @@ func reseedLocalOrganization(ctx context.Context, logger *slog.Logger, d e2eCont // environment's ClickHouse, so the organization's telemetry pages stay empty. // Every session the test user was issued before the reset ends with it. func reseedPreviewOrganization(ctx context.Context, logger *slog.Logger, d e2eControlDeps, spec demoseed.Spec) error { - started := time.Now() if err := demoseed.Run(ctx, logger, d.db, nil, d.blob, d.encryption, d.issuerURL, d.serverURL.String(), spec); err != nil { return fmt.Errorf("apply seed: %w", err) } if err := demoseed.RunPreviewFixtures(ctx, logger, d.db, d.redis, spec); err != nil { return fmt.Errorf("apply preview fixtures: %w", err) } - if err := d.sessions.RaiseUserEpoch(ctx, spec.PreviewRunner().ID, started); err != nil { + // Taken once the reset is committed, so a sign-in that read the + // organization while it was being rebuilt ends too. + if err := d.sessions.RaiseUserEpoch(ctx, spec.PreviewRunner().ID, time.Now()); err != nil { return fmt.Errorf("end the test user's earlier sessions: %w", err) } return nil diff --git a/server/cmd/gram/deps_e2e_test.go b/server/cmd/gram/deps_e2e_test.go index 0271c932b04..0e40ca84dae 100644 --- a/server/cmd/gram/deps_e2e_test.go +++ b/server/cmd/gram/deps_e2e_test.go @@ -50,6 +50,8 @@ type recordingSessions struct { func (recordingSessions) SignInEnforced(context.Context, string) bool { return false } +func (recordingSessions) InvalidateUserInfoCache(context.Context, string) error { return nil } + func (recordingSessions) Issue(context.Context, http.ResponseWriter, sessions.Session, time.Time) error { return nil } diff --git a/server/internal/demoseed/preview.go b/server/internal/demoseed/preview.go index ad609c48c69..48f5a5c4d59 100644 --- a/server/internal/demoseed/preview.go +++ b/server/internal/demoseed/preview.go @@ -111,7 +111,14 @@ func RunPreviewFixtures(ctx context.Context, logger *slog.Logger, db *pgxpool.Po return q.LocalUpsertEnvironment(ctx, repo.LocalUpsertEnvironmentParams{ID: uuid.MustParse(spec.FixedUUID("0000-4000-a000-000000007004")), OrganizationID: spec.OrgID, ProjectID: projectID}) }}, {"runner", func() error { - return q.PreviewUpsertRunner(ctx, repo.PreviewUpsertRunnerParams{ID: runner.ID, Email: runner.Email, DisplayName: runner.Name, WorkosID: workosID}) + rows, err := q.PreviewUpsertRunner(ctx, repo.PreviewUpsertRunnerParams{ID: runner.ID, Email: runner.Email, DisplayName: runner.Name, WorkosID: workosID}) + switch { + case err != nil: + return fmt.Errorf("upsert runner: %w", err) + case rows != 1: + return errors.New("the runner's id belongs to another user") + } + return nil }}, {"runner membership", func() error { return q.LocalAdoptDeveloper(ctx, repo.LocalAdoptDeveloperParams{OrganizationID: spec.OrgID, UserID: runner.ID, WorkosUserID: workosID}) diff --git a/server/internal/demoseed/preview_test.go b/server/internal/demoseed/preview_test.go index a70b2970553..79e5f1b7345 100644 --- a/server/internal/demoseed/preview_test.go +++ b/server/internal/demoseed/preview_test.go @@ -91,6 +91,45 @@ func TestPreviewFixturesRefuseADatabaseWithoutBuiltInRoles(t *testing.T) { require.ErrorIs(t, err, pgx.ErrNoRows) } +// The runner's id already belonging to someone is a refusal too: their row is +// not rewritten into the runner. +func TestPreviewFixturesDoNotRewriteAnotherUsersRow(t *testing.T) { + t.Parallel() + + ctx := t.Context() + logger := testenv.NewLogger(t) + spec, err := PreviewSpec(126) + require.NoError(t, err) + runner := spec.PreviewRunner() + + db, err := infra.CloneTestDatabase(t, "testdb") + require.NoError(t, err) + neighbour := LocalSpec() + seedLocalPostgres(ctx, t, db, neighbour) + require.NoError(t, RunLocalFixtures(ctx, logger, db, assetstest.NewTestBlobStore(t), nil, LocalFixturesOptions{DeveloperEmail: testDeveloperEmail, Environment: "local"})) + require.NoError(t, demoseedtest.PlantLoginArtifacts(ctx, db, demoseedtest.LoginArtifacts{ + OrgID: "org-someone-else", + OrgWorkOSID: "workos-org-someone-else", + OrgName: "Someone else", + OrgSlug: "someone-else", + UserID: runner.ID, + Email: "someone-else@example.test", + WorkOSID: "workos-user-someone-else", + MembershipID: "membership-someone-else", + })) + seedLocalPostgres(ctx, t, db, spec) + + require.ErrorContains(t, RunPreviewFixtures(ctx, logger, db, nil, spec), "belongs to another user") + + user, err := userrepo.New(db).GetUser(ctx, runner.ID) + require.NoError(t, err) + require.Equal(t, "someone-else@example.test", user.Email) + organizations, err := orgrepo.New(db).ListOrganizationsForUser(ctx, conv.ToPGText(runner.ID)) + require.NoError(t, err) + require.Len(t, organizations, 1) + require.Equal(t, "org-someone-else", organizations[0].ID) +} + // The runner's address already belonging to someone is a refusal, not an // adoption: that user keeps their id and gains no membership. func TestPreviewFixturesDoNotAdoptAnotherUsersAddress(t *testing.T) { diff --git a/server/internal/demoseed/queries/preview.sql b/server/internal/demoseed/queries/preview.sql index 27601d95a0a..9141ca279a7 100644 --- a/server/internal/demoseed/queries/preview.sql +++ b/server/internal/demoseed/queries/preview.sql @@ -6,13 +6,15 @@ -- gram_preview_pr_; the server decides from it whether it is a preview. SELECT current_database()::text; --- name: PreviewUpsertRunner :exec --- The one account an end-to-end test run signs in as. Never platform staff, --- and keyed on id only: an address that already belongs to another user is a --- unique violation, which aborts the fixtures instead of adopting that user. +-- name: PreviewUpsertRunner :execrows +-- The one account an end-to-end test run signs in as. Never platform staff. +-- It only ever creates the runner or restores its own row: an address that +-- already belongs to another user is a unique violation, and an id that +-- already belongs to another address updates nothing, which the caller treats +-- as a refusal. Neither adopts or rewrites somebody else. INSERT INTO users (id, email, display_name, workos_id, admin) VALUES (@id::text, @email::text, @display_name::text, @workos_id::text, FALSE) ON CONFLICT (id) DO UPDATE - SET email = EXCLUDED.email, display_name = EXCLUDED.display_name, - workos_id = EXCLUDED.workos_id, admin = FALSE, deleted_at = NULL, - updated_at = clock_timestamp(); + SET display_name = EXCLUDED.display_name, workos_id = EXCLUDED.workos_id, + admin = FALSE, deleted_at = NULL, updated_at = clock_timestamp() + WHERE users.email = EXCLUDED.email; diff --git a/server/internal/demoseed/repo/preview.sql.go b/server/internal/demoseed/repo/preview.sql.go index a6798d57326..cccfd4b8516 100644 --- a/server/internal/demoseed/repo/preview.sql.go +++ b/server/internal/demoseed/repo/preview.sql.go @@ -25,13 +25,13 @@ func (q *Queries) PreviewCurrentDatabase(ctx context.Context) (string, error) { return column_1, err } -const previewUpsertRunner = `-- name: PreviewUpsertRunner :exec +const previewUpsertRunner = `-- name: PreviewUpsertRunner :execrows INSERT INTO users (id, email, display_name, workos_id, admin) VALUES ($1::text, $2::text, $3::text, $4::text, FALSE) ON CONFLICT (id) DO UPDATE - SET email = EXCLUDED.email, display_name = EXCLUDED.display_name, - workos_id = EXCLUDED.workos_id, admin = FALSE, deleted_at = NULL, - updated_at = clock_timestamp() + SET display_name = EXCLUDED.display_name, workos_id = EXCLUDED.workos_id, + admin = FALSE, deleted_at = NULL, updated_at = clock_timestamp() + WHERE users.email = EXCLUDED.email ` type PreviewUpsertRunnerParams struct { @@ -41,15 +41,20 @@ type PreviewUpsertRunnerParams struct { WorkosID string } -// The one account an end-to-end test run signs in as. Never platform staff, -// and keyed on id only: an address that already belongs to another user is a -// unique violation, which aborts the fixtures instead of adopting that user. -func (q *Queries) PreviewUpsertRunner(ctx context.Context, arg PreviewUpsertRunnerParams) error { - _, err := q.db.Exec(ctx, previewUpsertRunner, +// The one account an end-to-end test run signs in as. Never platform staff. +// It only ever creates the runner or restores its own row: an address that +// already belongs to another user is a unique violation, and an id that +// already belongs to another address updates nothing, which the caller treats +// as a refusal. Neither adopts or rewrites somebody else. +func (q *Queries) PreviewUpsertRunner(ctx context.Context, arg PreviewUpsertRunnerParams) (int64, error) { + result, err := q.db.Exec(ctx, previewUpsertRunner, arg.ID, arg.Email, arg.DisplayName, arg.WorkosID, ) - return err + if err != nil { + return 0, err + } + return result.RowsAffected(), nil } diff --git a/server/internal/e2econtrol/e2econtrol.go b/server/internal/e2econtrol/e2econtrol.go index c68bab59c87..729ab73926d 100644 --- a/server/internal/e2econtrol/e2econtrol.go +++ b/server/internal/e2econtrol/e2econtrol.go @@ -96,6 +96,7 @@ type Users interface { // SessionStore issues the dashboard session. Implemented by sessions.Manager. type SessionStore interface { SignInEnforced(ctx context.Context, organizationID string) bool + InvalidateUserInfoCache(ctx context.Context, userID string) error Issue(ctx context.Context, w http.ResponseWriter, session sessions.Session, issuedAt time.Time) error } @@ -225,6 +226,11 @@ func (s *Service) handleSignIn(w http.ResponseWriter, r *http.Request) error { if reason := s.refusal(user); reason != "" { return oops.E(oops.CodeForbidden, nil, "%s", reason).LogError(ctx, s.logger) } + // Requests are authorized from a cached copy of the user (staff bit, + // organizations). Drop it, so the session is judged by the rows just read. + if err := s.sessions.InvalidateUserInfoCache(ctx, user.UserID); err != nil { + return fmt.Errorf("e2e sign-in: drop cached user: %w", err) + } sessionID, err := sessions.NewSessionID() if err != nil { diff --git a/server/internal/e2econtrol/e2econtrol_test.go b/server/internal/e2econtrol/e2econtrol_test.go index 9b68b74162b..37f0786be86 100644 --- a/server/internal/e2econtrol/e2econtrol_test.go +++ b/server/internal/e2econtrol/e2econtrol_test.go @@ -48,12 +48,21 @@ func (f *fakeUsers) UserByEmail(_ context.Context, email string) (*sessions.Cach } type fakeSessions struct { - issued []sessions.Session - enforced bool + issued []sessions.Session + invalidated []string + enforced bool } func (f *fakeSessions) SignInEnforced(context.Context, string) bool { return f.enforced } +func (f *fakeSessions) InvalidateUserInfoCache(_ context.Context, userID string) error { + // Before the session exists, or its first request could be judged by a stale copy. + if len(f.issued) == 0 { + f.invalidated = append(f.invalidated, userID) + } + return nil +} + func (f *fakeSessions) Issue(_ context.Context, w http.ResponseWriter, session sessions.Session, _ time.Time) error { f.issued = append(f.issued, session) // The real cookie's attributes are sessions.Manager's, and tested there. @@ -107,7 +116,7 @@ func newHarness(t *testing.T) *harness { users: &fakeUsers{asked: nil, users: map[string]*sessions.CachedUserInfo{ testEmail: {UserID: testUserID, Email: testEmail, Admin: true, Organizations: []sessions.Organization{otherOrg, testOrg}}, }}, - sessions: &fakeSessions{issued: nil, enforced: false}, + sessions: &fakeSessions{issued: nil, invalidated: nil, enforced: false}, reseeds: 0, reseed: func(context.Context) error { return nil }, } @@ -260,6 +269,7 @@ func TestSignInLinkSignsTheTestUserIntoTheTestOrganizationOnce(t *testing.T) { require.Equal(t, []string{testEmail}, h.users.asked, "only the configured user is ever signed in") require.Len(t, h.sessions.issued, 1) + require.Equal(t, []string{testUserID}, h.sessions.invalidated, "the cached copy of the user is dropped before the session exists") session := h.sessions.issued[0] require.Equal(t, testUserID, session.UserID) require.Equal(t, testOrgID, session.ActiveOrganizationID)