feat: draft implementation

Author: sheremet-va

packages/runner/src/collect.ts

@@ -1,9 +1,10 @@
+import type { FixtureItem } from './fixture'
 import type { FileSpecification, VitestRunner } from './types/runner'
-import type { File, SuiteHooks } from './types/tasks'
+import type { File, SuiteHooks, Task } from './types/tasks'
 import { toArray } from '@vitest/utils'
 import { processError } from '@vitest/utils/error'
 import { collectorContext } from './context'
-import { getHooks, setHooks } from './map'
+import { getHooks, getTestFixture, setHooks, setTestFixture } from './map'
 import { runSetupFiles } from './setup'
 import {
   clearCollectorContext,
@@ -104,11 +105,36 @@ export async function collectTests(
     }
 
     files.push(file)
+
+    // TODO: any
+    setTestFixture(file.context as any, getFileFixtires(file))
   }
 
   return files
 }
 
+function getFileFixtires(file: File): FixtureItem[] {
+  const fixtures = new Set<FixtureItem>()
+  function traverse(children: Task[]) {
+    for (const child of children) {
+      if (child.type === 'test') {
+        const childFixtures = getTestFixture(child.context) || []
+        for (const fixture of childFixtures) {
+          // TODO: what if overriden?
+          if (fixture.scope === 'file' && !fixtures.has(fixture)) {
+            fixtures.add(fixture)
+          }
+        }
+      }
+      else {
+        traverse(child.tasks)
+      }
+    }
+  }
+  traverse(file.tasks)
+  return Array.from(fixtures)
+}
+
 function mergeHooks(baseHooks: SuiteHooks, hooks: SuiteHooks): SuiteHooks {
   for (const _key in hooks) {
     const key = _key as keyof SuiteHooks

packages/runner/src/fixture.ts

@@ -45,7 +45,7 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
   context: T,
   inject: (key: string) => unknown,
 ): T {
-  const fixtureOptionKeys = ['auto', 'injected']
+  const fixtureOptionKeys = ['auto', 'injected', 'scope']
   const fixtureArray: FixtureItem[] = Object.entries(fixtures).map(
     ([prop, value]) => {
       const fixtureItem = { value } as FixtureItem
@@ -94,11 +94,11 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
 
 const fixtureValueMaps = new Map<TestContext, Map<FixtureItem, any>>()
 const cleanupFnArrayMap = new Map<
-  TestContext,
+  object,
   Array<() => void | Promise<void>>
 >()
 
-export async function callFixtureCleanup(context: TestContext): Promise<void> {
+export async function callFixtureCleanup(context: object): Promise<void> {
   const cleanupFnArray = cleanupFnArrayMap.get(context) ?? []
   for (const cleanup of cleanupFnArray.reverse()) {
     await cleanup()
@@ -153,21 +153,75 @@ export function withFixtures(fn: Function, testContext?: TestContext) {
           continue
         }
 
-        const resolvedValue = fixture.isFn
-          ? await resolveFixtureFunction(fixture.value, context, cleanupFnArray)
-          : fixture.value
+        const resolvedValue = await resolveFixtureValue(
+          fixture,
+          context!,
+          cleanupFnArray,
+        )
         context![fixture.prop] = resolvedValue
         fixtureValueMap.set(fixture, resolvedValue)
-        cleanupFnArray.unshift(() => {
-          fixtureValueMap.delete(fixture)
-        })
+
+        if (!fixture.scope || fixture.scope === 'test') {
+          cleanupFnArray.unshift(() => {
+            fixtureValueMap.delete(fixture)
+          })
+        }
       }
     }
 
     return resolveFixtures().then(() => fn(context))
   }
 }
 
+const fileFixturePromise = new WeakMap<FixtureItem, Promise<unknown>>()
+
+function resolveFixtureValue(
+  fixture: FixtureItem,
+  context: TestContext & { [key: string]: any },
+  cleanupFnArray: (() => void | Promise<void>)[],
+) {
+  if (!fixture.isFn) {
+    return fixture.value
+  }
+
+  if (!fixture.scope || fixture.scope === 'test') {
+    return resolveFixtureFunction(
+      fixture.value,
+      context,
+      cleanupFnArray,
+    )
+  }
+
+  const fileContext = context.task.file.context
+
+  if (fixture.prop in fileContext) {
+    return fileContext[fixture.prop]
+  }
+
+  // in case the test runs in parallel
+  if (fileFixturePromise.has(fixture)) {
+    return fileFixturePromise.get(fixture)!
+  }
+
+  if (!cleanupFnArrayMap.has(fileContext)) {
+    cleanupFnArrayMap.set(fileContext, [])
+  }
+  const cleanupFnFileArray = cleanupFnArrayMap.get(fileContext)!
+
+  const promise = resolveFixtureFunction(
+    fixture.value,
+    fileContext,
+    cleanupFnFileArray,
+  ).then((value) => {
+    fileContext[fixture.prop] = value
+    fileFixturePromise.delete(fixture)
+    return value
+  })
+
+  fileFixturePromise.set(fixture, promise)
+  return promise
+}
+
 async function resolveFixtureFunction(
   fixtureFn: (
     context: unknown,

packages/runner/src/run.ts

@@ -526,6 +526,9 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
     try {
       await callSuiteHook(suite, suite, 'afterAll', runner, [suite])
       await callCleanupHooks(runner, beforeAllCleanups)
+      if (suite.file === suite) {
+        await callFixtureCleanup((suite as File).context)
+      }
     }
     catch (e) {
       failTask(suite.result, e, runner.config.diffOptions)

packages/runner/src/types/tasks.ts

@@ -239,6 +239,8 @@ export interface File extends Suite {
    * @internal
    */
   local?: boolean
+  /** @internal */
+  context: Record<string, unknown>
 }
 
 export interface Test<ExtraContext = object> extends TaskPopulated {
@@ -479,12 +481,21 @@ export type { TestAPI as CustomAPI }
 export interface FixtureOptions {
   /**
    * Whether to automatically set up current fixture, even though it's not being used in tests.
+   * @default false
    */
   auto?: boolean
   /**
    * Indicated if the injected value from the config should be preferred over the fixture value
    */
   injected?: boolean
+  /**
+   * When should the fixture be set up.
+   * - **test**: fixture will be set up before ever test
+   * - **worker**: fixture will be set up once per worker
+   * - **file**: fixture will be set up once per file
+   * @default 'test'
+   */
+  scope?: 'test' | 'worker' | 'file'
 }
 
 export type Use<T> = (value: T) => Promise<void>

packages/runner/src/utils/collect.ts

@@ -192,6 +192,7 @@ export function createFileTask(
     projectName,
     file: undefined!,
     pool,
+    context: Object.create(null),
   }
   file.file = file
   return file