pokeedex 0.1.0

data/node_modules/playwright/lib/worker/testTracing.js

@@ -0,0 +1,314 @@
+"use strict";
+
+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: error.message || String(error.value),
+      stack
+    });
+  }
+  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;
+}

data/node_modules/playwright/lib/worker/timeoutManager.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.kMaxDeadline = exports.TimeoutManagerError = exports.TimeoutManager = void 0;
+var _utilsBundle = require("playwright-core/lib/utilsBundle");
+var _utils = require("playwright-core/lib/utils");
+/**
+ * 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 kMaxDeadline = exports.kMaxDeadline = 2147483647; // 2^31-1
+
+class TimeoutManager {
+  constructor(timeout) {
+    this._defaultSlot = void 0;
+    this._running = void 0;
+    this._ignoreTimeouts = false;
+    this._defaultSlot = {
+      timeout,
+      elapsed: 0
+    };
+  }
+  setIgnoreTimeouts() {
+    this._ignoreTimeouts = true;
+    if (this._running) this._updateTimeout(this._running);
+  }
+  interrupt() {
+    if (this._running) this._running.timeoutPromise.reject(this._createTimeoutError(this._running));
+  }
+  isTimeExhaustedFor(runnable) {
+    var _runnable$fixture;
+    const slot = ((_runnable$fixture = runnable.fixture) === null || _runnable$fixture === void 0 ? void 0 : _runnable$fixture.slot) || runnable.slot || this._defaultSlot;
+    // Note: the "-1" here matches the +1 in _updateTimeout.
+    return slot.timeout > 0 && slot.elapsed >= slot.timeout - 1;
+  }
+  async withRunnable(runnable, cb) {
+    var _runnable$fixture2;
+    if (!runnable) return await cb();
+    if (this._running) throw new Error(`Internal error: duplicate runnable`);
+    const running = this._running = {
+      runnable,
+      slot: ((_runnable$fixture2 = runnable.fixture) === null || _runnable$fixture2 === void 0 ? void 0 : _runnable$fixture2.slot) || runnable.slot || this._defaultSlot,
+      start: (0, _utils.monotonicTime)(),
+      deadline: kMaxDeadline,
+      timer: undefined,
+      timeoutPromise: new _utils.ManualPromise()
+    };
+    try {
+      this._updateTimeout(running);
+      return await Promise.race([cb(), running.timeoutPromise]);
+    } finally {
+      if (running.timer) clearTimeout(running.timer);
+      running.timer = undefined;
+      running.slot.elapsed += (0, _utils.monotonicTime)() - running.start;
+      this._running = undefined;
+    }
+  }
+  _updateTimeout(running) {
+    if (running.timer) clearTimeout(running.timer);
+    running.timer = undefined;
+    if (this._ignoreTimeouts || !running.slot.timeout) {
+      running.deadline = kMaxDeadline;
+      return;
+    }
+    running.deadline = running.start + (running.slot.timeout - running.slot.elapsed);
+    // Compensate for Node.js troubles with timeouts that can fire too early.
+    // We add an extra millisecond which seems to be enough.
+    // See https://github.com/nodejs/node/issues/26578.
+    const timeout = running.deadline - (0, _utils.monotonicTime)() + 1;
+    if (timeout <= 0) running.timeoutPromise.reject(this._createTimeoutError(running));else running.timer = setTimeout(() => running.timeoutPromise.reject(this._createTimeoutError(running)), timeout);
+  }
+  defaultSlot() {
+    return this._defaultSlot;
+  }
+  slow() {
+    const slot = this._running ? this._running.slot : this._defaultSlot;
+    slot.timeout = slot.timeout * 3;
+    if (this._running) this._updateTimeout(this._running);
+  }
+  setTimeout(timeout) {
+    const slot = this._running ? this._running.slot : this._defaultSlot;
+    slot.timeout = timeout;
+    if (this._running) this._updateTimeout(this._running);
+  }
+  currentSlotDeadline() {
+    return this._running ? this._running.deadline : kMaxDeadline;
+  }
+  currentSlotType() {
+    return this._running ? this._running.runnable.type : 'test';
+  }
+  _createTimeoutError(running) {
+    var _runnable$fixture3;
+    let message = '';
+    const timeout = running.slot.timeout;
+    const runnable = running.runnable;
+    switch (runnable.type) {
+      case 'test':
+        {
+          if (runnable.fixture) {
+            if (runnable.fixture.phase === 'setup') message = `Test timeout of ${timeout}ms exceeded while setting up "${runnable.fixture.title}".`;else message = `Tearing down "${runnable.fixture.title}" exceeded the test timeout of ${timeout}ms.`;
+          } else {
+            message = `Test timeout of ${timeout}ms exceeded.`;
+          }
+          break;
+        }
+      case 'afterEach':
+      case 'beforeEach':
+        message = `Test timeout of ${timeout}ms exceeded while running "${runnable.type}" hook.`;
+        break;
+      case 'beforeAll':
+      case 'afterAll':
+        message = `"${runnable.type}" hook timeout of ${timeout}ms exceeded.`;
+        break;
+      case 'teardown':
+        {
+          if (runnable.fixture) message = `Worker teardown timeout of ${timeout}ms exceeded while ${runnable.fixture.phase === 'setup' ? 'setting up' : 'tearing down'} "${runnable.fixture.title}".`;else message = `Worker teardown timeout of ${timeout}ms exceeded.`;
+          break;
+        }
+      case 'skip':
+      case 'slow':
+      case 'fixme':
+      case 'fail':
+        message = `"${runnable.type}" modifier timeout of ${timeout}ms exceeded.`;
+        break;
+    }
+    const fixtureWithSlot = (_runnable$fixture3 = runnable.fixture) !== null && _runnable$fixture3 !== void 0 && _runnable$fixture3.slot ? runnable.fixture : undefined;
+    if (fixtureWithSlot) message = `Fixture "${fixtureWithSlot.title}" timeout of ${timeout}ms exceeded during ${fixtureWithSlot.phase}.`;
+    message = _utilsBundle.colors.red(message);
+    const location = (fixtureWithSlot || runnable).location;
+    const error = new TimeoutManagerError(message);
+    error.name = '';
+    // Include location for hooks, modifiers and fixtures to distinguish between them.
+    error.stack = message + (location ? `\n    at ${location.file}:${location.line}:${location.column}` : '');
+    return error;
+  }
+}
+exports.TimeoutManager = TimeoutManager;
+class TimeoutManagerError extends Error {}
+exports.TimeoutManagerError = TimeoutManagerError;