|
|
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'); |
|
|
}); |
|
|
}); |
|
|
}); |
|
|
|
