@smoothdeploy/playwright 1.58.3 → 1.60.0-beta-1780662356000

package/lib/worker/testTracing.js

@@ -1,345 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var testTracing_exports = {};
-__export(testTracing_exports, {
-  TestTracing: () => TestTracing,
-  testTraceEntryName: () => testTraceEntryName
-});
-module.exports = __toCommonJS(testTracing_exports);
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_utils = require("playwright-core/lib/utils");
-var import_zipBundle = require("playwright-core/lib/zipBundle");
-var import_util = require("../util");
-const testTraceEntryName = "test.trace";
-const version = 8;
-let traceOrdinal = 0;
-class TestTracing {
-  constructor(testInfo, artifactsDir) {
-    this._traceEvents = [];
-    this._temporaryTraceFiles = [];
-    this._didFinishTestFunctionAndAfterEachHooks = false;
-    this._testInfo = testInfo;
-    this._artifactsDir = artifactsDir;
-    this._tracesDir = import_path.default.join(this._artifactsDir, "traces");
-    this._contextCreatedEvent = {
-      version,
-      type: "context-options",
-      origin: "testRunner",
-      browserName: "",
-      playwrightVersion: (0, import_utils.getPlaywrightVersion)(),
-      options: {},
-      platform: process.platform,
-      wallTime: Date.now(),
-      monotonicTime: (0, import_utils.monotonicTime)(),
-      sdkLanguage: "javascript"
-    };
-    this._appendTraceEvent(this._contextCreatedEvent);
-  }
-  _shouldCaptureTrace() {
-    if (this._options?.mode === "on")
-      return true;
-    if (this._options?.mode === "retain-on-failure")
-      return true;
-    if (this._options?.mode === "on-first-retry" && this._testInfo.retry === 1)
-      return true;
-    if (this._options?.mode === "on-all-retries" && this._testInfo.retry > 0)
-      return true;
-    if (this._options?.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 = void 0;
-      return;
-    }
-    if (!this._liveTraceFile && this._options._live) {
-      this._liveTraceFile = { file: import_path.default.join(this._tracesDir, `${this._testInfo.testId}-test.trace`), fs: new import_utils.SerializedFS() };
-      this._liveTraceFile.fs.mkdir(import_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);
-    }
-  }
-  didFinishTestFunctionAndAfterEachHooks() {
-    this._didFinishTestFunctionAndAfterEachHooks = true;
-  }
-  artifactsDir() {
-    return this._artifactsDir;
-  }
-  tracesDir() {
-    return this._tracesDir;
-  }
-  traceTitle() {
-    return [import_path.default.relative(this._testInfo.project.testDir, this._testInfo.file) + ":" + this._testInfo.line, ...this._testInfo.titlePath.slice(1)].join(" \u203A ");
-  }
-  generateNextTraceRecordingName() {
-    const ordinalSuffix = traceOrdinal ? `-recording${traceOrdinal}` : "";
-    ++traceOrdinal;
-    const retrySuffix = this._testInfo.retry ? `-retry${this._testInfo.retry}` : "";
-    return `${this._testInfo.testId}${retrySuffix}${ordinalSuffix}`;
-  }
-  _generateNextTraceRecordingPath() {
-    const file = import_path.default.join(this._artifactsDir, (0, import_utils.createGuid)() + ".zip");
-    this._temporaryTraceFiles.push(file);
-    return file;
-  }
-  traceOptions() {
-    return this._options;
-  }
-  maybeGenerateNextTraceRecordingPath() {
-    if (this._didFinishTestFunctionAndAfterEachHooks && this._shouldAbandonTrace())
-      return;
-    return this._generateNextTraceRecordingPath();
-  }
-  _shouldAbandonTrace() {
-    if (!this._options)
-      return true;
-    const testFailed = this._testInfo.status !== this._testInfo.expectedStatus;
-    return !testFailed && (this._options.mode === "retain-on-failure" || this._options.mode === "retain-on-first-failure");
-  }
-  async stopIfNeeded() {
-    if (!this._options)
-      return;
-    const error = await this._liveTraceFile?.fs.syncAndGetError();
-    if (error)
-      throw error;
-    if (this._shouldAbandonTrace()) {
-      for (const file of this._temporaryTraceFiles)
-        await import_fs.default.promises.unlink(file).catch(() => {
-        });
-      return;
-    }
-    const zipFile = new import_zipBundle.yazl.ZipFile();
-    if (!this._options?.attachments) {
-      for (const event of this._traceEvents) {
-        if (event.type === "after")
-          delete event.attachments;
-      }
-    }
-    if (this._options?.sources) {
-      const sourceFiles = /* @__PURE__ */ 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 import_fs.default.promises.readFile(sourceFile, "utf8").then((source) => {
-          zipFile.addBuffer(Buffer.from(source), "resources/src@" + (0, import_utils.calculateSha1)(sourceFile) + ".txt");
-        }).catch(() => {
-        });
-      }
-    }
-    const sha1s = /* @__PURE__ */ 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 = import_fs.default.promises.readFile(attachment.path).catch(() => void 0);
-        else if (attachment.base64)
-          contentPromise = Promise.resolve(Buffer.from(attachment.base64, "base64"));
-        const content = await contentPromise;
-        if (content === void 0)
-          continue;
-        const sha1 = (0, import_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(void 0, () => {
-        zipFile.outputStream.pipe(import_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) {
-    const rawStack = error.stack?.split("\n") || [];
-    const stack = rawStack ? (0, import_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, import_utils.monotonicTime)(),
-      text: typeof chunk === "string" ? chunk : void 0,
-      base64: typeof chunk === "string" ? void 0 : chunk.toString("base64")
-    });
-  }
-  appendBeforeActionForStep(options) {
-    this._appendTraceEvent({
-      type: "before",
-      callId: options.stepId,
-      stepId: options.stepId,
-      parentId: options.parentId,
-      startTime: (0, import_utils.monotonicTime)(),
-      class: "Test",
-      method: options.category,
-      title: options.title,
-      params: Object.fromEntries(Object.entries(options.params || {}).map(([name, value]) => [name, generatePreview(value)])),
-      stack: options.stack,
-      group: options.group
-    });
-  }
-  appendAfterActionForStep(callId, error, attachments = [], annotations) {
-    this._appendTraceEvent({
-      type: "after",
-      callId,
-      endTime: (0, import_utils.monotonicTime)(),
-      attachments: serializeAttachments(attachments),
-      annotations,
-      error
-    });
-  }
-  _appendTraceEvent(event) {
-    this._traceEvents.push(event);
-    if (this._liveTraceFile)
-      this._liveTraceFile.fs.appendFile(this._liveTraceFile.file, JSON.stringify(event) + "\n", true);
-  }
-}
-function serializeAttachments(attachments) {
-  if (attachments.length === 0)
-    return void 0;
-  return attachments.filter((a) => a.name !== "trace").map((a) => {
-    return {
-      name: a.name,
-      contentType: a.contentType,
-      path: a.path,
-      base64: a.body?.toString("base64")
-    };
-  });
-}
-function generatePreview(value, visited = /* @__PURE__ */ 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 === void 0)
-    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) => import_fs.default.existsSync(file));
-  if (temporaryTraceFiles.length === 1) {
-    await import_fs.default.promises.rename(temporaryTraceFiles[0], fileName);
-    return;
-  }
-  const mergePromise = new import_utils.ManualPromise();
-  const zipFile = new import_zipBundle.yazl.ZipFile();
-  const entryNames = /* @__PURE__ */ 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 import_utils.ManualPromise();
-    import_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) {
-        } else if (entry.fileName.match(/trace\.[a-z]*$/)) {
-          entryName = i + "-" + entry.fileName;
-        }
-        if (entryNames.has(entryName)) {
-          if (--pendingEntries === 0)
-            promise.resolve();
-          return;
-        }
-        entryNames.add(entryName);
-        inZipFile.openReadStream(entry, (err2, readStream) => {
-          if (err2) {
-            promise.reject(err2);
-            return;
-          }
-          zipFile.addReadStream(readStream, entryName);
-          if (--pendingEntries === 0)
-            promise.resolve();
-        });
-      });
-    });
-    await promise;
-  }
-  zipFile.end(void 0, () => {
-    zipFile.outputStream.pipe(import_fs.default.createWriteStream(fileName)).on("close", () => {
-      void Promise.all(temporaryTraceFiles.map((tempFile) => import_fs.default.promises.unlink(tempFile))).then(() => {
-        mergePromise.resolve();
-      }).catch((error) => mergePromise.reject(error));
-    }).on("error", (error) => mergePromise.reject(error));
-  });
-  await mergePromise;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TestTracing,
-  testTraceEntryName
-});

