@zohodesk/testinglibrary 0.1.9-exp-actors → 0.1.12-experimental

package/build/core/playwright/helpers/contextFailureHandler.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleContextFailureSegregation = handleContextFailureSegregation;
+exports.performDefaultContextSteps = performDefaultContextSteps;
+var _failureTagClassifier = require("./failureTagClassifier");
+var _runtimeLogPath = require("./runtimeLogPath");
+var _logger = require("../../../utils/logger");
+async function performDefaultContextSteps({
+  context,
+  testSetup
+}) {
+  if (testSetup.context && typeof testSetup.context === 'function') {
+    await testSetup.context({
+      context
+    });
+  }
+}
+
+// Fixture teardown has no Playwright result.stdout/stderr; use the thrown
+// error text so TOOL/CASE stdio patterns (e.g. data-generator failures) match.
+function buildStdioTextFromTestInfo(testInfo) {
+  // A stack already starts with the message, so emitting both would halve the
+  // truncation budget the recorded match evidence gets.
+  return (testInfo.errors || []).map(err => (err === null || err === void 0 ? void 0 : err.stack) || (err === null || err === void 0 ? void 0 : err.message) || (err === null || err === void 0 ? void 0 : err.value) || '').filter(Boolean).join('\n');
+}
+function splitTagList(description = '') {
+  return description.split(',').map(tag => tag.trim()).filter(Boolean);
+}
+
+// Prepends TOOL_failure (etc.) into the "tags" annotation so Playwright HTML
+// shows: tags: TOOL_failure, @edition_enterprise, @profile_admin
+function prependFailureTagsToAnnotations(testInfo, failureTags) {
+  const annotations = testInfo.annotations ?? (testInfo.annotations = []);
+  const tagsAnnotation = annotations.find(annotation => annotation.type === 'tags');
+  const description = (0, _failureTagClassifier.mergeFailureTags)(splitTagList(tagsAnnotation === null || tagsAnnotation === void 0 ? void 0 : tagsAnnotation.description), failureTags).join(', ');
+  if (tagsAnnotation) {
+    tagsAnnotation.description = description;
+  } else {
+    annotations.push({
+      type: 'tags',
+      description
+    });
+  }
+}
+
+// Failure-only: write runtime logs and attach failure-tag metadata.
+async function handleContextFailureSegregation({
+  collector,
+  testInfo,
+  logsDir
+}) {
+  const isFailure = testInfo.status && testInfo.status !== testInfo.expectedStatus;
+  if (!isFailure) {
+    return;
+  }
+  try {
+    const base = (0, _runtimeLogPath.resolveRuntimeLogBaseName)({
+      workerIndex: testInfo.workerIndex,
+      retry: testInfo.retry,
+      title: testInfo.title,
+      titlePath: testInfo.titlePath
+    });
+    collector.flushToFile(logsDir, base);
+    const metadata = (0, _failureTagClassifier.classifyFailureDetailsFromEvents)(collector.events, buildStdioTextFromTestInfo(testInfo));
+    prependFailureTagsToAnnotations(testInfo, metadata.tags);
+
+    // classifyFailureDetailsFromEvents always yields at least CODE, so attachment is non-null.
+    const attachment = (0, _failureTagClassifier.buildFailureTagMetadataAttachment)(metadata);
+    await testInfo.attach(attachment.name, {
+      contentType: attachment.contentType,
+      body: attachment.body
+    });
+  } catch (err) {
+    // Runs from the fixture's finally after a failure; a throw here would
+    // replace the real test error with a bookkeeping error.
+    _logger.Logger.error(err);
+  }
+}

