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

createField.test.tsx

387 lines11.3 KB

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