|
|
import React from 'react'; |
|
|
import { |
|
|
act, |
|
|
fireEvent, |
|
|
render, |
|
|
renderHook, |
|
|
screen, |
|
|
waitFor, |
|
|
} from '@testing-library/react'; |
|
|
|
|
|
import { Controller } from '../../controller'; |
|
|
import type { Control, UseFormRegister, UseFormReturn } from '../../types'; |
|
|
import { useController } from '../../useController'; |
|
|
import { useFieldArray } from '../../useFieldArray'; |
|
|
import { useForm } from '../../useForm'; |
|
|
import { useWatch } from '../../useWatch'; |
|
|
import noop from '../../utils/noop'; |
|
|
|
|
|
jest.useFakeTimers(); |
|
|
|
|
|
describe('reset', () => { |
|
|
it('should reset the form and re-render the form', async () => { |
|
|
const { result } = renderHook(() => useForm<{ test: string }>()); |
|
|
|
|
|
result.current.register('test'); |
|
|
result.current.setValue('test', 'data'); |
|
|
|
|
|
expect(result.current.formState.isSubmitted).toBeFalsy(); |
|
|
await act(async () => { |
|
|
await result.current.handleSubmit((data) => { |
|
|
expect(data).toEqual({ |
|
|
test: 'data', |
|
|
}); |
|
|
})({ |
|
|
preventDefault: noop, |
|
|
persist: noop, |
|
|
} as React.SyntheticEvent); |
|
|
}); |
|
|
|
|
|
expect(result.current.formState.isSubmitted).toBeTruthy(); |
|
|
act(() => result.current.reset()); |
|
|
expect(result.current.formState.isSubmitted).toBeFalsy(); |
|
|
}); |
|
|
|
|
|
it('should reset form value', () => { |
|
|
let methods: any; |
|
|
const App = () => { |
|
|
methods = useForm<{ |
|
|
test: string; |
|
|
}>(); |
|
|
return ( |
|
|
<form> |
|
|
<input {...methods.register('test')} /> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
render(<App />); |
|
|
|
|
|
act(() => |
|
|
methods.reset({ |
|
|
test: 'test', |
|
|
}), |
|
|
); |
|
|
|
|
|
expect(methods.getValues()).toEqual({ |
|
|
test: 'test', |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should reset the form with callback action', () => { |
|
|
const App = () => { |
|
|
const { register, reset } = useForm({ |
|
|
defaultValues: { |
|
|
test: '', |
|
|
}, |
|
|
}); |
|
|
|
|
|
React.useEffect(() => { |
|
|
reset((formValues) => { |
|
|
return { |
|
|
...formValues, |
|
|
test: 'test', |
|
|
}; |
|
|
}); |
|
|
}, [reset]); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('test')} /> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
|
|
'test', |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should set array value of multiple checkbox inputs correctly', async () => { |
|
|
const App = () => { |
|
|
const { register } = useForm<{ |
|
|
test: string[]; |
|
|
}>({ |
|
|
defaultValues: { |
|
|
test: ['1', '2'], |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<input type="checkbox" value={'1'} {...register('test')} /> |
|
|
<input type="checkbox" value={'2'} {...register('test')} /> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
screen |
|
|
.getAllByRole('checkbox') |
|
|
.forEach((checkbox) => |
|
|
expect((checkbox as HTMLInputElement).checked).toBeTruthy(), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should reset the form if ref is HTMLElement and parent element is not form', async () => { |
|
|
const mockReset = jest.spyOn(window.HTMLFormElement.prototype, 'reset'); |
|
|
let methods: UseFormReturn<{ |
|
|
test: string; |
|
|
}>; |
|
|
const App = () => { |
|
|
methods = useForm<{ |
|
|
test: string; |
|
|
}>(); |
|
|
return <input {...methods.register('test')} />; |
|
|
}; |
|
|
render(<App />); |
|
|
|
|
|
act(() => methods.reset()); |
|
|
|
|
|
expect(mockReset).not.toHaveBeenCalled(); |
|
|
}); |
|
|
|
|
|
it('should set default value if values is specified to first argument', async () => { |
|
|
const { result } = renderHook(() => |
|
|
useForm<{ |
|
|
test: string; |
|
|
}>(), |
|
|
); |
|
|
|
|
|
result.current.register('test'); |
|
|
|
|
|
act(() => result.current.reset({ test: 'test' })); |
|
|
|
|
|
expect(result.current.control._defaultValues).toEqual({ |
|
|
test: 'test', |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should reset unmountFieldsState value when shouldUnregister set to false', () => { |
|
|
const { result } = renderHook(() => |
|
|
useForm<{ |
|
|
test: string; |
|
|
}>(), |
|
|
); |
|
|
|
|
|
result.current.register('test'); |
|
|
|
|
|
act(() => result.current.reset({ test: 'test' })); |
|
|
}); |
|
|
|
|
|
it('should not reset unmountFieldsState value by default', () => { |
|
|
const { result } = renderHook(() => |
|
|
useForm<{ |
|
|
test: string; |
|
|
}>(), |
|
|
); |
|
|
|
|
|
result.current.register('test'); |
|
|
|
|
|
act(() => result.current.reset({ test: 'test' })); |
|
|
}); |
|
|
|
|
|
it('should not reset form values when keepValues is specified', () => { |
|
|
const App = () => { |
|
|
const { register, reset } = useForm(); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<input {...register('test')} /> |
|
|
<button |
|
|
type={'button'} |
|
|
onClick={() => |
|
|
reset(undefined, { |
|
|
keepValues: true, |
|
|
}) |
|
|
} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getByRole('textbox'), { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
|
|
'test', |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should not reset form defaultValues when keepDefaultValues is specified', async () => { |
|
|
const App = () => { |
|
|
const { |
|
|
register, |
|
|
reset, |
|
|
formState: { isDirty }, |
|
|
} = useForm({ |
|
|
defaultValues: { |
|
|
test: 'test1', |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<input {...register('test')} /> |
|
|
<p>{isDirty ? 'dirty' : ''}</p> |
|
|
<button |
|
|
type={'button'} |
|
|
onClick={() => |
|
|
reset(undefined, { |
|
|
keepValues: true, |
|
|
}) |
|
|
} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getByRole('textbox'), { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect((screen.getByRole('textbox') as HTMLInputElement).value).toEqual( |
|
|
'test', |
|
|
); |
|
|
|
|
|
fireEvent.change(screen.getByRole('textbox'), { |
|
|
target: { |
|
|
value: 'test2', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(await screen.findByText('dirty')).toBeVisible(); |
|
|
|
|
|
fireEvent.change(screen.getByRole('textbox'), { |
|
|
target: { |
|
|
value: 'test1', |
|
|
}, |
|
|
}); |
|
|
|
|
|
expect(screen.queryByText('dirty')).not.toBeInTheDocument(); |
|
|
}); |
|
|
|
|
|
it('should update dirty and dirtyFields when keepDefaultValues and updatedValues is provided', async () => { |
|
|
function App() { |
|
|
const { |
|
|
register, |
|
|
reset, |
|
|
formState: { isDirty, dirtyFields }, |
|
|
} = useForm({ |
|
|
defaultValues: { |
|
|
firstName: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('firstName')} placeholder="First Name" /> |
|
|
<p>{isDirty ? 'dirty' : 'pristine'}</p> |
|
|
<p>{JSON.stringify(dirtyFields)}</p> |
|
|
|
|
|
<button |
|
|
type="button" |
|
|
onClick={() => { |
|
|
reset( |
|
|
{ |
|
|
firstName: 'other', |
|
|
}, |
|
|
{ |
|
|
keepDefaultValues: true, |
|
|
}, |
|
|
); |
|
|
}} |
|
|
> |
|
|
test |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(await screen.findByText('dirty')).toBeVisible(); |
|
|
expect(screen.getByText('{"firstName":true}')).toBeVisible(); |
|
|
}); |
|
|
|
|
|
it('should not reset if keepStateOption is specified', async () => { |
|
|
let formState = {}; |
|
|
const onSubmit = jest.fn(); |
|
|
|
|
|
const App = () => { |
|
|
const { |
|
|
register, |
|
|
handleSubmit, |
|
|
reset, |
|
|
formState: { touchedFields, errors, isDirty }, |
|
|
} = useForm<{ test: string }>({ |
|
|
defaultValues: { |
|
|
test: '', |
|
|
}, |
|
|
}); |
|
|
|
|
|
formState = { touchedFields, errors, isDirty }; |
|
|
|
|
|
return ( |
|
|
<form onSubmit={handleSubmit(onSubmit)}> |
|
|
<input {...register('test', { required: true, minLength: 3 })} /> |
|
|
<button>submit</button> |
|
|
<button |
|
|
onClick={() => { |
|
|
reset( |
|
|
{ test: '' }, |
|
|
{ |
|
|
keepErrors: true, |
|
|
keepDirty: true, |
|
|
keepIsSubmitted: true, |
|
|
keepIsSubmitSuccessful: true, |
|
|
keepTouched: true, |
|
|
keepSubmitCount: true, |
|
|
}, |
|
|
); |
|
|
}} |
|
|
type={'button'} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getByRole('textbox'), { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
fireEvent.blur(screen.getByRole('textbox')); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
await waitFor(() => expect(onSubmit).toHaveBeenCalled()); |
|
|
await waitFor(() => |
|
|
expect(formState).toEqual({ |
|
|
errors: {}, |
|
|
isDirty: true, |
|
|
touchedFields: { |
|
|
test: true, |
|
|
}, |
|
|
}), |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
|
|
|
expect(formState).toEqual({ |
|
|
errors: {}, |
|
|
isDirty: true, |
|
|
touchedFields: { |
|
|
test: true, |
|
|
}, |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should reset field array fine with empty value', async () => { |
|
|
let data: unknown; |
|
|
const App = () => { |
|
|
const { control, register, reset, handleSubmit } = useForm<{ |
|
|
test: { |
|
|
firstName: string; |
|
|
lastName: string; |
|
|
}[]; |
|
|
}>(); |
|
|
const { fields } = useFieldArray({ |
|
|
control, |
|
|
name: 'test', |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((d) => { |
|
|
data = d; |
|
|
})} |
|
|
> |
|
|
{fields.map((field, index) => ( |
|
|
<div key={field.id}> |
|
|
<input {...register(`test.${index}.firstName` as const)} /> |
|
|
<Controller |
|
|
control={control} |
|
|
name={`test.${index}.lastName` as const} |
|
|
render={({ field }) => <input {...field} />} |
|
|
/> |
|
|
</div> |
|
|
))} |
|
|
|
|
|
<button>submit</button> |
|
|
|
|
|
<button type={'button'} onClick={() => reset()}> |
|
|
reset |
|
|
</button> |
|
|
<button |
|
|
type={'button'} |
|
|
onClick={() => |
|
|
reset({ |
|
|
test: [{ firstName: 'test', lastName: 'test' }], |
|
|
}) |
|
|
} |
|
|
> |
|
|
reset with value |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
const resetButton = screen.getByRole('button', { name: 'reset' }); |
|
|
const submitButton = screen.getByRole('button', { name: 'submit' }); |
|
|
|
|
|
fireEvent.click(resetButton); |
|
|
fireEvent.click(submitButton); |
|
|
|
|
|
await waitFor(() => expect(data).toEqual({})); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset with value' })); |
|
|
fireEvent.click(submitButton); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(data).toEqual({ |
|
|
test: [{ firstName: 'test', lastName: 'test' }], |
|
|
}), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should return reset nested value', () => { |
|
|
const getValuesResult: unknown[] = []; |
|
|
|
|
|
function App() { |
|
|
const [, update] = React.useState({}); |
|
|
const { register, reset, getValues } = useForm<{ |
|
|
names: { name: string }[]; |
|
|
}>({ |
|
|
defaultValues: { |
|
|
names: [{ name: 'test' }], |
|
|
}, |
|
|
}); |
|
|
|
|
|
React.useEffect(() => { |
|
|
reset({ names: [{ name: 'Bill' }, { name: 'Luo' }] }); |
|
|
}, [reset]); |
|
|
|
|
|
getValuesResult.push(getValues()); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('names.0.name')} placeholder="Name" /> |
|
|
<button type={'button'} onClick={() => update({})}> |
|
|
update |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(getValuesResult).toEqual([ |
|
|
{ |
|
|
names: [ |
|
|
{ |
|
|
name: 'test', |
|
|
}, |
|
|
], |
|
|
}, |
|
|
{ |
|
|
names: [ |
|
|
{ |
|
|
name: 'Bill', |
|
|
}, |
|
|
{ |
|
|
name: 'Luo', |
|
|
}, |
|
|
], |
|
|
}, |
|
|
{ |
|
|
names: [ |
|
|
{ |
|
|
name: 'Bill', |
|
|
}, |
|
|
{ |
|
|
name: 'Luo', |
|
|
}, |
|
|
], |
|
|
}, |
|
|
]); |
|
|
}); |
|
|
|
|
|
it('should keep defaultValues after reset with shouldKeepDefaultValues', async () => { |
|
|
type FormValues = { test: string; test1: string }; |
|
|
const ControlledInput = ({ control }: { control: Control<FormValues> }) => { |
|
|
const { field } = useController({ |
|
|
name: 'test', |
|
|
control, |
|
|
}); |
|
|
|
|
|
return <input {...field} />; |
|
|
}; |
|
|
|
|
|
function App() { |
|
|
const { control, register, reset } = useForm<FormValues>({ |
|
|
defaultValues: { test: 'test', test1: 'test1' }, |
|
|
}); |
|
|
const resetData = () => { |
|
|
reset(undefined, { keepDefaultValues: true }); |
|
|
}; |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<ControlledInput control={control} /> |
|
|
<input {...register('test1')} /> |
|
|
<input type="button" onClick={resetData} value="Reset" /> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { value: 'data' }, |
|
|
}); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { value: 'data' }, |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[0] as HTMLInputElement).value, |
|
|
).toEqual('test'); |
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[1] as HTMLInputElement).value, |
|
|
).toEqual('test1'); |
|
|
}); |
|
|
|
|
|
describe('when reset optional props set to keepDirtyValues', () => { |
|
|
describe('with uncontrolled components', () => { |
|
|
let updatedDirtyFields: Record<string, boolean> = {}; |
|
|
let updatedDirty = false; |
|
|
let submittedValue: unknown = {}; |
|
|
|
|
|
function App() { |
|
|
const [showButton, setShowButton] = React.useState(false); |
|
|
const { |
|
|
reset, |
|
|
register, |
|
|
handleSubmit, |
|
|
formState: { dirtyFields, isDirty }, |
|
|
} = useForm(); |
|
|
|
|
|
updatedDirtyFields = dirtyFields; |
|
|
updatedDirty = isDirty; |
|
|
|
|
|
React.useEffect(() => { |
|
|
setTimeout(() => { |
|
|
reset( |
|
|
{ |
|
|
firstName: 'bill', |
|
|
lastName: 'luo', |
|
|
}, |
|
|
{ keepDirtyValues: true }, |
|
|
); |
|
|
setShowButton(true); |
|
|
}, 500); |
|
|
}, [reset]); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((data) => { |
|
|
submittedValue = data; |
|
|
})} |
|
|
> |
|
|
<input {...register('firstName')} placeholder="First Name" /> |
|
|
<input {...register('lastName')} placeholder="Last Name" /> |
|
|
|
|
|
{showButton && ( |
|
|
<button |
|
|
type="button" |
|
|
onClick={() => { |
|
|
reset(); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
)} |
|
|
<button>submit</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
it('should only update new reset values', async () => { |
|
|
render(<App />); |
|
|
|
|
|
await waitFor(() => |
|
|
expect( |
|
|
(screen.getByPlaceholderText('First Name') as HTMLInputElement) |
|
|
.value, |
|
|
).toEqual('bill'), |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
|
|
|
expect(updatedDirtyFields).toEqual({}); |
|
|
expect(updatedDirty).toBeFalsy(); |
|
|
|
|
|
expect( |
|
|
(screen.getByPlaceholderText('First Name') as HTMLInputElement).value, |
|
|
).toEqual('bill'); |
|
|
|
|
|
expect(updatedDirtyFields).toEqual({}); |
|
|
expect(updatedDirty).toBeFalsy(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(submittedValue).toEqual({ |
|
|
firstName: 'bill', |
|
|
lastName: 'luo', |
|
|
}), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should only update none dirty fields and keep other values updated', async () => { |
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getByPlaceholderText('First Name'), { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await waitFor(() => |
|
|
expect( |
|
|
(screen.getByPlaceholderText('Last Name') as HTMLInputElement) |
|
|
.value, |
|
|
).toEqual('luo'), |
|
|
); |
|
|
|
|
|
expect(updatedDirtyFields).toEqual({ |
|
|
firstName: true, |
|
|
}); |
|
|
expect(updatedDirty).toBeTruthy(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(submittedValue).toEqual({ |
|
|
firstName: 'test', |
|
|
lastName: 'luo', |
|
|
}), |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
|
|
|
expect( |
|
|
(screen.getByPlaceholderText('First Name') as HTMLInputElement).value, |
|
|
).toEqual('bill'); |
|
|
|
|
|
expect(updatedDirtyFields).toEqual({}); |
|
|
expect(updatedDirty).toBeFalsy(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(submittedValue).toEqual({ |
|
|
firstName: 'bill', |
|
|
lastName: 'luo', |
|
|
}), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should treat previously-undirty fields as dirty when keepDefaultValues is set', async () => { |
|
|
let updatedDirtyFields: Record<string, boolean> = {}; |
|
|
let updatedDirty = false; |
|
|
|
|
|
function App() { |
|
|
const { |
|
|
reset, |
|
|
register, |
|
|
handleSubmit, |
|
|
formState: { dirtyFields, isDirty }, |
|
|
} = useForm({ defaultValues: { firstName: '', lastName: '' } }); |
|
|
|
|
|
function resetKeepDefaults() { |
|
|
reset( |
|
|
{ |
|
|
firstName: 'bill', |
|
|
lastName: 'luo', |
|
|
}, |
|
|
{ |
|
|
keepDefaultValues: true, |
|
|
keepDirtyValues: true, |
|
|
}, |
|
|
); |
|
|
} |
|
|
|
|
|
updatedDirtyFields = dirtyFields; |
|
|
updatedDirty = isDirty; |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((data) => { |
|
|
submittedValue = data; |
|
|
})} |
|
|
> |
|
|
<input {...register('firstName')} placeholder="First Name" /> |
|
|
<input {...register('lastName')} placeholder="Last Name" /> |
|
|
|
|
|
<button |
|
|
type="button" |
|
|
onClick={() => { |
|
|
resetKeepDefaults(); |
|
|
}} |
|
|
> |
|
|
reset keep defaults |
|
|
</button> |
|
|
<button>submit</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click( |
|
|
screen.getByRole('button', { name: 'reset keep defaults' }), |
|
|
); |
|
|
|
|
|
await waitFor(() => |
|
|
expect( |
|
|
(screen.getByPlaceholderText('Last Name') as HTMLInputElement) |
|
|
.value, |
|
|
).toEqual('luo'), |
|
|
); |
|
|
|
|
|
expect( |
|
|
(screen.getByPlaceholderText('First Name') as HTMLInputElement).value, |
|
|
).toEqual('bill'); |
|
|
|
|
|
|
|
|
expect(updatedDirtyFields).toEqual({ |
|
|
firstName: true, |
|
|
lastName: true, |
|
|
}); |
|
|
|
|
|
expect(updatedDirty).toBeTruthy(); |
|
|
}); |
|
|
}); |
|
|
|
|
|
describe('with controlled components', () => { |
|
|
let updatedDirtyFields: Record<string, boolean> = {}; |
|
|
let updatedDirty = false; |
|
|
let submittedValue: unknown = {}; |
|
|
|
|
|
function App() { |
|
|
const [showButton, setShowButton] = React.useState(false); |
|
|
const { |
|
|
reset, |
|
|
control, |
|
|
handleSubmit, |
|
|
formState: { dirtyFields, isDirty }, |
|
|
} = useForm({ |
|
|
defaultValues: { |
|
|
firstName: '', |
|
|
lastName: '', |
|
|
}, |
|
|
}); |
|
|
|
|
|
updatedDirtyFields = dirtyFields; |
|
|
updatedDirty = isDirty; |
|
|
|
|
|
React.useEffect(() => { |
|
|
setTimeout(() => { |
|
|
reset( |
|
|
{ |
|
|
firstName: 'bill', |
|
|
lastName: 'luo', |
|
|
}, |
|
|
{ keepDirtyValues: true }, |
|
|
); |
|
|
setShowButton(true); |
|
|
}, 500); |
|
|
}, [reset]); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((data) => { |
|
|
submittedValue = data; |
|
|
})} |
|
|
> |
|
|
<Controller |
|
|
control={control} |
|
|
render={({ field }) => { |
|
|
return <input {...field} placeholder="First Name" />; |
|
|
}} |
|
|
name={'firstName'} |
|
|
/> |
|
|
<Controller |
|
|
control={control} |
|
|
render={({ field }) => { |
|
|
return <input {...field} placeholder="Last Name" />; |
|
|
}} |
|
|
name={'lastName'} |
|
|
/> |
|
|
|
|
|
{showButton && ( |
|
|
<button |
|
|
type="button" |
|
|
onClick={() => { |
|
|
reset(); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
)} |
|
|
|
|
|
<button>submit</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
it('should only update new reset values', async () => { |
|
|
render(<App />); |
|
|
|
|
|
await waitFor(() => |
|
|
expect( |
|
|
(screen.getByPlaceholderText('First Name') as HTMLInputElement) |
|
|
.value, |
|
|
).toEqual('bill'), |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
|
|
|
expect(updatedDirtyFields).toEqual({}); |
|
|
expect(updatedDirty).toBeFalsy(); |
|
|
|
|
|
expect( |
|
|
(screen.getByPlaceholderText('First Name') as HTMLInputElement).value, |
|
|
).toEqual('bill'); |
|
|
|
|
|
expect(updatedDirtyFields).toEqual({}); |
|
|
expect(updatedDirty).toBeFalsy(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(submittedValue).toEqual({ |
|
|
firstName: 'bill', |
|
|
lastName: 'luo', |
|
|
}), |
|
|
); |
|
|
}); |
|
|
|
|
|
it('should only update none dirty fields and keep other values updated', async () => { |
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getByPlaceholderText('First Name'), { |
|
|
target: { |
|
|
value: 'test', |
|
|
}, |
|
|
}); |
|
|
|
|
|
await waitFor(() => |
|
|
expect( |
|
|
(screen.getByPlaceholderText('Last Name') as HTMLInputElement) |
|
|
.value, |
|
|
).toEqual('luo'), |
|
|
); |
|
|
|
|
|
expect(updatedDirtyFields).toEqual({ |
|
|
firstName: true, |
|
|
}); |
|
|
expect(updatedDirty).toBeTruthy(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(submittedValue).toEqual({ |
|
|
firstName: 'test', |
|
|
lastName: 'luo', |
|
|
}), |
|
|
); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
|
|
|
expect( |
|
|
(screen.getByPlaceholderText('First Name') as HTMLInputElement).value, |
|
|
).toEqual('bill'); |
|
|
|
|
|
expect(updatedDirtyFields).toEqual({}); |
|
|
expect(updatedDirty).toBeFalsy(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(submittedValue).toEqual({ |
|
|
firstName: 'bill', |
|
|
lastName: 'luo', |
|
|
}), |
|
|
); |
|
|
}); |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should allow to reset unmounted field array', () => { |
|
|
type FormValues = { |
|
|
test: { name: string }[]; |
|
|
}; |
|
|
|
|
|
const FieldArray = ({ |
|
|
control, |
|
|
register, |
|
|
}: { |
|
|
control: Control<FormValues>; |
|
|
register: UseFormRegister<FormValues>; |
|
|
}) => { |
|
|
const { fields, append } = useFieldArray({ |
|
|
control, |
|
|
name: 'test', |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<div> |
|
|
{fields.map((field, index) => { |
|
|
return ( |
|
|
<input |
|
|
key={field.id} |
|
|
{...register(`test.${index}.name` as const)} |
|
|
/> |
|
|
); |
|
|
})} |
|
|
<button |
|
|
onClick={() => { |
|
|
append({ name: '' }); |
|
|
}} |
|
|
> |
|
|
append |
|
|
</button> |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
const App = () => { |
|
|
const [show, setShow] = React.useState(true); |
|
|
const { control, register, reset } = useForm<FormValues>(); |
|
|
|
|
|
return ( |
|
|
<div> |
|
|
{show && <FieldArray control={control} register={register} />} |
|
|
<button |
|
|
onClick={() => { |
|
|
setShow(!show); |
|
|
}} |
|
|
> |
|
|
toggle |
|
|
</button> |
|
|
<button |
|
|
onClick={() => { |
|
|
reset({ |
|
|
test: [{ name: 'test' }], |
|
|
}); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
</div> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'append' })); |
|
|
fireEvent.click(screen.getByRole('button', { name: 'append' })); |
|
|
|
|
|
expect(screen.getAllByRole('textbox').length).toEqual(2); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'toggle' })); |
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
fireEvent.click(screen.getByRole('button', { name: 'toggle' })); |
|
|
|
|
|
expect(screen.getAllByRole('textbox').length).toEqual(1); |
|
|
}); |
|
|
|
|
|
it('should only return register input when reset is invoked with shouldUnregister:true', async () => { |
|
|
let submittedData = {}; |
|
|
|
|
|
const App = () => { |
|
|
const { reset, handleSubmit } = useForm({ |
|
|
defaultValues: { |
|
|
test: 'bill', |
|
|
}, |
|
|
shouldUnregister: true, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((data) => { |
|
|
submittedData = data; |
|
|
})} |
|
|
> |
|
|
<button>submit</button> |
|
|
<button |
|
|
type={'button'} |
|
|
onClick={() => { |
|
|
reset({ |
|
|
test: '1234', |
|
|
}); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
expect(submittedData).toEqual({}); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
expect(submittedData).toEqual({}); |
|
|
}); |
|
|
|
|
|
it('should update controlled input correctly with shouldUnregister set to true', () => { |
|
|
function App() { |
|
|
const { register, reset, control } = useForm({ |
|
|
defaultValues: { uncontrolled: '', control: '' }, |
|
|
shouldUnregister: true, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('uncontrolled')} /> |
|
|
<Controller |
|
|
render={({ field }) => ( |
|
|
<input |
|
|
ref={field.ref} |
|
|
value={field.value} |
|
|
onChange={field.onChange} |
|
|
/> |
|
|
)} |
|
|
name="control" |
|
|
control={control} |
|
|
/> |
|
|
|
|
|
<button |
|
|
type="button" |
|
|
onClick={() => { |
|
|
reset({ uncontrolled: 'uncontrolled', control: 'control' }); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[0] as HTMLInputElement).value, |
|
|
).toEqual('uncontrolled'); |
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[1] as HTMLInputElement).value, |
|
|
).toEqual('control'); |
|
|
}); |
|
|
|
|
|
it('should keep input values when keepValues is set to true', () => { |
|
|
function App() { |
|
|
const { register, handleSubmit, reset } = useForm(); |
|
|
const [show, setShow] = React.useState(true); |
|
|
|
|
|
return ( |
|
|
<form onSubmit={handleSubmit(noop)}> |
|
|
<input {...register('firstName')} placeholder="First Name" /> |
|
|
{show && <input {...register('lastName')} placeholder="Last Name" />} |
|
|
<button |
|
|
type="button" |
|
|
onClick={() => { |
|
|
reset({}, { keepValues: true }); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
<button |
|
|
type="button" |
|
|
onClick={() => { |
|
|
setShow(!show); |
|
|
}} |
|
|
> |
|
|
toggle |
|
|
</button> |
|
|
<input type="submit" /> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { value: 'test' }, |
|
|
}); |
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { value: 'test' }, |
|
|
}); |
|
|
fireEvent.click(screen.getByRole('button', { name: 'toggle' })); |
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
fireEvent.click(screen.getByRole('button', { name: 'toggle' })); |
|
|
|
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[1] as HTMLInputElement).value, |
|
|
).toEqual('test'); |
|
|
}); |
|
|
|
|
|
it('should not update isMounted when isValid is subscribed', async () => { |
|
|
const mounted: unknown[] = []; |
|
|
|
|
|
const App = () => { |
|
|
const { control, reset } = useForm(); |
|
|
|
|
|
mounted.push(control._state.mount); |
|
|
|
|
|
React.useEffect(() => { |
|
|
reset({}); |
|
|
}, [reset]); |
|
|
|
|
|
return <form />; |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect(mounted).toEqual([false, true]); |
|
|
}); |
|
|
|
|
|
it('should update isMounted when isValid is subscribed', async () => { |
|
|
const mounted: unknown[] = []; |
|
|
let tempControl: Control = {} as Control; |
|
|
|
|
|
const App = () => { |
|
|
const { |
|
|
control, |
|
|
reset, |
|
|
formState: { isValid }, |
|
|
} = useForm(); |
|
|
|
|
|
mounted.push(control._state.mount); |
|
|
tempControl = control; |
|
|
|
|
|
React.useEffect(() => { |
|
|
reset({}); |
|
|
}, [reset]); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<p>{isValid ? 'true' : 'false'}</p> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect(await screen.findByText('false')).toBeVisible(); |
|
|
|
|
|
expect(mounted).toEqual([false, false]); |
|
|
|
|
|
expect(tempControl._state.mount).toBeTruthy(); |
|
|
}); |
|
|
|
|
|
it('should reset values but keep defaultValues', async () => { |
|
|
const App = () => { |
|
|
const { register, control, reset } = useForm({ |
|
|
defaultValues: { |
|
|
test: 'test', |
|
|
test1: 'test1', |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<> |
|
|
<input {...register('test')} /> |
|
|
<Controller |
|
|
control={control} |
|
|
render={({ field }) => <input {...field} />} |
|
|
name={'test1'} |
|
|
/> |
|
|
<button |
|
|
onClick={() => { |
|
|
reset( |
|
|
{ |
|
|
test: 'changed1', |
|
|
test1: 'changed2', |
|
|
}, |
|
|
{ keepDefaultValues: true }, |
|
|
); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
<p>{JSON.stringify(control._defaultValues)}</p> |
|
|
</> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect( |
|
|
await screen.findByText('{"test":"test","test1":"test1"}'), |
|
|
).toBeVisible(); |
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[0] as HTMLInputElement).value, |
|
|
).toEqual('changed1'); |
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[1] as HTMLInputElement).value, |
|
|
).toEqual('changed2'); |
|
|
}); |
|
|
|
|
|
it('should reset field array async', () => { |
|
|
let tempFields: unknown[] = []; |
|
|
|
|
|
function App() { |
|
|
const { control, reset } = useForm<{ |
|
|
names: { |
|
|
test: string; |
|
|
}[]; |
|
|
}>({ |
|
|
defaultValues: { |
|
|
names: [], |
|
|
}, |
|
|
}); |
|
|
const { fields, append } = useFieldArray({ |
|
|
control, |
|
|
name: 'names', |
|
|
}); |
|
|
|
|
|
tempFields = fields; |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<button |
|
|
type="button" |
|
|
onClick={() => { |
|
|
setTimeout(() => { |
|
|
reset(); |
|
|
}, 100); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
<button |
|
|
type="button" |
|
|
onClick={() => |
|
|
append({ |
|
|
test: '1', |
|
|
}) |
|
|
} |
|
|
> |
|
|
append |
|
|
</button> |
|
|
<ul> |
|
|
{fields.map((item, index) => ( |
|
|
<Controller |
|
|
key={item.id} |
|
|
render={({ field }) => <input {...field} />} |
|
|
name={`names.${index}.test`} |
|
|
control={control} |
|
|
/> |
|
|
))} |
|
|
</ul> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'append' })); |
|
|
fireEvent.click(screen.getByRole('button', { name: 'append' })); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
|
|
|
act(() => { |
|
|
jest.advanceTimersByTime(100); |
|
|
}); |
|
|
|
|
|
expect(tempFields).toEqual([]); |
|
|
}); |
|
|
|
|
|
it('should reset the form after submitted', async () => { |
|
|
function App() { |
|
|
const { |
|
|
register, |
|
|
control, |
|
|
handleSubmit, |
|
|
reset, |
|
|
formState: { isDirty, dirtyFields }, |
|
|
} = useForm({ |
|
|
defaultValues: { |
|
|
something: 'anything', |
|
|
test: [{ firstName: 'Bill', lastName: 'Luo' }], |
|
|
}, |
|
|
}); |
|
|
const { fields } = useFieldArray({ |
|
|
control, |
|
|
name: 'test', |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit((data) => { |
|
|
reset({ ...data }); |
|
|
})} |
|
|
> |
|
|
<p>is dirty? {isDirty ? 'yes' : 'no'}</p> |
|
|
<p>{JSON.stringify(dirtyFields)}</p> |
|
|
<input {...register('something')} /> |
|
|
<ul> |
|
|
{fields.map((item, index) => { |
|
|
return ( |
|
|
<li key={item.id}> |
|
|
<input |
|
|
defaultValue={`${item.firstName}`} |
|
|
{...register(`test.${index}.firstName`)} |
|
|
/> |
|
|
|
|
|
<Controller |
|
|
render={({ field }) => <input {...field} />} |
|
|
name={`test.${index}.lastName`} |
|
|
control={control} |
|
|
defaultValue={item.lastName} |
|
|
/> |
|
|
</li> |
|
|
); |
|
|
})} |
|
|
</ul> |
|
|
|
|
|
<button>Submit</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getAllByRole('textbox')[0], { |
|
|
target: { value: '1' }, |
|
|
}); |
|
|
fireEvent.change(screen.getAllByRole('textbox')[1], { |
|
|
target: { value: '2' }, |
|
|
}); |
|
|
fireEvent.change(screen.getAllByRole('textbox')[2], { |
|
|
target: { value: '3' }, |
|
|
}); |
|
|
|
|
|
expect(screen.getByText(/yes/i)).toBeVisible(); |
|
|
expect( |
|
|
screen.getByText( |
|
|
`{"something":true,"test":[{"firstName":true,"lastName":true}]}`, |
|
|
), |
|
|
).toBeVisible(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(await screen.findByText(/no/i)).toBeVisible(); |
|
|
|
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[0] as HTMLInputElement).value, |
|
|
).toEqual('1'); |
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[1] as HTMLInputElement).value, |
|
|
).toEqual('2'); |
|
|
expect( |
|
|
(screen.getAllByRole('textbox')[2] as HTMLInputElement).value, |
|
|
).toEqual('3'); |
|
|
}); |
|
|
|
|
|
it('should keep isSubmitted and isSubmitSuccessful value when flags are set', async () => { |
|
|
const { result } = renderHook(() => useForm<{ test: string }>()); |
|
|
|
|
|
expect(result.current.formState.isSubmitted).toBeFalsy(); |
|
|
expect(result.current.formState.isSubmitSuccessful).toBeFalsy(); |
|
|
|
|
|
await act(() => |
|
|
result.current.reset(undefined, { |
|
|
keepIsSubmitted: true, |
|
|
keepIsSubmitSuccessful: true, |
|
|
}), |
|
|
); |
|
|
expect(result.current.formState.isSubmitted).toBeFalsy(); |
|
|
expect(result.current.formState.isSubmitSuccessful).toBeFalsy(); |
|
|
|
|
|
result.current.register('test'); |
|
|
result.current.setValue('test', 'data'); |
|
|
|
|
|
await act(async () => { |
|
|
await result.current.handleSubmit((data) => { |
|
|
expect(data).toEqual({ |
|
|
test: 'data', |
|
|
}); |
|
|
})({ |
|
|
preventDefault: noop, |
|
|
persist: noop, |
|
|
} as React.SyntheticEvent); |
|
|
}); |
|
|
|
|
|
expect(result.current.formState.isSubmitted).toBeTruthy(); |
|
|
expect(result.current.formState.isSubmitSuccessful).toBeTruthy(); |
|
|
|
|
|
act(() => |
|
|
result.current.reset(undefined, { |
|
|
keepIsSubmitted: true, |
|
|
keepIsSubmitSuccessful: true, |
|
|
}), |
|
|
); |
|
|
|
|
|
expect(result.current.formState.isSubmitted).toBeTruthy(); |
|
|
expect(result.current.formState.isSubmitSuccessful).toBeTruthy(); |
|
|
}); |
|
|
|
|
|
it('should keep track on updated defaultValues', async () => { |
|
|
function App() { |
|
|
const { |
|
|
handleSubmit, |
|
|
reset, |
|
|
formState: { defaultValues }, |
|
|
} = useForm({ |
|
|
defaultValues: { firstName: 'Bill', lastName: 'Luo' }, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form |
|
|
onSubmit={handleSubmit(() => { |
|
|
reset({ firstName: 'Bill1', lastName: 'Luo1' }); |
|
|
})} |
|
|
> |
|
|
<button>Submit</button> |
|
|
<p>{defaultValues?.firstName}</p> |
|
|
<p>{defaultValues?.lastName}</p> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => { |
|
|
expect(screen.getByText('Bill1')).toBeVisible(); |
|
|
expect(screen.getByText('Luo1')).toBeVisible(); |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should return defaultValues in useWatch and watch when using calling reset with empty object', async () => { |
|
|
const defaultValues = { |
|
|
something: 'anything', |
|
|
}; |
|
|
|
|
|
function App() { |
|
|
const { control, reset, register, watch } = useForm({ |
|
|
defaultValues, |
|
|
}); |
|
|
const watchValue = watch('something'); |
|
|
const useWatchValue = useWatch({ |
|
|
control, |
|
|
name: 'something', |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('something')} /> |
|
|
<button |
|
|
type="button" |
|
|
onClick={() => { |
|
|
reset({}); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
<p>watch: {watchValue}</p> |
|
|
<p>useWatch: {useWatchValue}</p> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.change(screen.getByRole('textbox'), { |
|
|
target: { value: '1' }, |
|
|
}); |
|
|
|
|
|
expect(screen.getByText('watch: 1')).toBeVisible(); |
|
|
expect(screen.getByText('useWatch: 1')).toBeVisible(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
expect(screen.getByText('watch: anything')).toBeVisible(); |
|
|
expect(screen.getByText('useWatch: anything')).toBeVisible(); |
|
|
}); |
|
|
|
|
|
it('should keep mounted value after reset with keep dirty values', async () => { |
|
|
function App() { |
|
|
const { |
|
|
getValues, |
|
|
reset, |
|
|
register, |
|
|
formState: { isValid }, |
|
|
} = useForm({ |
|
|
mode: 'onChange', |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input |
|
|
{...register('value', { required: true })} |
|
|
defaultValue="Any default value!" |
|
|
/> |
|
|
<p>{getValues().test}</p> |
|
|
<p>isValid = {isValid ? 'true' : 'false'}</p> |
|
|
<button |
|
|
type="button" |
|
|
onClick={() => reset({ test: '34' }, { keepDirtyValues: true })} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect(await screen.findByText('isValid = true')).toBeVisible(); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button')); |
|
|
|
|
|
await waitFor(() => { |
|
|
screen.getByText('34'); |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should keep dirty array value after reset with keepDirtyValues', async () => { |
|
|
function App() { |
|
|
const { |
|
|
getValues, |
|
|
reset, |
|
|
setValue, |
|
|
formState: { isDirty }, |
|
|
} = useForm<{ |
|
|
array: string[]; |
|
|
}>({ |
|
|
mode: 'onChange', |
|
|
defaultValues: { |
|
|
array: [], |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input defaultValue="users#0" /> |
|
|
<p>{`users#${getValues().array.length}`}</p> |
|
|
<p>isDirty = {isDirty ? 'true' : 'false'}</p> |
|
|
<button |
|
|
data-testid="dirtyButton" |
|
|
type="button" |
|
|
onClick={() => setValue('array', ['1'], { shouldDirty: true })} |
|
|
> |
|
|
dirty |
|
|
</button> |
|
|
<button |
|
|
data-testid="resetButton" |
|
|
type="button" |
|
|
onClick={() => reset({ array: [] }, { keepDirtyValues: true })} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
} |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
expect(await screen.findByText('isDirty = false')).toBeVisible(); |
|
|
await waitFor(() => { |
|
|
screen.getByText('users#0'); |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByTestId('dirtyButton')); |
|
|
expect(await screen.findByText('isDirty = true')).toBeVisible(); |
|
|
await waitFor(() => { |
|
|
screen.getByText('users#1'); |
|
|
}); |
|
|
|
|
|
fireEvent.click(screen.getByTestId('resetButton')); |
|
|
|
|
|
await waitFor(() => { |
|
|
screen.getByText('users#1'); |
|
|
}); |
|
|
}); |
|
|
|
|
|
it('should not mutate data outside of library', () => { |
|
|
const defaultValues = { |
|
|
test: 'ok', |
|
|
}; |
|
|
|
|
|
const App = () => { |
|
|
const { register, reset, resetField } = useForm(); |
|
|
|
|
|
return ( |
|
|
<form> |
|
|
<input {...register('test')} /> |
|
|
<button type="button" onClick={() => reset(defaultValues)}> |
|
|
reset |
|
|
</button> |
|
|
<button |
|
|
type="button" |
|
|
onClick={() => resetField('test', { defaultValue: 'error' })} |
|
|
> |
|
|
resetField |
|
|
</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
fireEvent.click(screen.getByRole('button', { name: 'resetField' })); |
|
|
|
|
|
expect(defaultValues.test).toBe('ok'); |
|
|
}); |
|
|
|
|
|
it('should not reset value to undefined with onSubmit data', async () => { |
|
|
const onSubmit = jest.fn(); |
|
|
const App = () => { |
|
|
const { handleSubmit, reset, register } = useForm({ |
|
|
defaultValues: { |
|
|
test: 'test' as string | undefined, |
|
|
}, |
|
|
}); |
|
|
|
|
|
return ( |
|
|
<form onSubmit={handleSubmit((data) => onSubmit(data))}> |
|
|
<button |
|
|
onClick={() => { |
|
|
reset( |
|
|
{ |
|
|
test: undefined, |
|
|
}, |
|
|
{ |
|
|
keepDefaultValues: true, |
|
|
}, |
|
|
); |
|
|
}} |
|
|
> |
|
|
reset |
|
|
</button> |
|
|
<input {...register('test')} /> |
|
|
<button>submit</button> |
|
|
</form> |
|
|
); |
|
|
}; |
|
|
|
|
|
render(<App />); |
|
|
|
|
|
fireEvent.click(screen.getByRole('button', { name: 'reset' })); |
|
|
fireEvent.click(screen.getByRole('button', { name: 'submit' })); |
|
|
|
|
|
await waitFor(() => |
|
|
expect(onSubmit).toBeCalledWith({ |
|
|
test: 'test', |
|
|
}), |
|
|
); |
|
|
}); |
|
|
}); |
|
|
|
