558 lines
21 KiB
JavaScript
558 lines
21 KiB
JavaScript
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.TerminalReporter = void 0;
|
||
exports.fitToWidth = fitToWidth;
|
||
exports.formatError = formatError;
|
||
exports.formatFailure = formatFailure;
|
||
exports.formatResultFailure = formatResultFailure;
|
||
exports.formatRetry = formatRetry;
|
||
exports.nonTerminalScreen = exports.kOutputSymbol = exports.internalScreen = void 0;
|
||
exports.prepareErrorStack = prepareErrorStack;
|
||
exports.relativeFilePath = relativeFilePath;
|
||
exports.resolveOutputFile = resolveOutputFile;
|
||
exports.separator = separator;
|
||
exports.stepSuffix = stepSuffix;
|
||
exports.terminalScreen = void 0;
|
||
var _path = _interopRequireDefault(require("path"));
|
||
var _utils = require("playwright-core/lib/utils");
|
||
var _utilsBundle = require("playwright-core/lib/utilsBundle");
|
||
var _util = require("../util");
|
||
var _utilsBundle2 = require("../utilsBundle");
|
||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
|
||
/**
|
||
* 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 kOutputSymbol = exports.kOutputSymbol = Symbol('output');
|
||
// Output goes to terminal.
|
||
const terminalScreen = exports.terminalScreen = (() => {
|
||
let isTTY = !!process.stdout.isTTY;
|
||
let ttyWidth = process.stdout.columns || 0;
|
||
if (process.env.PLAYWRIGHT_FORCE_TTY === 'false' || process.env.PLAYWRIGHT_FORCE_TTY === '0') {
|
||
isTTY = false;
|
||
ttyWidth = 0;
|
||
} else if (process.env.PLAYWRIGHT_FORCE_TTY === 'true' || process.env.PLAYWRIGHT_FORCE_TTY === '1') {
|
||
isTTY = true;
|
||
ttyWidth = process.stdout.columns || 100;
|
||
} else if (process.env.PLAYWRIGHT_FORCE_TTY) {
|
||
isTTY = true;
|
||
ttyWidth = +process.env.PLAYWRIGHT_FORCE_TTY;
|
||
if (isNaN(ttyWidth)) ttyWidth = 100;
|
||
}
|
||
let useColors = isTTY;
|
||
if (process.env.DEBUG_COLORS === '0' || process.env.DEBUG_COLORS === 'false' || process.env.FORCE_COLOR === '0' || process.env.FORCE_COLOR === 'false') useColors = false;else if (process.env.DEBUG_COLORS || process.env.FORCE_COLOR) useColors = true;
|
||
const colors = useColors ? _utils.colors : _utils.noColors;
|
||
return {
|
||
resolveFiles: 'cwd',
|
||
isTTY,
|
||
ttyWidth,
|
||
colors
|
||
};
|
||
})();
|
||
|
||
// Output does not go to terminal, but colors are controlled with terminal env vars.
|
||
const nonTerminalScreen = exports.nonTerminalScreen = {
|
||
colors: terminalScreen.colors,
|
||
isTTY: false,
|
||
ttyWidth: 0,
|
||
resolveFiles: 'rootDir'
|
||
};
|
||
|
||
// Internal output for post-processing, should always contain real colors.
|
||
const internalScreen = exports.internalScreen = {
|
||
colors: _utils.colors,
|
||
isTTY: false,
|
||
ttyWidth: 0,
|
||
resolveFiles: 'rootDir'
|
||
};
|
||
class TerminalReporter {
|
||
constructor(options = {}) {
|
||
this.screen = terminalScreen;
|
||
this.config = void 0;
|
||
this.suite = void 0;
|
||
this.totalTestCount = 0;
|
||
this.result = void 0;
|
||
this.fileDurations = new Map();
|
||
this._omitFailures = void 0;
|
||
this._fatalErrors = [];
|
||
this._failureCount = 0;
|
||
this._omitFailures = options.omitFailures || false;
|
||
}
|
||
version() {
|
||
return 'v2';
|
||
}
|
||
onConfigure(config) {
|
||
this.config = config;
|
||
}
|
||
onBegin(suite) {
|
||
this.suite = suite;
|
||
this.totalTestCount = suite.allTests().length;
|
||
}
|
||
onStdOut(chunk, test, result) {
|
||
this._appendOutput({
|
||
chunk,
|
||
type: 'stdout'
|
||
}, result);
|
||
}
|
||
onStdErr(chunk, test, result) {
|
||
this._appendOutput({
|
||
chunk,
|
||
type: 'stderr'
|
||
}, result);
|
||
}
|
||
_appendOutput(output, result) {
|
||
if (!result) return;
|
||
result[kOutputSymbol] = result[kOutputSymbol] || [];
|
||
result[kOutputSymbol].push(output);
|
||
}
|
||
onTestEnd(test, result) {
|
||
if (result.status !== 'skipped' && result.status !== test.expectedStatus) ++this._failureCount;
|
||
const projectName = test.titlePath()[1];
|
||
const relativePath = relativeTestPath(this.screen, this.config, test);
|
||
const fileAndProject = (projectName ? `[${projectName}] › ` : '') + relativePath;
|
||
const entry = this.fileDurations.get(fileAndProject) || {
|
||
duration: 0,
|
||
workers: new Set()
|
||
};
|
||
entry.duration += result.duration;
|
||
entry.workers.add(result.workerIndex);
|
||
this.fileDurations.set(fileAndProject, entry);
|
||
}
|
||
onError(error) {
|
||
this._fatalErrors.push(error);
|
||
}
|
||
async onEnd(result) {
|
||
this.result = result;
|
||
}
|
||
fitToScreen(line, prefix) {
|
||
if (!this.screen.ttyWidth) {
|
||
// Guard against the case where we cannot determine available width.
|
||
return line;
|
||
}
|
||
return fitToWidth(line, this.screen.ttyWidth, prefix);
|
||
}
|
||
generateStartingMessage() {
|
||
var _this$config$metadata;
|
||
const jobs = (_this$config$metadata = this.config.metadata.actualWorkers) !== null && _this$config$metadata !== void 0 ? _this$config$metadata : this.config.workers;
|
||
const shardDetails = this.config.shard ? `, shard ${this.config.shard.current} of ${this.config.shard.total}` : '';
|
||
if (!this.totalTestCount) return '';
|
||
return '\n' + this.screen.colors.dim('Running ') + this.totalTestCount + this.screen.colors.dim(` test${this.totalTestCount !== 1 ? 's' : ''} using `) + jobs + this.screen.colors.dim(` worker${jobs !== 1 ? 's' : ''}${shardDetails}`);
|
||
}
|
||
getSlowTests() {
|
||
if (!this.config.reportSlowTests) return [];
|
||
// Only pick durations that were served by single worker.
|
||
const fileDurations = [...this.fileDurations.entries()].filter(([key, value]) => value.workers.size === 1).map(([key, value]) => [key, value.duration]);
|
||
fileDurations.sort((a, b) => b[1] - a[1]);
|
||
const count = Math.min(fileDurations.length, this.config.reportSlowTests.max || Number.POSITIVE_INFINITY);
|
||
const threshold = this.config.reportSlowTests.threshold;
|
||
return fileDurations.filter(([, duration]) => duration > threshold).slice(0, count);
|
||
}
|
||
generateSummaryMessage({
|
||
didNotRun,
|
||
skipped,
|
||
expected,
|
||
interrupted,
|
||
unexpected,
|
||
flaky,
|
||
fatalErrors
|
||
}) {
|
||
const tokens = [];
|
||
if (unexpected.length) {
|
||
tokens.push(this.screen.colors.red(` ${unexpected.length} failed`));
|
||
for (const test of unexpected) tokens.push(this.screen.colors.red(this.formatTestHeader(test, {
|
||
indent: ' '
|
||
})));
|
||
}
|
||
if (interrupted.length) {
|
||
tokens.push(this.screen.colors.yellow(` ${interrupted.length} interrupted`));
|
||
for (const test of interrupted) tokens.push(this.screen.colors.yellow(this.formatTestHeader(test, {
|
||
indent: ' '
|
||
})));
|
||
}
|
||
if (flaky.length) {
|
||
tokens.push(this.screen.colors.yellow(` ${flaky.length} flaky`));
|
||
for (const test of flaky) tokens.push(this.screen.colors.yellow(this.formatTestHeader(test, {
|
||
indent: ' '
|
||
})));
|
||
}
|
||
if (skipped) tokens.push(this.screen.colors.yellow(` ${skipped} skipped`));
|
||
if (didNotRun) tokens.push(this.screen.colors.yellow(` ${didNotRun} did not run`));
|
||
if (expected) tokens.push(this.screen.colors.green(` ${expected} passed`) + this.screen.colors.dim(` (${(0, _utilsBundle.ms)(this.result.duration)})`));
|
||
if (fatalErrors.length && expected + unexpected.length + interrupted.length + flaky.length > 0) tokens.push(this.screen.colors.red(` ${fatalErrors.length === 1 ? '1 error was not a part of any test' : fatalErrors.length + ' errors were not a part of any test'}, see above for details`));
|
||
return tokens.join('\n');
|
||
}
|
||
generateSummary() {
|
||
let didNotRun = 0;
|
||
let skipped = 0;
|
||
let expected = 0;
|
||
const interrupted = [];
|
||
const interruptedToPrint = [];
|
||
const unexpected = [];
|
||
const flaky = [];
|
||
this.suite.allTests().forEach(test => {
|
||
switch (test.outcome()) {
|
||
case 'skipped':
|
||
{
|
||
if (test.results.some(result => result.status === 'interrupted')) {
|
||
if (test.results.some(result => !!result.error)) interruptedToPrint.push(test);
|
||
interrupted.push(test);
|
||
} else if (!test.results.length || test.expectedStatus !== 'skipped') {
|
||
++didNotRun;
|
||
} else {
|
||
++skipped;
|
||
}
|
||
break;
|
||
}
|
||
case 'expected':
|
||
++expected;
|
||
break;
|
||
case 'unexpected':
|
||
unexpected.push(test);
|
||
break;
|
||
case 'flaky':
|
||
flaky.push(test);
|
||
break;
|
||
}
|
||
});
|
||
const failuresToPrint = [...unexpected, ...flaky, ...interruptedToPrint];
|
||
return {
|
||
didNotRun,
|
||
skipped,
|
||
expected,
|
||
interrupted,
|
||
unexpected,
|
||
flaky,
|
||
failuresToPrint,
|
||
fatalErrors: this._fatalErrors
|
||
};
|
||
}
|
||
epilogue(full) {
|
||
const summary = this.generateSummary();
|
||
const summaryMessage = this.generateSummaryMessage(summary);
|
||
if (full && summary.failuresToPrint.length && !this._omitFailures) this._printFailures(summary.failuresToPrint);
|
||
this._printSlowTests();
|
||
// TODO: 1.52: Make warning display prettier
|
||
// this._printWarnings();
|
||
this._printSummary(summaryMessage);
|
||
}
|
||
_printFailures(failures) {
|
||
console.log('');
|
||
failures.forEach((test, index) => {
|
||
console.log(this.formatFailure(test, index + 1));
|
||
});
|
||
}
|
||
_printSlowTests() {
|
||
const slowTests = this.getSlowTests();
|
||
slowTests.forEach(([file, duration]) => {
|
||
console.log(this.screen.colors.yellow(' Slow test file: ') + file + this.screen.colors.yellow(` (${(0, _utilsBundle.ms)(duration)})`));
|
||
});
|
||
if (slowTests.length) console.log(this.screen.colors.yellow(' Consider running tests from slow files in parallel, see https://playwright.dev/docs/test-parallel.'));
|
||
}
|
||
_printWarnings() {
|
||
const warningTests = this.suite.allTests().filter(test => test.annotations.some(a => a.type === 'warning'));
|
||
const encounteredWarnings = new Map();
|
||
for (const test of warningTests) {
|
||
for (const annotation of test.annotations) {
|
||
if (annotation.type !== 'warning' || annotation.description === undefined) continue;
|
||
let tests = encounteredWarnings.get(annotation.description);
|
||
if (!tests) {
|
||
tests = [];
|
||
encounteredWarnings.set(annotation.description, tests);
|
||
}
|
||
tests.push(test);
|
||
}
|
||
}
|
||
for (const [description, tests] of encounteredWarnings) {
|
||
console.log(this.screen.colors.yellow(' Warning: ') + description);
|
||
for (const test of tests) console.log(this.formatTestHeader(test, {
|
||
indent: ' ',
|
||
mode: 'default'
|
||
}));
|
||
}
|
||
}
|
||
_printSummary(summary) {
|
||
if (summary.trim()) console.log(summary);
|
||
}
|
||
willRetry(test) {
|
||
return test.outcome() === 'unexpected' && test.results.length <= test.retries;
|
||
}
|
||
formatTestTitle(test, step, omitLocation = false) {
|
||
return formatTestTitle(this.screen, this.config, test, step, omitLocation);
|
||
}
|
||
formatTestHeader(test, options = {}) {
|
||
return formatTestHeader(this.screen, this.config, test, options);
|
||
}
|
||
formatFailure(test, index) {
|
||
return formatFailure(this.screen, this.config, test, index);
|
||
}
|
||
formatError(error) {
|
||
return formatError(this.screen, error);
|
||
}
|
||
}
|
||
exports.TerminalReporter = TerminalReporter;
|
||
function formatFailure(screen, config, test, index) {
|
||
const lines = [];
|
||
const header = formatTestHeader(screen, config, test, {
|
||
indent: ' ',
|
||
index,
|
||
mode: 'error'
|
||
});
|
||
lines.push(screen.colors.red(header));
|
||
for (const result of test.results) {
|
||
const resultLines = [];
|
||
const errors = formatResultFailure(screen, test, result, ' ');
|
||
if (!errors.length) continue;
|
||
const retryLines = [];
|
||
if (result.retry) {
|
||
retryLines.push('');
|
||
retryLines.push(screen.colors.gray(separator(screen, ` Retry #${result.retry}`)));
|
||
}
|
||
resultLines.push(...retryLines);
|
||
resultLines.push(...errors.map(error => '\n' + error.message));
|
||
for (let i = 0; i < result.attachments.length; ++i) {
|
||
const attachment = result.attachments[i];
|
||
if (attachment.name.startsWith('_')) continue;
|
||
const hasPrintableContent = attachment.contentType.startsWith('text/');
|
||
if (!attachment.path && !hasPrintableContent) continue;
|
||
resultLines.push('');
|
||
resultLines.push(screen.colors.cyan(separator(screen, ` attachment #${i + 1}: ${attachment.name} (${attachment.contentType})`)));
|
||
if (attachment.path) {
|
||
const relativePath = _path.default.relative(process.cwd(), attachment.path);
|
||
resultLines.push(screen.colors.cyan(` ${relativePath}`));
|
||
// Make this extensible
|
||
if (attachment.name === 'trace') {
|
||
const packageManagerCommand = (0, _utils.getPackageManagerExecCommand)();
|
||
resultLines.push(screen.colors.cyan(` Usage:`));
|
||
resultLines.push('');
|
||
resultLines.push(screen.colors.cyan(` ${packageManagerCommand} playwright show-trace ${quotePathIfNeeded(relativePath)}`));
|
||
resultLines.push('');
|
||
}
|
||
} else {
|
||
if (attachment.contentType.startsWith('text/') && attachment.body) {
|
||
let text = attachment.body.toString();
|
||
if (text.length > 300) text = text.slice(0, 300) + '...';
|
||
for (const line of text.split('\n')) resultLines.push(screen.colors.cyan(` ${line}`));
|
||
}
|
||
}
|
||
resultLines.push(screen.colors.cyan(separator(screen, ' ')));
|
||
}
|
||
lines.push(...resultLines);
|
||
}
|
||
lines.push('');
|
||
return lines.join('\n');
|
||
}
|
||
function formatRetry(screen, result) {
|
||
const retryLines = [];
|
||
if (result.retry) {
|
||
retryLines.push('');
|
||
retryLines.push(screen.colors.gray(separator(screen, ` Retry #${result.retry}`)));
|
||
}
|
||
return retryLines;
|
||
}
|
||
function quotePathIfNeeded(path) {
|
||
if (/\s/.test(path)) return `"${path}"`;
|
||
return path;
|
||
}
|
||
function formatResultFailure(screen, test, result, initialIndent) {
|
||
const errorDetails = [];
|
||
if (result.status === 'passed' && test.expectedStatus === 'failed') {
|
||
errorDetails.push({
|
||
message: indent(screen.colors.red(`Expected to fail, but passed.`), initialIndent)
|
||
});
|
||
}
|
||
if (result.status === 'interrupted') {
|
||
errorDetails.push({
|
||
message: indent(screen.colors.red(`Test was interrupted.`), initialIndent)
|
||
});
|
||
}
|
||
for (const error of result.errors) {
|
||
const formattedError = formatError(screen, error);
|
||
errorDetails.push({
|
||
message: indent(formattedError.message, initialIndent),
|
||
location: formattedError.location
|
||
});
|
||
}
|
||
return errorDetails;
|
||
}
|
||
function relativeFilePath(screen, config, file) {
|
||
if (screen.resolveFiles === 'cwd') return _path.default.relative(process.cwd(), file);
|
||
return _path.default.relative(config.rootDir, file);
|
||
}
|
||
function relativeTestPath(screen, config, test) {
|
||
return relativeFilePath(screen, config, test.location.file);
|
||
}
|
||
function stepSuffix(step) {
|
||
const stepTitles = step ? step.titlePath() : [];
|
||
return stepTitles.map(t => t.split('\n')[0]).map(t => ' › ' + t).join('');
|
||
}
|
||
function formatTestTitle(screen, config, test, step, omitLocation = false) {
|
||
// root, project, file, ...describes, test
|
||
const [, projectName,, ...titles] = test.titlePath();
|
||
let location;
|
||
if (omitLocation) location = `${relativeTestPath(screen, config, test)}`;else location = `${relativeTestPath(screen, config, test)}:${test.location.line}:${test.location.column}`;
|
||
const projectTitle = projectName ? `[${projectName}] › ` : '';
|
||
const testTitle = `${projectTitle}${location} › ${titles.join(' › ')}`;
|
||
const extraTags = test.tags.filter(t => !testTitle.includes(t));
|
||
return `${testTitle}${stepSuffix(step)}${extraTags.length ? ' ' + extraTags.join(' ') : ''}`;
|
||
}
|
||
function formatTestHeader(screen, config, test, options = {}) {
|
||
const title = formatTestTitle(screen, config, test);
|
||
const header = `${options.indent || ''}${options.index ? options.index + ') ' : ''}${title}`;
|
||
let fullHeader = header;
|
||
|
||
// Render the path to the deepest failing test.step.
|
||
if (options.mode === 'error') {
|
||
const stepPaths = new Set();
|
||
for (const result of test.results.filter(r => !!r.errors.length)) {
|
||
const stepPath = [];
|
||
const visit = steps => {
|
||
const errors = steps.filter(s => s.error);
|
||
if (errors.length > 1) return;
|
||
if (errors.length === 1 && errors[0].category === 'test.step') {
|
||
stepPath.push(errors[0].title);
|
||
visit(errors[0].steps);
|
||
}
|
||
};
|
||
visit(result.steps);
|
||
stepPaths.add(['', ...stepPath].join(' › '));
|
||
}
|
||
fullHeader = header + (stepPaths.size === 1 ? stepPaths.values().next().value : '');
|
||
}
|
||
return separator(screen, fullHeader);
|
||
}
|
||
function formatError(screen, error) {
|
||
const message = error.message || error.value || '';
|
||
const stack = error.stack;
|
||
if (!stack && !error.location) return {
|
||
message
|
||
};
|
||
const tokens = [];
|
||
|
||
// Now that we filter out internals from our stack traces, we can safely render
|
||
// the helper / original exception locations.
|
||
const parsedStack = stack ? prepareErrorStack(stack) : undefined;
|
||
tokens.push((parsedStack === null || parsedStack === void 0 ? void 0 : parsedStack.message) || message);
|
||
if (error.snippet) {
|
||
let snippet = error.snippet;
|
||
if (!screen.colors.enabled) snippet = (0, _util.stripAnsiEscapes)(snippet);
|
||
tokens.push('');
|
||
tokens.push(snippet);
|
||
}
|
||
if (parsedStack && parsedStack.stackLines.length) tokens.push(screen.colors.dim(parsedStack.stackLines.join('\n')));
|
||
let location = error.location;
|
||
if (parsedStack && !location) location = parsedStack.location;
|
||
if (error.cause) tokens.push(screen.colors.dim('[cause]: ') + formatError(screen, error.cause).message);
|
||
return {
|
||
location,
|
||
message: tokens.join('\n')
|
||
};
|
||
}
|
||
function separator(screen, text = '') {
|
||
if (text) text += ' ';
|
||
const columns = Math.min(100, screen.ttyWidth || 100);
|
||
return text + screen.colors.dim('─'.repeat(Math.max(0, columns - text.length)));
|
||
}
|
||
function indent(lines, tab) {
|
||
return lines.replace(/^(?=.+$)/gm, tab);
|
||
}
|
||
function prepareErrorStack(stack) {
|
||
return (0, _utils.parseErrorStack)(stack, _path.default.sep, !!process.env.PWDEBUGIMPL);
|
||
}
|
||
function characterWidth(c) {
|
||
return _utilsBundle2.getEastAsianWidth.eastAsianWidth(c.codePointAt(0));
|
||
}
|
||
function stringWidth(v) {
|
||
let width = 0;
|
||
for (const {
|
||
segment
|
||
} of new Intl.Segmenter(undefined, {
|
||
granularity: 'grapheme'
|
||
}).segment(v)) width += characterWidth(segment);
|
||
return width;
|
||
}
|
||
function suffixOfWidth(v, width) {
|
||
const segments = [...new Intl.Segmenter(undefined, {
|
||
granularity: 'grapheme'
|
||
}).segment(v)];
|
||
let suffixBegin = v.length;
|
||
for (const {
|
||
segment,
|
||
index
|
||
} of segments.reverse()) {
|
||
const segmentWidth = stringWidth(segment);
|
||
if (segmentWidth > width) break;
|
||
width -= segmentWidth;
|
||
suffixBegin = index;
|
||
}
|
||
return v.substring(suffixBegin);
|
||
}
|
||
|
||
// Leaves enough space for the "prefix" to also fit.
|
||
function fitToWidth(line, width, prefix) {
|
||
const prefixLength = prefix ? (0, _util.stripAnsiEscapes)(prefix).length : 0;
|
||
width -= prefixLength;
|
||
if (stringWidth(line) <= width) return line;
|
||
|
||
// Even items are plain text, odd items are control sequences.
|
||
const parts = line.split(_util.ansiRegex);
|
||
const taken = [];
|
||
for (let i = parts.length - 1; i >= 0; i--) {
|
||
if (i % 2) {
|
||
// Include all control sequences to preserve formatting.
|
||
taken.push(parts[i]);
|
||
} else {
|
||
let part = suffixOfWidth(parts[i], width);
|
||
const wasTruncated = part.length < parts[i].length;
|
||
if (wasTruncated && parts[i].length > 0) {
|
||
// Add ellipsis if we are truncating.
|
||
part = '\u2026' + suffixOfWidth(parts[i], width - 1);
|
||
}
|
||
taken.push(part);
|
||
width -= stringWidth(part);
|
||
}
|
||
}
|
||
return taken.reverse().join('');
|
||
}
|
||
function resolveFromEnv(name) {
|
||
const value = process.env[name];
|
||
if (value) return _path.default.resolve(process.cwd(), value);
|
||
return undefined;
|
||
}
|
||
|
||
// In addition to `outputFile` the function returns `outputDir` which should
|
||
// be cleaned up if present by some reporters contract.
|
||
function resolveOutputFile(reporterName, options) {
|
||
var _ref, _process$env, _options$default;
|
||
const name = reporterName.toUpperCase();
|
||
let outputFile = resolveFromEnv(`PLAYWRIGHT_${name}_OUTPUT_FILE`);
|
||
if (!outputFile && options.outputFile) outputFile = _path.default.resolve(options.configDir, options.outputFile);
|
||
if (outputFile) return {
|
||
outputFile
|
||
};
|
||
let outputDir = resolveFromEnv(`PLAYWRIGHT_${name}_OUTPUT_DIR`);
|
||
if (!outputDir && options.outputDir) outputDir = _path.default.resolve(options.configDir, options.outputDir);
|
||
if (!outputDir && options.default) outputDir = (0, _util.resolveReporterOutputPath)(options.default.outputDir, options.configDir, undefined);
|
||
if (!outputDir) outputDir = options.configDir;
|
||
const reportName = (_ref = (_process$env = process.env[`PLAYWRIGHT_${name}_OUTPUT_NAME`]) !== null && _process$env !== void 0 ? _process$env : options.fileName) !== null && _ref !== void 0 ? _ref : (_options$default = options.default) === null || _options$default === void 0 ? void 0 : _options$default.fileName;
|
||
if (!reportName) return undefined;
|
||
outputFile = _path.default.resolve(outputDir, reportName);
|
||
return {
|
||
outputFile,
|
||
outputDir
|
||
};
|
||
} |