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

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

@@ -6,18 +6,27 @@ 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)(tempDir, {
+  const file = (0, _runtimeLogPath.resolveRuntimeLogFilePath)(runtimeLogsDir(), {
     workerIndex,
     retry,
     title
@@ -55,6 +64,9 @@ function failingDetailWithStdio({
 }
 beforeEach(() => {
   tempDir = _fs.default.mkdtempSync(_path.default.join(_os.default.tmpdir(), 'failure-tag-'));
+  _readConfigFile.generateConfigFromFile.mockReturnValue({
+    uatDirectory: tempDir
+  });
 });
 afterEach(() => {
   _fs.default.rmSync(tempDir, {
@@ -63,12 +75,12 @@ afterEach(() => {
   });
 });
 describe('classifyFailureTags', () => {
-  test('returns flaky and skips log analysis for flaky outcome', () => {
+  test('leaves retry-passed (flaky) outcomes untagged', () => {
     const tags = (0, _failureTagClassifier.classifyFailureTags)([{
       status: 'flaky',
       results: []
-    }], TEST_TITLE, tempDir);
-    expect(tags).toEqual(['FLAKY']);
+    }], TEST_TITLE);
+    expect(tags).toEqual([]);
   });
   test('tags environment when a document abort is present', () => {
     const tags = (0, _failureTagClassifier.classifyFailureTags)([failingDetail([{
@@ -76,7 +88,7 @@ describe('classifyFailureTags', () => {
       url: 'https://app/events/list/commentsubtabevent',
       failure: 'net::ERR_ABORTED',
       resourceType: 'document'
-    }])], TEST_TITLE, tempDir);
+    }])], TEST_TITLE);
     expect(tags).toEqual(['ENVIRONMENT']);
   });
   test('tags environment for a network/cert failure', () => {
@@ -87,7 +99,7 @@ describe('classifyFailureTags', () => {
       resourceType: 'script'
     }], {
       title: 'cert-test'
-    })], 'cert-test', tempDir);
+    })], 'cert-test');
     expect(tags).toEqual(['ENVIRONMENT']);
   });
   test('tags code when an app undefined-property error is present', () => {
@@ -97,10 +109,10 @@ describe('classifyFailureTags', () => {
       message: "Cannot read properties of undefined (reading 'id')"
     }], {
       title: 'code-test'
-    })], 'code-test', tempDir);
+    })], 'code-test');
     expect(tags).toEqual(['CODE']);
   });
-  test('does not tag a non-document (xhr) abort as environment', () => {
+  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',
@@ -108,17 +120,17 @@ describe('classifyFailureTags', () => {
       resourceType: 'xhr'
     }], {
       title: 'xhr-test'
-    })], 'xhr-test', tempDir);
-    expect(tags).toEqual([]);
+    })], 'xhr-test');
+    expect(tags).toEqual(['CODE']);
   });
-  test('tags case and code when stderr reports DATA_GENERATION_ERROR', () => {
+  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, tempDir);
-    expect(tags).toEqual(['CASE', 'CODE']);
+    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({
@@ -126,10 +138,10 @@ describe('classifyFailureTags', () => {
         buffer: Buffer.from('Error during login').toString('base64')
       }]
     });
-    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE);
     expect(tags).toEqual(['TOOL']);
   });
-  test('tags case and code when stderr matches a case pattern', () => {
+  test('tags case when stderr matches a case pattern', () => {
     const originalCasePatterns = casePatterns.CASE_PATTERNS.slice();
     try {
       casePatterns.CASE_PATTERNS.push(/expect\(received\)\.toBe/i);
@@ -138,22 +150,37 @@ describe('classifyFailureTags', () => {
           text: 'Error: expect(received).toBe(expected)'
         }]
       });
-      const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
-      expect(tags).toEqual(['CASE', 'CODE']);
+      const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE);
+      expect(tags).toEqual(['CASE']);
     } finally {
       casePatterns.CASE_PATTERNS.length = 0;
       casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
     }
   });
-  test('does not tag tool for benign stdout/stderr', () => {
+  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, tempDir);
-    expect(tags).toEqual([]);
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE);
+    expect(tags).toEqual(['CODE']);
   });
   test('does not throw for malformed stdio chunk entries', () => {
     const detail = failingDetailWithStdio({
@@ -162,10 +189,10 @@ describe('classifyFailureTags', () => {
       }],
       stderr: [false]
     });
-    expect(() => (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir)).not.toThrow();
-    expect((0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir)).toEqual([]);
+    expect(() => (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE)).not.toThrow();
+    expect((0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE)).toEqual(['CODE']);
   });
-  test('leaves untagged when no environment or code pattern is present', () => {
+  test('defaults to code when a failure matches no pattern', () => {
     const tags = (0, _failureTagClassifier.classifyFailureTags)([failingDetail([{
       kind: 'response',
       status: 200,
@@ -180,7 +207,18 @@ describe('classifyFailureTags', () => {
       }
     }], {
       title: 'neutral-test'
-    })], 'neutral-test', tempDir);
+    })], '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([]);
   });
 });
