re-iterate

Author: mxschmitt

packages/playwright/src/common/testLoader.ts

@@ -15,14 +15,13 @@
  */
 
 import path from 'path';
-import util from 'util';
 
 import * as esmLoaderHost from './esmLoaderHost';
 import { isWorkerProcess, setCurrentlyLoadingFileSuite } from './globals';
 import { Suite } from './test';
 import { startCollectingFileDeps, stopCollectingFileDeps } from '../transform/compilationCache';
 import { requireOrImport } from '../transform/transform';
-import { filterStackTrace } from '../util';
+import { serializeLoadError } from '../util';
 
 import type { TestError } from '../../types/testReporter';
 
@@ -50,7 +49,7 @@ export async function loadTestFile(file: string, rootDir: string, testErrors?: T
   } catch (e) {
     if (!testErrors)
       throw e;
-    testErrors.push(serializeLoadError(file, e));
+    testErrors.push(serializeLoadError(e, file));
   } finally {
     setCurrentlyLoadingFileSuite(undefined);
     if (!isWorkerProcess()) {
@@ -81,18 +80,3 @@ export async function loadTestFile(file: string, rootDir: string, testErrors?: T
 
   return suite;
 }
-
-export function serializeLoadError(file: string, error: Error | any): TestError {
-  if (error instanceof Error) {
-    const result: TestError = filterStackTrace(error);
-    // Babel parse errors have location.
-    const loc = (error as any).loc;
-    result.location = loc ? {
-      file,
-      line: loc.line || 0,
-      column: loc.column || 0,
-    } : undefined;
-    return result;
-  }
-  return { value: util.inspect(error) };
-}

packages/playwright/src/program.ts

@@ -32,9 +32,8 @@ import { filterProjects } from './runner/projectUtils';
 import { Runner } from './runner/runner';
 import * as testServer from './runner/testServer';
 import { runWatchModeLoop } from './runner/watchMode';
-import { serializeError } from './util';
+import { serializeLoadError } from './util';
 
-import type { TestError } from '../types/testReporter';
 import type { ConfigCLIOverrides } from './common/ipc';
 import type { TraceMode } from '../types/test';
 import type { ReporterDescription } from '../types/test';
@@ -249,8 +248,7 @@ export async function withRunnerAndMutedWrite(configFile: string | undefined, ca
       gracefullyProcessExitDoNotHang(0);
     });
   } catch (e) {
-    const error: TestError = serializeError(e);
-    error.location = prepareErrorStack(e.stack).location;
+    const error = serializeLoadError(e, resolveConfigLocation(configFile).resolvedConfigFile);
     stdoutWrite(JSON.stringify({ error }, undefined, 2), () => {
       gracefullyProcessExitDoNotHang(0);
     });

packages/playwright/src/runner/testServer.ts

@@ -33,7 +33,7 @@ import { internalScreen } from '../reporters/base';
 import { InternalReporter } from '../reporters/internalReporter';
 import ListReporter from '../reporters/list';
 import { affectedTestFiles, collectAffectedTestFiles, dependenciesForTestFile } from '../transform/compilationCache';
-import { serializeError } from '../util';
+import { serializeLoadError } from '../util';
 
 import type * as reporterTypes from '../../types/testReporter';
 import type { ConfigLocation, FullConfigInternal } from '../common/config';
@@ -43,7 +43,6 @@ import type { TestRunnerPluginRegistration } from '../plugins';
 import type { ReporterV2 } from '../reporters/reporterV2';
 import type { TraceViewerRedirectOptions, TraceViewerServerOptions } from 'playwright-core/lib/server/trace/viewer/traceViewer';
 import type { HttpServer, Transport } from 'playwright-core/lib/utils';
-import { serializeLoadError } from '../common/testLoader';
 
 const originalStdoutWrite = process.stdout.write;
 const originalStderrWrite = process.stderr.write;
@@ -419,7 +418,7 @@ export class TestServerDispatcher implements TestServerInterface {
       }
       return { config };
     } catch (e) {
-      return { config: null, error: this._configLocation.resolvedConfigFile ? serializeLoadError(this._configLocation.resolvedConfigFile, e) : serializeError(e) };
+      return { config: null, error: serializeLoadError(e, this._configLocation.resolvedConfigFile) };
     }
   }
 

packages/playwright/src/util.ts

@@ -22,7 +22,9 @@ import util from 'util';
 import { parseStackFrame, sanitizeForFilePath, calculateSha1, isRegExp, isString, stringifyStackFrames } from 'playwright-core/lib/utils';
 import { colors, debug, mime, minimatch } from 'playwright-core/lib/utilsBundle';
 
