fix: don't panic when file contains invalid syntax in browser mode (#522

)

* fix: don't panic when file contains invalid syntax

* fix: always return something

* chore: construct an errors array

* test: add a test

* chore: remove only

.github/workflows/ci.yml

@@ -38,6 +38,7 @@ jobs:
         run: |
           pnpm -C samples/e2e i
           pnpm -C samples/monorepo-vitest-workspace i
+          pnpm -C samples/browser i
           npm -C samples/imba i
           pnpm test-e2e --retry 2
 

src/worker/collect.ts

@@ -9,7 +9,7 @@ import {
   generateHash,
   someTasksAreOnly,
 } from '@vitest/runner/utils'
-import type { RunnerTestCase, RunnerTestFile, RunnerTestSuite, TaskBase } from 'vitest'
+import type { RunnerTestCase, RunnerTestFile, RunnerTestSuite, TaskBase, TestError } from 'vitest'
 import type { WorkspaceProject } from 'vitest/node'
 
 interface ParsedFile extends RunnerTestFile {
@@ -42,7 +42,7 @@ interface LocalCallDefinition {
 export interface FileInformation {
   file: RunnerTestFile
   filepath: string
-  parsed: string
+  parsed: string | null
   map: SourceMap | { mappings: string } | null
   definitions: LocalCallDefinition[]
 }
@@ -164,17 +164,67 @@ export function astParseFile(filepath: string, code: string) {
   }
 }
 
+export function createFailedFileTask(ctx: WorkspaceProject, filepath: string, error: Error) {
+  const testFilepath = relative(ctx.config.root, filepath)
+  const file: ParsedFile = {
+    filepath,
+    type: 'suite',
+    id: /* @__PURE__ */ generateHash(`${testFilepath}${ctx.config.name || ''}`),
+    name: testFilepath,
+    mode: 'run',
+    tasks: [],
+    start: 0,
+    end: 0,
+    projectName: ctx.getName(),
+    meta: {},
+    pool: 'browser',
+    file: null!,
+    result: {
+      state: 'fail',
+      errors: serializeError(ctx, error),
+    },
+  }
+  file.file = file
+  return file
+}
+
+function serializeError(ctx: WorkspaceProject, error: any): TestError[] {
+  if ('errors' in error && 'pluginCode' in error) {
+    const errors = error.errors.map((e: any) => {
+      return {
+        name: error.name,
+        message: e.text,
+        stack: e.location
+          ? `${error.name}: ${e.text}\n  at ${relative(ctx.config.root, e.location.file)}:${e.location.line}:${e.location.column}`
+          : '',
+      }
+    })
+    return errors
+  }
+  return [
+    {
+      name: error.name,
+      stack: error.stack,
+      message: error.message,
+    },
+  ]
+}
+
 export async function astCollectTests(
   ctx: WorkspaceProject,
   filepath: string,
   transformMode: 'web' | 'ssr',
-): Promise<null | FileInformation> {
+): Promise<ParsedFile> {
   const request = await ctx.vitenode.transformRequest(filepath, filepath, transformMode)
   // TODO: error cannot parse
   const testFilepath = relative(ctx.config.root, filepath)
   if (!request) {
     debug?.('Cannot parse', testFilepath, '(vite didn\'t return anything)')
-    return null
+    return createFailedFileTask(
+      ctx,
+      filepath,
+      new Error(`Failed to parse ${testFilepath}. Vite didn't return anything.`),
+    )
   }
   const { definitions, ast } = astParseFile(testFilepath, request.code)
   const file: ParsedFile = {
@@ -303,13 +353,7 @@ export async function astCollectTests(
       ],
     }
   }
-  return {
-    file,
-    parsed: request.code,
-    filepath,
-    map: request.map,
-    definitions,
-  }
+  return file
 }
 
 function createIndexMap(source: string) {

src/worker/vitest.ts

@@ -6,7 +6,7 @@ import type { SerializedTestSpecification, VitestMethods } from '../api/rpc'
 import { VitestWatcher } from './watcher'
 import { VitestCoverage } from './coverage'
 import { assert, limitConcurrency } from './utils'
-import { astCollectTests } from './collect'
+import { astCollectTests, createFailedFileTask } from './collect'
 
 const verbose = process.env.VITEST_VSCODE_LOG === 'verbose'
   ? (...args: any[]) => {
@@ -80,10 +80,9 @@ export class Vitest implements VitestMethods {
     const runConcurrently = limitConcurrency(5)
 
     const promises = specs.map(([project, filename]) => runConcurrently(
-      () => astCollectTests(project, filename, transformMode),
+      () => astCollectTests(project, filename, transformMode).catch(err => createFailedFileTask(project, filename, err)),
     ))
-    const result = await Promise.all(promises)
-    const files = result.filter(r => r != null).map((r => r!.file))
+    const files = await Promise.all(promises)
     this.ctx.configOverride.testNamePattern = new RegExp(Vitest.COLLECT_NAME_PATTERN)
     await this.ctx.report('onCollected', files)
     this.setTestNamePattern(undefined)

test-e2e/assertions.ts

@@ -33,6 +33,17 @@ expect.extend({
       name: 'toHaveState',
     }
   },
+  async toHaveError(item: TesterTestItem, error: string) {
+    const page = item.page
+    const depth = Number(await item.locator.getAttribute('aria-level'))
+
+    await expect(page.locator(`[aria-label*="${error}"][aria-level="${depth + 1}"]`)).toBeVisible()
+
+    return {
+      pass: true,
+      message: () => '',
+    }
+  },
   async toHaveTests(item: TesterTestItem, tests: TestsTree) {
     const page = item.page
     const depth = Number(await item.locator.getAttribute('aria-level'))
@@ -81,6 +92,7 @@ declare global {
        * })
        */
       toHaveTests: (tests: TestsTree) => Promise<R>
+      toHaveError: (error: string) => Promise<R>
     }
   }
 }

test-e2e/basic.test.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs'
+import { readFileSync, rmSync } from 'node:fs'
 import { beforeAll, beforeEach, describe, onTestFailed } from 'vitest'
 import { expect } from '@playwright/test'
 import { test } from './helper'
@@ -13,6 +13,9 @@ beforeAll(() => {
 beforeEach<{ logPath: string }>(({ logPath }) => {
   onTestFailed(() => {
     console.error(`Log during test:\n${readFileSync(logPath, 'utf-8')}`)
+    if (!process.env.CI) {
+      rmSync(logPath)
+    }
   })
 })
 
@@ -70,6 +73,24 @@ test('custom imba language', async ({ launch }) => {
   await expect(tester.tree.getFileItem('counter.imba')).toHaveState('failed')
 })
 
+test('browser mode correctly collects tests', async ({ launch }) => {
+  const { tester } = await launch({
+    workspacePath: './samples/browser',
+  })
+
+  await tester.tree.expand('test/console.test.ts')
+  const consoleTest = tester.tree.getFileItem('console.test.ts')
+  await consoleTest.navigate()
+
+  await expect(consoleTest).toHaveTests({
+    console: 'waiting',
+  })
+
+  editFile('samples/browser/test/console.test.ts', content => `/arakara---\n${content}`)
+
+  await expect(consoleTest).toHaveError('Error: Unterminated regular expression')
+})
+
 describe('continuous testing', () => {
   test('reruns tests on test file change', async ({ launch }) => {
     const { tester } = await launch({