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

validation.spec.ts

422 lines11.4 KB

1import { describe, expect, it, vi } from 'vitest'
2import { InternalFormApi } from '../../src/FormApi/FormApi.lib'
3​
4describe('field - mount validators', () => {
5 it('runs synchronous mount validators on first registration', () => {
6 const validator = vi.fn(() => 'Field is invalid')
7 const form = new InternalFormApi({
8 defaultValues: { name: '' },
9 })
10 const field = form._getOrCreateFieldApi({
11 name: 'name',
12 validators: [
13 {
14 run: validator,
15 runOnMount: true,
16 triggers: [],
17 },
18 ],
19 })
20​
21 const unregister = field._register()
22​
23 expect(validator).toHaveBeenCalledWith(
24 expect.objectContaining({
25 event: 'mount',
26 fieldApi: field,
27 formApi: form,
28 value: '',
29 }),
30 )
31 expect(field.errors).toEqual([{ message: 'Field is invalid' }])
32​
33 unregister()
34 })
35​
36 it('skips field mount validation when no validator opts in', () => {
37 const validator = vi.fn(() => 'Should not run')
38 const form = new InternalFormApi({
39 defaultValues: { name: '' },
40 })
41 const field = form._getOrCreateFieldApi({
42 name: 'name',
43 validators: [
44 {
45 run: validator,
46 triggers: [],
47 },
48 ],
49 })
50​
51 const unregister = field._register()
52​
53 expect(validator).not.toHaveBeenCalled()
54 expect(field.meta.isValidating).toBe(false)
55​
56 unregister()
57 })
58​
59 it('tracks async mount validation on the field', async () => {
60 let resolve!: (value: string) => void
61 const result = new Promise<string>((res) => {
62 resolve = res
63 })
64 const form = new InternalFormApi({
65 defaultValues: { name: '' },
66 })
67 const field = form._getOrCreateFieldApi({
68 name: 'name',
69 validators: [
70 {
71 run: () => result,
72 runOnMount: true,
73 triggers: [],
74 },
75 ],
76 })
77​
78 const unregister = field._register()
79 expect(field.meta.isValidating).toBe(true)
80​
81 resolve('Async field error')
82 await vi.waitFor(() => expect(field.meta.isValidating).toBe(false))
83​
84 expect(field.errors).toEqual([{ message: 'Async field error' }])
85​
86 unregister()
87 })
88})
89​
90describe('field - linked validators', () => {
91 it('runs a watched validator when its watched source field changes', async () => {
92 vi.useFakeTimers()
93 const validator = vi.fn()
94​
95 const form = new InternalFormApi({
96 defaultValues: { source: '', target: 'target' },
97 })
98 const targetField = form._getOrCreateFieldApi({
99 name: 'target',
100 validators: [
101 {
102 triggers: ['change'],
103 watchFields: ['source'],
104 run: validator,
105 },
106 ],
107 })
108 const sourceField = form._getOrCreateFieldApi({ name: 'source' })
109​
110 sourceField.handleChange('source')
111​
112 await vi.runOnlyPendingTimersAsync()
113​
114 expect(validator).toHaveBeenCalledOnce()
115 expect(validator).toHaveBeenCalledWith(
116 expect.objectContaining({
117 value: 'target',
118 fieldApi: targetField,
119 formApi: form,
120 }),
121 )
122 })
123​
124 it('does not run unrelated watched validators', async () => {
125 vi.useFakeTimers()
126 const watchedValidator = vi.fn()
127 const unrelatedValidator = vi.fn()
128​
129 const form = new InternalFormApi({
130 defaultValues: { source: '', other: '', target: '' },
131 })
132 form._getOrCreateFieldApi({
133 name: 'target',
134 validators: [
135 {
136 triggers: ['change'],
137 watchFields: ['source'],
138 run: watchedValidator,
139 },
140 {
141 triggers: ['change'],
142 watchFields: ['other'],
143 run: unrelatedValidator,
144 },
145 ],
146 })
147 const sourceField = form._getOrCreateFieldApi({ name: 'source' })
148​
149 sourceField.handleChange('source')
150 await vi.runOnlyPendingTimersAsync()
151​
152 expect(watchedValidator).toHaveBeenCalledOnce()
153 expect(unrelatedValidator).not.toHaveBeenCalled()
154 })
155​
156 it("does not run a watched field's validator when the trigger does not match", async () => {
157 vi.useFakeTimers()
158 const validator = vi.fn()
159​
160 const form = new InternalFormApi({
161 defaultValues: { source: '', target: '' },
162 })
163 form._getOrCreateFieldApi({
164 name: 'target',
165 validators: [
166 {
167 triggers: ['blur'],
168 watchFields: ['source'],
169 run: validator,
170 },
171 ],
172 })
173 const sourceField = form._getOrCreateFieldApi({ name: 'source' })
174​
175 sourceField.handleChange('source')
176 await vi.runOnlyPendingTimersAsync()
177​
178 expect(validator).not.toHaveBeenCalled()
179 })
180​
181 it('runs a linked validator when any of multiple watched fields changes', async () => {
182 vi.useFakeTimers()
183 const validator = vi.fn()
184​
185 const form = new InternalFormApi({
186 defaultValues: { source: '', other: '', target: '' },
187 })
188 form._getOrCreateFieldApi({
189 name: 'target',
190 validators: [
191 {
192 triggers: ['change'],
193 watchFields: ['source', 'other'],
194 run: validator,
195 },
196 ],
197 })
198 const sourceField = form._getOrCreateFieldApi({ name: 'source' })
199 const otherField = form._getOrCreateFieldApi({ name: 'other' })
200​
201 sourceField.handleChange('source')
202 otherField.handleChange('other')
203 await vi.runOnlyPendingTimersAsync()
204​
205 expect(validator).toHaveBeenCalledTimes(2)
206 })
207​
208 it('updates watched fields when the watched name changes without moving a field', async () => {
209 vi.useFakeTimers()
210 const validator = vi.fn()
211​
212 const form = new InternalFormApi({
213 defaultValues: { source: '', other: '', target: '' },
214 })
215 const targetField = form._getOrCreateFieldApi({
216 name: 'target',
217 validators: [
218 {
219 triggers: ['change'],
220 watchFields: ['source'],
221 run: validator,
222 },
223 ],
224 })
225 const sourceField = form._getOrCreateFieldApi({ name: 'source' })
226 const otherField = form._getOrCreateFieldApi({ name: 'other' })
227​
228 targetField._update({
229 validators: [
230 {
231 triggers: ['change'],
232 watchFields: ['other'],
233 run: validator,
234 },
235 ],
236 })
237​
238 sourceField.handleChange('source changed')
239 await vi.runOnlyPendingTimersAsync()
240​
241 expect(validator).not.toHaveBeenCalled()
242​
243 otherField.handleChange('other changed')
244 await vi.runOnlyPendingTimersAsync()
245​
246 expect(validator).toHaveBeenCalledOnce()
247 })
248​
249 it('updates a dynamic watched field name after its field moves', async () => {
250 vi.useFakeTimers()
251 const validator = vi.fn()
252​
253 const form = new InternalFormApi({
254 defaultValues: { users: ['first', 'second'], target: '' },
255 })
256 const targetField = form._getOrCreateFieldApi({
257 name: 'target',
258 validators: [
259 {
260 triggers: ['change'],
261 watchFields: ['users[0]'],
262 run: validator,
263 },
264 ],
265 })
266 const fieldAt0Before = form._getOrCreateFieldApi({ name: 'users[0]' })
267 const fieldAt1Before = form._getOrCreateFieldApi({ name: 'users[1]' })
268​
269 form.swapFieldValues('users', 0, 1)
270 expect(form._getOrCreateFieldApi({ name: 'users[1]' })).toBe(fieldAt0Before)
271​
272 targetField._update({
273 validators: [
274 {
275 triggers: ['change'],
276 watchFields: ['users[1]'],
277 run: validator,
278 },
279 ],
280 })
281​
282 fieldAt1Before.handleChange('first index changed')
283 await vi.runOnlyPendingTimersAsync()
284​
285 expect(validator).not.toHaveBeenCalled()
286​
287 fieldAt0Before.handleChange('second index changed')
288 await vi.runOnlyPendingTimersAsync()
289​
290 expect(validator).toHaveBeenCalledOnce()
291 })
292​
293 it('keeps validator result indices stable when running selected watched validators', async () => {
294 vi.useFakeTimers()
295 const otherValidator = vi.fn(() => 'other error')
296 const sourceValidator = vi
297 .fn()
298 .mockReturnValueOnce('source error')
299 .mockReturnValueOnce('updated source error')
300​
301 const form = new InternalFormApi({
302 defaultValues: { source: '', other: '', target: '' },
303 })
304 const targetField = form._getOrCreateFieldApi({
305 name: 'target',
306 validators: [
307 {
308 triggers: ['change'],
309 watchFields: ['other'],
310 run: otherValidator,
311 },
312 {
313 triggers: ['change'],
314 watchFields: ['source'],
315 run: sourceValidator,
316 },
317 ],
318 })
319 const unregister = targetField._register()
320 const sourceField = form._getOrCreateFieldApi({ name: 'source' })
321 const [otherValidatorInstance, sourceValidatorInstance] =
322 targetField._validatorInstances!
323​
324 sourceField.handleChange('source')
325 await vi.runOnlyPendingTimersAsync()
326​
327 expect(otherValidator).not.toHaveBeenCalled()
328 expect(sourceValidator).toHaveBeenCalledOnce()
329 expect(
330 targetField.meta._validationSourceErrors?.get(otherValidatorInstance!),
331 ).toBeUndefined()
332 expect(
333 targetField.meta._validationSourceErrors?.get(sourceValidatorInstance!)
334 ?.errors,
335 ).toEqual([{ message: 'source error' }])
336 expect(targetField.errors).toEqual([{ message: 'source error' }])
337​
338 sourceField.handleChange('updated source')
339 await vi.runOnlyPendingTimersAsync()
340​
341 expect(
342 targetField.meta._validationSourceErrors?.get(otherValidatorInstance!),
343 ).toBeUndefined()
344 expect(
345 targetField.meta._validationSourceErrors?.get(sourceValidatorInstance!)
346 ?.errors,
347 ).toEqual([{ message: 'updated source error' }])
348 expect(targetField.errors).toEqual([{ message: 'updated source error' }])
349​
350 unregister()
351 await vi.runOnlyPendingTimersAsync()
352 })
353​
354 it('warns and stops cyclical validator watch chains', async () => {
355 vi.useFakeTimers()
356 const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
357 const firstValidator = vi.fn()
358 const secondValidator = vi.fn()
359​
360 const form = new InternalFormApi({
361 defaultValues: { first: '', second: '' },
362 })
363 const firstField = form._getOrCreateFieldApi({
364 name: 'first',
365 validators: [
366 {
367 triggers: ['change'],
368 watchFields: ['second'],
369 run: firstValidator,
370 },
371 ],
372 })
373 form._getOrCreateFieldApi({
374 name: 'second',
375 validators: [
376 {
377 triggers: ['change'],
378 watchFields: ['first'],
379 run: secondValidator,
380 },
381 ],
382 })
383​
384 firstField.handleChange('first')
385 await vi.runOnlyPendingTimersAsync()
386​
387 expect(firstValidator).toHaveBeenCalledOnce()
388 expect(secondValidator).toHaveBeenCalledOnce()
389 expect(warn).toHaveBeenCalledWith(
390 expect.stringContaining('cyclical validator cycle detected'),
391 )
392​
393 warn.mockRestore()
394 })
395​
396 it('clears watched validator links when a field is killed', () => {
397 const form = new InternalFormApi({
398 defaultValues: { source: '', target: '' },
399 })
400 const targetField = form._getOrCreateFieldApi({
401 name: 'target',
402 validators: [
403 { run: vi.fn(), watchFields: ['source'], triggers: ['change'] },
404 ],
405 })
406 const sourceField = form._getOrCreateFieldApi({ name: 'source' })
407 const validatorInstance = targetField._validatorInstances![0]!
408​
409 expect(sourceField._watchingValidatorFields?.has(targetField)).toBe(true)
410 expect(validatorInstance.resolvedWatchFields?.get('source')).toBe(
411 sourceField,
412 )
413​
414 form.deleteField('target')
415​
416 expect(sourceField._watchingValidatorFields).toBeNull()
417 expect(validatorInstance.resolvedWatchFields).toBeNull()
418 expect(targetField._isKilled).toBe(true)
419 expect(form._tryGetFieldApi('source')).toBeNull()
420 expect(form._tryGetFieldApi('target')).toBeNull()
421 })
422})