Vitest prop testing

.changeset/young-boxes-reflect.md

@@ -0,0 +1,31 @@
+---
+"@effect/vitest": patch
+---
+
+Adds property testing to @effect/vitest
+
+```ts
+import { Schema } from "effect"
+import { it } from "@effect/vitest"
+
+const realNumber = Schema.Finite.pipe(Schema.nonNaN())
+
+it.prop("symmetry", [realNumber, realNumber], ([a, b]) => a + b === b + a)
+
+it.effect.prop("symmetry", [realNumber, realNumber], ([a, b]) =>
+  Effect.gen(function* () {
+    yield* Effect.void
+    return a + b === b + a
+  })
+)
+
+it.scoped.prop(
+  "should detect the substring",
+  { a: Schema.String, b: Schema.String, c: Schema.String },
+  ({ a, b, c }) =>
+    Effect.gen(function* () {
+      yield* Effect.scope
+      return (a + b + c).includes(b)
+    })
+)
+```

packages/vitest/src/index.ts

@@ -4,6 +4,7 @@
 import type * as Duration from "effect/Duration"
 import type * as Effect from "effect/Effect"
 import type * as Layer from "effect/Layer"
+import type * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import type * as TestServices from "effect/TestServices"
 import * as V from "vitest"
@@ -36,6 +37,11 @@ export namespace Vitest {
     ): void
   }
 
+  /**
+   * @since 1.0.0
+   */
+  export type SchemaObj = Array<Schema.Schema.Any> | { [K in string]: Schema.Schema.Any }
+
   /**
    * @since 1.0.0
    */
@@ -47,6 +53,21 @@ export namespace Vitest {
     each: <T>(
       cases: ReadonlyArray<T>
     ) => <A, E>(name: string, self: TestFunction<A, E, R, Array<T>>, timeout?: number | V.TestOptions) => void
+
+    /**
+     * @since 1.0.0
+     */
+    prop: <const S extends SchemaObj, A, E>(
+      name: string,
+      schemas: S,
+      self: TestFunction<
+        A,
+        E,
+        R,
+        [{ [K in keyof S]: Schema.Schema.Type<S[K]> }, V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext]
+      >,
+      timeout?: number | V.TestOptions
+    ) => void
   }
 
   /**
@@ -67,6 +88,19 @@ export namespace Vitest {
       (f: (it: Vitest.Methods<R | R2>) => void): void
       (name: string, f: (it: Vitest.Methods<R | R2>) => void): void
     }
+
+    /**
+     * @since 1.0.0
+     */
+    readonly prop: <const S extends SchemaObj>(
+      name: string,
+      schemas: S,
+      self: (
+        schemas: { [K in keyof S]: Schema.Schema.Type<S[K]> },
+        ctx: V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext
+      ) => void,
+      timeout?: number | V.TestOptions
+    ) => void
   }
 }
 
@@ -151,8 +185,25 @@ export const flakyTest: <A, E, R>(
   timeout?: Duration.DurationInput
 ) => Effect.Effect<A, never, R> = internal.flakyTest
 
+/**
+ * @since 1.0.0
+ */
+export const prop: <const S extends Vitest.SchemaObj>(
+  name: string,
+  schemas: S,
+  self: (
+    schemas: { [K in keyof S]: Schema.Schema.Type<S[K]> },
+    ctx: V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext
+  ) => void,
+  timeout?: number | V.TestOptions
+) => void = internal.prop
+
+/**
+ * @since 1.0.0
+ */
+
 /** @ignored */
-const methods = { effect, live, flakyTest, scoped, scopedLive, layer } as const
+const methods = { effect, live, flakyTest, scoped, scopedLive, layer, prop } as const
 
 /**
  * @since 1.0.0

packages/vitest/src/internal.ts

@@ -2,6 +2,7 @@
  * @since 1.0.0
  */
 import type { Tester, TesterContext } from "@vitest/expect"
+import * as Arbitrary from "effect/Arbitrary"
 import * as Cause from "effect/Cause"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
@@ -16,6 +17,7 @@ import * as Scope from "effect/Scope"
 import * as TestEnvironment from "effect/TestContext"
 import type * as TestServices from "effect/TestServices"
 import * as Utils from "effect/Utils"
+import fc from "fast-check"
 import * as V from "vitest"
 import type * as Vitest from "./index.js"
 
@@ -45,8 +47,7 @@ const runPromise = (ctx?: Vitest.TaskContext) => <E, A>(effect: Effect.Effect<A,
   }).pipe(Effect.runPromise).then((f) => f())
 
 /** @internal */