package/build/core/playwright/helpers/customFixturesHelper.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractTagInfo = extractTagInfo;
+exports.getCustomAccountDetails = getCustomAccountDetails;
+var _auth = require("../helpers/auth");
+var _logger = require("../../../utils/logger");
+/* eslint-disable global-require */
+
+function getTagInputFromSelectedTags(tags, inputString) {
+  const selectedTag = [...tags].reverse().find(tag => tag.startsWith(inputString));
+  let tagInput = null;
+  if (selectedTag) {
+    tagInput = selectedTag.split(`${inputString}_`).pop().toLowerCase();
+  }
+  return tagInput;
+}
+function extractTagInfo(tags) {
+  const tagsTobeFiltered = ['@profile', '@edition', '@beta', '@portal'];
+  const filteredTags = tags.filter(tag => tagsTobeFiltered.some(prefix => tag.startsWith(prefix)));
+  if (!filteredTags.length) {
+    return {
+      portalInfo: null,
+      betaFeature: null,
+      profileInfo: null,
+      editionInfo: null
+    };
+  }
+  const portalInfo = getTagInputFromSelectedTags(filteredTags, '@portal');
+  const betaFeature = getTagInputFromSelectedTags(filteredTags, '@beta');
+  const profileInfo = getTagInputFromSelectedTags(filteredTags, '@profile');
+  const editionInfo = getTagInputFromSelectedTags(filteredTags, '@edition');
+  return {
+    portalInfo,
+    betaFeature,
+    profileInfo,
+    editionInfo
+  };
+}
+function getCustomAccountDetails(tags) {
+  try {
+    const {
+      portalInfo,
+      betaFeature,
+      profileInfo,
+      editionInfo
+    } = extractTagInfo(tags);
+    if (portalInfo || betaFeature || profileInfo || editionInfo) {
+      const user = (0, _auth.getUserForSelectedEditionAndProfile)(editionInfo, profileInfo, betaFeature, portalInfo);
+      return user;
+    }
+    return (0, _auth.getDefaultActor)();
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Error while getting accounts details:', err);
+  }
+}

package/build/core/playwright/helpers/failureTagClassifier.js

