Spaces:
Running
Running
Download node_modules/playwright/lib/worker/fixtureRunner.js from AK51/LunarSpark: direct link, hf CLI and curl.
- Browser
- Download file 10.3 kB
-
https://huggingface.co/spaces/AK51/LunarSpark/resolve/main/node_modules/playwright/lib/worker/fixtureRunner.js
- Command line
-
hf download hf://spaces/AK51/LunarSpark/node_modules/playwright/lib/worker/fixtureRunner.js
-
curl -L -o fixtureRunner.js https://huggingface.co/spaces/AK51/LunarSpark/resolve/main/node_modules/playwright/lib/worker/fixtureRunner.js
10.3 kB
| ; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.FixtureRunner = void 0; | |
| var _util = require("../util"); | |
| var _utils = require("playwright-core/lib/utils"); | |
| var _fixtures = require("../common/fixtures"); | |
| /** | |
| * 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 Fixture { | |
| constructor(runner, registration) { | |
| this.runner = void 0; | |
| this.registration = void 0; | |
| this.value = void 0; | |
| this.failed = false; | |
| this._useFuncFinished = void 0; | |
| this._selfTeardownComplete = void 0; | |
| this._setupDescription = void 0; | |
| this._teardownDescription = void 0; | |
| this._stepInfo = void 0; | |
| this._deps = new Set(); | |
| this._usages = new Set(); | |
| this.runner = runner; | |
| this.registration = registration; | |
| this.value = null; | |
| const shouldGenerateStep = !this.registration.box && !this.registration.option; | |
| const isUserFixture = this.registration.location && (0, _util.filterStackFile)(this.registration.location.file); | |
| const title = this.registration.customTitle || this.registration.name; | |
| const location = isUserFixture ? this.registration.location : undefined; | |
| this._stepInfo = shouldGenerateStep ? { | |
| category: 'fixture', | |
| location | |
| } : undefined; | |
| this._setupDescription = { | |
| title, | |
| phase: 'setup', | |
| location, | |
| slot: this.registration.timeout === undefined ? undefined : { | |
| timeout: this.registration.timeout, | |
| elapsed: 0 | |
| } | |
| }; | |
| this._teardownDescription = { | |
| ...this._setupDescription, | |
| phase: 'teardown' | |
| }; | |
| } | |
| async setup(testInfo, runnable) { | |
| this.runner.instanceForId.set(this.registration.id, this); | |
| if (typeof this.registration.fn !== 'function') { | |
| this.value = this.registration.fn; | |
| return; | |
| } | |
| await testInfo._runAsStage({ | |
| title: `fixture: ${this.registration.name}`, | |
| runnable: { | |
| ...runnable, | |
| fixture: this._setupDescription | |
| }, | |
| stepInfo: this._stepInfo | |
| }, async () => { | |
| await this._setupInternal(testInfo); | |
| }); | |
| } | |
| async _setupInternal(testInfo) { | |
| const params = {}; | |
| for (const name of this.registration.deps) { | |
| const registration = this.runner.pool.resolve(name, this.registration); | |
| const dep = this.runner.instanceForId.get(registration.id); | |
| if (!dep) { | |
| this.failed = true; | |
| return; | |
| } | |
| // Fixture teardown is root => leaves, when we need to teardown a fixture, | |
| // it recursively tears down its usages first. | |
| dep._usages.add(this); | |
| // Don't forget to decrement all usages when fixture goes. | |
| // Otherwise worker-scope fixtures will retain test-scope fixtures forever. | |
| this._deps.add(dep); | |
| params[name] = dep.value; | |
| if (dep.failed) { | |
| this.failed = true; | |
| return; | |
| } | |
| } | |
| let called = false; | |
| const useFuncStarted = new _utils.ManualPromise(); | |
| const useFunc = async value => { | |
| if (called) throw new Error(`Cannot provide fixture value for the second time`); | |
| called = true; | |
| this.value = value; | |
| this._useFuncFinished = new _utils.ManualPromise(); | |
| useFuncStarted.resolve(); | |
| await this._useFuncFinished; | |
| }; | |
| const workerInfo = { | |
| config: testInfo.config, | |
| parallelIndex: testInfo.parallelIndex, | |
| workerIndex: testInfo.workerIndex, | |
| project: testInfo.project | |
| }; | |
| const info = this.registration.scope === 'worker' ? workerInfo : testInfo; | |
| this._selfTeardownComplete = (async () => { | |
| try { | |
| await this.registration.fn(params, useFunc, info); | |
| } catch (error) { | |
| this.failed = true; | |
| if (!useFuncStarted.isDone()) useFuncStarted.reject(error);else throw error; | |
| } | |
| })(); | |
| await useFuncStarted; | |
| } | |
| async teardown(testInfo, runnable) { | |
| try { | |
| const fixtureRunnable = { | |
| ...runnable, | |
| fixture: this._teardownDescription | |
| }; | |
| // Do not even start the teardown for a fixture that does not have any | |
| // time remaining in the time slot. This avoids cascading timeouts. | |
| if (!testInfo._timeoutManager.isTimeExhaustedFor(fixtureRunnable)) { | |
| await testInfo._runAsStage({ | |
| title: `fixture: ${this.registration.name}`, | |
| runnable: fixtureRunnable, | |
| stepInfo: this._stepInfo | |
| }, async () => { | |
| await this._teardownInternal(); | |
| }); | |
| } | |
| } finally { | |
| // To preserve fixtures integrity, forcefully cleanup fixtures | |
| // that cannnot teardown due to a timeout or an error. | |
| for (const dep of this._deps) dep._usages.delete(this); | |
| this.runner.instanceForId.delete(this.registration.id); | |
| } | |
| } | |
| async _teardownInternal() { | |
| if (typeof this.registration.fn !== 'function') return; | |
| if (this._usages.size !== 0) { | |
| // TODO: replace with assert. | |
| console.error('Internal error: fixture integrity at', this._teardownDescription.title); // eslint-disable-line no-console | |
| this._usages.clear(); | |
| } | |
| if (this._useFuncFinished) { | |
| this._useFuncFinished.resolve(); | |
| this._useFuncFinished = undefined; | |
| await this._selfTeardownComplete; | |
| } | |
| } | |
| _collectFixturesInTeardownOrder(scope, collector) { | |
| if (this.registration.scope !== scope) return; | |
| for (const fixture of this._usages) fixture._collectFixturesInTeardownOrder(scope, collector); | |
| collector.add(this); | |
| } | |
| } | |
| class FixtureRunner { | |
| constructor() { | |
| this.testScopeClean = true; | |
| this.pool = void 0; | |
| this.instanceForId = new Map(); | |
| } | |
| setPool(pool) { | |
| if (!this.testScopeClean) throw new Error('Did not teardown test scope'); | |
| if (this.pool && pool.digest !== this.pool.digest) { | |
| throw new Error([`Playwright detected inconsistent test.use() options.`, `Most common mistakes that lead to this issue:`, ` - Calling test.use() outside of the test file, for example in a common helper.`, ` - One test file imports from another test file.`].join('\n')); | |
| } | |
| this.pool = pool; | |
| } | |
| _collectFixturesInSetupOrder(registration, collector) { | |
| if (collector.has(registration)) return; | |
| for (const name of registration.deps) { | |
| const dep = this.pool.resolve(name, registration); | |
| this._collectFixturesInSetupOrder(dep, collector); | |
| } | |
| collector.add(registration); | |
| } | |
| async teardownScope(scope, testInfo, runnable) { | |
| // Teardown fixtures in the reverse order. | |
| const fixtures = Array.from(this.instanceForId.values()).reverse(); | |
| const collector = new Set(); | |
| for (const fixture of fixtures) fixture._collectFixturesInTeardownOrder(scope, collector); | |
| let firstError; | |
| for (const fixture of collector) { | |
| try { | |
| await fixture.teardown(testInfo, runnable); | |
| } catch (error) { | |
| var _firstError; | |
| firstError = (_firstError = firstError) !== null && _firstError !== void 0 ? _firstError : error; | |
| } | |
| } | |
| if (scope === 'test') this.testScopeClean = true; | |
| if (firstError) throw firstError; | |
| } | |
| async resolveParametersForFunction(fn, testInfo, autoFixtures, runnable) { | |
| const collector = new Set(); | |
| // Collect automatic fixtures. | |
| const auto = []; | |
| for (const registration of this.pool.autoFixtures()) { | |
| let shouldRun = true; | |
| if (autoFixtures === 'all-hooks-only') shouldRun = registration.scope === 'worker' || registration.auto === 'all-hooks-included';else if (autoFixtures === 'worker') shouldRun = registration.scope === 'worker'; | |
| if (shouldRun) auto.push(registration); | |
| } | |
| auto.sort((r1, r2) => (r1.scope === 'worker' ? 0 : 1) - (r2.scope === 'worker' ? 0 : 1)); | |
| for (const registration of auto) this._collectFixturesInSetupOrder(registration, collector); | |
| // Collect used fixtures. | |
| const names = getRequiredFixtureNames(fn); | |
| for (const name of names) this._collectFixturesInSetupOrder(this.pool.resolve(name), collector); | |
| // Setup fixtures. | |
| for (const registration of collector) await this._setupFixtureForRegistration(registration, testInfo, runnable); | |
| // Create params object. | |
| const params = {}; | |
| for (const name of names) { | |
| const registration = this.pool.resolve(name); | |
| const fixture = this.instanceForId.get(registration.id); | |
| if (!fixture || fixture.failed) return null; | |
| params[name] = fixture.value; | |
| } | |
| return params; | |
| } | |
| async resolveParametersAndRunFunction(fn, testInfo, autoFixtures, runnable) { | |
| const params = await this.resolveParametersForFunction(fn, testInfo, autoFixtures, runnable); | |
| if (params === null) { | |
| // Do not run the function when fixture setup has already failed. | |
| return null; | |
| } | |
| await testInfo._runAsStage({ | |
| title: 'run function', | |
| runnable | |
| }, async () => { | |
| await fn(params, testInfo); | |
| }); | |
| } | |
| async _setupFixtureForRegistration(registration, testInfo, runnable) { | |
| if (registration.scope === 'test') this.testScopeClean = false; | |
| let fixture = this.instanceForId.get(registration.id); | |
| if (fixture) return fixture; | |
| fixture = new Fixture(this, registration); | |
| await fixture.setup(testInfo, runnable); | |
| return fixture; | |
| } | |
| dependsOnWorkerFixturesOnly(fn, location) { | |
| const names = getRequiredFixtureNames(fn, location); | |
| for (const name of names) { | |
| const registration = this.pool.resolve(name); | |
| if (registration.scope !== 'worker') return false; | |
| } | |
| return true; | |
| } | |
| } | |
| exports.FixtureRunner = FixtureRunner; | |
| function getRequiredFixtureNames(fn, location) { | |
| return (0, _fixtures.fixtureParameterNames)(fn, location !== null && location !== void 0 ? location : { | |
| file: '<unknown>', | |
| line: 1, | |
| column: 1 | |
| }, e => { | |
| throw new Error(`${(0, _util.formatLocation)(e.location)}: ${e.message}`); | |
| }); | |
| } |