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

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/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,33 @@
+"use strict";
+
+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 () {
+    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 _casePatterns = require("./casePatterns");
+var _toolPatterns = require("./toolPatterns");

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

@@ -0,0 +1,34 @@
+"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 = [/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
+/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 (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, spec.title);
+    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'
@@ -30,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)),
@@ -52,6 +78,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,413 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var toolPatterns = _interopRequireWildcard(require("../../../../../core/playwright/patterns/toolPatterns"));
+var casePatterns = _interopRequireWildcard(require("../../../../../core/playwright/patterns/casePatterns"));
+var _runtimeLogPath = require("../../../../../core/playwright/helpers/runtimeLogPath");
+var _failureTagClassifier = require("../../../../../core/playwright/helpers/failureTagClassifier");
+var _failureTagConstants = require("../../../../../core/playwright/constants/failureTagConstants");
+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); }
+const TEST_TITLE = 'environment-abort-test';
+let tempDir;
+function writeRuntimeLog(events, {
+  workerIndex = 0,
+  retry = 0,
+  title = TEST_TITLE
+} = {}) {
+  const file = (0, _runtimeLogPath.resolveRuntimeLogFilePath)(tempDir, {
+    workerIndex,
+    retry,
+    title
+  });
+  _fs.default.mkdirSync(_path.default.dirname(file), {
+    recursive: true
+  });
+  _fs.default.writeFileSync(file, `${events.map(e => JSON.stringify(e)).join('\n')}\n`);
+  return file;
+}
+function failingDetail(events, options = {}) {
+  writeRuntimeLog(events, options);
+  return {
+    status: 'unexpected',
+    results: [{
+      status: 'failed',
+      workerIndex: options.workerIndex ?? 0,
+      retry: options.retry ?? 0
+    }]
+  };
+}
+function failingDetailWithStdio({
+  stdout = [],
+  stderr = []
+}) {
+  return {
+    status: 'unexpected',
+    results: [{
+      status: 'failed',
+      attachments: [],
+      stdout,
+      stderr
+    }]
+  };
+}
+beforeEach(() => {
+  tempDir = _fs.default.mkdtempSync(_path.default.join(_os.default.tmpdir(), 'failure-tag-'));
+});
+afterEach(() => {
+  _fs.default.rmSync(tempDir, {
+    recursive: true,
+    force: true
+  });
+});
+describe('classifyFailureTags', () => {
+  test('returns flaky and skips log analysis for flaky outcome', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([{
+      status: 'flaky',
+      results: []
+    }], TEST_TITLE, tempDir);
+    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'
+    }])], TEST_TITLE, tempDir);
+    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'
+    }], {
+      title: 'cert-test'
+    })], 'cert-test', tempDir);
+    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')"
+    }], {
+      title: 'code-test'
+    })], 'code-test', tempDir);
+    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'
+    }], {
+      title: 'xhr-test'
+    })], 'xhr-test', tempDir);
+    expect(tags).toEqual([]);
+  });
+  test('tags case and code when stderr reports DATA_GENERATION_ERROR', () => {
+    const detail = failingDetailWithStdio({
+      stderr: [{
+        text: 'status : DATA_GENERATION_ERROR\n generator: comments'
+      }]
+    });
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
+    expect(tags).toEqual(['CASE', 'CODE']);
+  });
+  test('tags tool for a known tool pattern in base64 stdout', () => {
+    const detail = failingDetailWithStdio({
+      stdout: [{
+        buffer: Buffer.from('Error during login').toString('base64')
+      }]
+    });
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
+    expect(tags).toEqual(['TOOL']);
+  });
+  test('tags case and code when stderr matches a case pattern', () => {
+    const originalCasePatterns = casePatterns.CASE_PATTERNS.slice();
+    try {
+      casePatterns.CASE_PATTERNS.push(/expect\(received\)\.toBe/i);
+      const detail = failingDetailWithStdio({
+        stderr: [{
+          text: 'Error: expect(received).toBe(expected)'
+        }]
+      });
+      const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
+      expect(tags).toEqual(['CASE', 'CODE']);
+    } finally {
+      casePatterns.CASE_PATTERNS.length = 0;
+      casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
+    }
+  });
+  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], TEST_TITLE, tempDir);
+    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], TEST_TITLE, tempDir)).not.toThrow();
+    expect((0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir)).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'
+      }
+    }], {
+      title: 'neutral-test'
+    })], 'neutral-test', tempDir);
+    expect(tags).toEqual([]);
+  });
+});
+describe('classifyFailureDetails', () => {
+  test('records the matching pattern for environment failures', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetails)([failingDetail([{
+      kind: 'requestfailed',
+      url: 'https://app/events/list/commentsubtabevent',
+      failure: 'net::ERR_ABORTED',
+      resourceType: 'document'
+    }])], TEST_TITLE, tempDir);
+    expect(details.tags).toEqual(['ENVIRONMENT']);
+    expect(details.matches).toHaveLength(1);
+    expect(details.matches[0]).toMatchObject({
+      tag: 'ENVIRONMENT',
+      pattern: '^requestfailed document\\b[\\s\\S]*ERR_ABORTED',
+      source: 'runtime-log'
+    });
+    expect(details.matches[0].text).toContain('ERR_ABORTED');
+  });
+  test('records the matching pattern for code failures from events', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetailsFromEvents)([{
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }]);
+    expect(details.tags).toEqual(['CODE']);
+    expect(details.matches[0]).toMatchObject({
+      tag: 'CODE',
+      pattern: 'Cannot read properties of (undefined|null)',
+      source: 'runtime-log'
+    });
+  });
+  test('records flaky outcome without a regex pattern', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetails)([{
+      status: 'flaky',
+      results: []
+    }], TEST_TITLE, tempDir);
+    expect(details.tags).toEqual(['FLAKY']);
+    expect(details.matches[0]).toEqual({
+      tag: 'FLAKY',
+      pattern: null,
+      source: 'retry-outcome',
+      text: null
+    });
+  });
+  test('records tool pattern from stdio', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetails)([failingDetailWithStdio({
+      stderr: [{
+        text: 'Error during login for actor admin'
+      }]
+    })], TEST_TITLE, tempDir);
+    expect(details.tags).toEqual(['TOOL']);
+    expect(details.matches[0]).toMatchObject({
+      tag: 'TOOL',
+      pattern: 'Error during login',
+      source: 'stdio'
+    });
+  });
+  test('records case pattern from stdio and implies code', () => {
+    const originalCasePatterns = casePatterns.CASE_PATTERNS.slice();
+    try {
+      casePatterns.CASE_PATTERNS.push(/expect\(received\)\.toBe/i);
+      const details = (0, _failureTagClassifier.classifyFailureDetails)([failingDetailWithStdio({
+        stderr: [{
+          text: 'Error: expect(received).toBe(expected)'
+        }]
+      })], TEST_TITLE, tempDir);
+      expect(details.tags).toEqual(['CASE', 'CODE']);
+      expect(details.matches).toHaveLength(2);
+      expect(details.matches[0]).toMatchObject({
+        tag: 'CASE',
+        pattern: 'expect\\(received\\)\\.toBe',
+        source: 'stdio'
+      });
+      expect(details.matches[1]).toMatchObject({
+        tag: 'CODE',
+        pattern: null,
+        source: 'case-implied'
+      });
+      expect(details.matches[1].text).toContain('expect(received).toBe(expected)');
+    } finally {
+      casePatterns.CASE_PATTERNS.length = 0;
+      casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
+    }
+  });
+  test('keeps runtime-log code match when case also matches', () => {
+    const originalCasePatterns = casePatterns.CASE_PATTERNS.slice();
+    try {
+      casePatterns.CASE_PATTERNS.push(/expect\(received\)\.toBe/i);
+      writeRuntimeLog([{
+        kind: 'pageerror',
+        name: 'TypeError',
+        message: "Cannot read properties of undefined (reading 'id')"
+      }], {
+        title: 'case-with-runtime-code'
+      });
+      const details = (0, _failureTagClassifier.classifyFailureDetails)([{
+        status: 'unexpected',
+        results: [{
+          status: 'failed',
+          workerIndex: 0,
+          retry: 0,
+          stderr: [{
+            text: 'Error: expect(received).toBe(expected)'
+          }]
+        }]
+      }], 'case-with-runtime-code', tempDir);
+      expect(details.tags).toEqual(['CASE', 'CODE']);
+      expect(details.matches).toHaveLength(2);
+      expect(details.matches.find(match => match.tag === 'CASE')).toMatchObject({
+        source: 'stdio'
+      });
+      expect(details.matches.find(match => match.tag === 'CODE')).toMatchObject({
+        source: 'runtime-log',
+        pattern: 'Cannot read properties of (undefined|null)'
+      });
+    } finally {
+      casePatterns.CASE_PATTERNS.length = 0;
+      casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
+    }
+  });
+  test('implies code from case when no runtime log is present', () => {
+    const originalCasePatterns = casePatterns.CASE_PATTERNS.slice();
+    try {
+      casePatterns.CASE_PATTERNS.push(/Timed out \d+ms waiting for/i);
+      const details = (0, _failureTagClassifier.classifyFailureDetails)([failingDetailWithStdio({
+        stderr: [{
+          text: 'Timed out 5000ms waiting for locator("#save")'
+        }]
+      })], TEST_TITLE, tempDir);
+      expect(details.tags).toEqual(['CASE', 'CODE']);
+      expect(details.matches.find(match => match.tag === 'CODE')).toMatchObject({
+        source: 'case-implied',
+        pattern: null
+      });
+    } finally {
+      casePatterns.CASE_PATTERNS.length = 0;
+      casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
+    }
+  });
+});
+describe('failure tag metadata attachment', () => {
+  test('builds a small JSON attachment when tags are present', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetailsFromEvents)([{
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }]);
+    const attachment = (0, _failureTagClassifier.buildFailureTagMetadataAttachment)(details);
+    expect(attachment).toMatchObject({
+      name: _failureTagConstants.FAILURE_TAG_METADATA_ATTACHMENT,
+      contentType: 'application/json'
+    });
+    expect(JSON.parse(attachment.body.toString('utf8'))).toEqual(details);
+  });
+  test('returns null when no tags are present', () => {
+    expect((0, _failureTagClassifier.buildFailureTagMetadataAttachment)({
+      tags: [],
+      matches: []
+    })).toBeNull();
+  });
+  test('replaces an existing metadata attachment', () => {
+    const first = (0, _failureTagClassifier.buildFailureTagMetadataAttachment)({
+      tags: ['CODE'],
+      matches: [{
+        tag: 'CODE',
+        pattern: 'old',
+        source: 'runtime-log',
+        text: 'old'
+      }]
+    });
+    const second = (0, _failureTagClassifier.buildFailureTagMetadataAttachment)({
+      tags: ['TOOL'],
+      matches: [{
+        tag: 'TOOL',
+        pattern: 'new',
+        source: 'stdio',
+        text: 'new'
+      }]
+    });
+    const merged = (0, _failureTagClassifier.upsertFailureTagMetadataAttachment)([{
+      name: 'screenshot',
+      path: '/tmp/a.png'
+    }, first], JSON.parse(second.body.toString('utf8')));
+    expect(merged).toHaveLength(2);
+    expect(merged[0].name).toBe('screenshot');
+    expect(merged[1].name).toBe(_failureTagConstants.FAILURE_TAG_METADATA_ATTACHMENT);
+    expect(JSON.parse(merged[1].body.toString('utf8')).matches[0].pattern).toBe('new');
+  });
+});
+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']);
+  });
+  test('formats case and code failure tags with suffix', () => {
+    expect((0, _failureTagClassifier.mergeFailureTags)(['@smoke'], ['CASE', 'CODE'])).toEqual(['CASE_failure', 'CODE_failure', '@smoke']);
+  });
+});
+describe('regex safety', () => {
+  test('resets stateful regex for tool pattern checks', () => {
+    const originalToolPatterns = toolPatterns.TOOL_PATTERNS.slice();
+    const originalCasePatterns = casePatterns.CASE_PATTERNS.slice();
+    try {
+      toolPatterns.TOOL_PATTERNS.length = 0;
+      toolPatterns.TOOL_PATTERNS.push(/DATA_GENERATION_ERROR/g);
+      casePatterns.CASE_PATTERNS.length = 0;
+      const detail = failingDetailWithStdio({
+        stderr: [{
+          text: 'status : DATA_GENERATION_ERROR'
+        }]
+      });
+      const first = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
+      const second = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
+      expect(first).toEqual(['TOOL']);
+      expect(second).toEqual(['TOOL']);
+    } finally {
+      toolPatterns.TOOL_PATTERNS.length = 0;
+      toolPatterns.TOOL_PATTERNS.push(...originalToolPatterns);
+      casePatterns.CASE_PATTERNS.length = 0;
+      casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
+    }
+  });
+});