| package e2e |
| |
| import ( |
| "encoding/json" |
| "fmt" |
| "net/url" |
| "os" |
| "path/filepath" |
| "regexp" |
| "sort" |
| "strings" |
| "sync" |
| "time" |
| |
| playwright "github.com/mxschmitt/playwright-go" |
| ) |
| |
| type browserRuntime struct { |
| Playwright *playwright.Playwright |
| Browser playwright.Browser |
| mu sync.Mutex |
| closed bool |
| } |
| |
| func startBrowserRuntime() (*browserRuntime, error) { |
| return startBrowserRuntimeOwned(nil) |
| } |
| |
| func startBrowserRuntimeOwned(owner *suiteLifecycle) (*browserRuntime, error) { |
| runtime := &browserRuntime{} |
| if owner != nil && !owner.setBrowser(runtime) { |
| return nil, fmt.Errorf("E2E watchdog fired before browser ownership registration") |
| } |
| pw, err := playwright.Run() |
| if err != nil { |
| return runtime, fmt.Errorf("start Playwright %s: %w; run `make install-e2e-browser` (go run github.com/mxschmitt/playwright-go/cmd/playwright@%s install chromium)", playwrightVersion, err, playwrightVersion) |
| } |
| runtime.mu.Lock() |
| if runtime.closed { |
| runtime.mu.Unlock() |
| _ = pw.Stop() |
| return runtime, fmt.Errorf("E2E cleanup started while launching Playwright") |
| } |
| runtime.Playwright = pw |
| runtime.mu.Unlock() |
| browser, err := pw.Chromium.Launch(playwright.BrowserTypeLaunchOptions{Headless: playwright.Bool(true)}) |
| if err != nil { |
| _ = runtime.Close() |
| return runtime, fmt.Errorf("launch Playwright-managed Chromium: %w; run `make install-e2e-browser`", err) |
| } |
| runtime.mu.Lock() |
| if runtime.closed { |
| runtime.mu.Unlock() |
| _ = browser.Close() |
| return runtime, fmt.Errorf("E2E cleanup started while launching Chromium") |
| } |
| runtime.Browser = browser |
| runtime.mu.Unlock() |
| if got := browser.Version(); got != chromiumVersion { |
| _ = runtime.Close() |
| return runtime, fmt.Errorf("unexpected managed Chromium version %q, want %s (revision %s, Playwright CLI %s)", got, chromiumVersion, chromiumRevision, playwrightCLIVersion) |
| } |
| return runtime, nil |
| } |
| |
| func (r *browserRuntime) Close() error { |
| if r == nil { |
| return nil |
| } |
| r.mu.Lock() |
| if r.closed { |
| r.mu.Unlock() |
| return nil |
| } |
| r.closed = true |
| browser, pw := r.Browser, r.Playwright |
| r.mu.Unlock() |
| var errs []string |
| if browser != nil { |
| if err := browser.Close(); err != nil { |
| errs = append(errs, err.Error()) |
| } |
| } |
| if pw != nil { |
| if err := pw.Stop(); err != nil { |
| errs = append(errs, err.Error()) |
| } |
| } |
| if len(errs) > 0 { |
| return fmt.Errorf("close browser runtime: %s", strings.Join(errs, "; ")) |
| } |
| return nil |
| } |
| |
| type testReporter interface { |
| Name() string |
| Failed() bool |
| Errorf(string, ...any) |
| Cleanup(func()) |
| } |
| |
| type browserSize struct { |
| Width int `json:"width"` |
| Height int `json:"height"` |
| } |
| |
| type browserSessionOptions struct { |
| Viewport browserSize |
| VideoSize browserSize |
| ReducedMotion bool |
| } |
| |
| func defaultBrowserSessionOptions() browserSessionOptions { |
| return browserSessionOptions{ |
| Viewport: browserSize{Width: 1280, Height: 720}, |
| VideoSize: browserSize{Width: 1280, Height: 720}, |
| } |
| } |
| |
| func validateBrowserSessionOptions(options browserSessionOptions) error { |
| if options.Viewport.Width <= 0 || options.Viewport.Height <= 0 { |
| return fmt.Errorf("browser viewport must have positive dimensions") |
| } |
| if options.VideoSize.Width <= 0 || options.VideoSize.Height <= 0 { |
| return fmt.Errorf("browser video must have positive dimensions") |
| } |
| return nil |
| } |
| |
| type browserSession struct { |
| Page playwright.Page |
| Context playwright.BrowserContext |
| t testReporter |
| dir string |
| video playwright.Video |
| started time.Time |
| viewport browserSize |
| videoSize browserSize |
| screenshots []string |
| checkpoint int |
| finalize sync.Once |
| lifecycleMu sync.Mutex |
| forcedFailure bool |
| registry *sessionRegistry |
| browserVer string |
| blockedMu sync.Mutex |
| blocked []string |
| requestsMu sync.Mutex |
| requests []requestMetadata |
| diagnosticsMu sync.Mutex |
| diagnostics []string |
| tracingStarted bool |
| screenshotOp func(string) error |
| stopTraceOp func(string) error |
| closeContextOp func() error |
| saveVideoOp func(string) error |
| finalURLOp func() string |
| } |
| |
| func newBrowserSession(t testReporter, browser playwright.Browser, root string, allowedOrigins []string) (*browserSession, error) { |
| return newBrowserSessionWithOptions(t, browser, root, allowedOrigins, defaultBrowserSessionOptions()) |
| } |
| |
| func newBrowserSessionWithOptions(t testReporter, browser playwright.Browser, root string, allowedOrigins []string, options browserSessionOptions) (*browserSession, error) { |
| if err := validateBrowserSessionOptions(options); err != nil { |
| return nil, err |
| } |
| session, err := newBrowserSessionOwner(t, root, browser.Version()) |
| if err != nil { |
| return nil, err |
| } |
| assignBrowserSessionMetadata(session, options) |
| // Register while holding the construction/finalization lock. A watchdog |
| // either snapshots this ownership and waits here, or rejects construction |
| // before any external Playwright context exists. |
| session.lifecycleMu.Lock() |
| if activeSuiteLifecycle != nil { |
| session.registry = activeSuiteLifecycle.sessions |
| if !session.registry.add(session) { |
| session.lifecycleMu.Unlock() |
| _ = session.finalizeAfterTimeout() |
| return nil, fmt.Errorf("create browser session after E2E watchdog cleanup started") |
| } |
| } |
| defer session.lifecycleMu.Unlock() |
| videoDir := filepath.Join(session.dir, ".video") |
| contextOptions := playwright.BrowserNewContextOptions{ |
| Viewport: &playwright.Size{Width: options.Viewport.Width, Height: options.Viewport.Height}, |
| RecordVideo: &playwright.RecordVideo{Dir: playwright.String(videoDir), Size: &playwright.Size{Width: options.VideoSize.Width, Height: options.VideoSize.Height}}, |
| ServiceWorkers: playwright.ServiceWorkerPolicyBlock, |
| } |
| if options.ReducedMotion { |
| contextOptions.ReducedMotion = playwright.ReducedMotionReduce |
| } |
| context, err := browser.NewContext(contextOptions) |
| if err != nil { |
| return nil, err |
| } |
| session.Context = context |
| if err := context.Tracing().Start(playwright.TracingStartOptions{Screenshots: playwright.Bool(true), Snapshots: playwright.Bool(true), Sources: playwright.Bool(true)}); err != nil { |
| return nil, err |
| } |
| session.tracingStarted = true |
| page, err := context.NewPage() |
| if err != nil { |
| return nil, err |
| } |
| page.SetDefaultTimeout(15_000) |
| page.SetDefaultNavigationTimeout(30_000) |
| page.OnRequest(func(request playwright.Request) { |
| session.recordRequest(request.Method(), 0, request.URL()) |
| }) |
| page.OnResponse(func(response playwright.Response) { |
| session.recordRequest(response.Request().Method(), response.Status(), response.Request().URL()) |
| }) |
| page.OnConsole(func(message playwright.ConsoleMessage) { |
| if message.Type() == "error" && !isExpectedFormStatusConsoleError(message.Text()) { |
| session.recordDiagnostic("console error: " + message.Text()) |
| } |
| }) |
| page.OnPageError(func(err error) { |
| session.recordDiagnostic("page error: " + err.Error()) |
| }) |
| s := session |
| s.Page = page |
| s.video = page.Video() |
| policy := newRoutePolicy(allowedOrigins) |
| if err := context.Route("**/*", func(route playwright.Route) { |
| if policy(route.Request().URL()) { |
| _ = route.Continue() |
| } else { |
| session.recordBlocked(route.Request().URL()) |
| _ = route.Abort("blockedbyclient") |
| } |
| }); err != nil { |
| return nil, err |
| } |
| if err := s.screenshot("00-initial.png"); err != nil { |
| return nil, err |
| } |
| return s, nil |
| } |
| |
| func assignBrowserSessionMetadata(session *browserSession, options browserSessionOptions) { |
| session.viewport = options.Viewport |
| session.videoSize = options.VideoSize |
| } |
| |
| func newBrowserSessionOwner(t testReporter, root, browserVersion string) (*browserSession, error) { |
| dir := filepath.Join(root, sanitizeName(t.Name())) |
| if err := os.MkdirAll(filepath.Join(dir, "screenshots"), 0o700); err != nil { |
| return nil, err |
| } |
| if err := os.MkdirAll(filepath.Join(dir, ".video"), 0o700); err != nil { |
| return nil, err |
| } |
| defaults := defaultBrowserSessionOptions() |
| session := &browserSession{t: t, dir: dir, started: time.Now().UTC(), browserVer: browserVersion, viewport: defaults.Viewport, videoSize: defaults.VideoSize} |
| session.installDefaultArtifactOps() |
| // Own metadata and all available partial artifacts before Playwright context |
| // construction. If Playwright cannot create a context/page/trace, cleanup |
| // records the failure without pretending the unavailable artifacts succeeded. |
| t.Cleanup(func() { |
| if err := session.Finalize(); err != nil { |
| t.Errorf("finalize browser artifacts: %v", err) |
| } |
| }) |
| return session, nil |
| } |
| |
| func newRoutePolicy(allowedOrigins []string) func(string) bool { |
| allowed := make(map[string]struct{}, len(allowedOrigins)) |
| for _, origin := range allowedOrigins { |
| u, err := url.Parse(origin) |
| if err == nil && u.Scheme == "http" && u.Hostname() == "127.0.0.1" && u.Port() != "" && u.Path == "" { |
| allowed[u.Scheme+"://"+u.Host] = struct{}{} |
| } |
| } |
| return func(raw string) bool { |
| u, err := url.Parse(raw) |
| if err != nil || u.Scheme != "http" || u.Hostname() != "127.0.0.1" || u.Port() == "" || u.User != nil { |
| return false |
| } |
| _, ok := allowed[u.Scheme+"://"+u.Host] |
| return ok |
| } |
| } |
| |
| type requestMetadata struct { |
| Method string `json:"method"` |
| Status int `json:"status,omitempty"` |
| Origin string `json:"origin"` |
| Path string `json:"path"` |
| } |
| |
| func sanitizedRequest(method string, status int, raw string) (requestMetadata, bool) { |
| u, err := url.Parse(raw) |
| if err != nil || u.Scheme == "" || u.Host == "" { |
| return requestMetadata{}, false |
| } |
| return requestMetadata{Method: method, Status: status, Origin: u.Scheme + "://" + u.Host, Path: u.EscapedPath()}, true |
| } |
| |
| func (s *browserSession) recordRequest(method string, status int, raw string) { |
| metadata, ok := sanitizedRequest(method, status, raw) |
| if !ok { |
| return |
| } |
| s.requestsMu.Lock() |
| s.requests = append(s.requests, metadata) |
| s.requestsMu.Unlock() |
| } |
| |
| func (s *browserSession) RequestMetadata() []requestMetadata { |
| s.requestsMu.Lock() |
| defer s.requestsMu.Unlock() |
| return append([]requestMetadata(nil), s.requests...) |
| } |
| |
| func (s *browserSession) recordBlocked(raw string) { |
| u, err := url.Parse(raw) |
| if err != nil { |
| return |
| } |
| s.blockedMu.Lock() |
| s.blocked = append(s.blocked, u.Scheme+"://"+u.Host+u.Path) |
| s.blockedMu.Unlock() |
| } |
| |
| func (s *browserSession) BlockedRequests() []string { |
| s.blockedMu.Lock() |
| defer s.blockedMu.Unlock() |
| return sortedStrings(s.blocked) |
| } |
| |
| func isExpectedFormStatusConsoleError(message string) bool { |
| switch message { |
| case "Failed to load resource: the server responded with a status of 409 (Conflict)", |
| "Failed to load resource: the server responded with a status of 422 (Unprocessable Entity)": |
| return true |
| default: |
| return false |
| } |
| } |
| |
| func (s *browserSession) recordDiagnostic(message string) { |
| s.diagnosticsMu.Lock() |
| s.diagnostics = append(s.diagnostics, message) |
| s.diagnosticsMu.Unlock() |
| } |
| |
| func (s *browserSession) BrowserDiagnostics() []string { |
| s.diagnosticsMu.Lock() |
| defer s.diagnosticsMu.Unlock() |
| return append([]string(nil), s.diagnostics...) |
| } |
| |
| func (s *browserSession) Checkpoint(name string) error { |
| s.lifecycleMu.Lock() |
| defer s.lifecycleMu.Unlock() |
| s.checkpoint++ |
| return s.screenshot(fmt.Sprintf("%02d-%s.png", s.checkpoint, sanitizeName(name))) |
| } |
| |
| func (s *browserSession) installDefaultArtifactOps() { |
| s.screenshotOp = func(path string) error { |
| if s.Page == nil { |
| return fmt.Errorf("page unavailable") |
| } |
| _, err := s.Page.Screenshot(playwright.PageScreenshotOptions{Path: playwright.String(path), FullPage: playwright.Bool(true)}) |
| return err |
| } |
| s.stopTraceOp = func(path string) error { |
| if s.Context == nil || !s.tracingStarted { |
| return fmt.Errorf("tracing unavailable") |
| } |
| return s.Context.Tracing().Stop(path) |
| } |
| s.closeContextOp = func() error { |
| if s.Context == nil { |
| return nil |
| } |
| return s.Context.Close() |
| } |
| s.saveVideoOp = func(path string) error { |
| if s.video == nil { |
| return fmt.Errorf("video unavailable") |
| } |
| return s.video.SaveAs(path) |
| } |
| s.finalURLOp = func() string { |
| if s.Page == nil { |
| return "" |
| } |
| return s.Page.URL() |
| } |
| } |
| |
| func (s *browserSession) screenshot(name string) error { |
| path := filepath.Join(s.dir, "screenshots", name) |
| if err := s.screenshotOp(path); err != nil { |
| return err |
| } |
| s.screenshots = append(s.screenshots, name) |
| return nil |
| } |
| |
| func (s *browserSession) Finalize() error { |
| if s.registry != nil { |
| return s.registry.finalizeNormal(s) |
| } |
| return s.finalizeClaimed(false) |
| } |
| |
| func (s *browserSession) finalizeAfterTimeout() error { |
| return s.finalizeClaimed(true) |
| } |
| |
| func (s *browserSession) finalizeClaimed(forcedFailure bool) error { |
| s.lifecycleMu.Lock() |
| defer s.lifecycleMu.Unlock() |
| if forcedFailure { |
| s.forcedFailure = true |
| } |
| var finalErr error |
| s.finalize.Do(func() { |
| var errs []string |
| if err := s.screenshot("99-final.png"); err != nil { |
| errs = append(errs, "final screenshot: "+err.Error()) |
| } |
| if s.t.Failed() || s.forcedFailure { |
| if err := s.screenshot("failure.png"); err != nil { |
| errs = append(errs, "failure screenshot: "+err.Error()) |
| } |
| } |
| if err := s.stopTraceOp(filepath.Join(s.dir, "trace.zip")); err != nil { |
| errs = append(errs, "trace: "+err.Error()) |
| } |
| finalURL := sanitizeFinalURL(s.finalURLOp()) |
| if err := s.closeContextOp(); err != nil { |
| errs = append(errs, "context: "+err.Error()) |
| } |
| if err := s.saveVideoOp(filepath.Join(s.dir, "video.webm")); err != nil { |
| errs = append(errs, "video: "+err.Error()) |
| } else { |
| _ = os.RemoveAll(filepath.Join(s.dir, ".video")) |
| } |
| outcome := "passed" |
| if s.t.Failed() || s.forcedFailure || len(errs) > 0 { |
| outcome = "failed" |
| } |
| metadata := sessionMetadata{TestName: s.t.Name(), StartedAt: s.started, FinishedAt: time.Now().UTC(), Outcome: outcome, BindingVersion: playwrightVersion, CLIVersion: playwrightCLIVersion, ChromiumRevision: chromiumRevision, BrowserVersion: s.browserVer, Viewport: s.viewport, VideoSize: s.videoSize, Screenshots: s.screenshots, FinalURL: finalURL} |
| data, err := json.MarshalIndent(metadata, "", " ") |
| if err == nil { |
| err = os.WriteFile(filepath.Join(s.dir, "session.json"), append(data, '\n'), 0o600) |
| } |
| if err != nil { |
| errs = append(errs, "metadata: "+err.Error()) |
| } |
| if len(errs) > 0 { |
| finalErr = fmt.Errorf("%s", strings.Join(errs, "; ")) |
| } |
| }) |
| return finalErr |
| } |
| |
| func artifactOutcomeExpectation(failedBeforeFinalize, failedAfterFinalize bool) (outcome string, requireFailureScreenshot bool) { |
| if failedBeforeFinalize { |
| return "failed", true |
| } |
| if failedAfterFinalize { |
| return "failed", false |
| } |
| return "passed", false |
| } |
| |
| type sessionMetadata struct { |
| TestName string `json:"test_name"` |
| StartedAt time.Time `json:"started_at"` |
| FinishedAt time.Time `json:"finished_at"` |
| Outcome string `json:"outcome"` |
| BindingVersion string `json:"binding_version"` |
| CLIVersion string `json:"playwright_cli_version"` |
| ChromiumRevision string `json:"chromium_revision"` |
| BrowserVersion string `json:"browser_version"` |
| Viewport browserSize `json:"viewport"` |
| VideoSize browserSize `json:"video_size"` |
| Screenshots []string `json:"screenshots"` |
| FinalURL string `json:"final_url"` |
| } |
| |
| var unsafeName = regexp.MustCompile(`[^A-Za-z0-9._-]+`) |
| |
| func sanitizeName(name string) string { |
| name = strings.Trim(unsafeName.ReplaceAllString(name, "-"), "-.") |
| if name == "" { |
| return "unnamed" |
| } |
| if len(name) > 100 { |
| name = name[:100] |
| } |
| return name |
| } |
| |
| func sanitizeFinalURL(raw string) string { |
| u, err := url.Parse(raw) |
| if err != nil || u.Scheme == "" || u.Host == "" { |
| return "" |
| } |
| u.RawQuery = "" |
| u.Fragment = "" |
| u.User = nil |
| return u.String() |
| } |
| |
| func sortedStrings(values []string) []string { |
| out := append([]string(nil), values...) |
| sort.Strings(out) |
| return out |
| } |