feat: page.requests() (#37490)

Author: dgozman

docs/src/api/class-page.md

@@ -3137,6 +3137,13 @@ return value resolves to `[]`.
 * since: v1.9
 
 
+## async method: Page.requests
+* since: v1.56
+- returns: <[Array]<[Request]>>
+
+Returns up to 100 last network request from this page. See [`event: Page.request`] for more details.
+
+
 ## async method: Page.addLocatorHandler
 * since: v1.42
 

packages/playwright-client/types/types.d.ts

@@ -3926,6 +3926,12 @@ export interface Page {
    */
   requestGC(): Promise<void>;
 
+  /**
+   * Returns up to 100 last network request from this page. See
+   * [page.on('request')](https://playwright.dev/docs/api/class-page#page-event-request) for more details.
+   */
+  requests(): Promise<Array<Request>>;
+
   /**
    * Routing provides the capability to modify network requests that are made by a page.
    *

packages/playwright-core/src/client/page.ts

@@ -29,7 +29,7 @@ import { Frame, verifyLoadState } from './frame';
 import { HarRouter } from './harRouter';
 import { Keyboard, Mouse, Touchscreen } from './input';
 import { JSHandle, assertMaxArguments, parseResult, serializeArgument } from './jsHandle';
-import { Response, Route, RouteHandler, WebSocket,  WebSocketRoute, WebSocketRouteHandler, validateHeaders } from './network';
+import { Request, Response, Route, RouteHandler, WebSocket,  WebSocketRoute, WebSocketRouteHandler, validateHeaders } from './network';
 import { Video } from './video';
 import { Waiter } from './waiter';
 import { Worker } from './worker';
@@ -48,7 +48,7 @@ import type { Clock } from './clock';
 import type { APIRequestContext } from './fetch';
 import type { WaitForNavigationOptions } from './frame';
 import type { FrameLocator, Locator, LocatorOptions } from './locator';
-import type { Request, RouteHandlerCallback, WebSocketRouteHandlerCallback } from './network';
+import type { RouteHandlerCallback, WebSocketRouteHandlerCallback } from './network';
 import type { FilePayload, Headers, LifecycleEvent, SelectOption, SelectOptionOptions, Size, TimeoutOptions, WaitForEventOptions, WaitForFunctionOptions } from './types';
 import type * as structs from '../../types/structs';
 import type * as api from '../../types/types';
@@ -804,6 +804,11 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
     return await this._mainFrame.waitForFunction(pageFunction, arg, options);
   }
 
+  async requests() {
+    const { requests } = await this._channel.requests();
+    return requests.map(request => Request.from(request));
+  }
+
   workers(): Worker[] {
     return [...this._workers];
   }

packages/playwright-core/src/protocol/validator.ts

@@ -1481,6 +1481,10 @@ scheme.PagePdfParams = tObject({
 scheme.PagePdfResult = tObject({
   pdf: tBinary,
 });
+scheme.PageRequestsParams = tOptional(tObject({}));
+scheme.PageRequestsResult = tObject({
+  requests: tArray(tChannel(['Request'])),
+});
 scheme.PageSnapshotForAIParams = tObject({
   timeout: tFloat,
 });

packages/playwright-core/src/server/browserContext.ts

@@ -62,6 +62,7 @@ export abstract class BrowserContext extends SdkObject {
     RequestAborted: 'requestaborted',
     RequestFulfilled: 'requestfulfilled',
     RequestContinued: 'requestcontinued',
+    RequestCollected: 'requestcollected',
     BeforeClose: 'beforeclose',
     VideoStarted: 'videostarted',
     RecorderEvent: 'recorderevent',

packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts

@@ -154,6 +154,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
       if (!redirectFromDispatcher && !this._shouldDispatchNetworkEvent(request, 'request') && !request.isNavigationRequest())
         return;
       const requestDispatcher = RequestDispatcher.from(this, request);
+      requestDispatcher.reportedThroughEvent = true;
       this._dispatchEvent('request', {
         request: requestDispatcher,
         page: PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined())
@@ -190,6 +191,11 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
         page: PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined()),
       });
     });
+    this.addObjectListener(BrowserContext.Events.RequestCollected, (request: Request) => {
+      const requestDispatcher = this.connection.existingDispatcher<RequestDispatcher>(request);
+      if (requestDispatcher && !requestDispatcher.reportedThroughEvent)
+        requestDispatcher._dispose('gc');
+    });
     this.addObjectListener(BrowserContext.Events.RecorderEvent, ({ event, data, page, code }: { event: 'actionAdded' | 'actionUpdated' | 'signalAdded', data: any, page: Page, code: string }) => {
       this._dispatchEvent('recorderEvent', { event, data, code, page: PageDispatcher.from(this, page) });
     });

packages/playwright-core/src/server/dispatchers/networkDispatchers.ts

@@ -32,6 +32,7 @@ import type { Progress } from '@protocol/progress';
 export class RequestDispatcher extends Dispatcher<Request, channels.RequestChannel, BrowserContextDispatcher | PageDispatcher | FrameDispatcher> implements channels.RequestChannel {
   _type_Request: boolean;
   private _browserContextDispatcher: BrowserContextDispatcher;
+  reportedThroughEvent = false;
 
   static from(scope: BrowserContextDispatcher, request: Request): RequestDispatcher {
     const result = scope.connection.existingDispatcher<RequestDispatcher>(request);
@@ -48,9 +49,9 @@ export class RequestDispatcher extends Dispatcher<Request, channels.RequestChann
     const frame = request.frame();
     const page = request.frame()?._page;
     const pageDispatcher = page ? scope.connection.existingDispatcher<PageDispatcher>(page) : null;
-    const frameDispatcher = frame ? FrameDispatcher.from(scope, frame) : null;
+    const frameDispatcher = FrameDispatcher.fromNullable(scope, frame);
     super(pageDispatcher || frameDispatcher || scope, request, 'Request', {
-      frame: FrameDispatcher.fromNullable(scope, request.frame()),
+      frame: frameDispatcher,
       serviceWorker: WorkerDispatcher.fromNullable(scope, request.serviceWorker()),
       url: request.url(),
       resourceType: request.resourceType(),

packages/playwright-core/src/server/dispatchers/pageDispatcher.ts

@@ -339,6 +339,10 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
     return { pdf: buffer };
   }
 
+  async requests(params: channels.PageRequestsParams, progress: Progress): Promise<channels.PageRequestsResult> {
+    return { requests: this._page.networkRequests().map(request => RequestDispatcher.from(this.parentScope(), request)) };
+  }
+
   async snapshotForAI(params: channels.PageSnapshotForAIParams, progress: Progress): Promise<channels.PageSnapshotForAIResult> {
     return { snapshot: await this._page.snapshotForAI(progress) };
   }

packages/playwright-core/src/server/frames.ts

@@ -302,6 +302,7 @@ export class FrameManager {
       route?.abort('aborted').catch(() => {});
       return;
     }
+    this._page.addNetworkRequest(request);
     this._page.emitOnContext(BrowserContext.Events.Request, request);
     if (route)
       new network.Route(request, route).handle([...this._page.requestInterceptors, ...this._page.browserContext.requestInterceptors]);

packages/playwright-core/src/server/page.ts

@@ -166,6 +166,7 @@ export class Page extends SdkObject {
   private _locatorHandlers = new Map<number, { selector: string, noWaitAfter?: boolean, resolved?: ManualPromise<void> }>();
   private _lastLocatorHandlerUid = 0;
   private _locatorHandlerRunningCounter = 0;
+  private _networkRequests: network.Request[] = [];
 
   // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
   // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
@@ -350,6 +351,16 @@ export class Page extends SdkObject {
     return this._extraHTTPHeaders;
   }
 
+  addNetworkRequest(request: network.Request) {
+    this._networkRequests.push(request);
+    for (const collected of ensureArrayLimit(this._networkRequests, 100))
+      this.emitOnContext(BrowserContext.Events.RequestCollected, collected);
+  }
+
+  networkRequests() {
+    return this._networkRequests;
+  }
+
   async onBindingCalled(payload: string, context: dom.FrameExecutionContext) {
     if (this._closedState === 'closed')
       return;
@@ -1078,7 +1089,8 @@ async function snapshotFrameForAI(progress: Progress, frame: frames.Frame, frame
   return result;
 }
 
-function ensureArrayLimit(array: any[], limit: number) {
+function ensureArrayLimit<T>(array: T[], limit: number): T[] {
   if (array.length > limit)
-    array.splice(0, limit / 10);
+    return array.splice(0, limit / 10);
+  return [];
 }