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