fix(tests): fix all failing tests

1. Remove `/\\.` from `vitest.config.ts`. This was necessary to fix the error `No test files found`. This can also be fixed by updating Vitest to version 4, but this has a change to how snapshots are stored. See [the migration guide](https://vitest.dev/guide/migration.html#changes-to-mocking). All of the tests are found by removing `/\\.`, so the Vitest upgrade is better in a later PR.
1. Inlined `z` in `vitest.config.ts` to spy on `parse()` from `zod/v4/core`. Without this, a `TypeError: Cannot redefine property: parse` error occurs.
1. Change `bun test` to `bun run test` in CONTRIBUTING.md. `bun test` runs Bun's native test runner, not the `test` script.
1. Add `Test` stage to `.github/workflows/main.yml`. It was removed in [this PR](react-hook-form#699) and the tests haven't been running in CI.
1. Fix failing tests

Notes:

1. All
    * Fixed tests that called `useForm` outside of a component. This fixed the errors `Error: Invalid hook call. Hooks can only be called inside of the body of a function component.` and `TypeError: Cannot read properties of null (reading 'useRef')`.
1. Arktype
    * [This PR](react-hook-form#753) changed from directly calling Arktype to using standard schema. Part of this transition was changing `type: error.code` to `type: ''` (because `error.code` is not part of the standard schema). This required an update to the snapshot.
1. Superstruct
    * Fix validation of schemas that perform coercion (`{ coerce: true }` must be passed in)
    * Added additional overload for type definition `superstructResolver` that improves handling of coerced schemas (This fixes a type error with the form values).
    * Fix definition of coercion schema so that it correctly converts from number to string
    * As mentioned in [this issue](ianstormtaylor/superstruct#1159), there is no way to infer the input type of a coerced schema. A [separate PR](ianstormtaylor/superstruct#1181) would be necessary. Some of the type inference tests have been changed to manually provide the input type (this enables `watch` to return the correct value for a coerced schema).
1. Typeschema
    * The `for` loop was looping through the `schemaErrors` variable, but the current error was based on the `typeschemaErrors[0]` variable. This caused only the first error to be returned.
    * Change from spying on `typeschema.validate` to watching `schema["~standard"]`
1. Zod
    * Fixed Zod tests that spied on `schema.parse()` instead of `z4.parse()`
    * Added missing snapshots

Author: BrendanC23

.github/workflows/main.yml

@@ -28,6 +28,9 @@ jobs:
 
       - name: Lint
         run: bun lint
+      
+      - name: Test
+        run: bun run test
 
       - name: TS
         run: bun lint:types

CONTRIBUTING.md

@@ -16,7 +16,7 @@ Here is a quick guide to doing code contributions to the library.
 
 4. If you've added a code that should be tested, ensure the test suite still passes.
 
-   > bun test
+   > bun run test
 
 5. Try to write some unit tests to cover as much of your code as possible.
 

arktype/src/__tests__/__snapshots__/arktype.ts.snap

@@ -6,41 +6,41 @@ exports[`arktypeResolver > should return a single error from arktypeResolver whe
     "accessToken": {
       "message": "accessToken must be a number or a string (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "birthYear": {
       "message": "birthYear must be a number (was a string)",
       "ref": undefined,
-      "type": "domain",
+      "type": "",
     },
     "dateStr": {
       "message": "dateStr must be a Date (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "email": {
       "message": "email must be an email address (was "")",
       "ref": {
         "name": "email",
       },
-      "type": "pattern",
+      "type": "",
     },
     "enabled": {
       "message": "enabled must be boolean (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "like": [
       {
         "id": {
           "message": "like[0].id must be a number (was a string)",
           "ref": undefined,
-          "type": "domain",
+          "type": "",
         },
         "name": {
           "message": "like[0].name must be a string (was missing)",
           "ref": undefined,
-          "type": "required",
+          "type": "",
         },
       },
     ],
@@ -49,24 +49,24 @@ exports[`arktypeResolver > should return a single error from arktypeResolver whe
       "ref": {
         "name": "password",
       },
-      "type": "union",
+      "type": "",
     },
     "repeatPassword": {
       "message": "repeatPassword must be a string (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "tags": {
       "message": "tags must be an array (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "username": {
       "message": "username must be a string (was missing)",
       "ref": {
         "name": "username",
       },
-      "type": "required",
+      "type": "",
     },
   },
   "values": {},

arktype/src/__tests__/arktype.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { type } from 'arktype';
 import { Resolver, useForm } from 'react-hook-form';
 import { SubmitHandler } from 'react-hook-form';
@@ -51,9 +52,13 @@ describe('arktypeResolver', () => {
   it('should correctly infer the output type from a arktype schema for the handleSubmit function in useForm', () => {
     const schema = type({ id: 'number' });
 
-    const form = useForm({
-      resolver: arktypeResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: arktypeResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -67,9 +72,13 @@ describe('arktypeResolver', () => {
   it('should correctly infer the output type from a arktype schema with a transform for the handleSubmit function in useForm', () => {
     const schema = type({ id: type('string').pipe((s) => Number.parseInt(s)) });
 
-    const form = useForm({
-      resolver: arktypeResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: arktypeResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<string>();
 

bun.lock

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import Schema, { number } from 'computed-types';
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
 import { computedTypesResolver } from '..';
@@ -65,9 +66,13 @@ describe('computedTypesResolver', () => {
   it('should correctly infer the output type from a computedTypes schema for the handleSubmit function in useForm', () => {
     const schema = Schema({ id: number });
 
-    const form = useForm({
-      resolver: computedTypesResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: computedTypesResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -81,9 +86,13 @@ describe('computedTypesResolver', () => {
   it('should correctly infer the output type from a computedTypes schema with a transform for the handleSubmit function in useForm', () => {
     const schema = Schema({ id: number.transform((val) => String(val)) });
 
-    const form = useForm({
-      resolver: computedTypesResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: computedTypesResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 

computed-types/src/__tests__/computed-types.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { Schema } from 'effect';
 import { Resolver, useForm } from 'react-hook-form';
 import { SubmitHandler } from 'react-hook-form';
@@ -114,9 +115,13 @@ describe('effectTsResolver', () => {
   it('should correctly infer the output type from a effectTs schema for the handleSubmit function in useForm', () => {
     const schema = Schema.Struct({ id: Schema.Number });
 
-    const form = useForm({
-      resolver: effectTsResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: effectTsResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -133,9 +138,13 @@ describe('effectTsResolver', () => {
       }),
     });
 
-    const form = useForm({
-      resolver: effectTsResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: effectTsResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 

effect-ts/src/__tests__/effect-ts.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import * as t from 'io-ts';
 import * as tt from 'io-ts-types';
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
@@ -60,9 +61,13 @@ describe('ioTsResolver', () => {
   it('should correctly infer the output type from a io-ts schema for the handleSubmit function in useForm', () => {
     const schema = t.type({ id: t.number });
 
-    const form = useForm({
-      resolver: ioTsResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: ioTsResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -76,9 +81,13 @@ describe('ioTsResolver', () => {
   it('should correctly infer the output type from a io-ts schema with a transform for the handleSubmit function in useForm', () => {
     const schema = t.type({ id: tt.NumberFromString });
 
-    const form = useForm({
-      resolver: ioTsResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: ioTsResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<string>();
 

io-ts/src/__tests__/io-ts.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
 import { z } from 'zod/v3';
 import { standardSchemaResolver } from '..';
@@ -113,13 +114,16 @@ describe('standardSchemaResolver', () => {
 
   it('should correctly infer the output type from a standardSchema schema for the handleSubmit function in useForm', () => {
     const schema = z.object({ id: z.number() });
-
-    const form = useForm({
-      resolver: standardSchemaResolver(schema),
-      defaultValues: {
-        id: 3,
-      },
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: standardSchemaResolver(schema),
+        defaultValues: {
+          id: 3,
+        },
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -133,12 +137,16 @@ describe('standardSchemaResolver', () => {
   it('should correctly infer the output type from a standardSchema schema with a transform for the handleSubmit function in useForm', () => {
     const schema = z.object({ id: z.number().transform((val) => String(val)) });
 
-    const form = useForm({
-      resolver: standardSchemaResolver(schema),
-      defaultValues: {
-        id: 3,
-      },
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: standardSchemaResolver(schema),
+        defaultValues: {
+          id: 3,
+        },
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 

standard-schema/src/__tests__/standard-schema.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
 import * as s from 'superstruct';
 import { superstructResolver } from '..';
@@ -18,8 +19,9 @@ describe('superstructResolver', () => {
   it('should return values from superstructResolver with coerced values', async () => {
     const result = await superstructResolver(
       s.object({
-        id: s.coerce(s.number(), s.string(), (val) => String(val)),
+        id: s.coerce(s.string(), s.number(), (val) => String(val)),
       }),
+      { coerce: true },
     )({ id: 1 }, undefined, {
       fields,
       shouldUseNativeValidation,
@@ -64,9 +66,13 @@ describe('superstructResolver', () => {
   it('should correctly infer the output type from a superstruct schema for the handleSubmit function in useForm', () => {
     const schema = s.object({ id: s.number() });
 
-    const form = useForm({
-      resolver: superstructResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: superstructResolver(schema, {}),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -82,11 +88,19 @@ describe('superstructResolver', () => {
       id: s.coerce(s.string(), s.number(), (val) => String(val)),
     });
 
-    const form = useForm({
-      resolver: superstructResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        // With coerce, there is no way to infer the input type of the schema
+        resolver: superstructResolver<{ id: number }, unknown, { id: string }>(
+          schema,
+          { coerce: true },
+        ),
+      }),
+    );
 
-    expectTypeOf(form.watch('id')).toEqualTypeOf<string>();
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
     expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
       SubmitHandler<{