-import type { Location } from './../types/testReporter';
+import { prepareErrorStack } from './reporters/base';
+
+import type { Location, TestError } from './../types/testReporter';
 import type { TestInfoErrorImpl } from './common/ipc';
 import type { StackFrame } from '@protocol/channels';
 import type { RawStack } from 'playwright-core/lib/utils';
@@ -73,6 +75,25 @@ export function serializeError(error: Error | any): TestInfoErrorImpl {
   };
 }
 
+export function serializeLoadError(e: Error | any, resolvedConfigFile: string | undefined): TestError {
+  const error: TestError = serializeError(e);
+  if (e instanceof Error && e.name === 'SyntaxError' && (e as NodeJS.ErrnoException).code === 'BABEL_PARSE_ERROR' && resolvedConfigFile) {
+    // Babel parse errors are:
+    // - always SyntaxError
+    // - always have '.loc' property
+    // - always have error code BABEL_PARSE_ERROR
+    // @see https://github.com/babel/babel/blob/5c350eab83dd12268add44cce0eeda6c898211e3/packages/babel-parser/src/parse-error.ts#L97
+    error.location = {
+      file: resolvedConfigFile,
+      line: (e as any).loc?.line,
+      column: (e as any).loc?.column,
+    };
+  } else {
+    error.location = prepareErrorStack(e.stack).location;
+  }
+  return error;
+}
+
 export type Matcher = (value: string) => boolean;
 
 export type TestFileFilter = {

tests/playwright-test/list-files.spec.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import path from 'path';
 import { test, expect } from './playwright-test-fixtures';
 
 test('should list files', async ({ runCLICommand }) => {
@@ -99,3 +100,25 @@ test('should report error', async ({ runCLICommand }) => {
     }
   });
 });
+
+test('should report SyntaxErrors', async ({ runCLICommand }) => {
+  const result = await runCLICommand({
+    'playwright.config.ts': `
+      !?NotAValidConfig
+    `,
+  }, 'list-files');
+  expect(result.exitCode).toBe(0);
+
+  const data = JSON.parse(result.stdout);
+  expect(data).toEqual({
+    error: {
+      location: {
+        file: expect.stringContaining('playwright.config.ts'),
+        line: 2,
+        column: 7,
+      },
+      message: expect.stringContaining(`SyntaxError: ${path.join(test.info().outputDir, 'playwright.config.ts')}: Unexpected token (2:7)`),
+      stack: expect.stringContaining(`SyntaxError: ${path.join(test.info().outputDir, 'playwright.config.ts')}: Unexpected token (2:7)`),
+    }
+  });
+});

tests/playwright-test/test-server.spec.ts

@@ -145,6 +145,51 @@ test('should list tests with testIdAttribute', async ({ startTestServer, writeFi
   expect(onProject.use.testIdAttribute).toBe('testId');
 });
 
+test('should serialize exception if config throws error', async ({ startTestServer, writeFiles }) => {
+  await writeFiles({
+    'playwright.config.ts': `
+      throw new Error('Config error');
+    `,
+  });
+
+  const testServerConnection = await startTestServer();
+  const events = await testServerConnection.listFiles({});
+  const error = events.report.find(e => e.method === 'onError').params.error;
+  expect(error).toEqual({
+    message: expect.stringContaining('Config error'),
+    location: {
+      file: expect.stringContaining('playwright.config.ts'),
+      line: 2,
+      column: 13,
+    },
+    snippet: expect.anything(),
+    stack: expect.stringContaining('Error: Config error'),
+  });
+});
+
+
+test('should serialize exception if config has SyntaxError', async ({ startTestServer, writeFiles }) => {
+  await writeFiles({
+    'playwright.config.ts': `
+      Invalid syntax
+    `,
+  });
+
+  const testServerConnection = await startTestServer();
+  const events = await testServerConnection.listFiles({});
+  const error = events.report.find(e => e.method === 'onError').params.error;
+  expect(error).toEqual({
+    message: expect.stringMatching(/SyntaxError: .*playwright\.config\.ts: Missing semicolon/),
+    location: {
+      file: expect.stringContaining('playwright.config.ts'),
+      line: 2,
+      column: 13,
+    },
+    snippet: expect.anything(),
+    stack: expect.stringMatching(/SyntaxError: .*playwright\.config\.ts: Missing semicolon/),
+  });
+});
+
 test('stdio interception', async ({ startTestServer, writeFiles }) => {
   const testServerConnection = await startTestServer();
   await testServerConnection.initialize({ interceptStdio: true });