Filip/playwright
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

feat(test): introduce test.config.js (#1725)

Browse source 
This file encapsulate everything specific to playwright testing. Now the general test.js can be reused for other projects.
This commit is contained in:
Dmitry Gozman 2020-04-09 18:14:29 -07:00 committed by GitHub
parent 7189d19913
commit 42beb3784f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 368 additions and 318 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
test/download.spec.js
View file

@ -62,6 +62,7 @@ describe('Download', function() {
expect(fs.existsSync(path)).toBeTruthy();
await download.delete();
expect(fs.existsSync(path)).toBeFalsy();
await page.close();
});
it('should expose stream', async({browser, server}) => {
const page = await browser.newPage({ acceptDownloads: true });
@ -76,6 +77,7 @@ describe('Download', function() {
await new Promise(f => stream.on('end', f));
expect(content).toBe('Hello world');
stream.close();
await page.close();
});
it('should delete downloads on context destruction', async({browser, server}) => {
const page = await browser.newPage({ acceptDownloads: true });

264
test/playwright.spec.js
View file

@ -1,264 +0,0 @@
/**
* Copyright 2019 Google Inc. All rights reserved.
* Modifications copyright (c) Microsoft Corporation.
*
* 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.
*/
const fs = require('fs');
const path = require('path');
const rm = require('rimraf').sync;
const readline = require('readline');
const {TestServer} = require('../utils/testserver/');
const {Environment} = require('../utils/testrunner/Test');
const serverEnvironment = new Environment('TestServer');
serverEnvironment.beforeAll(async state => {
const assetsPath = path.join(__dirname, 'assets');
const cachedPath = path.join(__dirname, 'assets', 'cached');
const port = 8907 + state.parallelIndex * 3;
state.server = await TestServer.create(assetsPath, port);
state.server.enableHTTPCache(cachedPath);
state.server.PORT = port;
state.server.PREFIX = `http://localhost:${port}`;
state.server.CROSS_PROCESS_PREFIX = `http://127.0.0.1:${port}`;
state.server.EMPTY_PAGE = `http://localhost:${port}/empty.html`;
const httpsPort = port + 1;
state.httpsServer = await TestServer.createHTTPS(assetsPath, httpsPort);
state.httpsServer.enableHTTPCache(cachedPath);
state.httpsServer.PORT = httpsPort;
state.httpsServer.PREFIX = `https://localhost:${httpsPort}`;
state.httpsServer.CROSS_PROCESS_PREFIX = `https://127.0.0.1:${httpsPort}`;
state.httpsServer.EMPTY_PAGE = `https://localhost:${httpsPort}/empty.html`;
const sourcePort = port + 2;
state.sourceServer = await TestServer.create(path.join(__dirname, '..'), sourcePort);
state.sourceServer.PORT = sourcePort;
state.sourceServer.PREFIX = `http://localhost:${sourcePort}`;
});
serverEnvironment.afterAll(async({server, sourceServer, httpsServer}) => {
await Promise.all([
server.stop(),
httpsServer.stop(),
sourceServer.stop(),
]);
});
serverEnvironment.beforeEach(async({server, httpsServer}) => {
server.reset();
httpsServer.reset();
});
const goldenEnvironment = new Environment('Golden');
goldenEnvironment.beforeAll(async ({browserType}) => {
const { OUTPUT_DIR, GOLDEN_DIR } = require('./utils').testOptions(browserType);
if (fs.existsSync(OUTPUT_DIR))
rm(OUTPUT_DIR);
fs.mkdirSync(OUTPUT_DIR, { recursive: true });
expect.setupGolden(GOLDEN_DIR, OUTPUT_DIR);
});
/**
* @type {TestSuite}
*/
module.exports.addPlaywrightTests = ({testRunner, products}) => {
const dumpProtocolOnFailure = valueFromEnv('DEBUGP', false);
const playwrightPath = require('./utils').projectRoot();
const playwright = require(playwrightPath);
const playwrightEnvironment = new Environment('Playwright');
playwrightEnvironment.beforeAll(async state => {
state.playwright = playwright;
global.playwright = playwright;
});
playwrightEnvironment.afterAll(async state => {
delete state.playwright;
delete global.playwright;
});
testRunner.collector().useEnvironment(serverEnvironment); // Custom global environment.
testRunner.collector().useEnvironment(playwrightEnvironment);
for (const product of products) {
const browserTypeEnvironment = new Environment('BrowserType');
browserTypeEnvironment.beforeAll(async state => {
state.browserType = state.playwright[product.toLowerCase()];
});
browserTypeEnvironment.afterAll(async state => {
delete state.browserType;
});
const browserType = playwright[product.toLowerCase()];
const executablePath = {
'chromium': process.env.CRPATH,
'firefox': process.env.FFPATH,
'webkit': process.env.WKPATH,
}[browserType.name()];
if (executablePath) {
const YELLOW_COLOR = '\x1b[33m';
const RESET_COLOR = '\x1b[0m';
console.warn(`${YELLOW_COLOR}WARN: running ${product} tests with ${executablePath}${RESET_COLOR}`);
browserType._executablePath = executablePath;
} else {
// Make sure the `npm install` was run after the chromium roll.
if (!fs.existsSync(browserType.executablePath()))
throw new Error(`Browser is not downloaded. Run 'npm install' and try to re-run tests`);
}
const launchOptions = {
handleSIGINT: false,
slowMo: valueFromEnv('SLOW_MO', 0),
headless: !!valueFromEnv('HEADLESS', true),
};
const browserEnvironment = new Environment(product);
browserEnvironment.beforeAll(async state => {
state.browser = await state.browserType.launch(launchOptions);
state.browserServer = state.browser._ownedServer;
state._stdout = readline.createInterface({ input: state.browserServer.process().stdout });
state._stderr = readline.createInterface({ input: state.browserServer.process().stderr });
});
browserEnvironment.afterAll(async state => {
await state.browserServer.close();
state.browser = null;
state.browserServer = null;
state._stdout.close();
state._stderr.close();
});
browserEnvironment.beforeEach(async(state, testRun) => {
const dumpout = data => testRun.log(`\x1b[33m[pw:stdio:out]\x1b[0m ${data}`);
const dumperr = data => testRun.log(`\x1b[31m[pw:stdio:err]\x1b[0m ${data}`);
state._stdout.on('line', dumpout);
state._stderr.on('line', dumperr);
if (dumpProtocolOnFailure)
state.browser._debugProtocol.log = data => testRun.log(`\x1b[32m[pw:protocol]\x1b[0m ${data}`);
state.tearDown = async () => {
state._stdout.off('line', dumpout);
state._stderr.off('line', dumperr);
if (dumpProtocolOnFailure)
delete state.browser._debugProtocol.log;
};
});
browserEnvironment.afterEach(async (state, test) => {
if (state.browser.contexts().length !== 0) {
if (test.result === 'ok')
console.warn(`\nWARNING: test "${test.fullName()}" (${test.location()}) did not close all created contexts!\n`);
await Promise.all(state.browser.contexts().map(context => context.close()));
}
await state.tearDown();
});
const pageEnvironment = new Environment('Page');
pageEnvironment.beforeEach(async state => {
state.context = await state.browser.newContext();
state.page = await state.context.newPage();
});
pageEnvironment.afterEach(async state => {
await state.context.close();
state.context = null;
state.page = null;
});
function loadTest(path) {
require(path);
delete require.cache[require.resolve(path)];
}
describe(product, () => {
// In addition to state, expose these two on global so that describes can access them.
global.playwright = playwright;
global.browserType = browserType;
testRunner.collector().useEnvironment(browserTypeEnvironment);
testRunner.collector().useEnvironment(goldenEnvironment); // Custom environment.
describe('', function() {
testRunner.collector().useEnvironment(browserEnvironment);
describe('', function() {
testRunner.collector().useEnvironment(pageEnvironment);
// Page-level tests that are given a browser, a context and a page.
// Each test is launched in a new browser context.
loadTest('./accessibility.spec.js');
loadTest('./autowaiting.spec.js');
loadTest('./click.spec.js');
loadTest('./cookies.spec.js');
loadTest('./dialog.spec.js');
loadTest('./download.spec.js');
loadTest('./elementhandle.spec.js');
loadTest('./emulation.spec.js');
loadTest('./evaluation.spec.js');
loadTest('./frame.spec.js');
loadTest('./focus.spec.js');
loadTest('./input.spec.js');
loadTest('./jshandle.spec.js');
loadTest('./keyboard.spec.js');
loadTest('./mouse.spec.js');
loadTest('./navigation.spec.js');
loadTest('./network.spec.js');
loadTest('./page.spec.js');
loadTest('./queryselector.spec.js');
loadTest('./screenshot.spec.js');
loadTest('./waittask.spec.js');
loadTest('./interception.spec.js');
loadTest('./geolocation.spec.js');
loadTest('./workers.spec.js');
loadTest('./capabilities.spec.js');
loadTest('./permissions.spec.js');
describe.skip(product !== 'Chromium')('[Chromium]', () => {
loadTest('./chromium/chromium.spec.js');
loadTest('./chromium/coverage.spec.js');
loadTest('./chromium/pdf.spec.js');
loadTest('./chromium/session.spec.js');
});
});
// Browser-level tests that are given a browser.
describe('[Driver]', () => {
loadTest('./browser.spec.js');
loadTest('./browsercontext.spec.js');
loadTest('./ignorehttpserrors.spec.js');
loadTest('./popup.spec.js');
});
});
// Top-level tests that launch Browser themselves.
describe('[Driver]', () => {
loadTest('./defaultbrowsercontext.spec.js');
loadTest('./fixtures.spec.js');
loadTest('./launcher.spec.js');
loadTest('./headful.spec.js');
loadTest('./multiclient.spec.js');
});
describe.skip(product !== 'Chromium')('[Chromium]', () => {
loadTest('./chromium/launcher.spec.js');
loadTest('./chromium/oopif.spec.js');
loadTest('./chromium/tracing.spec.js');
});
loadTest('./apicoverage.spec.js');
delete global.browserType;
delete global.playwright;
});
}
};
function valueFromEnv(name, defaultValue) {
if (!(name in process.env))
return defaultValue;
return JSON.parse(process.env[name]);
}

225
test/test.config.js Normal file
View file

@ -0,0 +1,225 @@
/**
* Copyright 2019 Google Inc. All rights reserved.
* Modifications copyright (c) Microsoft Corporation.
*
* 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.
*/
const fs = require('fs');
const path = require('path');
const rm = require('rimraf').sync;
const {TestServer} = require('../utils/testserver/');
const {Environment} = require('../utils/testrunner/Test');
const serverEnvironment = new Environment('TestServer');
serverEnvironment.beforeAll(async state => {
const assetsPath = path.join(__dirname, 'assets');
const cachedPath = path.join(__dirname, 'assets', 'cached');
const port = 8907 + state.parallelIndex * 2;
state.server = await TestServer.create(assetsPath, port);
state.server.enableHTTPCache(cachedPath);
state.server.PORT = port;
state.server.PREFIX = `http://localhost:${port}`;
state.server.CROSS_PROCESS_PREFIX = `http://127.0.0.1:${port}`;
state.server.EMPTY_PAGE = `http://localhost:${port}/empty.html`;
const httpsPort = port + 1;
state.httpsServer = await TestServer.createHTTPS(assetsPath, httpsPort);
state.httpsServer.enableHTTPCache(cachedPath);
state.httpsServer.PORT = httpsPort;
state.httpsServer.PREFIX = `https://localhost:${httpsPort}`;
state.httpsServer.CROSS_PROCESS_PREFIX = `https://127.0.0.1:${httpsPort}`;
state.httpsServer.EMPTY_PAGE = `https://localhost:${httpsPort}/empty.html`;
});
serverEnvironment.afterAll(async({server, httpsServer}) => {
await Promise.all([
server.stop(),
httpsServer.stop(),
]);
});
serverEnvironment.beforeEach(async({server, httpsServer}) => {
server.reset();
httpsServer.reset();
});
const customEnvironment = new Environment('Golden+CheckContexts');
customEnvironment.beforeAll(async ({browserType}) => {
const { OUTPUT_DIR, GOLDEN_DIR } = require('./utils').testOptions(browserType);
if (fs.existsSync(OUTPUT_DIR))
rm(OUTPUT_DIR);
fs.mkdirSync(OUTPUT_DIR, { recursive: true });
expect.setupGolden(GOLDEN_DIR, OUTPUT_DIR);
});
customEnvironment.afterEach(async (state, testRun) => {
if (state.browser && state.browser.contexts().length !== 0) {
if (testRun.ok())
console.warn(`\nWARNING: test "${testRun.test().fullName()}" (${testRun.test().location()}) did not close all created contexts!\n`);
await Promise.all(state.browser.contexts().map(context => context.close()));
}
});
function valueFromEnv(name, defaultValue) {
if (!(name in process.env))
return defaultValue;
return JSON.parse(process.env[name]);
}
function setupTestRunner(testRunner) {
const collector = testRunner.collector();
collector.addTestModifier('skip', (t, condition) => condition && t.setSkipped(true));
collector.addSuiteModifier('skip', (s, condition) => condition && s.setSkipped(true));
collector.addTestModifier('fail', (t, condition) => condition && t.setExpectation(t.Expectations.Fail));
collector.addSuiteModifier('fail', (s, condition) => condition && s.setExpectation(s.Expectations.Fail));
collector.addTestModifier('slow', t => t.setTimeout(t.timeout() * 3));
collector.addTestAttribute('debug', t => {
t.setTimeout(100000000);
let session;
t.environment().beforeEach(async () => {
const inspector = require('inspector');
const fs = require('fs');
const util = require('util');
const url = require('url');
const readFileAsync = util.promisify(fs.readFile.bind(fs));
session = new inspector.Session();
session.connect();
const postAsync = util.promisify(session.post.bind(session));
await postAsync('Debugger.enable');
const setBreakpointCommands = [];
const N = t.body().toString().split('\n').length;
const location = t.location();
const lines = (await readFileAsync(location.filePath(), 'utf8')).split('\n');
for (let line = 0; line < N; ++line) {
const lineNumber = line + location.lineNumber();
setBreakpointCommands.push(postAsync('Debugger.setBreakpointByUrl', {
url: url.pathToFileURL(location.filePath()),
lineNumber,
condition: `console.log('${String(lineNumber + 1).padStart(6, ' ')} | ' + ${JSON.stringify(lines[lineNumber])})`,
}).catch(e => {}));
}
await Promise.all(setBreakpointCommands);
});
t.environment().afterEach(async () => {
session.disconnect();
});
});
testRunner.api().fdescribe = testRunner.api().describe.only;
testRunner.api().xdescribe = testRunner.api().describe.skip(true);
testRunner.api().fit = testRunner.api().it.only;
testRunner.api().xit = testRunner.api().it.skip(true);
testRunner.api().dit = testRunner.api().it.only.debug;
}
module.exports = {
playwrightPath: '..',
dumpProtocolOnFailure: valueFromEnv('DEBUGP', false),
launchOptions: {
executablePath: {
chromium: process.env.CRPATH,
firefox: process.env.FFPATH,
webkit: process.env.WKPATH,
},
slowMo: valueFromEnv('SLOW_MO', 0),
headless: !!valueFromEnv('HEADLESS', true),
},
globalEnvironments: [serverEnvironment],
setupTestRunner,
specs: [
{
files: [
'./accessibility.spec.js',
'./autowaiting.spec.js',
'./click.spec.js',
'./cookies.spec.js',
'./dialog.spec.js',
'./download.spec.js',
'./elementhandle.spec.js',
'./emulation.spec.js',
'./evaluation.spec.js',
'./frame.spec.js',
'./focus.spec.js',
'./input.spec.js',
'./jshandle.spec.js',
'./keyboard.spec.js',
'./mouse.spec.js',
'./navigation.spec.js',
'./network.spec.js',
'./page.spec.js',
'./queryselector.spec.js',
'./screenshot.spec.js',
'./waittask.spec.js',
'./interception.spec.js',
'./geolocation.spec.js',
'./workers.spec.js',
'./capabilities.spec.js',
'./permissions.spec.js',
],
environments: [customEnvironment, 'page'],
},
{
files: [
'./chromium/chromium.spec.js',
'./chromium/coverage.spec.js',
'./chromium/pdf.spec.js',
'./chromium/session.spec.js',
],
browsers: ['chromium'],
title: '[Chromium]',
environments: [customEnvironment, 'page'],
},
{
files: [
'./browser.spec.js',
'./browsercontext.spec.js',
'./ignorehttpserrors.spec.js',
'./popup.spec.js',
],
environments: [customEnvironment, 'browser'],
},
{
files: [
'./defaultbrowsercontext.spec.js',
'./fixtures.spec.js',
'./launcher.spec.js',
'./headful.spec.js',
'./multiclient.spec.js',
],
environments: [customEnvironment],
},
{
files: [
'./chromium/launcher.spec.js',
'./chromium/oopif.spec.js',
'./chromium/tracing.spec.js',
],
browsers: ['chromium'],
title: '[Chromium]',
environments: [customEnvironment],
},
{
files: [
'./apicoverage.spec.js',
],
environments: [],
},
],
};

150
test/test.js
View file

@ -15,9 +15,10 @@
* limitations under the License.
*/
const fs = require('fs');
const readline = require('readline');
const TestRunner = require('../utils/testrunner/');
const utils = require('./utils');
const os = require('os');
const {Environment} = require('../utils/testrunner/Test');
let parallel = 1;
if (process.env.PW_PARALLEL_TESTS)
@ -36,6 +37,8 @@ if (MAJOR_NODEJS_VERSION >= 8 && require('inspector').url()) {
timeout = 0;
}
const config = require('./test.config');
const testRunner = new TestRunner({
timeout,
totalTimeout: process.env.CI ? 15 * 60 * 1000 : 0,
@ -46,20 +49,150 @@ const testRunner = new TestRunner({
showSlowTests: process.env.CI ? 5 : 0,
showMarkedAsFailingTests: 10,
});
utils.setupTestRunner(testRunner);
if (config.setupTestRunner)
config.setupTestRunner(testRunner);
console.log('Testing on Node', process.version);
const products = ['Chromium', 'Firefox', 'WebKit'].filter(name => {
return process.env.BROWSER === name.toLowerCase() || process.env.BROWSER === 'all';
const browserNames = ['chromium', 'firefox', 'webkit'].filter(name => {
return process.env.BROWSER === name || process.env.BROWSER === 'all';
});
for (const [key, value] of Object.entries(testRunner.api()))
global[key] = value;
require('./playwright.spec.js').addPlaywrightTests({
testRunner,
products,
// TODO: this should be a preinstalled playwright by default.
const playwrightPath = config.playwrightPath;
const playwright = require(playwrightPath);
const playwrightEnvironment = new Environment('Playwright');
playwrightEnvironment.beforeAll(async state => {
state.playwright = playwright;
global.playwright = playwright;
});
playwrightEnvironment.afterAll(async state => {
delete state.playwright;
delete global.playwright;
});
testRunner.collector().useEnvironment(playwrightEnvironment);
for (const e of config.globalEnvironments || [])
testRunner.collector().useEnvironment(e);
for (const browserName of browserNames) {
const browserType = playwright[browserName];
const browserTypeEnvironment = new Environment('BrowserType');
browserTypeEnvironment.beforeAll(async state => {
state.browserType = browserType;
});
browserTypeEnvironment.afterAll(async state => {
delete state.browserType;
});
// TODO: maybe launch options per browser?
const launchOptions = {
...(config.launchOptions || {}),
handleSIGINT: false,
};
if (launchOptions.executablePath)
launchOptions.executablePath = launchOptions.executablePath[browserName];
if (launchOptions.executablePath) {
const YELLOW_COLOR = '\x1b[33m';
const RESET_COLOR = '\x1b[0m';
console.warn(`${YELLOW_COLOR}WARN: running ${browserName} tests with ${launchOptions.executablePath}${RESET_COLOR}`);
browserType._executablePath = launchOptions.executablePath;
delete launchOptions.executablePath;
} else {
if (!fs.existsSync(browserType.executablePath()))
throw new Error(`Browser is not downloaded. Run 'npm install' and try to re-run tests`);
}
const browserEnvironment = new Environment(browserName);
browserEnvironment.beforeAll(async state => {
state.browser = await state.browserType.launch(launchOptions);
// TODO: remove browserServer from state.
state.browserServer = state.browser._ownedServer;
state._stdout = readline.createInterface({ input: state.browserServer.process().stdout });
state._stderr = readline.createInterface({ input: state.browserServer.process().stderr });
});
browserEnvironment.afterAll(async state => {
await state.browserServer.close();
delete state.browser;
delete state.browserServer;
state._stdout.close();
state._stderr.close();
delete state._stdout;
delete state._stderr;
});
browserEnvironment.beforeEach(async(state, testRun) => {
const dumpout = data => testRun.log(`\x1b[33m[pw:stdio:out]\x1b[0m ${data}`);
const dumperr = data => testRun.log(`\x1b[31m[pw:stdio:err]\x1b[0m ${data}`);
state._stdout.on('line', dumpout);
state._stderr.on('line', dumperr);
// TODO: figure out debug options.
if (config.dumpProtocolOnFailure) {
state.browser._debugProtocol.log = data => testRun.log(`\x1b[32m[pw:protocol]\x1b[0m ${data}`);
state.browser._debugProtocol.enabled = true;
}
state._browserTearDown = async (testRun) => {
state._stdout.off('line', dumpout);
state._stderr.off('line', dumperr);
if (config.dumpProtocolOnFailure) {
delete state.browser._debugProtocol.log;
state.browser._debugProtocol.enabled = false;
if (testRun.ok())
testRun.output().splice(0);
}
};
});
browserEnvironment.afterEach(async (state, testRun) => {
await state._browserTearDown(testRun);
delete state._browserTearDown;
});
const pageEnvironment = new Environment('Page');
pageEnvironment.beforeEach(async state => {
state.context = await state.browser.newContext();
state.page = await state.context.newPage();
});
pageEnvironment.afterEach(async state => {
await state.context.close();
state.context = null;
state.page = null;
});
const suiteName = { 'chromium': 'Chromium', 'firefox': 'Firefox', 'webkit': 'WebKit' }[browserName];
describe(suiteName, () => {
// In addition to state, expose these two on global so that describes can access them.
global.playwright = playwright;
global.browserType = browserType;
testRunner.collector().useEnvironment(browserTypeEnvironment);
for (const spec of config.specs || []) {
const skip = spec.browsers && !spec.browsers.includes(browserName);
(skip ? xdescribe : describe)(spec.title || '', () => {
for (const e of spec.environments || ['page']) {
if (e === 'browser') {
testRunner.collector().useEnvironment(browserEnvironment);
} else if (e === 'page') {
testRunner.collector().useEnvironment(browserEnvironment);
testRunner.collector().useEnvironment(pageEnvironment);
} else {
testRunner.collector().useEnvironment(e);
}
}
for (const file of spec.files || []) {
require(file);
delete require.cache[require.resolve(file)];
}
});
}
delete global.browserType;
delete global.playwright;
});
}
for (const [key, value] of Object.entries(testRunner.api())) {
// expect is used when running tests, while the rest of api is not.
if (key !== 'expect')
@ -72,5 +205,4 @@ if (filterArgIndex !== -1) {
testRunner.focusMatchingTests(new RegExp(filter, 'i'));
}
// await utils.initializeFlakinessDashboardIfNeeded(testRunner);
testRunner.run().then(() => { delete global.expect; });

45
test/utils.js
View file

@ -20,7 +20,6 @@ const path = require('path');
const util = require('util');
const os = require('os');
const removeFolder = require('rimraf');
const url = require('url');
const {FlakinessDashboard} = require('../utils/flakiness-dashboard');
const PROJECT_ROOT = fs.existsSync(path.join(__dirname, '..', 'package.json')) ? path.join(__dirname, '..') : path.join(__dirname, '..', '..');
@ -170,50 +169,6 @@ const utils = module.exports = {
await removeFolderAsync(dir).catch(e => {});
},
setupTestRunner: function(testRunner) {
const collector = testRunner._collector;
collector.addTestModifier('skip', (t, condition) => condition && t.setSkipped(true));
collector.addSuiteModifier('skip', (s, condition) => condition && s.setSkipped(true));
collector.addTestModifier('fail', (t, condition) => condition && t.setExpectation(t.Expectations.Fail));
collector.addSuiteModifier('fail', (s, condition) => condition && s.setExpectation(s.Expectations.Fail));
collector.addTestModifier('slow', t => t.setTimeout(t.timeout() * 3));
collector.addTestAttribute('debug', t => {
t.setTimeout(100000000);
let session;
t.environment().beforeEach(async () => {
const inspector = require('inspector');
const readFileAsync = util.promisify(fs.readFile.bind(fs));
session = new inspector.Session();
session.connect();
const postAsync = util.promisify(session.post.bind(session));
await postAsync('Debugger.enable');
const setBreakpointCommands = [];
const N = t.body().toString().split('\n').length;
const location = t.location();
const lines = (await readFileAsync(location.filePath(), 'utf8')).split('\n');
for (let line = 0; line < N; ++line) {
const lineNumber = line + location.lineNumber();
setBreakpointCommands.push(postAsync('Debugger.setBreakpointByUrl', {
url: url.pathToFileURL(location.filePath()),
lineNumber,
condition: `console.log('${String(lineNumber + 1).padStart(6, ' ')} | ' + ${JSON.stringify(lines[lineNumber])})`,
}).catch(e => {}));
}
await Promise.all(setBreakpointCommands);
});
t.environment().afterEach(async () => {
session.disconnect();
});
});
testRunner.api().fdescribe = testRunner.api().describe.only;
testRunner.api().xdescribe = testRunner.api().describe.skip(true);
testRunner.api().fit = testRunner.api().it.only;
testRunner.api().xit = testRunner.api().it.skip(true);
testRunner.api().dit = testRunner.api().it.only.debug;
},
testOptions(browserType) {
const headless = !!valueFromEnv('HEADLESS', true);
const defaultBrowserOptions = {