@@ -0,0 +1,197 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildFailureTagMetadataAttachment = buildFailureTagMetadataAttachment;
+exports.classifyFailureDetails = classifyFailureDetails;
+exports.classifyFailureDetailsFromEvents = classifyFailureDetailsFromEvents;
+exports.classifyFailureDetailsFromResult = classifyFailureDetailsFromResult;
+exports.classifyFailureTags = classifyFailureTags;
+exports.isFailingResultStatus = isFailingResultStatus;
+exports.mergeFailureTags = mergeFailureTags;
+exports.upsertFailureTagMetadataAttachment = upsertFailureTagMetadataAttachment;
+var _path = _interopRequireDefault(require("path"));
+var _failureTagConstants = require("../constants/failureTagConstants");
+var _patterns = require("../patterns");
+var _readConfigFile = require("../readConfigFile");
+var _runtimeLogReader = require("./runtimeLogReader");
+var _runtimeLogAnnotator = require("./runtimeLogAnnotator");
+// A failing test resolves to a SINGLE category tag by strict priority:
+// TOOL > CASE > CODE > ENVIRONMENT. If several categories match, only the
+// highest-priority one is emitted (e.g. CODE + ENVIRONMENT -> CODE only).
+// Metadata `matches` keeps only that winning category's unique hits (deduped by
+// tag + pattern + text). CODE/ENVIRONMENT patterns are matched against the
+// runtime log; TOOL/CASE against stdout/stderr. If a failure matches no
+// category at all it defaults to CODE. Retry-passed (flaky) outcomes are not tagged.
+
+const UNEXPECTED_OUTCOME = 'unexpected';
+function isFailingResultStatus(status) {
+  return !['passed', 'skipped'].includes(status);
+}
+
+// Single-tag priority: the highest-ranked matched category wins.
+const CATEGORY_PRIORITY = [_failureTagConstants.FAILURE_TAGS.TOOL, _failureTagConstants.FAILURE_TAGS.CASE, _failureTagConstants.FAILURE_TAGS.CODE, _failureTagConstants.FAILURE_TAGS.ENVIRONMENT];
+const STDIO_RULES = [{
+  tag: _failureTagConstants.FAILURE_TAGS.TOOL,
+  patterns: _patterns.TOOL_PATTERNS
+}, {
+  tag: _failureTagConstants.FAILURE_TAGS.CASE,
+  patterns: _patterns.CASE_PATTERNS
+}];
+function resolveLogsDir() {
+  const {
+    reportPath
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  return _path.default.join(reportPath, 'runtime-logs');
+}
+function stdioToText(entries = []) {
+  return entries.map(entry => {
+    if (typeof entry === 'string') {
+      return entry;
+    }
+    if (!entry || typeof entry !== 'object') {
+      return '';
+    }
+    if (entry.text) {
+      return entry.text;
+    }
+    if (entry.buffer) {
+      try {
+        return Buffer.from(entry.buffer, 'base64').toString('utf8');
+      } catch {
+        return '';
+      }
+    }
+    return '';
+  }).join('\n');
+}
+function buildStdioText(result = {}) {
+  return `${stdioToText(result.stdout)}\n${stdioToText(result.stderr)}`;
+}
+function findStdioMatch(stdio, patterns, tag) {
+  for (const pattern of patterns) {
+    if ((0, _runtimeLogAnnotator.testPattern)(pattern, stdio)) {
+      return {
+        tag,
+        pattern: (0, _runtimeLogAnnotator.patternLabel)(pattern),
+        source: 'stdio',
+        text: (0, _runtimeLogAnnotator.truncateText)(stdio)
+      };
+    }
+  }
+  return null;
+}
+function collectStdioMatches(stdio) {
+  const matches = [];
+  for (const rule of STDIO_RULES) {
+    const match = findStdioMatch(stdio, rule.patterns, rule.tag);
+    if (match) {
+      matches.push(match);
+    }
+  }
+  return matches;
+}
+function matchKey(match) {
+  return `${match.tag}\0${match.pattern}\0${match.text}`;
+}
+function uniqueMatchesByEvidence(matches = []) {
+  const uniqueMatches = [];
+  const seen = new Set();
+  for (const match of matches) {
+    const key = matchKey(match);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    uniqueMatches.push(match);
+  }
+  return uniqueMatches;
+}
+function collectMatchesFromResult(result, testTitle) {
+  const events = (0, _runtimeLogAnnotator.normalizeRuntimeLogEvents)((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, testTitle, resolveLogsDir()));
+  return [...(0, _runtimeLogAnnotator.collectRuntimeLogMatches)(events), ...collectStdioMatches(buildStdioText(result))];
+}
+function buildFailureTagMetadata(matches = []) {
+  // Collapse the matched categories to the single highest-priority winner.
+  // When a failure matched no category, fall back to CODE.
+  const winningCategory = CATEGORY_PRIORITY.find(tag => matches.some(match => match.tag === tag)) || _failureTagConstants.FAILURE_TAGS.CODE;
+
+  // Only the winning category's evidence is surfaced; drop lower-priority
+  // categories (e.g. ENVIRONMENT when CODE wins) and identical duplicates.
+  const winningMatches = uniqueMatchesByEvidence(matches.filter(match => match.tag === winningCategory));
+  return {
+    tags: [winningCategory],
+    matches: winningMatches
+  };
+}
+
+// events = browser runtime log; stdioText = stdout/stderr or test error text
+// (TOOL/CASE patterns only match against stdioText).
+function classifyFailureDetailsFromEvents(events = [], stdioText = '') {
+  return buildFailureTagMetadata([...(0, _runtimeLogAnnotator.collectRuntimeLogMatches)((0, _runtimeLogAnnotator.normalizeRuntimeLogEvents)(events)), ...collectStdioMatches(stdioText)]);
+}
+function classifyFailureDetailsFromResult(result, testTitle) {
+  return buildFailureTagMetadata(collectMatchesFromResult(result, testTitle));
+}
+function classifyFailureDetails(testDetails = [], testTitle = 'test') {
+  const unexpectedDetails = testDetails.filter(detail => detail.status === UNEXPECTED_OUTCOME);
+  if (unexpectedDetails.length === 0) {
+    return {
+      tags: [],
+      matches: []
+    };
+  }
+  const matches = [];
+  for (const detail of unexpectedDetails) {
+    const failingResult = pickFailingResult(detail.results);
+    if (!failingResult) {
+      continue;
+    }
+    matches.push(...collectMatchesFromResult(failingResult, testTitle));
+  }
+  return buildFailureTagMetadata(matches);
+}
+function classifyFailureTags(testDetails = [], testTitle = 'test') {
+  return classifyFailureDetails(testDetails, testTitle).tags;
+}
+function pickFailingResult(results = []) {
+  const failing = results.filter(result => isFailingResultStatus(result.status));
+  if (failing.length === 0) {
+    return null;
+  }
+  return failing[failing.length - 1];
+}
+function formatFailureTag(tag) {
+  return `${tag}${_failureTagConstants.FAILURE_TAG_SUFFIX}`;
+}
+function mergeFailureTags(existingTags = [], failureTags = []) {
+  const formatted = failureTags.map(formatFailureTag);
+  const merged = [...formatted];
+  for (const tag of existingTags) {
+    if (!merged.includes(tag)) {
+      merged.push(tag);
+    }
+  }
+  return merged;
+}
+function buildFailureTagMetadataAttachment(details) {
+  var _details$tags;
+  if (!(details !== null && details !== void 0 && (_details$tags = details.tags) !== null && _details$tags !== void 0 && _details$tags.length)) {
+    return null;
+  }
+  return {
+    name: _failureTagConstants.FAILURE_TAG_METADATA_ATTACHMENT,
+    contentType: 'application/json',
+    body: Buffer.from(JSON.stringify(details, null, 2))
+  };
+}
+function upsertFailureTagMetadataAttachment(attachments = [], details) {
+  const metadataAttachment = buildFailureTagMetadataAttachment(details);
+  if (!metadataAttachment) {
+    return attachments;
+  }
+  const withoutMetadata = attachments.filter(item => item.name !== _failureTagConstants.FAILURE_TAG_METADATA_ATTACHMENT);
+  return [...withoutMetadata, metadataAttachment];
+}

package/build/core/playwright/helpers/fileMutex.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _FileMutex_brand = /*#__PURE__*/new WeakSet();
+class FileMutex {
+  constructor(directory, lockFileName, fileDeletionTimeoutConfig) {
+    _classPrivateMethodInitSpec(this, _FileMutex_brand);
+    this.directory = directory;
+    this.lockFileName = lockFileName + ".lock";
+    this.fileDeletionTimeout = fileDeletionTimeoutConfig.timeout;
+    this.lockFilePath = _assertClassBrand(_FileMutex_brand, this, _getLockFilePath).call(this);
+    _assertClassBrand(_FileMutex_brand, this, _createDirectoryIfNotExist).call(this);
+  }
+  async acquire() {
+    return new Promise((resolve, reject) => {
+      if (!(0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.writeFileSync)(this.lockFilePath, 'locked');
+        console.log(`Lock file created: ${this.lockFilePath}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+        return resolve();
+      }
+      const timeout = setTimeout(() => {
+        watcher.close();
+        reject(new Error('Watch timeout exceeded'));
+      }, this.fileDeletionTimeout);
+      const watcher = (0, _fs.watch)(this.directory, (eventType, filename) => {
+        try {
+          if (eventType === 'rename' && filename === this.lockFileName) {
+            clearTimeout(timeout);
+            console.log(`Lock file deleted! Proceeding, worker index - ${process.env.TEST_WORKER_INDEX}`);
+            watcher.close();
+            resolve();
+          }
+        } catch (err) {
+          console.error(`Error watching for lock file deletion: ${err.message}`);
+          watcher.close();
+        }
+      });
+    });
+  }
+  async release() {
+    try {
+      if ((0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.unlinkSync)(this.lockFilePath);
+        console.log(`Lock file deleted: ${this.lockFilePath}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      }
+    } catch (err) {
+      console.error(`Error deleting lock file: ${err.message}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      throw err;
+    }
+  }
+}
+function _getLockFilePath() {
+  return _path.default.resolve(_path.default.join(this.directory, this.lockFileName));
+}
+async function _createDirectoryIfNotExist() {
+  if (!(0, _fs.existsSync)(this.directory)) {
+    (0, _fs.mkdirSync)(this.directory, {
+      recursive: true
+    });
+  }
+}
+var _default = exports.default = FileMutex;

package/build/core/playwright/helpers/logCollector.js

@@ -0,0 +1,147 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogCollector = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fileUtils = require("../../../utils/fileUtils");
+var _logCollectorIgnorePatterns = require("../patterns/logCollectorIgnorePatterns");
+var _runtimeLogAnnotator = require("./runtimeLogAnnotator");
+// Per-context Playwright runtime event collector — network failures,
+// console errors, page errors and crashes. Buffered in-memory and flushed
+// to the project runtime-logs folder per test.
+
+const DEFAULT_CONFIG = {
+  maxEvents: 2000,
+  ignoreMessagePatterns: _logCollectorIgnorePatterns.IGNORE_MESSAGE_PATTERNS,
+  ignoreUrlPatterns: _logCollectorIgnorePatterns.IGNORE_URL_PATTERNS
+};
+class LogCollector {
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    this.events = [];
+    this._bound = [];
+  }
+  _push(evt) {
+    if (this.events.length >= this.config.maxEvents) {
+      this.events.shift();
+    }
+    this.events.push({
+      ts: Date.now(),
+      ...evt
+    });
+  }
+  _shouldIgnore(url) {
+    if (!url) {
+      return false;
+    }
+    return this.config.ignoreUrlPatterns.some(re => re.test(url));
+  }
+  _shouldIgnoreMessage(message) {
+    if (!message) {
+      return false;
+    }
+    return this.config.ignoreMessagePatterns.some(re => re.test(message));
+  }
+  _bind(target, event, handler) {
+    target.on(event, handler);
+    this._bound.push([target, event, handler]);
+  }
+  attachToContext(context) {
+    context.pages().forEach(p => this._attachPage(p));
+    this._bind(context, 'page', p => this._attachPage(p));
+    this._bind(context, 'response', res => {
+      const url = res.url();
+      if (this._shouldIgnore(url)) {
+        return;
+      }
+      if (res.status() >= 400) {
+        this._push({
+          kind: 'response',
+          status: res.status(),
+          method: res.request().method(),
+          url,
+          fromCache: res.fromServiceWorker()
+        });
+      }
+    });
+    this._bind(context, 'requestfailed', req => {
+      var _req$failure;
+      const url = req.url();
+      const failure = (_req$failure = req.failure()) === null || _req$failure === void 0 ? void 0 : _req$failure.errorText;
+      if (this._shouldIgnore(url) || this._shouldIgnoreMessage(failure)) {
+        return;
+      }
+      this._push({
+        kind: 'requestfailed',
+        method: req.method(),
+        url,
+        failure,
+        resourceType: req.resourceType()
+      });
+    });
+  }
+  _attachPage(page) {
+    this._bind(page, 'console', msg => {
+      const type = msg.type();
+      if (type !== 'error') {
+        return;
+      }
+      const text = msg.text();
+      const location = msg.location();
+      if (this._shouldIgnoreMessage(text) || this._shouldIgnore(location === null || location === void 0 ? void 0 : location.url)) {
+        return;
+      }
+      this._push({
+        kind: 'console',
+        level: type,
+        text,
+        location
+      });
+    });
+    this._bind(page, 'pageerror', err => {
+      if (this._shouldIgnoreMessage(err.message)) {
+        return;
+      }
+      this._push({
+        kind: 'pageerror',
+        name: err.name,
+        message: err.message,
+        stack: err.stack
+      });
+    });
+    this._bind(page, 'crash', () => {
+      this._push({
+        kind: 'crash',
+        url: page.url()
+      });
+    });
+  }
+  detach() {
+    for (const [target, event, handler] of this._bound) {
+      try {
+        target.removeListener(event, handler);
+      } catch {
+        // context may already be closed
+      }
+    }
+    this._bound.length = 0;
+  }
+  flushToFile(dir, baseName) {
+    if (this.events.length === 0) {
+      return null;
+    }
+    const file = _path.default.join(dir, `${baseName}.jsonl`);
+    // Keep in-memory events raw; annotate category matches only on disk.
+    const lines = (0, _runtimeLogAnnotator.annotateRuntimeLogEvents)(this.events);
+    const body = lines.map(e => JSON.stringify(e)).join('\n') + '\n';
+    (0, _fileUtils.writeFileContents)(file, body);
+    return file;
+  }
+}
+exports.LogCollector = LogCollector;

package/build/core/playwright/helpers/parseUserArgs.js

@@ -3,9 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.parseUserArgs = parseUserArgs;
 var _cliArgsToObject = require("../../../utils/cliArgsToObject");
 function parseUserArgs() {
   return (0, _cliArgsToObject.cliArgsToObject)(process.argv.slice(2));
-}
-var _default = exports.default = parseUserArgs;
+}