Skip to content
Source
Sign inSign up
TanStack/form
Open History to see the last commit

useForm.spec.tsx

376 lines10.1 KB

1import { render } from 'vitest-browser-preact'
2import { describe, expect, it, vi } from 'vitest'
3import { useState } from 'preact/compat'
4import { useForm } from '../src'
5​
6describe('useForm', () => {
7 it('should mount the form to the dom', () => {
8 function Component() {
9 const form = useForm({ defaultValues: { name: 'tony-hawk' } })
10​
11 return (
12 <form.Field name="name">
13 {(field) => (
14 <label>
15 Name
16 <input
17 value={field.value}
18 onChange={(event) =>
19 field.handleChange(event.currentTarget.value)
20 }
21 />
22 </label>
23 )}
24 </form.Field>
25 )
26 }
27​
28 const screen = render(<Component />)
29​
30 expect(screen.getByRole('textbox', { name: 'Name' })).toHaveValue(
31 'tony-hawk',
32 )
33 })
34​
35 it('uses a supplied formId', () => {
36 function Component() {
37 const form = useForm({
38 formId: 'signup-form',
39 defaultValues: { name: '' },
40 })
41​
42 return <form id={form.formId} aria-label="Signup" />
43 }
44​
45 const screen = render(<Component />)
46​
47 expect(screen.getByRole('form', { name: 'Signup' })).toHaveAttribute(
48 'id',
49 'signup-form',
50 )
51 })
52​
53 it('creates a stable formId when one is not supplied', () => {
54 function Component() {
55 const form = useForm({ defaultValues: { name: '' } })
56​
57 return <form id={form.formId} aria-label="Signup" />
58 }
59​
60 const screen = render(<Component />)
61 const formElement = screen.getByRole('form', { name: 'Signup' })
62 const formId = formElement.element().id
63​
64 expect(formId.length).toBeGreaterThan(0)
65​
66 screen.rerender(<Component />)
67​
68 expect(formElement).toHaveAttribute('id', formId)
69 })
70​
71 it('should support async defaultValues with useState', async () => {
72 function Component() {
73 const [defaultValues, setDefaultValues] = useState({ name: 'initial' })
74 const form = useForm({ defaultValues })
75​
76 return (
77 <>
78 <form.Field name="name">
79 {(field) => (
80 <label>
81 Name
82 <input
83 value={field.value}
84 onChange={(event) =>
85 field.handleChange(event.currentTarget.value)
86 }
87 />
88 </label>
89 )}
90 </form.Field>
91 <button onClick={() => setDefaultValues({ name: 'async-value' })}>
92 Load defaults
93 </button>
94 </>
95 )
96 }
97​
98 const screen = render(<Component />)
99 const name = screen.getByRole('textbox', { name: 'Name' })
100​
101 await expect.element(name).toHaveValue('initial')
102​
103 await screen.getByRole('button', { name: 'Load defaults' }).click()
104​
105 await expect.element(name).toHaveValue('async-value')
106 })
107​
108 it('should not overwrite a touched field with async defaultValues', async () => {
109 function Component() {
110 const [defaultValues, setDefaultValues] = useState({
111 name: 'initial',
112 age: 0,
113 })
114 const form = useForm({ defaultValues })
115​
116 return (
117 <>
118 <form.Field name="name">
119 {(field) => (
120 <label>
121 Name
122 <input
123 value={field.value}
124 onChange={(event) =>
125 field.handleChange(event.currentTarget.value)
126 }
127 />
128 </label>
129 )}
130 </form.Field>
131 <form.Field name="age">
132 {(field) => (
133 <label>
134 Age
135 <input
136 type="number"
137 value={field.value}
138 onChange={(event) =>
139 field.handleChange(event.currentTarget.valueAsNumber)
140 }
141 />
142 </label>
143 )}
144 </form.Field>
145 <button
146 onClick={() => setDefaultValues({ name: 'new-default', age: 99 })}
147 >
148 Load defaults
149 </button>
150 </>
151 )
152 }
153​
154 const screen = render(<Component />)
155 const name = screen.getByRole('textbox', { name: 'Name' })
156 const age = screen.getByRole('spinbutton', { name: 'Age' })
157​
158 await expect.element(name).toHaveValue('initial')
159 await expect.element(age).toHaveValue(0)
160​
161 await name.fill('touched')
162​
163 await expect.element(name).toHaveValue('touched')
164​
165 await screen.getByRole('button', { name: 'Load defaults' }).click()
166​
167 await expect.element(age).toHaveValue(99)
168 await expect.element(name).toHaveValue('touched')
169 })
170​
171 it('should overwrite field B if only field A was touched and B is not a child of A', async () => {
172 function Component() {
173 const [defaultValues, setDefaultValues] = useState({
174 a: { nested: 'initial-a' },
175 b: 'initial-b',
176 })
177 const form = useForm({ defaultValues })
178​
179 return (
180 <>
181 <form.Field name="a.nested">
182 {(field) => (
183 <label>
184 Field A
185 <input
186 value={field.value}
187 onChange={(event) =>
188 field.handleChange(event.currentTarget.value)
189 }
190 />
191 </label>
192 )}
193 </form.Field>
194 <form.Field name="b">
195 {(field) => (
196 <label>
197 Field B
198 <input
199 value={field.value}
200 onChange={(event) =>
201 field.handleChange(event.currentTarget.value)
202 }
203 />
204 </label>
205 )}
206 </form.Field>
207 <button
208 onClick={() =>
209 setDefaultValues({ a: { nested: 'new-a' }, b: 'new-b' })
210 }
211 >
212 Load defaults
213 </button>
214 </>
215 )
216 }
217​
218 const screen = render(<Component />)
219 const fieldA = screen.getByRole('textbox', { name: 'Field A' })
220 const fieldB = screen.getByRole('textbox', { name: 'Field B' })
221​
222 await expect.element(fieldA).toHaveValue('initial-a')
223 await expect.element(fieldB).toHaveValue('initial-b')
224​
225 await fieldA.fill('touched-a')
226​
227 await expect.element(fieldA).toHaveValue('touched-a')
228​
229 await screen.getByRole('button', { name: 'Load defaults' }).click()
230​
231 await expect.element(fieldB).toHaveValue('new-b')
232 await expect.element(fieldA).toHaveValue('touched-a')
233 })
234​
235 it('does not render with pre-validation state for synchronous runOnMount validation', () => {
236 const renderStates: Array<{
237 errors: Array<string>
238 isValid: boolean
239 canSubmit: boolean
240 }> = []
241​
242 function Component() {
243 const form = useForm({
244 defaultValues: { name: '' },
245 validators: [
246 {
247 runOnMount: true,
248 triggers: [],
249 run: () => 'Name is required',
250 },
251 ],
252 })
253​
254 return (
255 <form.Subscribe
256 selector={(state) => ({
257 errors: state.errors.map((error) => error.message),
258 isValid: state.isValid,
259 canSubmit: state.canSubmit,
260 })}
261 >
262 {(state) => {
263 renderStates.push(state)
264 return (
265 <output data-testid="form-state">
266 {state.errors.join(',')}|{String(state.isValid)}|
267 {String(state.canSubmit)}
268 </output>
269 )
270 }}
271 </form.Subscribe>
272 )
273 }
274​
275 const screen = render(<Component />)
276​
277 expect(screen.getByTestId('form-state')).toHaveTextContent(
278 'Name is required|false|false',
279 )
280 expect(renderStates.length).toBeGreaterThan(0)
281 for (const state of renderStates) {
282 expect(state).toEqual({
283 errors: ['Name is required'],
284 isValid: false,
285 canSubmit: false,
286 })
287 }
288 })
289​
290 it('updates form.Subscribe selectors for isDefaultValue', async () => {
291 function Component() {
292 const form = useForm({ defaultValues: { name: 'tony-hawk' } })
293​
294 return (
295 <>
296 <button onClick={() => form.setFieldValue('name', 'rodney-mullen')}>
297 Change name
298 </button>
299 <button onClick={() => form.setFieldValue('name', 'tony-hawk')}>
300 Restore name
301 </button>
302 <form.Subscribe selector={(state) => state.isDefaultValue}>
303 {(isDefaultValue) => (
304 <output data-testid="is-default-value">
305 {String(isDefaultValue)}
306 </output>
307 )}
308 </form.Subscribe>
309 </>
310 )
311 }
312​
313 const screen = render(<Component />)
314​
315 await expect
316 .element(screen.getByTestId('is-default-value'))
317 .toHaveTextContent('true')
318​
319 await screen.getByRole('button', { name: 'Change name' }).click()
320 await expect
321 .element(screen.getByTestId('is-default-value'))
322 .toHaveTextContent('false')
323​
324 await screen.getByRole('button', { name: 'Restore name' }).click()
325 await expect
326 .element(screen.getByTestId('is-default-value'))
327 .toHaveTextContent('true')
328 })
329​
330 it('does not crash when asynchronous runOnMount validation resolves after unmount', async () => {
331 let resolveValidation!: (value: string) => void
332 const validator = vi.fn(
333 () =>
334 new Promise<string>((resolve) => {
335 resolveValidation = resolve
336 }),
337 )
338​
339 function Component() {
340 const form = useForm({
341 defaultValues: { name: '' },
342 validators: [
343 {
344 runOnMount: true,
345 triggers: [],
346 run: validator,
347 },
348 ],
349 })
350​
351 return (
352 <form.Subscribe selector={(state) => state.isValidating}>
353 {(isValidating) => (
354 <output data-testid="is-validating">{String(isValidating)}</output>
355 )}
356 </form.Subscribe>
357 )
358 }
359​
360 const screen = render(<Component />)
361​
362 expect(validator).toHaveBeenCalledOnce()
363 await expect
364 .element(screen.getByTestId('is-validating'))
365 .toHaveTextContent('true')
366​
367 screen.unmount()
368​
369 await expect(
370 (async () => {
371 resolveValidation('Async mount error')
372 await Promise.resolve()
373 })(),
374 ).resolves.toBeUndefined()
375 })
376})