package/lib/worker/timeoutManager.js

@@ -1,174 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var timeoutManager_exports = {};
-__export(timeoutManager_exports, {
-  TimeoutManager: () => TimeoutManager,
-  TimeoutManagerError: () => TimeoutManagerError,
-  kMaxDeadline: () => kMaxDeadline
-});
-module.exports = __toCommonJS(timeoutManager_exports);
-var import_utils = require("playwright-core/lib/utils");
-var import_utils2 = require("playwright-core/lib/utils");
-var import_util = require("../util");
-const kMaxDeadline = 2147483647;
-class TimeoutManager {
-  constructor(timeout) {
-    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) {
-    const slot = runnable.fixture?.slot || runnable.slot || this._defaultSlot;
-    return slot.timeout > 0 && slot.elapsed >= slot.timeout - 1;
-  }
-  async withRunnable(runnable, cb) {
-    if (this._running)
-      throw new Error(`Internal error: duplicate runnable`);
-    const running = this._running = {
-      runnable,
-      slot: runnable.fixture?.slot || runnable.slot || this._defaultSlot,
-      start: (0, import_utils.monotonicTime)(),
-      deadline: kMaxDeadline,
-      timer: void 0,
-      timeoutPromise: new import_utils.ManualPromise()
-    };
-    let debugTitle = "";
-    try {
-      if (import_util.debugTest.enabled) {
-        debugTitle = runnable.fixture ? `${runnable.fixture.phase} "${runnable.fixture.title}"` : runnable.type;
-        const location = runnable.location ? ` at "${(0, import_util.formatLocation)(runnable.location)}"` : ``;
-        (0, import_util.debugTest)(`started ${debugTitle}${location}`);
-      }
-      this._updateTimeout(running);
-      return await Promise.race([
-        cb(),
-        running.timeoutPromise
-      ]);
-    } finally {
-      if (running.timer)
-        clearTimeout(running.timer);
-      running.timer = void 0;
-      running.slot.elapsed += (0, import_utils.monotonicTime)() - running.start;
-      this._running = void 0;
-      if (import_util.debugTest.enabled)
-        (0, import_util.debugTest)(`finished ${debugTitle}`);
-    }
-  }
-  _updateTimeout(running) {
-    if (running.timer)
-      clearTimeout(running.timer);
-    running.timer = void 0;
-    if (this._ignoreTimeouts || !running.slot.timeout) {
-      running.deadline = kMaxDeadline;
-      return;
-    }
-    running.deadline = running.start + (running.slot.timeout - running.slot.elapsed);
-    const timeout = running.deadline - (0, import_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) {
-    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.fixture?.slot ? runnable.fixture : void 0;
-    if (fixtureWithSlot)
-      message = `Fixture "${fixtureWithSlot.title}" timeout of ${timeout}ms exceeded during ${fixtureWithSlot.phase}.`;
-    message = import_utils2.colors.red(message);
-    const location = (fixtureWithSlot || runnable).location;
-    const error = new TimeoutManagerError(message);
-    error.name = "";
-    error.stack = message + (location ? `
-    at ${location.file}:${location.line}:${location.column}` : "");
-    return error;
-  }
-}
-class TimeoutManagerError extends Error {
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TimeoutManager,
-  TimeoutManagerError,
-  kMaxDeadline
-});

package/lib/worker/util.js

@@ -1,31 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var util_exports = {};
-__export(util_exports, {
-  testInfoError: () => testInfoError
-});
-module.exports = __toCommonJS(util_exports);
-var import_util = require("../util");
-function testInfoError(error) {
-  return (0, import_util.serializeError)(error);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  testInfoError
-});