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

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

@@ -1,23 +1,41 @@
 "use strict";
 
-var _logCollectorConstants = require("../../../../../core/playwright/constants/logCollectorConstants");
+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); }
-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`)
-    });
-  }
+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',
-      attachments
+      workerIndex: options.workerIndex ?? 0,
+      retry: options.retry ?? 0
     }]
   };
 }
@@ -35,12 +53,21 @@ function failingDetailWithStdio({
     }]
   };
 }
+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', () => {
@@ -49,7 +76,7 @@ describe('classifyFailureTags', () => {
       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', () => {
@@ -58,7 +85,9 @@ describe('classifyFailureTags', () => {
       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', () => {
@@ -66,7 +95,9 @@ describe('classifyFailureTags', () => {
       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', () => {
@@ -75,27 +106,45 @@ describe('classifyFailureTags', () => {
       url: 'https://app/api/tickets',
       failure: 'net::ERR_ABORTED',
       resourceType: 'xhr'
-    }])]);
+    }], {
+      title: 'xhr-test'
+    })], 'xhr-test', tempDir);
     expect(tags).toEqual([]);
   });
-  test('tags tool when stderr reports a DATA_GENERATION_ERROR', () => {
+  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]);
-    expect(tags).toEqual(['TOOL']);
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
+    expect(tags).toEqual(['CASE', 'CODE']);
   });
-  test('tags tool for an "Error Type:" line in base64 stdout', () => {
+  test('tags tool for a known tool pattern in base64 stdout', () => {
     const detail = failingDetailWithStdio({
       stdout: [{
-        buffer: Buffer.from('Error Type: Error').toString('base64')
+        buffer: Buffer.from('Error during login').toString('base64')
       }]
     });
-    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail]);
+    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: [{
@@ -103,7 +152,7 @@ describe('classifyFailureTags', () => {
       }],
       stderr: []
     });
-    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail]);
+    const tags = (0, _failureTagClassifier.classifyFailureTags)([detail], TEST_TITLE, tempDir);
     expect(tags).toEqual([]);
   });
   test('does not throw for malformed stdio chunk entries', () => {
@@ -113,8 +162,8 @@ describe('classifyFailureTags', () => {
       }],
       stderr: [false]
     });
-    expect(() => (0, _failureTagClassifier.classifyFailureTags)([detail])).not.toThrow();
-    expect((0, _failureTagClassifier.classifyFailureTags)([detail])).toEqual([]);
+    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([{
@@ -129,10 +178,200 @@ describe('classifyFailureTags', () => {
       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']);
@@ -143,25 +382,32 @@ describe('mergeFailureTags', () => {
   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]);
-      const second = (0, _failureTagClassifier.classifyFailureTags)([detail]);
+      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);
     }
   });
 });

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

@@ -1,5 +1,9 @@
 "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 _logCollector = require("../../../../../core/playwright/helpers/logCollector");
 function makeEmitter() {
   const handlers = {};
@@ -100,19 +104,29 @@ describe('LogCollector baseline-noise stripping', () => {
       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('flushes captured events to a jsonl file', () => {
+    const flushDir = _fs.default.mkdtempSync(_path.default.join(_os.default.tmpdir(), 'log-collector-flush-'));
+    try {
+      page.emit('pageerror', {
+        name: 'TypeError',
+        message: "Cannot read properties of undefined (reading 'id')",
+        stack: 'TypeError: ...'
+      });
+      const filePath = collector.flushToFile(flushDir, 'w0-test-0');
+      const contents = _fs.default.readFileSync(filePath, 'utf8');
+      expect(filePath).toContain('w0-test-0.jsonl');
+      expect(contents).toContain('"kind":"pageerror"');
+      expect(contents).toContain("Cannot read properties of undefined (reading 'id')");
+      expect(contents.endsWith('\n')).toBe(true);
+    } finally {
+      _fs.default.rmSync(flushDir, {
+        recursive: true,
+        force: true
+      });
+    }
   });
-  test('returns null from toJsonlBody when no events were captured', () => {
-    expect(collector.toJsonlBody()).toBeNull();
+  test('returns null from flushToFile when no events were captured', () => {
+    expect(collector.flushToFile('/tmp', 'empty')).toBeNull();
   });
   test('keeps a document-navigation abort (real environment signal)', () => {
     context.emit('requestfailed', failedRequest('https://app/agent/events/list/commentsubtabevent', 'net::ERR_ABORTED', 'document'));

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

@@ -1,41 +1,103 @@
 "use strict";
 
-var _logCollectorConstants = require("../../../../../core/playwright/constants/logCollectorConstants");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _runtimeLogPath = require("../../../../../core/playwright/helpers/runtimeLogPath");
 var _runtimeLogReader = require("../../../../../core/playwright/helpers/runtimeLogReader");
-function jsonlBody(events) {
-  return Buffer.from(`${events.map(e => JSON.stringify(e)).join('\n')}\n`);
+const TEST_TITLE = 'runtime-log-reader-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;
 }
-describe('readRuntimeLogEventsFromResult', () => {
-  test('reads inline runtime-log-events body', () => {
-    const inlineEvents = [{
+beforeEach(() => {
+  tempDir = _fs.default.mkdtempSync(_path.default.join(_os.default.tmpdir(), 'runtime-log-reader-'));
+});
+afterEach(() => {
+  _fs.default.rmSync(tempDir, {
+    recursive: true,
+    force: true
+  });
+});
+describe('readRuntimeLogEventsForResult', () => {
+  test('reads project-side runtime log for a failing result', () => {
+    const events = [{
       kind: 'pageerror',
       message: 'inline boom'
     }];
+    writeRuntimeLog(events);
     const result = {
-      attachments: [{
-        name: _logCollectorConstants.RUNTIME_LOG_EVENTS_ATTACHMENT,
-        contentType: _logCollectorConstants.RUNTIME_LOG_EVENTS_CONTENT_TYPE,
-        body: jsonlBody(inlineEvents)
-      }]
+      status: 'failed',
+      workerIndex: 0,
+      retry: 0
     };
-    expect((0, _runtimeLogReader.readRuntimeLogEventsFromResult)(result)).toEqual(inlineEvents);
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, TEST_TITLE, tempDir)).toEqual(events);
   });
   test('skips malformed jsonl lines', () => {
-    const raw = [JSON.stringify({
+    const file = writeRuntimeLog([]);
+    _fs.default.writeFileSync(file, [JSON.stringify({
       kind: 'console',
       text: 'ok'
     }), 'not-json', JSON.stringify({
       kind: 'pageerror',
       message: 'err'
-    })].join('\n');
+    })].join('\n') + '\n');
+    const result = {
+      status: 'failed',
+      workerIndex: 0,
+      retry: 0
+    };
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, TEST_TITLE, tempDir)).toEqual([{
+      kind: 'console',
+      text: 'ok'
+    }, {
+      kind: 'pageerror',
+      message: 'err'
+    }]);
+  });
+  test('returns an empty array when the runtime log file is missing', () => {
+    const result = {
+      status: 'failed',
+      workerIndex: 0,
+      retry: 0
+    };
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, 'missing-test', tempDir)).toEqual([]);
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(null, TEST_TITLE, tempDir)).toEqual([]);
+  });
+  test('returns an empty array when logsDir is missing', () => {
     const result = {
-      attachments: [{
-        name: _logCollectorConstants.RUNTIME_LOG_EVENTS_ATTACHMENT,
-        contentType: _logCollectorConstants.RUNTIME_LOG_EVENTS_CONTENT_TYPE,
-        body: Buffer.from(`${raw}\n`)
-      }]
+      status: 'failed',
+      workerIndex: 0,
+      retry: 0
     };
-    expect((0, _runtimeLogReader.readRuntimeLogEventsFromResult)(result)).toEqual([{
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, TEST_TITLE)).toEqual([]);
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, TEST_TITLE, undefined)).toEqual([]);
+  });
+});
+describe('readRuntimeLogEvents', () => {
+  test('reads events from a jsonl file path', () => {
+    const file = writeRuntimeLog([{
+      kind: 'console',
+      text: 'ok'
+    }, {
+      kind: 'pageerror',
+      message: 'err'
+    }]);
+    expect((0, _runtimeLogReader.readRuntimeLogEvents)(file)).toEqual([{
       kind: 'console',
       text: 'ok'
     }, {
@@ -43,10 +105,8 @@ describe('readRuntimeLogEventsFromResult', () => {
       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([]);
+  test('returns an empty array for a missing file', () => {
+    expect((0, _runtimeLogReader.readRuntimeLogEvents)(null)).toEqual([]);
+    expect((0, _runtimeLogReader.readRuntimeLogEvents)(_path.default.join(tempDir, 'missing.jsonl'))).toEqual([]);
   });
 });