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

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

@@ -0,0 +1,604 @@
+"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 codePatterns = _interopRequireWildcard(require("../../../../../core/playwright/patterns/codePatterns"));
+var _readConfigFile = require("../../../../../core/playwright/readConfigFile");
+var _runtimeLogPath = require("../../../../../core/playwright/helpers/runtimeLogPath");
+var _failureTagClassifier = require("../../../../../core/playwright/helpers/failureTagClassifier");
+var _runtimeLogAnnotator = require("../../../../../core/playwright/helpers/runtimeLogAnnotator");
+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); }
+jest.mock('../../../../../core/playwright/readConfigFile', () => ({
+  generateConfigFromFile: jest.fn()
+}));
+const TEST_TITLE = 'environment-abort-test';
+let tempDir;
+function runtimeLogsDir() {
+  return _path.default.join(tempDir, 'runtime-logs');
+}
+function writeRuntimeLog(events, {
+  workerIndex = 0,
+  retry = 0,
+  title = TEST_TITLE
+} = {}) {
+  const file = (0, _runtimeLogPath.resolveRuntimeLogFilePath)(runtimeLogsDir(), {
+    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-'));
+  _readConfigFile.generateConfigFromFile.mockReturnValue({
+    reportPath: tempDir
+  });
+});
+afterEach(() => {
+  _fs.default.rmSync(tempDir, {
+    recursive: true,
+    force: true
+  });
+});
+describe('classifyFailureTags', () => {
+  test('leaves retry-passed (flaky) outcomes untagged', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([{
+      status: 'flaky',
+      results: []
+    }], TEST_TITLE);
+    expect(tags).toEqual([]);
+  });
+  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);
+    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');
+    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');
+    expect(tags).toEqual(['CODE']);
+  });
+  test('defaults to code (not environment) for a non-document xhr abort', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([failingDetail([{
+      kind: 'requestfailed',
+      url: 'https://app/api/tickets',
+      failure: 'net::ERR_ABORTED',
+      resourceType: 'xhr'
+    }], {
+      title: 'xhr-test'
+    })], 'xhr-test');
+    expect(tags).toEqual(['CODE']);
+  });
+  test('tags case 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);
+    expect(tags).toEqual(['CASE']);
+  });
+  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);
+    expect(tags).toEqual(['TOOL']);
+  });
+  test('tags case 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);
+      expect(tags).toEqual(['CASE']);
+    } finally {
+      casePatterns.CASE_PATTERNS.length = 0;
+      casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
+    }
+  });
+  test('emits only the highest-priority tag (CODE) when CODE and ENVIRONMENT both match', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([failingDetail([{
+      kind: 'requestfailed',
+      url: 'https://app/events/list/commentsubtabevent',
+      failure: 'net::ERR_ABORTED',
+      resourceType: 'document'
+    }, {
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }], {
+      title: 'code-over-env-test'
+    })], 'code-over-env-test');
+    expect(tags).toEqual(['CODE']);
+  });
+  test('defaults to code (not tool) for benign stdout/stderr', () => {
+    const detail = failingDetailWithStdio({
+      stdout: [{
+        text: 'Generated 5 records successfully'
+      }],
+      stderr: []
+    });
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE);
+    expect(tags).toEqual(['CODE']);
+  });
+  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)).not.toThrow();
+    expect((0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE)).toEqual(['CODE']);
+  });
+  test('defaults to code when a failure matches no pattern', () => {
+    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');
+    expect(tags).toEqual(['CODE']);
+  });
+  test('leaves a passing spec untagged (no default code)', () => {
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([{
+      status: 'expected',
+      results: [{
+        status: 'passed',
+        workerIndex: 0,
+        retry: 0
+      }]
+    }], 'passing-test');
+    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);
+    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('defaults to code with no matches when events carry no recognised pattern', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetailsFromEvents)([]);
+    expect(details.tags).toEqual(['CODE']);
+    expect(details.matches).toEqual([]);
+  });
+  test('tags tool when stdio text has Data Generator Service Error: status: 404', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetailsFromEvents)([], 'Error Message: Data Generator Service Error: status: 404, body: ');
+    expect(details.tags).toEqual(['TOOL']);
+    expect(details.matches[0]).toMatchObject({
+      tag: 'TOOL',
+      pattern: 'Data Generator Service Error: status: 404',
+      source: 'stdio'
+    });
+  });
+  test('records tool pattern from stdio', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetails)([failingDetailWithStdio({
+      stderr: [{
+        text: 'Error during login for actor admin'
+      }]
+    })], TEST_TITLE);
+    expect(details.tags).toEqual(['TOOL']);
+    expect(details.matches[0]).toMatchObject({
+      tag: 'TOOL',
+      pattern: 'Error during login',
+      source: 'stdio'
+    });
+  });
+  test('records case pattern from stdio without implying 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);
+      expect(details.tags).toEqual(['CASE']);
+      expect(details.matches).toHaveLength(1);
+      expect(details.matches[0]).toMatchObject({
+        tag: 'CASE',
+        pattern: 'expect\\(received\\)\\.toBe',
+        source: 'stdio'
+      });
+    } finally {
+      casePatterns.CASE_PATTERNS.length = 0;
+      casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
+    }
+  });
+  test('resolves to CASE when a stdio case match outranks a runtime-log code match', () => {
+    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');
+
+      // CASE outranks CODE, so only CASE surfaces as the tag and as matches.
+      expect(details.tags).toEqual(['CASE']);
+      expect(details.matches).toHaveLength(1);
+      expect(details.matches.find(match => match.tag === 'CODE')).toBeUndefined();
+      expect(details.matches[0]).toMatchObject({
+        tag: 'CASE',
+        source: 'stdio',
+        pattern: 'expect\\(received\\)\\.toBe'
+      });
+    } finally {
+      casePatterns.CASE_PATTERNS.length = 0;
+      casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
+    }
+  });
+  test('keeps case as the tag and does not add code 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);
+      expect(details.tags).toEqual(['CASE']);
+      expect(details.matches.find(match => match.tag === 'CODE')).toBeUndefined();
+    } finally {
+      casePatterns.CASE_PATTERNS.length = 0;
+      casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
+    }
+  });
+  test('records every CODE pattern hit from the runtime log', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetailsFromEvents)([{
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }, {
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: 'foo is not a function'
+    }, {
+      kind: 'console',
+      level: 'error',
+      text: 'bar is not defined',
+      location: {
+        url: 'https://app/page'
+      }
+    }]);
+    expect(details.tags).toEqual(['CODE']);
+    expect(details.matches.filter(match => match.tag === 'CODE')).toHaveLength(3);
+    expect(details.matches.map(match => match.pattern)).toEqual(expect.arrayContaining(['Cannot read properties of (undefined|null)', '\\bis not a function\\b', '\\bis not defined\\b']));
+  });
+  test('keeps only winning CODE matches when CODE and ENVIRONMENT both match', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetails)([failingDetail([{
+      kind: 'requestfailed',
+      url: 'https://app/events/list/commentsubtabevent',
+      failure: 'net::ERR_ABORTED',
+      resourceType: 'document'
+    }, {
+      kind: 'requestfailed',
+      url: 'https://cdn/app.js',
+      failure: 'net::ERR_CONNECTION_REFUSED',
+      resourceType: 'script'
+    }, {
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }, {
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: 'handler is not a function'
+    }], {
+      title: 'multi-code-env-test'
+    })], 'multi-code-env-test');
+    expect(details.tags).toEqual(['CODE']);
+    expect(details.matches).toHaveLength(2);
+    expect(details.matches.every(match => match.tag === 'CODE')).toBe(true);
+    expect(details.matches.find(match => match.tag === 'ENVIRONMENT')).toBeUndefined();
+  });
+  test('dedupes identical winning-category matches', () => {
+    const details = (0, _failureTagClassifier.classifyFailureDetailsFromEvents)([{
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }, {
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }, {
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }, {
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: 'a is not a function'
+    }, {
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: 'e.apply is not a function'
+    }, {
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: 'a is not a function'
+    }]);
+    expect(details.tags).toEqual(['CODE']);
+    expect(details.matches).toHaveLength(3);
+    expect(details.matches.map(match => match.text)).toEqual(["pageerror TypeError Cannot read properties of undefined (reading 'id')", 'pageerror TypeError a is not a function', 'pageerror TypeError e.apply is not a function']);
+  });
+  test('dedupes annotated dual-match JSONL lines before classifying from disk', () => {
+    writeRuntimeLog([{
+      pattern: 'CODE',
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }, {
+      pattern: 'ENVIRONMENT',
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }], {
+      title: 'annotated-dual-test'
+    });
+    const details = (0, _failureTagClassifier.classifyFailureDetails)([{
+      status: 'unexpected',
+      results: [{
+        status: 'failed',
+        workerIndex: 0,
+        retry: 0
+      }]
+    }], 'annotated-dual-test');
+    expect(details.tags).toEqual(['CODE']);
+    expect(details.matches.filter(match => match.tag === 'CODE')).toHaveLength(1);
+  });
+});
+describe('annotateRuntimeLogEvents', () => {
+  test('adds pattern CODE on matching events and leaves unmatched events unchanged', () => {
+    const lines = (0, _runtimeLogAnnotator.annotateRuntimeLogEvents)([{
+      ts: 1,
+      kind: 'pageerror',
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')"
+    }, {
+      ts: 2,
+      kind: 'console',
+      level: 'error',
+      text: 'Some benign log line',
+      location: {
+        url: 'https://app/page'
+      }
+    }]);
+    expect(lines).toHaveLength(2);
+    expect(lines[0]).toMatchObject({
+      pattern: 'CODE',
+      ts: 1,
+      kind: 'pageerror'
+    });
+    expect(lines[1]).toEqual({
+      ts: 2,
+      kind: 'console',
+      level: 'error',
+      text: 'Some benign log line',
+      location: {
+        url: 'https://app/page'
+      }
+    });
+    expect(lines[1].pattern).toBeUndefined();
+  });
+  test('emits one line per matched category when an event hits CODE and ENVIRONMENT', () => {
+    const originalCode = codePatterns.CODE_PATTERNS.slice();
+    try {
+      // Force a dual match on one environment event by also treating ERR_ABORTED as CODE.
+      codePatterns.CODE_PATTERNS.push(/ERR_ABORTED/i);
+      const event = {
+        ts: 1783961014561,
+        kind: 'requestfailed',
+        url: 'https://app/events/list/commentsubtabevent',
+        failure: 'net::ERR_ABORTED',
+        resourceType: 'document',
+        method: 'GET'
+      };
+      const lines = (0, _runtimeLogAnnotator.annotateRuntimeLogEvents)([event]);
+      expect(lines).toHaveLength(2);
+      expect(lines.map(line => line.pattern).sort()).toEqual(['CODE', 'ENVIRONMENT']);
+      expect(lines[0].ts).toBe(1783961014561);
+      expect(lines[1].ts).toBe(1783961014561);
+    } finally {
+      codePatterns.CODE_PATTERNS.length = 0;
+      codePatterns.CODE_PATTERNS.push(...originalCode);
+    }
+  });
+});
+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('formats all failure tags with suffix', () => {
+    expect((0, _failureTagClassifier.mergeFailureTags)([], ['CODE', 'TOOL'])).toEqual(['CODE_failure', 'TOOL_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);
+      const second = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE);
+      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);
+    }
+  });
+});

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

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fileMutex = _interopRequireDefault(require("../../../../../core/playwright/helpers/fileMutex"));
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+jest.mock('fs');
+describe('FileMutex', () => {
+  const directory = '/tmp/locks';
+  const lockFileName = 'test-lock';
+  const fileDeletionTimeoutConfig = {
+    timeout: 1000
+  };
+  const lockFilePath = _path.default.resolve(directory, lockFileName + '.lock');
+  let fileMutex;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fileMutex = new _fileMutex.default(directory, lockFileName, fileDeletionTimeoutConfig);
+  });
+  describe('acquire', () => {
+    it('should create the lock file if it does not exist', async () => {
+      _fs.writeFileSync.mockImplementation(() => {});
+      await fileMutex.acquire();
+      expect(_fs.writeFileSync).toHaveBeenCalledWith(fileMutex.lockFilePath, 'locked');
+    });
+    it('should wait for lock file deletion if it exists', async () => {
+      _fs.existsSync.mockImplementation(filePath => filePath === fileMutex.lockFilePath);
+      _fs.watch.mockImplementation((dir, callback) => {
+        setTimeout(() => {
+          _fs.existsSync.mockImplementation(() => false);
+          callback('rename', fileMutex.lockFileName);
+        }, fileDeletionTimeoutConfig);
+        return {
+          close: jest.fn()
+        };
+      });
+      await fileMutex.acquire();
+      expect(_fs.watch).toHaveBeenCalledWith(directory, expect.any(Function));
+    });
+    it('should reject if watch timeout exceeds', async () => {
+      _fs.existsSync.mockImplementation(filePath => filePath === lockFilePath);
+      _fs.watch.mockImplementation(() => {
+        return {
+          close: jest.fn()
+        };
+      });
+      await expect(fileMutex.acquire()).rejects.toThrow('Watch timeout exceeded');
+    });
+  });
+  describe('release', () => {
+    it('should delete the lock file if it exists', async () => {
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {});
+      await fileMutex.release();
+      expect(_fs.existsSync).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.unlinkSync).toHaveBeenCalledWith(lockFilePath);
+    });
+    it('should release lock by deleting lock file', async () => {
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {});
+      await fileMutex.release();
+      expect(_fs.unlinkSync).toHaveBeenCalledWith(lockFilePath);
+    });
+    it('should not attempt to delete the lock file if it does not exist', async () => {
+      _fs.existsSync.mockReturnValue(false);
+      await fileMutex.release();
+      expect(_fs.existsSync).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.unlinkSync).not.toHaveBeenCalled();
+    });
+    it('should log an error if deleting the lock file fails', async () => {
+      const errorMessage = 'Error deleting lock file';
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {
+        throw new Error(errorMessage);
+      });
+      await expect(fileMutex.release()).rejects.toThrow(errorMessage);
+    });
+  });
+});