test: update Electron to v30

package.json

@@ -82,7 +82,7 @@
  "concurrently": "^6.2.1",
  "cross-env": "^7.0.3",
  "dotenv": "^16.0.0",
- "electron": "19.0.11",
+ "electron": "^30.1.2",
  "enquirer": "^2.3.6",
  "esbuild": "^0.18.11",
  "eslint": "^8.55.0",

tests/library/browsercontext-storage-state.spec.ts

@@ -223,9 +223,8 @@ it('should serialize storageState with lone surrogates', async ({ page, context,
  expect(storageState.origins[0].localStorage[0].value).toBe(String.fromCharCode(55934));
 });
 
-it('should work when service worker is intefering', async ({ page, context, server, isAndroid, isElectron }) => {
+it('should work when service worker is intefering', async ({ page, context, server, isAndroid }) => {
  it.skip(isAndroid);
- it.skip(isElectron);
 
  server.setRoute('/', (req, res) => {
  res.writeHead(200, { 'content-type': 'text/html' });

tests/library/page-event-crash.spec.ts

@@ -70,9 +70,8 @@ test('should cancel navigation when page crashes', async ({ server, page, crash
  expect(error.message).toContain('page.goto: Page crashed');
 });
 
-test('should be able to close context when page crashes', async ({ isAndroid, isElectron, isWebView2, page, crash }) => {
+test('should be able to close context when page crashes', async ({ isAndroid, isWebView2, page, crash }) => {
  test.skip(isAndroid);
- test.skip(isElectron);
  test.skip(isWebView2, 'Page.close() is not supported in WebView2');
 
  await page.setContent(`<div>This page should crash</div>`);

tests/page/expect-boolean.spec.ts

@@ -455,7 +455,6 @@ test('should print selector syntax error', async ({ page }) => {
 
 test.describe(() => {
  test.skip(({ isAndroid }) => isAndroid, 'server.EMPTY_PAGE is the emulator address 10.0.2.2');
- test.skip(({ isElectron }) => isElectron, 'Protocol error (Storage.getCookies): Browser context management is not supported.');
 
  test('toBeOK', async ({ page, server }) => {
  const res = await page.request.get(server.EMPTY_PAGE);

tests/page/interception.spec.ts

@@ -33,9 +33,8 @@ it('should work with navigation @smoke', async ({ page, server }) => {
  expect(requests.get('style.css').isNavigationRequest()).toBe(false);
 });
 
-it('should intercept after a service worker', async ({ page, server, browserName, isAndroid, isElectron }) => {
+it('should intercept after a service worker', async ({ page, server, browserName, isAndroid }) => {
  it.skip(isAndroid);
- it.skip(isElectron);
 
  await page.goto(server.PREFIX + '/serviceworkers/fetchdummy/sw.html');
  await page.evaluate(() => window['activationPromise']);

tests/page/page-event-request.spec.ts

@@ -107,9 +107,8 @@ it('should report requests and responses handled by service worker with routing'
  expect(interceptedUrls).toEqual(expectedUrls);
 });
 
-it('should report navigation requests and responses handled by service worker', async ({ page, server, isAndroid, isElectron, browserName }) => {
+it('should report navigation requests and responses handled by service worker', async ({ page, server, isAndroid, browserName }) => {
  it.fixme(isAndroid);
- it.fixme(isElectron);
 
  await page.goto(server.PREFIX + '/serviceworkers/stub/sw.html');
  await page.evaluate(() => window['activationPromise']);
@@ -136,9 +135,8 @@ it('should report navigation requests and responses handled by service worker',
  }
 });
 
-it('should report navigation requests and responses handled by service worker with routing', async ({ page, server, isAndroid, isElectron, browserName }) => {
+it('should report navigation requests and responses handled by service worker with routing', async ({ page, server, isAndroid, browserName }) => {
  it.fixme(isAndroid);
- it.fixme(isElectron);
 
  await page.route('**/*', route => route.continue());
  await page.goto(server.PREFIX + '/serviceworkers/stub/sw.html');

tests/page/page-goto.spec.ts

@@ -685,8 +685,7 @@ it('should fail when canceled by another navigation', async ({ page, server }) =
  expect(error.message).toBeTruthy();
 });
 
-it('should work with lazy loading iframes', async ({ page, server, isElectron, isAndroid }) => {
- it.fixme(isElectron);
+it('should work with lazy loading iframes', async ({ page, server, isAndroid }) => {
  it.fixme(isAndroid);
 
  await page.goto(server.PREFIX + '/frames/lazy-frame.html');

tests/page/page-network-request.spec.ts

@@ -88,8 +88,7 @@ it('should return headers', async ({ page, server, browserName }) => {
  expect(response.request().headers()['user-agent']).toContain('WebKit');
 });
 
-it('should get the same headers as the server', async ({ page, server, browserName, platform, isElectron, browserMajorVersion }) => {
- it.skip(isElectron && browserMajorVersion < 99, 'This needs Chromium >= 99');
+it('should get the same headers as the server', async ({ page, server, browserName, platform }) => {
  it.fail(browserName === 'webkit' && platform === 'win32', 'Curl does not show accept-encoding and accept-language');
  let serverRequest;
  server.setRoute('/empty.html', (request, response) => {
@@ -101,8 +100,7 @@ it('should get the same headers as the server', async ({ page, server, browserNa
  expect(headers).toEqual(adjustServerHeaders(serverRequest.headers, browserName));
 });
 
-it('should not return allHeaders() until they are available', async ({ page, server, browserName, platform, isElectron, browserMajorVersion }) => {
- it.skip(isElectron && browserMajorVersion < 99, 'This needs Chromium >= 99');
+it('should not return allHeaders() until they are available', async ({ page, server, browserName, platform }) => {
  it.fail(browserName === 'webkit' && platform === 'win32', 'Curl does not show accept-encoding and accept-language');
 
  let requestHeadersPromise;
@@ -126,8 +124,7 @@ it('should not return allHeaders() until they are available', async ({ page, ser
  expect(responseHeaders['foo']).toBe('bar');
 });
 
-it('should get the same headers as the server CORS', async ({ page, server, browserName, platform, isElectron, browserMajorVersion, }) => {
- it.skip(isElectron && browserMajorVersion < 99, 'This needs Chromium >= 99');
+it('should get the same headers as the server CORS', async ({ page, server, browserName, platform }) => {
  it.fail(browserName === 'webkit' && platform === 'win32', 'Curl does not show accept-encoding and accept-language');
 
  await page.goto(server.PREFIX + '/empty.html');
@@ -384,9 +381,7 @@ it('should return navigation bit when navigating to image', async ({ page, serve
  expect(requests[0].isNavigationRequest()).toBe(true);
 });
 
-it('should report raw headers', async ({ page, server, browserName, platform, isElectron, browserMajorVersion, channel }) => {
- it.skip(isElectron && browserMajorVersion < 99, 'This needs Chromium >= 99');
-
+it('should report raw headers', async ({ page, server, browserName, platform }) => {
  let expectedHeaders: { name: string, value: string }[];
  server.setRoute('/headers', (req, res) => {
  expectedHeaders = [];
@@ -455,8 +450,7 @@ it('should report raw response headers in redirects', async ({ page, server, bro
  expect(headersChain).toEqual(expectedHeaders);
 });
 
-it('should report all cookies in one header', async ({ page, server, isElectron, browserMajorVersion }) => {
- it.skip(isElectron && browserMajorVersion < 99, 'This needs Chromium >= 99');
+it('should report all cookies in one header', async ({ page, server }) => {
 
  const expectedHeaders = {};
  server.setRoute('/headers', (req, res) => {

tests/page/page-network-response.spec.ts

@@ -178,8 +178,7 @@ it('should return status text', async ({ page, server }) => {
  expect(response.statusText()).toBe('cool!');
 });
 
-it('should report all headers', async ({ page, server, browserName, platform, isElectron, browserMajorVersion }) => {
- it.skip(isElectron && browserMajorVersion < 99, 'This needs Chromium >= 99');
+it('should report all headers', async ({ page, server, browserName, platform }) => {
  it.skip(browserName === 'webkit' && platform === 'win32', 'libcurl does not support non-set-cookie multivalue headers');
 
  const expectedHeaders = {
@@ -214,8 +213,7 @@ it('should report all headers', async ({ page, server, browserName, platform, is
  expect(actualHeaders).toEqual(expectedHeaders);
 });
 
-it('should report multiple set-cookie headers', async ({ page, server, isElectron, browserMajorVersion }) => {
- it.skip(isElectron && browserMajorVersion < 99, 'This needs Chromium >= 99');
+it('should report multiple set-cookie headers', async ({ page, server }) => {
 
  server.setRoute('/headers', (req, res) => {
  res.writeHead(200, {
@@ -270,14 +268,14 @@ it('should behave the same way for headers and allHeaders', async ({ page, serve
  expect(allHeaders['name-b']).toEqual('v4');
 });
 
-it('should provide a Response with a file URL', async ({ page, asset, isAndroid, isElectron, isWindows, browserName, browserMajorVersion, mode }) => {
+it('should provide a Response with a file URL', async ({ page, asset, isAndroid, isWindows, browserName, browserMajorVersion, mode }) => {
  it.skip(isAndroid, 'No files on Android');
  it.skip(browserName === 'firefox', 'Firefox does return null for file:https:// URLs');
  it.skip(mode.startsWith('service'));
 
  const fileurl = url.pathToFileURL(asset('frames/two-frames.html')).href;
  const response = await page.goto(fileurl);
- if (isElectron || (browserName === 'chromium' && browserMajorVersion >= 99) || (browserName === 'webkit' && isWindows))
+ if ((browserName === 'chromium' && browserMajorVersion >= 99) || (browserName === 'webkit' && isWindows))
  expect(response.status()).toBe(200);
  else
  expect(response.status()).toBe(0);
@@ -322,8 +320,8 @@ it('should return headers after route.fulfill', async ({ page, server }) => {
  });
 });
 
-it('should report if request was fromServiceWorker', async ({ page, server, isAndroid, isElectron }) => {
- it.skip(isAndroid || isElectron);
+it('should report if request was fromServiceWorker', async ({ page, server, isAndroid }) => {
+ it.skip(isAndroid);
  {
  const res = await page.goto(server.PREFIX + '/serviceworkers/fetch/sw.html');
  expect(res.fromServiceWorker()).toBe(false);

tests/page/page-network-sizes.spec.ts

@@ -20,8 +20,6 @@ import zlib from 'zlib';
 
 import { test as it, expect } from './pageTest';
 
-it.skip(({ isElectron, browserMajorVersion }) => isElectron && browserMajorVersion < 99, 'This needs Chromium >= 99');
-
 it('should set bodySize and headersSize', async ({ page, server }) => {
  await page.goto(server.EMPTY_PAGE);
  const [request] = await Promise.all([

tests/page/page-request-fulfill.spec.ts

@@ -140,10 +140,9 @@ it('should allow mocking binary responses', async ({ page, server, browserName,
  expect(await img.screenshot()).toMatchSnapshot('mock-binary-response.png');
 });
 
-it('should allow mocking svg with charset', async ({ page, server, browserName, headless, isAndroid, isElectron, mode }) => {
+it('should allow mocking svg with charset', async ({ page, server, browserName, headless, isAndroid }) => {
  it.skip(browserName === 'firefox' && !headless, 'Firefox headed produces a different image.');
  it.skip(isAndroid);
- it.skip(isElectron, 'Protocol error (Storage.getCookies): Browser context management is not supported');
 
  await page.route('**/*', route => {
  void route.fulfill({
@@ -253,8 +252,7 @@ it('should include the origin header', async ({ page, server, isAndroid }) => {
  expect(interceptedRequest.headers()['origin']).toEqual(server.PREFIX);
 });
 
-it('should fulfill with global fetch result', async ({ playwright, page, server, isElectron, rewriteAndroidLoopbackURL }) => {
- it.fixme(isElectron, 'error: Browser context management is not supported.');
+it('should fulfill with global fetch result', async ({ playwright, page, server, rewriteAndroidLoopbackURL }) => {
  await page.route('**/*', async route => {
  const request = await playwright.request.newContext();
  const response = await request.get(rewriteAndroidLoopbackURL(server.PREFIX + '/simple.json'));
@@ -265,8 +263,7 @@ it('should fulfill with global fetch result', async ({ playwright, page, server,
  expect(await response.json()).toEqual({ 'foo': 'bar' });
 });
 
-it('should fulfill with fetch result', async ({ page, server, isElectron, rewriteAndroidLoopbackURL }) => {
- it.fixme(isElectron, 'error: Browser context management is not supported.');
+it('should fulfill with fetch result', async ({ page, server, rewriteAndroidLoopbackURL }) => {
  await page.route('**/*', async route => {
  const response = await page.request.get(rewriteAndroidLoopbackURL(server.PREFIX + '/simple.json'));
  void route.fulfill({ response });
@@ -276,8 +273,7 @@ it('should fulfill with fetch result', async ({ page, server, isElectron, rewrit
  expect(await response.json()).toEqual({ 'foo': 'bar' });
 });
 
-it('should fulfill with fetch result and overrides', async ({ page, server, isElectron, rewriteAndroidLoopbackURL }) => {
- it.fixme(isElectron, 'error: Browser context management is not supported.');
+it('should fulfill with fetch result and overrides', async ({ page, server, rewriteAndroidLoopbackURL }) => {
  await page.route('**/*', async route => {
  const response = await page.request.get(rewriteAndroidLoopbackURL(server.PREFIX + '/simple.json'));
  void route.fulfill({
@@ -295,8 +291,7 @@ it('should fulfill with fetch result and overrides', async ({ page, server, isEl
  expect(await response.json()).toEqual({ 'foo': 'bar' });
 });
 
-it('should fetch original request and fulfill', async ({ page, server, isElectron, isAndroid }) => {
- it.fixme(isElectron, 'error: Browser context management is not supported.');
+it('should fetch original request and fulfill', async ({ page, server, isAndroid }) => {
  it.skip(isAndroid, 'The internal Android localhost (10.0.0.2) != the localhost on the host');
  await page.route('**/*', async route => {
  const response = await page.request.fetch(route.request());
@@ -309,8 +304,7 @@ it('should fetch original request and fulfill', async ({ page, server, isElectro
  expect(await page.title()).toEqual('Woof-Woof');
 });
 
-it('should fulfill with multiple set-cookie', async ({ page, server, isElectron }) => {
- it.fixme(isElectron, 'Electron 14+ is required');
+it('should fulfill with multiple set-cookie', async ({ page, server }) => {
  const cookies = ['a=b', 'c=d'];
  await page.route('**/empty.html', async route => {
  void route.fulfill({
@@ -442,9 +436,8 @@ it('should fulfill json', async ({ page, server }) => {
 
 it('should fulfill with gzip and readback', {
  annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/29261' },
-}, async ({ page, server, isAndroid, isElectron }) => {
+}, async ({ page, server, isAndroid }) => {
  it.skip(isAndroid, 'The internal Android localhost (10.0.0.2) != the localhost on the host');
- it.fixme(isElectron, 'error: Browser context management is not supported.');
  server.enableGzip('/one-style.html');
  await page.route('**/one-style.html', async route => {
  const response = await route.fetch();