| import React, { useState } from 'react'; |
| import { |
| act, |
| fireEvent, |
| render, |
| renderHook, |
| screen, |
| waitFor, |
| waitForElementToBeRemoved, |
| } from '@testing-library/react'; |
|
|
| import { VALIDATION_MODE } from '../constants'; |
| import type { |
| Control, |
| FieldErrors, |
| FieldValues, |
| FormState, |
| Mode, |
| RegisterOptions, |
| SubmitHandler, |
| UseFormGetFieldState, |
| UseFormRegister, |
| UseFormReturn, |
| UseFormUnregister, |
| } from '../types'; |
| import isFunction from '../utils/isFunction'; |
| import noop from '../utils/noop'; |
| import sleep from '../utils/sleep'; |
| import { Controller, createFormControl, useFieldArray, useForm } from '../'; |
|
|
| jest.useFakeTimers(); |
|
|
| describe('useForm', () => { |
| describe('when component unMount', () => { |
| it('should call unSubscribe', () => { |
| const { result, unmount } = renderHook(() => useForm<{ test: string }>()); |
|
|
| result.current.register('test'); |
| unmount(); |
|
|
| expect(result.current.getValues()).toEqual({}); |
| }); |
|
|
| it('should remain array field values when inputs gets unmounted', () => { |
| const { result, unmount } = renderHook(() => |
| useForm<{ test: string[] }>(), |
| ); |
|
|
| result.current.register('test.0'); |
| result.current.register('test.1'); |
| result.current.register('test.2'); |
|
|
| unmount(); |
|
|
| expect(result.current.getValues()).toEqual({ |
| test: [undefined, undefined, undefined], |
| }); |
| }); |
|
|
| it('should not unregister errors when unmounted', async () => { |
| const { result, unmount } = renderHook(() => |
| useForm<{ |
| test: string; |
| }>(), |
| ); |
|
|
| result.current.formState.errors; |
| result.current.register('test', { required: true }); |
|
|
| await act(async () => { |
| await result.current.handleSubmit(noop)({ |
| preventDefault: noop, |
| persist: noop, |
| } as React.SyntheticEvent); |
| }); |
|
|
| expect(result.current.formState.errors.test).toBeDefined(); |
|
|
| unmount(); |
|
|
| expect(result.current.formState.errors.test).toBeDefined(); |
| }); |
|
|
| it('should only unregister errors when unregister method invoked', async () => { |
| const { result } = renderHook(() => |
| useForm<{ |
| test: string; |
| }>(), |
| ); |
|
|
| result.current.formState.errors; |
| result.current.register('test', { required: true }); |
|
|
| await act(async () => { |
| await result.current.handleSubmit(noop)({ |
| preventDefault: noop, |
| persist: noop, |
| } as React.SyntheticEvent); |
| }); |
|
|
| expect(result.current.formState.errors.test).toBeDefined(); |
|
|
| await act(async () => { |
| result.current.unregister('test'); |
| }); |
|
|
| expect(result.current.formState.errors.test).not.toBeDefined(); |
| }); |
|
|
| it('should not unregister touched', () => { |
| let formState: any; |
| const Component = () => { |
| const { register, formState: tempFormState } = useForm<{ |
| test: string; |
| }>(); |
| formState = tempFormState; |
|
|
| formState.touchedFields; |
|
|
| return ( |
| <div> |
| <input {...register('test', { required: true })} /> |
| </div> |
| ); |
| }; |
| const { unmount } = render(<Component />); |
|
|
| fireEvent.blur(screen.getByRole('textbox'), { |
| target: { |
| value: 'test', |
| }, |
| }); |
|
|
| expect(formState.touchedFields.test).toBeDefined(); |
| expect(formState.isDirty).toBeFalsy(); |
|
|
| unmount(); |
|
|
| expect(formState.touchedFields.test).toBeDefined(); |
| expect(formState.isDirty).toBeFalsy(); |
| }); |
|
|
| it('should update dirtyFields during unregister', () => { |
| let formState: any; |
| const Component = () => { |
| const { register, formState: tempFormState } = useForm<{ |
| test: string; |
| }>(); |
| formState = tempFormState; |
|
|
| formState.isDirty; |
| formState.dirtyFields; |
|
|
| return <input {...register('test', { required: true })} />; |
| }; |
| const { unmount } = render(<Component />); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { |
| value: 'test', |
| }, |
| }); |
|
|
| expect(formState.dirtyFields.test).toBeDefined(); |
| expect(formState.isDirty).toBeTruthy(); |
|
|
| unmount(); |
|
|
| expect(formState.dirtyFields.test).toBeDefined(); |
| expect(formState.isDirty).toBeTruthy(); |
| }); |
|
|
| it('should only validate input which are mounted even with shouldUnregister: false', async () => { |
| const Component = () => { |
| const [show, setShow] = React.useState(true); |
| const { |
| handleSubmit, |
| register, |
| formState: { errors }, |
| } = useForm<{ |
| firstName: string; |
| lastName: string; |
| }>(); |
|
|
| return ( |
| <form onSubmit={handleSubmit(noop)}> |
| {show && <input {...register('firstName', { required: true })} />} |
| {errors.firstName && <p>First name is required.</p>} |
| |
| <input {...register('lastName', { required: true })} /> |
| {errors.lastName && <p>Last name is required.</p>} |
| |
| <button type={'button'} onClick={() => setShow(!show)}> |
| toggle |
| </button> |
| <button type={'submit'}>submit</button> |
| </form> |
| ); |
| }; |
|
|
| render(<Component />); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
| expect(await screen.findByText('First name is required.')).toBeVisible(); |
| expect(screen.getByText('Last name is required.')).toBeVisible(); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'toggle' })); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
| expect(screen.getByText('Last name is required.')).toBeVisible(); |
|
|
| await waitForElementToBeRemoved( |
| screen.queryByText('First name is required.'), |
| ); |
| }); |
| }); |
|
|
| describe('when shouldUnregister set to true', () => { |
| describe('with useFieldArray', () => { |
| type FormValues = { |
| test: string; |
| test1: string; |
| test2: { |
| value: string; |
| }[]; |
| }; |
|
|
| const Child = ({ |
| control, |
| register, |
| }: { |
| control: Control<FormValues>; |
| register: UseFormRegister<FormValues>; |
| }) => { |
| const { fields } = useFieldArray({ |
| control, |
| name: 'test2', |
| shouldUnregister: true, |
| }); |
|
|
| return ( |
| <> |
| {fields.map((field, i) => ( |
| <input |
| key={field.id} |
| {...register(`test2.${i}.value` as const)} |
| /> |
| ))} |
| </> |
| ); |
| }; |
|
|
| it('should remove and unregister inputs when inputs gets unmounted', async () => { |
| let submittedData: FormValues; |
|
|
| const Component = () => { |
| const [show, setShow] = React.useState(true); |
| const { register, handleSubmit, control } = useForm<FormValues>({ |
| shouldUnregister: true, |
| defaultValues: { |
| test: 'bill', |
| test1: 'bill1', |
| test2: [{ value: 'bill2' }], |
| }, |
| }); |
|
|
| return ( |
| <form onSubmit={handleSubmit((data) => (submittedData = data))}> |
| {show && ( |
| <> |
| <input {...register('test')} /> |
| <Controller |
| control={control} |
| render={({ field }) => <input {...field} />} |
| name={'test1'} |
| /> |
| <Child control={control} register={register} /> |
| </> |
| )} |
| <button>Submit</button> |
| <button type={'button'} onClick={() => setShow(false)}> |
| Toggle |
| </button> |
| </form> |
| ); |
| }; |
|
|
| render(<Component />); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'Submit' })); |
|
|
| await waitFor(() => |
| expect(submittedData).toEqual({ |
| test: 'bill', |
| test1: 'bill1', |
| test2: [ |
| { |
| value: 'bill2', |
| }, |
| ], |
| }), |
| ); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'Toggle' })); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'Submit' })); |
|
|
| await waitFor(() => expect(submittedData).toEqual({})); |
| }); |
| }); |
|
|
| it('should not mutate defaultValues', () => { |
| const defaultValues = { |
| test: { |
| test: '123', |
| test1: '1234', |
| }, |
| }; |
|
|
| const Form = () => { |
| const { register, control } = useForm({ |
| defaultValues, |
| }); |
| return ( |
| <> |
| <input {...register('test.test', { shouldUnregister: true })} /> |
| <Controller |
| control={control} |
| shouldUnregister |
| render={() => { |
| return <input />; |
| }} |
| name={'test.test1'} |
| /> |
| </> |
| ); |
| }; |
|
|
| const App = () => { |
| const [show, setShow] = React.useState(true); |
| return ( |
| <> |
| {show && <Form />} |
| <button |
| type={'button'} |
| onClick={() => { |
| setShow(!show); |
| }} |
| > |
| toggle |
| </button> |
| </> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| expect(defaultValues).toEqual({ |
| test: { |
| test: '123', |
| test1: '1234', |
| }, |
| }); |
| }); |
|
|
| it('should not register or shallow defaultValues into submission data', () => { |
| let data = {}; |
|
|
| const App = () => { |
| const { handleSubmit } = useForm({ |
| defaultValues: { |
| test: 'test', |
| }, |
| }); |
|
|
| return ( |
| <button |
| onClick={handleSubmit((d) => { |
| data = d; |
| })} |
| > |
| submit |
| </button> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| expect(data).toEqual({}); |
| }); |
|
|
| it('should keep validation during unmount', async () => { |
| const onSubmit = jest.fn(); |
|
|
| function Component() { |
| const { |
| register, |
| handleSubmit, |
| watch, |
| formState: { errors, submitCount }, |
| } = useForm<{ |
| firstName: string; |
| moreDetail: boolean; |
| }>({ |
| shouldUnregister: true, |
| }); |
| const moreDetail = watch('moreDetail'); |
|
|
| return ( |
| <> |
| <p>Submit count: {submitCount}</p> |
| <form onSubmit={handleSubmit(onSubmit)}> |
| <input |
| placeholder="firstName" |
| {...register('firstName', { maxLength: 3 })} |
| /> |
| {errors.firstName && <p>max length</p>} |
| <input |
| type="checkbox" |
| {...register('moreDetail')} |
| placeholder={'checkbox'} |
| /> |
| |
| {moreDetail && <p>show more</p>} |
| <button>Submit</button> |
| </form> |
| </> |
| ); |
| } |
|
|
| render(<Component />); |
|
|
| fireEvent.change(screen.getByPlaceholderText('firstName'), { |
| target: { |
| value: 'testtesttest', |
| }, |
| }); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| expect(await screen.findByText('Submit count: 1')).toBeVisible(); |
| expect(screen.getByText('max length')).toBeVisible(); |
|
|
| fireEvent.click(screen.getByPlaceholderText('checkbox')); |
|
|
| expect(screen.getByText('show more')).toBeVisible(); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| expect(await screen.findByText('Submit count: 2')).toBeVisible(); |
| expect(screen.getByText('max length')).toBeVisible(); |
| }); |
|
|
| it('should only unregister inputs when all checkboxes are unmounted', async () => { |
| let result: Record<string, string> | undefined = undefined; |
|
|
| const Component = () => { |
| const { register, handleSubmit } = useForm({ |
| shouldUnregister: true, |
| }); |
| const [radio1, setRadio1] = React.useState(true); |
| const [radio2, setRadio2] = React.useState(true); |
|
|
| return ( |
| <form |
| onSubmit={handleSubmit((data) => { |
| result = data; |
| })} |
| > |
| {radio1 && ( |
| <input {...register('test')} type={'radio'} value={'1'} /> |
| )} |
| {radio2 && ( |
| <input {...register('test')} type={'radio'} value={'2'} /> |
| )} |
| <button type={'button'} onClick={() => setRadio1(!radio1)}> |
| setRadio1 |
| </button> |
| <button type={'button'} onClick={() => setRadio2(!radio2)}> |
| setRadio2 |
| </button> |
| <button>Submit</button> |
| </form> |
| ); |
| }; |
|
|
| render(<Component />); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'setRadio1' })); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'Submit' })); |
|
|
| await waitFor(() => expect(result).toEqual({ test: null })); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'setRadio2' })); |
|
|
| fireEvent.click(screen.getByRole('button', { name: 'Submit' })); |
|
|
| await waitFor(() => expect(result).toEqual({})); |
| }); |
| }); |
|
|
| describe('when errors changes', () => { |
| it('should display the latest error message', async () => { |
| const Form = () => { |
| const { |
| register, |
| setError, |
| formState: { errors }, |
| } = useForm<{ |
| test: string; |
| }>(); |
|
|
| React.useEffect(() => { |
| setError('test', { |
| type: 'data', |
| message: 'data', |
| }); |
| }, [setError]); |
|
|
| return ( |
| <div> |
| <input |
| {...register('test', { |
| maxLength: { |
| message: 'max', |
| value: 3, |
| }, |
| })} |
| placeholder="test" |
| type="text" |
| /> |
| <span role="alert">{errors.test && errors.test.message}</span> |
| </div> |
| ); |
| }; |
|
|
| render(<Form />); |
|
|
| const span = screen.getByRole('alert'); |
|
|
| await waitFor(() => expect(span.textContent).toBe('data')); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { |
| value: 'test', |
| }, |
| }); |
|
|
| await waitFor(() => expect(span.textContent).toBe('data')); |
| }); |
|
|
| it('should display the latest error message with errors prop', () => { |
| const Form = () => { |
| type FormValues = { |
| test1: string; |
| test2: string; |
| }; |
| const [errorsState, setErrorsState] = React.useState< |
| FieldErrors<FormValues> |
| >({ |
| test1: { type: 'test1', message: 'test1 error' }, |
| }); |
| const { |
| register, |
| formState: { errors }, |
| } = useForm<FormValues>({ |
| errors: errorsState, |
| }); |
|
|
| return ( |
| <div> |
| <input {...register('test1')} type="text" /> |
| <span role="alert">{errors.test1 && errors.test1.message}</span> |
| <input {...register('test2')} type="text" /> |
| <span role="alert">{errors.test2 && errors.test2.message}</span> |
| <button |
| onClick={() => |
| setErrorsState((errors) => ({ |
| ...errors, |
| test2: { type: 'test2', message: 'test2 error' }, |
| })) |
| } |
| > |
| Set Errors |
| </button> |
| </div> |
| ); |
| }; |
|
|
| render(<Form />); |
|
|
| const alert1 = screen.getAllByRole('alert')[0]; |
| expect(alert1.textContent).toBe('test1 error'); |
| const test1Input = screen.getAllByRole('textbox')[0]; |
| expect(test1Input).toHaveFocus(); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| const alert2 = screen.getAllByRole('alert')[1]; |
| expect(alert2.textContent).toBe('test2 error'); |
| expect(test1Input).toHaveFocus(); |
| }); |
|
|
| it("shouldn't focus the input of the error defined in the errors prop if shouldFocusError is false", () => { |
| const formErrors = { |
| test1: { type: 'test1', message: 'test1 error' }, |
| }; |
| const Form = () => { |
| type FormValues = { |
| test1: string; |
| }; |
| const { |
| register, |
| formState: { errors }, |
| } = useForm<FormValues>({ |
| errors: formErrors, |
| shouldFocusError: false, |
| }); |
|
|
| return ( |
| <div> |
| <input {...register('test1')} type="text" /> |
| <span role="alert">{errors.test1 && errors.test1.message}</span> |
| </div> |
| ); |
| }; |
|
|
| const renderRes = render(<Form />); |
| const alert1 = screen.getAllByRole('alert')[0]; |
| expect(alert1.textContent).toBe('test1 error'); |
| expect(renderRes.baseElement).toHaveFocus(); |
| }); |
| }); |
|
|
| describe('handleChangeRef', () => { |
| const Component = ({ |
| resolver, |
| mode, |
| rules = { required: 'required' }, |
| onSubmit = noop, |
| }: { |
| resolver?: any; |
| mode?: 'onBlur' | 'onSubmit' | 'onChange'; |
| rules?: RegisterOptions<{ test: string }, 'test'>; |
| onSubmit?: () => void; |
| }) => { |
| const internationalMethods = useForm<{ test: string }>({ |
| resolver, |
| mode, |
| }); |
| const { |
| register, |
| handleSubmit, |
| formState: { errors, isValid, isDirty }, |
| } = internationalMethods; |
| methods = internationalMethods; |
|
|
| return ( |
| <div> |
| <input type="text" {...register('test', resolver ? {} : rules)} /> |
| <span role="alert"> |
| {errors?.test?.message && errors.test.message} |
| </span> |
| <button onClick={handleSubmit(onSubmit)}>button</button> |
| <p>{isValid ? 'valid' : 'invalid'}</p> |
| <p>{isDirty ? 'dirty' : 'pristine'}</p> |
| </div> |
| ); |
| }; |
| let methods: UseFormReturn<{ test: string }>; |
|
|
| describe('onSubmit mode', () => { |
| it('should not contain error if value is valid', async () => { |
| const onSubmit = jest.fn(); |
|
|
| render(<Component onSubmit={onSubmit} />); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: 'test' }, |
| }); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => expect(onSubmit).toHaveBeenCalled()); |
|
|
| const alert = await screen.findByRole('alert'); |
| expect(alert.textContent).toBe(''); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: 'test' }, |
| }); |
|
|
| expect(alert.textContent).toBe(''); |
| }); |
|
|
| it('should not contain error if name is invalid', async () => { |
| const onSubmit = jest.fn(); |
|
|
| render(<Component onSubmit={onSubmit} />); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: 'test' }, |
| }); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => expect(onSubmit).toHaveBeenCalled()); |
|
|
| const alert = await screen.findByRole('alert'); |
| expect(alert.textContent).toBe(''); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'wrongName', value: '' }, |
| }); |
|
|
| expect(alert.textContent).toBe(''); |
| }); |
|
|
| it('should contain error if value is invalid with revalidateMode is onChange', async () => { |
| const onSubmit = jest.fn(); |
|
|
| render(<Component onSubmit={onSubmit} />); |
|
|
| const input = screen.getByRole('textbox'); |
|
|
| fireEvent.input(input, { target: { name: 'test', value: 'test' } }); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => expect(onSubmit).toHaveBeenCalled()); |
|
|
| expect(screen.getByRole('alert').textContent).toBe(''); |
|
|
| fireEvent.input(input, { target: { name: 'test', value: '' } }); |
|
|
| await waitFor(() => |
| expect(screen.getByRole('alert').textContent).toBe('required'), |
| ); |
| }); |
|
|
| it('should not call reRender method if the current error is the same as the previous error', async () => { |
| render(<Component />); |
|
|
| const input = screen.getByRole('textbox'); |
|
|
| fireEvent.input(input, { target: { name: 'test', value: '' } }); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => |
| expect(screen.getByRole('alert').textContent).toBe('required'), |
| ); |
|
|
| fireEvent.input(input, { target: { name: 'test', value: '' } }); |
|
|
| expect(screen.getByRole('alert').textContent).toBe('required'); |
| }); |
|
|
| it('should set name to formState.touchedFields when formState.touchedFields is defined', async () => { |
| const onSubmit = jest.fn(); |
|
|
| render(<Component onSubmit={onSubmit} rules={{}} />); |
|
|
| methods.formState.touchedFields; |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => expect(onSubmit).toHaveBeenCalled()); |
|
|
| fireEvent.blur(screen.getByRole('textbox'), { |
| target: { name: 'test', value: 'test' }, |
| }); |
|
|
| await waitFor(() => |
| expect(methods.formState.touchedFields).toEqual({ |
| test: true, |
| }), |
| ); |
| expect(screen.getByRole('alert').textContent).toBe(''); |
| }); |
|
|
| |
| it('should perform correct behavior when reValidateMode is onBlur', async () => { |
| const onSubmit = jest.fn(); |
|
|
| const Component = () => { |
| const { |
| register, |
| handleSubmit, |
| formState: { errors }, |
| } = useForm<{ |
| test: string; |
| }>({ |
| reValidateMode: 'onBlur', |
| }); |
| return ( |
| <form onSubmit={handleSubmit(onSubmit)}> |
| <input type="text" {...register('test', { required: true })} /> |
| {errors.test && <span role="alert">required</span>} |
| <button>submit</button> |
| </form> |
| ); |
| }; |
|
|
| render(<Component />); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { |
| value: 'test', |
| }, |
| }); |
|
|
| fireEvent.click(screen.getByRole('button', { name: /submit/i })); |
|
|
| await waitFor(() => expect(onSubmit).toHaveBeenCalled()); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { value: '' }, |
| }); |
|
|
| expect(screen.queryByRole('alert')).not.toBeInTheDocument(); |
|
|
| fireEvent.blur(screen.getByRole('textbox')); |
|
|
| expect(await screen.findByRole('alert')).toBeVisible(); |
| }); |
| }); |
|
|
| describe('onChange', () => { |
| it('should display error with onChange', async () => { |
| render(<Component mode="onChange" />); |
|
|
| fireEvent.change(screen.getByRole('textbox'), { |
| target: { |
| value: 'test', |
| }, |
| }); |
|
|
| await waitFor(() => screen.getByText('valid')); |
|
|
| fireEvent.change(screen.getByRole('textbox'), { |
| target: { |
| value: '', |
| }, |
| }); |
|
|
| await waitFor(() => |
| expect(screen.getByRole('alert').textContent).toBe('required'), |
| ); |
| }); |
|
|
| it('should display error with onSubmit', async () => { |
| render(<Component mode="onChange" />); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => |
| expect(screen.getByRole('alert').textContent).toBe('required'), |
| ); |
| }); |
|
|
| it('should not display error with onBlur', async () => { |
| render(<Component mode="onChange" />); |
|
|
| fireEvent.blur(screen.getByRole('textbox'), { |
| target: { |
| value: '', |
| }, |
| }); |
|
|
| expect(screen.getByRole('alert').textContent).toBe(''); |
| }); |
| }); |
|
|
| describe('onBlur', () => { |
| it('should display error with onBlur', async () => { |
| render(<Component mode="onBlur" />); |
|
|
| fireEvent.blur(screen.getByRole('textbox'), { |
| target: { |
| value: '', |
| }, |
| }); |
|
|
| await waitFor(() => |
| expect(screen.getByRole('alert').textContent).toBe('required'), |
| ); |
| }); |
|
|
| it('should display error with onSubmit', async () => { |
| render(<Component mode="onBlur" />); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => |
| expect(screen.getByRole('alert').textContent).toBe('required'), |
| ); |
| }); |
|
|
| it('should not display error with onChange', async () => { |
| render(<Component mode="onBlur" />); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { |
| value: '', |
| }, |
| }); |
|
|
| expect(screen.getByRole('alert').textContent).toBe(''); |
| }); |
| }); |
|
|
| describe('with watch', () => { |
| it('should be return undefined or null value', () => { |
| const { result } = renderHook(() => |
| useForm<{ |
| test: string | null; |
| test1?: string; |
| }>(), |
| ); |
|
|
| result.current.register('test'); |
| result.current.register('test1'); |
|
|
| act(() => { |
| result.current.setValue('test', null); |
| }); |
|
|
| act(() => { |
| result.current.setValue('test1', undefined); |
| }); |
|
|
| const test = result.current.watch('test'); |
| const test1 = result.current.watch('test1'); |
|
|
| expect(test).toBeNull(); |
| expect(test1).toBeUndefined(); |
| }); |
|
|
| it('should be called reRender method if isWatchAllRef is true', async () => { |
| let watchedField: any; |
| const Component = () => { |
| const { register, handleSubmit, watch } = useForm<{ |
| test: string; |
| }>(); |
| watchedField = watch(); |
| return ( |
| <form onSubmit={handleSubmit(noop)}> |
| <input {...register('test')} /> |
| <button>button</button> |
| </form> |
| ); |
| }; |
| render(<Component />); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: 'test' }, |
| }); |
|
|
| expect(watchedField).toEqual({ test: 'test' }); |
| }); |
|
|
| it('should be called reRender method if field is watched', async () => { |
| let watchedField: any; |
| const Component = () => { |
| const { register, handleSubmit, watch } = useForm<{ |
| test: string; |
| }>(); |
| watchedField = watch('test'); |
| return ( |
| <form onSubmit={handleSubmit(noop)}> |
| <input {...register('test')} /> |
| <button>button</button> |
| </form> |
| ); |
| }; |
| render(<Component />); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: 'test' }, |
| }); |
|
|
| expect(watchedField).toBe('test'); |
| }); |
|
|
| it('should be called reRender method if array field is watched', async () => { |
| let watchedField: any; |
| const Component = () => { |
| const { register, handleSubmit, watch } = useForm<{ |
| test: string[]; |
| }>(); |
| watchedField = watch('test'); |
| return ( |
| <form onSubmit={handleSubmit(noop)}> |
| <input {...register('test.0')} /> |
| <input {...register('test.1')} /> |
| <input {...register('test.2')} /> |
| <button>button</button> |
| </form> |
| ); |
| }; |
| render(<Component />); |
|
|
| fireEvent.input(screen.getAllByRole('textbox')[0], { |
| target: { name: 'test.0', value: 'test' }, |
| }); |
|
|
| expect(watchedField).toEqual(['test', '', '']); |
| }); |
| }); |
|
|
| describe('with resolver', () => { |
| it('should contain error if value is invalid with resolver', async () => { |
| const resolver = jest.fn(async (data: any) => { |
| if (data.test) { |
| return { values: data, errors: {} }; |
| } |
| return { |
| values: data, |
| errors: { |
| test: { |
| message: 'resolver error', |
| }, |
| }, |
| }; |
| }); |
|
|
| render(<Component resolver={resolver} mode="onChange" />); |
|
|
| methods.formState.isValid; |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: 'test' }, |
| }); |
| expect(await screen.findByText('dirty')).toBeVisible(); |
| expect(resolver).toHaveBeenCalled(); |
|
|
| expect(screen.getByRole('alert').textContent).toBe(''); |
| expect(methods.formState.isValid).toBeTruthy(); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: '' }, |
| }); |
|
|
| await waitFor(() => { |
| expect(screen.getByRole('alert')).toHaveTextContent('resolver error'); |
| }); |
| expect(resolver).toHaveBeenCalled(); |
| expect(methods.formState.isValid).toBeFalsy(); |
| }); |
|
|
| it('with sync resolver it should contain error if value is invalid with resolver', async () => { |
| const resolver = jest.fn((data: any) => { |
| if (data.test) { |
| return { values: data, errors: {} }; |
| } |
| return { |
| values: data, |
| errors: { |
| test: { |
| message: 'resolver error', |
| }, |
| }, |
| }; |
| }); |
|
|
| render(<Component resolver={resolver} mode="onChange" />); |
|
|
| methods.formState.isValid; |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: 'test' }, |
| }); |
|
|
| await waitFor(() => expect(methods.formState.isValid).toBe(true)); |
| expect(screen.getByRole('alert').textContent).toBe(''); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: '' }, |
| }); |
|
|
| expect(await screen.findByText('invalid')).toBeVisible(); |
| expect(methods.formState.isValid).toBe(false); |
| expect(screen.getByRole('alert')).toHaveTextContent('resolver error'); |
| expect(resolver).toHaveBeenCalled(); |
| }); |
|
|
| it('should make isValid change to false if it contain error that is not related name with onChange mode', async () => { |
| const resolver = jest.fn(async (data: any) => { |
| if (data.test) { |
| return { values: data, errors: {} }; |
| } |
| return { |
| values: data, |
| errors: { |
| notRelatedName: { |
| message: 'resolver error', |
| }, |
| }, |
| }; |
| }); |
|
|
| render(<Component resolver={resolver} mode="onChange" />); |
|
|
| methods.formState.isValid; |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: 'test' }, |
| }); |
|
|
| await waitFor(() => expect(methods.formState.isValid).toBeTruthy()); |
| expect(screen.getByRole('alert').textContent).toBe(''); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { name: 'test', value: '' }, |
| }); |
|
|
| await waitFor(() => expect(methods.formState.isValid).toBeFalsy()); |
| expect(resolver).toHaveBeenCalled(); |
| expect(screen.getByRole('alert').textContent).toBe(''); |
| }); |
|
|
| it("should call the resolver with the field being validated when an input's value change", async () => { |
| const resolver = jest.fn((values: any) => ({ values, errors: {} })); |
| const onSubmit = jest.fn(); |
|
|
| render( |
| <Component resolver={resolver} onSubmit={onSubmit} mode="onChange" />, |
| ); |
|
|
| expect(await screen.findByText('valid')).toBeVisible(); |
|
|
| const input = screen.getByRole('textbox'); |
|
|
| expect(resolver).toHaveBeenCalledWith( |
| { |
| test: '', |
| }, |
| undefined, |
| { |
| criteriaMode: undefined, |
| fields: { |
| test: { |
| mount: true, |
| name: 'test', |
| ref: input, |
| }, |
| }, |
| names: ['test'], |
| shouldUseNativeValidation: undefined, |
| }, |
| ); |
|
|
| resolver.mockClear(); |
|
|
| fireEvent.input(input, { |
| target: { name: 'test', value: 'test' }, |
| }); |
|
|
| expect(await screen.findByText('dirty')).toBeVisible(); |
|
|
| expect(resolver).toHaveBeenCalledWith( |
| { |
| test: 'test', |
| }, |
| undefined, |
| { |
| criteriaMode: undefined, |
| fields: { |
| test: { |
| mount: true, |
| name: 'test', |
| ref: input, |
| }, |
| }, |
| names: ['test'], |
| shouldUseNativeValidation: undefined, |
| }, |
| ); |
|
|
| resolver.mockClear(); |
|
|
| fireEvent.click(screen.getByText(/button/i)); |
|
|
| await waitFor(() => expect(onSubmit).toHaveBeenCalled()); |
|
|
| expect(resolver).toHaveBeenCalledWith( |
| { |
| test: 'test', |
| }, |
| undefined, |
| { |
| criteriaMode: undefined, |
| fields: { |
| test: { |
| mount: true, |
| name: 'test', |
| ref: input, |
| }, |
| }, |
| names: ['test'], |
| shouldUseNativeValidation: undefined, |
| }, |
| ); |
| }); |
|
|
| it('should call the resolver with the field being validated when `trigger` is called', async () => { |
| const resolver = jest.fn((values: any) => ({ values, errors: {} })); |
| const defaultValues = { test: { sub: 'test' }, test1: 'test1' }; |
|
|
| const { result } = renderHook(() => |
| useForm<typeof defaultValues>({ |
| mode: VALIDATION_MODE.onChange, |
| resolver, |
| defaultValues, |
| }), |
| ); |
|
|
| expect(resolver).not.toHaveBeenCalled(); |
|
|
| await act(async () => { |
| await result.current.register('test.sub'); |
| await result.current.register('test1'); |
| }); |
|
|
| await act(async () => { |
| result.current.trigger('test.sub'); |
| }); |
|
|
| const fields = { |
| test: { |
| sub: { |
| mount: true, |
| name: 'test.sub', |
| ref: { name: 'test.sub' }, |
| }, |
| }, |
| test1: { |
| mount: true, |
| name: 'test1', |
| ref: { |
| name: 'test1', |
| }, |
| }, |
| }; |
|
|
| expect(resolver).toHaveBeenCalledWith(defaultValues, undefined, { |
| criteriaMode: undefined, |
| fields: { test: fields.test }, |
| names: ['test.sub'], |
| }); |
|
|
| await act(async () => { |
| result.current.trigger(); |
| }); |
|
|
| expect(resolver).toHaveBeenNthCalledWith(2, defaultValues, undefined, { |
| criteriaMode: undefined, |
| fields, |
| names: ['test.sub', 'test1'], |
| }); |
|
|
| await act(async () => { |
| result.current.trigger(['test.sub', 'test1']); |
| }); |
|
|
| expect(resolver).toHaveBeenNthCalledWith(3, defaultValues, undefined, { |
| criteriaMode: undefined, |
| fields, |
| names: ['test.sub', 'test1'], |
| }); |
| }); |
| }); |
| }); |
|
|
| describe('when mode or reValidateMode changes', () => { |
| it('should use updated mode and reValidateMode inside of onChange handler', async () => { |
| const resolver = jest.fn(async (data: any) => ({ |
| values: data, |
| errors: {}, |
| })); |
| const Form = () => { |
| const [mode, setMode] = React.useState<Mode>('onChange'); |
| const [reValidateMode, setReValidateMode] = |
| React.useState<Exclude<Mode, 'onTouched' | 'all'>>('onBlur'); |
| const { register, handleSubmit } = useForm<{ test: string }>({ |
| mode, |
| reValidateMode, |
| resolver, |
| }); |
| return ( |
| <form onSubmit={handleSubmit(noop)}> |
| <input {...register('test')} type="text" /> |
| <button |
| type="button" |
| onClick={() => { |
| setMode('onTouched'); |
| setReValidateMode('onChange'); |
| }} |
| > |
| Update Validation Mode |
| </button> |
| <input type="submit" /> |
| </form> |
| ); |
| }; |
|
|
| render(<Form />); |
|
|
| fireEvent.click( |
| screen.getByRole('button', { name: /update validation mode/i }), |
| ); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { |
| value: 'test', |
| }, |
| }); |
| expect(resolver).toHaveBeenCalledTimes(0); |
|
|
| fireEvent.blur(screen.getByRole('textbox'), { |
| target: { |
| value: 'test', |
| }, |
| }); |
| expect(resolver).toHaveBeenCalledTimes(1); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { |
| value: 'test1', |
| }, |
| }); |
| expect(resolver).toHaveBeenCalledTimes(2); |
|
|
| fireEvent.click(screen.getByRole('button', { name: /submit/i })); |
| await waitFor(() => expect(resolver).toHaveBeenCalledTimes(3)); |
|
|
| fireEvent.blur(screen.getByRole('textbox'), { |
| target: { |
| value: 'test1', |
| }, |
| }); |
| expect(resolver).toHaveBeenCalledTimes(3); |
|
|
| fireEvent.input(screen.getByRole('textbox'), { |
| target: { |
| value: 'test12', |
| }, |
| }); |
| expect(resolver).toHaveBeenCalledTimes(4); |
| }); |
| }); |
|
|
| describe('updateValid', () => { |
| it('should be called resolver with default values if default value is defined', async () => { |
| type FormValues = { |
| test: string; |
| }; |
|
|
| const resolver = jest.fn(async (data: FormValues) => { |
| return { |
| values: data, |
| errors: {}, |
| }; |
| }); |
|
|
| const { result } = renderHook(() => |
| useForm<FormValues>({ |
| resolver, |
| defaultValues: { test: 'default' }, |
| }), |
| ); |
|
|
| const { ref } = result.current.register('test'); |
|
|
| isFunction(ref) && |
| ref({ |
| target: { |
| value: '', |
| }, |
| }); |
|
|
| await act(async () => { |
| await result.current.trigger(); |
| }); |
|
|
| expect(resolver).toHaveBeenCalledWith( |
| { |
| test: 'default', |
| }, |
| undefined, |
| { |
| criteriaMode: undefined, |
| fields: { |
| test: { |
| mount: true, |
| name: 'test', |
| ref: { |
| target: { |
| value: '', |
| }, |
| value: 'default', |
| }, |
| }, |
| }, |
| names: ['test'], |
| }, |
| ); |
| }); |
|
|
| it('should be called resolver with field values if value is undefined', async () => { |
| type FormValues = { |
| test: string; |
| }; |
|
|
| const resolver = jest.fn(async (data: FormValues) => { |
| return { |
| values: data, |
| errors: {}, |
| }; |
| }); |
|
|
| const { result } = renderHook(() => |
| useForm<FormValues>({ |
| resolver, |
| }), |
| ); |
|
|
| result.current.register('test'); |
|
|
| result.current.setValue('test', 'value'); |
|
|
| result.current.trigger(); |
|
|
| expect(resolver).toHaveBeenCalledWith({ test: 'value' }, undefined, { |
| criteriaMode: undefined, |
| fields: { |
| test: { |
| mount: true, |
| name: 'test', |
| ref: { name: 'test', value: 'value' }, |
| }, |
| }, |
| names: ['test'], |
| }); |
| }); |
| }); |
|
|
| describe('mode with onTouched', () => { |
| it('should validate form only when input is been touched', async () => { |
| const Component = () => { |
| const { |
| register, |
| formState: { errors }, |
| } = useForm<{ |
| test: string; |
| }>({ |
| mode: 'onTouched', |
| }); |
|
|
| return ( |
| <> |
| <input |
| type="text" |
| {...register('test', { required: 'This is required.' })} |
| /> |
| {errors.test?.message} |
| </> |
| ); |
| }; |
|
|
| render(<Component />); |
|
|
| const input = screen.getByRole('textbox'); |
|
|
| fireEvent.focus(input); |
|
|
| fireEvent.blur(input); |
|
|
| expect(await screen.findByText('This is required.')).toBeVisible(); |
|
|
| fireEvent.input(input, { |
| target: { |
| value: 'test', |
| }, |
| }); |
|
|
| await waitFor(() => |
| expect(screen.queryByText('This is required.')).not.toBeInTheDocument(), |
| ); |
|
|
| fireEvent.input(input, { |
| target: { |
| value: '', |
| }, |
| }); |
|
|
| expect(await screen.findByText('This is required.')).toBeVisible(); |
| }); |
|
|
| it('should validate onFocusout event', async () => { |
| const Component = () => { |
| const { |
| register, |
| formState: { errors }, |
| } = useForm<{ |
| test: string; |
| }>({ |
| mode: 'onTouched', |
| }); |
|
|
| return ( |
| <> |
| <input |
| type="text" |
| {...register('test', { required: 'This is required.' })} |
| /> |
| {errors.test?.message} |
| </> |
| ); |
| }; |
|
|
| render(<Component />); |
|
|
| const input = screen.getByRole('textbox'); |
|
|
| fireEvent.focus(input); |
|
|
| fireEvent.focusOut(input); |
|
|
| expect(await screen.findByText('This is required.')).toBeVisible(); |
|
|
| fireEvent.input(input, { |
| target: { |
| value: 'test', |
| }, |
| }); |
|
|
| await waitFor(() => |
| expect(screen.queryByText('This is required.')).not.toBeInTheDocument(), |
| ); |
|
|
| fireEvent.input(input, { |
| target: { |
| value: '', |
| }, |
| }); |
|
|
| expect(await screen.findByText('This is required.')).toBeVisible(); |
| }); |
| }); |
|
|
| describe('with schema validation', () => { |
| it('should trigger and clear errors for group errors object', async () => { |
| let errorsObject = {}; |
|
|
| const Component = () => { |
| const { |
| formState: { errors }, |
| register, |
| handleSubmit, |
| } = useForm<{ |
| checkbox: string[]; |
| }>({ |
| mode: 'onChange', |
| resolver: (data) => { |
| return { |
| errors: { |
| ...(data.checkbox.every((value) => !value) |
| ? { checkbox: { type: 'error', message: 'wrong' } } |
| : {}), |
| }, |
| values: {}, |
| }; |
| }, |
| }); |
| errorsObject = errors; |
|
|
| return ( |
| <form onSubmit={handleSubmit(noop)}> |
| {[1, 2, 3].map((value, index) => ( |
| <div key={`test.${index}`}> |
| <label |
| htmlFor={`checkbox.${index}`} |
| >{`checkbox.${index}`}</label> |
| <input |
| type={'checkbox'} |
| key={index} |
| id={`checkbox.${index}`} |
| {...register(`checkbox.${index}` as const)} |
| value={value} |
| /> |
| </div> |
| ))} |
| |
| <button>Submit</button> |
| </form> |
| ); |
| }; |
|
|
| render(<Component />); |
|
|
| fireEvent.click(screen.getByLabelText('checkbox.0')); |
|
|
| fireEvent.click(screen.getByLabelText('checkbox.0')); |
|
|
| await waitFor(() => |
| expect(errorsObject).toEqual({ |
| checkbox: { type: 'error', message: 'wrong' }, |
| }), |
| ); |
|
|
| fireEvent.click(screen.getByLabelText('checkbox.0')); |
|
|
| await waitFor(() => expect(errorsObject).toEqual({})); |
|
|
| fireEvent.click(screen.getByLabelText('checkbox.0')); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => |
| expect(errorsObject).toEqual({ |
| checkbox: { type: 'error', message: 'wrong' }, |
| }), |
| ); |
|
|
| fireEvent.click(screen.getByLabelText('checkbox.0')); |
|
|
| await waitFor(() => expect(errorsObject).toEqual({})); |
| }); |
|
|
| it('should not clear errors for non checkbox parent inputs', async () => { |
| let errorsObject = {}; |
|
|
| const Component = () => { |
| const { |
| formState: { errors }, |
| register, |
| handleSubmit, |
| } = useForm<{ |
| checkbox: [{ test: string }, { test1: string }]; |
| }>({ |
| mode: 'onChange', |
| resolver: (data) => { |
| return { |
| errors: { |
| ...(!data.checkbox[0].test || !data.checkbox[1].test1 |
| ? { |
| checkbox: [ |
| { |
| ...(!data.checkbox[0].test |
| ? { test: { type: 'error', message: 'wrong' } } |
| : {}), |
| ...(!data.checkbox[1].test1 |
| ? { test1: { type: 'error', message: 'wrong' } } |
| : {}), |
| }, |
| ], |
| } |
| : {}), |
| }, |
| values: {}, |
| }; |
| }, |
| }); |
| errorsObject = errors; |
|
|
| return ( |
| <form onSubmit={handleSubmit(noop)}> |
| <input type={'checkbox'} {...register(`checkbox.0.test`)} /> |
| |
| <input {...register(`checkbox.1.test1`)} /> |
| <button>Submit</button> |
| </form> |
| ); |
| }; |
|
|
| render(<Component />); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => |
| expect(errorsObject).toEqual({ |
| checkbox: [ |
| { |
| test: { type: 'error', message: 'wrong' }, |
| test1: { type: 'error', message: 'wrong' }, |
| }, |
| ], |
| }), |
| ); |
|
|
| fireEvent.click(screen.getByRole('checkbox')); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => |
| expect(errorsObject).toEqual({ |
| checkbox: [ |
| { |
| test1: { type: 'error', message: 'wrong' }, |
| }, |
| ], |
| }), |
| ); |
| }); |
|
|
| it('should have formState.isValid equals true with defined default values after executing resolver', async () => { |
| const Toggle = () => { |
| const [toggle, setToggle] = React.useState(false); |
|
|
| const { register, formState } = useForm({ |
| defaultValues: { test: 'Test' }, |
| mode: 'onChange', |
| resolver: async (values) => { |
| if (!values.test) { |
| return { |
| values: {}, |
| errors: { |
| test: { |
| type: 'required', |
| }, |
| }, |
| }; |
| } |
|
|
| return { |
| values, |
| errors: {}, |
| }; |
| }, |
| }); |
|
|
| return ( |
| <> |
| <button onClick={() => setToggle(!toggle)}>Toggle</button> |
| {toggle && <input id="test" {...register('test')} />} |
| <button disabled={!formState.isValid}>Submit</button> |
| </> |
| ); |
| }; |
|
|
| render(<Toggle />); |
|
|
| const toggle = () => fireEvent.click(screen.getByText('Toggle')); |
|
|
| toggle(); |
|
|
| await waitFor(() => expect(screen.getByText('Submit')).toBeEnabled()); |
|
|
| toggle(); |
| toggle(); |
|
|
| expect(screen.getByText('Submit')).toBeEnabled(); |
| }); |
| }); |
|
|
| describe('control', () => { |
| it('does not change across re-renders', () => { |
| let control; |
|
|
| const Component = () => { |
| const form = useForm<{ |
| test: string; |
| }>(); |
|
|
| control = form.control; |
|
|
| return ( |
| <> |
| <input type="text" {...form.register('test')} /> |
| </> |
| ); |
| }; |
|
|
| const { rerender } = render(<Component />); |
|
|
| const firstRenderControl = control; |
|
|
| rerender(<Component />); |
|
|
| const secondRenderControl = control; |
|
|
| expect(Object.is(firstRenderControl, secondRenderControl)).toBe(true); |
| }); |
| }); |
|
|
| describe('when input is not registered', () => { |
| it('trigger should not throw warn', async () => { |
| const { result } = renderHook(() => |
| useForm<{ |
| test: string; |
| }>(), |
| ); |
|
|
| await act(async () => |
| expect(await result.current.trigger('test')).toBeTruthy(), |
| ); |
| }); |
| }); |
|
|
| it('should update isValidating form and field states correctly', async () => { |
| jest.useFakeTimers(); |
|
|
| let formState = {} as FormState<FieldValues>; |
| let getFieldState = {} as UseFormGetFieldState<FieldValues>; |
| const App = () => { |
| const [stateValidation, setStateValidation] = React.useState(false); |
| const { |
| register, |
| formState: tmpFormState, |
| getFieldState: tmpGetFieldState, |
| } = useForm({ mode: 'all' }); |
| formState = tmpFormState; |
| getFieldState = tmpGetFieldState; |
|
|
| formState.isValidating; |
|
|
| return ( |
| <div> |
| <p>stateValidation: {String(stateValidation)}</p> |
| <form> |
| <input |
| {...register('lastName', { |
| required: true, |
| validate: () => { |
| setStateValidation(true); |
| return new Promise((resolve) => { |
| setTimeout(() => { |
| setStateValidation(false); |
| resolve(true); |
| }, 5000); |
| }); |
| }, |
| })} |
| placeholder="async" |
| /> |
| |
| <input |
| {...register('firstName', { required: true })} |
| placeholder="required" |
| /> |
| </form> |
| </div> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| fireEvent.change(screen.getByPlaceholderText('async'), { |
| target: { value: 'test' }, |
| }); |
| fireEvent.change(screen.getByPlaceholderText('required'), { |
| target: { value: 'test' }, |
| }); |
|
|
| expect(formState.isValidating).toBe(true); |
| expect(formState.validatingFields).toStrictEqual({ |
| lastName: true, |
| firstName: true, |
| }); |
| expect(getFieldState('lastName').isValidating).toBe(true); |
| expect(getFieldState('firstName').isValidating).toBe(true); |
| screen.getByText('stateValidation: true'); |
|
|
| await act(async () => { |
| jest.advanceTimersByTime(1000); |
| }); |
|
|
| expect(formState.isValidating).toBe(true); |
| expect(formState.validatingFields).toStrictEqual({ |
| lastName: true, |
| }); |
| expect(getFieldState('lastName').isValidating).toBe(true); |
| expect(getFieldState('firstName').isValidating).toBe(false); |
| screen.getByText('stateValidation: true'); |
|
|
| await act(async () => { |
| jest.advanceTimersByTime(4000); |
| }); |
|
|
| expect(formState.isValidating).toBe(false); |
| expect(formState.validatingFields).toStrictEqual({}); |
| expect(getFieldState('lastName').isValidating).toBe(false); |
| expect(getFieldState('firstName').isValidating).toBe(false); |
| screen.getByText('stateValidation: false'); |
| }); |
|
|
| it('should correctly handle multiple async validation triggers', async () => { |
| jest.useFakeTimers(); |
|
|
| let formState = {} as FormState<FieldValues>; |
| let getFieldState = {} as UseFormGetFieldState<FieldValues>; |
| const App = () => { |
| const [stateValidation, setStateValidation] = React.useState(false); |
| const { |
| register, |
| formState: tmpFormState, |
| getFieldState: tmpGetFieldState, |
| } = useForm({ mode: 'onChange' }); |
| formState = tmpFormState; |
| getFieldState = tmpGetFieldState; |
|
|
| formState.validatingFields; |
| formState.isDirty; |
|
|
| return ( |
| <div> |
| <p>stateValidation: {String(stateValidation)}</p> |
| <form> |
| <input |
| {...register('lastName', { |
| required: true, |
| validate: () => { |
| setStateValidation(true); |
| return new Promise((resolve) => { |
| setTimeout(() => { |
| setStateValidation(false); |
| resolve(true); |
| }, 2000); |
| }); |
| }, |
| })} |
| placeholder="async" |
| /> |
| </form> |
| </div> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| expect(formState.validatingFields).toStrictEqual({}); |
| expect(formState.isDirty).toStrictEqual(false); |
| expect(formState.dirtyFields).toStrictEqual({}); |
| expect(getFieldState('lastName').isDirty).toStrictEqual(false); |
|
|
| fireEvent.change(screen.getByPlaceholderText('async'), { |
| target: { value: 'test' }, |
| }); |
|
|
| expect(formState.isDirty).toStrictEqual(true); |
| expect(formState.dirtyFields).toStrictEqual({ lastName: true }); |
| expect(getFieldState('lastName').isDirty).toStrictEqual(true); |
|
|
| await act(async () => { |
| jest.advanceTimersByTime(1000); |
| }); |
|
|
| expect(formState.validatingFields).toStrictEqual({ lastName: true }); |
|
|
| fireEvent.change(screen.getByPlaceholderText('async'), { |
| target: { value: 'test1' }, |
| }); |
|
|
| expect(formState.validatingFields).toStrictEqual({ lastName: true }); |
| expect(getFieldState('lastName').isValidating).toBe(true); |
|
|
| await act(async () => { |
| jest.advanceTimersByTime(1500); |
| }); |
|
|
| expect(formState.validatingFields).toStrictEqual({}); |
| expect(getFieldState('lastName').isValidating).toBe(false); |
| }); |
|
|
| it('should update isValidating to true when using with resolver', async () => { |
| jest.useFakeTimers(); |
|
|
| let formState = {} as FormState<FieldValues>; |
| let getFieldState = {} as UseFormGetFieldState<FieldValues>; |
| const App = () => { |
| const { |
| register, |
| formState: tmpFormState, |
| getFieldState: tmpGetFieldState, |
| } = useForm<{ |
| firstName: string; |
| lastName: string; |
| }>({ |
| mode: 'all', |
| defaultValues: { |
| lastName: '', |
| firstName: '', |
| }, |
| resolver: async () => { |
| await sleep(2000); |
|
|
| return { |
| errors: {}, |
| values: {}, |
| }; |
| }, |
| }); |
| getFieldState = tmpGetFieldState; |
| formState = tmpFormState; |
|
|
| formState.isValidating; |
|
|
| return ( |
| <div> |
| <input {...register('lastName')} placeholder="async" /> |
| <input {...register('firstName')} placeholder="required" /> |
| </div> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| fireEvent.change(screen.getByPlaceholderText('async'), { |
| target: { value: 'test' }, |
| }); |
| fireEvent.change(screen.getByPlaceholderText('async'), { |
| target: { value: 'test1' }, |
| }); |
| fireEvent.change(screen.getByPlaceholderText('required'), { |
| target: { value: 'test2' }, |
| }); |
| fireEvent.change(screen.getByPlaceholderText('required'), { |
| target: { value: 'test3' }, |
| }); |
|
|
| expect(formState.isValidating).toBe(true); |
| expect(formState.validatingFields).toStrictEqual({ |
| lastName: true, |
| firstName: true, |
| }); |
| expect(getFieldState('lastName').isValidating).toBe(true); |
| expect(getFieldState('firstName').isValidating).toBe(true); |
|
|
| await act(async () => { |
| jest.runAllTimers(); |
| }); |
|
|
| expect(formState.isValidating).toBe(false); |
| expect(formState.validatingFields).toStrictEqual({}); |
| expect(getFieldState('lastName').isValidating).toBe(false); |
| expect(getFieldState('firstName').isValidating).toBe(false); |
| }); |
|
|
| it('should remove field from validatingFields on unregister', async () => { |
| jest.useFakeTimers(); |
| let unregister: UseFormUnregister<FieldValues>; |
| let formState = {} as FormState<FieldValues>; |
| const App = () => { |
| const { |
| register, |
| unregister: tmpUnregister, |
| formState: tmpFormState, |
| } = useForm({ mode: 'all' }); |
| unregister = tmpUnregister; |
| formState = tmpFormState; |
|
|
| formState.validatingFields; |
|
|
| return ( |
| <div> |
| <form> |
| <input |
| {...register('firstName', { |
| required: true, |
| })} |
| placeholder="firstName" |
| /> |
| </form> |
| </div> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| fireEvent.change(screen.getByPlaceholderText('firstName'), { |
| target: { value: 'test' }, |
| }); |
|
|
| expect(formState.validatingFields).toEqual({ firstName: true }); |
| await act(async () => { |
| unregister('firstName'); |
| jest.runAllTimers(); |
| }); |
| expect(formState.validatingFields).toEqual({}); |
| }); |
|
|
| it('should update defaultValues async', async () => { |
| const App = () => { |
| const { |
| register, |
| formState: { isLoading }, |
| } = useForm<{ |
| test: string; |
| }>({ |
| defaultValues: async () => { |
| await sleep(100); |
|
|
| return { |
| test: 'test', |
| }; |
| }, |
| }); |
|
|
| return ( |
| <form> |
| <input {...register('test')} /> |
| <p>{isLoading ? 'loading...' : 'done'}</p> |
| </form> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| await waitFor(() => { |
| screen.getByText('loading...'); |
| }); |
|
|
| await waitFor(() => { |
| expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
| 'test', |
| ); |
| }); |
|
|
| await waitFor(() => { |
| screen.getByText('done'); |
| }); |
| }); |
|
|
| it('should update async default values for controlled components', async () => { |
| const App = () => { |
| const { control } = useForm<{ |
| test: string; |
| }>({ |
| defaultValues: async () => { |
| await sleep(100); |
|
|
| return { |
| test: 'test', |
| }; |
| }, |
| }); |
|
|
| return ( |
| <form> |
| <Controller |
| control={control} |
| render={({ field }) => <input {...field} />} |
| defaultValue="" |
| name={'test'} |
| /> |
| </form> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| await waitFor(() => { |
| expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
| 'test', |
| ); |
| }); |
| }); |
|
|
| it('should update async form values', async () => { |
| type FormValues = { |
| test: string; |
| }; |
|
|
| function Loader() { |
| const [values, setValues] = React.useState<FormValues>({ |
| test: '', |
| }); |
|
|
| const loadData = React.useCallback(async () => { |
| await sleep(100); |
|
|
| setValues({ |
| test: 'test', |
| }); |
| }, []); |
|
|
| React.useEffect(() => { |
| loadData(); |
| }, [loadData]); |
|
|
| return <App values={values} />; |
| } |
|
|
| const App = ({ values }: { values: FormValues }) => { |
| const { register } = useForm({ |
| values, |
| }); |
|
|
| return ( |
| <form> |
| <input {...register('test')} /> |
| </form> |
| ); |
| }; |
|
|
| render(<Loader />); |
|
|
| await waitFor(() => { |
| expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
| 'test', |
| ); |
| }); |
| }); |
|
|
| it('should only update async form values which are not interacted', async () => { |
| type FormValues = { |
| test: string; |
| test1: string; |
| }; |
|
|
| function Loader() { |
| const [values, setValues] = React.useState<FormValues>({ |
| test: '', |
| test1: '', |
| }); |
|
|
| const loadData = React.useCallback(async () => { |
| await sleep(100); |
|
|
| setValues({ |
| test: 'test', |
| test1: 'data', |
| }); |
| }, []); |
|
|
| React.useEffect(() => { |
| loadData(); |
| }, [loadData]); |
|
|
| return <App values={values} />; |
| } |
|
|
| const App = ({ values }: { values: FormValues }) => { |
| const { register } = useForm({ |
| values, |
| resetOptions: { |
| keepDirtyValues: true, |
| }, |
| }); |
|
|
| return ( |
| <form> |
| <input {...register('test')} /> |
| <input {...register('test1')} /> |
| </form> |
| ); |
| }; |
|
|
| render(<Loader />); |
|
|
| fireEvent.change(screen.getAllByRole('textbox')[0], { |
| target: { |
| value: 'test1', |
| }, |
| }); |
|
|
| await waitFor(() => { |
| expect( |
| (screen.getAllByRole('textbox')[0] as HTMLInputElement).value, |
| ).toEqual('test1'); |
| }); |
|
|
| await waitFor(() => { |
| expect( |
| (screen.getAllByRole('textbox')[1] as HTMLInputElement).value, |
| ).toEqual('data'); |
| }); |
| }); |
|
|
| it('should not update isLoading when literal defaultValues are provided', async () => { |
| const { result } = renderHook(() => |
| useForm({ defaultValues: { test: 'default' } }), |
| ); |
|
|
| expect(result.current.formState.isLoading).toBe(false); |
| }); |
|
|
| it('should update form values when values updates even with the same values', async () => { |
| type FormValues = { |
| firstName: string; |
| }; |
|
|
| function App() { |
| const [firstName, setFirstName] = React.useState('C'); |
| const values = React.useMemo(() => ({ firstName }), [firstName]); |
|
|
| const { |
| register, |
| formState: { isDirty }, |
| watch, |
| } = useForm<FormValues>({ |
| defaultValues: { |
| firstName: 'C', |
| }, |
| values, |
| resetOptions: { keepDefaultValues: true }, |
| }); |
| const formValues = watch(); |
|
|
| return ( |
| <form> |
| <button type="button" onClick={() => setFirstName('A')}> |
| 1 |
| </button> |
| <button type="button" onClick={() => setFirstName('B')}> |
| 2 |
| </button> |
| <button type="button" onClick={() => setFirstName('C')}> |
| 3 |
| </button> |
| <input {...register('firstName')} placeholder="First Name" /> |
| <p>{isDirty ? 'dirty' : 'pristine'}</p> |
| <p>{formValues.firstName}</p> |
| <input type="submit" /> |
| </form> |
| ); |
| } |
|
|
| render(<App />); |
|
|
| fireEvent.click(screen.getByRole('button', { name: '1' })); |
|
|
| await waitFor(() => { |
| screen.getByText('A'); |
| screen.getByText('dirty'); |
| }); |
|
|
| fireEvent.click(screen.getByRole('button', { name: '2' })); |
|
|
| await waitFor(() => { |
| screen.getByText('B'); |
| screen.getByText('dirty'); |
| }); |
|
|
| fireEvent.click(screen.getByRole('button', { name: '3' })); |
|
|
| await waitFor(() => { |
| screen.getByText('C'); |
| screen.getByText('pristine'); |
| }); |
| }); |
|
|
| it('should keep defaultValues if set keep default values is true on reset option', async () => { |
| type FormValues = { |
| firstName: string; |
| }; |
|
|
| function App() { |
| const { register, formState } = useForm<FormValues>({ |
| defaultValues: { |
| firstName: 'Alex', |
| }, |
| values: { |
| firstName: 'John', |
| }, |
| resetOptions: { keepDefaultValues: true }, |
| }); |
|
|
| return ( |
| <form> |
| <input {...register('firstName')} placeholder="First Name" /> |
| <div>{String(formState.isDirty)}</div> |
| <input type="submit" /> |
| </form> |
| ); |
| } |
|
|
| render(<App />); |
|
|
| fireEvent.change(screen.getByRole('textbox'), { |
| target: { value: 'John' }, |
| }); |
|
|
| screen.getByText('true'); |
|
|
| fireEvent.change(screen.getByRole('textbox'), { |
| target: { value: 'Alex' }, |
| }); |
|
|
| screen.getByText('false'); |
| }); |
|
|
| it('should change defaultValues if not reset options presented', async () => { |
| type FormValues = { |
| firstName: string; |
| }; |
|
|
| function App() { |
| const { register, formState } = useForm<FormValues>({ |
| defaultValues: { |
| firstName: 'Alex', |
| }, |
| values: { |
| firstName: 'John', |
| }, |
| }); |
|
|
| return ( |
| <form> |
| <input {...register('firstName')} placeholder="First Name" /> |
| <div>{String(formState.isDirty)}</div> |
| <input type="submit" /> |
| </form> |
| ); |
| } |
|
|
| render(<App />); |
|
|
| fireEvent.change(screen.getByRole('textbox'), { |
| target: { value: 'Alex' }, |
| }); |
|
|
| screen.getByText('true'); |
|
|
| fireEvent.change(screen.getByRole('textbox'), { |
| target: { value: 'John' }, |
| }); |
|
|
| screen.getByText('false'); |
| }); |
|
|
| it('should disable the entire form inputs', async () => { |
| function App() { |
| const { register } = useForm({ |
| disabled: true, |
| defaultValues: { |
| lastName: '', |
| firstName: '', |
| }, |
| }); |
|
|
| return ( |
| <form> |
| <input {...register('firstName')} placeholder="firstName" /> |
| <input {...register('lastName')} placeholder="lastName" /> |
| </form> |
| ); |
| } |
|
|
| render(<App />); |
|
|
| await waitFor(() => { |
| expect( |
| (screen.getByPlaceholderText('firstName') as HTMLInputElement).disabled, |
| ).toBeTruthy(); |
| expect( |
| (screen.getByPlaceholderText('lastName') as HTMLInputElement).disabled, |
| ).toBeTruthy(); |
| }); |
| }); |
|
|
| it('should disable the entire form', () => { |
| const App = () => { |
| const [disabled, setDisabled] = useState(false); |
| const { register, control } = useForm({ |
| disabled, |
| }); |
|
|
| return ( |
| <form> |
| <input |
| type={'checkbox'} |
| {...register('checkbox')} |
| data-testid={'checkbox'} |
| /> |
| <input type={'radio'} {...register('radio')} data-testid={'radio'} /> |
| <input type={'range'} {...register('range')} data-testid={'range'} /> |
| <select {...register('select')} data-testid={'select'} /> |
| <textarea {...register('textarea')} data-testid={'textarea'} /> |
| |
| <Controller |
| control={control} |
| render={({ field }) => { |
| return ( |
| <input disabled={field.disabled} data-testid={'controller'} /> |
| ); |
| }} |
| name="test" |
| /> |
| |
| <button |
| type="button" |
| onClick={() => { |
| setDisabled(!disabled); |
| }} |
| > |
| Submit |
| </button> |
| </form> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| expect(screen.getByTestId('checkbox')).toHaveAttribute('disabled'); |
| expect(screen.getByTestId('radio')).toHaveAttribute('disabled'); |
| expect(screen.getByTestId('range')).toHaveAttribute('disabled'); |
| expect(screen.getByTestId('select')).toHaveAttribute('disabled'); |
| expect(screen.getByTestId('textarea')).toHaveAttribute('disabled'); |
| expect(screen.getByTestId('controller')).toHaveAttribute('disabled'); |
|
|
| fireEvent.click(screen.getByRole('button')); |
| expect(screen.getByTestId('checkbox')).not.toBeDisabled(); |
| expect(screen.getByTestId('radio')).not.toBeDisabled(); |
| expect(screen.getByTestId('range')).not.toBeDisabled(); |
| expect(screen.getByTestId('select')).not.toBeDisabled(); |
| expect(screen.getByTestId('textarea')).not.toBeDisabled(); |
| expect(screen.getByTestId('controller')).not.toBeDisabled(); |
| }); |
|
|
| it('should disable form inputs separately from its form', async () => { |
| function App() { |
| const { register } = useForm({ |
| disabled: false, |
| defaultValues: { |
| lastName: '', |
| firstName: '', |
| }, |
| }); |
|
|
| return ( |
| <form> |
| <input |
| {...register('firstName', { disabled: true })} |
| placeholder="firstName" |
| /> |
| <input |
| {...register('lastName', { disabled: false })} |
| placeholder="lastName" |
| /> |
| </form> |
| ); |
| } |
|
|
| render(<App />); |
|
|
| await waitFor(() => { |
| expect( |
| (screen.getByPlaceholderText('firstName') as HTMLInputElement).disabled, |
| ).toBeTruthy(); |
| expect( |
| (screen.getByPlaceholderText('lastName') as HTMLInputElement).disabled, |
| ).toBeFalsy(); |
| }); |
| }); |
|
|
| it('should be able to disable the entire form', async () => { |
| const App = () => { |
| const [disabled, setDisabled] = useState(false); |
| const { register, handleSubmit } = useForm({ |
| disabled, |
| }); |
|
|
| return ( |
| <form |
| onSubmit={handleSubmit(async () => { |
| setDisabled(true); |
| await sleep(100); |
| setDisabled(false); |
| })} |
| > |
| <input |
| type={'checkbox'} |
| {...register('checkbox')} |
| data-testid={'checkbox'} |
| /> |
| <input type={'radio'} {...register('radio')} data-testid={'radio'} /> |
| <input type={'range'} {...register('range')} data-testid={'range'} /> |
| <select {...register('select')} data-testid={'select'} /> |
| <textarea {...register('textarea')} data-testid={'textarea'} /> |
| <button>Submit</button> |
| </form> |
| ); |
| }; |
|
|
| render(<App />); |
|
|
| expect( |
| (screen.getByTestId('textarea') as HTMLTextAreaElement).disabled, |
| ).toBeFalsy(); |
| expect( |
| (screen.getByTestId('range') as HTMLInputElement).disabled, |
| ).toBeFalsy(); |
| expect( |
| (screen.getByTestId('select') as HTMLInputElement).disabled, |
| ).toBeFalsy(); |
| expect( |
| (screen.getByTestId('textarea') as HTMLInputElement).disabled, |
| ).toBeFalsy(); |
|
|
| fireEvent.click(screen.getByRole('button')); |
|
|
| await waitFor(() => { |
| expect( |
| (screen.getByTestId('textarea') as HTMLTextAreaElement).disabled, |
| ).toBeTruthy(); |
| expect( |
| (screen.getByTestId('range') as HTMLInputElement).disabled, |
| ).toBeTruthy(); |
| expect( |
| (screen.getByTestId('select') as HTMLInputElement).disabled, |
| ).toBeTruthy(); |
| expect( |
| (screen.getByTestId('textarea') as HTMLInputElement).disabled, |
| ).toBeTruthy(); |
| }); |
|
|
| await waitFor(() => { |
| expect( |
| (screen.getByTestId('textarea') as HTMLTextAreaElement).disabled, |
| ).toBeFalsy(); |
| expect( |
| (screen.getByTestId('range') as HTMLInputElement).disabled, |
| ).toBeFalsy(); |
| expect( |
| (screen.getByTestId('select') as HTMLInputElement).disabled, |
| ).toBeFalsy(); |
| expect( |
| (screen.getByTestId('textarea') as HTMLInputElement).disabled, |
| ).toBeFalsy(); |
| }); |
| }); |
|
|
| it('should allow to submit a form with disabled form fields', async () => { |
| function App() { |
| const { register, getFieldState, formState, handleSubmit } = useForm(); |
|
|
| return ( |
| <form onSubmit={handleSubmit(() => {})}> |
| <input |
| {...register('firstName', { disabled: true, required: true })} |
| placeholder="firstName" |
| /> |
| <p> |
| {getFieldState('firstName', formState).error |
| ? 'has error' |
| : 'no error'} |
| </p> |
| <input type="submit" value="Submit" /> |
| </form> |
| ); |
| } |
|
|
| render(<App />); |
|
|
| await act(() => { |
| fireEvent.click(screen.getByRole('button')); |
| }); |
|
|
| await waitFor(() => { |
| expect( |
| (screen.getByPlaceholderText('firstName') as HTMLInputElement).disabled, |
| ).toBeTruthy(); |
| expect( |
| screen.getByText('no error') as HTMLInputElement, |
| ).toBeInTheDocument(); |
| }); |
| }); |
|
|
| describe('when given formControl', () => { |
| it('accepts default values', async () => { |
| type FormValues = { |
| firstName: string; |
| }; |
|
|
| const { register, handleSubmit, formControl } = |
| createFormControl<FormValues>(); |
|
|
| function FormComponent({ |
| onSubmit, |
| defaultValues, |
| }: { |
| defaultValues: FormValues; |
| onSubmit: SubmitHandler<FormValues>; |
| }) { |
| useForm({ |
| formControl, |
| defaultValues, |
| }); |
| return ( |
| <form onSubmit={handleSubmit(onSubmit)}> |
| <input {...register('firstName')} placeholder="First Name" /> |
| <input type="submit" /> |
| </form> |
| ); |
| } |
|
|
| function App() { |
| const [state, setState] = React.useState(''); |
| return ( |
| <div> |
| <FormComponent |
| defaultValues={{ firstName: 'Emilia' }} |
| onSubmit={(data) => { |
| setState(JSON.stringify(data)); |
| }} |
| /> |
| <pre>{state}</pre> |
| </div> |
| ); |
| } |
|
|
| render(<App />); |
|
|
| const input = screen.getAllByRole<HTMLInputElement>('textbox')[0]; |
| expect(input.value).toBe('Emilia'); |
|
|
| fireEvent.input(input, { target: { value: 'abc' } }); |
| expect(input.value).toBe('abc'); |
| }); |
| }); |
| }); |
|
|
