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

useField.test.tsx

464 lines13.3 KB

1/// <reference lib="dom" />
2import * as React from 'react'
3import { render, waitFor } from '@testing-library/react'
4import userEvent from '@testing-library/user-event'
5import '@testing-library/jest-dom'
6import { type FormApi, createFormFactory } from '..'
7import { sleep } from './utils'
8​
9const user = userEvent.setup()
10​
11describe('useField', () => {
12 it('should allow to set default value', () => {
13 type Person = {
14 firstName: string
15 lastName: string
16 }
17​
18 const formFactory = createFormFactory<Person>()
19​
20 function Comp() {
21 const form = formFactory.useForm({
22 defaultValues: {
23 firstName: 'FirstName',
24 lastName: 'LastName',
25 },
26 })
27​
28 return (
29 <form.Provider>
30 <form.Field
31 name="firstName"
32 children={(field) => {
33 return (
34 <input
35 data-testid="fieldinput"
36 value={field.state.value}
37 onBlur={field.handleBlur}
38 onChange={(e) => field.handleChange(e.target.value)}
39 />
40 )
41 }}
42 />
43 </form.Provider>
44 )
45 }
46​
47 const { getByTestId } = render(<Comp />)
48 const input = getByTestId('fieldinput')
49 expect(input).toHaveValue('FirstName')
50 })
51​
52 it('should use field default value first', async () => {
53 type Person = {
54 firstName: string
55 lastName: string
56 }
57​
58 const formFactory = createFormFactory<Person>()
59​
60 function Comp() {
61 const form = formFactory.useForm({
62 defaultValues: {
63 firstName: 'FirstName',
64 lastName: 'LastName',
65 },
66 })
67​
68 return (
69 <form.Provider>
70 <form.Field
71 name="firstName"
72 defaultValue="otherName"
73 children={(field) => {
74 return (
75 <input
76 data-testid="fieldinput"
77 value={field.state.value}
78 onBlur={field.handleBlur}
79 onChange={(e) => field.handleChange(e.target.value)}
80 />
81 )
82 }}
83 />
84 </form.Provider>
85 )
86 }
87​
88 const { getByTestId } = render(<Comp />)
89 const input = getByTestId('fieldinput')
90 expect(input).toHaveValue('otherName')
91 })
92​
93 it('should not validate on change if isTouched is false', async () => {
94 type Person = {
95 firstName: string
96 lastName: string
97 }
98 const error = 'Please enter a different value'
99​
100 const formFactory = createFormFactory<Person>()
101​
102 function Comp() {
103 const form = formFactory.useForm()
104​
105 return (
106 <form.Provider>
107 <form.Field
108 name="firstName"
109 validators={{
110 onChange: ({ value }) => (value === 'other' ? error : undefined),
111 }}
112 children={(field) => (
113 <div>
114 <input
115 data-testid="fieldinput"
116 name={field.name}
117 value={field.state.value}
118 onBlur={field.handleBlur}
119 onChange={(e) => field.setValue(e.target.value)}
120 />
121 <p>{field.getMeta().errors}</p>
122 </div>
123 )}
124 />
125 </form.Provider>
126 )
127 }
128​
129 const { getByTestId, queryByText } = render(<Comp />)
130 const input = getByTestId('fieldinput')
131 await user.type(input, 'other')
132 expect(queryByText(error)).not.toBeInTheDocument()
133 })
134​
135 it('should validate on change if isTouched is true', async () => {
136 type Person = {
137 firstName: string
138 lastName: string
139 }
140 const error = 'Please enter a different value'
141​
142 const formFactory = createFormFactory<Person>()
143​
144 function Comp() {
145 const form = formFactory.useForm()
146​
147 return (
148 <form.Provider>
149 <form.Field
150 name="firstName"
151 defaultMeta={{ isTouched: true }}
152 validators={{
153 onChange: ({ value }) => (value === 'other' ? error : undefined),
154 }}
155 children={(field) => (
156 <div>
157 <input
158 data-testid="fieldinput"
159 name={field.name}
160 value={field.state.value}
161 onBlur={field.handleBlur}
162 onChange={(e) => field.handleChange(e.target.value)}
163 />
164 <p>{field.getMeta().errorMap?.onChange}</p>
165 </div>
166 )}
167 />
168 </form.Provider>
169 )
170 }
171​
172 const { getByTestId, getByText, queryByText } = render(<Comp />)
173 const input = getByTestId('fieldinput')
174 expect(queryByText(error)).not.toBeInTheDocument()
175 await user.type(input, 'other')
176 expect(getByText(error)).toBeInTheDocument()
177 })
178​
179 it('should validate on change and on blur', async () => {
180 type Person = {
181 firstName: string
182 lastName: string
183 }
184 const onChangeError = 'Please enter a different value (onChangeError)'
185 const onBlurError = 'Please enter a different value (onBlurError)'
186​
187 const formFactory = createFormFactory<Person>()
188​
189 function Comp() {
190 const form = formFactory.useForm()
191​
192 return (
193 <form.Provider>
194 <form.Field
195 name="firstName"
196 defaultMeta={{ isTouched: true }}
197 validators={{
198 onChange: ({ value }) =>
199 value === 'other' ? onChangeError : undefined,
200 onBlur: ({ value }) =>
201 value === 'other' ? onBlurError : undefined,
202 }}
203 children={(field) => (
204 <div>
205 <input
206 data-testid="fieldinput"
207 name={field.name}
208 value={field.state.value}
209 onBlur={field.handleBlur}
210 onChange={(e) => field.handleChange(e.target.value)}
211 />
212 <p>{field.getMeta().errorMap?.onChange}</p>
213 <p>{field.getMeta().errorMap?.onBlur}</p>
214 </div>
215 )}
216 />
217 </form.Provider>
218 )
219 }
220​
221 const { getByTestId, getByText, queryByText } = render(<Comp />)
222 const input = getByTestId('fieldinput')
223 expect(queryByText(onChangeError)).not.toBeInTheDocument()
224 expect(queryByText(onBlurError)).not.toBeInTheDocument()
225 await user.type(input, 'other')
226 expect(getByText(onChangeError)).toBeInTheDocument()
227 await user.click(document.body)
228 expect(queryByText(onBlurError)).toBeInTheDocument()
229 })
230​
231 it('should validate async on change', async () => {
232 type Person = {
233 firstName: string
234 lastName: string
235 }
236 const error = 'Please enter a different value'
237​
238 const formFactory = createFormFactory<Person>()
239​
240 function Comp() {
241 const form = formFactory.useForm()
242​
243 return (
244 <form.Provider>
245 <form.Field
246 name="firstName"
247 defaultMeta={{ isTouched: true }}
248 validators={{
249 onChangeAsync: async () => {
250 await sleep(10)
251 return error
252 },
253 }}
254 children={(field) => (
255 <div>
256 <input
257 data-testid="fieldinput"
258 name={field.name}
259 value={field.state.value}
260 onBlur={field.handleBlur}
261 onChange={(e) => field.handleChange(e.target.value)}
262 />
263 <p>{field.getMeta().errorMap?.onChange}</p>
264 </div>
265 )}
266 />
267 </form.Provider>
268 )
269 }
270​
271 const { getByTestId, getByText, queryByText } = render(<Comp />)
272 const input = getByTestId('fieldinput')
273 expect(queryByText(error)).not.toBeInTheDocument()
274 await user.type(input, 'other')
275 await waitFor(() => getByText(error))
276 expect(getByText(error)).toBeInTheDocument()
277 })
278​
279 it('should validate async on change and async on blur', async () => {
280 type Person = {
281 firstName: string
282 lastName: string
283 }
284 const onChangeError = 'Please enter a different value (onChangeError)'
285 const onBlurError = 'Please enter a different value (onBlurError)'
286​
287 const formFactory = createFormFactory<Person>()
288​
289 function Comp() {
290 const form = formFactory.useForm()
291​
292 return (
293 <form.Provider>
294 <form.Field
295 name="firstName"
296 defaultMeta={{ isTouched: true }}
297 validators={{
298 onChangeAsync: async () => {
299 await sleep(10)
300 return onChangeError
301 },
302 onBlurAsync: async () => {
303 await sleep(10)
304 return onBlurError
305 },
306 }}
307 children={(field) => (
308 <div>
309 <input
310 data-testid="fieldinput"
311 name={field.name}
312 value={field.state.value}
313 onBlur={field.handleBlur}
314 onChange={(e) => field.handleChange(e.target.value)}
315 />
316 <p>{field.getMeta().errorMap?.onChange}</p>
317 <p>{field.getMeta().errorMap?.onBlur}</p>
318 </div>
319 )}
320 />
321 </form.Provider>
322 )
323 }
324​
325 const { getByTestId, getByText, queryByText } = render(<Comp />)
326 const input = getByTestId('fieldinput')
327​
328 expect(queryByText(onChangeError)).not.toBeInTheDocument()
329 expect(queryByText(onBlurError)).not.toBeInTheDocument()
330 await user.type(input, 'other')
331 await waitFor(() => getByText(onChangeError))
332 expect(getByText(onChangeError)).toBeInTheDocument()
333 await user.click(document.body)
334 await waitFor(() => getByText(onBlurError))
335 expect(getByText(onBlurError)).toBeInTheDocument()
336 })
337​
338 it('should validate async on change with debounce', async () => {
339 type Person = {
340 firstName: string
341 lastName: string
342 }
343 const mockFn = vi.fn()
344 const error = 'Please enter a different value'
345 const formFactory = createFormFactory<Person>()
346​
347 function Comp() {
348 const form = formFactory.useForm()
349​
350 return (
351 <form.Provider>
352 <form.Field
353 name="firstName"
354 defaultMeta={{ isTouched: true }}
355 validators={{
356 onChangeAsyncDebounceMs: 100,
357 onChangeAsync: async () => {
358 mockFn()
359 await sleep(10)
360 return error
361 },
362 }}
363 children={(field) => (
364 <div>
365 <input
366 data-testid="fieldinput"
367 name={field.name}
368 value={field.state.value}
369 onBlur={field.handleBlur}
370 onChange={(e) => field.handleChange(e.target.value)}
371 />
372 <p>{field.getMeta().errors}</p>
373 </div>
374 )}
375 />
376 </form.Provider>
377 )
378 }
379​
380 const { getByTestId, getByText } = render(<Comp />)
381 const input = getByTestId('fieldinput')
382 await user.type(input, 'other')
383 // mockFn will have been called 5 times without onChangeAsyncDebounceMs
384 expect(mockFn).toHaveBeenCalledTimes(0)
385 await waitFor(() => getByText(error))
386 expect(getByText(error)).toBeInTheDocument()
387 })
388​
389 it('should preserve value when preserve value property is true', async () => {
390 type Person = {
391 firstName: string
392 lastName: string
393 }
394 const formFactory = createFormFactory<Person>()
395 let form: FormApi<Person> | null = null
396 function Comp() {
397 form = formFactory.useForm()
398 return (
399 <form.Provider>
400 <form.Field
401 name="firstName"
402 defaultValue="hello"
403 preserveValue={true}
404 children={(field) => {
405 return (
406 <input
407 data-testid="fieldinput"
408 value={field.state.value}
409 onBlur={field.handleBlur}
410 onChange={(e) => field.handleChange(e.target.value)}
411 />
412 )
413 }}
414 />
415 </form.Provider>
416 )
417 }
418​
419 const { getByTestId, unmount, rerender } = render(<Comp />)
420 const input = getByTestId('fieldinput')
421 expect(input).toHaveValue('hello')
422 await user.type(input, 'world')
423 unmount()
424 expect(form!.fieldInfo['firstName']).toBeDefined()
425 })
426​
427 it('should not preserve value when preserve value property is false', async () => {
428 type Person = {
429 firstName: string
430 lastName: string
431 }
432 const formFactory = createFormFactory<Person>()
433 let form: FormApi<Person> | null = null
434 function Comp() {
435 form = formFactory.useForm()
436 return (
437 <form.Provider>
438 <form.Field
439 name="firstName"
440 defaultValue="hello"
441 preserveValue={false}
442 children={(field) => {
443 return (
444 <input
445 data-testid="fieldinput"
446 value={field.state.value}
447 onBlur={field.handleBlur}
448 onChange={(e) => field.handleChange(e.target.value)}
449 />
450 )
451 }}
452 />
453 </form.Provider>
454 )
455 }
456​
457 const { getByTestId, unmount } = render(<Comp />)
458 const input = getByTestId('fieldinput')
459 expect(input).toHaveValue('hello')
460 unmount()
461 const info = form!.fieldInfo
462 expect(Object.keys(info)).toHaveLength(0)
463 })
464})