@zohodesk/testinglibrary 0.0.83-n20-experimental → 0.0.84-n20-experimental

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

@@ -1,16 +1,24 @@
 "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 _readConfigFile = require("../readConfigFile");
-var _logCollectorConstants = require("../constants/logCollectorConstants");
 var _logCollector = require("../helpers/logCollector");
+var _failureTagClassifier = require("../helpers/failureTagClassifier");
+var _runtimeLogPath = require("../helpers/runtimeLogPath");
 const {
   testSetup,
+  uatDirectory,
   browserLogs = {}
 } = (0, _readConfigFile.generateConfigFromFile)();
+
+// Keep runtime logs OUTSIDE reportPath (HTML reporter wipes it on onEnd) and
+// outside test-results (Playwright outputDir is cleaned each run).
+const LOGS_DIR = _path.default.join(uatDirectory, 'runtime-logs');
 async function performDefaultContextSteps({
   context
 }) {
@@ -38,13 +46,25 @@ var _default = exports.default = {
       collector.detach();
       const failureOnly = browserLogs.mode === 'failure-only';
       const isFailure = testInfo.status && testInfo.status !== testInfo.expectedStatus;
-      const shouldAttach = !failureOnly || isFailure;
-      const logBody = shouldAttach ? collector.toJsonlBody() : null;
-      if (logBody) {
-        await testInfo.attach(_logCollectorConstants.RUNTIME_LOG_EVENTS_ATTACHMENT, {
-          body: logBody,
-          contentType: _logCollectorConstants.RUNTIME_LOG_EVENTS_CONTENT_TYPE
+      const shouldFlush = !failureOnly || isFailure;
+      if (shouldFlush) {
+        const base = (0, _runtimeLogPath.resolveRuntimeLogBaseName)({
+          workerIndex: testInfo.workerIndex,
+          retry: testInfo.retry,
+          title: testInfo.title,
+          titlePath: testInfo.titlePath
         });
+        collector.flushToFile(LOGS_DIR, base);
+      }
+      if (isFailure) {
+        const metadata = (0, _failureTagClassifier.classifyFailureDetailsFromEvents)(collector.events);
+        const attachment = (0, _failureTagClassifier.buildFailureTagMetadataAttachment)(metadata);
+        if (attachment) {
+          await testInfo.attach(attachment.name, {
+            contentType: attachment.contentType,
+            body: attachment.body
+          });
+        }
       }
     }
   }

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

@@ -3,8 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.FAILURE_TAG_SUFFIX = exports.FAILURE_TAGS = void 0;
+exports.FAILURE_TAG_SUFFIX = exports.FAILURE_TAG_METADATA_SCHEMA_VERSION = exports.FAILURE_TAG_METADATA_ATTACHMENT = exports.FAILURE_TAGS = void 0;
 const FAILURE_TAGS = exports.FAILURE_TAGS = {
+  CASE: 'CASE',
   CODE: 'CODE',
   ENVIRONMENT: 'ENVIRONMENT',
   FLAKY: 'FLAKY',
@@ -13,4 +14,6 @@ const FAILURE_TAGS = exports.FAILURE_TAGS = {
 
 // 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").
-const FAILURE_TAG_SUFFIX = exports.FAILURE_TAG_SUFFIX = '_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;

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

@@ -3,12 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.RUNTIME_LOG_EVENTS_CONTENT_TYPE = exports.RUNTIME_LOG_EVENTS_ATTACHMENT = exports.IGNORE_URL_PATTERNS = exports.IGNORE_MESSAGE_PATTERNS = void 0;
+exports.IGNORE_URL_PATTERNS = exports.IGNORE_MESSAGE_PATTERNS = void 0;
 // Ignore patterns for the runtime-log LogCollector. Matching events are dropped here so it is never recorded.
 
-const RUNTIME_LOG_EVENTS_ATTACHMENT = exports.RUNTIME_LOG_EVENTS_ATTACHMENT = 'runtime-log-events';
-const RUNTIME_LOG_EVENTS_CONTENT_TYPE = exports.RUNTIME_LOG_EVENTS_CONTENT_TYPE = 'text/plain';
-
 // Matched against console-error text, pageerror messages and requestfailed
 
 const IGNORE_MESSAGE_PATTERNS = exports.IGNORE_MESSAGE_PATTERNS = [/Access is denied for this document/i, /enableDarkTheme is not a function/i, /enableZohoSearchAskZia is not a function/i, /enableSMSBridge is not a function/i, /Unexpected token '<'[\s\S]*not valid JSON/i, /blocked by CORS policy/i, /ERR_BLOCKED_BY_ORB/i];

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

@@ -1,25 +1,73 @@
 "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.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");
 // 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`
-// (any may apply). `FLAKY` comes from the Playwright retry outcome, not the log.
+// 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.
 
 const FAILING_RESULT_STATUSES = new Set(['failed', 'timedOut', 'interrupted']);
-// Playwright TestCase.outcome() value for a failing (non-flaky) test.
 const UNEXPECTED_OUTCOME = 'unexpected';
 const FLAKY_OUTCOME = 'flaky';
-
-// Flattens a runtime-log event into a single string for pattern matching. Field
-// order is fixed so patterns can rely on it (e.g. resourceType before failure).
+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
+}];
+const STDIO_RULES = [{
+  tag: _failureTagConstants.FAILURE_TAGS.TOOL,
+  patterns: _patterns.TOOL_PATTERNS
+}, {
+  tag: _failureTagConstants.FAILURE_TAGS.CASE,
+  patterns: _patterns.CASE_PATTERNS,
+  impliesCode: true
+}];
+function resolveLogsDir(logsDir) {
+  if (logsDir) {
+    return logsDir;
+  }
+  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) {
@@ -35,23 +83,22 @@ function eventToText(event) {
       return JSON.stringify(event);
   }
 }
-
-// True when any event matches any of the given patterns.
-function matchesAny(events, patterns) {
-  return events.some(event => {
+function findEventMatch(events, patterns, tag, source) {
+  for (const event of events) {
     const text = eventToText(event);
-    return patterns.some(pattern => {
-      if (pattern.global || pattern.sticky) {
-        pattern.lastIndex = 0;
+    for (const pattern of patterns) {
+      if (testPattern(pattern, text)) {
+        return {
+          tag,
+          pattern: patternLabel(pattern),
+          source,
+          text: truncateText(text)
+        };
       }
-      return pattern.test(text);
-    });
-  });
+    }
+  }
+  return null;
 }
-
-// Flattens a result's stdout/stderr chunks into a single string. Each chunk is
-// either a plain string, { text } or { buffer } (base64) as produced by the
-// reporter's stdioEntry.
 function stdioToText(entries = []) {
   return entries.map(entry => {
     if (typeof entry === 'string') {
@@ -73,41 +120,85 @@ function stdioToText(entries = []) {
     return '';
   }).join('\n');
 }
-
-// Reads a failing result and reports which categories are present. environment
-// and code come from the browser runtime log; tool comes from stdout/stderr.
-function classifyResult(result) {
-  const events = (0, _runtimeLogReader.readRuntimeLogEventsFromResult)(result);
-  const stdio = `${stdioToText(result.stdout)}\n${stdioToText(result.stderr)}`;
-  return {
-    environment: matchesAny(events, _patterns.ENVIRONMENT_PATTERNS),
-    code: matchesAny(events, _patterns.CODE_PATTERNS),
-    tool: _patterns.TOOL_PATTERNS.some(pattern => {
-      if (pattern.global || pattern.sticky) {
-        pattern.lastIndex = 0;
-      }
-      return pattern.test(stdio);
-    })
-  };
+function buildStdioText(result = {}) {
+  return `${stdioToText(result.stdout)}\n${stdioToText(result.stderr)}`;
 }
-function pickFailingResult(results = []) {
-  const failing = results.filter(result => FAILING_RESULT_STATUSES.has(result.status));
-  if (failing.length === 0) {
-    return null;
+function findStdioMatch(stdio, patterns, tag) {
+  for (const pattern of patterns) {
+    if (testPattern(pattern, stdio)) {
+      return {
+        tag,
+        pattern: patternLabel(pattern),
+        source: 'stdio',
+        text: truncateText(stdio)
+      };
+    }
   }
-  return failing[failing.length - 1];
+  return null;
 }
-
-// Returns the ordered list of bare failure tags for a spec's test details.
-// `testDetails` is the array of { status, results } objects under a spec.
-function classifyFailureTags(testDetails = []) {
-  const tags = new Set();
-  let environment = false;
-  let code = false;
-  let tool = false;
+function collectRuntimeLogMatches(events, matches) {
+  for (const rule of RUNTIME_LOG_RULES) {
+    const match = findEventMatch(events, rule.patterns, rule.tag, RUNTIME_LOG_SOURCE);
+    if (match) {
+      matches.push(match);
+    }
+  }
+}
+function collectStdioMatches(stdio, matches) {
+  for (const rule of STDIO_RULES) {
+    const match = findStdioMatch(stdio, rule.patterns, rule.tag);
+    if (!match) {
+      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;
+  }
+  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);
+}
+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 buildFailureTagMetadata(matches = []) {
+  const tags = TAG_ORDER.filter(tag => matches.some(match => match.tag === tag));
+  return {
+    schemaVersion: _failureTagConstants.FAILURE_TAG_METADATA_SCHEMA_VERSION,
+    tags,
+    matches
+  };
+}
+function classifyFailureDetails(testDetails = [], testTitle = 'test', logsDir) {
+  const resolvedLogsDir = resolveLogsDir(logsDir);
+  const matches = [];
   for (const detail of testDetails) {
     if (detail.status === FLAKY_OUTCOME) {
-      tags.add(_failureTagConstants.FAILURE_TAGS.FLAKY);
+      matches.push({
+        tag: _failureTagConstants.FAILURE_TAGS.FLAKY,
+        pattern: null,
+        source: 'retry-outcome',
+        text: null
+      });
       continue;
     }
     if (detail.status !== UNEXPECTED_OUTCOME) {
@@ -117,43 +208,33 @@ function classifyFailureTags(testDetails = []) {
     if (!failingResult) {
       continue;
     }
-    const matched = classifyResult(failingResult);
-    environment = environment || matched.environment;
-    code = code || matched.code;
-    tool = tool || matched.tool;
+    const resultDetails = classifyFailureDetailsFromResult(failingResult, testTitle, resolvedLogsDir);
+    matches.push(...resultDetails.matches);
   }
-  if (environment) {
-    tags.add(_failureTagConstants.FAILURE_TAGS.ENVIRONMENT);
-  }
-  if (code) {
-    tags.add(_failureTagConstants.FAILURE_TAGS.CODE);
+  const uniqueMatches = [];
+  for (const match of matches) {
+    if (!uniqueMatches.some(existing => existing.tag === match.tag)) {
+      uniqueMatches.push(match);
+    }
   }
-  if (tool) {
-    tags.add(_failureTagConstants.FAILURE_TAGS.TOOL);
+  return buildFailureTagMetadata(uniqueMatches);
+}
+function classifyFailureTags(testDetails = [], testTitle = 'test', logsDir) {
+  return classifyFailureDetails(testDetails, testTitle, logsDir).tags;
+}
+function pickFailingResult(results = []) {
+  const failing = results.filter(result => FAILING_RESULT_STATUSES.has(result.status));
+  if (failing.length === 0) {
+    return null;
   }
-
-  // Stable order: flaky, environment, code, tool.
-  const ordered = [];
-  if (tags.has(_failureTagConstants.FAILURE_TAGS.FLAKY)) ordered.push(_failureTagConstants.FAILURE_TAGS.FLAKY);
-  if (tags.has(_failureTagConstants.FAILURE_TAGS.ENVIRONMENT)) ordered.push(_failureTagConstants.FAILURE_TAGS.ENVIRONMENT);
-  if (tags.has(_failureTagConstants.FAILURE_TAGS.CODE)) ordered.push(_failureTagConstants.FAILURE_TAGS.CODE);
-  if (tags.has(_failureTagConstants.FAILURE_TAGS.TOOL)) ordered.push(_failureTagConstants.FAILURE_TAGS.TOOL);
-  return ordered;
+  return failing[failing.length - 1];
 }
-
-// Formats a bare category into its emitted tag form (e.g. "CODE" -> "CODE_failure").
-// The flaky category is a passed-on-retry outcome, not a failure, so it is emitted
-// as "FLAKY" without a suffix.
 function formatFailureTag(tag) {
   if (tag === _failureTagConstants.FAILURE_TAGS.FLAKY) {
     return tag;
   }
   return `${tag}${_failureTagConstants.FAILURE_TAG_SUFFIX}`;
 }
-
-// Merges derived failure tags into an existing tags array. Failure tags are
-// placed first, followed by the existing tags, without removing or duplicating
-// entries.
 function mergeFailureTags(existingTags = [], failureTags = []) {
   const formatted = failureTags.map(formatFailureTag);
   const merged = [...formatted];
@@ -163,4 +244,23 @@ function mergeFailureTags(existingTags = [], failureTags = []) {
     }
   }
   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/logCollector.js

@@ -1,13 +1,16 @@
 "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 _logCollectorConstants = require("../constants/logCollectorConstants");
 // Per-context Playwright runtime event collector — network failures,
-// console errors, page errors and crashes. Buffered in-memory and attached
-// once per test via testInfo.attach.
+// console errors, page errors and crashes. Buffered in-memory and flushed
+// to the project runtime-logs folder per test.
 
 const DEFAULT_CONFIG = {
   maxEvents: 2000,
@@ -128,11 +131,14 @@ class LogCollector {
     }
     this._bound.length = 0;
   }
-  toJsonlBody() {
+  flushToFile(dir, baseName) {
     if (this.events.length === 0) {
       return null;
     }
-    return this.events.map(e => JSON.stringify(e)).join('\n') + '\n';
+    const file = _path.default.join(dir, `${baseName}.jsonl`);
+    const body = this.events.map(e => JSON.stringify(e)).join('\n') + '\n';
+    (0, _fileUtils.writeFileContents)(file, body);
+    return file;
   }
 }
 exports.LogCollector = LogCollector;

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

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveRuntimeLogBaseName = resolveRuntimeLogBaseName;
+exports.resolveRuntimeLogFilePath = resolveRuntimeLogFilePath;
+exports.sanitizeForFilename = sanitizeForFilename;
+var _path = _interopRequireDefault(require("path"));
+const MAX_FILENAME_LENGTH = 200;
+const EXAMPLE_TITLE = /^Example\s*#\d+$/i;
+const SPEC_FILE = /\.(js|ts)$/;
+function sanitizeForFilename(name) {
+  if (!name) return 'test';
+  const cleaned = name.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+  return cleaned || 'test';
+}
+
+// playwright-bdd nests Example rows under test.describe(scenario.name).
+function extractOutlineScenarioName(titlePath = []) {
+  const segments = titlePath.filter(Boolean);
+  if (segments.length < 2 || !EXAMPLE_TITLE.test(segments[segments.length - 1])) {
+    return null;
+  }
+  for (let i = segments.length - 2; i >= 0; i--) {
+    const segment = segments[i];
+    if (segment && !SPEC_FILE.test(segment)) {
+      return segment;
+    }
+  }
+  return null;
+}
+function resolveRuntimeLogBaseName({
+  workerIndex = 0,
+  retry = 0,
+  title = 'test',
+  titlePath = []
+}) {
+  const scenarioName = extractOutlineScenarioName(titlePath);
+  const label = scenarioName ? `${scenarioName} ${title}` : title;
+  const base = `w${workerIndex}-${sanitizeForFilename(label)}-${retry}`;
+  if (base.length <= MAX_FILENAME_LENGTH) {
+    return base;
+  }
+  return base.slice(0, MAX_FILENAME_LENGTH).replace(/-$/, '');
+}
+function resolveRuntimeLogFilePath(logsDir, {
+  workerIndex,
+  retry,
+  title,
+  titlePath = []
+}) {
+  const base = resolveRuntimeLogBaseName({
+    workerIndex,
+    retry,
+    title,
+    titlePath
+  });
+  return _path.default.join(logsDir, `${base}.jsonl`);
+}

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

@@ -1,22 +1,17 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.readRuntimeLogEventsFromResult = readRuntimeLogEventsFromResult;
-var _logCollectorConstants = require("../constants/logCollectorConstants");
-// Reads runtime-log-events attachments produced by the context fixture.
+exports.readRuntimeLogEvents = readRuntimeLogEvents;
+exports.readRuntimeLogEventsForResult = readRuntimeLogEventsForResult;
+var _fs = _interopRequireDefault(require("fs"));
+var _fileUtils = require("../../../utils/fileUtils");
+var _runtimeLogPath = require("./runtimeLogPath");
+// Reads per-test runtime browser logs from the project runtime-logs folder.
 // Used by the failure-tag classifier to correlate browser events with a test failure.
 
-function attachmentBodyToString(body) {
-  if (!body) {
-    return '';
-  }
-  if (Buffer.isBuffer(body)) {
-    return body.toString('utf8');
-  }
-  return String(body);
-}
 function parseJsonlContent(raw) {
   const trimmed = raw.trim();
   if (!trimmed) {
@@ -36,10 +31,24 @@ function parseJsonlContent(raw) {
   }
   return events;
 }
-function readRuntimeLogEventsFromResult(result) {
-  const eventsAttachment = ((result === null || result === void 0 ? void 0 : result.attachments) || []).find(item => item.name === _logCollectorConstants.RUNTIME_LOG_EVENTS_ATTACHMENT);
-  if (!(eventsAttachment !== null && eventsAttachment !== void 0 && eventsAttachment.body)) {
+function readRuntimeLogEvents(filePath) {
+  if (!filePath || !_fs.default.existsSync(filePath)) {
+    return [];
+  }
+  const rawContent = (0, _fileUtils.readFileContents)(filePath);
+  if (typeof rawContent !== 'string') {
+    return [];
+  }
+  return parseJsonlContent(rawContent);
+}
+function readRuntimeLogEventsForResult(result, testTitle, logsDir) {
+  if (!logsDir) {
     return [];
   }
-  return parseJsonlContent(attachmentBodyToString(eventsAttachment.body));
+  const filePath = (0, _runtimeLogPath.resolveRuntimeLogFilePath)(logsDir, {
+    workerIndex: (result === null || result === void 0 ? void 0 : result.workerIndex) ?? 0,
+    retry: (result === null || result === void 0 ? void 0 : result.retry) ?? 0,
+    title: testTitle
+  });
+  return readRuntimeLogEvents(filePath);
 }

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

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CASE_PATTERNS = void 0;
+// Case patterns: test-case / assertion failures from Playwright output.
+// Matched against the failing result's stdout + stderr.
+const CASE_PATTERNS = exports.CASE_PATTERNS = [
+// Generator
+/GeneratorError: Generator/i, /DataGeneratorConfigurationError: Data Generator configuration is missing for the profile/i, /HTTP error! status:/i, /status\s*:\s*DATA_GENERATION_ERROR/i];

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

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "CASE_PATTERNS", {
+  enumerable: true,
+  get: function () {
+    return _casePatterns.CASE_PATTERNS;
+  }
+});
 Object.defineProperty(exports, "CODE_PATTERNS", {
   enumerable: true,
   get: function () {
@@ -23,4 +29,5 @@ Object.defineProperty(exports, "TOOL_PATTERNS", {
 });
 var _environmentPatterns = require("./environmentPatterns");
 var _codePatterns = require("./codePatterns");
+var _casePatterns = require("./casePatterns");
 var _toolPatterns = require("./toolPatterns");

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

@@ -7,9 +7,7 @@ exports.TOOL_PATTERNS = void 0;
 // Tool patterns: failures originating from the test tooling / data-generation
 // layer (not the app under test). Matched against the failing result's
 // stdout + stderr text. Add new patterns here to recognise more tool errors.
-const TOOL_PATTERNS = exports.TOOL_PATTERNS = [/status\s*:\s*DATA_GENERATION_ERROR/i, /Error Type\s*:\s*Error/i, /Error during login/i,
-// Generator
-/GeneratorError: Generator/i, /DataGeneratorConfigurationError: Data Generator configuration is missing for the profile/i, /HTTP error! status:/i,
+const TOOL_PATTERNS = exports.TOOL_PATTERNS = [/Error during login/i, /fetch failed/i,
 // Configuration
 /Config File Not Exists\. Please provide a/i, /Exception while getting the uat file from the application/i, /There is no beta feature configured with the name/i, /No config mapping found for stage:/i,
 // Edition

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

@@ -13,10 +13,10 @@ var _ConfigurationHelper = require("../configuration/ConfigurationHelper");
 var _failureTagClassifier = require("../helpers/failureTagClassifier");
 const stage = (0, _ConfigurationHelper.getRunStage)();
 
-// Walks the built suite tree and appends derived failure tags (CODE_failure, ENVIRONMENT_failure) into each spec's tags array.
+// Walks the built suite tree and appends derived failure tags (CASE_failure, CODE_failure, ENVIRONMENT_failure) into each spec's tags array.
 const applyFailureTags = node => {
   for (const spec of node.specs ?? []) {
-    const failureTags = (0, _failureTagClassifier.classifyFailureTags)(spec.tests);
+    const failureTags = (0, _failureTagClassifier.classifyFailureTags)(spec.tests, spec.title);
     if (failureTags.length > 0) {
       spec.tags = (0, _failureTagClassifier.mergeFailureTags)(spec.tags, failureTags);
     }
@@ -44,9 +44,21 @@ 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) {
+      const metadata = (0, _failureTagClassifier.classifyFailureDetailsFromResult)({
+        status: result.status,
+        workerIndex: result.workerIndex,
+        retry: result.retry,
+        stdout: result.stdout.map(out => stdioEntry(out)),
+        stderr: result.stderr.map(err => stdioEntry(err))
+      }, test.title);
+      attachments = (0, _failureTagClassifier.upsertFailureTagMetadataAttachment)(attachments, metadata);
+    }
     const testResult = {
       status: result.status,
-      attachments: result.attachments,
+      attachments,
       startTime: result.startTime,
       retry: result.retry,
       stderr: result.stderr.map(err => stdioEntry(err)),