@zohodesk/testinglibrary 0.0.82-n20-experimental → 0.0.83-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]) => {
-        const additionalContext = await browser.newContext();
-        const additionalPage = await additionalContext.newPage();
-        const ctxTestDetails = {
-          page: additionalPage,
+        let context = await browser.newContext();
+        let page = await context.newPage();
+        let ctxTestDetails = {
+          page,
           $tags,
-          context: additionalContext,
+          context,
           ...actorInfo
         };
-        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(additionalContext, testInfo, ctxTestDetails, actorInfo);
+        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(context, testInfo, ctxTestDetails, actorInfo);
         this.actorsObj[role] = {
           role,
           browser,
-          context: additionalContext,
-          page: additionalPage,
+          context,
+          page,
           executionContext: {
             actorInfo
           }
@@ -69,10 +69,7 @@ var _default = exports.default = {
   }, use, testInfo) => {
     const ctxObject = new ActorContext();
     await ctxObject.setup(browser, $tags, testInfo, context, page, executionContext);
-    try {
-      await use(ctxObject);
-    } finally {
-      await ctxObject.cleanup();
-    }
+    await use(ctxObject);
+    await ctxObject.cleanup();
   }
 };

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

@@ -1,28 +1,16 @@
 "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");
 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');
-const MAX_FILENAME_LENGTH = 120;
-function sanitizeForFilename(name) {
-  if (!name) return 'test';
-  const cleaned = name.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, MAX_FILENAME_LENGTH);
-  return cleaned || 'test';
-}
 async function performDefaultContextSteps({
   context
 }) {
@@ -44,28 +32,20 @@ var _default = exports.default = {
     });
     const collector = new _logCollector.LogCollector(browserLogs.limits);
     collector.attachToContext(context);
-    testInfo.runtimeLogs = collector;
     try {
       await use(context);
     } finally {
       collector.detach();
       const failureOnly = browserLogs.mode === 'failure-only';
       const isFailure = testInfo.status && testInfo.status !== testInfo.expectedStatus;
-      const shouldFlush = !failureOnly || isFailure;
-      const summary = collector.toSummary();
-      let filePath = null;
-      if (shouldFlush) {
-        const base = `w${testInfo.workerIndex}-${sanitizeForFilename(testInfo.title)}-${testInfo.retry}`;
-        filePath = collector.flushToFile(LOGS_DIR, base);
+      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
+        });
       }
-      await testInfo.attach('runtime-log', {
-        contentType: 'application/json',
-        body: Buffer.from(JSON.stringify({
-          schemaVersion: 1,
-          summary,
-          file: filePath
-        }))
-      });
     }
   }
 };

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FAILURE_TAG_SUFFIX = exports.FAILURE_TAGS = void 0;
+const FAILURE_TAGS = exports.FAILURE_TAGS = {
+  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").
+const FAILURE_TAG_SUFFIX = exports.FAILURE_TAG_SUFFIX = '_failure';

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

@@ -0,0 +1,18 @@
+"use strict";
+
+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;
+// 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];
+
+// Matched against request/response/requestfailed URLs and console-error source URLs.
+
+const IGNORE_URL_PATTERNS = exports.IGNORE_URL_PATTERNS = [/\.(png|jpe?g|gif|svg|webp|woff2?|ttf|css|map)(\?|$)/i, /google-analytics\.com|googletagmanager\.com|sentry\.io/i, /getHamburgerMenu\.do/i, /_chat\/unreadzmsg\.do/i, /_chat\/chatbarsync\.do/i, /agentAvailabilityConfig/i, /notifyAvailabilityStatus/i, /murphysdk/i, /phonebridge/i, /inproductsdk/i, /zquartz-tracker/i, /zohosearch\/.*gshandler/i, /stratuscdn\.com/i, /zohochat/i];

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

@@ -0,0 +1,166 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.classifyFailureTags = classifyFailureTags;
+exports.mergeFailureTags = mergeFailureTags;
+var _failureTagConstants = require("../constants/failureTagConstants");
+var _patterns = require("../patterns");
+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.
+
+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).
+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);
+  }
+}
+
+// True when any event matches any of the given patterns.
+function matchesAny(events, patterns) {
+  return events.some(event => {
+    const text = eventToText(event);
+    return patterns.some(pattern => {
+      if (pattern.global || pattern.sticky) {
+        pattern.lastIndex = 0;
+      }
+      return pattern.test(text);
+    });
+  });
+}
+
+// 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') {
+      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');
+}
+
+// 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 pickFailingResult(results = []) {
+  const failing = results.filter(result => FAILING_RESULT_STATUSES.has(result.status));
+  if (failing.length === 0) {
+    return null;
+  }
+  return failing[failing.length - 1];
+}
+
+// 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;
+  for (const detail of testDetails) {
+    if (detail.status === FLAKY_OUTCOME) {
+      tags.add(_failureTagConstants.FAILURE_TAGS.FLAKY);
+      continue;
+    }
+    if (detail.status !== UNEXPECTED_OUTCOME) {
+      continue;
+    }
+    const failingResult = pickFailingResult(detail.results);
+    if (!failingResult) {
+      continue;
+    }
+    const matched = classifyResult(failingResult);
+    environment = environment || matched.environment;
+    code = code || matched.code;
+    tool = tool || matched.tool;
+  }
+  if (environment) {
+    tags.add(_failureTagConstants.FAILURE_TAGS.ENVIRONMENT);
+  }
+  if (code) {
+    tags.add(_failureTagConstants.FAILURE_TAGS.CODE);
+  }
+  if (tool) {
+    tags.add(_failureTagConstants.FAILURE_TAGS.TOOL);
+  }
+
+  // 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;
+}
+
+// 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];
+  for (const tag of existingTags) {
+    if (!merged.includes(tag)) {
+      merged.push(tag);
+    }
+  }
+  return merged;
+}

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

