Spaces:
Running
Running
Download node_modules/playwright/lib/worker/testTracing.js from AK51/LunarSpark: direct link, hf CLI and curl.
- Browser
- Download file 13 kB
-
https://huggingface.co/spaces/AK51/LunarSpark/resolve/main/node_modules/playwright/lib/worker/testTracing.js
- Command line
-
hf download hf://spaces/AK51/LunarSpark/node_modules/playwright/lib/worker/testTracing.js
-
curl -L -o testTracing.js https://huggingface.co/spaces/AK51/LunarSpark/resolve/main/node_modules/playwright/lib/worker/testTracing.js
13 kB
| ; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.testTraceEntryName = exports.TestTracing = void 0; | |
| var _fs = _interopRequireDefault(require("fs")); | |
| var _path = _interopRequireDefault(require("path")); | |
| var _utils = require("playwright-core/lib/utils"); | |
| var _zipBundle = require("playwright-core/lib/zipBundle"); | |
| var _util = require("../util"); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| /** | |
| * 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. | |
| */ | |
| const testTraceEntryName = exports.testTraceEntryName = 'test.trace'; | |
| const version = 7; | |
| let traceOrdinal = 0; | |
| class TestTracing { | |
| constructor(testInfo, artifactsDir) { | |
| this._testInfo = void 0; | |
| this._options = void 0; | |
| this._liveTraceFile = void 0; | |
| this._traceEvents = []; | |
| this._temporaryTraceFiles = []; | |
| this._artifactsDir = void 0; | |
| this._tracesDir = void 0; | |
| this._contextCreatedEvent = void 0; | |
| this._testInfo = testInfo; | |
| this._artifactsDir = artifactsDir; | |
| this._tracesDir = _path.default.join(this._artifactsDir, 'traces'); | |
| this._contextCreatedEvent = { | |
| version, | |
| type: 'context-options', | |
| origin: 'testRunner', | |
| browserName: '', | |
| options: {}, | |
| platform: process.platform, | |
| wallTime: Date.now(), | |
| monotonicTime: (0, _utils.monotonicTime)(), | |
| sdkLanguage: 'javascript' | |
| }; | |
| this._appendTraceEvent(this._contextCreatedEvent); | |
| } | |
| _shouldCaptureTrace() { | |
| var _this$_options, _this$_options2, _this$_options3, _this$_options4, _this$_options5; | |
| if (process.env.PW_TEST_DISABLE_TRACING) return false; | |
| if (((_this$_options = this._options) === null || _this$_options === void 0 ? void 0 : _this$_options.mode) === 'on') return true; | |
| if (((_this$_options2 = this._options) === null || _this$_options2 === void 0 ? void 0 : _this$_options2.mode) === 'retain-on-failure') return true; | |
| if (((_this$_options3 = this._options) === null || _this$_options3 === void 0 ? void 0 : _this$_options3.mode) === 'on-first-retry' && this._testInfo.retry === 1) return true; | |
| if (((_this$_options4 = this._options) === null || _this$_options4 === void 0 ? void 0 : _this$_options4.mode) === 'on-all-retries' && this._testInfo.retry > 0) return true; | |
| if (((_this$_options5 = this._options) === null || _this$_options5 === void 0 ? void 0 : _this$_options5.mode) === 'retain-on-first-failure' && this._testInfo.retry === 0) return true; | |
| return false; | |
| } | |
| async startIfNeeded(value) { | |
| const defaultTraceOptions = { | |
| screenshots: true, | |
| snapshots: true, | |
| sources: true, | |
| attachments: true, | |
| _live: false, | |
| mode: 'off' | |
| }; | |
| if (!value) { | |
| this._options = defaultTraceOptions; | |
| } else if (typeof value === 'string') { | |
| this._options = { | |
| ...defaultTraceOptions, | |
| mode: value === 'retry-with-trace' ? 'on-first-retry' : value | |
| }; | |
| } else { | |
| const mode = value.mode || 'off'; | |
| this._options = { | |
| ...defaultTraceOptions, | |
| ...value, | |
| mode: mode === 'retry-with-trace' ? 'on-first-retry' : mode | |
| }; | |
| } | |
| if (!this._shouldCaptureTrace()) { | |
| this._options = undefined; | |
| return; | |
| } | |
| if (!this._liveTraceFile && this._options._live) { | |
| // Note that trace name must start with testId for live tracing to work. | |
| this._liveTraceFile = { | |
| file: _path.default.join(this._tracesDir, `${this._testInfo.testId}-test.trace`), | |
| fs: new _utils.SerializedFS() | |
| }; | |
| this._liveTraceFile.fs.mkdir(_path.default.dirname(this._liveTraceFile.file)); | |
| const data = this._traceEvents.map(e => JSON.stringify(e)).join('\n') + '\n'; | |
| this._liveTraceFile.fs.writeFile(this._liveTraceFile.file, data); | |
| } | |
| } | |
| artifactsDir() { | |
| return this._artifactsDir; | |
| } | |
| tracesDir() { | |
| return this._tracesDir; | |
| } | |
| traceTitle() { | |
| return [_path.default.relative(this._testInfo.project.testDir, this._testInfo.file) + ':' + this._testInfo.line, ...this._testInfo.titlePath.slice(1)].join(' › '); | |
| } | |
| generateNextTraceRecordingName() { | |
| const ordinalSuffix = traceOrdinal ? `-recording${traceOrdinal}` : ''; | |
| ++traceOrdinal; | |
| const retrySuffix = this._testInfo.retry ? `-retry${this._testInfo.retry}` : ''; | |
| // Note that trace name must start with testId for live tracing to work. | |
| return `${this._testInfo.testId}${retrySuffix}${ordinalSuffix}`; | |
| } | |
| generateNextTraceRecordingPath() { | |
| const file = _path.default.join(this._artifactsDir, (0, _utils.createGuid)() + '.zip'); | |
| this._temporaryTraceFiles.push(file); | |
| return file; | |
| } | |
| traceOptions() { | |
| return this._options; | |
| } | |
| async stopIfNeeded() { | |
| var _this$_liveTraceFile, _this$_options6, _this$_options7; | |
| if (!this._options) return; | |
| const error = await ((_this$_liveTraceFile = this._liveTraceFile) === null || _this$_liveTraceFile === void 0 ? void 0 : _this$_liveTraceFile.fs.syncAndGetError()); | |
| if (error) throw error; | |
| const testFailed = this._testInfo.status !== this._testInfo.expectedStatus; | |
| const shouldAbandonTrace = !testFailed && (this._options.mode === 'retain-on-failure' || this._options.mode === 'retain-on-first-failure'); | |
| if (shouldAbandonTrace) { | |
| for (const file of this._temporaryTraceFiles) await _fs.default.promises.unlink(file).catch(() => {}); | |
| return; | |
| } | |
| const zipFile = new _zipBundle.yazl.ZipFile(); | |
| if (!((_this$_options6 = this._options) !== null && _this$_options6 !== void 0 && _this$_options6.attachments)) { | |
| for (const event of this._traceEvents) { | |
| if (event.type === 'after') delete event.attachments; | |
| } | |
| } | |
| if ((_this$_options7 = this._options) !== null && _this$_options7 !== void 0 && _this$_options7.sources) { | |
| const sourceFiles = new Set(); | |
| for (const event of this._traceEvents) { | |
| if (event.type === 'before') { | |
| for (const frame of event.stack || []) sourceFiles.add(frame.file); | |
| } | |
| } | |
| for (const sourceFile of sourceFiles) { | |
| await _fs.default.promises.readFile(sourceFile, 'utf8').then(source => { | |
| zipFile.addBuffer(Buffer.from(source), 'resources/src@' + (0, _utils.calculateSha1)(sourceFile) + '.txt'); | |
| }).catch(() => {}); | |
| } | |
| } | |
| const sha1s = new Set(); | |
| for (const event of this._traceEvents.filter(e => e.type === 'after')) { | |
| for (const attachment of event.attachments || []) { | |
| let contentPromise; | |
| if (attachment.path) contentPromise = _fs.default.promises.readFile(attachment.path).catch(() => undefined);else if (attachment.base64) contentPromise = Promise.resolve(Buffer.from(attachment.base64, 'base64')); | |
| const content = await contentPromise; | |
| if (content === undefined) continue; | |
| const sha1 = (0, _utils.calculateSha1)(content); | |
| attachment.sha1 = sha1; | |
| delete attachment.path; | |
| delete attachment.base64; | |
| if (sha1s.has(sha1)) continue; | |
| sha1s.add(sha1); | |
| zipFile.addBuffer(content, 'resources/' + sha1); | |
| } | |
| } | |
| const traceContent = Buffer.from(this._traceEvents.map(e => JSON.stringify(e)).join('\n')); | |
| zipFile.addBuffer(traceContent, testTraceEntryName); | |
| await new Promise(f => { | |
| zipFile.end(undefined, () => { | |
| zipFile.outputStream.pipe(_fs.default.createWriteStream(this.generateNextTraceRecordingPath())).on('close', f); | |
| }); | |
| }); | |
| const tracePath = this._testInfo.outputPath('trace.zip'); | |
| await mergeTraceFiles(tracePath, this._temporaryTraceFiles); | |
| this._testInfo.attachments.push({ | |
| name: 'trace', | |
| path: tracePath, | |
| contentType: 'application/zip' | |
| }); | |
| } | |
| appendForError(error) { | |
| var _error$stack; | |
| const rawStack = ((_error$stack = error.stack) === null || _error$stack === void 0 ? void 0 : _error$stack.split('\n')) || []; | |
| const stack = rawStack ? (0, _util.filteredStackTrace)(rawStack) : []; | |
| this._appendTraceEvent({ | |
| type: 'error', | |
| message: this._formatError(error), | |
| stack | |
| }); | |
| } | |
| _formatError(error) { | |
| const parts = [error.message || String(error.value)]; | |
| if (error.cause) parts.push('[cause]: ' + this._formatError(error.cause)); | |
| return parts.join('\n'); | |
| } | |
| appendStdioToTrace(type, chunk) { | |
| this._appendTraceEvent({ | |
| type, | |
| timestamp: (0, _utils.monotonicTime)(), | |
| text: typeof chunk === 'string' ? chunk : undefined, | |
| base64: typeof chunk === 'string' ? undefined : chunk.toString('base64') | |
| }); | |
| } | |
| appendBeforeActionForStep(callId, parentId, apiName, params, stack) { | |
| this._appendTraceEvent({ | |
| type: 'before', | |
| callId, | |
| parentId, | |
| startTime: (0, _utils.monotonicTime)(), | |
| class: 'Test', | |
| method: 'step', | |
| apiName, | |
| params: Object.fromEntries(Object.entries(params || {}).map(([name, value]) => [name, generatePreview(value)])), | |
| stack | |
| }); | |
| } | |
| appendAfterActionForStep(callId, error, attachments = []) { | |
| this._appendTraceEvent({ | |
| type: 'after', | |
| callId, | |
| endTime: (0, _utils.monotonicTime)(), | |
| attachments: serializeAttachments(attachments), | |
| error | |
| }); | |
| } | |
| _appendTraceEvent(event) { | |
| this._traceEvents.push(event); | |
| if (this._liveTraceFile) this._liveTraceFile.fs.appendFile(this._liveTraceFile.file, JSON.stringify(event) + '\n', true); | |
| } | |
| } | |
| exports.TestTracing = TestTracing; | |
| function serializeAttachments(attachments) { | |
| return attachments.filter(a => a.name !== 'trace').map(a => { | |
| var _a$body; | |
| return { | |
| name: a.name, | |
| contentType: a.contentType, | |
| path: a.path, | |
| base64: (_a$body = a.body) === null || _a$body === void 0 ? void 0 : _a$body.toString('base64') | |
| }; | |
| }); | |
| } | |
| function generatePreview(value, visited = new Set()) { | |
| if (visited.has(value)) return ''; | |
| visited.add(value); | |
| if (typeof value === 'string') return value; | |
| if (typeof value === 'number') return value.toString(); | |
| if (typeof value === 'boolean') return value.toString(); | |
| if (value === null) return 'null'; | |
| if (value === undefined) return 'undefined'; | |
| if (Array.isArray(value)) return '[' + value.map(v => generatePreview(v, visited)).join(', ') + ']'; | |
| if (typeof value === 'object') return 'Object'; | |
| return String(value); | |
| } | |
| async function mergeTraceFiles(fileName, temporaryTraceFiles) { | |
| temporaryTraceFiles = temporaryTraceFiles.filter(file => _fs.default.existsSync(file)); | |
| if (temporaryTraceFiles.length === 1) { | |
| await _fs.default.promises.rename(temporaryTraceFiles[0], fileName); | |
| return; | |
| } | |
| const mergePromise = new _utils.ManualPromise(); | |
| const zipFile = new _zipBundle.yazl.ZipFile(); | |
| const entryNames = new Set(); | |
| zipFile.on('error', error => mergePromise.reject(error)); | |
| for (let i = temporaryTraceFiles.length - 1; i >= 0; --i) { | |
| const tempFile = temporaryTraceFiles[i]; | |
| const promise = new _utils.ManualPromise(); | |
| _zipBundle.yauzl.open(tempFile, (err, inZipFile) => { | |
| if (err) { | |
| promise.reject(err); | |
| return; | |
| } | |
| let pendingEntries = inZipFile.entryCount; | |
| inZipFile.on('entry', entry => { | |
| let entryName = entry.fileName; | |
| if (entry.fileName === testTraceEntryName) { | |
| // Keep the name for test traces so that the last test trace | |
| // that contains most of the information is kept in the trace. | |
| // Note the reverse order of the iteration (from new traces to old). | |
| } else if (entry.fileName.match(/[\d-]*trace\./)) { | |
| entryName = i + '-' + entry.fileName; | |
| } | |
| if (entryNames.has(entryName)) { | |
| if (--pendingEntries === 0) promise.resolve(); | |
| return; | |
| } | |
| entryNames.add(entryName); | |
| inZipFile.openReadStream(entry, (err, readStream) => { | |
| if (err) { | |
| promise.reject(err); | |
| return; | |
| } | |
| zipFile.addReadStream(readStream, entryName); | |
| if (--pendingEntries === 0) promise.resolve(); | |
| }); | |
| }); | |
| }); | |
| await promise; | |
| } | |
| zipFile.end(undefined, () => { | |
| zipFile.outputStream.pipe(_fs.default.createWriteStream(fileName)).on('close', () => { | |
| void Promise.all(temporaryTraceFiles.map(tempFile => _fs.default.promises.unlink(tempFile))).then(() => { | |
| mergePromise.resolve(); | |
| }).catch(error => mergePromise.reject(error)); | |
| }).on('error', error => mergePromise.reject(error)); | |
| }); | |
| await mergePromise; | |
| } |