-const runTest = (ctx?: Vitest.TaskContext) => <E, A>(effect: Effect.Effect<A, E>) =>
-  runPromise(ctx)(Effect.asVoid(effect))
+const runTest = (ctx?: Vitest.TaskContext) => <E, A>(effect: Effect.Effect<A, E>) => runPromise(ctx)(effect)
 
 /** @internal */
 const TestEnv = TestEnvironment.TestContext.pipe(
@@ -93,10 +94,62 @@ const makeTester = <R>(
     V.it.for(cases)(
       name,
       typeof timeout === "number" ? { timeout } : timeout ?? {},
-      (args, ctx) => run(ctx, [args], self)
+      (args, ctx) => run(ctx, [args], self) as any
     )
 
-  return Object.assign(f, { skip, skipIf, runIf, only, each })
+  const prop: Vitest.Vitest.Tester<R>["prop"] = (name, schemaObj, self, timeout) => {
+    if (Array.isArray(schemaObj)) {
+      const arbs = schemaObj.map((schema) => Arbitrary.make(schema))
+      return V.it(
+        name,
+        // @ts-ignore
+        (ctx) => fc.assert(fc.asyncProperty(...arbs, (...as) => run(ctx, [as as any, ctx], self))),
+        timeout
+      )
+    }
+
+    const arbs = fc.record(
+      Object.keys(schemaObj).reduce(function(result, key) {
+        result[key] = Arbitrary.make(schemaObj[key])
+        return result
+      }, {} as Record<string, fc.Arbitrary<any>>)
+    )
+
+    return V.it(
+      name,
+      // @ts-ignore
+      (ctx) => fc.assert(fc.asyncProperty(arbs, (...as) => run(ctx, [as[0] as any, ctx], self))),
+      timeout
+    )
+  }
+
+  return Object.assign(f, { skip, skipIf, runIf, only, each, prop })
+}
+
+export const prop: Vitest.Vitest.Methods["prop"] = (name, schemaObj, self, timeout) => {
+  if (Array.isArray(schemaObj)) {
+    const arbs = schemaObj.map((schema) => Arbitrary.make(schema))
+    return V.it(
+      name,
+      // @ts-ignore
+      (ctx) => fc.assert(fc.property(...arbs, (...as) => self(as, ctx))),
+      timeout
+    )
+  }
+
+  const arbs = fc.record(
+    Object.keys(schemaObj).reduce(function(result, key) {
+      result[key] = Arbitrary.make(schemaObj[key])
+      return result
+    }, {} as Record<string, fc.Arbitrary<any>>)
+  )
+
+  return V.it(
+    name,
+    // @ts-ignore
+    (ctx) => fc.assert(fc.property(arbs, (...as) => self(as[0], ctx))),
+    timeout
+  )
 }
 
 /** @internal */
@@ -127,6 +180,9 @@ export const layer = <R, E>(layer_: Layer.Layer<R, E>, options?: {
           Effect.provide(TestEnv)
         ))
     ),
+
+    prop,
+
     scoped: makeTester<TestServices.TestServices | Scope.Scope | R>((effect) =>
       Effect.flatMap(runtimeEffect, (runtime) =>
         effect.pipe(

packages/vitest/test/index.test.ts

@@ -1,5 +1,5 @@
 import { afterAll, describe, expect, it, layer } from "@effect/vitest"
-import { Context, Effect, Layer } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
 
 it.live(
   "live %s",
@@ -146,5 +146,34 @@ layer(Foo.Live)("layer", (it) => {
           expect(scoped).toEqual("scoped")
         }))
     })
+
+    it.effect.prop("adds context", [Schema.Number], ([num]) =>
+      Effect.gen(function*() {
+        const foo = yield* Foo
+        expect(foo).toEqual("foo")
+        return num === num
+      }))
   })
 })
+
+// property testing
+
+const realNumber = Schema.Finite.pipe(Schema.nonNaN())
+
+it.prop("symmetry", [realNumber, realNumber], ([a, b]) => a + b === b + a)
+
+it.effect.prop("symmetry", [realNumber, realNumber], ([a, b]) =>
+  Effect.gen(function*() {
+    yield* Effect.void
+    return a + b === b + a
+  }))
+
+it.scoped.prop(
+  "should detect the substring",
+  { a: Schema.String, b: Schema.String, c: Schema.String },
+  ({ a, b, c }) =>
+    Effect.gen(function*() {
+      yield* Effect.scope
+      return (a + b + c).includes(b)
+    })
+)