f1a6b8d66d
* chore: vendor Mitt into src/common/third-party As discussed in #6203 we need to vendor our common dependencies in so that when we ship an ESM build all imports point to file paths and do not rely on Node resolution (e.g. a browser does not understand `import mitt from 'mitt'`).
662 lines
27 KiB
TypeScript
662 lines
27 KiB
TypeScript
/**
|
|
* Copyright 2017 Google Inc. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
import fs from 'fs';
|
|
import os from 'os';
|
|
import path from 'path';
|
|
import sinon from 'sinon';
|
|
import { promisify } from 'util';
|
|
import {
|
|
getTestState,
|
|
itFailsFirefox,
|
|
itOnlyRegularInstall,
|
|
itFailsWindowsUntilDate,
|
|
} from './mocha-utils'; // eslint-disable-line import/extensions
|
|
import utils from './utils.js';
|
|
import expect from 'expect';
|
|
import rimraf from 'rimraf';
|
|
import { Page } from '../lib/cjs/puppeteer/common/Page.js';
|
|
|
|
const rmAsync = promisify(rimraf);
|
|
const mkdtempAsync = promisify(fs.mkdtemp);
|
|
const readFileAsync = promisify(fs.readFile);
|
|
const statAsync = promisify(fs.stat);
|
|
const TMP_FOLDER = path.join(os.tmpdir(), 'pptr_tmp_folder-');
|
|
|
|
describe('Launcher specs', function () {
|
|
if (getTestState().isFirefox) this.timeout(30 * 1000);
|
|
|
|
describe('Puppeteer', function () {
|
|
describe('BrowserFetcher', function () {
|
|
it('should download and extract chrome linux binary', async () => {
|
|
const { server, puppeteer } = getTestState();
|
|
|
|
const downloadsFolder = await mkdtempAsync(TMP_FOLDER);
|
|
const browserFetcher = puppeteer.createBrowserFetcher({
|
|
platform: 'linux',
|
|
path: downloadsFolder,
|
|
host: server.PREFIX,
|
|
});
|
|
const expectedRevision = '123456';
|
|
let revisionInfo = browserFetcher.revisionInfo(expectedRevision);
|
|
server.setRoute(
|
|
revisionInfo.url.substring(server.PREFIX.length),
|
|
(req, res) => {
|
|
server.serveFile(req, res, '/chromium-linux.zip');
|
|
}
|
|
);
|
|
|
|
expect(revisionInfo.local).toBe(false);
|
|
expect(browserFetcher.platform()).toBe('linux');
|
|
expect(browserFetcher.product()).toBe('chrome');
|
|
expect(!!browserFetcher.host()).toBe(true);
|
|
expect(await browserFetcher.canDownload('100000')).toBe(false);
|
|
expect(await browserFetcher.canDownload(expectedRevision)).toBe(true);
|
|
|
|
revisionInfo = await browserFetcher.download(expectedRevision);
|
|
expect(revisionInfo.local).toBe(true);
|
|
expect(await readFileAsync(revisionInfo.executablePath, 'utf8')).toBe(
|
|
'LINUX BINARY\n'
|
|
);
|
|
const expectedPermissions = os.platform() === 'win32' ? 0o666 : 0o755;
|
|
expect(
|
|
(await statAsync(revisionInfo.executablePath)).mode & 0o777
|
|
).toBe(expectedPermissions);
|
|
expect(await browserFetcher.localRevisions()).toEqual([
|
|
expectedRevision,
|
|
]);
|
|
await browserFetcher.remove(expectedRevision);
|
|
expect(await browserFetcher.localRevisions()).toEqual([]);
|
|
await rmAsync(downloadsFolder);
|
|
});
|
|
it('should download and extract firefox linux binary', async () => {
|
|
const { server, puppeteer } = getTestState();
|
|
|
|
const downloadsFolder = await mkdtempAsync(TMP_FOLDER);
|
|
const browserFetcher = puppeteer.createBrowserFetcher({
|
|
platform: 'linux',
|
|
path: downloadsFolder,
|
|
host: server.PREFIX,
|
|
product: 'firefox',
|
|
});
|
|
const expectedVersion = '75.0a1';
|
|
let revisionInfo = browserFetcher.revisionInfo(expectedVersion);
|
|
server.setRoute(
|
|
revisionInfo.url.substring(server.PREFIX.length),
|
|
(req, res) => {
|
|
server.serveFile(
|
|
req,
|
|
res,
|
|
`/firefox-${expectedVersion}.en-US.linux-x86_64.tar.bz2`
|
|
);
|
|
}
|
|
);
|
|
|
|
expect(revisionInfo.local).toBe(false);
|
|
expect(browserFetcher.platform()).toBe('linux');
|
|
expect(browserFetcher.product()).toBe('firefox');
|
|
expect(await browserFetcher.canDownload('100000')).toBe(false);
|
|
expect(await browserFetcher.canDownload(expectedVersion)).toBe(true);
|
|
|
|
revisionInfo = await browserFetcher.download(expectedVersion);
|
|
expect(revisionInfo.local).toBe(true);
|
|
expect(await readFileAsync(revisionInfo.executablePath, 'utf8')).toBe(
|
|
'FIREFOX LINUX BINARY\n'
|
|
);
|
|
const expectedPermissions = os.platform() === 'win32' ? 0o666 : 0o755;
|
|
expect(
|
|
(await statAsync(revisionInfo.executablePath)).mode & 0o777
|
|
).toBe(expectedPermissions);
|
|
expect(await browserFetcher.localRevisions()).toEqual([
|
|
expectedVersion,
|
|
]);
|
|
await browserFetcher.remove(expectedVersion);
|
|
expect(await browserFetcher.localRevisions()).toEqual([]);
|
|
await rmAsync(downloadsFolder);
|
|
});
|
|
});
|
|
|
|
describe('Browser.disconnect', function () {
|
|
it('should reject navigation when browser closes', async () => {
|
|
const { server, puppeteer, defaultBrowserOptions } = getTestState();
|
|
server.setRoute('/one-style.css', () => {});
|
|
const browser = await puppeteer.launch(defaultBrowserOptions);
|
|
const remote = await puppeteer.connect({
|
|
browserWSEndpoint: browser.wsEndpoint(),
|
|
});
|
|
const page = await remote.newPage();
|
|
const navigationPromise = page
|
|
.goto(server.PREFIX + '/one-style.html', { timeout: 60000 })
|
|
.catch((error_) => error_);
|
|
await server.waitForRequest('/one-style.css');
|
|
remote.disconnect();
|
|
const error = await navigationPromise;
|
|
expect(error.message).toBe(
|
|
'Navigation failed because browser has disconnected!'
|
|
);
|
|
await browser.close();
|
|
});
|
|
it('should reject waitForSelector when browser closes', async () => {
|
|
const { server, puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
server.setRoute('/empty.html', () => {});
|
|
const browser = await puppeteer.launch(defaultBrowserOptions);
|
|
const remote = await puppeteer.connect({
|
|
browserWSEndpoint: browser.wsEndpoint(),
|
|
});
|
|
const page = await remote.newPage();
|
|
const watchdog = page
|
|
.waitForSelector('div', { timeout: 60000 })
|
|
.catch((error_) => error_);
|
|
remote.disconnect();
|
|
const error = await watchdog;
|
|
expect(error.message).toContain('Protocol error');
|
|
await browser.close();
|
|
});
|
|
});
|
|
describe('Browser.close', function () {
|
|
it('should terminate network waiters', async () => {
|
|
const { server, puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
const browser = await puppeteer.launch(defaultBrowserOptions);
|
|
const remote = await puppeteer.connect({
|
|
browserWSEndpoint: browser.wsEndpoint(),
|
|
});
|
|
const newPage = await remote.newPage();
|
|
const results = await Promise.all([
|
|
newPage.waitForRequest(server.EMPTY_PAGE).catch((error) => error),
|
|
newPage.waitForResponse(server.EMPTY_PAGE).catch((error) => error),
|
|
browser.close(),
|
|
]);
|
|
for (let i = 0; i < 2; i++) {
|
|
const message = results[i].message;
|
|
expect(message).toContain('Target closed');
|
|
expect(message).not.toContain('Timeout');
|
|
}
|
|
await browser.close();
|
|
});
|
|
});
|
|
describe('Puppeteer.launch', function () {
|
|
it('should reject all promises when browser is closed', async () => {
|
|
const { defaultBrowserOptions, puppeteer } = getTestState();
|
|
const browser = await puppeteer.launch(defaultBrowserOptions);
|
|
const page = await browser.newPage();
|
|
let error = null;
|
|
const neverResolves = page
|
|
.evaluate(() => new Promise(() => {}))
|
|
.catch((error_) => (error = error_));
|
|
await browser.close();
|
|
await neverResolves;
|
|
expect(error.message).toContain('Protocol error');
|
|
});
|
|
it('should reject if executable path is invalid', async () => {
|
|
const { defaultBrowserOptions, puppeteer } = getTestState();
|
|
|
|
let waitError = null;
|
|
const options = Object.assign({}, defaultBrowserOptions, {
|
|
executablePath: 'random-invalid-path',
|
|
});
|
|
await puppeteer.launch(options).catch((error) => (waitError = error));
|
|
expect(waitError.message).toContain('Failed to launch');
|
|
});
|
|
it('userDataDir option', async () => {
|
|
const { defaultBrowserOptions, puppeteer } = getTestState();
|
|
|
|
const userDataDir = await mkdtempAsync(TMP_FOLDER);
|
|
const options = Object.assign({ userDataDir }, defaultBrowserOptions);
|
|
const browser = await puppeteer.launch(options);
|
|
// Open a page to make sure its functional.
|
|
await browser.newPage();
|
|
expect(fs.readdirSync(userDataDir).length).toBeGreaterThan(0);
|
|
await browser.close();
|
|
expect(fs.readdirSync(userDataDir).length).toBeGreaterThan(0);
|
|
// This might throw. See https://github.com/puppeteer/puppeteer/issues/2778
|
|
await rmAsync(userDataDir).catch(() => {});
|
|
});
|
|
it('userDataDir argument', async () => {
|
|
const { isChrome, puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
const userDataDir = await mkdtempAsync(TMP_FOLDER);
|
|
const options = Object.assign({}, defaultBrowserOptions);
|
|
if (isChrome) {
|
|
options.args = [
|
|
...(defaultBrowserOptions.args || []),
|
|
`--user-data-dir=${userDataDir}`,
|
|
];
|
|
} else {
|
|
options.args = [
|
|
...(defaultBrowserOptions.args || []),
|
|
`-profile`,
|
|
userDataDir,
|
|
];
|
|
}
|
|
const browser = await puppeteer.launch(options);
|
|
expect(fs.readdirSync(userDataDir).length).toBeGreaterThan(0);
|
|
await browser.close();
|
|
expect(fs.readdirSync(userDataDir).length).toBeGreaterThan(0);
|
|
// This might throw. See https://github.com/puppeteer/puppeteer/issues/2778
|
|
await rmAsync(userDataDir).catch(() => {});
|
|
});
|
|
it('userDataDir option should restore state', async () => {
|
|
const { server, puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
const userDataDir = await mkdtempAsync(TMP_FOLDER);
|
|
const options = Object.assign({ userDataDir }, defaultBrowserOptions);
|
|
const browser = await puppeteer.launch(options);
|
|
const page = await browser.newPage();
|
|
await page.goto(server.EMPTY_PAGE);
|
|
await page.evaluate(() => (localStorage.hey = 'hello'));
|
|
await browser.close();
|
|
|
|
const browser2 = await puppeteer.launch(options);
|
|
const page2 = await browser2.newPage();
|
|
await page2.goto(server.EMPTY_PAGE);
|
|
expect(await page2.evaluate(() => localStorage.hey)).toBe('hello');
|
|
await browser2.close();
|
|
// This might throw. See https://github.com/puppeteer/puppeteer/issues/2778
|
|
await rmAsync(userDataDir).catch(() => {});
|
|
});
|
|
// This mysteriously fails on Windows on AppVeyor. See
|
|
// https://github.com/puppeteer/puppeteer/issues/4111
|
|
xit('userDataDir option should restore cookies', async () => {
|
|
const { server, puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
const userDataDir = await mkdtempAsync(TMP_FOLDER);
|
|
const options = Object.assign({ userDataDir }, defaultBrowserOptions);
|
|
const browser = await puppeteer.launch(options);
|
|
const page = await browser.newPage();
|
|
await page.goto(server.EMPTY_PAGE);
|
|
await page.evaluate(
|
|
() =>
|
|
(document.cookie =
|
|
'doSomethingOnlyOnce=true; expires=Fri, 31 Dec 9999 23:59:59 GMT')
|
|
);
|
|
await browser.close();
|
|
|
|
const browser2 = await puppeteer.launch(options);
|
|
const page2 = await browser2.newPage();
|
|
await page2.goto(server.EMPTY_PAGE);
|
|
expect(await page2.evaluate(() => document.cookie)).toBe(
|
|
'doSomethingOnlyOnce=true'
|
|
);
|
|
await browser2.close();
|
|
// This might throw. See https://github.com/puppeteer/puppeteer/issues/2778
|
|
await rmAsync(userDataDir).catch(() => {});
|
|
});
|
|
it('should return the default arguments', async () => {
|
|
const { isChrome, isFirefox, puppeteer } = getTestState();
|
|
|
|
if (isChrome) {
|
|
expect(puppeteer.defaultArgs()).toContain('--no-first-run');
|
|
expect(puppeteer.defaultArgs()).toContain('--headless');
|
|
expect(puppeteer.defaultArgs({ headless: false })).not.toContain(
|
|
'--headless'
|
|
);
|
|
expect(puppeteer.defaultArgs({ userDataDir: 'foo' })).toContain(
|
|
'--user-data-dir=foo'
|
|
);
|
|
} else if (isFirefox) {
|
|
expect(puppeteer.defaultArgs()).toContain('--headless');
|
|
expect(puppeteer.defaultArgs()).toContain('--no-remote');
|
|
expect(puppeteer.defaultArgs()).toContain('--foreground');
|
|
expect(puppeteer.defaultArgs({ headless: false })).not.toContain(
|
|
'--headless'
|
|
);
|
|
expect(puppeteer.defaultArgs({ userDataDir: 'foo' })).toContain(
|
|
'--profile'
|
|
);
|
|
expect(puppeteer.defaultArgs({ userDataDir: 'foo' })).toContain(
|
|
'foo'
|
|
);
|
|
} else {
|
|
expect(puppeteer.defaultArgs()).toContain('-headless');
|
|
expect(puppeteer.defaultArgs({ headless: false })).not.toContain(
|
|
'-headless'
|
|
);
|
|
expect(puppeteer.defaultArgs({ userDataDir: 'foo' })).toContain(
|
|
'-profile'
|
|
);
|
|
expect(puppeteer.defaultArgs({ userDataDir: 'foo' })).toContain(
|
|
'foo'
|
|
);
|
|
}
|
|
});
|
|
it('should report the correct product', async () => {
|
|
const { isChrome, isFirefox, puppeteer } = getTestState();
|
|
if (isChrome) expect(puppeteer.product).toBe('chrome');
|
|
else if (isFirefox) expect(puppeteer.product).toBe('firefox');
|
|
});
|
|
it('should work with no default arguments', async () => {
|
|
const { defaultBrowserOptions, puppeteer } = getTestState();
|
|
const options = Object.assign({}, defaultBrowserOptions);
|
|
options.ignoreDefaultArgs = true;
|
|
const browser = await puppeteer.launch(options);
|
|
const page = await browser.newPage();
|
|
expect(await page.evaluate('11 * 11')).toBe(121);
|
|
await page.close();
|
|
await browser.close();
|
|
});
|
|
it('should filter out ignored default arguments', async () => {
|
|
const { defaultBrowserOptions, puppeteer } = getTestState();
|
|
// Make sure we launch with `--enable-automation` by default.
|
|
const defaultArgs = puppeteer.defaultArgs();
|
|
const browser = await puppeteer.launch(
|
|
Object.assign({}, defaultBrowserOptions, {
|
|
// Ignore first and third default argument.
|
|
ignoreDefaultArgs: [defaultArgs[0], defaultArgs[2]],
|
|
})
|
|
);
|
|
const spawnargs = browser.process().spawnargs;
|
|
if (!spawnargs) {
|
|
throw new Error('spawnargs not present');
|
|
}
|
|
expect(spawnargs.indexOf(defaultArgs[0])).toBe(-1);
|
|
expect(spawnargs.indexOf(defaultArgs[1])).not.toBe(-1);
|
|
expect(spawnargs.indexOf(defaultArgs[2])).toBe(-1);
|
|
await browser.close();
|
|
});
|
|
it('should have default URL when launching browser', async function () {
|
|
const { defaultBrowserOptions, puppeteer } = getTestState();
|
|
const browser = await puppeteer.launch(defaultBrowserOptions);
|
|
const pages = (await browser.pages()).map((page) => page.url());
|
|
expect(pages).toEqual(['about:blank']);
|
|
await browser.close();
|
|
});
|
|
itFailsFirefox(
|
|
'should have custom URL when launching browser',
|
|
async () => {
|
|
const { server, puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
const options = Object.assign({}, defaultBrowserOptions);
|
|
options.args = [server.EMPTY_PAGE].concat(options.args || []);
|
|
const browser = await puppeteer.launch(options);
|
|
const pages = await browser.pages();
|
|
expect(pages.length).toBe(1);
|
|
const page = pages[0];
|
|
if (page.url() !== server.EMPTY_PAGE) await page.waitForNavigation();
|
|
expect(page.url()).toBe(server.EMPTY_PAGE);
|
|
await browser.close();
|
|
}
|
|
);
|
|
it('should set the default viewport', async () => {
|
|
const { puppeteer, defaultBrowserOptions } = getTestState();
|
|
const options = Object.assign({}, defaultBrowserOptions, {
|
|
defaultViewport: {
|
|
width: 456,
|
|
height: 789,
|
|
},
|
|
});
|
|
const browser = await puppeteer.launch(options);
|
|
const page = await browser.newPage();
|
|
expect(await page.evaluate('window.innerWidth')).toBe(456);
|
|
expect(await page.evaluate('window.innerHeight')).toBe(789);
|
|
await browser.close();
|
|
});
|
|
it('should disable the default viewport', async () => {
|
|
const { puppeteer, defaultBrowserOptions } = getTestState();
|
|
const options = Object.assign({}, defaultBrowserOptions, {
|
|
defaultViewport: null,
|
|
});
|
|
const browser = await puppeteer.launch(options);
|
|
const page = await browser.newPage();
|
|
expect(page.viewport()).toBe(null);
|
|
await browser.close();
|
|
});
|
|
it('should take fullPage screenshots when defaultViewport is null', async () => {
|
|
const { server, puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
const options = Object.assign({}, defaultBrowserOptions, {
|
|
defaultViewport: null,
|
|
});
|
|
const browser = await puppeteer.launch(options);
|
|
const page = await browser.newPage();
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
const screenshot = await page.screenshot({
|
|
fullPage: true,
|
|
});
|
|
expect(screenshot).toBeInstanceOf(Buffer);
|
|
await browser.close();
|
|
});
|
|
});
|
|
|
|
describe('Puppeteer.launch', function () {
|
|
let productName;
|
|
|
|
before(async () => {
|
|
const { puppeteer } = getTestState();
|
|
productName = puppeteer._productName;
|
|
});
|
|
|
|
after(async () => {
|
|
const { puppeteer } = getTestState();
|
|
/* launcher is a private property so we don't want our users doing this
|
|
* but we need to reset the state fully here for testing different
|
|
* browser launchers
|
|
*/
|
|
// @ts-expect-error
|
|
puppeteer._lazyLauncher = undefined;
|
|
puppeteer._productName = productName;
|
|
});
|
|
|
|
itOnlyRegularInstall('should be able to launch Chrome', async () => {
|
|
const { puppeteer } = getTestState();
|
|
const browser = await puppeteer.launch({ product: 'chrome' });
|
|
const userAgent = await browser.userAgent();
|
|
await browser.close();
|
|
expect(userAgent).toContain('Chrome');
|
|
});
|
|
|
|
it('falls back to launching chrome if there is an unknown product but logs a warning', async () => {
|
|
const { puppeteer } = getTestState();
|
|
const consoleStub = sinon.stub(console, 'warn');
|
|
const browser = await puppeteer.launch({ product: 'SO_NOT_A_PRODUCT' });
|
|
const userAgent = await browser.userAgent();
|
|
await browser.close();
|
|
expect(userAgent).toContain('Chrome');
|
|
expect(consoleStub.callCount).toEqual(1);
|
|
expect(consoleStub.firstCall.args).toEqual([
|
|
'Warning: unknown product name SO_NOT_A_PRODUCT. Falling back to chrome.',
|
|
]);
|
|
});
|
|
|
|
/* We think there's a bug in the FF Windows launcher, or some
|
|
* combo of that plus it running on CI, but we're deferring fixing
|
|
* this so we can get Windows CI stable and then dig into this
|
|
* properly with help from the Mozilla folks.
|
|
*/
|
|
itFailsWindowsUntilDate(
|
|
new Date('2020-07-30'),
|
|
'should be able to launch Firefox',
|
|
async () => {
|
|
const { puppeteer } = getTestState();
|
|
const browser = await puppeteer.launch({ product: 'firefox' });
|
|
const userAgent = await browser.userAgent();
|
|
await browser.close();
|
|
expect(userAgent).toContain('Firefox');
|
|
}
|
|
);
|
|
});
|
|
|
|
describe('Puppeteer.connect', function () {
|
|
it('should be able to connect multiple times to the same browser', async () => {
|
|
const { puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
const originalBrowser = await puppeteer.launch(defaultBrowserOptions);
|
|
const otherBrowser = await puppeteer.connect({
|
|
browserWSEndpoint: originalBrowser.wsEndpoint(),
|
|
});
|
|
const page = await otherBrowser.newPage();
|
|
expect(await page.evaluate(() => 7 * 8)).toBe(56);
|
|
otherBrowser.disconnect();
|
|
|
|
const secondPage = await originalBrowser.newPage();
|
|
expect(await secondPage.evaluate(() => 7 * 6)).toBe(42);
|
|
await originalBrowser.close();
|
|
});
|
|
it('should be able to close remote browser', async () => {
|
|
const { defaultBrowserOptions, puppeteer } = getTestState();
|
|
|
|
const originalBrowser = await puppeteer.launch(defaultBrowserOptions);
|
|
const remoteBrowser = await puppeteer.connect({
|
|
browserWSEndpoint: originalBrowser.wsEndpoint(),
|
|
});
|
|
await Promise.all([
|
|
utils.waitEvent(originalBrowser, 'disconnected'),
|
|
remoteBrowser.close(),
|
|
]);
|
|
});
|
|
it('should support ignoreHTTPSErrors option', async () => {
|
|
const {
|
|
httpsServer,
|
|
puppeteer,
|
|
defaultBrowserOptions,
|
|
} = getTestState();
|
|
|
|
const originalBrowser = await puppeteer.launch(defaultBrowserOptions);
|
|
const browserWSEndpoint = originalBrowser.wsEndpoint();
|
|
|
|
const browser = await puppeteer.connect({
|
|
browserWSEndpoint,
|
|
ignoreHTTPSErrors: true,
|
|
});
|
|
const page = await browser.newPage();
|
|
let error = null;
|
|
const [serverRequest, response] = await Promise.all([
|
|
httpsServer.waitForRequest('/empty.html'),
|
|
page.goto(httpsServer.EMPTY_PAGE).catch((error_) => (error = error_)),
|
|
]);
|
|
expect(error).toBe(null);
|
|
expect(response.ok()).toBe(true);
|
|
expect(response.securityDetails()).toBeTruthy();
|
|
const protocol = serverRequest.socket.getProtocol().replace('v', ' ');
|
|
expect(response.securityDetails().protocol()).toBe(protocol);
|
|
await page.close();
|
|
await browser.close();
|
|
});
|
|
itFailsFirefox(
|
|
'should be able to reconnect to a disconnected browser',
|
|
async () => {
|
|
const { server, puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
const originalBrowser = await puppeteer.launch(defaultBrowserOptions);
|
|
const browserWSEndpoint = originalBrowser.wsEndpoint();
|
|
const page = await originalBrowser.newPage();
|
|
await page.goto(server.PREFIX + '/frames/nested-frames.html');
|
|
originalBrowser.disconnect();
|
|
|
|
const browser = await puppeteer.connect({ browserWSEndpoint });
|
|
const pages = await browser.pages();
|
|
const restoredPage = pages.find(
|
|
(page) =>
|
|
page.url() === server.PREFIX + '/frames/nested-frames.html'
|
|
);
|
|
expect(utils.dumpFrames(restoredPage.mainFrame())).toEqual([
|
|
'http://localhost:<PORT>/frames/nested-frames.html',
|
|
' http://localhost:<PORT>/frames/two-frames.html (2frames)',
|
|
' http://localhost:<PORT>/frames/frame.html (uno)',
|
|
' http://localhost:<PORT>/frames/frame.html (dos)',
|
|
' http://localhost:<PORT>/frames/frame.html (aframe)',
|
|
]);
|
|
expect(await restoredPage.evaluate(() => 7 * 8)).toBe(56);
|
|
await browser.close();
|
|
}
|
|
);
|
|
// @see https://github.com/puppeteer/puppeteer/issues/4197#issuecomment-481793410
|
|
itFailsFirefox(
|
|
'should be able to connect to the same page simultaneously',
|
|
async () => {
|
|
const { puppeteer } = getTestState();
|
|
|
|
const browserOne = await puppeteer.launch();
|
|
const browserTwo = await puppeteer.connect({
|
|
browserWSEndpoint: browserOne.wsEndpoint(),
|
|
});
|
|
const [page1, page2] = await Promise.all([
|
|
new Promise<Page>((x) =>
|
|
browserOne.once('targetcreated', (target) => x(target.page()))
|
|
),
|
|
browserTwo.newPage(),
|
|
]);
|
|
expect(await page1.evaluate(() => 7 * 8)).toBe(56);
|
|
expect(await page2.evaluate(() => 7 * 6)).toBe(42);
|
|
await browserOne.close();
|
|
}
|
|
);
|
|
});
|
|
describe('Puppeteer.executablePath', function () {
|
|
itOnlyRegularInstall('should work', async () => {
|
|
const { puppeteer } = getTestState();
|
|
|
|
const executablePath = puppeteer.executablePath();
|
|
expect(fs.existsSync(executablePath)).toBe(true);
|
|
expect(fs.realpathSync(executablePath)).toBe(executablePath);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Browser target events', function () {
|
|
itFailsFirefox('should work', async () => {
|
|
const { server, puppeteer, defaultBrowserOptions } = getTestState();
|
|
|
|
const browser = await puppeteer.launch(defaultBrowserOptions);
|
|
const events = [];
|
|
browser.on('targetcreated', () => events.push('CREATED'));
|
|
browser.on('targetchanged', () => events.push('CHANGED'));
|
|
browser.on('targetdestroyed', () => events.push('DESTROYED'));
|
|
const page = await browser.newPage();
|
|
await page.goto(server.EMPTY_PAGE);
|
|
await page.close();
|
|
expect(events).toEqual(['CREATED', 'CHANGED', 'DESTROYED']);
|
|
await browser.close();
|
|
});
|
|
});
|
|
|
|
describe('Browser.Events.disconnected', function () {
|
|
it('should be emitted when: browser gets closed, disconnected or underlying websocket gets closed', async () => {
|
|
const { puppeteer, defaultBrowserOptions } = getTestState();
|
|
const originalBrowser = await puppeteer.launch(defaultBrowserOptions);
|
|
const browserWSEndpoint = originalBrowser.wsEndpoint();
|
|
const remoteBrowser1 = await puppeteer.connect({ browserWSEndpoint });
|
|
const remoteBrowser2 = await puppeteer.connect({ browserWSEndpoint });
|
|
|
|
let disconnectedOriginal = 0;
|
|
let disconnectedRemote1 = 0;
|
|
let disconnectedRemote2 = 0;
|
|
originalBrowser.on('disconnected', () => ++disconnectedOriginal);
|
|
remoteBrowser1.on('disconnected', () => ++disconnectedRemote1);
|
|
remoteBrowser2.on('disconnected', () => ++disconnectedRemote2);
|
|
|
|
await Promise.all([
|
|
utils.waitEvent(remoteBrowser2, 'disconnected'),
|
|
remoteBrowser2.disconnect(),
|
|
]);
|
|
|
|
expect(disconnectedOriginal).toBe(0);
|
|
expect(disconnectedRemote1).toBe(0);
|
|
expect(disconnectedRemote2).toBe(1);
|
|
|
|
await Promise.all([
|
|
utils.waitEvent(remoteBrowser1, 'disconnected'),
|
|
utils.waitEvent(originalBrowser, 'disconnected'),
|
|
originalBrowser.close(),
|
|
]);
|
|
|
|
expect(disconnectedOriginal).toBe(1);
|
|
expect(disconnectedRemote1).toBe(1);
|
|
expect(disconnectedRemote2).toBe(1);
|
|
});
|
|
});
|
|
});
|