index.js•34 kB
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports._baseTest = void 0;
Object.defineProperty(exports, "defineConfig", {
enumerable: true,
get: function () {
return _configLoader.defineConfig;
}
});
Object.defineProperty(exports, "expect", {
enumerable: true,
get: function () {
return _expect.expect;
}
});
Object.defineProperty(exports, "mergeExpects", {
enumerable: true,
get: function () {
return _expect.mergeExpects;
}
});
Object.defineProperty(exports, "mergeTests", {
enumerable: true,
get: function () {
return _testType.mergeTests;
}
});
exports.test = void 0;
var fs = _interopRequireWildcard(require("fs"));
var path = _interopRequireWildcard(require("path"));
var playwrightLibrary = _interopRequireWildcard(require("playwright-core"));
var _utils = require("playwright-core/lib/utils");
var _testType = require("./common/testType");
var _globals = require("./common/globals");
var _expect = require("./matchers/expect");
var _configLoader = require("./common/configLoader");
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
/**
* 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 _baseTest = exports._baseTest = _testType.rootTestType.test;
(0, _utils.addInternalStackPrefix)(path.dirname(require.resolve('../package.json')));
if (process['__pw_initiator__']) {
const originalStackTraceLimit = Error.stackTraceLimit;
Error.stackTraceLimit = 200;
try {
throw new Error('Requiring @playwright/test second time, \nFirst:\n' + process['__pw_initiator__'] + '\n\nSecond: ');
} finally {
Error.stackTraceLimit = originalStackTraceLimit;
}
} else {
process['__pw_initiator__'] = new Error().stack;
}
const playwrightFixtures = {
defaultBrowserType: ['chromium', {
scope: 'worker',
option: true
}],
browserName: [({
defaultBrowserType
}, use) => use(defaultBrowserType), {
scope: 'worker',
option: true
}],
playwright: [async ({}, use) => {
await use(require('playwright-core'));
}, {
scope: 'worker',
box: true
}],
headless: [({
launchOptions
}, use) => {
var _launchOptions$headle;
return use((_launchOptions$headle = launchOptions.headless) !== null && _launchOptions$headle !== void 0 ? _launchOptions$headle : true);
}, {
scope: 'worker',
option: true
}],
channel: [({
launchOptions
}, use) => use(launchOptions.channel), {
scope: 'worker',
option: true
}],
launchOptions: [{}, {
scope: 'worker',
option: true
}],
connectOptions: [async ({
_optionConnectOptions
}, use) => {
await use(connectOptionsFromEnv() || _optionConnectOptions);
}, {
scope: 'worker',
option: true
}],
screenshot: ['off', {
scope: 'worker',
option: true
}],
video: ['off', {
scope: 'worker',
option: true
}],
trace: ['off', {
scope: 'worker',
option: true
}],
_browserOptions: [async ({
playwright,
headless,
channel,
launchOptions
}, use) => {
const options = {
handleSIGINT: false,
...launchOptions
};
if (headless !== undefined) options.headless = headless;
if (channel !== undefined) options.channel = channel;
options.tracesDir = tracing().tracesDir();
for (const browserType of [playwright.chromium, playwright.firefox, playwright.webkit, playwright._bidiChromium, playwright._bidiFirefox]) browserType._defaultLaunchOptions = options;
await use(options);
for (const browserType of [playwright.chromium, playwright.firefox, playwright.webkit, playwright._bidiChromium, playwright._bidiFirefox]) browserType._defaultLaunchOptions = undefined;
}, {
scope: 'worker',
auto: true,
box: true
}],
browser: [async ({
playwright,
browserName,
_browserOptions,
connectOptions,
_reuseContext
}, use, testInfo) => {
if (!['chromium', 'firefox', 'webkit', '_bidiChromium', '_bidiFirefox'].includes(browserName)) throw new Error(`Unexpected browserName "${browserName}", must be one of "chromium", "firefox" or "webkit"`);
if (connectOptions) {
var _connectOptions$expos;
const browser = await playwright[browserName].connect({
...connectOptions,
exposeNetwork: (_connectOptions$expos = connectOptions.exposeNetwork) !== null && _connectOptions$expos !== void 0 ? _connectOptions$expos : connectOptions._exposeNetwork,
headers: {
...(_reuseContext ? {
'x-playwright-reuse-context': '1'
} : {}),
// HTTP headers are ASCII only (not UTF-8).
'x-playwright-launch-options': (0, _utils.jsonStringifyForceASCII)(_browserOptions),
...connectOptions.headers
}
});
await use(browser);
await browser._wrapApiCall(async () => {
await browser.close({
reason: 'Test ended.'
});
}, true);
return;
}
const browser = await playwright[browserName].launch();
await use(browser);
await browser._wrapApiCall(async () => {
await browser.close({
reason: 'Test ended.'
});
}, true);
}, {
scope: 'worker',
timeout: 0
}],
acceptDownloads: [({
contextOptions
}, use) => {
var _contextOptions$accep;
return use((_contextOptions$accep = contextOptions.acceptDownloads) !== null && _contextOptions$accep !== void 0 ? _contextOptions$accep : true);
}, {
option: true
}],
bypassCSP: [({
contextOptions
}, use) => {
var _contextOptions$bypas;
return use((_contextOptions$bypas = contextOptions.bypassCSP) !== null && _contextOptions$bypas !== void 0 ? _contextOptions$bypas : false);
}, {
option: true
}],
colorScheme: [({
contextOptions
}, use) => use(contextOptions.colorScheme === undefined ? 'light' : contextOptions.colorScheme), {
option: true
}],
deviceScaleFactor: [({
contextOptions
}, use) => use(contextOptions.deviceScaleFactor), {
option: true
}],
extraHTTPHeaders: [({
contextOptions
}, use) => use(contextOptions.extraHTTPHeaders), {
option: true
}],
geolocation: [({
contextOptions
}, use) => use(contextOptions.geolocation), {
option: true
}],
hasTouch: [({
contextOptions
}, use) => {
var _contextOptions$hasTo;
return use((_contextOptions$hasTo = contextOptions.hasTouch) !== null && _contextOptions$hasTo !== void 0 ? _contextOptions$hasTo : false);
}, {
option: true
}],
httpCredentials: [({
contextOptions
}, use) => use(contextOptions.httpCredentials), {
option: true
}],
ignoreHTTPSErrors: [({
contextOptions
}, use) => {
var _contextOptions$ignor;
return use((_contextOptions$ignor = contextOptions.ignoreHTTPSErrors) !== null && _contextOptions$ignor !== void 0 ? _contextOptions$ignor : false);
}, {
option: true
}],
isMobile: [({
contextOptions
}, use) => {
var _contextOptions$isMob;
return use((_contextOptions$isMob = contextOptions.isMobile) !== null && _contextOptions$isMob !== void 0 ? _contextOptions$isMob : false);
}, {
option: true
}],
javaScriptEnabled: [({
contextOptions
}, use) => {
var _contextOptions$javaS;
return use((_contextOptions$javaS = contextOptions.javaScriptEnabled) !== null && _contextOptions$javaS !== void 0 ? _contextOptions$javaS : true);
}, {
option: true
}],
locale: [({
contextOptions
}, use) => {
var _contextOptions$local;
return use((_contextOptions$local = contextOptions.locale) !== null && _contextOptions$local !== void 0 ? _contextOptions$local : 'en-US');
}, {
option: true
}],
offline: [({
contextOptions
}, use) => {
var _contextOptions$offli;
return use((_contextOptions$offli = contextOptions.offline) !== null && _contextOptions$offli !== void 0 ? _contextOptions$offli : false);
}, {
option: true
}],
permissions: [({
contextOptions
}, use) => use(contextOptions.permissions), {
option: true
}],
proxy: [({
contextOptions
}, use) => use(contextOptions.proxy), {
option: true
}],
storageState: [({
contextOptions
}, use) => use(contextOptions.storageState), {
option: true
}],
clientCertificates: [({
contextOptions
}, use) => use(contextOptions.clientCertificates), {
option: true
}],
timezoneId: [({
contextOptions
}, use) => use(contextOptions.timezoneId), {
option: true
}],
userAgent: [({
contextOptions
}, use) => use(contextOptions.userAgent), {
option: true
}],
viewport: [({
contextOptions
}, use) => use(contextOptions.viewport === undefined ? {
width: 1280,
height: 720
} : contextOptions.viewport), {
option: true
}],
actionTimeout: [0, {
option: true
}],
testIdAttribute: ['data-testid', {
option: true
}],
navigationTimeout: [0, {
option: true
}],
baseURL: [async ({}, use) => {
await use(process.env.PLAYWRIGHT_TEST_BASE_URL);
}, {
option: true
}],
serviceWorkers: [({
contextOptions
}, use) => {
var _contextOptions$servi;
return use((_contextOptions$servi = contextOptions.serviceWorkers) !== null && _contextOptions$servi !== void 0 ? _contextOptions$servi : 'allow');
}, {
option: true
}],
contextOptions: [{}, {
option: true
}],
_combinedContextOptions: [async ({
acceptDownloads,
bypassCSP,
clientCertificates,
colorScheme,
deviceScaleFactor,
extraHTTPHeaders,
hasTouch,
geolocation,
httpCredentials,
ignoreHTTPSErrors,
isMobile,
javaScriptEnabled,
locale,
offline,
permissions,
proxy,
storageState,
viewport,
timezoneId,
userAgent,
baseURL,
contextOptions,
serviceWorkers
}, use) => {
const options = {};
if (acceptDownloads !== undefined) options.acceptDownloads = acceptDownloads;
if (bypassCSP !== undefined) options.bypassCSP = bypassCSP;
if (colorScheme !== undefined) options.colorScheme = colorScheme;
if (deviceScaleFactor !== undefined) options.deviceScaleFactor = deviceScaleFactor;
if (extraHTTPHeaders !== undefined) options.extraHTTPHeaders = extraHTTPHeaders;
if (geolocation !== undefined) options.geolocation = geolocation;
if (hasTouch !== undefined) options.hasTouch = hasTouch;
if (httpCredentials !== undefined) options.httpCredentials = httpCredentials;
if (ignoreHTTPSErrors !== undefined) options.ignoreHTTPSErrors = ignoreHTTPSErrors;
if (isMobile !== undefined) options.isMobile = isMobile;
if (javaScriptEnabled !== undefined) options.javaScriptEnabled = javaScriptEnabled;
if (locale !== undefined) options.locale = locale;
if (offline !== undefined) options.offline = offline;
if (permissions !== undefined) options.permissions = permissions;
if (proxy !== undefined) options.proxy = proxy;
if (storageState !== undefined) options.storageState = storageState;
if (clientCertificates !== null && clientCertificates !== void 0 && clientCertificates.length) options.clientCertificates = resolveClientCerticates(clientCertificates);
if (timezoneId !== undefined) options.timezoneId = timezoneId;
if (userAgent !== undefined) options.userAgent = userAgent;
if (viewport !== undefined) options.viewport = viewport;
if (baseURL !== undefined) options.baseURL = baseURL;
if (serviceWorkers !== undefined) options.serviceWorkers = serviceWorkers;
await use({
...contextOptions,
...options
});
}, {
box: true
}],
_setupContextOptions: [async ({
playwright,
_combinedContextOptions,
actionTimeout,
navigationTimeout,
testIdAttribute
}, use, testInfo) => {
if (testIdAttribute) playwrightLibrary.selectors.setTestIdAttribute(testIdAttribute);
testInfo.snapshotSuffix = process.platform;
if ((0, _utils.debugMode)()) testInfo._setDebugMode();
for (const browserType of [playwright.chromium, playwright.firefox, playwright.webkit]) {
browserType._defaultContextOptions = _combinedContextOptions;
browserType._defaultContextTimeout = actionTimeout || 0;
browserType._defaultContextNavigationTimeout = navigationTimeout || 0;
}
playwright.request._defaultContextOptions = {
..._combinedContextOptions
};
playwright.request._defaultContextOptions.tracesDir = tracing().tracesDir();
playwright.request._defaultContextOptions.timeout = actionTimeout || 0;
await use();
playwright.request._defaultContextOptions = undefined;
for (const browserType of [playwright.chromium, playwright.firefox, playwright.webkit]) {
browserType._defaultContextOptions = undefined;
browserType._defaultContextTimeout = undefined;
browserType._defaultContextNavigationTimeout = undefined;
}
}, {
auto: 'all-hooks-included',
title: 'context configuration',
box: true
}],
_setupArtifacts: [async ({
playwright,
screenshot
}, use, testInfo) => {
// This fixture has a separate zero-timeout slot to ensure that artifact collection
// happens even after some fixtures or hooks time out.
// Now that default test timeout is known, we can replace zero with an actual value.
testInfo.setTimeout(testInfo.project.timeout);
const artifactsRecorder = new ArtifactsRecorder(playwright, tracing().artifactsDir(), screenshot);
await artifactsRecorder.willStartTest(testInfo);
const tracingGroupSteps = [];
const csiListener = {
onApiCallBegin: data => {
const testInfo = (0, _globals.currentTestInfo)();
// Some special calls do not get into steps.
if (!testInfo || data.apiName.includes('setTestIdAttribute') || data.apiName === 'tracing.groupEnd') return;
const zone = _utils.zones.zoneData('stepZone');
if (zone && zone.category === 'expect') {
// Display the internal locator._expect call under the name of the enclosing expect call,
// and connect it to the existing expect step.
data.apiName = zone.title;
data.stepId = zone.stepId;
return;
}
// In the general case, create a step for each api call and connect them through the stepId.
const step = testInfo._addStep({
location: data.frames[0],
category: 'pw:api',
title: renderApiCall(data.apiName, data.params),
apiName: data.apiName,
params: data.params
}, tracingGroupSteps[tracingGroupSteps.length - 1]);
data.userData = step;
data.stepId = step.stepId;
if (data.apiName === 'tracing.group') tracingGroupSteps.push(step);
},
onApiCallEnd: data => {
// "tracing.group" step will end later, when "tracing.groupEnd" finishes.
if (data.apiName === 'tracing.group') return;
if (data.apiName === 'tracing.groupEnd') {
const step = tracingGroupSteps.pop();
step === null || step === void 0 || step.complete({
error: data.error
});
return;
}
const step = data.userData;
step === null || step === void 0 || step.complete({
error: data.error
});
},
onWillPause: ({
keepTestTimeout
}) => {
var _currentTestInfo;
if (!keepTestTimeout) (_currentTestInfo = (0, _globals.currentTestInfo)()) === null || _currentTestInfo === void 0 || _currentTestInfo._setDebugMode();
},
runAfterCreateBrowserContext: async context => {
await (artifactsRecorder === null || artifactsRecorder === void 0 ? void 0 : artifactsRecorder.didCreateBrowserContext(context));
const testInfo = (0, _globals.currentTestInfo)();
if (testInfo) attachConnectedHeaderIfNeeded(testInfo, context.browser());
},
runAfterCreateRequestContext: async context => {
await (artifactsRecorder === null || artifactsRecorder === void 0 ? void 0 : artifactsRecorder.didCreateRequestContext(context));
},
runBeforeCloseBrowserContext: async context => {
await (artifactsRecorder === null || artifactsRecorder === void 0 ? void 0 : artifactsRecorder.willCloseBrowserContext(context));
},
runBeforeCloseRequestContext: async context => {
await (artifactsRecorder === null || artifactsRecorder === void 0 ? void 0 : artifactsRecorder.willCloseRequestContext(context));
}
};
const clientInstrumentation = playwright._instrumentation;
clientInstrumentation.addListener(csiListener);
await use();
clientInstrumentation.removeListener(csiListener);
await artifactsRecorder.didFinishTest();
}, {
auto: 'all-hooks-included',
title: 'trace recording',
box: true,
timeout: 0
}],
_contextFactory: [async ({
browser,
video,
_reuseContext,
_combinedContextOptions /** mitigate dep-via-auto lack of traceability */
}, use, testInfo) => {
const testInfoImpl = testInfo;
const videoMode = normalizeVideoMode(video);
const captureVideo = shouldCaptureVideo(videoMode, testInfo) && !_reuseContext;
const contexts = new Map();
await use(async options => {
const hook = testInfoImpl._currentHookType();
if (hook === 'beforeAll' || hook === 'afterAll') {
throw new Error([`"context" and "page" fixtures are not supported in "${hook}" since they are created on a per-test basis.`, `If you would like to reuse a single page between tests, create context manually with browser.newContext(). See https://aka.ms/playwright/reuse-page for details.`, `If you would like to configure your page before each test, do that in beforeEach hook instead.`].join('\n'));
}
const videoOptions = captureVideo ? {
recordVideo: {
dir: tracing().artifactsDir(),
size: typeof video === 'string' ? undefined : video.size
}
} : {};
const context = await browser.newContext({
...videoOptions,
...options
});
const contextData = {
pagesWithVideo: []
};
contexts.set(context, contextData);
if (captureVideo) context.on('page', page => contextData.pagesWithVideo.push(page));
if (process.env.PW_CLOCK === 'frozen') {
await context._wrapApiCall(async () => {
await context.clock.install({
time: 0
});
await context.clock.pauseAt(1000);
}, true);
} else if (process.env.PW_CLOCK === 'realtime') {
await context._wrapApiCall(async () => {
await context.clock.install({
time: 0
});
}, true);
}
return context;
});
let counter = 0;
const closeReason = testInfo.status === 'timedOut' ? 'Test timeout of ' + testInfo.timeout + 'ms exceeded.' : 'Test ended.';
await Promise.all([...contexts.keys()].map(async context => {
await context._wrapApiCall(async () => {
await context.close({
reason: closeReason
});
}, true);
const testFailed = testInfo.status !== testInfo.expectedStatus;
const preserveVideo = captureVideo && (videoMode === 'on' || testFailed && videoMode === 'retain-on-failure' || videoMode === 'on-first-retry' && testInfo.retry === 1);
if (preserveVideo) {
const {
pagesWithVideo: pagesForVideo
} = contexts.get(context);
const videos = pagesForVideo.map(p => p.video()).filter(Boolean);
await Promise.all(videos.map(async v => {
try {
const savedPath = testInfo.outputPath(`video${counter ? '-' + counter : ''}.webm`);
++counter;
await v.saveAs(savedPath);
testInfo.attachments.push({
name: 'video',
path: savedPath,
contentType: 'video/webm'
});
} catch (e) {
// Silent catch empty videos.
}
}));
}
}));
}, {
scope: 'test',
title: 'context',
box: true
}],
_optionContextReuseMode: ['none', {
scope: 'worker',
option: true
}],
_optionConnectOptions: [undefined, {
scope: 'worker',
option: true
}],
_reuseContext: [async ({
video,
_optionContextReuseMode
}, use) => {
let mode = _optionContextReuseMode;
if (process.env.PW_TEST_REUSE_CONTEXT) mode = 'when-possible';
const reuse = mode === 'when-possible' && normalizeVideoMode(video) === 'off';
await use(reuse);
}, {
scope: 'worker',
title: 'context',
box: true
}],
context: async ({
playwright,
browser,
_reuseContext,
_contextFactory
}, use, testInfo) => {
attachConnectedHeaderIfNeeded(testInfo, browser);
if (!_reuseContext) {
await use(await _contextFactory());
return;
}
const defaultContextOptions = playwright.chromium._defaultContextOptions;
const context = await browser._newContextForReuse(defaultContextOptions);
context[kIsReusedContext] = true;
await use(context);
const closeReason = testInfo.status === 'timedOut' ? 'Test timeout of ' + testInfo.timeout + 'ms exceeded.' : 'Test ended.';
await browser._stopPendingOperations(closeReason);
},
page: async ({
context,
_reuseContext
}, use) => {
if (!_reuseContext) {
await use(await context.newPage());
return;
}
// First time we are reusing the context, we should create the page.
let [page] = context.pages();
if (!page) page = await context.newPage();
await use(page);
},
request: async ({
playwright
}, use) => {
const request = await playwright.request.newContext();
await use(request);
const hook = test.info()._currentHookType();
if (hook === 'beforeAll') {
await request.dispose({
reason: [`Fixture { request } from beforeAll cannot be reused in a test.`, ` - Recommended fix: use a separate { request } in the test.`, ` - Alternatively, manually create APIRequestContext in beforeAll and dispose it in afterAll.`, `See https://playwright.dev/docs/api-testing#sending-api-requests-from-ui-tests for more details.`].join('\n')
});
} else {
await request.dispose();
}
}
};
function normalizeVideoMode(video) {
if (!video) return 'off';
let videoMode = typeof video === 'string' ? video : video.mode;
if (videoMode === 'retry-with-video') videoMode = 'on-first-retry';
return videoMode;
}
function shouldCaptureVideo(videoMode, testInfo) {
return videoMode === 'on' || videoMode === 'retain-on-failure' || videoMode === 'on-first-retry' && testInfo.retry === 1;
}
function normalizeScreenshotMode(screenshot) {
if (!screenshot) return 'off';
return typeof screenshot === 'string' ? screenshot : screenshot.mode;
}
function attachConnectedHeaderIfNeeded(testInfo, browser) {
const connectHeaders = browser === null || browser === void 0 ? void 0 : browser._connectHeaders;
if (!connectHeaders) return;
for (const header of connectHeaders) {
if (header.name !== 'x-playwright-attachment') continue;
const [name, value] = header.value.split('=');
if (!name || !value) continue;
if (testInfo.attachments.some(attachment => attachment.name === name)) continue;
testInfo.attachments.push({
name,
contentType: 'text/plain',
body: Buffer.from(value)
});
}
}
function resolveFileToConfig(file) {
const config = test.info().config.configFile;
if (!config || !file) return file;
if (path.isAbsolute(file)) return file;
return path.resolve(path.dirname(config), file);
}
function resolveClientCerticates(clientCertificates) {
for (const cert of clientCertificates) {
cert.certPath = resolveFileToConfig(cert.certPath);
cert.keyPath = resolveFileToConfig(cert.keyPath);
cert.pfxPath = resolveFileToConfig(cert.pfxPath);
}
return clientCertificates;
}
const kTracingStarted = Symbol('kTracingStarted');
const kIsReusedContext = Symbol('kReusedContext');
function connectOptionsFromEnv() {
const wsEndpoint = process.env.PW_TEST_CONNECT_WS_ENDPOINT;
if (!wsEndpoint) return undefined;
const headers = process.env.PW_TEST_CONNECT_HEADERS ? JSON.parse(process.env.PW_TEST_CONNECT_HEADERS) : undefined;
return {
wsEndpoint,
headers,
exposeNetwork: process.env.PW_TEST_CONNECT_EXPOSE_NETWORK
};
}
class ArtifactsRecorder {
constructor(playwright, artifactsDir, screenshot) {
this._testInfo = void 0;
this._playwright = void 0;
this._artifactsDir = void 0;
this._screenshotMode = void 0;
this._screenshotOptions = void 0;
this._temporaryScreenshots = [];
this._temporaryArtifacts = [];
this._reusedContexts = new Set();
this._screenshotOrdinal = 0;
this._screenshottedSymbol = void 0;
this._startedCollectingArtifacts = void 0;
this._playwright = playwright;
this._artifactsDir = artifactsDir;
this._screenshotMode = normalizeScreenshotMode(screenshot);
this._screenshotOptions = typeof screenshot === 'string' ? undefined : screenshot;
this._screenshottedSymbol = Symbol('screenshotted');
this._startedCollectingArtifacts = Symbol('startedCollectingArtifacts');
}
_createTemporaryArtifact(...name) {
const file = path.join(this._artifactsDir, ...name);
this._temporaryArtifacts.push(file);
return file;
}
async willStartTest(testInfo) {
this._testInfo = testInfo;
testInfo._onDidFinishTestFunction = () => this.didFinishTestFunction();
// Since beforeAll(s), test and afterAll(s) reuse the same TestInfo, make sure we do not
// overwrite previous screenshots.
this._screenshotOrdinal = testInfo.attachments.filter(a => a.name === 'screenshot').length;
// Process existing contexts.
for (const browserType of [this._playwright.chromium, this._playwright.firefox, this._playwright.webkit]) {
const promises = [];
const existingContexts = Array.from(browserType._contexts);
for (const context of existingContexts) {
if (context[kIsReusedContext]) this._reusedContexts.add(context);else promises.push(this.didCreateBrowserContext(context));
}
await Promise.all(promises);
}
{
const existingApiRequests = Array.from(this._playwright.request._contexts);
await Promise.all(existingApiRequests.map(c => this.didCreateRequestContext(c)));
}
}
async didCreateBrowserContext(context) {
await this._startTraceChunkOnContextCreation(context.tracing);
}
async willCloseBrowserContext(context) {
// When reusing context, we get all previous contexts closed at the start of next test.
// Do not record empty traces and useless screenshots for them.
if (this._reusedContexts.has(context)) return;
await this._stopTracing(context.tracing);
if (this._screenshotMode === 'on' || this._screenshotMode === 'only-on-failure' || this._screenshotMode === 'on-first-failure' && this._testInfo.retry === 0) {
// Capture screenshot for now. We'll know whether we have to preserve them
// after the test finishes.
await Promise.all(context.pages().map(page => this._screenshotPage(page, true)));
}
}
async didCreateRequestContext(context) {
const tracing = context._tracing;
await this._startTraceChunkOnContextCreation(tracing);
}
async willCloseRequestContext(context) {
const tracing = context._tracing;
await this._stopTracing(tracing);
}
_shouldCaptureScreenshotUponFinish() {
return this._screenshotMode === 'on' || this._screenshotMode === 'only-on-failure' && this._testInfo._isFailure() || this._screenshotMode === 'on-first-failure' && this._testInfo._isFailure() && this._testInfo.retry === 0;
}
async didFinishTestFunction() {
if (this._shouldCaptureScreenshotUponFinish()) await this._screenshotOnTestFailure();
}
async didFinishTest() {
const captureScreenshots = this._shouldCaptureScreenshotUponFinish();
if (captureScreenshots) await this._screenshotOnTestFailure();
let leftoverContexts = [];
for (const browserType of [this._playwright.chromium, this._playwright.firefox, this._playwright.webkit]) leftoverContexts.push(...browserType._contexts);
leftoverContexts = leftoverContexts.filter(context => !this._reusedContexts.has(context));
const leftoverApiRequests = Array.from(this._playwright.request._contexts);
// Collect traces/screenshots for remaining contexts.
await Promise.all(leftoverContexts.map(async context => {
await this._stopTracing(context.tracing);
}).concat(leftoverApiRequests.map(async context => {
const tracing = context._tracing;
await this._stopTracing(tracing);
})));
// Attach temporary screenshots for contexts closed before collecting the test trace.
if (captureScreenshots) {
for (const file of this._temporaryScreenshots) {
try {
const screenshotPath = this._createScreenshotAttachmentPath();
await fs.promises.rename(file, screenshotPath);
this._attachScreenshot(screenshotPath);
} catch {}
}
}
}
_createScreenshotAttachmentPath() {
const testFailed = this._testInfo._isFailure();
const index = this._screenshotOrdinal + 1;
++this._screenshotOrdinal;
const screenshotPath = this._testInfo.outputPath(`test-${testFailed ? 'failed' : 'finished'}-${index}.png`);
return screenshotPath;
}
async _screenshotPage(page, temporary) {
if (page[this._screenshottedSymbol]) return;
page[this._screenshottedSymbol] = true;
try {
const screenshotPath = temporary ? this._createTemporaryArtifact((0, _utils.createGuid)() + '.png') : this._createScreenshotAttachmentPath();
// Pass caret=initial to avoid any evaluations that might slow down the screenshot
// and let the page modify itself from the problematic state it had at the moment of failure.
await page.screenshot({
...this._screenshotOptions,
timeout: 5000,
path: screenshotPath,
caret: 'initial'
});
if (temporary) this._temporaryScreenshots.push(screenshotPath);else this._attachScreenshot(screenshotPath);
} catch {
// Screenshot may fail, just ignore.
}
}
_attachScreenshot(screenshotPath) {
this._testInfo.attachments.push({
name: 'screenshot',
path: screenshotPath,
contentType: 'image/png'
});
}
async _screenshotOnTestFailure() {
const contexts = [];
for (const browserType of [this._playwright.chromium, this._playwright.firefox, this._playwright.webkit]) contexts.push(...browserType._contexts);
const pages = contexts.map(ctx => ctx.pages()).flat();
await Promise.all(pages.map(page => this._screenshotPage(page, false)));
}
async _startTraceChunkOnContextCreation(tracing) {
const options = this._testInfo._tracing.traceOptions();
if (options) {
const title = this._testInfo._tracing.traceTitle();
const name = this._testInfo._tracing.generateNextTraceRecordingName();
if (!tracing[kTracingStarted]) {
await tracing.start({
...options,
title,
name
});
tracing[kTracingStarted] = true;
} else {
await tracing.startChunk({
title,
name
});
}
} else {
if (tracing[kTracingStarted]) {
tracing[kTracingStarted] = false;
await tracing.stop();
}
}
}
async _stopTracing(tracing) {
if (tracing[this._startedCollectingArtifacts]) return;
tracing[this._startedCollectingArtifacts] = true;
if (this._testInfo._tracing.traceOptions() && tracing[kTracingStarted]) await tracing.stopChunk({
path: this._testInfo._tracing.generateNextTraceRecordingPath()
});
}
}
const paramsToRender = ['url', 'selector', 'text', 'key'];
function renderApiCall(apiName, params) {
if (apiName === 'tracing.group') return params.name;
const paramsArray = [];
if (params) {
for (const name of paramsToRender) {
if (!(name in params)) continue;
let value;
if (name === 'selector' && (0, _utils.isString)(params[name]) && params[name].startsWith('internal:')) {
const getter = (0, _utils.asLocator)('javascript', params[name]);
apiName = apiName.replace(/^locator\./, 'locator.' + getter + '.');
apiName = apiName.replace(/^page\./, 'page.' + getter + '.');
apiName = apiName.replace(/^frame\./, 'frame.' + getter + '.');
} else {
value = params[name];
paramsArray.push(value);
}
}
}
const paramsText = paramsArray.length ? '(' + paramsArray.join(', ') + ')' : '';
return apiName + paramsText;
}
function tracing() {
return test.info()._tracing;
}
const test = exports.test = _baseTest.extend(playwrightFixtures);