Spaces:
Running
Running
File size: 28,316 Bytes
15b27a1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 | "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.create = exports.WorkerMain = void 0;
var _utilsBundle = require("playwright-core/lib/utilsBundle");
var _util = require("../util");
var _ipc = require("../common/ipc");
var _globals = require("../common/globals");
var _configLoader = require("../common/configLoader");
var _fixtureRunner = require("./fixtureRunner");
var _utils = require("playwright-core/lib/utils");
var _testInfo = require("./testInfo");
var _process = require("../common/process");
var _testLoader = require("../common/testLoader");
var _suiteUtils = require("../common/suiteUtils");
var _poolBuilder = require("../common/poolBuilder");
var _fixtures = require("../common/fixtures");
var _util2 = require("./util");
/**
* Copyright Microsoft Corporation. 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.
*/
class WorkerMain extends _process.ProcessRunner {
constructor(params) {
super();
this._params = void 0;
this._config = void 0;
this._project = void 0;
this._poolBuilder = void 0;
this._fixtureRunner = void 0;
// Accumulated fatal errors that cannot be attributed to a test.
this._fatalErrors = [];
// Whether we should skip running remaining tests in this suite because
// of a setup error, usually beforeAll hook.
this._skipRemainingTestsInSuite = void 0;
// The stage of the full cleanup. Once "finished", we can safely stop running anything.
this._didRunFullCleanup = false;
// Whether the worker was requested to stop.
this._isStopped = false;
// This promise resolves once the single "run test group" call finishes.
this._runFinished = new _utils.ManualPromise();
this._currentTest = null;
this._lastRunningTests = [];
this._totalRunningTests = 0;
// Suites that had their beforeAll hooks, but not afterAll hooks executed.
// These suites still need afterAll hooks to be executed for the proper cleanup.
// Contains dynamic annotations originated by modifiers with a callback, e.g. `test.skip(() => true)`.
this._activeSuites = new Map();
process.env.TEST_WORKER_INDEX = String(params.workerIndex);
process.env.TEST_PARALLEL_INDEX = String(params.parallelIndex);
(0, _globals.setIsWorkerProcess)();
this._params = params;
this._fixtureRunner = new _fixtureRunner.FixtureRunner();
// Resolve this promise, so worker does not stall waiting for the non-existent run to finish,
// when it was sopped before running any test group.
this._runFinished.resolve();
process.on('unhandledRejection', reason => this.unhandledError(reason));
process.on('uncaughtException', error => this.unhandledError(error));
process.stdout.write = chunk => {
var _this$_currentTest;
this.dispatchEvent('stdOut', (0, _ipc.stdioChunkToParams)(chunk));
(_this$_currentTest = this._currentTest) === null || _this$_currentTest === void 0 || _this$_currentTest._tracing.appendStdioToTrace('stdout', chunk);
return true;
};
if (!process.env.PW_RUNNER_DEBUG) {
process.stderr.write = chunk => {
var _this$_currentTest2;
this.dispatchEvent('stdErr', (0, _ipc.stdioChunkToParams)(chunk));
(_this$_currentTest2 = this._currentTest) === null || _this$_currentTest2 === void 0 || _this$_currentTest2._tracing.appendStdioToTrace('stderr', chunk);
return true;
};
}
}
_stop() {
if (!this._isStopped) {
var _this$_currentTest3;
this._isStopped = true;
(_this$_currentTest3 = this._currentTest) === null || _this$_currentTest3 === void 0 || _this$_currentTest3._interrupt();
}
return this._runFinished;
}
async gracefullyClose() {
try {
await this._stop();
// Ignore top-level errors, they are already inside TestInfo.errors.
const fakeTestInfo = new _testInfo.TestInfoImpl(this._config, this._project, this._params, undefined, 0, () => {}, () => {}, () => {});
const runnable = {
type: 'teardown'
};
// We have to load the project to get the right deadline below.
await fakeTestInfo._runAsStage({
title: 'worker cleanup',
runnable
}, () => this._loadIfNeeded()).catch(() => {});
await this._fixtureRunner.teardownScope('test', fakeTestInfo, runnable).catch(() => {});
await this._fixtureRunner.teardownScope('worker', fakeTestInfo, runnable).catch(() => {});
// Close any other browsers launched in this process. This includes anything launched
// manually in the test/hooks and internal browsers like Playwright Inspector.
await fakeTestInfo._runAsStage({
title: 'worker cleanup',
runnable
}, () => (0, _utils.gracefullyCloseAll)()).catch(() => {});
this._fatalErrors.push(...fakeTestInfo.errors);
} catch (e) {
this._fatalErrors.push((0, _util2.testInfoError)(e));
}
if (this._fatalErrors.length) {
this._appendProcessTeardownDiagnostics(this._fatalErrors[this._fatalErrors.length - 1]);
const payload = {
fatalErrors: this._fatalErrors
};
this.dispatchEvent('teardownErrors', payload);
}
}
_appendProcessTeardownDiagnostics(error) {
if (!this._lastRunningTests.length) return;
const count = this._totalRunningTests === 1 ? '1 test' : `${this._totalRunningTests} tests`;
let lastMessage = '';
if (this._lastRunningTests.length < this._totalRunningTests) lastMessage = `, last ${this._lastRunningTests.length} tests were`;
const message = ['', '', _utilsBundle.colors.red(`Failed worker ran ${count}${lastMessage}:`), ...this._lastRunningTests.map(test => formatTestTitle(test, this._project.project.name))].join('\n');
if (error.message) {
if (error.stack) {
let index = error.stack.indexOf(error.message);
if (index !== -1) {
index += error.message.length;
error.stack = error.stack.substring(0, index) + message + error.stack.substring(index);
}
}
error.message += message;
} else if (error.value) {
error.value += message;
}
}
unhandledError(error) {
// No current test - fatal error.
if (!this._currentTest) {
if (!this._fatalErrors.length) this._fatalErrors.push((0, _util2.testInfoError)(error));
void this._stop();
return;
}
// We do not differentiate between errors in the control flow
// and unhandled errors - both lead to the test failing. This is good for regular tests,
// so that you can, e.g. expect() from inside an event handler. The test fails,
// and we restart the worker.
if (!this._currentTest._hasUnhandledError) {
this._currentTest._hasUnhandledError = true;
this._currentTest._failWithError(error);
}
// For tests marked with test.fail(), this might be a problem when unhandled error
// is not coming from the user test code (legit failure), but from fixtures or test runner.
//
// Ideally, we would mark this test as "failed unexpectedly" and show that in the report.
// However, we do not have such a special test status, so the test will be considered ok (failed as expected).
//
// To avoid messing up future tests, we forcefully stop the worker, unless it is
// an expect() error which we know does not mess things up.
const isExpectError = error instanceof Error && !!error.matcherResult;
const shouldContinueInThisWorker = this._currentTest.expectedStatus === 'failed' && isExpectError;
if (!shouldContinueInThisWorker) void this._stop();
}
async _loadIfNeeded() {
if (this._config) return;
this._config = await (0, _configLoader.deserializeConfig)(this._params.config);
this._project = this._config.projects.find(p => p.id === this._params.projectId);
this._poolBuilder = _poolBuilder.PoolBuilder.createForWorker(this._project);
}
async runTestGroup(runPayload) {
this._runFinished = new _utils.ManualPromise();
const entries = new Map(runPayload.entries.map(e => [e.testId, e]));
let fatalUnknownTestIds;
try {
await this._loadIfNeeded();
const fileSuite = await (0, _testLoader.loadTestFile)(runPayload.file, this._config.config.rootDir);
const suite = (0, _suiteUtils.bindFileSuiteToProject)(this._project, fileSuite);
if (this._params.repeatEachIndex) (0, _suiteUtils.applyRepeatEachIndex)(this._project, suite, this._params.repeatEachIndex);
const hasEntries = (0, _suiteUtils.filterTestsRemoveEmptySuites)(suite, test => entries.has(test.id));
if (hasEntries) {
this._poolBuilder.buildPools(suite);
this._activeSuites = new Map();
this._didRunFullCleanup = false;
const tests = suite.allTests();
for (let i = 0; i < tests.length; i++) {
// Do not run tests after full cleanup, because we are entirely done.
if (this._isStopped && this._didRunFullCleanup) break;
const entry = entries.get(tests[i].id);
entries.delete(tests[i].id);
(0, _util.debugTest)(`test started "${tests[i].title}"`);
await this._runTest(tests[i], entry.retry, tests[i + 1]);
(0, _util.debugTest)(`test finished "${tests[i].title}"`);
}
} else {
fatalUnknownTestIds = runPayload.entries.map(e => e.testId);
void this._stop();
}
} catch (e) {
// In theory, we should run above code without any errors.
// However, in the case we screwed up, or loadTestFile failed in the worker
// but not in the runner, let's do a fatal error.
this._fatalErrors.push((0, _util2.testInfoError)(e));
void this._stop();
} finally {
const donePayload = {
fatalErrors: this._fatalErrors,
skipTestsDueToSetupFailure: [],
fatalUnknownTestIds
};
for (const test of ((_this$_skipRemainingT = this._skipRemainingTestsInSuite) === null || _this$_skipRemainingT === void 0 ? void 0 : _this$_skipRemainingT.allTests()) || []) {
var _this$_skipRemainingT;
if (entries.has(test.id)) donePayload.skipTestsDueToSetupFailure.push(test.id);
}
this.dispatchEvent('done', donePayload);
this._fatalErrors = [];
this._skipRemainingTestsInSuite = undefined;
this._runFinished.resolve();
}
}
async _runTest(test, retry, nextTest) {
const testInfo = new _testInfo.TestInfoImpl(this._config, this._project, this._params, test, retry, stepBeginPayload => this.dispatchEvent('stepBegin', stepBeginPayload), stepEndPayload => this.dispatchEvent('stepEnd', stepEndPayload), attachment => this.dispatchEvent('attach', attachment));
const processAnnotation = annotation => {
testInfo.annotations.push(annotation);
switch (annotation.type) {
case 'fixme':
case 'skip':
testInfo.expectedStatus = 'skipped';
break;
case 'fail':
if (testInfo.expectedStatus !== 'skipped') testInfo.expectedStatus = 'failed';
break;
case 'slow':
testInfo._timeoutManager.slow();
break;
}
};
if (!this._isStopped) this._fixtureRunner.setPool(test._pool);
const suites = getSuites(test);
const reversedSuites = suites.slice().reverse();
const nextSuites = new Set(getSuites(nextTest));
testInfo._timeoutManager.setTimeout(test.timeout);
for (const annotation of test.annotations) processAnnotation(annotation);
// Process existing annotations dynamically set for parent suites.
for (const suite of suites) {
const extraAnnotations = this._activeSuites.get(suite) || [];
for (const annotation of extraAnnotations) processAnnotation(annotation);
}
this._currentTest = testInfo;
(0, _globals.setCurrentTestInfo)(testInfo);
this.dispatchEvent('testBegin', buildTestBeginPayload(testInfo));
const isSkipped = testInfo.expectedStatus === 'skipped';
const hasAfterAllToRunBeforeNextTest = reversedSuites.some(suite => {
return this._activeSuites.has(suite) && !nextSuites.has(suite) && suite._hooks.some(hook => hook.type === 'afterAll');
});
if (isSkipped && nextTest && !hasAfterAllToRunBeforeNextTest) {
// Fast path - this test is skipped, and there are more tests that will handle cleanup.
testInfo.status = 'skipped';
this.dispatchEvent('testEnd', buildTestEndPayload(testInfo));
return;
}
this._totalRunningTests++;
this._lastRunningTests.push(test);
if (this._lastRunningTests.length > 10) this._lastRunningTests.shift();
let shouldRunAfterEachHooks = false;
testInfo._allowSkips = true;
await testInfo._runAsStage({
title: 'setup and test'
}, async () => {
await testInfo._runAsStage({
title: 'start tracing',
runnable: {
type: 'test'
}
}, async () => {
// Ideally, "trace" would be an config-level option belonging to the
// test runner instead of a fixture belonging to Playwright.
// However, for backwards compatibility, we have to read it from a fixture today.
// We decided to not introduce the config-level option just yet.
const traceFixtureRegistration = test._pool.resolve('trace');
if (!traceFixtureRegistration) return;
if (typeof traceFixtureRegistration.fn === 'function') throw new Error(`"trace" option cannot be a function`);
await testInfo._tracing.startIfNeeded(traceFixtureRegistration.fn);
});
if (this._isStopped || isSkipped) {
// Two reasons to get here:
// - Last test is skipped, so we should not run the test, but run the cleanup.
// - Worker is requested to stop, but was not able to run full cleanup yet.
// We should skip the test, but run the cleanup.
testInfo.status = 'skipped';
return;
}
await (0, _utils.removeFolders)([testInfo.outputDir]);
let testFunctionParams = null;
await testInfo._runAsStage({
title: 'Before Hooks',
stepInfo: {
category: 'hook'
}
}, async () => {
// Run "beforeAll" hooks, unless already run during previous tests.
for (const suite of suites) await this._runBeforeAllHooksForSuite(suite, testInfo);
// Run "beforeEach" hooks. Once started with "beforeEach", we must run all "afterEach" hooks as well.
shouldRunAfterEachHooks = true;
await this._runEachHooksForSuites(suites, 'beforeEach', testInfo);
// Setup fixtures required by the test.
testFunctionParams = await this._fixtureRunner.resolveParametersForFunction(test.fn, testInfo, 'test', {
type: 'test'
});
});
if (testFunctionParams === null) {
// Fixture setup failed or was skipped, we should not run the test now.
return;
}
await testInfo._runAsStage({
title: 'test function',
runnable: {
type: 'test'
}
}, async () => {
// Now run the test itself.
const fn = test.fn; // Extract a variable to get a better stack trace ("myTest" vs "TestCase.myTest [as fn]").
await fn(testFunctionParams, testInfo);
});
}).catch(() => {}); // Ignore the top-level error, it is already inside TestInfo.errors.
// Update duration, so it is available in fixture teardown and afterEach hooks.
testInfo.duration = testInfo._timeoutManager.defaultSlot().elapsed | 0;
// No skips in after hooks.
testInfo._allowSkips = true;
// After hooks get an additional timeout.
const afterHooksTimeout = calculateMaxTimeout(this._project.project.timeout, testInfo.timeout);
const afterHooksSlot = {
timeout: afterHooksTimeout,
elapsed: 0
};
await testInfo._runAsStage({
title: 'After Hooks',
stepInfo: {
category: 'hook'
}
}, async () => {
let firstAfterHooksError;
try {
// Run "immediately upon test function finish" callback.
await testInfo._runAsStage({
title: 'on-test-function-finish',
runnable: {
type: 'test',
slot: afterHooksSlot
}
}, async () => {
var _testInfo$_onDidFinis;
return (_testInfo$_onDidFinis = testInfo._onDidFinishTestFunction) === null || _testInfo$_onDidFinis === void 0 ? void 0 : _testInfo$_onDidFinis.call(testInfo);
});
} catch (error) {
var _firstAfterHooksError;
firstAfterHooksError = (_firstAfterHooksError = firstAfterHooksError) !== null && _firstAfterHooksError !== void 0 ? _firstAfterHooksError : error;
}
try {
// Run "afterEach" hooks, unless we failed at beforeAll stage.
if (shouldRunAfterEachHooks) await this._runEachHooksForSuites(reversedSuites, 'afterEach', testInfo, afterHooksSlot);
} catch (error) {
var _firstAfterHooksError2;
firstAfterHooksError = (_firstAfterHooksError2 = firstAfterHooksError) !== null && _firstAfterHooksError2 !== void 0 ? _firstAfterHooksError2 : error;
}
try {
// Teardown test-scoped fixtures. Attribute to 'test' so that users understand
// they should probably increase the test timeout to fix this issue.
await this._fixtureRunner.teardownScope('test', testInfo, {
type: 'test',
slot: afterHooksSlot
});
} catch (error) {
var _firstAfterHooksError3;
firstAfterHooksError = (_firstAfterHooksError3 = firstAfterHooksError) !== null && _firstAfterHooksError3 !== void 0 ? _firstAfterHooksError3 : error;
}
// Run "afterAll" hooks for suites that are not shared with the next test.
// In case of failure the worker will be stopped and we have to make sure that afterAll
// hooks run before worker fixtures teardown.
for (const suite of reversedSuites) {
if (!nextSuites.has(suite) || testInfo._isFailure()) {
try {
await this._runAfterAllHooksForSuite(suite, testInfo);
} catch (error) {
var _firstAfterHooksError4;
// Continue running "afterAll" hooks even after some of them timeout.
firstAfterHooksError = (_firstAfterHooksError4 = firstAfterHooksError) !== null && _firstAfterHooksError4 !== void 0 ? _firstAfterHooksError4 : error;
}
}
}
if (firstAfterHooksError) throw firstAfterHooksError;
}).catch(() => {}); // Ignore the top-level error, it is already inside TestInfo.errors.
if (testInfo._isFailure()) this._isStopped = true;
if (this._isStopped) {
// Run all remaining "afterAll" hooks and teardown all fixtures when worker is shutting down.
// Mark as "cleaned up" early to avoid running cleanup twice.
this._didRunFullCleanup = true;
await testInfo._runAsStage({
title: 'Worker Cleanup',
stepInfo: {
category: 'hook'
}
}, async () => {
let firstWorkerCleanupError;
// Give it more time for the full cleanup.
const teardownSlot = {
timeout: this._project.project.timeout,
elapsed: 0
};
try {
// Attribute to 'test' so that users understand they should probably increate the test timeout to fix this issue.
await this._fixtureRunner.teardownScope('test', testInfo, {
type: 'test',
slot: teardownSlot
});
} catch (error) {
var _firstWorkerCleanupEr;
firstWorkerCleanupError = (_firstWorkerCleanupEr = firstWorkerCleanupError) !== null && _firstWorkerCleanupEr !== void 0 ? _firstWorkerCleanupEr : error;
}
for (const suite of reversedSuites) {
try {
await this._runAfterAllHooksForSuite(suite, testInfo);
} catch (error) {
var _firstWorkerCleanupEr2;
firstWorkerCleanupError = (_firstWorkerCleanupEr2 = firstWorkerCleanupError) !== null && _firstWorkerCleanupEr2 !== void 0 ? _firstWorkerCleanupEr2 : error;
}
}
try {
// Attribute to 'teardown' because worker fixtures are not perceived as a part of a test.
await this._fixtureRunner.teardownScope('worker', testInfo, {
type: 'teardown',
slot: teardownSlot
});
} catch (error) {
var _firstWorkerCleanupEr3;
firstWorkerCleanupError = (_firstWorkerCleanupEr3 = firstWorkerCleanupError) !== null && _firstWorkerCleanupEr3 !== void 0 ? _firstWorkerCleanupEr3 : error;
}
if (firstWorkerCleanupError) throw firstWorkerCleanupError;
}).catch(() => {}); // Ignore the top-level error, it is already inside TestInfo.errors.
}
const tracingSlot = {
timeout: this._project.project.timeout,
elapsed: 0
};
await testInfo._runAsStage({
title: 'stop tracing',
runnable: {
type: 'test',
slot: tracingSlot
}
}, async () => {
await testInfo._tracing.stopIfNeeded();
}).catch(() => {}); // Ignore the top-level error, it is already inside TestInfo.errors.
testInfo.duration = testInfo._timeoutManager.defaultSlot().elapsed + afterHooksSlot.elapsed | 0;
this._currentTest = null;
(0, _globals.setCurrentTestInfo)(null);
this.dispatchEvent('testEnd', buildTestEndPayload(testInfo));
const preserveOutput = this._config.config.preserveOutput === 'always' || this._config.config.preserveOutput === 'failures-only' && testInfo._isFailure();
if (!preserveOutput) await (0, _utils.removeFolders)([testInfo.outputDir]);
}
_collectHooksAndModifiers(suite, type, testInfo) {
const runnables = [];
for (const modifier of suite._modifiers) {
const modifierType = this._fixtureRunner.dependsOnWorkerFixturesOnly(modifier.fn, modifier.location) ? 'beforeAll' : 'beforeEach';
if (modifierType !== type) continue;
const fn = async fixtures => {
const result = await modifier.fn(fixtures);
testInfo[modifier.type](!!result, modifier.description);
};
(0, _fixtures.inheritFixtureNames)(modifier.fn, fn);
runnables.push({
title: `${modifier.type} modifier`,
location: modifier.location,
type: modifier.type,
fn
});
}
// Modifiers first, then hooks.
runnables.push(...suite._hooks.filter(hook => hook.type === type));
return runnables;
}
async _runBeforeAllHooksForSuite(suite, testInfo) {
if (this._activeSuites.has(suite)) return;
const extraAnnotations = [];
this._activeSuites.set(suite, extraAnnotations);
await this._runAllHooksForSuite(suite, testInfo, 'beforeAll', extraAnnotations);
}
async _runAllHooksForSuite(suite, testInfo, type, extraAnnotations) {
// Always run all the hooks, and capture the first error.
let firstError;
for (const hook of this._collectHooksAndModifiers(suite, type, testInfo)) {
try {
await testInfo._runAsStage({
title: hook.title,
stepInfo: {
category: 'hook',
location: hook.location
}
}, async () => {
// Separate time slot for each beforeAll/afterAll hook.
const timeSlot = {
timeout: this._project.project.timeout,
elapsed: 0
};
const runnable = {
type: hook.type,
slot: timeSlot,
location: hook.location
};
const existingAnnotations = new Set(testInfo.annotations);
try {
await this._fixtureRunner.resolveParametersAndRunFunction(hook.fn, testInfo, 'all-hooks-only', runnable);
} finally {
if (extraAnnotations) {
// Inherit all annotations defined in the beforeAll/modifer to all tests in the suite.
const newAnnotations = testInfo.annotations.filter(a => !existingAnnotations.has(a));
extraAnnotations.push(...newAnnotations);
}
// Each beforeAll/afterAll hook has its own scope for test fixtures. Attribute to the same runnable and timeSlot.
// Note: we must teardown even after hook fails, because we'll run more hooks.
await this._fixtureRunner.teardownScope('test', testInfo, runnable);
}
});
} catch (error) {
var _firstError;
firstError = (_firstError = firstError) !== null && _firstError !== void 0 ? _firstError : error;
// Skip in beforeAll/modifier prevents others from running.
if (type === 'beforeAll' && error instanceof _testInfo.SkipError) break;
if (type === 'beforeAll' && !this._skipRemainingTestsInSuite) {
// This will inform dispatcher that we should not run more tests from this group
// because we had a beforeAll error.
// This behavior avoids getting the same common error for each test.
this._skipRemainingTestsInSuite = suite;
}
}
}
if (firstError) throw firstError;
}
async _runAfterAllHooksForSuite(suite, testInfo) {
if (!this._activeSuites.has(suite)) return;
this._activeSuites.delete(suite);
await this._runAllHooksForSuite(suite, testInfo, 'afterAll');
}
async _runEachHooksForSuites(suites, type, testInfo, slot) {
// Always run all the hooks, unless one of the times out, and capture the first error.
let firstError;
const hooks = suites.map(suite => this._collectHooksAndModifiers(suite, type, testInfo)).flat();
for (const hook of hooks) {
const runnable = {
type: hook.type,
location: hook.location,
slot
};
if (testInfo._timeoutManager.isTimeExhaustedFor(runnable)) {
// Do not run hooks that will timeout right away.
continue;
}
try {
await testInfo._runAsStage({
title: hook.title,
stepInfo: {
category: 'hook',
location: hook.location
}
}, async () => {
await this._fixtureRunner.resolveParametersAndRunFunction(hook.fn, testInfo, 'test', runnable);
});
} catch (error) {
var _firstError2;
firstError = (_firstError2 = firstError) !== null && _firstError2 !== void 0 ? _firstError2 : error;
// Skip in modifier prevents others from running.
if (error instanceof _testInfo.SkipError) break;
}
}
if (firstError) throw firstError;
}
}
exports.WorkerMain = WorkerMain;
function buildTestBeginPayload(testInfo) {
return {
testId: testInfo.testId,
startWallTime: testInfo._startWallTime
};
}
function buildTestEndPayload(testInfo) {
return {
testId: testInfo.testId,
duration: testInfo.duration,
status: testInfo.status,
errors: testInfo.errors,
hasNonRetriableError: testInfo._hasNonRetriableError,
expectedStatus: testInfo.expectedStatus,
annotations: testInfo.annotations,
timeout: testInfo.timeout
};
}
function getSuites(test) {
const suites = [];
for (let suite = test === null || test === void 0 ? void 0 : test.parent; suite; suite = suite.parent) suites.push(suite);
suites.reverse(); // Put root suite first.
return suites;
}
function formatTestTitle(test, projectName) {
// file, ...describes, test
const [, ...titles] = test.titlePath();
const location = `${(0, _util.relativeFilePath)(test.location.file)}:${test.location.line}:${test.location.column}`;
const projectTitle = projectName ? `[${projectName}] › ` : '';
return `${projectTitle}${location} › ${titles.join(' › ')}`;
}
function calculateMaxTimeout(t1, t2) {
// Zero means "no timeout".
return !t1 || !t2 ? 0 : Math.max(t1, t2);
}
const create = params => new WorkerMain(params);
exports.create = create; |