add events

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

@@ -14,12 +14,13 @@
  * limitations under the License.
  */
 import type { CallMetadata } from '@protocol/callMetadata';
-import type { MockingProxy } from '../mockingProxy';
+import { MockingProxy } from '../mockingProxy';
 import type { RootDispatcher } from './dispatcher';
 import { Dispatcher, existingDispatcher } from './dispatcher';
 import type * as channels from '@protocol/channels';
-import { APIRequestContextDispatcher } from './networkDispatchers';
+import { APIRequestContextDispatcher, RequestDispatcher, ResponseDispatcher, RouteDispatcher } from './networkDispatchers';
 import { urlMatches } from '@isomorphic/urlMatch';
+import type { Request, Response, Route } from '../network';
 
 export class MockingProxyDispatcher extends Dispatcher<MockingProxy, channels.MockingProxyChannel, RootDispatcher> implements channels.MockingProxyChannel {
   _type_MockingProxy = true;
@@ -34,6 +35,33 @@ export class MockingProxyDispatcher extends Dispatcher<MockingProxy, channels.Mo
       port: mockingProxy.port,
       requestContext: APIRequestContextDispatcher.from(scope, mockingProxy.fetchRequest),
     });
+
+    this.addObjectListener(MockingProxy.Events.Route, (route: Route) => {
+      const requestDispatcher = RequestDispatcher.from(this as any, route.request());
+      this._dispatchEvent('route', { route: RouteDispatcher.from(requestDispatcher, route) });
+    });
+    this.addObjectListener(MockingProxy.Events.Request, (request: Request) => {
+      this._dispatchEvent('request', { request: RequestDispatcher.from(this as any, request) });
+    });
+    this.addObjectListener(MockingProxy.Events.RequestFailed, (request: Request) => {
+      this._dispatchEvent('requestFailed', {
+        request: RequestDispatcher.from(this as any, request),
+        responseEndTiming: request._responseEndTiming,
+        failureText: request._failureText ?? undefined
+      });
+    });
+    this.addObjectListener(MockingProxy.Events.Response, (response: Response) => {
+      this._dispatchEvent('response', {
+        request: RequestDispatcher.from(this as any, response.request()),
+        response: ResponseDispatcher.from(this as any, response),
+      });
+    });
+    this.addObjectListener(MockingProxy.Events.RequestFinished, (request: Request) => {
+      this._dispatchEvent('requestFinished', {
+        request: RequestDispatcher.from(this as any, request),
+        responseEndTiming: request._responseEndTiming,
+      });
+    });
   }
 
   async setInterceptionPatterns(params: channels.MockingProxySetInterceptionPatternsParams, metadata?: CallMetadata): Promise<channels.MockingProxySetInterceptionPatternsResult> {

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

@@ -29,6 +29,14 @@ import { pipeline } from 'stream/promises';
 import { Transform } from 'stream';
 
 export class MockingProxy extends SdkObject implements RequestContext {
+  static Events = {
+    Request: 'request',
+    Response: 'response',
+    Route: 'route',
+    RequestFailed: 'requestfailed',
+    RequestFinished: 'requestfinished',
+  };
+
   fetchRequest: APIRequestContext;
   private _matches?: (url: string) => boolean;
   private _httpServer = new WorkerHttpServer();
@@ -130,7 +138,7 @@ export class MockingProxy extends SdkObject implements RequestContext {
             response.setRawResponseHeaders(headers);
             response._securityDetailsFinished(securityDetails);
             response._serverAddrFinished({ ipAddress: address.family === 'IPv6' ? `[${address.address}]` : address.address, port: address.port });
-            this.emit('response', response);
+            this.emit(MockingProxy.Events.Response, response);
 
             try {
               res.writeHead(proxyRes.statusCode!, proxyRes.headers);
@@ -155,18 +163,18 @@ export class MockingProxy extends SdkObject implements RequestContext {
               response.setTransferSize(transferSize);
               response.setEncodedBodySize(encodedBodySize);
               response.setResponseHeadersSize(transferSize - encodedBodySize);
-              this.emit('requestFinished', response);
+              this.emit(MockingProxy.Events.RequestFinished, response);
               resolve();
             } catch (error) {
               request._setFailureText('' + error);
-              this.emit('failed', request);
+              this.emit(MockingProxy.Events.RequestFailed, request);
               resolve();
             }
           });
 
           proxyReq.on('error', error => {
             request._setFailureText('' + error);
-            this.emit('failed', request);
+            this.emit(MockingProxy.Events.RequestFailed, request);
             res.statusCode = 502;
             res.end(resolve);
           });
@@ -194,7 +202,7 @@ export class MockingProxy extends SdkObject implements RequestContext {
     });
 
     if (this._matches?.(req.url!))
-      this.emit('route', { route, request });
+      this.emit(MockingProxy.Events.Route, route);
     else
       await route.continue({ isFallback: false });
   }