@@ -191,7 +229,7 @@ describe('classifyFailureDetails', () => {
       url: 'https://app/events/list/commentsubtabevent',
       failure: 'net::ERR_ABORTED',
       resourceType: 'document'
-    }])], TEST_TITLE, tempDir);
+    }])], TEST_TITLE);
     expect(details.tags).toEqual(['ENVIRONMENT']);
     expect(details.matches).toHaveLength(1);
     expect(details.matches[0]).toMatchObject({
@@ -214,25 +252,17 @@ describe('classifyFailureDetails', () => {
       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('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('records tool pattern from stdio', () => {
     const details = (0, _failureTagClassifier.classifyFailureDetails)([failingDetailWithStdio({
       stderr: [{
         text: 'Error during login for actor admin'
       }]
-    })], TEST_TITLE, tempDir);
+    })], TEST_TITLE);
     expect(details.tags).toEqual(['TOOL']);
     expect(details.matches[0]).toMatchObject({
       tag: 'TOOL',
@@ -240,7 +270,7 @@ describe('classifyFailureDetails', () => {
       source: 'stdio'
     });
   });
-  test('records case pattern from stdio and implies code', () => {
+  test('records case pattern from stdio without implying code', () => {
     const originalCasePatterns = casePatterns.CASE_PATTERNS.slice();
     try {
       casePatterns.CASE_PATTERNS.push(/expect\(received\)\.toBe/i);
@@ -248,26 +278,20 @@ describe('classifyFailureDetails', () => {
         stderr: [{
           text: 'Error: expect(received).toBe(expected)'
         }]
-      })], TEST_TITLE, tempDir);
-      expect(details.tags).toEqual(['CASE', 'CODE']);
-      expect(details.matches).toHaveLength(2);
+      })], 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'
       });
-      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', () => {
+  test('resolves to CODE when a runtime-log code match outranks a stdio case match', () => {
     const originalCasePatterns = casePatterns.CASE_PATTERNS.slice();
     try {
       casePatterns.CASE_PATTERNS.push(/expect\(received\)\.toBe/i);
@@ -288,13 +312,14 @@ describe('classifyFailureDetails', () => {
             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({
+      }], 'case-with-runtime-code');
+
+      // CODE outranks CASE, so only CODE surfaces as the tag and as matches.
+      expect(details.tags).toEqual(['CODE']);
+      expect(details.matches).toHaveLength(1);
+      expect(details.matches.find(match => match.tag === 'CASE')).toBeUndefined();
+      expect(details.matches[0]).toMatchObject({
+        tag: 'CODE',
         source: 'runtime-log',
         pattern: 'Cannot read properties of (undefined|null)'
       });
@@ -303,7 +328,7 @@ describe('classifyFailureDetails', () => {
       casePatterns.CASE_PATTERNS.push(...originalCasePatterns);
     }
   });
-  test('implies code from case when no runtime log is present', () => {
+  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);
@@ -311,17 +336,174 @@ describe('classifyFailureDetails', () => {
         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
-      });
+      })], 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', () => {
@@ -376,8 +558,8 @@ 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('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']);
@@ -399,8 +581,8 @@ describe('regex safety', () => {
           text: 'status : DATA_GENERATION_ERROR'
         }]
       });
-      const first = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
-      const second = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
+      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 {

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

@@ -114,10 +114,34 @@ describe('LogCollector baseline-noise stripping', () => {
       });
       const filePath = collector.flushToFile(flushDir, 'w0-test-0');
       const contents = _fs.default.readFileSync(filePath, 'utf8');
+      const line = JSON.parse(contents.trim());
       expect(filePath).toContain('w0-test-0.jsonl');
-      expect(contents).toContain('"kind":"pageerror"');
+      expect(line).toMatchObject({
+        pattern: 'CODE',
+        kind: 'pageerror'
+      });
       expect(contents).toContain("Cannot read properties of undefined (reading 'id')");
       expect(contents.endsWith('\n')).toBe(true);
+      // In-memory events stay unannotated.
+      expect(collector.events[0].pattern).toBeUndefined();
+    } finally {
+      _fs.default.rmSync(flushDir, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  test('flushes ENVIRONMENT pattern annotation for document aborts', () => {
+    const flushDir = _fs.default.mkdtempSync(_path.default.join(_os.default.tmpdir(), 'log-collector-flush-'));
+    try {
+      context.emit('requestfailed', failedRequest('https://app/agent/events/list/commentsubtabevent', 'net::ERR_ABORTED', 'document'));
+      const filePath = collector.flushToFile(flushDir, 'w0-env-0');
+      const line = JSON.parse(_fs.default.readFileSync(filePath, 'utf8').trim());
+      expect(line).toMatchObject({
+        pattern: 'ENVIRONMENT',
+        kind: 'requestfailed',
+        resourceType: 'document'
+      });
     } finally {
       _fs.default.rmSync(flushDir, {
         recursive: true,