Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

chore: enable service worker networking by default (#37868)

Dmitry Gozman766a93b120ee
diff --git a/docs/src/network.md b/docs/src/network.md
index 6d0c676d6e..7ee76e8c71 100644
--- a/docs/src/network.md
+++ b/docs/src/network.md
@@ -769,6 +769,11 @@ page.WebSocket += (_, ws) =>
Playwright's built-in [`method: BrowserContext.route`] and [`method: Page.route`] allow your tests to natively route requests and perform mocking and interception.
-1. If you're using Playwright's native [`method: BrowserContext.route`] and [`method: Page.route`], and it appears network events are missing, disable Service Workers by setting [`option: Browser.newContext.serviceWorkers`] to `'block'`.
-1. It might be that you are using a mock tool such as Mock Service Worker (MSW). While this tool works out of the box for mocking responses, it adds its own Service Worker that takes over the network requests, hence making them invisible to [`method: BrowserContext.route`] and [`method: Page.route`]. If you are interested in both network testing and mocking, consider using built-in [`method: BrowserContext.route`] and [`method: Page.route`] for [response mocking](#handle-requests).
-1. If you're interested in not solely using Service Workers for testing and network mocking, but in routing and listening for requests made by Service Workers themselves, please see [this experimental feature](https://github.com/microsoft/playwright/issues/15684).
+If you're using Playwright's native [`method: BrowserContext.route`] and [`method: Page.route`], and it appears network events are missing, disable Service Workers by setting [`option: Browser.newContext.serviceWorkers`] to `'block'`.
+
+It might be that you are using a mock tool such as Mock Service Worker (MSW). While this tool works out of the box for mocking responses, it adds its own Service Worker that takes over the network requests, hence making them invisible to [`method: BrowserContext.route`] and [`method: Page.route`]. If you are interested in both network testing and mocking, consider using built-in [`method: BrowserContext.route`] and [`method: Page.route`] for [response mocking](#handle-requests).
+
+######
+* langs: js
+
+If you're interested in not solely using Service Workers for testing and network mocking, but in routing and listening for requests made by Service Workers themselves, please see [this guide](./service-workers.md).
diff --git a/docs/src/service-workers-experimental-network-events-js.md b/docs/src/service-workers-experimental-network-events-js.md
deleted file mode 100644
index 43f32d7e61..0000000000
--- a/docs/src/service-workers-experimental-network-events-js.md
+++ /dev/null
@@ -1,235 +0,0 @@
----
-id: service-workers-experimental
-title: "(Experimental) Service Worker Network Events"
----
-
-## Introduction
-
-:::warning
-If you're looking to do general network mocking, routing, and interception, please see the [Network Guide](./network.md) first. Playwright provides built-in APIs for this use case that don't require the information below. However, if you're interested in requests made by Service Workers themselves, please read below.
-:::
-
-[Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) provide a browser-native method of handling requests made by a page with the native [Fetch API (`fetch`)](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) along with other network-requested assets (like scripts, css, and images).
-
-They can act as a **network proxy** between the page and the external network to perform caching logic or can provide users with an offline experience if the Service Worker adds a [FetchEvent](https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent#examples) listener.
-
-Many sites that use Service Workers simply use them as a transparent optimization technique. While users might notice a faster experience, the app's implementation is unaware of their existence. Running the app with or without Service Workers enabled appears functionally equivalent.
-
-## How to Enable
-
-Playwright's inspection and routing of requests made by Service Workers are **experimental** and disabled by default.
-
-Set the `PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS` environment variable to `1` (or any other value) to enable the feature. Only Chrome/Chromium are currently supported.
-
-If you're using (or are interested in using this feature), please comment on [this issue](https://github.com/microsoft/playwright/issues/15684) letting us know your use case.
-
-## Service Worker Fetch
-
-### Accessing Service Workers and Waiting for Activation
-
-You can use [`method: BrowserContext.serviceWorkers`] to list the Service [Worker]s, or specifically watch for the Service [Worker] if you anticipate a page will trigger its [registration](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register):
-
-```js
-const serviceWorkerPromise = context.waitForEvent('serviceworker');
-await page.goto('/example-with-a-service-worker.html');
-const serviceworker = await serviceWorkerPromise;
-```
-
-[`event: BrowserContext.serviceWorker`] is fired ***before*** the Service Worker's main script has been evaluated, so ***before*** calling service[`method: Worker.evaluate`] you should wait on its activation.
-
-There are more idiomatic methods of waiting for a Service Worker to be activated, but the following is an implementation agnostic method:
-
-```js
-await page.evaluate(async () => {
- const registration = await window.navigator.serviceWorker.getRegistration();
- if (registration.active?.state === 'activated')
- return;
- await new Promise(res =>
- window.navigator.serviceWorker.addEventListener('controllerchange', res),
- );
-});
-```
-
-### Network Events and Routing
-
-Any network request made by the **Service Worker** will have:
-
-* [`event: BrowserContext.request`] and its corresponding events ([`event: BrowserContext.requestFinished`] and [`event: BrowserContext.response`], or [`event: BrowserContext.requestFailed`])
-* [`method: BrowserContext.route`] will see the request
-* [`method: Request.serviceWorker`] will be set to the Service [Worker] instance, and [`method: Request.frame`] will **throw**
-* [`method: Response.fromServiceWorker`] will return `false`
-
-Additionally, any network request made by the **Page** (including its sub-[Frame]s) will have:
-
-* [`event: BrowserContext.request`] and its corresponding events ([`event: BrowserContext.requestFinished`] and [`event: BrowserContext.response`], or [`event: BrowserContext.requestFailed`])
-* [`event: Page.request`] and its corresponding events ([`event: Page.requestFinished`] and [`event: Page.response`], or [`event: Page.requestFailed`])
-* [`method: Page.route`] and [`method: Page.route`] will **not** see the request (if a Service Worker's fetch handler was registered)
-* [`method: Request.serviceWorker`] will be set to `null`, and [`method: Request.frame`] will return the [Frame]
-* [`method: Response.fromServiceWorker`] will return `true` (if a Service Worker's fetch handler was registered)
-
-Many Service Worker implementations simply execute the request from the page (possibly with some custom caching/offline logic omitted for simplicity):
-
-```js title="transparent-service-worker.js"
-self.addEventListener('fetch', event => {
- // actually make the request
- const responsePromise = fetch(event.request);
- // send it back to the page
- event.respondWith(responsePromise);
-});
-
-self.addEventListener('activate', event => {
- event.waitUntil(clients.claim());
-});
-```
-
-If a page registers the above Service Worker:
-
-```html
-<!-- filename: index.html -->
-<script>
- window.registrationPromise = navigator.serviceWorker.register('/transparent-service-worker.js');
-</script>
-```
-
-On the first visit to the page via [`method: Page.goto`], the following Request/Response events would be emitted (along with the corresponding network lifecycle events):
-
-| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |
-| - | - | - | - | - |
-| [`event: BrowserContext.request`] | [Frame] | index.html | Yes | |
-| [`event: Page.request`] | [Frame] | index.html | Yes | |
-| [`event: BrowserContext.request`] | Service [Worker] | transparent-service-worker.js | Yes | |
-| [`event: BrowserContext.request`] | Service [Worker] | data.json | Yes | |
-| [`event: BrowserContext.request`] | [Frame] | data.json | | Yes |
-| [`event: Page.request`] | [Frame] | data.json | | Yes |
-
-
-
-Since the example Service Worker just acts a basic transparent "proxy":
-
-* There's 2 [`event: BrowserContext.request`] events for `data.json`; one [Frame]-owned, the other Service [Worker]-owned.
-* Only the Service [Worker]-owned request for the resource was routable via [`method: BrowserContext.route`]; the [Frame]-owned events for `data.json` are not routeable, as they would not have even had the possibility to hit the external network since the Service Worker has a fetch handler registered.
-
-:::caution
-It's important to note: calling [`method: Request.frame`] or [`method: Response.frame`] will **throw** an exception, if called on a [Request]/[Response] that has a non-null [`method: Request.serviceWorker`].
-:::
-
-
-#### Advanced Example
-
-When a Service Worker handles a page's request, the Service Worker can make 0 to n requests to the external network. The Service Worker might respond directly from a cache, generate a response in memory, rewrite the request, make two requests and then combine into 1, etc.
-
-Consider the code snippets below to understand Playwright's view into the Request/Responses and how it impacts routing in some of these cases.
-
-
-```js title="complex-service-worker.js"
-self.addEventListener('install', function(event) {
- event.waitUntil(
- caches.open('v1').then(function(cache) {
- // 1. Pre-fetches and caches /addressbook.json
- return cache.add('/addressbook.json');
- })
- );
-});
-
-// Opt to handle FetchEvent's from the page
-self.addEventListener('fetch', event => {
- event.respondWith(
- (async () => {
- // 1. Try to first serve directly from caches
- const response = await caches.match(event.request);
- if (response)
- return response;
-
- // 2. Re-write request for /foo to /bar
- if (event.request.url.endsWith('foo'))
- return fetch('./bar');
-
- // 3. Prevent tracker.js from being retrieved, and returns a placeholder response
- if (event.request.url.endsWith('tracker.js')) {
- return new Response('console.log("no trackers!")', {
- status: 200,
- headers: { 'Content-Type': 'text/javascript' },
- });
- }
-
- // 4. Otherwise, fallthrough, perform the fetch and respond
- return fetch(event.request);
- })()
- );
-});
-
-self.addEventListener('activate', event => {
- event.waitUntil(clients.claim());
-});
-```
-
-And a page that simply registers the Service Worker:
-
-```html
-<!-- filename: index.html -->
-<script>
- window.registrationPromise = navigator.serviceWorker.register('/complex-service-worker.js');
-</script>
-```
-
-On the first visit to the page via [`method: Page.goto`], the following Request/Response events would be emitted:
-
-| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |
-| - | - | - | - | - |
-| [`event: BrowserContext.request`] | [Frame] | index.html | Yes | |
-| [`event: Page.request`] | [Frame] | index.html | Yes | |
-| [`event: BrowserContext.request`] | Service [Worker] | complex-service-worker.js | Yes | |
-| [`event: BrowserContext.request`] | Service [Worker] | addressbook.json | Yes | |
-
-It's important to note that [`cache.add`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/add) caused the Service Worker to make a request (Service [Worker]-owned), even before `addressbook.json` was asked for in the page.
-
-Once the Service Worker is activated and handling FetchEvents, if the page makes the following requests:
-
-```js
-await page.evaluate(() => fetch('/addressbook.json'));
-await page.evaluate(() => fetch('/foo'));
-await page.evaluate(() => fetch('/tracker.js'));
-await page.evaluate(() => fetch('/fallthrough.txt'));
-```
-
-The following Request/Response events would be emitted:
-
-| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |
-| - | - | - | - | - |
-| [`event: BrowserContext.request`] | [Frame] | addressbook.json | | Yes |
-| [`event: Page.request`] | [Frame] | addressbook.json | | Yes |
-| [`event: BrowserContext.request`] | Service [Worker] | bar | Yes | |
-| [`event: BrowserContext.request`] | [Frame] | foo | | Yes |
-| [`event: Page.request`] | [Frame] | foo | | Yes |
-| [`event: BrowserContext.request`] | [Frame] | tracker.js | | Yes |
-| [`event: Page.request`] | [Frame] | tracker.js | | Yes |
-| [`event: BrowserContext.request`] | Service [Worker] | fallthrough.txt | Yes | |
-| [`event: BrowserContext.request`] | [Frame] | fallthrough.txt | | Yes |
-| [`event: Page.request`] | [Frame] | fallthrough.txt | | Yes |
-
-It's important to note:
-
-* The page requested `/foo`, but the Service Worker requested `/bar`, so there are only [Frame]-owned events for `/foo`, but not `/bar`.
-* Likewise, the Service Worker never hit the network for `tracker.js`, so only [Frame]-owned events were emitted for that request.
-
-## Routing Service Worker Requests Only
-
-```js
-await context.route('**', async route => {
- if (route.request().serviceWorker()) {
- // NB: calling route.request().frame() here would THROW
- return route.fulfill({
- contentType: 'text/plain',
- status: 200,
- body: 'from sw',
- });
- } else {
- return route.continue();
- }
-});
-```
-
-## Known Limitations
-
-Requests for updated Service Worker main script code currently cannot be routed (https://github.com/microsoft/playwright/issues/14711).
-
diff --git a/docs/src/service-workers-js.md b/docs/src/service-workers-js.md
new file mode 100644
index 0000000000..4db2e32a35
--- /dev/null
+++ b/docs/src/service-workers-js.md
@@ -0,0 +1,132 @@
+---
+id: service-workers
+title: "Service Workers"
+---
+
+## Introduction
+
+:::warning
+Service workers are only supported on Chromium-based browsers.
+:::
+
+
+:::note
+If you're looking to do general network mocking, routing, and interception, please see the [Network Guide](./network.md) first. Playwright provides built-in APIs for this use case that don't require the information below. However, if you're interested in requests made by Service Workers themselves, please read below.
+:::
+
+[Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) provide a browser-native method of handling requests made by a page with the native [Fetch API (`fetch`)](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) along with other network-requested assets (like scripts, css, and images).
+
+They can act as a **network proxy** between the page and the external network to perform caching logic or can provide users with an offline experience if the Service Worker adds a [FetchEvent](https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent#examples) listener.
+
+Many sites that use Service Workers simply use them as a transparent optimization technique. While users might notice a faster experience, the app's implementation is unaware of their existence. Running the app with or without Service Workers enabled appears functionally equivalent.
+
+## How to Disable Service Workers
+
+Playwright allows to disable Service Workers during testing. This makes tests more predictable and performant. However, if your actual page uses a Service Worker, the behavior might be different.
+
+To disable service workers, set [`property: TestOptions.serviceWorkers`] to `'block'`.
+
+```js title="playwright.config.ts"
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+ use: {
+ serviceWorkers: 'allow'
+ },
+});
+```
+
+## Accessing Service Workers and Waiting for Activation
+
+You can use [`method: BrowserContext.serviceWorkers`] to list the Service [Worker]s, or specifically watch for the Service [Worker] if you anticipate a page will trigger its [registration](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register):
+
+```js
+const serviceWorkerPromise = context.waitForEvent('serviceworker');
+await page.goto('/example-with-a-service-worker.html');
+const serviceworker = await serviceWorkerPromise;
+```
+
+[`event: BrowserContext.serviceWorker`] event is fired ***before*** the Service Worker has taken control over the page, so ***before*** evaluating in the worker with [`method: Worker.evaluate`] you should wait on its activation.
+
+There are more idiomatic methods of waiting for a Service Worker to be activated, but the following is an implementation agnostic method:
+
+```js
+await page.evaluate(async () => {
+ const registration = await window.navigator.serviceWorker.getRegistration();
+ if (registration.active?.state === 'activated')
+ return;
+ await new Promise(resolve => {
+ window.navigator.serviceWorker.addEventListener('controllerchange', resolve);
+ });
+});
+```
+
+## Network Events and Routing
+
+Any network request made by the **Service Worker** is reported through the [BrowserContext] object:
+
+* [`event: BrowserContext.request`], [`event: BrowserContext.requestFinished`], [`event: BrowserContext.response`] and [`event: BrowserContext.requestFailed`] are fired
+* [`method: BrowserContext.route`] sees the request
+* [`method: Request.serviceWorker`] will be set to the Service [Worker] instance, and [`method: Request.frame`] will **throw**
+
+Additionally, for any network request made by the **Page**, method [`method: Response.fromServiceWorker`] return `true` when the request was handled a Service Worker's fetch handler.
+
+Consider a simple service worker that fetches every request made by the page:
+
+```js title="transparent-service-worker.js"
+self.addEventListener('fetch', event => {
+ // actually make the request
+ const responsePromise = fetch(event.request);
+ // send it back to the page
+ event.respondWith(responsePromise);
+});
+
+self.addEventListener('activate', event => {
+ event.waitUntil(clients.claim());
+});
+```
+
+If `index.html` registers this service worker, and then fetches `data.json`, the following Request/Response events would be emitted (along with the corresponding network lifecycle events):
+
+| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |
+| - | - | - | - | - |
+| [`event: BrowserContext.request`] | [Frame] | index.html | Yes | |
+| [`event: Page.request`] | [Frame] | index.html | Yes | |
+| [`event: BrowserContext.request`] | Service [Worker] | transparent-service-worker.js | Yes | |
+| [`event: BrowserContext.request`] | Service [Worker] | data.json | Yes | |
+| [`event: BrowserContext.request`] | [Frame] | data.json | | Yes |
+| [`event: Page.request`] | [Frame] | data.json | | Yes |
+
+
+
+Since the example Service Worker just acts a basic transparent "proxy":
+
+* There's 2 [`event: BrowserContext.request`] events for `data.json`; one [Frame]-owned, the other Service [Worker]-owned.
+* Only the Service [Worker]-owned request for the resource was routable via [`method: BrowserContext.route`]; the [Frame]-owned events for `data.json` are not routeable, as they would not have even had the possibility to hit the external network since the Service Worker has a fetch handler registered.
+
+:::caution
+It's important to note: calling [`method: Request.frame`] or [`method: Response.frame`] will **throw** an exception, if called on a [Request]/[Response] that has a non-null [`method: Request.serviceWorker`].
+:::
+
+
+## Routing Service Worker Requests Only
+
+```js
+await context.route('**', async route => {
+ if (route.request().serviceWorker()) {
+ // NB: calling route.request().frame() here would THROW
+ await route.fulfill({
+ contentType: 'text/plain',
+ status: 200,
+ body: 'from sw',
+ });
+ } else {
+ await route.continue();
+ }
+});
+```
+
+## Known Limitations
+
+Requests for updated Service Worker main script code currently cannot be routed (https://github.com/microsoft/playwright/issues/14711).
+
diff --git a/packages/playwright-core/src/server/chromium/crServiceWorker.ts b/packages/playwright-core/src/server/chromium/crServiceWorker.ts
index 23099867c5..31cd981582 100644
--- a/packages/playwright-core/src/server/chromium/crServiceWorker.ts
+++ b/packages/playwright-core/src/server/chromium/crServiceWorker.ts
@@ -31,7 +31,7 @@ export class CRServiceWorker extends Worker {
super(browserContext, url);
this._session = session;
this.browserContext = browserContext;
- if (!!process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS)
+ if (!process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_NETWORK)
this._networkManager = new CRNetworkManager(null, this);
session.once('Runtime.executionContextCreated', event => {
this.createExecutionContext(new CRExecutionContext(session, event.context));
diff --git a/tests/library/chromium/chromium.spec.ts b/tests/library/chromium/chromium.spec.ts
index f254ad3cf0..5c55850bb6 100644
--- a/tests/library/chromium/chromium.spec.ts
+++ b/tests/library/chromium/chromium.spec.ts
@@ -174,461 +174,455 @@ playwrightTest('should pass args with spaces', async ({ browserType, createUserD
expect(userAgent).toBe('I am Foo');
});
-test.describe('PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS=1', () => {
- test.skip(({ mode }) => mode !== 'default', 'Cannot set env variables in non-default');
- test.beforeAll(() => process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS = '1');
- test.afterAll(() => delete process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS);
-
- test('serviceWorker(), and fromServiceWorker() work', async ({ context, page, server }) => {
- const [worker, html, main, inWorker] = await Promise.all([
- context.waitForEvent('serviceworker'),
- context.waitForEvent('request', r => r.url().endsWith('/sw.html')),
- context.waitForEvent('request', r => r.url().endsWith('/sw.js')),
- context.waitForEvent('request', r => r.url().endsWith('/request-from-within-worker.txt')),
- page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html')
- ]);
+test('serviceWorker(), and fromServiceWorker() work', async ({ context, page, server }) => {
+ const [worker, html, main, inWorker] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ context.waitForEvent('request', r => r.url().endsWith('/sw.html')),
+ context.waitForEvent('request', r => r.url().endsWith('/sw.js')),
+ context.waitForEvent('request', r => r.url().endsWith('/request-from-within-worker.txt')),
+ page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html')
+ ]);
- expect(html.frame()).toBeTruthy();
- expect(html.serviceWorker()).toBe(null);
- expect((await html.response()).fromServiceWorker()).toBe(false);
+ expect(html.frame()).toBeTruthy();
+ expect(html.serviceWorker()).toBe(null);
+ expect((await html.response()).fromServiceWorker()).toBe(false);
- expect(main.frame).toThrow();
- expect(main.serviceWorker()).toBe(worker);
- expect((await main.response()).fromServiceWorker()).toBe(false);
+ expect(main.frame).toThrow();
+ expect(main.serviceWorker()).toBe(worker);
+ expect((await main.response()).fromServiceWorker()).toBe(false);
- expect(inWorker.frame).toThrow();
- expect(inWorker.serviceWorker()).toBe(worker);
- expect((await inWorker.response()).fromServiceWorker()).toBe(false);
+ expect(inWorker.frame).toThrow();
+ expect(inWorker.serviceWorker()).toBe(worker);
+ expect((await inWorker.response()).fromServiceWorker()).toBe(false);
- await page.evaluate(() => window['activationPromise']);
- const [innerSW, innerPage] = await Promise.all([
- context.waitForEvent('request', r => r.url().endsWith('/inner.txt') && !!r.serviceWorker()),
- context.waitForEvent('request', r => r.url().endsWith('/inner.txt') && !r.serviceWorker()),
- page.evaluate(() => fetch('/inner.txt')),
- ]);
- expect(innerPage.serviceWorker()).toBe(null);
- expect((await innerPage.response()).fromServiceWorker()).toBe(true);
+ await page.evaluate(() => window['activationPromise']);
+ const [innerSW, innerPage] = await Promise.all([
+ context.waitForEvent('request', r => r.url().endsWith('/inner.txt') && !!r.serviceWorker()),
+ context.waitForEvent('request', r => r.url().endsWith('/inner.txt') && !r.serviceWorker()),
+ page.evaluate(() => fetch('/inner.txt')),
+ ]);
+ expect(innerPage.serviceWorker()).toBe(null);
+ expect((await innerPage.response()).fromServiceWorker()).toBe(true);
- expect(innerSW.serviceWorker()).toBe(worker);
- expect((await innerSW.response()).fromServiceWorker()).toBe(false);
- });
+ expect(innerSW.serviceWorker()).toBe(worker);
+ expect((await innerSW.response()).fromServiceWorker()).toBe(false);
+});
- test('should intercept service worker requests (main and within)', async ({ context, page, server }) => {
- await context.route('**/request-from-within-worker', route =>
- route.fulfill({
- contentType: 'application/json',
- status: 200,
- body: '"intercepted!"',
- })
- );
+test('should intercept service worker requests (main and within)', async ({ context, page, server }) => {
+ await context.route('**/request-from-within-worker', route =>
+ route.fulfill({
+ contentType: 'application/json',
+ status: 200,
+ body: '"intercepted!"',
+ })
+ );
+
+ await context.route('**/sw.js', route =>
+ route.fulfill({
+ contentType: 'text/javascript',
+ status: 200,
+ body: `
+ self.contentPromise = new Promise(res => fetch('/request-from-within-worker').then(r => r.json()).then(res));
+ `,
+ })
+ );
- await context.route('**/sw.js', route =>
- route.fulfill({
- contentType: 'text/javascript',
- status: 200,
- body: `
- self.contentPromise = new Promise(res => fetch('/request-from-within-worker').then(r => r.json()).then(res));
- `,
- })
- );
+ const [sw] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ context.waitForEvent('response', r => r.url().endsWith('/request-from-within-worker')),
+ context.waitForEvent('request', r => r.url().endsWith('sw.js') && !!r.serviceWorker()),
+ context.waitForEvent('response', r => r.url().endsWith('sw.js') && !r.fromServiceWorker()),
+ page.goto(server.PREFIX + '/serviceworkers/empty/sw.html'),
+ ]);
- const [sw] = await Promise.all([
- context.waitForEvent('serviceworker'),
- context.waitForEvent('response', r => r.url().endsWith('/request-from-within-worker')),
- context.waitForEvent('request', r => r.url().endsWith('sw.js') && !!r.serviceWorker()),
- context.waitForEvent('response', r => r.url().endsWith('sw.js') && !r.fromServiceWorker()),
- page.goto(server.PREFIX + '/serviceworkers/empty/sw.html'),
- ]);
+ await expect(sw.evaluate(() => self['contentPromise'])).resolves.toBe('intercepted!');
+});
- await expect(sw.evaluate(() => self['contentPromise'])).resolves.toBe('intercepted!');
+test('should report failure (due to content-type) of main service worker request', async ({ server, page, context, browserMajorVersion }) => {
+ test.skip(browserMajorVersion < 104, 'Requires http://crrev.com/1012503 or later.');
+ server.setRoute('/serviceworkers/fetch/sw.js', (req, res) => {
+ res.writeHead(200, 'OK', { 'Content-Type': 'text/html' });
+ res.write(`console.log('hi from sw');`);
+ res.end();
});
+ const [, main] = await Promise.all([
+ server.waitForRequest('/serviceworkers/fetch/sw.js'),
+ context.waitForEvent('request', r => r.url().endsWith('sw.js')),
+ page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html'),
+ ]);
+ // This will timeout today
+ await main.response();
+});
- test('should report failure (due to content-type) of main service worker request', async ({ server, page, context, browserMajorVersion }) => {
- test.skip(browserMajorVersion < 104, 'Requires http://crrev.com/1012503 or later.');
- server.setRoute('/serviceworkers/fetch/sw.js', (req, res) => {
- res.writeHead(200, 'OK', { 'Content-Type': 'text/html' });
- res.write(`console.log('hi from sw');`);
- res.end();
- });
- const [, main] = await Promise.all([
- server.waitForRequest('/serviceworkers/fetch/sw.js'),
- context.waitForEvent('request', r => r.url().endsWith('sw.js')),
- page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html'),
- ]);
- // This will timeout today
- await main.response();
- });
+test('should report failure (due to redirect) of main service worker request', async ({ server, page, context, browserMajorVersion }) => {
+ test.skip(browserMajorVersion < 104, 'Requires http://crrev.com/1012503 or later.');
+ server.setRedirect('/serviceworkers/empty/sw.js', '/dev/null');
+ const [, main] = await Promise.all([
+ server.waitForRequest('/serviceworkers/empty/sw.js'),
+ context.waitForEvent('request', r => r.url().endsWith('sw.js')),
+ page.goto(server.PREFIX + '/serviceworkers/empty/sw.html'),
+ ]);
+ // This will timeout today
+ const resp = await main.response();
+ expect(resp.status()).toBe(302);
+});
- test('should report failure (due to redirect) of main service worker request', async ({ server, page, context, browserMajorVersion }) => {
- test.skip(browserMajorVersion < 104, 'Requires http://crrev.com/1012503 or later.');
- server.setRedirect('/serviceworkers/empty/sw.js', '/dev/null');
- const [, main] = await Promise.all([
- server.waitForRequest('/serviceworkers/empty/sw.js'),
- context.waitForEvent('request', r => r.url().endsWith('sw.js')),
- page.goto(server.PREFIX + '/serviceworkers/empty/sw.html'),
- ]);
- // This will timeout today
- const resp = await main.response();
- expect(resp.status()).toBe(302);
- });
+test('should intercept service worker importScripts', async ({ context, page, server }) => {
+ await context.route('**/import.js', route =>
+ route.fulfill({
+ contentType: 'text/javascript',
+ status: 200,
+ body: 'self.exportedValue = 47;',
+ })
+ );
+
+ await context.route('**/sw.js', route =>
+ route.fulfill({
+ contentType: 'text/javascript',
+ status: 200,
+ body: `
+ importScripts('/import.js');
+ self.importedValue = self.exportedValue;
+ `,
+ })
+ );
- test('should intercept service worker importScripts', async ({ context, page, server }) => {
- await context.route('**/import.js', route =>
- route.fulfill({
- contentType: 'text/javascript',
- status: 200,
- body: 'self.exportedValue = 47;',
- })
- );
+ const [sw] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ context.waitForEvent('response', r => r.url().endsWith('/import.js')),
+ page.goto(server.PREFIX + '/serviceworkers/empty/sw.html'),
+ ]);
- await context.route('**/sw.js', route =>
- route.fulfill({
- contentType: 'text/javascript',
- status: 200,
- body: `
- importScripts('/import.js');
- self.importedValue = self.exportedValue;
- `,
- })
- );
-
- const [sw] = await Promise.all([
- context.waitForEvent('serviceworker'),
- context.waitForEvent('response', r => r.url().endsWith('/import.js')),
- page.goto(server.PREFIX + '/serviceworkers/empty/sw.html'),
- ]);
+ await expect(sw.evaluate(() => self['importedValue'])).resolves.toBe(47);
+});
- await expect(sw.evaluate(() => self['importedValue'])).resolves.toBe(47);
- });
+test('should report intercepted service worker requests in HAR', async ({ pageWithHar, server }) => {
+ const { context, page, getLog } = await pageWithHar();
+ await context.route('**/request-from-within-worker', route =>
+ route.fulfill({
+ contentType: 'application/json',
+ headers: {
+ 'x-pw-test': 'request-within-worker',
+ },
+ status: 200,
+ body: '"intercepted!"',
+ })
+ );
+
+ await context.route('**/sw.js', route =>
+ route.fulfill({
+ contentType: 'text/javascript',
+ headers: {
+ 'x-pw-test': 'intercepted-main',
+ },
+ status: 200,
+ body: `
+ self.contentPromise = new Promise(res => fetch('/request-from-within-worker').then(r => r.json()).then(res));
+ `,
+ })
+ );
- test('should report intercepted service worker requests in HAR', async ({ pageWithHar, server }) => {
- const { context, page, getLog } = await pageWithHar();
- await context.route('**/request-from-within-worker', route =>
- route.fulfill({
- contentType: 'application/json',
- headers: {
- 'x-pw-test': 'request-within-worker',
- },
- status: 200,
- body: '"intercepted!"',
- })
- );
-
- await context.route('**/sw.js', route =>
- route.fulfill({
- contentType: 'text/javascript',
- headers: {
- 'x-pw-test': 'intercepted-main',
- },
- status: 200,
- body: `
- self.contentPromise = new Promise(res => fetch('/request-from-within-worker').then(r => r.json()).then(res));
- `,
- })
- );
+ const [sw] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ context.waitForEvent('response', r => r.url().endsWith('/request-from-within-worker')),
+ page.goto(server.PREFIX + '/serviceworkers/empty/sw.html'),
+ ]);
- const [sw] = await Promise.all([
- context.waitForEvent('serviceworker'),
- context.waitForEvent('response', r => r.url().endsWith('/request-from-within-worker')),
- page.goto(server.PREFIX + '/serviceworkers/empty/sw.html'),
- ]);
+ await expect(sw.evaluate(() => self['contentPromise'])).resolves.toBe('intercepted!');
- await expect(sw.evaluate(() => self['contentPromise'])).resolves.toBe('intercepted!');
+ const log = await getLog();
+ {
+ const sw = log.entries.filter(e => e.request.url.endsWith('sw.js'));
+ expect.soft(sw).toHaveLength(1);
+ expect.soft(sw[0].response.headers.filter(v => v.name === 'x-pw-test')).toEqual([{ name: 'x-pw-test', value: 'intercepted-main' }]);
+ }
+ {
+ const req = log.entries.filter(e => e.request.url.endsWith('request-from-within-worker'));
+ expect.soft(req).toHaveLength(1);
+ expect.soft(req[0].response.headers.filter(v => v.name === 'x-pw-test')).toEqual([{ name: 'x-pw-test', value: 'request-within-worker' }]);
+ expect.soft(req[0].response.content.text).toBe('"intercepted!"');
+ }
+});
- const log = await getLog();
- {
- const sw = log.entries.filter(e => e.request.url.endsWith('sw.js'));
- expect.soft(sw).toHaveLength(1);
- expect.soft(sw[0].response.headers.filter(v => v.name === 'x-pw-test')).toEqual([{ name: 'x-pw-test', value: 'intercepted-main' }]);
- }
- {
- const req = log.entries.filter(e => e.request.url.endsWith('request-from-within-worker'));
- expect.soft(req).toHaveLength(1);
- expect.soft(req[0].response.headers.filter(v => v.name === 'x-pw-test')).toEqual([{ name: 'x-pw-test', value: 'request-within-worker' }]);
- expect.soft(req[0].response.content.text).toBe('"intercepted!"');
+test('should intercept only serviceworker request, not page', async ({ context, page, server }) => {
+ await context.route('**/data.json', async route => {
+ if (route.request().serviceWorker()) {
+ return route.fulfill({
+ contentType: 'text/plain',
+ status: 200,
+ body: 'from sw',
+ });
+ } else {
+ return route.continue();
}
});
- test('should intercept only serviceworker request, not page', async ({ context, page, server }) => {
- await context.route('**/data.json', async route => {
- if (route.request().serviceWorker()) {
- return route.fulfill({
- contentType: 'text/plain',
- status: 200,
- body: 'from sw',
- });
- } else {
- return route.continue();
- }
- });
+ const [sw] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html'),
+ ]);
+ await page.evaluate(() => window['activationPromise']);
+ const response = await page.evaluate(() => fetch('/data.json').then(r => r.text()));
+ const [url] = await sw.evaluate(() => self['intercepted']);
+ expect(url).toMatch(/\/data\.json$/);
+ expect(response).toBe('from sw');
+});
- const [sw] = await Promise.all([
- context.waitForEvent('serviceworker'),
- page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html'),
- ]);
- await page.evaluate(() => window['activationPromise']);
- const response = await page.evaluate(() => fetch('/data.json').then(r => r.text()));
- const [url] = await sw.evaluate(() => self['intercepted']);
- expect(url).toMatch(/\/data\.json$/);
- expect(response).toBe('from sw');
+test('should produce network events, routing, and annotations for Service Worker', async ({ page, context, server }) => {
+ server.setRoute('/index.html', (req, res) => {
+ res.write(`
+ <script>
+ window.registrationPromise = navigator.serviceWorker.register('/transparent-service-worker.js');
+ </script>
+ `);
+ res.end();
});
+ server.setRoute('/transparent-service-worker.js', (req, res) => {
+ res.writeHead(200, 'OK', { 'Content-Type': 'text/javascript' });
+ res.write(`
+ self.addEventListener("fetch", (event) => {
+ // actually make the request
+ const responsePromise = fetch(event.request);
+ // send it back to the page
+ event.respondWith(responsePromise);
+ });
- test('should produce network events, routing, and annotations for Service Worker', async ({ page, context, server }) => {
- server.setRoute('/index.html', (req, res) => {
- res.write(`
- <script>
- window.registrationPromise = navigator.serviceWorker.register('/transparent-service-worker.js');
- </script>
- `);
- res.end();
- });
- server.setRoute('/transparent-service-worker.js', (req, res) => {
- res.writeHead(200, 'OK', { 'Content-Type': 'text/javascript' });
- res.write(`
- self.addEventListener("fetch", (event) => {
- // actually make the request
- const responsePromise = fetch(event.request);
- // send it back to the page
- event.respondWith(responsePromise);
- });
-
- self.addEventListener("activate", (event) => {
- event.waitUntil(clients.claim());
- });
- `);
- res.end();
- });
+ self.addEventListener("activate", (event) => {
+ event.waitUntil(clients.claim());
+ });
+ `);
+ res.end();
+ });
- const routed = [];
- const formatRequest = async ([scope, r]: ['page' | 'context', any]) => `| ${(scope === 'page' ? '[`event: Page.request`]' : '[`event: BrowserContext.request`]').padEnd('[`event: BrowserContext.request`]'.length, ' ')} | ${r.serviceWorker() ? 'Service [Worker]' : '[Frame]'.padEnd('Service [Worker]'.length, ' ')} | ${r.url().split('/').pop().padEnd(30, ' ')} | ${(routed.includes(r) ? 'Yes' : '').padEnd('Routed'.length, ' ')} | ${((await r.response()).fromServiceWorker() ? 'Yes' : '').padEnd('[`method: Response.fromServiceWorker`]'.length, ' ')} |`;
- await context.route('**', async route => {
- routed.push(route.request());
- await route.continue();
- });
- await page.route('**', async route => {
- routed.push(route.request());
- await route.continue();
- });
- const requests = [];
- page.on('request', r => requests.push(['page', r]));
- context.on('request', r => requests.push(['context', r]));
+ const routed = [];
+ const formatRequest = async ([scope, r]: ['page' | 'context', any]) => `| ${(scope === 'page' ? '[`event: Page.request`]' : '[`event: BrowserContext.request`]').padEnd('[`event: BrowserContext.request`]'.length, ' ')} | ${r.serviceWorker() ? 'Service [Worker]' : '[Frame]'.padEnd('Service [Worker]'.length, ' ')} | ${r.url().split('/').pop().padEnd(30, ' ')} | ${(routed.includes(r) ? 'Yes' : '').padEnd('Routed'.length, ' ')} | ${((await r.response()).fromServiceWorker() ? 'Yes' : '').padEnd('[`method: Response.fromServiceWorker`]'.length, ' ')} |`;
+ await context.route('**', async route => {
+ routed.push(route.request());
+ await route.continue();
+ });
+ await page.route('**', async route => {
+ routed.push(route.request());
+ await route.continue();
+ });
+ const requests = [];
+ page.on('request', r => requests.push(['page', r]));
+ context.on('request', r => requests.push(['context', r]));
- const [sw] = await Promise.all([
- context.waitForEvent('serviceworker'),
- page.goto(server.PREFIX + '/index.html'),
- ]);
+ const [sw] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ page.goto(server.PREFIX + '/index.html'),
+ ]);
+
+ await expect.poll(() => sw.evaluate(() => (self as any).registration.active?.state)).toBe('activated');
+
+ await page.evaluate(() => fetch('/data.json'));
+
+ expect([
+ '| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |',
+ ...await Promise.all(requests.map(formatRequest))])
+ .toEqual([
+ '| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |',
+ '| [`event: BrowserContext.request`] | [Frame] | index.html | Yes | |',
+ '| [`event: Page.request`] | [Frame] | index.html | Yes | |',
+ '| [`event: BrowserContext.request`] | Service [Worker] | transparent-service-worker.js | Yes | |',
+ '| [`event: BrowserContext.request`] | Service [Worker] | data.json | Yes | |',
+ '| [`event: BrowserContext.request`] | [Frame] | data.json | | Yes |',
+ '| [`event: Page.request`] | [Frame] | data.json | | Yes |',
+ ]);
+});
- await expect.poll(() => sw.evaluate(() => (self as any).registration.active?.state)).toBe('activated');
-
- await page.evaluate(() => fetch('/data.json'));
-
- expect([
- '| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |',
- ...await Promise.all(requests.map(formatRequest))])
- .toEqual([
- '| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |',
- '| [`event: BrowserContext.request`] | [Frame] | index.html | Yes | |',
- '| [`event: Page.request`] | [Frame] | index.html | Yes | |',
- '| [`event: BrowserContext.request`] | Service [Worker] | transparent-service-worker.js | Yes | |',
- '| [`event: BrowserContext.request`] | Service [Worker] | data.json | Yes | |',
- '| [`event: BrowserContext.request`] | [Frame] | data.json | | Yes |',
- '| [`event: Page.request`] | [Frame] | data.json | | Yes |',
- ]);
+test('should produce network events, routing, and annotations for Service Worker (advanced)', async ({ page, context, server }) => {
+ server.setRoute('/index.html', (req, res) => {
+ res.write(`
+ <script>
+ window.registrationPromise = navigator.serviceWorker.register('/complex-service-worker.js');
+ </script>
+ `);
+ res.end();
});
+ server.setRoute('/complex-service-worker.js', (req, res) => {
+ res.writeHead(200, 'OK', { 'Content-Type': 'text/javascript' });
+ res.write(`
+ self.addEventListener("install", function (event) {
+ event.waitUntil(
+ caches.open("v1").then(function (cache) {
+ // 1. Pre-fetches and caches /addressbook.json
+ return cache.add("/addressbook.json");
+ })
+ );
+ });
- test('should produce network events, routing, and annotations for Service Worker (advanced)', async ({ page, context, server }) => {
- server.setRoute('/index.html', (req, res) => {
- res.write(`
- <script>
- window.registrationPromise = navigator.serviceWorker.register('/complex-service-worker.js');
- </script>
- `);
- res.end();
- });
- server.setRoute('/complex-service-worker.js', (req, res) => {
- res.writeHead(200, 'OK', { 'Content-Type': 'text/javascript' });
- res.write(`
- self.addEventListener("install", function (event) {
- event.waitUntil(
- caches.open("v1").then(function (cache) {
- // 1. Pre-fetches and caches /addressbook.json
- return cache.add("/addressbook.json");
- })
- );
- });
-
- // Opt to handle FetchEvent's from the page
- self.addEventListener("fetch", (event) => {
- event.respondWith(
- (async () => {
- // 1. Try to first serve directly from caches
- let response = await caches.match(event.request);
- if (response) return response;
-
- // 2. Re-write request for /foo to /bar
- if (event.request.url.endsWith("foo")) return fetch("./bar");
-
- // 3. Prevent tracker.js from being retrieved, and returns a placeholder response
- if (event.request.url.endsWith("tracker.js"))
- return new Response('console.log("no trackers!")', {
- status: 200,
- headers: { "Content-Type": "text/javascript" },
- });
-
- // 4. Otherwise, fallthrough, perform the fetch and respond
- return fetch(event.request);
- })()
- );
- });
-
- self.addEventListener("activate", (event) => {
- event.waitUntil(clients.claim());
- });
- `);
- res.end();
- });
- server.setRoute('/addressbook.json', (req, res) => {
- res.write('{}');
- res.end();
- });
+ // Opt to handle FetchEvent's from the page
+ self.addEventListener("fetch", (event) => {
+ event.respondWith(
+ (async () => {
+ // 1. Try to first serve directly from caches
+ let response = await caches.match(event.request);
+ if (response) return response;
+
+ // 2. Re-write request for /foo to /bar
+ if (event.request.url.endsWith("foo")) return fetch("./bar");
+
+ // 3. Prevent tracker.js from being retrieved, and returns a placeholder response
+ if (event.request.url.endsWith("tracker.js"))
+ return new Response('console.log("no trackers!")', {
+ status: 200,
+ headers: { "Content-Type": "text/javascript" },
+ });
- const routed = [];
- const formatRequest = async ([scope, r]: ['page' | 'context', any]) => `| ${(scope === 'page' ? '[`event: Page.request`]' : '[`event: BrowserContext.request`]').padEnd('[`event: BrowserContext.request`]'.length, ' ')} | ${r.serviceWorker() ? 'Service [Worker]' : '[Frame]'.padEnd('Service [Worker]'.length, ' ')} | ${r.url().split('/').pop().padEnd(30, ' ')} | ${(routed.includes(r) ? 'Yes' : '').padEnd('Routed'.length, ' ')} | ${((await r.response()).fromServiceWorker() ? 'Yes' : '').padEnd('[`method: Response.fromServiceWorker`]'.length, ' ')} |`;
- await context.route('**', async route => {
- routed.push(route.request());
- await route.continue();
- });
- await page.route('**', async route => {
- routed.push(route.request());
- await route.continue();
- });
- const requests = [];
- page.on('request', r => requests.push(['page', r]));
- context.on('request', r => requests.push(['context', r]));
+ // 4. Otherwise, fallthrough, perform the fetch and respond
+ return fetch(event.request);
+ })()
+ );
+ });
- const [sw] = await Promise.all([
- context.waitForEvent('serviceworker'),
- page.goto(server.PREFIX + '/index.html'),
- ]);
+ self.addEventListener("activate", (event) => {
+ event.waitUntil(clients.claim());
+ });
+ `);
+ res.end();
+ });
+ server.setRoute('/addressbook.json', (req, res) => {
+ res.write('{}');
+ res.end();
+ });
- await expect.poll(() => sw.evaluate(() => (self as any).registration.active?.state)).toBe('activated');
-
- await page.evaluate(() => fetch('/addressbook.json'));
- await page.evaluate(() => fetch('/foo'));
- await page.evaluate(() => fetch('/tracker.js'));
- await page.evaluate(() => fetch('/fallthrough.txt'));
-
- expect([
- '| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |',
- ...await Promise.all(requests.map(formatRequest))])
- .toEqual([
- '| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |',
- '| [`event: BrowserContext.request`] | [Frame] | index.html | Yes | |',
- '| [`event: Page.request`] | [Frame] | index.html | Yes | |',
- '| [`event: BrowserContext.request`] | Service [Worker] | complex-service-worker.js | Yes | |',
- '| [`event: BrowserContext.request`] | Service [Worker] | addressbook.json | Yes | |',
- '| [`event: BrowserContext.request`] | [Frame] | addressbook.json | | Yes |',
- '| [`event: Page.request`] | [Frame] | addressbook.json | | Yes |',
- '| [`event: BrowserContext.request`] | Service [Worker] | bar | Yes | |',
- '| [`event: BrowserContext.request`] | [Frame] | foo | | Yes |',
- '| [`event: Page.request`] | [Frame] | foo | | Yes |',
- '| [`event: BrowserContext.request`] | [Frame] | tracker.js | | Yes |',
- '| [`event: Page.request`] | [Frame] | tracker.js | | Yes |',
- '| [`event: BrowserContext.request`] | Service [Worker] | fallthrough.txt | Yes | |',
- '| [`event: BrowserContext.request`] | [Frame] | fallthrough.txt | | Yes |',
- '| [`event: Page.request`] | [Frame] | fallthrough.txt | | Yes |']);
+ const routed = [];
+ const formatRequest = async ([scope, r]: ['page' | 'context', any]) => `| ${(scope === 'page' ? '[`event: Page.request`]' : '[`event: BrowserContext.request`]').padEnd('[`event: BrowserContext.request`]'.length, ' ')} | ${r.serviceWorker() ? 'Service [Worker]' : '[Frame]'.padEnd('Service [Worker]'.length, ' ')} | ${r.url().split('/').pop().padEnd(30, ' ')} | ${(routed.includes(r) ? 'Yes' : '').padEnd('Routed'.length, ' ')} | ${((await r.response()).fromServiceWorker() ? 'Yes' : '').padEnd('[`method: Response.fromServiceWorker`]'.length, ' ')} |`;
+ await context.route('**', async route => {
+ routed.push(route.request());
+ await route.continue();
+ });
+ await page.route('**', async route => {
+ routed.push(route.request());
+ await route.continue();
});
+ const requests = [];
+ page.on('request', r => requests.push(['page', r]));
+ context.on('request', r => requests.push(['context', r]));
- test('should intercept service worker update requests', async ({ context, page, server }) => {
- test.fixme();
- test.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright/issues/14711' });
+ const [sw] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ page.goto(server.PREFIX + '/index.html'),
+ ]);
- let version = 0;
- server.setRoute('/worker.js', (req, res) => {
- res.writeHead(200, 'OK', { 'Content-Type': 'text/javascript' });
- res.write(`self.PW_VERSION = ${version++};`);
- res.end();
- });
+ await expect.poll(() => sw.evaluate(() => (self as any).registration.active?.state)).toBe('activated');
+
+ await page.evaluate(() => fetch('/addressbook.json'));
+ await page.evaluate(() => fetch('/foo'));
+ await page.evaluate(() => fetch('/tracker.js'));
+ await page.evaluate(() => fetch('/fallthrough.txt'));
+
+ expect([
+ '| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |',
+ ...await Promise.all(requests.map(formatRequest))])
+ .toEqual([
+ '| Event | Owner | URL | Routed | [`method: Response.fromServiceWorker`] |',
+ '| [`event: BrowserContext.request`] | [Frame] | index.html | Yes | |',
+ '| [`event: Page.request`] | [Frame] | index.html | Yes | |',
+ '| [`event: BrowserContext.request`] | Service [Worker] | complex-service-worker.js | Yes | |',
+ '| [`event: BrowserContext.request`] | Service [Worker] | addressbook.json | Yes | |',
+ '| [`event: BrowserContext.request`] | [Frame] | addressbook.json | | Yes |',
+ '| [`event: Page.request`] | [Frame] | addressbook.json | | Yes |',
+ '| [`event: BrowserContext.request`] | Service [Worker] | bar | Yes | |',
+ '| [`event: BrowserContext.request`] | [Frame] | foo | | Yes |',
+ '| [`event: Page.request`] | [Frame] | foo | | Yes |',
+ '| [`event: BrowserContext.request`] | [Frame] | tracker.js | | Yes |',
+ '| [`event: Page.request`] | [Frame] | tracker.js | | Yes |',
+ '| [`event: BrowserContext.request`] | Service [Worker] | fallthrough.txt | Yes | |',
+ '| [`event: BrowserContext.request`] | [Frame] | fallthrough.txt | | Yes |',
+ '| [`event: Page.request`] | [Frame] | fallthrough.txt | | Yes |']);
+});
- server.setRoute('/home', (req, res) => {
- res.write(`
- <!DOCTYPE html>
- <html>
- <head>
- <title>Service Worker Update Demo</title>
- </head>
- <body>
- <button id="update" disabled>update service worker</button>
- <script>
- const updateBtn = document.getElementById('update');
- updateBtn.addEventListener('click', evt => {
- evt.preventDefault();
- registration.then(r => r.update());
- });
+test('should intercept service worker update requests', async ({ context, page, server }) => {
+ test.fixme();
+ test.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright/issues/14711' });
- const registration = new Promise(r => navigator.serviceWorker.register('/worker.js').then(r));
- registration.then(() => updateBtn.disabled = false);
- </script>
- </body>
- </html>
- `);
- res.end();
- });
+ let version = 0;
+ server.setRoute('/worker.js', (req, res) => {
+ res.writeHead(200, 'OK', { 'Content-Type': 'text/javascript' });
+ res.write(`self.PW_VERSION = ${version++};`);
+ res.end();
+ });
- const [sw] = await Promise.all([
- context.waitForEvent('serviceworker'),
- page.goto(server.PREFIX + '/home'),
- ]);
+ server.setRoute('/home', (req, res) => {
+ res.write(`
+ <!DOCTYPE html>
+ <html>
+ <head>
+ <title>Service Worker Update Demo</title>
+ </head>
+ <body>
+ <button id="update" disabled>update service worker</button>
+ <script>
+ const updateBtn = document.getElementById('update');
+ updateBtn.addEventListener('click', evt => {
+ evt.preventDefault();
+ registration.then(r => r.update());
+ });
- await expect.poll(() => sw.evaluate(() => self['PW_VERSION'])).toBe(0);
+ const registration = new Promise(r => navigator.serviceWorker.register('/worker.js').then(r));
+ registration.then(() => updateBtn.disabled = false);
+ </script>
+ </body>
+ </html>
+ `);
+ res.end();
+ });
- // Before triggering, let's intercept the update request
- await context.route('**/worker.js', async route => {
- await route.fulfill({
- status: 200,
- body: `self.PW_VERSION = "intercepted";`,
- contentType: 'text/javascript',
- });
- });
+ const [sw] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ page.goto(server.PREFIX + '/home'),
+ ]);
- const [updatedSW] = await Promise.all([
- context.waitForEvent('serviceworker'),
- // currently times out here
- context.waitForEvent('request', r => r.url().endsWith('worker.js')),
- page.click('#update'),
- ]);
+ await expect.poll(() => sw.evaluate(() => self['PW_VERSION'])).toBe(0);
- await expect.poll(() => updatedSW.evaluate(() => self['PW_VERSION'])).toBe('intercepted');
+ // Before triggering, let's intercept the update request
+ await context.route('**/worker.js', async route => {
+ await route.fulfill({
+ status: 200,
+ body: `self.PW_VERSION = "intercepted";`,
+ contentType: 'text/javascript',
+ });
});
- test('setOffline', async ({ context, page, server }) => {
- const [worker] = await Promise.all([
- context.waitForEvent('serviceworker'),
- page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html')
- ]);
+ const [updatedSW] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ // currently times out here
+ context.waitForEvent('request', r => r.url().endsWith('worker.js')),
+ page.click('#update'),
+ ]);
- await page.evaluate(() => window['activationPromise']);
- await context.setOffline(true);
- const [, error] = await Promise.all([
- context.waitForEvent('request', r => r.url().endsWith('/inner.txt') && !!r.serviceWorker()),
- worker.evaluate(() => fetch('/inner.txt').catch(e => `REJECTED: ${e}`)),
- ]);
- expect(error).toMatch(/REJECTED.*Failed to fetch/);
- });
+ await expect.poll(() => updatedSW.evaluate(() => self['PW_VERSION'])).toBe('intercepted');
+});
- test('setExtraHTTPHeaders', async ({ context, page, server }) => {
- const [worker] = await Promise.all([
- context.waitForEvent('serviceworker'),
- page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html')
- ]);
+test('setOffline', async ({ context, page, server }) => {
+ const [worker] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html')
+ ]);
- await page.evaluate(() => window['activationPromise']);
- await context.setExtraHTTPHeaders({ 'x-custom-header': 'custom!' });
- const requestPromise = server.waitForRequest('/inner.txt');
- await worker.evaluate(() => fetch('/inner.txt'));
- const req = await requestPromise;
- expect(req.headers['x-custom-header']).toBe('custom!');
- });
+ await page.evaluate(() => window['activationPromise']);
+ await context.setOffline(true);
+ const [, error] = await Promise.all([
+ context.waitForEvent('request', r => r.url().endsWith('/inner.txt') && !!r.serviceWorker()),
+ worker.evaluate(() => fetch('/inner.txt').catch(e => `REJECTED: ${e}`)),
+ ]);
+ expect(error).toMatch(/REJECTED.*Failed to fetch/);
+});
+
+test('setExtraHTTPHeaders', async ({ context, page, server }) => {
+ const [worker] = await Promise.all([
+ context.waitForEvent('serviceworker'),
+ page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html')
+ ]);
+
+ await page.evaluate(() => window['activationPromise']);
+ await context.setExtraHTTPHeaders({ 'x-custom-header': 'custom!' });
+ const requestPromise = server.waitForRequest('/inner.txt');
+ await worker.evaluate(() => fetch('/inner.txt'));
+ const req = await requestPromise;
+ expect(req.headers['x-custom-header']).toBe('custom!');
});
test('should throw when connecting twice to an already running persistent context (--remote-debugging-port)', async ({ browserType, createUserDataDir, platform, isHeadlessShell }) => {
@@ -660,3 +654,33 @@ test('should throw when connecting twice to an already running persistent contex
await browser.close();
}
});
+
+test('PLAYWRIGHT_DISABLE_SERVICE_WORKER_NETWORK', async ({ mode, context, page, server }) => {
+ test.skip(mode !== 'default', 'no env in non-default mode');
+ process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_NETWORK = '1';
+
+ const urls = [];
+ context.on('request', r => {
+ expect(r.serviceWorker()).toBe(null);
+ urls.push(r.url());
+ });
+
+ await Promise.all([
+ context.waitForEvent('serviceworker'),
+ page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html')
+ ]);
+ expect(urls).toEqual([
+ server.PREFIX + '/serviceworkers/fetch/sw.html',
+ server.PREFIX + '/serviceworkers/fetch/style.css',
+ ]);
+
+ await page.evaluate(() => window['activationPromise']);
+ await page.evaluate(() => fetch('./inner.txt'));
+ expect(urls).toEqual([
+ server.PREFIX + '/serviceworkers/fetch/sw.html',
+ server.PREFIX + '/serviceworkers/fetch/style.css',
+ server.PREFIX + '/serviceworkers/fetch/inner.txt',
+ ]);
+
+ delete process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_NETWORK;
+});
diff --git a/tests/library/chromium/extensions.spec.ts b/tests/library/chromium/extensions.spec.ts
index feb88267f4..a54719e33e 100644
--- a/tests/library/chromium/extensions.spec.ts
+++ b/tests/library/chromium/extensions.spec.ts
@@ -70,8 +70,6 @@ it.describe('MV3', () => {
});
it('should support request/response events in the service worker', async ({ launchPersistentContext, asset, server }) => {
- it.fixme(true, 'Waiting for https://issues.chromium.org/u/1/issues/407795731 getting fixed.');
- process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS = '1';
server.setRoute('/empty.html', (req, res) => {
res.writeHead(200, { 'Content-Type': 'text/html', 'x-response-foobar': 'BarFoo' });
res.end(`<span>hello world!</span>`);
@@ -102,7 +100,6 @@ it.describe('MV3', () => {
expect(await response.allHeaders()).toEqual(expect.objectContaining({ 'x-response-foobar': 'BarFoo' }));
await context.close();
- delete process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS;
});
it('should report console messages from content script', {