@effect/vitest 4.0.0-beta.1 → 4.0.0-beta.100

package/src/internal/internal.ts

@@ -1,7 +1,8 @@
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 
+import { getCurrentSuite } from "@vitest/runner"
 import * as Cause from "effect/Cause"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
@@ -48,6 +49,44 @@ export const addEqualityTesters = () => {
 /** @internal */
 const testOptions = (timeout?: number | V.TestOptions) => typeof timeout === "number" ? { timeout } : timeout ?? {}
 
+const hookTimeout = (timeout?: Duration.Input) =>
+  timeout === undefined ? undefined : Duration.toMillis(Duration.fromInputUnsafe(timeout))
+
+const makeItProxy = <Methods extends object>(
+  it: V.TestAPI,
+  overrides: Methods
+): Methods & V.TestAPI =>
+  new Proxy(it as Methods & V.TestAPI, {
+    apply(target, thisArg, argArray) {
+      return Reflect.apply(target, thisArg, argArray)
+    },
+    get(target, property, receiver) {
+      if (property in overrides) {
+        return Reflect.get(overrides, property)
+      }
+      // do not bind: binding would strip vitest's static helpers (e.g. `describe.each`)
+      return Reflect.get(target, property, receiver)
+    }
+  })
+
+type CollectedTask = {
+  readonly type: string
+  readonly mode?: string
+  readonly tasks?: ReadonlyArray<CollectedTask>
+}
+
+const collectTasks = (tasks: ReadonlyArray<CollectedTask>, acc: Array<V.TestContext["task"]> = []) => {
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i]
+    if (task.type === "test" && task.mode !== "skip" && task.mode !== "todo") {
+      acc.push(task as V.TestContext["task"])
+    } else if (task.tasks !== undefined) {
+      collectTasks(task.tasks, acc)
+    }
+  }
+  return acc
+}
+
 /** @internal */
 const makeTester = <R>(
   mapEffect: <A, E>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, never>,
@@ -109,10 +148,7 @@ const makeTester = <R>(
     const arbs = fc.record(
       Object.keys(arbitraries).reduce(function(result, key) {
         const arb: any = arbitraries[key]
-        if (Schema.isSchema(arb)) {
-          result[key] = Schema.toArbitrary(arb)
-        }
-        result[key] = arb
+        result[key] = Schema.isSchema(arb) ? Schema.toArbitrary(arb) : arb
         return result
       }, {} as Record<string, fc.Arbitrary<any>>)
     )
@@ -176,7 +212,7 @@ export const layer = <R, E>(
   layer_: Layer.Layer<R, E>,
   options?: {
     readonly memoMap?: Layer.MemoMap
-    readonly timeout?: Duration.DurationInput
+    readonly timeout?: Duration.Input
     readonly excludeTestServices?: boolean
   }
 ): {
@@ -207,9 +243,17 @@ export const layer = <R, E>(
     Effect.cached,
     Effect.runSync
   )
+  let closed = false
+  const closeScope = (ctx?: Vitest.TestContext) => {
+    if (closed) {
+      return Promise.resolve()
+    }
+    closed = true
+    return runPromise(Scope.close(scope, Exit.void), ctx)
+  }
 
   const makeIt = (it: V.TestAPI): Vitest.Vitest.MethodsNonLive<R> =>
-    Object.assign(it, {
+    makeItProxy(it, {
       effect: makeTester<R | Scope.Scope>(
         (effect) =>
           Effect.flatMap(contextEffect, (context) =>
@@ -222,32 +266,60 @@ export const layer = <R, E>(
       prop,
       flakyTest,
       layer<R2, E2>(nestedLayer: Layer.Layer<R2, E2, R>, options?: {
-        readonly timeout?: Duration.DurationInput
+        readonly timeout?: Duration.Input
       }) {
-        return layer(Layer.provideMerge(nestedLayer, withTestEnv), { ...options, memoMap, excludeTestServices })
+        return layer(Layer.provideMerge(nestedLayer, withTestEnv), {
+          ...options,
+          memoMap: Layer.forkMemoMapUnsafe(memoMap),
+          excludeTestServices
+        })
       }
     })
 
   if (args.length === 1) {
-    V.beforeAll(
-      () => runPromise(Effect.asVoid(contextEffect)),
-      options?.timeout ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.timeout)) : undefined
+    const currentSuite = getCurrentSuite()
+    const previousTasks = new Set(currentSuite.tasks)
+
+    args[0](makeIt(V.it))
+
+    const blockTasks = collectTasks(
+      currentSuite.tasks.filter((task) => !previousTasks.has(task)) as ReadonlyArray<CollectedTask>
     )
-    V.afterAll(
-      () => runPromise(Scope.close(scope, Exit.void)),
-      options?.timeout ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.timeout)) : undefined
+    if (blockTasks.length === 0) {
+      V.afterAll(() => closeScope(), hookTimeout(options?.timeout))
+      return
+    }
+
+    const blockTaskSet = new Set(blockTasks)
+    let remaining = blockTasks.length
+
+    V.beforeEach(
+      (ctx) => {
+        if (!blockTaskSet.has(ctx.task)) {
+          return
+        }
+        ctx.onTestFinished(() => {
+          remaining--
+          if (remaining === 0) {
+            return closeScope(ctx)
+          }
+        })
+        return runPromise(Effect.asVoid(contextEffect), ctx)
+      },
+      hookTimeout(options?.timeout)
     )
-    return args[0](makeIt(V.it))
+    V.afterAll(() => closeScope(), hookTimeout(options?.timeout))
+    return
   }
 
   return V.describe(args[0], () => {
     V.beforeAll(
       () => runPromise(Effect.asVoid(contextEffect)),
-      options?.timeout ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.timeout)) : undefined
+      hookTimeout(options?.timeout)
     )
     V.afterAll(
-      () => runPromise(Scope.close(scope, Exit.void)),
-      options?.timeout ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.timeout)) : undefined
+      () => closeScope(),
+      hookTimeout(options?.timeout)
     )
     return args[1](makeIt(V.it))
   })
@@ -256,7 +328,7 @@ export const layer = <R, E>(
 /** @internal */
 export const flakyTest = <A, E, R>(
   self: Effect.Effect<A, E, R | Scope.Scope>,
-  timeout: Duration.DurationInput = Duration.seconds(30)
+  timeout: Duration.Input = Duration.seconds(30)
 ) =>
   pipe(
     self,
@@ -267,8 +339,8 @@ export const flakyTest = <A, E, R>(
         Schedule.recurs(10),
         Schedule.while((_) =>
           Effect.succeed(Duration.isLessThanOrEqualTo(
-            Duration.fromDurationInputUnsafe(_.elapsed),
-            Duration.fromDurationInputUnsafe(timeout)
+            Duration.fromInputUnsafe(_.elapsed),
+            Duration.fromInputUnsafe(timeout)
           ))
         )
       )
@@ -278,7 +350,7 @@ export const flakyTest = <A, E, R>(
 
 /** @internal */
 export const makeMethods = (it: V.TestAPI): Vitest.Vitest.Methods =>
-  Object.assign(it, {
+  makeItProxy(it, {
     effect: makeTester<Scope.Scope>(flow(Effect.scoped, Effect.provide(TestEnv)), it),
     live: makeTester<Scope.Scope>(Effect.scoped, it),
     flakyTest,

package/src/utils.ts

@@ -1,4 +1,12 @@
 /**
+ * Provides assertion helpers used by `@effect/vitest` tests.
+ *
+ * This module defines small assertion functions built on Node's `assert`,
+ * Vitest's instance checks, and Effect's equality support. The helpers cover
+ * basic equality, thrown errors, defined and undefined values, strings, regular
+ * expressions, class instances, `Option`, `Result`, and `Exit`. Most helpers are
+ * synchronous; `throwsAsync` handles rejected promises.
+ *
  * @since 4.0.0
  */
 import type * as Cause from "effect/Cause"
@@ -15,8 +23,9 @@ import { assert as vassert } from "vitest"
 // ----------------------------
 
 /**
- * Throws an `AssertionError` with the provided error message.
+ * Fails the current test with the provided error message.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function fail(message: string) {
@@ -24,35 +33,39 @@ export function fail(message: string) {
 }
 
 /**
- * Asserts that `actual` is equal to `expected` using the `Equal.equals` trait.
+ * Asserts that `actual` is deeply strictly equal to `expected` using Node's `assert.deepStrictEqual`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function deepStrictEqual<A>(actual: A, expected: A, message?: string, ..._: Array<never>) {
-  assert.deepStrictEqual(actual, expected, message)
+  assert.deepStrictEqual(actual, expected, message as string)
 }
 
 /**
- * Asserts that `actual` is not equal to `expected` using the `Equal.equals` trait.
+ * Asserts that `actual` is not deeply strictly equal to `expected` using Node's `assert.notDeepStrictEqual`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function notDeepStrictEqual<A>(actual: A, expected: A, message?: string, ..._: Array<never>) {
-  assert.notDeepStrictEqual(actual, expected, message)
+  assert.notDeepStrictEqual(actual, expected, message as string)
 }
 
 /**
- * Asserts that `actual` is equal to `expected` using the `Equal.equals` trait.
+ * Asserts that `actual` is strictly equal to `expected` using Node's `assert.strictEqual`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function strictEqual<A>(actual: A, expected: A, message?: string, ..._: Array<never>) {
-  assert.strictEqual(actual, expected, message)
+  assert.strictEqual(actual, expected, message as string)
 }
 
 /**
  * Asserts that `actual` is equal to `expected` using the `Equal.equals` trait.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertEquals<A>(actual: A, expected: A, message?: string, ..._: Array<never>) {
@@ -65,6 +78,7 @@ export function assertEquals<A>(actual: A, expected: A, message?: string, ..._:
 /**
  * Asserts that `thunk` does not throw an error.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function doesNotThrow(thunk: () => void, message?: string, ..._: Array<never>) {
@@ -78,6 +92,7 @@ export function doesNotThrow(thunk: () => void, message?: string, ..._: Array<ne
 /**
  * Asserts that `value` is an instance of `constructor`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertInstanceOf<C extends abstract new(...args: any) => any>(
@@ -92,6 +107,7 @@ export function assertInstanceOf<C extends abstract new(...args: any) => any>(
 /**
  * Asserts that `self` is `true`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertTrue(self: unknown, message?: string, ..._: Array<never>): asserts self {
@@ -101,6 +117,7 @@ export function assertTrue(self: unknown, message?: string, ..._: Array<never>):
 /**
  * Asserts that `self` is `false`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertFalse(self: boolean, message?: string, ..._: Array<never>) {
@@ -110,6 +127,7 @@ export function assertFalse(self: boolean, message?: string, ..._: Array<never>)
 /**
  * Asserts that `actual` includes `expected`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertInclude(actual: string | undefined, expected: string, ..._: Array<never>) {
@@ -123,6 +141,7 @@ export function assertInclude(actual: string | undefined, expected: string, ..._
 /**
  * Asserts that `actual` matches `regExp`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertMatch(actual: string, regExp: RegExp, ..._: Array<never>) {
@@ -132,8 +151,9 @@ export function assertMatch(actual: string, regExp: RegExp, ..._: Array<never>)
 }
 
 /**
- * Asserts that `thunk` throws an error.
+ * Asserts that `thunk` throws, optionally checking the thrown value against an expected `Error` or validation function.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function throws(thunk: () => void, error?: Error | ((u: unknown) => undefined), ..._: Array<never>) {
@@ -144,16 +164,19 @@ export function throws(thunk: () => void, error?: Error | ((u: unknown) => undef
     if (error !== undefined) {
       if (Predicate.isFunction(error)) {
         error(e)
-      } else {
+      } else if (error) {
         deepStrictEqual(e, error)
+      } else {
+        throw e
       }
     }
   }
 }
 
 /**
- * Asserts that `thunk` throws an error.
+ * Asserts that `thunk` throws or returns a rejected promise, optionally checking the failure value against an expected `Error` or validation function.
  *
+ * @category testing
  * @since 4.0.0
  */
 export async function throwsAsync(
@@ -182,6 +205,7 @@ export async function throwsAsync(
 /**
  * Asserts that `option` is `None`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertNone<A>(option: Option.Option<A>, ..._: Array<never>): asserts option is Option.None<never> {
@@ -191,6 +215,7 @@ export function assertNone<A>(option: Option.Option<A>, ..._: Array<never>): ass
 /**
  * Asserts that `a` is not `undefined`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertDefined<A>(
@@ -205,6 +230,7 @@ export function assertDefined<A>(
 /**
  * Asserts that `a` is `undefined`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertUndefined<A>(
@@ -217,8 +243,9 @@ export function assertUndefined<A>(
 }
 
 /**
- * Asserts that `option` is `Some`.
+ * Asserts that `option` is `Some` and contains a value equal to `expected`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertSome<A>(
@@ -234,8 +261,9 @@ export function assertSome<A>(
 // ----------------------------
 
 /**
- * Asserts that `result` is `Success`.
+ * Asserts that `result` is `Success` and contains a value equal to `expected`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertSuccess<A, E>(
@@ -247,8 +275,9 @@ export function assertSuccess<A, E>(
 }
 
 /**
- * Asserts that `result` is `Failure`.
+ * Asserts that `result` is `Failure` and contains an error equal to `expected`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertFailure<A, E>(
@@ -264,8 +293,9 @@ export function assertFailure<A, E>(
 // ----------------------------
 
 /**
- * Asserts that `exit` is a failure.
+ * Asserts that `exit` is a failure with a cause equal to `expected`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertExitFailure<A, E>(
@@ -277,8 +307,9 @@ export function assertExitFailure<A, E>(
 }
 
 /**
- * Asserts that `exit` is a success.
+ * Asserts that `exit` is a success with a value equal to `expected`.
  *
+ * @category testing
  * @since 4.0.0
  */
 export function assertExitSuccess<A, E>(