@@ -1,22 +1,18 @@
 "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 flushed
-// once per test via writeFileContents.
+// console errors, page errors and crashes. Buffered in-memory and attached
+// once per test via testInfo.attach.
 
 const DEFAULT_CONFIG = {
   maxEvents: 2000,
-  maxBodyBytes: 0,
-  captureHeaders: false,
-  ignoreMessagePatterns: [/n\.enableDarkTheme is not a function/],
-  ignoreUrlPatterns: [/\.(png|jpe?g|gif|svg|webp|woff2?|ttf|css|map)(\?|$)/i, /google-analytics\.com|googletagmanager\.com|sentry\.io/i]
+  ignoreMessagePatterns: _logCollectorConstants.IGNORE_MESSAGE_PATTERNS,
+  ignoreUrlPatterns: _logCollectorConstants.IGNORE_URL_PATTERNS
 };
 class LogCollector {
   constructor(config = {}) {
@@ -25,21 +21,10 @@ class LogCollector {
       ...config
     };
     this.events = [];
-    this.truncated = false;
-    this.counts = {
-      console: 0,
-      consoleError: 0,
-      pageError: 0,
-      request: 0,
-      response: 0,
-      failed: 0,
-      crash: 0
-    };
     this._bound = [];
   }
   _push(evt) {
     if (this.events.length >= this.config.maxEvents) {
-      this.truncated = true;
       this.events.shift();
     }
     this.events.push({
@@ -48,6 +33,9 @@ class LogCollector {
     });
   }
   _shouldIgnore(url) {
+    if (!url) {
+      return false;
+    }
     return this.config.ignoreUrlPatterns.some(re => re.test(url));
   }
   _shouldIgnoreMessage(message) {
@@ -63,18 +51,11 @@ class LogCollector {
   attachToContext(context) {
     context.pages().forEach(p => this._attachPage(p));
     this._bind(context, 'page', p => this._attachPage(p));
-    this._bind(context, 'request', req => {
-      if (this._shouldIgnore(req.url())) {
-        return;
-      }
-      this.counts.request++;
-    });
     this._bind(context, 'response', res => {
       const url = res.url();
       if (this._shouldIgnore(url)) {
         return;
       }
-      this.counts.response++;
       if (res.status() >= 400) {
         this._push({
           kind: 'response',
@@ -87,12 +68,16 @@ class LogCollector {
     });
     this._bind(context, 'requestfailed', req => {
       var _req$failure;
-      this.counts.failed++;
+      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: req.url(),
-        failure: (_req$failure = req.failure()) === null || _req$failure === void 0 ? void 0 : _req$failure.errorText,
+        url,
+        failure,
         resourceType: req.resourceType()
       });
     });
@@ -100,27 +85,25 @@ class LogCollector {
   _attachPage(page) {
     this._bind(page, 'console', msg => {
       const type = msg.type();
-      this.counts.console++;
       if (type !== 'error') {
         return;
       }
       const text = msg.text();
-      if (this._shouldIgnoreMessage(text)) {
+      const location = msg.location();
+      if (this._shouldIgnoreMessage(text) || this._shouldIgnore(location === null || location === void 0 ? void 0 : location.url)) {
         return;
       }
-      this.counts.consoleError++;
       this._push({
         kind: 'console',
         level: type,
         text,
-        location: msg.location()
+        location
       });
     });
     this._bind(page, 'pageerror', err => {
       if (this._shouldIgnoreMessage(err.message)) {
         return;
       }
-      this.counts.pageError++;
       this._push({
         kind: 'pageerror',
         name: err.name,
@@ -129,7 +112,6 @@ class LogCollector {
       });
     });
     this._bind(page, 'crash', () => {
-      this.counts.crash++;
       this._push({
         kind: 'crash',
         url: page.url()
@@ -146,22 +128,11 @@ class LogCollector {
     }
     this._bound.length = 0;
   }
-  toSummary() {
-    return {
-      ...this.counts,
-      total: this.events.length,
-      truncated: this.truncated
-    };
-  }
-  flushToFile(dir, baseName) {
+  toJsonlBody() {
     if (this.events.length === 0) {
       return null;
     }
-    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);
-    this.events.length = 0;
-    return file;
+    return this.events.map(e => JSON.stringify(e)).join('\n') + '\n';
   }
 }
 exports.LogCollector = LogCollector;

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

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readRuntimeLogEventsFromResult = readRuntimeLogEventsFromResult;
+var _logCollectorConstants = require("../constants/logCollectorConstants");
+// Reads runtime-log-events attachments produced by the context fixture.
+// 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) {
+    return [];
+  }
+  const events = [];
+  for (const line of trimmed.split('\n')) {
+    const lineTrimmed = line.trim();
+    if (!lineTrimmed) {
+      continue;
+    }
+    try {
+      events.push(JSON.parse(lineTrimmed));
+    } catch {
+      // skip malformed line
+    }
+  }
+  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)) {
+    return [];
+  }
+  return parseJsonlContent(attachmentBodyToString(eventsAttachment.body));
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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];

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ENVIRONMENT_PATTERNS = void 0;
+// Environment patterns: infra / network / server breakage. Matched against a
+// flattened text form of each runtime-log event (see eventToText).
+const ENVIRONMENT_PATTERNS = exports.ENVIRONMENT_PATTERNS = [
+// Main document navigation was aborted (page never loaded).
+/^requestfailed document\b[\s\S]*ERR_ABORTED/i,
+// Network / DNS / certificate / connection failures.
+/ERR_TUNNEL_CONNECTION_FAILED|ERR_CERT_|ERR_CONNECTION_|ERR_NAME_NOT_RESOLVED|ERR_INTERNET_DISCONNECTED|ERR_TIMED_OUT|ERR_ADDRESS_UNREACHABLE/i,
+// Server-side 5xx responses.
+/^response 5\d\d\b/i, /status of 5\d\d/i];

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CODE_PATTERNS", {
+  enumerable: true,
+  get: function () {
+    return _codePatterns.CODE_PATTERNS;
+  }
+});
+Object.defineProperty(exports, "ENVIRONMENT_PATTERNS", {
+  enumerable: true,
+  get: function () {
+    return _environmentPatterns.ENVIRONMENT_PATTERNS;
+  }
+});
+Object.defineProperty(exports, "TOOL_PATTERNS", {
+  enumerable: true,
+  get: function () {
+    return _toolPatterns.TOOL_PATTERNS;
+  }
+});
+var _environmentPatterns = require("./environmentPatterns");
+var _codePatterns = require("./codePatterns");
+var _toolPatterns = require("./toolPatterns");

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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,
+// 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
+/edition configured\./i, /portal configured in/i, /profile configured in/i,
+// Actor
+/file missing\./i, /Error loading actor configuration from/i, /The actors data is missing\./i, /not found in user pages\./i,
+// Module
+/does not exist\. We have not triggered the execution for this module/i,
+// Auth
+/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,
+// Search
+/Invalid or missing data in dataTable/i, /JSONPath query/i];

package/build/core/playwright/readConfigFile.js

@@ -120,7 +120,7 @@ function combineDefaultConfigWithUserConfig(userConfiguration) {
  * @property {Array} editionOrder: Order in the form of larger editions in the back. Edition with the most privelages should be last
  * @property {testSetupConfig} testSetup: Specify page and context functions that will be called while intilaizing fixtures.
  * @property {boolean} showCaseTimings: When true, the console reporter prints per-case start/end wall-clock times (h:mm:ss AM/PM) and a case-timings.json sidecar is written to reportPath for the HTML report addon. Default: true.
- * @property {Object} browserLogs: Runtime browser log capture. { mode: 'failure-only' | 'always', limits?: { maxEvents, captureHeaders, ignoreUrlPatterns, ignoreMessagePatterns } }. ignoreMessagePatterns is a list of RegExp matched against console-error text and pageerror messages; matching events are skipped. Default: { mode: 'failure-only' }.
+ * @property {Object} browserLogs: Runtime browser log capture. { mode: 'failure-only' | 'always', limits?: { maxEvents, ignoreUrlPatterns, ignoreMessagePatterns } }. ignoreMessagePatterns is a list of RegExp matched against console-error text and pageerror messages; matching events are skipped. Default: { mode: 'failure-only' }.
  */
 
 /**

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

@@ -128,15 +128,6 @@ class JSONSummaryReporter {
       const isFailure = result.status !== 'passed' && result.status !== 'skipped';
       if (isFailure) {
         var _result$error;
-        const runtimeAttachment = (result.attachments || []).find(a => a.name === 'runtime-log' && a.body);
-        let runtime = null;
-        if (runtimeAttachment) {
-          try {
-            runtime = JSON.parse(runtimeAttachment.body.toString('utf8'));
-          } catch {
-            // malformed attachment; skip
-          }
-        }
         this._caseTimings.push({
           title: fullTitle,
           fileName,
@@ -155,13 +146,7 @@ class JSONSummaryReporter {
               title: step.title,
               error: (_step$error = step.error) === null || _step$error === void 0 ? void 0 : _step$error.message
             };
-          }),
-          ...(runtime ? {
-            runtime: {
-              summary: runtime.summary,
-              logFile: runtime.file
-            }
-          } : {})
+          })
         });
       }
     }

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

@@ -10,7 +10,21 @@ var _path = _interopRequireDefault(require("path"));
 var _codeFrame = require("@babel/code-frame");
 var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
 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.
+const applyFailureTags = node => {
+  for (const spec of node.specs ?? []) {
+    const failureTags = (0, _failureTagClassifier.classifyFailureTags)(spec.tests);
+    if (failureTags.length > 0) {
+      spec.tags = (0, _failureTagClassifier.mergeFailureTags)(spec.tags, failureTags);
+    }
+  }
+  for (const child of node.suites ?? []) {
+    applyFailureTags(child);
+  }
+};
 class CustomJsonReporter {
   constructor({
     outputFile = 'test-results.json'
@@ -52,6 +66,7 @@ class CustomJsonReporter {
       const extracted = suite.suites.map(suite => extractMergedSuite(this.report.config.rootDir, suite, this.testResultsById));
       this.report.suites.push(...extracted);
     });
+    this.report.suites.forEach(suite => applyFailureTags(suite));
     const writableStream = _fs.default.createWriteStream(this.outputFile);
     writableStream.write('{\n');
     writableStream.write(`  "config": ${JSON.stringify(this.report.config, null, 2)},\n`);

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

@@ -0,0 +1,167 @@
+"use strict";
+
+var _logCollectorConstants = require("../../../../../core/playwright/constants/logCollectorConstants");
+var toolPatterns = _interopRequireWildcard(require("../../../../../core/playwright/patterns/toolPatterns"));
+var _failureTagClassifier = require("../../../../../core/playwright/helpers/failureTagClassifier");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function failingDetail(events) {
+  const attachments = [];
+  if (events.length > 0) {
+    attachments.push({
+      name: _logCollectorConstants.RUNTIME_LOG_EVENTS_ATTACHMENT,
+      contentType: _logCollectorConstants.RUNTIME_LOG_EVENTS_CONTENT_TYPE,
+      body: Buffer.from(`${events.map(e => JSON.stringify(e)).join('\n')}\n`)
+    });
+  }
+  return {
+    status: 'unexpected',
+    results: [{
+      status: 'failed',
+      attachments
+    }]
+  };
+}
+function failingDetailWithStdio({
+  stdout = [],
+  stderr = []
+}) {
+  return {
+    status: 'unexpected',
+    results: [{
+      status: 'failed',
+      attachments: [],
+      stdout,
+      stderr
+    }]
+  };
+}
+describe('classifyFailureTags', () => {
+  test('returns flaky and skips log analysis for flaky outcome', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([{
+      status: 'flaky',
+      results: []
+    }]);
+    expect(tags).toEqual(['FLAKY']);
+  });
+  test('tags environment when a document abort is present', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([failingDetail([{
+      kind: 'requestfailed',
+      url: 'https://app/events/list/commentsubtabevent',
+      failure: 'net::ERR_ABORTED',
+      resourceType: 'document'
+    }])]);
+    expect(tags).toEqual(['ENVIRONMENT']);
+  });
+  test('tags environment for a network/cert failure', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([failingDetail([{
+      kind: 'requestfailed',
+      url: 'https://js/gshandler.js',
+      failure: 'net::ERR_CERT_COMMON_NAME_INVALID',
+      resourceType: 'script'
+    }])]);
+    expect(tags).toEqual(['ENVIRONMENT']);
+  });
+  test('tags code when an app undefined-property error is present', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([failingDetail([{
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }])]);
+    expect(tags).toEqual(['CODE']);
+  });
+  test('does not tag a non-document (xhr) abort as environment', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([failingDetail([{
+      kind: 'requestfailed',
+      url: 'https://app/api/tickets',
+      failure: 'net::ERR_ABORTED',
+      resourceType: 'xhr'
+    }])]);
+    expect(tags).toEqual([]);
+  });
+  test('tags tool when stderr reports a DATA_GENERATION_ERROR', () => {
+    const detail = failingDetailWithStdio({
+      stderr: [{
+        text: 'status : DATA_GENERATION_ERROR\n generator: comments'
+      }]
+    });
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail]);
+    expect(tags).toEqual(['TOOL']);
+  });
+  test('tags tool for an "Error Type:" line in base64 stdout', () => {
+    const detail = failingDetailWithStdio({
+      stdout: [{
+        buffer: Buffer.from('Error Type: Error').toString('base64')
+      }]
+    });
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail]);
+    expect(tags).toEqual(['TOOL']);
+  });
+  test('does not tag tool for benign stdout/stderr', () => {
+    const detail = failingDetailWithStdio({
+      stdout: [{
+        text: 'Generated 5 records successfully'
+      }],
+      stderr: []
+    });
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail]);
+    expect(tags).toEqual([]);
+  });
+  test('does not throw for malformed stdio chunk entries', () => {
+    const detail = failingDetailWithStdio({
+      stdout: [null, undefined, 42, {
+        text: 'still fine'
+      }],
+      stderr: [false]
+    });
+    expect(() => (0, _failureTagClassifier.classifyFailureTags)([detail])).not.toThrow();
+    expect((0, _failureTagClassifier.classifyFailureTags)([detail])).toEqual([]);
+  });
+  test('leaves untagged when no environment or code pattern is present', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([failingDetail([{
+      kind: 'response',
+      status: 200,
+      method: 'GET',
+      url: 'https://app/ok'
+    }, {
+      kind: 'console',
+      level: 'error',
+      text: 'Some benign log line',
+      location: {
+        url: 'https://app/page'
+      }
+    }])]);
+    expect(tags).toEqual([]);
+  });
+});
+describe('mergeFailureTags', () => {
+  test('places suffixed failure tags first, then existing tags', () => {
+    expect((0, _failureTagClassifier.mergeFailureTags)(['@comments', '@calls'], ['CODE', 'ENVIRONMENT'])).toEqual(['CODE_failure', 'ENVIRONMENT_failure', '@comments', '@calls']);
+  });
+  test('emits the flaky category as FLAKY without a suffix', () => {
+    expect((0, _failureTagClassifier.mergeFailureTags)([], ['FLAKY', 'CODE'])).toEqual(['FLAKY', 'CODE_failure']);
+  });
+  test('does not duplicate an already-present failure tag', () => {
+    expect((0, _failureTagClassifier.mergeFailureTags)(['CODE_failure'], ['CODE'])).toEqual(['CODE_failure']);
+  });
+});
+describe('regex safety', () => {
+  test('resets stateful regex for tool pattern checks', () => {
+    const originalToolPatterns = toolPatterns.TOOL_PATTERNS.slice();
+    try {
+      toolPatterns.TOOL_PATTERNS.length = 0;
+      toolPatterns.TOOL_PATTERNS.push(/DATA_GENERATION_ERROR/g);
+      const detail = failingDetailWithStdio({
+        stderr: [{
+          text: 'status : DATA_GENERATION_ERROR'
+        }]
+      });
+      const first = (0, _failureTagClassifier.classifyFailureTags)([detail]);
+      const second = (0, _failureTagClassifier.classifyFailureTags)([detail]);
+      expect(first).toEqual(['TOOL']);
+      expect(second).toEqual(['TOOL']);
+    } finally {
+      toolPatterns.TOOL_PATTERNS.length = 0;
+      toolPatterns.TOOL_PATTERNS.push(...originalToolPatterns);
+    }
+  });
+});

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

@@ -0,0 +1,125 @@
+"use strict";
+
+var _logCollector = require("../../../../../core/playwright/helpers/logCollector");
+function makeEmitter() {
+  const handlers = {};
+  return {
+    handlers,
+    on(event, handler) {
+      (handlers[event] = handlers[event] || []).push(handler);
+    },
+    removeListener() {},
+    emit(event, arg) {
+      (handlers[event] || []).forEach(handler => handler(arg));
+    }
+  };
+}
+function makeContext() {
+  const page = makeEmitter();
+  const emitter = makeEmitter();
+  return {
+    page,
+    context: {
+      ...emitter,
+      pages: () => [page]
+    }
+  };
+}
+const failedRequest = (url, errorText, resourceType = 'script', method = 'GET') => ({
+  url: () => url,
+  failure: () => ({
+    errorText
+  }),
+  method: () => method,
+  resourceType: () => resourceType
+});
+const response = (url, status, method = 'GET') => ({
+  url: () => url,
+  status: () => status,
+  request: () => ({
+    method: () => method
+  }),
+  fromServiceWorker: () => false
+});
+const consoleMessage = (text, url) => ({
+  type: () => 'error',
+  text: () => text,
+  location: () => ({
+    url
+  })
+});
+describe('LogCollector baseline-noise stripping', () => {
+  let collector;
+  let context;
+  let page;
+  beforeEach(() => {
+    collector = new _logCollector.LogCollector();
+    const ctx = makeContext();
+    context = ctx.context;
+    page = ctx.page;
+    collector.attachToContext(context);
+  });
+  test('drops ORB-blocked request failures (message pattern)', () => {
+    context.emit('requestfailed', failedRequest('https://app/some/script.js', 'net::ERR_BLOCKED_BY_ORB'));
+    expect(collector.events).toHaveLength(0);
+  });
+  test('drops known noisy third-party URLs (url pattern)', () => {
+    context.emit('requestfailed', failedRequest('https://cdn/murphysdk/3.5.0/murphy.min.js', 'net::ERR_ABORTED'));
+    expect(collector.events).toHaveLength(0);
+  });
+  test('drops noisy 4xx responses by URL (e.g. getHamburgerMenu)', () => {
+    context.emit('response', response('https://app/biz/getHamburgerMenu.do?version=stable', 404));
+    expect(collector.events).toHaveLength(0);
+  });
+  test('drops CORS console errors (message pattern)', () => {
+    page.emit('console', consoleMessage("Access to font at 'https://x/f.woff' has been blocked by CORS policy: ...", 'https://app/page'));
+    expect(collector.events).toHaveLength(0);
+  });
+  test('drops baseline pageerrors (Access is denied / enable* not a function)', () => {
+    page.emit('pageerror', {
+      name: 'SecurityError',
+      message: 'Failed to read the localStorage: Access is denied for this document.',
+      stack: ''
+    });
+    page.emit('pageerror', {
+      name: 'TypeError',
+      message: 'n.enableDarkTheme is not a function',
+      stack: ''
+    });
+    expect(collector.events).toHaveLength(0);
+  });
+  test('keeps a real application pageerror', () => {
+    page.emit('pageerror', {
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')",
+      stack: 'TypeError: ...'
+    });
+    expect(collector.events).toHaveLength(1);
+    expect(collector.events[0]).toMatchObject({
+      kind: 'pageerror',
+      name: 'TypeError'
+    });
+  });
+  test('serializes captured events as jsonl', () => {
+    page.emit('pageerror', {
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')",
+      stack: 'TypeError: ...'
+    });
+    const body = collector.toJsonlBody();
+    expect(body).toContain('"kind":"pageerror"');
+    expect(body).toContain("Cannot read properties of undefined (reading 'id')");
+    expect(body === null || body === void 0 ? void 0 : body.endsWith('\n')).toBe(true);
+  });
+  test('returns null from toJsonlBody when no events were captured', () => {
+    expect(collector.toJsonlBody()).toBeNull();
+  });
+  test('keeps a document-navigation abort (real environment signal)', () => {
+    context.emit('requestfailed', failedRequest('https://app/agent/events/list/commentsubtabevent', 'net::ERR_ABORTED', 'document'));
+    expect(collector.events).toHaveLength(1);
+    expect(collector.events[0]).toMatchObject({
+      kind: 'requestfailed',
+      resourceType: 'document'
+    });
+  });
+});

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

@@ -0,0 +1,52 @@
+"use strict";
+
+var _logCollectorConstants = require("../../../../../core/playwright/constants/logCollectorConstants");
+var _runtimeLogReader = require("../../../../../core/playwright/helpers/runtimeLogReader");
+function jsonlBody(events) {
+  return Buffer.from(`${events.map(e => JSON.stringify(e)).join('\n')}\n`);
+}
+describe('readRuntimeLogEventsFromResult', () => {
+  test('reads inline runtime-log-events body', () => {
+    const inlineEvents = [{
+      kind: 'pageerror',
+      message: 'inline boom'
+    }];
+    const result = {
+      attachments: [{
+        name: _logCollectorConstants.RUNTIME_LOG_EVENTS_ATTACHMENT,
+        contentType: _logCollectorConstants.RUNTIME_LOG_EVENTS_CONTENT_TYPE,
+        body: jsonlBody(inlineEvents)
+      }]
+    };
+    expect((0, _runtimeLogReader.readRuntimeLogEventsFromResult)(result)).toEqual(inlineEvents);
+  });
+  test('skips malformed jsonl lines', () => {
+    const raw = [JSON.stringify({
+      kind: 'console',
+      text: 'ok'
+    }), 'not-json', JSON.stringify({
+      kind: 'pageerror',
+      message: 'err'
+    })].join('\n');
+    const result = {
+      attachments: [{
+        name: _logCollectorConstants.RUNTIME_LOG_EVENTS_ATTACHMENT,
+        contentType: _logCollectorConstants.RUNTIME_LOG_EVENTS_CONTENT_TYPE,
+        body: Buffer.from(`${raw}\n`)
+      }]
+    };
+    expect((0, _runtimeLogReader.readRuntimeLogEventsFromResult)(result)).toEqual([{
+      kind: 'console',
+      text: 'ok'
+    }, {
+      kind: 'pageerror',
+      message: 'err'
+    }]);
+  });
+  test('returns an empty array when runtime-log-events is missing', () => {
+    expect((0, _runtimeLogReader.readRuntimeLogEventsFromResult)({
+      attachments: []
+    })).toEqual([]);
+    expect((0, _runtimeLogReader.readRuntimeLogEventsFromResult)(null)).toEqual([]);
+  });
+});

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "0.0.82-n20-experimental",
+  "version": "0.0.83-n20-experimental",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@zohodesk/testinglibrary",
-      "version": "0.0.82-n20-experimental",
+      "version": "0.0.83-n20-experimental",
       "hasInstallScript": true,
       "license": "ISC",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "0.0.82-n20-experimental",
+  "version": "0.0.83-n20-experimental",
   "main": "./build/index.js",
   "scripts": {
     "postinstall": "node bin/postinstall.js",

package/unit_reports/unit-report.html

@@ -274,4 +274,4 @@ header {
   font-size: 1rem;
   padding: 0 0.5rem;
 }
-</style></head><body><main class="jesthtml-content"><header><h1 id="title">Unit Report</h1></header><section id="metadata-container"><div id="timestamp">Started: 2026-07-03 13:32:15</div><div id="summary"><div id="suite-summary"><div class="summary-total">Suites (1)</div><div class="summary-passed ">1 passed</div><div class="summary-failed  summary-empty">0 failed</div><div class="summary-pending  summary-empty">0 pending</div></div><div id="test-summary"><div class="summary-total">Tests (14)</div><div class="summary-passed ">14 passed</div><div class="summary-failed  summary-empty">0 failed</div><div class="summary-pending  summary-empty">0 pending</div></div></div></section><details id="suite-1" class="suite-container" open=""><summary class="suite-info"><div class="suite-path">/Users/muthu-19817/git/testing-framework/src/test/core/playwright/helpers/__tests__/failureTagClassifier.test.js</div><div class="suite-time">0.498s</div></summary><div class="suite-tests"><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">returns flaky and skips log analysis for flaky outcome</div><div class="test-status">passed</div><div class="test-duration">0.002s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags environment when a document abort is present</div><div class="test-status">passed</div><div class="test-duration">0.002s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags environment for a network/cert failure</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags code when an app undefined-property error is present</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">does not tag a non-document (xhr) abort as environment</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags tool when stderr reports a DATA_GENERATION_ERROR</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags tool for an "Error Type:" line in base64 stdout</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">does not tag tool for benign stdout/stderr</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">does not throw for malformed stdio chunk entries</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">leaves untagged when no environment or code pattern is present</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">mergeFailureTags</div><div class="test-title">places suffixed failure tags first, then existing tags</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">mergeFailureTags</div><div class="test-title">emits the flaky category as FLAKY without a suffix</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">mergeFailureTags</div><div class="test-title">does not duplicate an already-present failure tag</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">regex safety</div><div class="test-title">resets stateful regex for tool pattern checks</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div></div></details></main></body></html>
+</style></head><body><main class="jesthtml-content"><header><h1 id="title">Unit Report</h1></header><section id="metadata-container"><div id="timestamp">Started: 2026-07-05 00:43:44</div><div id="summary"><div id="suite-summary"><div class="summary-total">Suites (3)</div><div class="summary-passed ">3 passed</div><div class="summary-failed  summary-empty">0 failed</div><div class="summary-pending  summary-empty">0 pending</div></div><div id="test-summary"><div class="summary-total">Tests (26)</div><div class="summary-passed ">26 passed</div><div class="summary-failed  summary-empty">0 failed</div><div class="summary-pending  summary-empty">0 pending</div></div></div></section><details id="suite-1" class="suite-container" open=""><summary class="suite-info"><div class="suite-path">/Users/muthu-19817/git/testing-framework/src/test/core/playwright/helpers/__tests__/runtimeLogReader.test.js</div><div class="suite-time">0.459s</div></summary><div class="suite-tests"><div class="test-result passed"><div class="test-info"><div class="test-suitename">readRuntimeLogEventsFromResult</div><div class="test-title">reads inline runtime-log-events body</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">readRuntimeLogEventsFromResult</div><div class="test-title">skips malformed jsonl lines</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">readRuntimeLogEventsFromResult</div><div class="test-title">returns an empty array when runtime-log-events is missing</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div></div></details><details id="suite-2" class="suite-container" open=""><summary class="suite-info"><div class="suite-path">/Users/muthu-19817/git/testing-framework/src/test/core/playwright/helpers/__tests__/failureTagClassifier.test.js</div><div class="suite-time">0.11s</div></summary><div class="suite-tests"><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">returns flaky and skips log analysis for flaky outcome</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags environment when a document abort is present</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags environment for a network/cert failure</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags code when an app undefined-property error is present</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">does not tag a non-document (xhr) abort as environment</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags tool when stderr reports a DATA_GENERATION_ERROR</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">tags tool for an "Error Type:" line in base64 stdout</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">does not tag tool for benign stdout/stderr</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">does not throw for malformed stdio chunk entries</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">classifyFailureTags</div><div class="test-title">leaves untagged when no environment or code pattern is present</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">mergeFailureTags</div><div class="test-title">places suffixed failure tags first, then existing tags</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">mergeFailureTags</div><div class="test-title">emits the flaky category as FLAKY without a suffix</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">mergeFailureTags</div><div class="test-title">does not duplicate an already-present failure tag</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">regex safety</div><div class="test-title">resets stateful regex for tool pattern checks</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div></div></details><details id="suite-3" class="suite-container" open=""><summary class="suite-info"><div class="suite-path">/Users/muthu-19817/git/testing-framework/src/test/core/playwright/helpers/__tests__/logCollector.test.js</div><div class="suite-time">0.082s</div></summary><div class="suite-tests"><div class="test-result passed"><div class="test-info"><div class="test-suitename">LogCollector baseline-noise stripping</div><div class="test-title">drops ORB-blocked request failures (message pattern)</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">LogCollector baseline-noise stripping</div><div class="test-title">drops known noisy third-party URLs (url pattern)</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">LogCollector baseline-noise stripping</div><div class="test-title">drops noisy 4xx responses by URL (e.g. getHamburgerMenu)</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">LogCollector baseline-noise stripping</div><div class="test-title">drops CORS console errors (message pattern)</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">LogCollector baseline-noise stripping</div><div class="test-title">drops baseline pageerrors (Access is denied / enable* not a function)</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">LogCollector baseline-noise stripping</div><div class="test-title">keeps a real application pageerror</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">LogCollector baseline-noise stripping</div><div class="test-title">serializes captured events as jsonl</div><div class="test-status">passed</div><div class="test-duration">0.001s</div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">LogCollector baseline-noise stripping</div><div class="test-title">returns null from toJsonlBody when no events were captured</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div><div class="test-result passed"><div class="test-info"><div class="test-suitename">LogCollector baseline-noise stripping</div><div class="test-title">keeps a document-navigation abort (real environment signal)</div><div class="test-status">passed</div><div class="test-duration"> </div></div></div></div></details></main></body></html>