fix: support accessing fixture at same index of dependency fixture (#4387)

Author: dsyddall

Diff for: packages/runner/src/fixture.ts

@@ -37,7 +37,7 @@ export function mergeContextFixtures(fixtures: Record<string, any>, context: { f
     if (fixture.isFn) {
       const usedProps = getUsedProps(fixture.value)
       if (usedProps.length)
-        fixture.deps = context.fixtures!.filter(({ index, prop }) => index !== fixture.index && usedProps.includes(prop))
+        fixture.deps = context.fixtures!.filter(({ prop }) => prop !== fixture.prop && usedProps.includes(prop))
     }
   })
 

Diff for: packages/runner/src/types/tasks.ts

@@ -200,28 +200,15 @@ export type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & Extend
       K extends keyof ExtraContext ? ExtraContext[K] : never }>
 }
 
-type FixtureType<T> = T extends (context: any, use: (fixture: infer F) => any) => any ? F : T
-export type Fixture<
-  T,
-  K extends keyof T,
-  OnlyFunction,
-  ExtraContext = {},
-  V = FixtureType<T[K]>,
-  FN = (
-    context: {
-      [P in keyof T | keyof ExtraContext as P extends K ?
-        P extends keyof ExtraContext ? P : never : P
-      ]:
-      K extends P ? K extends keyof ExtraContext ? ExtraContext[K] : V :
-        P extends keyof T ? T[P] : never
-    } & TestContext,
-    use: (fixture: V) => Promise<void>
-  ) => Promise<void>,
-> = OnlyFunction extends true ? FN : (FN | V)
+export type Use<T> = (value: T) => Promise<void>
+export type FixtureFn<T, K extends keyof T, ExtraContext> =
+  (context: Omit<T, K> & ExtraContext, use: Use<T[K]>) => Promise<void>
+export type Fixture<T, K extends keyof T, ExtraContext = {}> =
+  ((...args: any) => any) extends T[K]
+    ? (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never)
+    : T[K] | (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never)
 export type Fixtures<T extends Record<string, any>, ExtraContext = {}> = {
-  [K in keyof T]: Fixture<T, K, false, ExtraContext>
-} | {
-  [K in keyof T]: Fixture<T, K, true, ExtraContext>
+  [K in keyof T]: Fixture<T, K, ExtraContext & ExtendedContext<Test>>
 }
 
 export type InferFixturesTypes<T> = T extends TestAPI<infer C> ? C : T

Diff for: test/core/test/fixture-initialization.test.ts

@@ -1,3 +1,4 @@
+import type { Use } from '@vitest/runner'
 import { describe, expect, expectTypeOf, test, vi } from 'vitest'
 
 interface Fixtures {
@@ -127,4 +128,20 @@ describe('fixture initialization', () => {
       expect(fnD).toBeCalledTimes(1)
     })
   })
+
+  describe('fixture dependency', () => {
+    const myTest = test
+      .extend({ a: 1 })
+      .extend({
+        b: async ({ a }, use: Use<number>) => {
+          expectTypeOf(a).toEqualTypeOf<number>()
+          await use(a * 2)
+        },
+      })
+
+    myTest('b => a', ({ b }) => {
+      expectTypeOf(b).toEqualTypeOf<number>()
+      expect(b).toBe(2)
+    })
+  })
 })

Diff for: test/core/test/test-extend.test.ts

@@ -47,6 +47,7 @@ describe('test.extend()', () => {
       string: string
       any: any
       boolean: boolean
+      func: (a: number, b: string) => void
     }
 
     const typesTest = test.extend<TypesContext>({
@@ -59,6 +60,9 @@ describe('test.extend()', () => {
         await use({})
       },
       boolean: true,
+      func: async ({}, use): Promise<void> => {
+        await use(() => undefined)
+      },
     })
 
     expectTypeOf(typesTest).toEqualTypeOf<TestAPI<InferFixturesTypes<typeof typesTest>>>()