Function resolveTestRunner

packages/vitest/src/runtime/runners/index.ts:32–156

(
  config: SerializedConfig,
  moduleRunner: TestModuleRunner,
  traces: Traces,
)

}

export async function resolveTestRunner(
  config: SerializedConfig,
  moduleRunner: TestModuleRunner,
  traces: Traces,
): Promise<VitestRunner> {
  const TestRunner = await getTestRunnerConstructor(config, moduleRunner)
  const testRunner = new TestRunner(config)

  // inject private executor to every runner
  Object.defineProperty(testRunner, 'moduleRunner', {
    value: moduleRunner,
    enumerable: false,
    configurable: false,
  })

  if (!testRunner.config) {
    testRunner.config = config
  }

  if (!testRunner.importFile) {
    throw new Error('Runner must implement "importFile" method.')
  }

  if ('__setTraces' in testRunner) {
    (testRunner.__setTraces as any)(traces)
  }

  const [diffOptions] = await Promise.all([
    loadDiffConfig(config, moduleRunner),
    loadSnapshotSerializers(config, moduleRunner),
  ])
  testRunner.config.diffOptions = diffOptions

  // patch some methods, so custom runners don't need to call RPC
  const originalOnTaskUpdate = testRunner.onTaskUpdate
  testRunner.onTaskUpdate = async (task, events) => {
    const p = rpc().onTaskUpdate(task, events)
    await originalOnTaskUpdate?.call(testRunner, task, events)
    return p
  }

  // patch some methods, so custom runners don't need to call RPC
  const originalOnTestAnnotate = testRunner.onTestAnnotate
  testRunner.onTestAnnotate = async (test, annotation) => {
    const p = rpc().onTaskArtifactRecord(test.id, { type: 'internal:annotation', location: annotation.location, annotation })
    const overriddenResult = await originalOnTestAnnotate?.call(testRunner, test, annotation)
    const vitestResult = await p
    return overriddenResult || vitestResult.annotation
  }

  const originalOnTestArtifactRecord = testRunner.onTestArtifactRecord
  testRunner.onTestArtifactRecord = async (test, artifact) => {
    const p = rpc().onTaskArtifactRecord(test.id, artifact)
    const overriddenResult = await originalOnTestArtifactRecord?.call(testRunner, test, artifact)
    const vitestResult = await p
    return overriddenResult as typeof artifact || vitestResult
  }