@zohodesk/testinglibrary 0.0.85-n20-experimental → 0.0.87-n20-experimental

package/build/core/playwright/builtInFixtures/actorContext.js

@@ -25,20 +25,20 @@ class ActorContext {
       };
       const additionalActors = (0, _additionalProfiles.additionProfiles)($tags);
       await Promise.all(Object.entries(additionalActors).map(async ([role, actorInfo]) => {
-        let context = await browser.newContext();
-        let page = await context.newPage();
-        let ctxTestDetails = {
-          page,
+        const additionalContext = await browser.newContext();
+        const additionalPage = await additionalContext.newPage();
+        const ctxTestDetails = {
+          page: additionalPage,
           $tags,
-          context,
+          context: additionalContext,
           ...actorInfo
         };
-        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(context, testInfo, ctxTestDetails, actorInfo);
+        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(additionalContext, testInfo, ctxTestDetails, actorInfo);
         this.actorsObj[role] = {
           role,
           browser,
-          context,
-          page,
+          context: additionalContext,
+          page: additionalPage,
           executionContext: {
             actorInfo
           }
@@ -69,7 +69,10 @@ var _default = exports.default = {
   }, use, testInfo) => {
     const ctxObject = new ActorContext();
     await ctxObject.setup(browser, $tags, testInfo, context, page, executionContext);
-    await use(ctxObject);
-    await ctxObject.cleanup();
+    try {
+      await use(ctxObject);
+    } finally {
+      await ctxObject.cleanup();
+    }
   }
 };

package/build/core/playwright/builtInFixtures/page.js

@@ -32,7 +32,6 @@ var _default = exports.default = {
     } finally {
       await (0, _loginDefaultStepsHelper.performDefaultPageSteps)(testDetails);
       await use(page);
-      await context.close();
     }
   }
 };

package/build/core/playwright/constants/failureTagConstants.js

@@ -3,17 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.FAILURE_TAG_SUFFIX = exports.FAILURE_TAG_METADATA_SCHEMA_VERSION = exports.FAILURE_TAG_METADATA_ATTACHMENT = exports.FAILURE_TAGS = void 0;
+exports.FAILURE_TAG_SUFFIX = exports.FAILURE_TAG_METADATA_ATTACHMENT = exports.FAILURE_TAGS = void 0;
 const FAILURE_TAGS = exports.FAILURE_TAGS = {
   CASE: 'CASE',
   CODE: 'CODE',
   ENVIRONMENT: 'ENVIRONMENT',
-  FLAKY: 'FLAKY',
   TOOL: 'TOOL'
 };
 
 // Suffix appended to a category when merging into the existing spec.tags array,
-// e.g. "CODE" -> "CODE_failure". The flaky category is emitted as-is ("FLAKY").
+// e.g. "CODE" -> "CODE_failure".
 const FAILURE_TAG_SUFFIX = exports.FAILURE_TAG_SUFFIX = '_failure';
-const FAILURE_TAG_METADATA_ATTACHMENT = exports.FAILURE_TAG_METADATA_ATTACHMENT = 'failure-tag-metadata';
-const FAILURE_TAG_METADATA_SCHEMA_VERSION = exports.FAILURE_TAG_METADATA_SCHEMA_VERSION = 1;
+const FAILURE_TAG_METADATA_ATTACHMENT = exports.FAILURE_TAG_METADATA_ATTACHMENT = 'failure-tag-metadata';

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

@@ -9,6 +9,7 @@ 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"));
@@ -16,89 +17,35 @@ var _failureTagConstants = require("../constants/failureTagConstants");
 var _patterns = require("../patterns");
 var _readConfigFile = require("../readConfigFile");
 var _runtimeLogReader = require("./runtimeLogReader");
-// A failing test is tagged purely on presence: if its runtime log contains an
-// environment pattern it gets `ENVIRONMENT`, if it contains a code pattern it
-// gets `CODE`, and if its stdout/stderr contains a tool pattern it gets `TOOL`
-// or a case pattern it gets `CASE` (any may apply). A `CASE` match also adds
-// `CODE` for now via case-implied metadata. `FLAKY` comes from the Playwright
-// retry outcome, not the log.
+var _runtimeLogAnnotator = require("./runtimeLogAnnotator");
+// A failing test resolves to a SINGLE category tag by strict priority:
+// CODE > CASE > TOOL > 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 FAILING_RESULT_STATUSES = new Set(['failed', 'timedOut', 'interrupted']);
 const UNEXPECTED_OUTCOME = 'unexpected';
-const FLAKY_OUTCOME = 'flaky';
-const RUNTIME_LOG_SOURCE = 'runtime-log';
-const MAX_MATCH_TEXT_LENGTH = 500;
-const TAG_ORDER = [_failureTagConstants.FAILURE_TAGS.FLAKY, _failureTagConstants.FAILURE_TAGS.ENVIRONMENT, _failureTagConstants.FAILURE_TAGS.CASE, _failureTagConstants.FAILURE_TAGS.CODE, _failureTagConstants.FAILURE_TAGS.TOOL];
-const RUNTIME_LOG_RULES = [{
-  tag: _failureTagConstants.FAILURE_TAGS.ENVIRONMENT,
-  patterns: _patterns.ENVIRONMENT_PATTERNS
-}, {
-  tag: _failureTagConstants.FAILURE_TAGS.CODE,
-  patterns: _patterns.CODE_PATTERNS
-}];
+function isFailingResultStatus(status) {
+  return !['passed', 'skipped'].includes(status);
+}
+
+// Single-tag priority: the highest-ranked matched category wins.
+const CATEGORY_PRIORITY = [_failureTagConstants.FAILURE_TAGS.CODE, _failureTagConstants.FAILURE_TAGS.CASE, _failureTagConstants.FAILURE_TAGS.TOOL, _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,
-  impliesCode: true
+  patterns: _patterns.CASE_PATTERNS
 }];
