@playwright/test 1.31.2 → 1.32.0

package/lib/matchers/matchers.js

@@ -50,76 +50,76 @@ var _utils = require("playwright-core/lib/utils");
  */
 
 function toBeChecked(locator, options) {
-  return _toBeTruthy.toBeTruthy.call(this, 'toBeChecked', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toBeTruthy.toBeTruthy.call(this, 'toBeChecked', locator, 'Locator', async (isNot, timeout) => {
     const checked = !options || options.checked === undefined || options.checked === true;
-    return await locator._expect(customStackTrace, checked ? 'to.be.checked' : 'to.be.unchecked', {
+    return await locator._expect(checked ? 'to.be.checked' : 'to.be.unchecked', {
       isNot,
       timeout
     });
   }, options);
 }
 function toBeDisabled(locator, options) {
-  return _toBeTruthy.toBeTruthy.call(this, 'toBeDisabled', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
-    return await locator._expect(customStackTrace, 'to.be.disabled', {
+  return _toBeTruthy.toBeTruthy.call(this, 'toBeDisabled', locator, 'Locator', async (isNot, timeout) => {
+    return await locator._expect('to.be.disabled', {
       isNot,
       timeout
     });
   }, options);
 }
 function toBeEditable(locator, options) {
-  return _toBeTruthy.toBeTruthy.call(this, 'toBeEditable', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toBeTruthy.toBeTruthy.call(this, 'toBeEditable', locator, 'Locator', async (isNot, timeout) => {
     const editable = !options || options.editable === undefined || options.editable === true;
-    return await locator._expect(customStackTrace, editable ? 'to.be.editable' : 'to.be.readonly', {
+    return await locator._expect(editable ? 'to.be.editable' : 'to.be.readonly', {
       isNot,
       timeout
     });
   }, options);
 }
 function toBeEmpty(locator, options) {
-  return _toBeTruthy.toBeTruthy.call(this, 'toBeEmpty', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
-    return await locator._expect(customStackTrace, 'to.be.empty', {
+  return _toBeTruthy.toBeTruthy.call(this, 'toBeEmpty', locator, 'Locator', async (isNot, timeout) => {
+    return await locator._expect('to.be.empty', {
       isNot,
       timeout
     });
   }, options);
 }
 function toBeEnabled(locator, options) {
-  return _toBeTruthy.toBeTruthy.call(this, 'toBeEnabled', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toBeTruthy.toBeTruthy.call(this, 'toBeEnabled', locator, 'Locator', async (isNot, timeout) => {
     const enabled = !options || options.enabled === undefined || options.enabled === true;
-    return await locator._expect(customStackTrace, enabled ? 'to.be.enabled' : 'to.be.disabled', {
+    return await locator._expect(enabled ? 'to.be.enabled' : 'to.be.disabled', {
       isNot,
       timeout
     });
   }, options);
 }
 function toBeFocused(locator, options) {
-  return _toBeTruthy.toBeTruthy.call(this, 'toBeFocused', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
-    return await locator._expect(customStackTrace, 'to.be.focused', {
+  return _toBeTruthy.toBeTruthy.call(this, 'toBeFocused', locator, 'Locator', async (isNot, timeout) => {
+    return await locator._expect('to.be.focused', {
       isNot,
       timeout
     });
   }, options);
 }
 function toBeHidden(locator, options) {
-  return _toBeTruthy.toBeTruthy.call(this, 'toBeHidden', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
-    return await locator._expect(customStackTrace, 'to.be.hidden', {
+  return _toBeTruthy.toBeTruthy.call(this, 'toBeHidden', locator, 'Locator', async (isNot, timeout) => {
+    return await locator._expect('to.be.hidden', {
       isNot,
       timeout
     });
   }, options);
 }
 function toBeVisible(locator, options) {
-  return _toBeTruthy.toBeTruthy.call(this, 'toBeVisible', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toBeTruthy.toBeTruthy.call(this, 'toBeVisible', locator, 'Locator', async (isNot, timeout) => {
     const visible = !options || options.visible === undefined || options.visible === true;
-    return await locator._expect(customStackTrace, visible ? 'to.be.visible' : 'to.be.hidden', {
+    return await locator._expect(visible ? 'to.be.visible' : 'to.be.hidden', {
       isNot,
       timeout
     });
   }, options);
 }
 function toBeInViewport(locator, options) {
-  return _toBeTruthy.toBeTruthy.call(this, 'toBeInViewport', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
-    return await locator._expect(customStackTrace, 'to.be.in.viewport', {
+  return _toBeTruthy.toBeTruthy.call(this, 'toBeInViewport', locator, 'Locator', async (isNot, timeout) => {
+    return await locator._expect('to.be.in.viewport', {
       isNot,
       expectedNumber: options === null || options === void 0 ? void 0 : options.ratio,
       timeout
@@ -128,13 +128,13 @@ function toBeInViewport(locator, options) {
 }
 function toContainText(locator, expected, options = {}) {
   if (Array.isArray(expected)) {
-    return _toEqual.toEqual.call(this, 'toContainText', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+    return _toEqual.toEqual.call(this, 'toContainText', locator, 'Locator', async (isNot, timeout) => {
       const expectedText = (0, _toMatchText.toExpectedTextValues)(expected, {
         matchSubstring: true,
         normalizeWhiteSpace: true,
         ignoreCase: options.ignoreCase
       });
-      return await locator._expect(customStackTrace, 'to.contain.text.array', {
+      return await locator._expect('to.contain.text.array', {
         expectedText,
         isNot,
         useInnerText: options.useInnerText,
@@ -145,13 +145,13 @@ function toContainText(locator, expected, options = {}) {
       contains: true
     });
   } else {
-    return _toMatchText.toMatchText.call(this, 'toContainText', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+    return _toMatchText.toMatchText.call(this, 'toContainText', locator, 'Locator', async (isNot, timeout) => {
       const expectedText = (0, _toMatchText.toExpectedTextValues)([expected], {
         matchSubstring: true,
         normalizeWhiteSpace: true,
         ignoreCase: options.ignoreCase
       });
-      return await locator._expect(customStackTrace, 'to.have.text', {
+      return await locator._expect('to.have.text', {
         expectedText,
         isNot,
         useInnerText: options.useInnerText,
@@ -161,9 +161,9 @@ function toContainText(locator, expected, options = {}) {
   }
 }
 function toHaveAttribute(locator, name, expected, options) {
-  return _toMatchText.toMatchText.call(this, 'toHaveAttribute', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toMatchText.toMatchText.call(this, 'toHaveAttribute', locator, 'Locator', async (isNot, timeout) => {
     const expectedText = (0, _toMatchText.toExpectedTextValues)([expected]);
-    return await locator._expect(customStackTrace, 'to.have.attribute', {
+    return await locator._expect('to.have.attribute', {
       expressionArg: name,
       expectedText,
       isNot,
@@ -173,18 +173,18 @@ function toHaveAttribute(locator, name, expected, options) {
 }
 function toHaveClass(locator, expected, options) {
   if (Array.isArray(expected)) {
-    return _toEqual.toEqual.call(this, 'toHaveClass', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+    return _toEqual.toEqual.call(this, 'toHaveClass', locator, 'Locator', async (isNot, timeout) => {
       const expectedText = (0, _toMatchText.toExpectedTextValues)(expected);
-      return await locator._expect(customStackTrace, 'to.have.class.array', {
+      return await locator._expect('to.have.class.array', {
         expectedText,
         isNot,
         timeout
       });
     }, expected, options);
   } else {
-    return _toMatchText.toMatchText.call(this, 'toHaveClass', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+    return _toMatchText.toMatchText.call(this, 'toHaveClass', locator, 'Locator', async (isNot, timeout) => {
       const expectedText = (0, _toMatchText.toExpectedTextValues)([expected]);
-      return await locator._expect(customStackTrace, 'to.have.class', {
+      return await locator._expect('to.have.class', {
         expectedText,
         isNot,
         timeout
@@ -193,8 +193,8 @@ function toHaveClass(locator, expected, options) {
   }
 }
 function toHaveCount(locator, expected, options) {
-  return _toEqual.toEqual.call(this, 'toHaveCount', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
-    return await locator._expect(customStackTrace, 'to.have.count', {
+  return _toEqual.toEqual.call(this, 'toHaveCount', locator, 'Locator', async (isNot, timeout) => {
+    return await locator._expect('to.have.count', {
       expectedNumber: expected,
       isNot,
       timeout
@@ -202,9 +202,9 @@ function toHaveCount(locator, expected, options) {
   }, expected, options);
 }
 function toHaveCSS(locator, name, expected, options) {
-  return _toMatchText.toMatchText.call(this, 'toHaveCSS', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toMatchText.toMatchText.call(this, 'toHaveCSS', locator, 'Locator', async (isNot, timeout) => {
     const expectedText = (0, _toMatchText.toExpectedTextValues)([expected]);
-    return await locator._expect(customStackTrace, 'to.have.css', {
+    return await locator._expect('to.have.css', {
       expressionArg: name,
       expectedText,
       isNot,
@@ -213,9 +213,9 @@ function toHaveCSS(locator, name, expected, options) {
   }, expected, options);
 }
 function toHaveId(locator, expected, options) {
-  return _toMatchText.toMatchText.call(this, 'toHaveId', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toMatchText.toMatchText.call(this, 'toHaveId', locator, 'Locator', async (isNot, timeout) => {
     const expectedText = (0, _toMatchText.toExpectedTextValues)([expected]);
-    return await locator._expect(customStackTrace, 'to.have.id', {
+    return await locator._expect('to.have.id', {
       expectedText,
       isNot,
       timeout
@@ -223,8 +223,8 @@ function toHaveId(locator, expected, options) {
   }, expected, options);
 }
 function toHaveJSProperty(locator, name, expected, options) {
-  return _toEqual.toEqual.call(this, 'toHaveJSProperty', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
-    return await locator._expect(customStackTrace, 'to.have.property', {
+  return _toEqual.toEqual.call(this, 'toHaveJSProperty', locator, 'Locator', async (isNot, timeout) => {
+    return await locator._expect('to.have.property', {
       expressionArg: name,
       expectedValue: expected,
       isNot,
@@ -234,12 +234,12 @@ function toHaveJSProperty(locator, name, expected, options) {
 }
 function toHaveText(locator, expected, options = {}) {
   if (Array.isArray(expected)) {
-    return _toEqual.toEqual.call(this, 'toHaveText', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+    return _toEqual.toEqual.call(this, 'toHaveText', locator, 'Locator', async (isNot, timeout) => {
       const expectedText = (0, _toMatchText.toExpectedTextValues)(expected, {
         normalizeWhiteSpace: true,
         ignoreCase: options.ignoreCase
       });
-      return await locator._expect(customStackTrace, 'to.have.text.array', {
+      return await locator._expect('to.have.text.array', {
         expectedText,
         isNot,
         useInnerText: options === null || options === void 0 ? void 0 : options.useInnerText,
@@ -247,12 +247,12 @@ function toHaveText(locator, expected, options = {}) {
       });
     }, expected, options);
   } else {
-    return _toMatchText.toMatchText.call(this, 'toHaveText', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+    return _toMatchText.toMatchText.call(this, 'toHaveText', locator, 'Locator', async (isNot, timeout) => {
       const expectedText = (0, _toMatchText.toExpectedTextValues)([expected], {
         normalizeWhiteSpace: true,
         ignoreCase: options.ignoreCase
       });
-      return await locator._expect(customStackTrace, 'to.have.text', {
+      return await locator._expect('to.have.text', {
         expectedText,
         isNot,
         useInnerText: options === null || options === void 0 ? void 0 : options.useInnerText,
@@ -262,9 +262,9 @@ function toHaveText(locator, expected, options = {}) {
   }
 }
 function toHaveValue(locator, expected, options) {
-  return _toMatchText.toMatchText.call(this, 'toHaveValue', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toMatchText.toMatchText.call(this, 'toHaveValue', locator, 'Locator', async (isNot, timeout) => {
     const expectedText = (0, _toMatchText.toExpectedTextValues)([expected]);
-    return await locator._expect(customStackTrace, 'to.have.value', {
+    return await locator._expect('to.have.value', {
       expectedText,
       isNot,
       timeout
@@ -272,9 +272,9 @@ function toHaveValue(locator, expected, options) {
   }, expected, options);
 }
 function toHaveValues(locator, expected, options) {
-  return _toEqual.toEqual.call(this, 'toHaveValues', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toEqual.toEqual.call(this, 'toHaveValues', locator, 'Locator', async (isNot, timeout) => {
     const expectedText = (0, _toMatchText.toExpectedTextValues)(expected);
-    return await locator._expect(customStackTrace, 'to.have.values', {
+    return await locator._expect('to.have.values', {
       expectedText,
       isNot,
       timeout
@@ -283,11 +283,11 @@ function toHaveValues(locator, expected, options) {
 }
 function toHaveTitle(page, expected, options = {}) {
   const locator = page.locator(':root');
-  return _toMatchText.toMatchText.call(this, 'toHaveTitle', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toMatchText.toMatchText.call(this, 'toHaveTitle', locator, 'Locator', async (isNot, timeout) => {
     const expectedText = (0, _toMatchText.toExpectedTextValues)([expected], {
       normalizeWhiteSpace: true
     });
-    return await locator._expect(customStackTrace, 'to.have.title', {
+    return await locator._expect('to.have.title', {
       expectedText,
       isNot,
       timeout
@@ -298,9 +298,9 @@ function toHaveURL(page, expected, options) {
   const baseURL = page.context()._options.baseURL;
   expected = typeof expected === 'string' ? (0, _utils.constructURLBasedOnBaseURL)(baseURL, expected) : expected;
   const locator = page.locator(':root');
-  return _toMatchText.toMatchText.call(this, 'toHaveURL', locator, 'Locator', async (isNot, timeout, customStackTrace) => {
+  return _toMatchText.toMatchText.call(this, 'toHaveURL', locator, 'Locator', async (isNot, timeout) => {
     const expectedText = (0, _toMatchText.toExpectedTextValues)([expected]);
-    return await locator._expect(customStackTrace, 'to.have.url', {
+    return await locator._expect('to.have.url', {
       expectedText,
       isNot,
       timeout

package/lib/matchers/toBeTruthy.js

@@ -34,7 +34,7 @@ async function toBeTruthy(matcherName, receiver, receiverType, query, options =
     matches,
     log,
     timedOut
-  } = await query(this.isNot, timeout, (0, _util.captureStackTrace)(`expect.${this.isNot ? 'not.' : ''}${matcherName}`));
+  } = await query(this.isNot, timeout);
   const message = () => {
     return (0, _matcherHint.matcherHint)(this, matcherName, undefined, '', matcherOptions, timedOut ? timeout : undefined) + (0, _util.callLogText)(log);
   };

package/lib/matchers/toEqual.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.toEqual = toEqual;
 var _util = require("../util");
-var _utils = require("playwright-core/lib/utils");
 var _matcherHint = require("./matcherHint");
 var _globals = require("../common/globals");
 /**
@@ -38,14 +37,12 @@ async function toEqual(matcherName, receiver, receiverType, query, expected, opt
     promise: this.promise
   };
   const timeout = (0, _globals.currentExpectTimeout)(options);
-  const customStackTrace = (0, _utils.captureStackTrace)();
-  customStackTrace.apiName = 'expect.' + matcherName;
   const {
     matches: pass,
     received,
     log,
     timedOut
-  } = await query(this.isNot, timeout, customStackTrace);
+  } = await query(this.isNot, timeout);
   const message = pass ? () => (0, _matcherHint.matcherHint)(this, matcherName, undefined, undefined, matcherOptions, timedOut ? timeout : undefined) + '\n\n' + `Expected: not ${this.utils.printExpected(expected)}\n` + (this.utils.stringify(expected) !== this.utils.stringify(received) ? `Received:     ${this.utils.printReceived(received)}` : '') + (0, _util.callLogText)(log) : () => (0, _matcherHint.matcherHint)(this, matcherName, undefined, undefined, matcherOptions, timedOut ? timeout : undefined) + '\n\n' + this.utils.printDiffOrStringify(expected, received, EXPECTED_LABEL, RECEIVED_LABEL, isExpand(this.expand)) + (0, _util.callLogText)(log);
 
   // Passing the actual and expected objects so that a custom reporter

package/lib/matchers/toMatchSnapshot.js

@@ -283,7 +283,6 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
     maxDiffPixels: undefined,
     maxDiffPixelRatio: undefined
   };
-  const customStackTrace = (0, _util.captureStackTrace)(`expect.${this.isNot ? 'not.' : ''}toHaveScreenshot`);
   const hasSnapshot = _fs.default.existsSync(helper.snapshotPath);
   if (this.isNot) {
     if (!hasSnapshot) return helper.handleMissingNegated();
@@ -291,7 +290,7 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
     // Having `errorMessage` means we timed out while waiting
     // for screenshots not to match, so screenshots
     // are actually the same in the end.
-    const isDifferent = !(await page._expectScreenshot(customStackTrace, {
+    const isDifferent = !(await page._expectScreenshot({
       expected: await _fs.default.promises.readFile(helper.snapshotPath),
       isNot: true,
       locator,
@@ -319,7 +318,7 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
       diff,
       errorMessage,
       log
-    } = await page._expectScreenshot(customStackTrace, {
+    } = await page._expectScreenshot({
       expected: undefined,
       isNot: false,
       locator,
@@ -348,7 +347,7 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
     diff,
     errorMessage,
     log
-  } = await page._expectScreenshot(customStackTrace, {
+  } = await page._expectScreenshot({
     expected,
     isNot: false,
     locator,

package/lib/matchers/toMatchText.js

@@ -41,7 +41,7 @@ async function toMatchText(matcherName, receiver, receiverType, query, expected,
     received,
     log,
     timedOut
-  } = await query(this.isNot, timeout, (0, _util.captureStackTrace)(`expect.${this.isNot ? 'not.' : ''}${matcherName}`));
+  } = await query(this.isNot, timeout);
   const stringSubstring = options.matchSubstring ? 'substring' : 'string';
   const receivedString = received || '';
   const message = pass ? () => typeof expected === 'string' ? (0, _matcherHint.matcherHint)(this, matcherName, undefined, undefined, matcherOptions, timedOut ? timeout : undefined) + '\n\n' + `Expected ${stringSubstring}: not ${this.utils.printExpected(expected)}\n` + `Received string: ${(0, _expect.printReceivedStringContainExpectedSubstring)(receivedString, receivedString.indexOf(expected), expected.length)}` + (0, _util.callLogText)(log) : (0, _matcherHint.matcherHint)(this, matcherName, undefined, undefined, matcherOptions, timedOut ? timeout : undefined) + '\n\n' + `Expected pattern: not ${this.utils.printExpected(expected)}\n` + `Received string: ${(0, _expect.printReceivedStringContainExpectedResult)(receivedString, typeof expected.exec === 'function' ? expected.exec(receivedString) : null)}` + (0, _util.callLogText)(log) : () => {

package/lib/plugins/vitePlugin.js

@@ -259,8 +259,9 @@ function vitePlugin(registerSource, relativeTemplateDir, buildInfo, componentReg
       const indexTs = _path.default.join(relativeTemplateDir, 'index.ts');
       const indexTsx = _path.default.join(relativeTemplateDir, 'index.tsx');
       const indexJs = _path.default.join(relativeTemplateDir, 'index.js');
+      const indexJsx = _path.default.join(relativeTemplateDir, 'index.jsx');
       const idResolved = _path.default.resolve(id);
-      if (!idResolved.endsWith(indexTs) && !idResolved.endsWith(indexTsx) && !idResolved.endsWith(indexJs)) return;
+      if (!idResolved.endsWith(indexTs) && !idResolved.endsWith(indexTsx) && !idResolved.endsWith(indexJs) && !idResolved.endsWith(indexJsx)) return;
       const folder = _path.default.dirname(id);
       const lines = [content, ''];
       lines.push(registerSource);
@@ -268,7 +269,7 @@ function vitePlugin(registerSource, relativeTemplateDir, buildInfo, componentReg
         const importPath = value.isModuleOrAlias ? value.importPath : './' + _path.default.relative(folder, value.importPath).replace(/\\/g, '/');
         if (value.importedName) lines.push(`import { ${value.importedName} as ${alias} } from '${importPath}';`);else lines.push(`import ${alias} from '${importPath}';`);
       }
-      lines.push(`register({ ${[...componentRegistry.keys()].join(',\n  ')} });`);
+      lines.push(`pwRegister({ ${[...componentRegistry.keys()].join(',\n  ')} });`);
       return {
         code: lines.join('\n'),
         map: {

package/lib/reporters/base.js

@@ -397,16 +397,13 @@ function prepareErrorStack(stack) {
   const stackLines = lines.slice(firstStackLine);
   let location;
   for (const line of stackLines) {
-    const {
-      frame: parsed,
-      fileName: resolvedFile
-    } = (0, _utilsBundle.parseStackTraceLine)(line);
-    if (!parsed || !resolvedFile) continue;
-    if (belongsToNodeModules(resolvedFile)) continue;
+    const frame = (0, _utilsBundle.parseStackTraceLine)(line);
+    if (!frame || !frame.file) continue;
+    if (belongsToNodeModules(frame.file)) continue;
     location = {
-      file: resolvedFile,
-      column: parsed.column || 0,
-      line: parsed.line || 0
+      file: frame.file,
+      column: frame.column || 0,
+      line: frame.line || 0
     };
     break;
   }

package/lib/reporters/html.js

@@ -271,13 +271,18 @@ class HtmlBuilder {
     if (this._hasTraces) {
       const traceViewerFolder = _path.default.join(require.resolve('playwright-core'), '..', 'lib', 'webpack', 'traceViewer');
       const traceViewerTargetFolder = _path.default.join(this._reportFolder, 'trace');
-      _fs.default.mkdirSync(traceViewerTargetFolder, {
+      const traceViewerAssetsTargetFolder = _path.default.join(traceViewerTargetFolder, 'assets');
+      _fs.default.mkdirSync(traceViewerAssetsTargetFolder, {
         recursive: true
       });
       for (const file of _fs.default.readdirSync(traceViewerFolder)) {
-        if (file.endsWith('.map')) continue;
+        if (file.endsWith('.map') || file.includes('watch') || file.includes('assets')) continue;
         await (0, _utils.copyFileAndMakeWritable)(_path.default.join(traceViewerFolder, file), _path.default.join(traceViewerTargetFolder, file));
       }
+      for (const file of _fs.default.readdirSync(_path.default.join(traceViewerFolder, 'assets'))) {
+        if (file.endsWith('.map') || file.includes('xtermModule')) continue;
+        await (0, _utils.copyFileAndMakeWritable)(_path.default.join(traceViewerFolder, 'assets', file), _path.default.join(traceViewerAssetsTargetFolder, file));
+      }
     }
 
     // Inline report data.

package/lib/reporters/json.js

@@ -62,7 +62,7 @@ class JSONReporter {
             repeatEach: project.repeatEach,
             retries: project.retries,
             metadata: project.metadata,
-            id: project._id,
+            id: project._internal.id,
             name: project.name,
             testDir: toPosixPath(project.testDir),
             testIgnore: serializePatterns(project.testIgnore),
@@ -78,7 +78,7 @@ class JSONReporter {
   _mergeSuites(suites) {
     const fileSuites = new _utils.MultiMap();
     for (const projectSuite of suites) {
-      const projectId = projectSuite.project()._id;
+      const projectId = projectSuite.project()._internal.id;
       const projectName = projectSuite.project().name;
       for (const fileSuite of projectSuite.suites) {
         const file = fileSuite.location.file;

package/lib/reporters/junit.js

@@ -51,7 +51,7 @@ class JUnitReporter {
   onBegin(config, suite) {
     this.config = config;
     this.suite = suite;
-    this.timestamp = Date.now();
+    this.timestamp = new Date();
     this.startTime = (0, _utils.monotonicTime)();
   }
   async onEnd(result) {
@@ -108,7 +108,7 @@ class JUnitReporter {
       name: 'testsuite',
       attributes: {
         name: suite.title,
-        timestamp: this.timestamp,
+        timestamp: this.timestamp.toISOString(),
         hostname: projectName,
         tests,
         failures,