fix tests, don't emit on page

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

@@ -69,7 +69,7 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
   _closeWasCalled = false;
   private _closeReason: string | undefined;
   private _harRouters: HarRouter[] = [];
-  private _mockingProxy?: MockingProxy;
+  _mockingProxy?: MockingProxy;
 
   static from(context: channels.BrowserContextChannel): BrowserContext {
     return (context as any)._object;

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

@@ -17,6 +17,7 @@ import * as network from './network';
 import type * as channels from '@protocol/channels';
 import { ChannelOwner } from './channelOwner';
 import { APIRequestContext } from './fetch';
+import { Events } from './events';
 
 export class MockingProxy extends ChannelOwner<channels.MockingProxyChannel> {
   private _port: number;
@@ -30,7 +31,7 @@ export class MockingProxy extends ChannelOwner<channels.MockingProxyChannel> {
     this._channel.on('route', (params: channels.MockingProxyRouteEvent) => {
       const route = network.Route.from(params.route);
       route._context = requestContext;
-      this.emit('route', route);
+      this.emit(Events.MockingProxy.Route, route);
     });
   }
 

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

@@ -568,8 +568,6 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
   private async _updateInterceptionPatterns() {
     const patterns = RouteHandler.prepareInterceptionPatterns(this._routes);
     await this._channel.setNetworkInterceptionPatterns({ patterns });
-    for (const proxy of this._browserContext._mockingProxies)
-      await proxy.setInterceptionPatterns({ patterns });
   }
 
   private async _updateWebSocketInterceptionPatterns() {

packages/playwright/src/index.ts

@@ -239,7 +239,7 @@ const playwrightFixtures: Fixtures<TestFixtures, WorkerFixtures> = ({
     if (serviceWorkers !== undefined)
       options.serviceWorkers = serviceWorkers;
     if (_mockingProxy)
-      options.extraHTTPHeaders = { ...options.extraHTTPHeaders, 'x-playwright-proxy-port': String(_mockingProxy.port()) };
+      options.extraHTTPHeaders = { ...options.extraHTTPHeaders, 'x-playwright-proxy': encodeURIComponent(`http://localhost:${_mockingProxy.port()}/`) };
     await use({
       ...contextOptions,
       ...options,

tests/playwright-test/playwright.mockingproxy.spec.ts

@@ -18,7 +18,7 @@ import { test, expect } from './playwright-test-fixtures';
 
 test('inject mode', async ({ runInlineTest, server }) => {
   server.setRoute('/page', (req, res) => {
-    res.end(req.headers['x-pw-proxy-port'] ?? 'no port given');
+    res.end(req.headers['x-playwright-proxy'] ? 'proxy url injected' : 'proxy url missing');
   });
   const result = await runInlineTest({
     'playwright.config.ts': `
@@ -30,12 +30,11 @@ test('inject mode', async ({ runInlineTest, server }) => {
     `,
     'a.test.ts': `
       import { test, expect } from '@playwright/test';
-      test('foo', async ({ server, page, request }) => {
+      test('foo', async ({ page, request }) => {
         await page.goto('${server.PREFIX}/page');
-        expect(await page.textContent('body')).toEqual('' + server.port());
+        expect(await page.textContent('body')).toEqual('proxy url injected');
-
         const response = await request.get('${server.PREFIX}/page');
-        expect(await response.text()).toEqual('' + server.port());
+        expect(await response.text()).toEqual('proxy url injected');
       });
     `
   }, { workers: 1 });
@@ -55,8 +54,7 @@ test('throws on fixed mocking proxy port and parallel workers', async ({ runInli
     `,
     'a.test.ts': `
       import { test, expect } from '@playwright/test';
-      test('foo', async ({ server }) => {
+      test('foo', async ({}) => {});
-      });
     `
   }, { workers: 2 });
 
@@ -64,26 +62,12 @@ test('throws on fixed mocking proxy port and parallel workers', async ({ runInli
   expect(result.output).toContain('Cannot share mocking proxy between multiple workers.');
 });
 
-test('throws on missing config', async ({ runInlineTest }) => {
-  const result = await runInlineTest({
-    'a.test.ts': `
-      import { test, expect } from '@playwright/test';
-      test('foo', async ({ server }) => {
-      });
-    `
-  }, { workers: 2 });
-
-  expect(result.exitCode).toBe(1);
-  expect(result.output).toContain(`The 'server' fixture is only available when 'mockingProxy' is enabled.`);
-});
-
 test('routes are reset between tests', async ({ runInlineTest, server, request }) => {
   server.setRoute('/fallback', async (req, res) => {
     res.end('fallback');
   });
   server.setRoute('/page', async (req, res) => {
-    const port = req.headers['x-pw-proxy-port'];
+    const proxyURL = decodeURIComponent((req.headers['x-playwright-proxy'] as string) ?? '');
-    const proxyURL = `http://localhost:${port}/`;
     const response = await request.get(proxyURL + server.PREFIX + '/fallback');
     res.end(await response.body());
   });
@@ -97,13 +81,13 @@ test('routes are reset between tests', async ({ runInlineTest, server, request }
     `,
     'a.test.ts': `
       import { test, expect } from '@playwright/test';
-      test('first', async ({ server, page, request }) => {
+      test('first', async ({ page, request, context }) => {
-        await server.route('${server.PREFIX}/fallback', route => route.fulfill({ body: 'first' }));
+        await context.route('${server.PREFIX}/fallback', route => route.fulfill({ body: 'first' }));
         await page.goto('${server.PREFIX}/page');
         expect(await page.textContent('body')).toEqual('first');
       });
-      test('second', async ({ server, page, request }) => {
+      test('second', async ({ page, request, context }) => {
-        await server.route('${server.PREFIX}/fallback', route => route.fallback());
+        await context.route('${server.PREFIX}/fallback', route => route.fallback());
         await page.goto('${server.PREFIX}/page');
         expect(await page.textContent('body')).toEqual('fallback');
       });