-function resolveLogsDir(logsDir) {
-  if (logsDir) {
-    return logsDir;
-  }
+function resolveLogsDir() {
   const {
     uatDirectory
   } = (0, _readConfigFile.generateConfigFromFile)();
   return _path.default.join(uatDirectory, 'runtime-logs');
 }
-function patternLabel(pattern) {
-  return pattern.source;
-}
-function testPattern(pattern, text) {
-  if (pattern.global || pattern.sticky) {
-    pattern.lastIndex = 0;
-  }
-  return pattern.test(text);
-}
-function truncateText(text) {
-  if (!text || text.length <= MAX_MATCH_TEXT_LENGTH) {
-    return text || '';
-  }
-  return `${text.slice(0, MAX_MATCH_TEXT_LENGTH)}...`;
-}
-function eventToText(event) {
-  var _event$location;
-  switch (event.kind) {
-    case 'pageerror':
-      return `pageerror ${event.name || ''} ${event.message || ''}`;
-    case 'console':
-      return `console ${event.text || ''} ${((_event$location = event.location) === null || _event$location === void 0 ? void 0 : _event$location.url) || ''}`;
-    case 'requestfailed':
-      return `requestfailed ${event.resourceType || ''} ${event.method || ''} ${event.url || ''} ${event.failure || ''}`;
-    case 'response':
-      return `response ${event.status || ''} ${event.method || ''} ${event.url || ''}`;
-    default:
-      return JSON.stringify(event);
-  }
-}
-function findEventMatch(events, patterns, tag, source) {
-  for (const event of events) {
-    const text = eventToText(event);
-    for (const pattern of patterns) {
-      if (testPattern(pattern, text)) {
-        return {
-          tag,
-          pattern: patternLabel(pattern),
-          source,
-          text: truncateText(text)
-        };
-      }
-    }
-  }
-  return null;
-}
 function stdioToText(entries = []) {
   return entries.map(entry => {
     if (typeof entry === 'string') {
@@ -125,82 +72,75 @@ function buildStdioText(result = {}) {
 }
 function findStdioMatch(stdio, patterns, tag) {
   for (const pattern of patterns) {
-    if (testPattern(pattern, stdio)) {
+    if ((0, _runtimeLogAnnotator.testPattern)(pattern, stdio)) {
       return {
         tag,
-        pattern: patternLabel(pattern),
+        pattern: (0, _runtimeLogAnnotator.patternLabel)(pattern),
         source: 'stdio',
-        text: truncateText(stdio)
+        text: (0, _runtimeLogAnnotator.truncateText)(stdio)
       };
     }
   }
   return null;
 }
-function collectRuntimeLogMatches(events, matches) {
-  for (const rule of RUNTIME_LOG_RULES) {
-    const match = findEventMatch(events, rule.patterns, rule.tag, RUNTIME_LOG_SOURCE);
+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 collectStdioMatches(stdio, matches) {
-  for (const rule of STDIO_RULES) {
-    const match = findStdioMatch(stdio, rule.patterns, rule.tag);
-    if (!match) {
+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;
     }
-    matches.push(match);
-    if (rule.impliesCode) {
-      implyCodeFromCase(matches, match);
-    }
-  }
-}
-function implyCodeFromCase(matches, caseMatch) {
-  if (matches.some(match => match.tag === _failureTagConstants.FAILURE_TAGS.CODE)) {
-    return;
+    seen.add(key);
+    uniqueMatches.push(match);
   }
-  matches.push({
-    tag: _failureTagConstants.FAILURE_TAGS.CODE,
-    pattern: null,
-    source: 'case-implied',
-    text: caseMatch.text
-  });
-}
-function classifyFailureDetailsFromEvents(events = []) {
-  const matches = [];
-  collectRuntimeLogMatches(events, matches);
-  return buildFailureTagMetadata(matches);
+  return uniqueMatches;
 }
-function classifyFailureDetailsFromResult(result, testTitle, logsDir) {
-  const resolvedLogsDir = resolveLogsDir(logsDir);
-  const events = (0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, testTitle, resolvedLogsDir);
-  const matches = [];
-  collectRuntimeLogMatches(events, matches);
-  collectStdioMatches(buildStdioText(result), matches);
-  return buildFailureTagMetadata(matches);
+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 = []) {
-  const tags = TAG_ORDER.filter(tag => matches.some(match => match.tag === tag));
+  // 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 {
-    schemaVersion: _failureTagConstants.FAILURE_TAG_METADATA_SCHEMA_VERSION,
-    tags,
-    matches
+    tags: [winningCategory],
+    matches: winningMatches
   };
 }
-function classifyFailureDetails(testDetails = [], testTitle = 'test', logsDir) {
-  const resolvedLogsDir = resolveLogsDir(logsDir);
+function classifyFailureDetailsFromEvents(events = []) {
+  return buildFailureTagMetadata((0, _runtimeLogAnnotator.collectRuntimeLogMatches)((0, _runtimeLogAnnotator.normalizeRuntimeLogEvents)(events)));
+}
+function classifyFailureDetailsFromResult(result, testTitle) {
+  return buildFailureTagMetadata(collectMatchesFromResult(result, testTitle));
+}
+function classifyFailureDetails(testDetails = [], testTitle = 'test') {
+  if (!testDetails.some(detail => detail.status === UNEXPECTED_OUTCOME)) {
+    return {
+      tags: [],
+      matches: []
+    };
+  }
   const matches = [];
   for (const detail of testDetails) {
-    if (detail.status === FLAKY_OUTCOME) {
-      matches.push({
-        tag: _failureTagConstants.FAILURE_TAGS.FLAKY,
-        pattern: null,
-        source: 'retry-outcome',
-        text: null
-      });
-      continue;
-    }
     if (detail.status !== UNEXPECTED_OUTCOME) {
       continue;
     }
@@ -208,31 +148,21 @@ function classifyFailureDetails(testDetails = [], testTitle = 'test', logsDir) {
     if (!failingResult) {
       continue;
     }
-    const resultDetails = classifyFailureDetailsFromResult(failingResult, testTitle, resolvedLogsDir);
-    matches.push(...resultDetails.matches);
+    matches.push(...collectMatchesFromResult(failingResult, testTitle));
   }
-  const uniqueMatches = [];
-  for (const match of matches) {
-    if (!uniqueMatches.some(existing => existing.tag === match.tag)) {
-      uniqueMatches.push(match);
-    }
-  }
-  return buildFailureTagMetadata(uniqueMatches);
+  return buildFailureTagMetadata(matches);
 }
-function classifyFailureTags(testDetails = [], testTitle = 'test', logsDir) {
-  return classifyFailureDetails(testDetails, testTitle, logsDir).tags;
+function classifyFailureTags(testDetails = [], testTitle = 'test') {
+  return classifyFailureDetails(testDetails, testTitle).tags;
 }
 function pickFailingResult(results = []) {
-  const failing = results.filter(result => FAILING_RESULT_STATUSES.has(result.status));
+  const failing = results.filter(result => isFailingResultStatus(result.status));
   if (failing.length === 0) {
     return null;
   }
   return failing[failing.length - 1];
 }
 function formatFailureTag(tag) {
-  if (tag === _failureTagConstants.FAILURE_TAGS.FLAKY) {
-    return tag;
-  }
   return `${tag}${_failureTagConstants.FAILURE_TAG_SUFFIX}`;
 }
 function mergeFailureTags(existingTags = [], failureTags = []) {

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

@@ -8,6 +8,7 @@ exports.LogCollector = void 0;
 var _path = _interopRequireDefault(require("path"));
 var _fileUtils = require("../../../utils/fileUtils");
 var _logCollectorConstants = require("../constants/logCollectorConstants");
+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.
@@ -136,7 +137,9 @@ class LogCollector {
       return null;
     }
     const file = _path.default.join(dir, `${baseName}.jsonl`);
-    const body = this.events.map(e => JSON.stringify(e)).join('\n') + '\n';
+    // 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;
   }

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

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.annotateRuntimeLogEvents = annotateRuntimeLogEvents;
+exports.collectRuntimeLogMatches = collectRuntimeLogMatches;
+exports.eventToText = eventToText;
+exports.normalizeRuntimeLogEvents = normalizeRuntimeLogEvents;
+exports.patternLabel = patternLabel;
+exports.testPattern = testPattern;
+exports.truncateText = truncateText;
+var _failureTagConstants = require("../constants/failureTagConstants");
+var _patterns = require("../patterns");
+// Shared runtime-log event text + CODE/ENVIRONMENT tagging.
+// Used by LogCollector (JSONL flush) and failureTagClassifier (metadata).
+
+const RUNTIME_LOG_SOURCE = 'runtime-log';
+const MAX_MATCH_TEXT_LENGTH = 500;
+const RUNTIME_LOG_RULES = [{
+  tag: _failureTagConstants.FAILURE_TAGS.ENVIRONMENT,
+  patterns: _patterns.ENVIRONMENT_PATTERNS
+}, {
+  tag: _failureTagConstants.FAILURE_TAGS.CODE,
+  patterns: _patterns.CODE_PATTERNS
+}];
+function testPattern(pattern, text) {
+  if (pattern.global || pattern.sticky) {
+    pattern.lastIndex = 0;
+  }
+  return pattern.test(text);
+}
+function truncateText(text) {
+  if (!text || text.length <= MAX_MATCH_TEXT_LENGTH) {
+    return text || '';
+  }
+  return `${text.slice(0, MAX_MATCH_TEXT_LENGTH)}...`;
+}
+function patternLabel(pattern) {
+  return pattern.source;
+}
+function eventToText(event) {
+  var _event$location;
+  switch (event.kind) {
+    case 'pageerror':
+      return `pageerror ${event.name || ''} ${event.message || ''}`;
+    case 'console':
+      return `console ${event.text || ''} ${((_event$location = event.location) === null || _event$location === void 0 ? void 0 : _event$location.url) || ''}`;
+    case 'requestfailed':
+      return `requestfailed ${event.resourceType || ''} ${event.method || ''} ${event.url || ''} ${event.failure || ''}`;
+    case 'response':
+      return `response ${event.status || ''} ${event.method || ''} ${event.url || ''}`;
+    default:
+      return JSON.stringify(event);
+  }
+}
+function matchingRuntimeLogTags(event) {
+  const text = eventToText(event);
+  const tags = [];
+  for (const rule of RUNTIME_LOG_RULES) {
+    if (rule.patterns.some(pattern => testPattern(pattern, text))) {
+      tags.push(rule.tag);
+    }
+  }
+  return tags;
+}
+function findAllEventMatches(events, patterns, tag, source) {
+  const matches = [];
+  for (const event of events) {
+    const text = eventToText(event);
+    for (const pattern of patterns) {
+      if (testPattern(pattern, text)) {
+        matches.push({
+          tag,
+          pattern: patternLabel(pattern),
+          source,
+          text: truncateText(text)
+        });
+      }
+    }
+  }
+  return matches;
+}
+
+// Matching events get a category `pattern` field (CODE / ENVIRONMENT).
+// Dual matches emit two lines with the same payload.
+function annotateRuntimeLogEvents(events = []) {
+  const lines = [];
+  for (const event of events) {
+    if (!event) {
+      continue;
+    }
+    const {
+      pattern: _ignored,
+      ...raw
+    } = event;
+    const matchedTags = matchingRuntimeLogTags(raw);
+    if (matchedTags.length === 0) {
+      lines.push(raw);
+      continue;
+    }
+    for (const tag of matchedTags) {
+      lines.push({
+        pattern: tag,
+        ...raw
+      });
+    }
+  }
+  return lines;
+}
+
+// Strip flush-time `pattern` annotations and drop duplicate event payloads so
+// CODE+ENVIRONMENT dual lines on disk do not inflate classification counts.
+function normalizeRuntimeLogEvents(events = []) {
+  const seen = new Set();
+  const normalized = [];
+  for (const event of events) {
+    if (!event) {
+      continue;
+    }
+    const {
+      pattern: _ignored,
+      ...raw
+    } = event;
+    const key = JSON.stringify(raw);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    normalized.push(raw);
+  }
+  return normalized;
+}
+function collectRuntimeLogMatches(events = []) {
+  const matches = [];
+  for (const rule of RUNTIME_LOG_RULES) {
+    matches.push(...findAllEventMatches(events, rule.patterns, rule.tag, RUNTIME_LOG_SOURCE));
+  }
+  return matches;
+}

package/build/core/playwright/patterns/codePatterns.js

@@ -6,4 +6,4 @@ Object.defineProperty(exports, "__esModule", {
 exports.CODE_PATTERNS = void 0;
 // Code patterns: real application defects surfacing as JS exceptions in the
 // browser. Matched against a flattened text form of each runtime-log event.
-const CODE_PATTERNS = exports.CODE_PATTERNS = [/Cannot read properties of (undefined|null)/i, /\bis not a function\b/i, /\bis not defined\b/i, /\bis not iterable\b/i];
+const CODE_PATTERNS = exports.CODE_PATTERNS = [/Cannot read properties of (undefined|null)/i, /\bis not a function\b/i, /\bis not defined\b/i, /\bis not iterable\b/i, /\bis not valid JSON\b/i, /\bis not a valid URL\b/i, /\bFailed to load resource: the server responded with a status of 422\b/i];

package/build/core/playwright/patterns/environmentPatterns.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ENVIRONMENT_PATTERNS = void 0;
 // Environment patterns: infra / network / server breakage. Matched against a
-// flattened text form of each runtime-log event (see eventToText).
+// flattened text form of each runtime-log event (see runtimeLogAnnotator.eventToText).
 const ENVIRONMENT_PATTERNS = exports.ENVIRONMENT_PATTERNS = [
 // Main document navigation was aborted (page never loaded).
 /^requestfailed document\b[\s\S]*ERR_ABORTED/i,

package/build/core/playwright/patterns/toolPatterns.js

@@ -20,15 +20,7 @@ const TOOL_PATTERNS = exports.TOOL_PATTERNS = [/Error during login/i, /fetch fai
 /Error while parsing cookies/i,
 // FileMutex
 /Watch timeout exceeded/i,
-// Runner
-/Method 'run\(\)' must be implemented\./i, /Invalid runner type/i,
-// Process
-/Child Process Exited with Code/i, /Terminating Playwright Process\.\.\./i, /Cleaning up\.\.\./i,
-// TestData
-/Error appending or creating the test data file:/i, /Error\(err\)/i, /Error while deleting the test data file:/i,
-// FeatureFile
-/Error while parsing feature files\. Please fix the above issues before running test cases/i,
 // RPC
-/Error: HTTP /i, /Invalid payload\. It must be a non-null object\./i, /Invalid payload\.arguments\.entityId\./i,
+/Invalid payload\. It must be a non-null object\./i, /Invalid payload\.arguments\.entityId\./i,
 // Search
 /Invalid or missing data in dataTable/i, /JSONPath query/i];

package/build/core/playwright/setup/qc-custom-reporter.js

@@ -44,9 +44,8 @@ class CustomJsonReporter {
   onTestEnd(test, result) {
     var _result$errors, _result$steps;
     const key = `${test.location.file}:${test.location.line}:${test.title}`;
-    const isFailure = !['passed', 'skipped'].includes(result.status);
     let attachments = result.attachments ?? [];
-    if (isFailure) {
+    if ((0, _failureTagClassifier.isFailingResultStatus)(result.status)) {
       const metadata = (0, _failureTagClassifier.classifyFailureDetailsFromResult)({
         status: result.status,
         workerIndex: result.workerIndex,