|
|
import React from 'react'; |
|
|
import { |
|
|
act, |
|
|
fireEvent, |
|
|
render, |
|
|
renderHook, |
|
|
screen, |
|
|
waitFor, |
|
|
waitForElementToBeRemoved, |
|
|
} from '@testing-library/react'; |
|
|
|
|
|
import { VALIDATION_MODE } from '../../constants'; |
|
|
import { Controller } from '../../controller'; |
|
|
import type { UseFormRegister } from '../../types'; |
|
|
import { useForm } from '../../useForm'; |
|
|
import { FormProvider, useFormContext } from '../../useFormContext'; |
|
|
import isFunction from '../../utils/isFunction'; |
|
|
import isString from '../../utils/isString'; |
|
|
import noop from '../../utils/noop'; |
|
|
|
|
|
describe('register', () => { |
|
|
it('should support register passed to ref', async () => { |
|
|
const { result } = renderHook(() => |
|
|
useForm<{ test: string }>({ |
|
|
defaultValues: { |
|
|
test: 'testData', |
|
|
}, |
|
|
}), |
|
|
); |
|
|
|
|
|
const { ref } = result.current.register('test'); |
|
|
|
|
|
isFunction(ref) && |
|
|
ref({ |
|
|
target: { |
|
|
value: 'testData', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await act(async () => { |
|
|
await result.current.handleSubmit((data) => { |
|
|
expect(data).toEqual({ |
|
|
test: 'testData', |
|
|
}); |
|
|
})({ |
|
|
preventDefault: noop, |
|
|
persist: noop, |
|
|
} as React.SyntheticEvent); |
|
|
}); |
|
|
}); |
|
|
|
|
|
test.each([['text'], ['radio'], ['checkbox']])( |
|
|
'should register field for %s type and remain its value after unmount', |
|
|
async (type) => { |
|
|
const Component = () => { |
|
|
const { |
|
|
register, |
|
|
watch, |
|
|
formState: { isDirty }, |
|
|
} = useForm<{ |
|
|
test: string; |
|
|
}>({ |
|
|
defaultValues: { |
|
|
test: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
const test = watch('test'); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input type={type} {...register('test')} /> |
|
|
<span role="alert">{`${isDirty}`}</span> |
|
|
{test} |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
const ref = screen.getByRole(type === 'text' ? 'textbox' : type); |
|
|
|
|
|
ref.remove(); |
|
|
|
|
|
expect(screen.getByRole('alert').textContent).toBe('false'); |
|
|
|
|
|
expect(screen.getByText('test')).toBeVisible(); |
|
|
}, |
|
|
); |
|
|
|
|
|
test.each([['text'], ['radio'], ['checkbox']])( |
|
|
'should not register the same %s input', |
|
|
async (type) => { |
|
|
const callback = jest.fn(); |
|
|
const Component = () => { |
|
|
const { register, handleSubmit } = useForm<{ |
|
|
test: string; |
|
|
}>(); |
|
|
return ( |
|
|
<div> |
|
|
<input type={type} {...register('test')} /> |
|
|
|
|
|
<button onClick={handleSubmit(callback)}>submit</button> |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: /submit/ })); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(callback).toHaveBeenCalledWith( |
|
|
{ |
|
|
test: type === 'checkbox' ? false : type === 'radio' ? null : '', |
|
|
}, |
|
|
expect.any(Object), |
|
|
), |
|
|
); |
|
|
}, |
|
|
); |
|
|
|
|
|
it('should determine checkbox group by type of reference value', async () => { |
|
|
const callback = jest.fn(); |
|
|
const Component = () => { |
|
|
const { register, handleSubmit } = useForm<{ |
|
|
test: string[]; |
|
|
}>({ |
|
|
defaultValues: { |
|
|
test: [], |
|
|
}, |
|
|
}); |
|
|
return ( |
|
|
<div> |
|
|
<input type="checkbox" value="A" {...register('test')} /> |
|
|
|
|
|
<button onClick={handleSubmit(callback)}>submit</button> |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('checkbox')); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: /submit/ })); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(callback).toHaveBeenCalledWith( |
|
|
{ |
|
|
test: ['A'], |
|
|
}, |
|
|
expect.any(Object), |
|
|
), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should re-render if errors occurred with resolver when formState.isValid is defined', async () => { |
|
|
const Component = () => { |
|
|
const { register, formState } = useForm<{ test: string }>({ |
|
|
resolver: async (data) => { |
|
|
return { |
|
|
values: data, |
|
|
errors: { |
|
|
test: { |
|
|
type: 'test', |
|
|
}, |
|
|
}, |
|
|
}; |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<div> |
|
|
<input {...register('test')} /> |
|
|
<span role="alert">{`${formState.isValid}`}</span> |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
expect(screen.getByRole('alert').textContent).toBe('false'); |
|
|
}); |
|
|
|
|
|
it('should be set default value when item is remounted again', async () => { |
|
|
const { result, unmount } = renderHook(() => useForm<{ test: string }>()); |
|
|
|
|
|
result.current.register('test'); |
|
|
|
|
|
result.current.setValue('test', 'test'); |
|
|
|
|
|
unmount(); |
|
|
|
|
|
const ref = { type: 'text', name: 'test' }; |
|
|
|
|
|
result.current.register('test'); |
|
|
|
|
|
expect(ref).toEqual({ type: 'text', name: 'test' }); |
|
|
|
|
|
expect(result.current.getValues()).toEqual({ test: 'test' }); |
|
|
}); |
|
|
|
|
|
|
|
|
it('should reset isValid formState after reset with valid value in initial render', async () => { |
|
|
const Component = () => { |
|
|
const { register, reset, formState } = useForm<{ |
|
|
issue: string; |
|
|
test: string; |
|
|
}>({ |
|
|
mode: VALIDATION_MODE.onChange, |
|
|
}); |
|
|
|
|
|
React.useEffect(() => { |
|
|
setTimeout(() => { |
|
|
reset({ issue: 'test', test: 'test' }); |
|
|
}); |
|
|
}, [reset]); |
|
|
|
|
|
return ( |
|
|
<div> |
|
|
<input {...register('test', { required: true })} /> |
|
|
<input type="text" {...register('issue', { required: true })} /> |
|
|
<button disabled={!formState.isValid}>submit</button> |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
await waitFor(() => { |
|
|
expect(screen.getByRole('button')).not.toBeDisabled(); |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should update isValid correctly with custom registered input', async () => { |
|
|
function Component() { |
|
|
const { |
|
|
register, |
|
|
setValue, |
|
|
formState: { isValid }, |
|
|
} = useForm({ |
|
|
defaultValues: { a: 'default', b: '' }, |
|
|
mode: 'onChange', |
|
|
}); |
|
|
|
|
|
React.useEffect(() => { |
|
|
register('a', { |
|
|
required: 'required', |
|
|
}); |
|
|
register('b', { |
|
|
required: 'required', |
|
|
}); |
|
|
}, [register]); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input |
|
|
placeholder={'inputA'} |
|
|
onChange={({ target: { value } }) => |
|
|
setValue('a', value, { shouldDirty: true, shouldValidate: true }) |
|
|
} |
|
|
/> |
|
|
<input |
|
|
placeholder={'inputB'} |
|
|
onChange={({ target: { value } }) => |
|
|
setValue('b', value, { shouldDirty: true, shouldValidate: true }) |
|
|
} |
|
|
/> |
|
|
<div>{String(isValid)}</div> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
expect(screen.getByText('false')).toBeVisible(); |
|
|
|
|
|
fireEvent.input(screen.getByPlaceholderText('inputA'), { |
|
|
target: { value: 'test' }, |
|
|
}); |
|
|
|
|
|
expect(await screen.findByText('false')).toBeVisible(); |
|
|
|
|
|
fireEvent.input(screen.getByPlaceholderText('inputB'), { |
|
|
target: { value: 'test' }, |
|
|
}); |
|
|
|
|
|
expect(await screen.findByText('true')).toBeVisible(); |
|
|
}); |
|
|
|
|
|
it('should custom register with value and can be updated', async () => { |
|
|
const App = () => { |
|
|
const [inputValue, setInput] = React.useState(1); |
|
|
const [data, setData] = React.useState(''); |
|
|
const { handleSubmit, register, setValue } = useForm<{ test: string }>(); |
|
|
|
|
|
React.useEffect(() => { |
|
|
register('test', { |
|
|
value: 'bill', |
|
|
}); |
|
|
}, [register]); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<button |
|
|
type={'button'} |
|
|
onClick={handleSubmit((data) => { |
|
|
setData(data.test); |
|
|
})} |
|
|
> |
|
|
handleSubmit |
|
|
</button> |
|
|
<button |
|
|
type={'button'} |
|
|
onClick={() => { |
|
|
setValue('test', '1234'); |
|
|
setInput(inputValue + 1); |
|
|
}} |
|
|
> |
|
|
update |
|
|
</button> |
|
|
<p>{data}</p> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'handleSubmit' })); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'update' })); |
|
|
|
|
|
expect(await screen.findByText('bill')).toBeVisible(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'handleSubmit' })); |
|
|
|
|
|
expect(await screen.findByText('1234')).toBeVisible(); |
|
|
}); |
|
|
|
|
|
it('should not affect or check against defaultChecked inputs', async () => { |
|
|
type FormValues = Partial<{ |
|
|
radio: string; |
|
|
checkbox: string[]; |
|
|
}>; |
|
|
let output: FormValues; |
|
|
|
|
|
output = {}; |
|
|
|
|
|
function Component() { |
|
|
const { register, handleSubmit } = useForm<FormValues>(); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((data) => { |
|
|
output = data; |
|
|
})} |
|
|
> |
|
|
<input {...register('radio')} type="radio" value="Yes" /> |
|
|
<input |
|
|
{...register('radio')} |
|
|
type="radio" |
|
|
value="No" |
|
|
defaultChecked |
|
|
/> |
|
|
<input {...register('checkbox')} type="checkbox" value="Yes" /> |
|
|
<input |
|
|
{...register('checkbox')} |
|
|
type="checkbox" |
|
|
value="No" |
|
|
defaultChecked |
|
|
/> |
|
|
<button /> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(output).toEqual({ |
|
|
checkbox: ['No'], |
|
|
radio: 'No', |
|
|
}), |
|
|
); |
|
|
}); |
|
|
|
|
|
describe('when defaultValue is provided', () => { |
|
|
it('should check checkbox by default when value matches', async () => { |
|
|
type FormValues = Partial<{ |
|
|
checkbox: string; |
|
|
}>; |
|
|
|
|
|
function Component() { |
|
|
const { register } = useForm<FormValues>({ |
|
|
defaultValues: { |
|
|
checkbox: 'A', |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('checkbox')} type="checkbox" value="A" /> |
|
|
<button /> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
expect((screen.getByRole('checkbox') as HTMLInputElement).checked).toBe( |
|
|
true, |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should not check checkboxes when defaultValue is empty array', async () => { |
|
|
type FormValues = Partial<{ |
|
|
checkbox: string[]; |
|
|
}>; |
|
|
|
|
|
function Component() { |
|
|
const { register } = useForm<FormValues>({ |
|
|
defaultValues: { |
|
|
checkbox: [], |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('checkbox')} type="checkbox" value="A" /> |
|
|
<button /> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
expect((screen.getByRole('checkbox') as HTMLInputElement).checked).toBe( |
|
|
false, |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should only check checkboxes when array defaultValue includes input value', async () => { |
|
|
type FormValues = Partial<{ |
|
|
checkbox: string[]; |
|
|
}>; |
|
|
|
|
|
function Component() { |
|
|
const { register } = useForm<FormValues>({ |
|
|
defaultValues: { |
|
|
checkbox: ['B'], |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input |
|
|
{...register('checkbox')} |
|
|
type="checkbox" |
|
|
value="A" |
|
|
aria-label="checkbox-A" |
|
|
/> |
|
|
<input {...register('checkbox')} type="checkbox" value="B" /> |
|
|
<button /> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
expect( |
|
|
(screen.getByLabelText('checkbox-A') as HTMLInputElement).checked, |
|
|
).toBe(false); |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should remove input value and reference with shouldUnregister: true', () => { |
|
|
type FormValue = { |
|
|
test: string; |
|
|
}; |
|
|
const watchedValue: FormValue[] = []; |
|
|
const Component = () => { |
|
|
const { register, watch } = useForm<FormValue>({ |
|
|
defaultValues: { |
|
|
test: 'bill', |
|
|
}, |
|
|
}); |
|
|
const [show, setShow] = React.useState(true); |
|
|
watchedValue.push(watch()); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
{show && <input {...register('test', { shouldUnregister: true })} />} |
|
|
<button onClick={() => setShow(false)}>hide</button> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
expect(watchedValue.at(-1)).toEqual({ test: 'bill' }); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
|
|
|
expect(watchedValue).toEqual([ |
|
|
{ |
|
|
test: 'bill', |
|
|
}, |
|
|
{ |
|
|
test: 'bill', |
|
|
}, |
|
|
{ |
|
|
test: 'bill', |
|
|
}, |
|
|
{}, |
|
|
]); |
|
|
}); |
|
|
|
|
|
it('should keep defaultValue with shouldUnregister: true when input unmounts', () => { |
|
|
type FormValue = { |
|
|
test: string; |
|
|
}; |
|
|
|
|
|
const Component = () => { |
|
|
const { register } = useForm<FormValue>({ |
|
|
defaultValues: { |
|
|
test: 'bill', |
|
|
}, |
|
|
shouldUnregister: true, |
|
|
}); |
|
|
const [show, setShow] = React.useState(true); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
{show && <input {...register('test', { shouldUnregister: true })} />} |
|
|
<button onClick={() => setShow(!show)}>hide</button> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
|
|
'bill', |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
|
|
'bill', |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should skip register absent fields which are checkbox/radio inputs', async () => { |
|
|
let data: unknown; |
|
|
|
|
|
const App = () => { |
|
|
const { register, handleSubmit } = useForm({ |
|
|
defaultValues: { |
|
|
test: ['1', '2', '3'], |
|
|
nested: { |
|
|
test: {}, |
|
|
test1: [], |
|
|
}, |
|
|
}, |
|
|
}); |
|
|
return ( |
|
|
<form onSubmit={handleSubmit((d) => (data = d))}> |
|
|
<input type="checkbox" {...register('test')} value={'1'} /> |
|
|
<input type="checkbox" {...register('test')} value={'2'} /> |
|
|
<input type="checkbox" {...register('test')} value={'3'} /> |
|
|
<button>Submit</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(data).toEqual({ |
|
|
nested: { |
|
|
test: {}, |
|
|
test1: [], |
|
|
}, |
|
|
test: ['1', '2', '3'], |
|
|
}), |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getAllByRole('checkbox')[0]); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(data).toEqual({ |
|
|
test: ['2', '3'], |
|
|
nested: { |
|
|
test: {}, |
|
|
test1: [], |
|
|
}, |
|
|
}), |
|
|
); |
|
|
}); |
|
|
|
|
|
describe('register disabled', () => { |
|
|
it('should return undefined for disabled inputs', async () => { |
|
|
let output = {}; |
|
|
const defaultValues = { |
|
|
test: true, |
|
|
}; |
|
|
|
|
|
function App() { |
|
|
const { register, handleSubmit } = useForm({ |
|
|
defaultValues: defaultValues, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((values) => { |
|
|
output = values; |
|
|
})} |
|
|
> |
|
|
{[ |
|
|
{ value: 'test', label: 'test' }, |
|
|
{ value: 'test1', label: 'test1' }, |
|
|
].map((item) => ( |
|
|
<input |
|
|
key={item.value} |
|
|
type="checkbox" |
|
|
{...register('test', { |
|
|
disabled: true, |
|
|
})} |
|
|
/> |
|
|
))} |
|
|
<button type="submit">submit</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(output).toEqual({ |
|
|
test: undefined, |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should still show all inputs which has disabled set to true', async () => { |
|
|
let outputData: object = {}; |
|
|
const watchedData: object[] = []; |
|
|
|
|
|
const Component = () => { |
|
|
const { register, handleSubmit, watch } = useForm<{ |
|
|
test?: string; |
|
|
test1?: string; |
|
|
test2?: string; |
|
|
test3?: string; |
|
|
test4: string; |
|
|
}>(); |
|
|
|
|
|
watchedData.push(watch()); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((data) => { |
|
|
outputData = data; |
|
|
})} |
|
|
> |
|
|
<input {...register('test')} disabled /> |
|
|
<input |
|
|
disabled |
|
|
value={'test'} |
|
|
type={'checkbox'} |
|
|
{...register('test1')} |
|
|
/> |
|
|
<input |
|
|
disabled |
|
|
value={'test'} |
|
|
type={'radio'} |
|
|
{...register('test2')} |
|
|
/> |
|
|
<select {...register('test3')} disabled /> |
|
|
<input {...register('test4')} data-testid={'input'} /> |
|
|
<button>Submit</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.change(screen.getByTestId('input'), { |
|
|
target: { value: '1234' }, |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(watchedData).toStrictEqual([ |
|
|
{}, |
|
|
{ |
|
|
test: '', |
|
|
test1: false, |
|
|
test2: null, |
|
|
test3: '', |
|
|
test4: '', |
|
|
}, |
|
|
{ |
|
|
test: '', |
|
|
test1: false, |
|
|
test2: null, |
|
|
test3: '', |
|
|
test4: '1234', |
|
|
}, |
|
|
]); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(outputData).toStrictEqual({ |
|
|
test: '', |
|
|
test1: false, |
|
|
test2: null, |
|
|
test3: '', |
|
|
test4: '1234', |
|
|
}), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should validate value after toggling enabled/disabled on input', async () => { |
|
|
const defaultValue = 'Test'; |
|
|
const validate = jest.fn(); |
|
|
const submit = jest.fn(); |
|
|
const onSubmit = (values: unknown) => { |
|
|
submit(values); |
|
|
}; |
|
|
|
|
|
const App = () => { |
|
|
const [editable, setEditable] = React.useState(false); |
|
|
const { register, handleSubmit } = useForm(); |
|
|
|
|
|
return ( |
|
|
<form onSubmit={handleSubmit(onSubmit)}> |
|
|
<input |
|
|
defaultValue={defaultValue} |
|
|
{...register('test', { validate, disabled: !editable })} |
|
|
/> |
|
|
<button type="button" onClick={() => setEditable(!editable)}> |
|
|
Toggle Edit |
|
|
</button> |
|
|
<button type="submit">Submit</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect(validate).toBeCalledTimes(0); |
|
|
|
|
|
fireEvent.click(screen.getByText('Toggle Edit')); |
|
|
fireEvent.click(screen.getByText('Submit')); |
|
|
|
|
|
expect(validate).toBeCalledWith(defaultValue, { test: 'Test' }); |
|
|
await waitFor(() => |
|
|
expect(submit).toBeCalledWith({ test: defaultValue }), |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getByText('Toggle Edit')); |
|
|
fireEvent.click(screen.getByText('Submit')); |
|
|
|
|
|
await waitFor(() => expect(submit).toBeCalledWith({ test: undefined })); |
|
|
}); |
|
|
|
|
|
it('should not throw errors with disabled input', async () => { |
|
|
const message = 'Must have at least one checked!'; |
|
|
|
|
|
function Checkbox() { |
|
|
const { register } = useFormContext(); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<p> |
|
|
Must select: |
|
|
<input |
|
|
type="checkbox" |
|
|
value="test" |
|
|
{...register('test', { |
|
|
disabled: false, |
|
|
validate: (value) => { |
|
|
return value && value.length > 0 ? true : message; |
|
|
}, |
|
|
})} |
|
|
/> |
|
|
A |
|
|
</p> |
|
|
</> |
|
|
); |
|
|
} |
|
|
|
|
|
function App() { |
|
|
const formMethods = useForm({ |
|
|
mode: 'onSubmit', |
|
|
defaultValues: { test: '' }, |
|
|
}); |
|
|
const { handleSubmit, formState } = formMethods; |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<FormProvider {...formMethods}> |
|
|
<form onSubmit={handleSubmit(noop)}> |
|
|
<Checkbox /> |
|
|
<button>Submit</button> |
|
|
<p>{formState.errors.test?.message}</p> |
|
|
</form> |
|
|
</FormProvider> |
|
|
</> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(await screen.findByText(message)).toBeVisible(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('checkbox')); |
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(screen.queryByText(message)).not.toBeInTheDocument(), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should affect a group of checked attribute with disabled attribute', () => { |
|
|
const App = () => { |
|
|
const { register } = useForm(); |
|
|
const options = [ |
|
|
{ checked: false, disabled: false, value: 'test' }, |
|
|
{ checked: true, disabled: true, value: 'test1' }, |
|
|
{ checked: false, disabled: false, value: 'test2' }, |
|
|
]; |
|
|
|
|
|
return ( |
|
|
<> |
|
|
{options.map((option, index) => { |
|
|
return ( |
|
|
<div key={index}> |
|
|
<input |
|
|
{...register('test')} |
|
|
type="checkbox" |
|
|
disabled={option.disabled} |
|
|
value={option.value} |
|
|
defaultChecked={option.checked} |
|
|
data-testid={'checkbox' + index} |
|
|
/> |
|
|
</div> |
|
|
); |
|
|
})} |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect( |
|
|
(screen.getByTestId('checkbox0') as HTMLInputElement).checked, |
|
|
).toBeFalsy(); |
|
|
expect( |
|
|
(screen.getByTestId('checkbox1') as HTMLInputElement).checked, |
|
|
).toBeTruthy(); |
|
|
expect( |
|
|
(screen.getByTestId('checkbox2') as HTMLInputElement).checked, |
|
|
).toBeFalsy(); |
|
|
}); |
|
|
|
|
|
it('should affect a single checked attribute with disabled attribute', () => { |
|
|
const App = () => { |
|
|
const { register } = useForm<{ |
|
|
test: boolean; |
|
|
test1: boolean; |
|
|
test2: boolean; |
|
|
}>({ |
|
|
defaultValues: { |
|
|
test: true, |
|
|
test1: true, |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<div> |
|
|
<input |
|
|
{...register('test')} |
|
|
type="checkbox" |
|
|
disabled={true} |
|
|
data-testid="checkbox1" |
|
|
/> |
|
|
<input |
|
|
{...register('test1')} |
|
|
type="checkbox" |
|
|
disabled={true} |
|
|
data-testid="checkbox2" |
|
|
/> |
|
|
<input |
|
|
{...register('test2')} |
|
|
type="checkbox" |
|
|
disabled={true} |
|
|
defaultChecked={true} |
|
|
data-testid="checkbox3" |
|
|
/> |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect( |
|
|
(screen.getByTestId('checkbox1') as HTMLInputElement).checked, |
|
|
).toBeTruthy(); |
|
|
expect( |
|
|
(screen.getByTestId('checkbox2') as HTMLInputElement).checked, |
|
|
).toBeTruthy(); |
|
|
expect( |
|
|
(screen.getByTestId('checkbox3') as HTMLInputElement).checked, |
|
|
).toBeTruthy(); |
|
|
}); |
|
|
|
|
|
it('should work correctly with toggle disabled attribute and validation', async () => { |
|
|
type FormValues = { |
|
|
test: string; |
|
|
}; |
|
|
|
|
|
function Input({ |
|
|
disabled, |
|
|
register, |
|
|
}: { |
|
|
disabled: boolean; |
|
|
register: UseFormRegister<FormValues>; |
|
|
}) { |
|
|
const options = { |
|
|
disabled, |
|
|
validate: (value: string) => { |
|
|
return value && value.length > 0 |
|
|
? true |
|
|
: 'Must have at least one checked!'; |
|
|
}, |
|
|
}; |
|
|
|
|
|
return ( |
|
|
<input type="checkbox" value="a" {...register('test', options)} /> |
|
|
); |
|
|
} |
|
|
|
|
|
const App = () => { |
|
|
const [value, setValue] = React.useState({}); |
|
|
const [disabled, setDisabled] = React.useState(false); |
|
|
const { |
|
|
register, |
|
|
handleSubmit, |
|
|
formState: { errors }, |
|
|
} = useForm<FormValues>(); |
|
|
|
|
|
return ( |
|
|
<form onSubmit={handleSubmit(setValue)}> |
|
|
<Input register={register} disabled={disabled} /> |
|
|
{errors.test && <p>error</p>} |
|
|
<button type={'button'} onClick={() => setDisabled(!disabled)}> |
|
|
setDisabled |
|
|
</button> |
|
|
<button>submit</button> |
|
|
<p>{JSON.stringify(value)}</p> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('checkbox')); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
expect(await screen.findByText('{"test":"a"}')).toBeVisible(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'setDisabled' })); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
expect(await screen.findByText('{}')).toBeVisible(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'setDisabled' })); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
expect(await screen.findByText('{"test":"a"}')).toBeVisible(); |
|
|
}); |
|
|
}); |
|
|
|
|
|
describe('register valueAs', () => { |
|
|
it('should return number value with valueAsNumber', async () => { |
|
|
let output = {}; |
|
|
const Component = () => { |
|
|
const { register, handleSubmit } = useForm<{ |
|
|
test: number; |
|
|
test1: boolean; |
|
|
}>(); |
|
|
|
|
|
return ( |
|
|
<form onSubmit={handleSubmit((data) => (output = data))}> |
|
|
<input {...register('test', { valueAsNumber: true })} /> |
|
|
<input |
|
|
{...register('test1', { |
|
|
setValueAs: (value: string) => value === 'true', |
|
|
})} |
|
|
/> |
|
|
<button>submit</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.input(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: '12345', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.input(screen.getAllByRole('textbox')[1], { |
|
|
target: { |
|
|
value: 'true', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => expect(output).toEqual({ test: 12345, test1: true })); |
|
|
}); |
|
|
|
|
|
it('should return undefined value with setValueAs', async () => { |
|
|
let output = {}; |
|
|
const Component = () => { |
|
|
const { register, handleSubmit } = useForm<{ |
|
|
test: number; |
|
|
}>(); |
|
|
|
|
|
return ( |
|
|
<form onSubmit={handleSubmit((data) => (output = data))}> |
|
|
<input |
|
|
{...register('test', { |
|
|
setValueAs: (value: string) => |
|
|
value === '' ? undefined : +value, |
|
|
})} |
|
|
defaultValue={12345} |
|
|
/> |
|
|
<button>submit</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.input(screen.getByRole('textbox'), { |
|
|
target: { |
|
|
value: '', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(output).toEqual({ test: undefined }); |
|
|
}); |
|
|
|
|
|
it('should return NaN when value is valid', async () => { |
|
|
let output = {}; |
|
|
const Component = () => { |
|
|
const { register, handleSubmit } = useForm<{ |
|
|
test: number; |
|
|
}>(); |
|
|
|
|
|
return ( |
|
|
<form onSubmit={handleSubmit((data) => (output = data))}> |
|
|
<input {...register('test', { valueAsNumber: true })} /> |
|
|
<button>submit</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.input(screen.getByRole('textbox'), { |
|
|
target: { |
|
|
value: '', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => expect(output).toEqual({ test: NaN })); |
|
|
}); |
|
|
|
|
|
it('should validate input before the valueAs', async () => { |
|
|
const Component = () => { |
|
|
const { |
|
|
register, |
|
|
formState: { errors }, |
|
|
} = useForm<{ |
|
|
test: number; |
|
|
test1: number; |
|
|
}>({ |
|
|
mode: 'onChange', |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<input |
|
|
{...register('test', { |
|
|
validate: (data) => { |
|
|
return !isString(data); |
|
|
}, |
|
|
})} |
|
|
/> |
|
|
<span role="alert">{errors.test && 'Not number'}</span> |
|
|
|
|
|
<input |
|
|
{...register('test1', { |
|
|
valueAsNumber: true, |
|
|
min: 20, |
|
|
})} |
|
|
/> |
|
|
<span role="alert">{errors.test1 && 'Number length'}</span> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: '123', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(await screen.findByText('Not number')).toBeVisible(); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { |
|
|
value: '12', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(await screen.findByText('Number length')).toBeVisible(); |
|
|
}); |
|
|
|
|
|
it('should be able to validate against formValues', async () => { |
|
|
const App = () => { |
|
|
const { |
|
|
register, |
|
|
formState: { errors }, |
|
|
} = useForm({ |
|
|
mode: 'onChange', |
|
|
defaultValues: { |
|
|
test: '', |
|
|
test1: '', |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<input |
|
|
{...register('test', { |
|
|
validate: (data, formValues) => data === formValues.test1, |
|
|
})} |
|
|
/> |
|
|
<span role="alert">{errors.test ? 'Not number' : 'No error'}</span> |
|
|
|
|
|
<input {...register('test1')} /> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: '1', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await waitFor(() => screen.findByText('Not number')); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { |
|
|
value: '11', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: '11', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await waitFor(() => screen.findByText('No error')); |
|
|
}); |
|
|
|
|
|
it('should send valueAs fields to schema validation', () => { |
|
|
let output: any; |
|
|
|
|
|
const Component = () => { |
|
|
const { register, trigger } = useForm<{ |
|
|
test: number; |
|
|
test1: any; |
|
|
test2: boolean; |
|
|
}>({ |
|
|
resolver: (data) => { |
|
|
output = data; |
|
|
return { |
|
|
values: { |
|
|
test: 1, |
|
|
test1: 2, |
|
|
test2: true, |
|
|
}, |
|
|
errors: {}, |
|
|
}; |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('test', { valueAsNumber: true })} /> |
|
|
<input {...register('test1', { valueAsDate: true })} /> |
|
|
<input |
|
|
{...register('test2', { setValueAs: (data) => data === 'test' })} |
|
|
/> |
|
|
<button type="button" onClick={() => trigger()}> |
|
|
trigger |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { value: 1 }, |
|
|
}); |
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { value: '1990' }, |
|
|
}); |
|
|
fireEvent.change(screen.getAllByRole('textbox')[2], { |
|
|
target: { value: 'test' }, |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(output).toEqual({ |
|
|
test: 1, |
|
|
|
|
|
test1: new Date('1990'), |
|
|
test2: true, |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should send valueAs fields to in build validator', async () => { |
|
|
const Component = () => { |
|
|
const { |
|
|
register, |
|
|
trigger, |
|
|
formState: { errors }, |
|
|
} = useForm({ |
|
|
mode: 'onChange', |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<input |
|
|
{...register('test', { |
|
|
validate: (value) => { |
|
|
return value === 1; |
|
|
}, |
|
|
valueAsNumber: true, |
|
|
})} |
|
|
/> |
|
|
{errors.test && <p>test error</p>} |
|
|
<input |
|
|
{...register('test1', { |
|
|
validate: (value) => { |
|
|
return value === 1; |
|
|
}, |
|
|
setValueAs: (value) => parseInt(value), |
|
|
})} |
|
|
/> |
|
|
{errors.test1 && <p>test1 error</p>} |
|
|
<button onClick={() => trigger()}>trigger</button> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(await screen.findByText('test error')).toBeVisible(); |
|
|
expect(screen.getByText('test1 error')).toBeVisible(); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: '1', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { |
|
|
value: '1', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await waitForElementToBeRemoved(screen.queryByText('test error')); |
|
|
expect(screen.queryByText('test1 error')).not.toBeInTheDocument(); |
|
|
}); |
|
|
|
|
|
it('should send valueAs fields to resolver', async () => { |
|
|
const Component = () => { |
|
|
const { |
|
|
register, |
|
|
trigger, |
|
|
formState: { errors }, |
|
|
} = useForm<{ |
|
|
test: number; |
|
|
test1: number; |
|
|
}>({ |
|
|
mode: 'onChange', |
|
|
resolver: async (data) => { |
|
|
const valid = !(isNaN(data.test) && isNaN(data.test1)); |
|
|
|
|
|
return { |
|
|
errors: valid |
|
|
? {} |
|
|
: { |
|
|
test: { |
|
|
type: 'error', |
|
|
message: 'issue', |
|
|
}, |
|
|
test1: { |
|
|
type: 'error', |
|
|
message: 'issue', |
|
|
}, |
|
|
}, |
|
|
values: valid |
|
|
? { |
|
|
test: 1, |
|
|
test1: 2, |
|
|
} |
|
|
: {}, |
|
|
}; |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<input |
|
|
{...register('test', { |
|
|
validate: (value) => { |
|
|
return value === 1; |
|
|
}, |
|
|
valueAsNumber: true, |
|
|
})} |
|
|
/> |
|
|
{errors.test && <p>test error</p>} |
|
|
<input |
|
|
{...register('test1', { |
|
|
validate: (value) => { |
|
|
return value === 1; |
|
|
}, |
|
|
setValueAs: (value) => parseInt(value), |
|
|
})} |
|
|
/> |
|
|
{errors.test && <p>test1 error</p>} |
|
|
<button onClick={() => trigger()}>trigger</button> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<Component />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(await screen.findByText('test error')).toBeVisible(); |
|
|
expect(screen.getByText('test1 error')).toBeVisible(); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: '1', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { |
|
|
value: '1', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await waitForElementToBeRemoved(screen.queryByText('test error')); |
|
|
expect(screen.queryByText('test1 error')).not.toBeInTheDocument(); |
|
|
}); |
|
|
|
|
|
it('should still validate with an error existed', async () => { |
|
|
function App() { |
|
|
const { |
|
|
register, |
|
|
handleSubmit, |
|
|
setError, |
|
|
formState: { errors }, |
|
|
} = useForm<{ firstName: string }>(); |
|
|
const { name, ref, onBlur, onChange } = register('firstName'); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit(() => { |
|
|
setError('firstName', { |
|
|
type: 'manual', |
|
|
message: 'Empty', |
|
|
}); |
|
|
})} |
|
|
> |
|
|
<input |
|
|
placeholder="First Name" |
|
|
name={name} |
|
|
ref={ref} |
|
|
onBlur={onBlur} |
|
|
onChange={onChange} |
|
|
/> |
|
|
{errors.firstName && <div>{errors.firstName.message}</div>} |
|
|
<input type="submit" /> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(await screen.findByText('Empty')).toBeVisible(); |
|
|
|
|
|
fireEvent.change(screen.getByRole('textbox'), { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await waitForElementToBeRemoved(screen.queryByText('Empty')); |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should not register nested input', () => { |
|
|
const watchedValue: unknown[] = []; |
|
|
let inputs: unknown; |
|
|
|
|
|
const Checkboxes = ({ |
|
|
value, |
|
|
onChange, |
|
|
}: { |
|
|
value: boolean[]; |
|
|
onChange: (value: boolean[]) => void; |
|
|
}) => { |
|
|
const [checkboxValue, setCheckboxValue] = React.useState(value); |
|
|
|
|
|
return ( |
|
|
<div> |
|
|
{value.map((_, index) => ( |
|
|
<input |
|
|
key={index} |
|
|
onChange={(e) => { |
|
|
const updatedValue = checkboxValue.map((item, i) => { |
|
|
if (index === i) { |
|
|
return e.target.checked; |
|
|
} |
|
|
return item; |
|
|
}); |
|
|
|
|
|
setCheckboxValue(updatedValue); |
|
|
onChange(updatedValue); |
|
|
}} |
|
|
type="checkbox" |
|
|
checked={checkboxValue[index]} |
|
|
/> |
|
|
))} |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
function App() { |
|
|
const { control, watch } = useForm({ |
|
|
defaultValues: { |
|
|
test: [true, false, false], |
|
|
}, |
|
|
}); |
|
|
inputs = control._fields; |
|
|
watchedValue.push(watch()); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<Controller |
|
|
name="test" |
|
|
control={control} |
|
|
render={({ field }) => ( |
|
|
<Checkboxes onChange={field.onChange} value={field.value} /> |
|
|
)} |
|
|
/> |
|
|
<input type="submit" /> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getAllByRole('checkbox')[0]); |
|
|
|
|
|
expect(watchedValue).toEqual([ |
|
|
{ test: [true, false, false] }, |
|
|
{ test: [true, false, false] }, |
|
|
{ test: [false, false, false] }, |
|
|
]); |
|
|
|
|
|
expect(inputs).toEqual({ |
|
|
test: { |
|
|
_f: { |
|
|
mount: true, |
|
|
name: 'test', |
|
|
ref: { |
|
|
name: 'test', |
|
|
}, |
|
|
value: [false, false, false], |
|
|
}, |
|
|
}, |
|
|
}); |
|
|
}); |
|
|
|
|
|
describe('when setValueAs is presented with inputs', () => { |
|
|
it('should not update inputs correctly with useForm defaultValues', () => { |
|
|
const App = () => { |
|
|
const { register } = useForm({ |
|
|
defaultValues: { |
|
|
test: '1234', |
|
|
}, |
|
|
}); |
|
|
return ( |
|
|
<form> |
|
|
<input |
|
|
{...register('test', { setValueAs: (value) => value + '5' })} |
|
|
/> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
|
|
'1234', |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should not update inputs correctly with reset', () => { |
|
|
const App = () => { |
|
|
const { register, reset } = useForm(); |
|
|
|
|
|
React.useEffect(() => { |
|
|
reset({ |
|
|
test: '1234', |
|
|
}); |
|
|
}, [reset]); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input |
|
|
{...register('test', { setValueAs: (value) => value + '5' })} |
|
|
/> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
|
|
'1234', |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should populate input as string and submit as datetime object ', async () => { |
|
|
let submitData: unknown; |
|
|
|
|
|
const App = () => { |
|
|
const { register, handleSubmit } = useForm<{ |
|
|
test: Date | string; |
|
|
}>({ |
|
|
defaultValues: { |
|
|
test: '2020-10-10', |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((data) => { |
|
|
submitData = data; |
|
|
})} |
|
|
> |
|
|
<input {...register('test', { valueAsDate: true })} /> |
|
|
<button>Submit</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
|
|
'2020-10-10', |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(submitData).toEqual({ |
|
|
test: new Date('2020-10-10'), |
|
|
}), |
|
|
); |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should not throw error when register with non input ref', () => { |
|
|
const App = () => { |
|
|
const { register } = useForm(); |
|
|
|
|
|
return ( |
|
|
<div {...register('test')}> |
|
|
<h1>test</h1> |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
}); |
|
|
|
|
|
it('should be able to register input/textarea/select when embedded deeply', async () => { |
|
|
let submitData: unknown; |
|
|
|
|
|
const Select = React.forwardRef<HTMLDivElement>((_, ref) => { |
|
|
return ( |
|
|
<div ref={ref}> |
|
|
<select data-testid="select"> |
|
|
<option value={''}></option> |
|
|
<option value={'select'}>select</option> |
|
|
</select> |
|
|
</div> |
|
|
); |
|
|
}); |
|
|
|
|
|
Select.displayName = 'Select'; |
|
|
|
|
|
const Input = React.forwardRef<HTMLDivElement>((_, ref) => { |
|
|
return ( |
|
|
<div ref={ref}> |
|
|
<input data-testid="input" /> |
|
|
</div> |
|
|
); |
|
|
}); |
|
|
|
|
|
Input.displayName = 'Input'; |
|
|
|
|
|
const Textarea = React.forwardRef<HTMLDivElement>((_, ref) => { |
|
|
return ( |
|
|
<div ref={ref}> |
|
|
<textarea data-testid="textarea" /> |
|
|
</div> |
|
|
); |
|
|
}); |
|
|
|
|
|
Textarea.displayName = 'Textarea'; |
|
|
|
|
|
const App = () => { |
|
|
const { register, handleSubmit } = useForm({ |
|
|
defaultValues: { |
|
|
input: 'input', |
|
|
select: 'select', |
|
|
textarea: 'textarea', |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((data) => { |
|
|
submitData = data; |
|
|
})} |
|
|
> |
|
|
<Input {...register('input')} /> |
|
|
<Select {...register('select')} /> |
|
|
<Textarea {...register('textarea')} /> |
|
|
<button>submit</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(submitData).toEqual({ |
|
|
input: 'input', |
|
|
select: 'select', |
|
|
textarea: 'textarea', |
|
|
}), |
|
|
); |
|
|
|
|
|
expect((screen.getByTestId('input') as HTMLInputElement).value).toEqual( |
|
|
'input', |
|
|
); |
|
|
expect((screen.getByTestId('select') as HTMLSelectElement).value).toEqual( |
|
|
'select', |
|
|
); |
|
|
expect( |
|
|
(screen.getByTestId('textarea') as HTMLTextAreaElement).value, |
|
|
).toEqual('textarea'); |
|
|
}); |
|
|
|
|
|
it('should should trigger deps validation', async () => { |
|
|
const App = () => { |
|
|
const { register, getValues, formState } = useForm<{ |
|
|
firstName: string; |
|
|
lastName: string; |
|
|
}>({ |
|
|
mode: 'onChange', |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<div> |
|
|
<input |
|
|
{...register('firstName', { |
|
|
validate: (value) => { |
|
|
return getValues('lastName') === value; |
|
|
}, |
|
|
})} |
|
|
/> |
|
|
{formState.errors.firstName && <p>error</p>} |
|
|
<input {...register('lastName', { deps: ['firstName'] })} /> |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(await screen.findByText('error')).toBeVisible(); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await waitForElementToBeRemoved(screen.queryByText('error')); |
|
|
}); |
|
|
|
|
|
it('should should trigger deps validation with schema validation', async () => { |
|
|
const App = () => { |
|
|
const { register, formState } = useForm<{ |
|
|
firstName: string; |
|
|
lastName: string; |
|
|
}>({ |
|
|
mode: 'onChange', |
|
|
resolver: (values) => { |
|
|
if (values.firstName === values.lastName) { |
|
|
return { |
|
|
errors: {}, |
|
|
values, |
|
|
}; |
|
|
} else { |
|
|
return { |
|
|
errors: { |
|
|
firstName: { |
|
|
type: 'error', |
|
|
}, |
|
|
lastName: { |
|
|
type: 'error', |
|
|
}, |
|
|
}, |
|
|
values, |
|
|
}; |
|
|
} |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<div> |
|
|
<input {...register('firstName')} /> |
|
|
{formState.errors.firstName && <p>firstName error</p>} |
|
|
<input {...register('lastName', { deps: ['firstName'] })} /> |
|
|
{formState.errors.lastName && <p>lastName error</p>} |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(await screen.findByText('firstName error')).toBeVisible(); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { |
|
|
value: 'test1', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(await screen.findByText('lastName error')).toBeVisible(); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(screen.queryByText(/error/)).not.toBeInTheDocument(), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should trigger custom onChange event', async () => { |
|
|
const onChange = jest.fn(); |
|
|
|
|
|
const App = () => { |
|
|
const { register } = useForm(); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('test', { onChange })} /> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.blur(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: 'value', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(onChange).toBeCalledTimes(0); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: 'value', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(onChange).toBeCalledTimes(1); |
|
|
expect(onChange).toBeCalledWith( |
|
|
expect.objectContaining({ |
|
|
bubbles: true, |
|
|
cancelable: false, |
|
|
currentTarget: null, |
|
|
type: 'change', |
|
|
}), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should trigger custom onBlur event', async () => { |
|
|
const onBlur = jest.fn(); |
|
|
|
|
|
const App = () => { |
|
|
const { register } = useForm(); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('test', { onBlur })} /> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { |
|
|
value: 'value', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(onBlur).toBeCalledTimes(0); |
|
|
|
|
|
fireEvent.blur(screen.getAllByRole('textbox')[0]); |
|
|
|
|
|
expect(onBlur).toBeCalledTimes(1); |
|
|
expect(onBlur).toBeCalledWith( |
|
|
expect.objectContaining({ |
|
|
bubbles: true, |
|
|
cancelable: false, |
|
|
currentTarget: null, |
|
|
type: 'blur', |
|
|
}), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should not programmatically set input file value with FileList', async () => { |
|
|
function App() { |
|
|
const { register, watch } = useForm(); |
|
|
const moreDetail = watch('toggle'); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input type="checkbox" {...register('toggle')} /> |
|
|
|
|
|
{moreDetail && ( |
|
|
<div> |
|
|
<label>Interests</label> |
|
|
<input |
|
|
type="file" |
|
|
{...register('Interests')} |
|
|
placeholder={'test'} |
|
|
/> |
|
|
</div> |
|
|
)} |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('checkbox')); |
|
|
|
|
|
expect(await screen.findByPlaceholderText('test')).toBeVisible(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('checkbox')); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(screen.queryByPlaceholderText('test')).not.toBeInTheDocument(), |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getByRole('checkbox')); |
|
|
|
|
|
expect(await screen.findByPlaceholderText('test')).toBeVisible(); |
|
|
}); |
|
|
|
|
|
it('should set value before custom onChange', () => { |
|
|
const test = jest.fn(); |
|
|
|
|
|
const App = () => { |
|
|
const { register, getValues } = useForm(); |
|
|
|
|
|
return ( |
|
|
<input |
|
|
{...register('test', { |
|
|
onChange: () => { |
|
|
test(getValues()); |
|
|
}, |
|
|
})} |
|
|
/> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getByRole('textbox'), { |
|
|
target: { value: 'test' }, |
|
|
}); |
|
|
|
|
|
expect(test).toBeCalledWith({ |
|
|
test: 'test', |
|
|
}); |
|
|
}); |
|
|
}); |
|
|
|
