Open History to see the last commit
1import {
2 InternalFormApi,
3 InternalFormGroupApi,
4} from '@tanstack/form-core/internals'
5import { describe, expect, it } from 'vitest'
6import { getFieldErrorDebugSuspicions } from '../src/bridge/fields/debug'
7import { setFieldValidatorErrors } from './testUtils'
8import type { FieldErrorDebugCase } from '../src/bridge/fields/debug'
9import type { DevtoolsFieldError } from '../src/eventClientTypes'
10β
11const schemaError = {
12 error: { message: 'Schema error' },
13 source: {
14 scope: 'form',
15 validatorIndex: 0,
16 validatorType: 'schema',
17 },
18 sourceEvent: 'change',
19} satisfies DevtoolsFieldError
20β
21const callbackError = {
22 error: { message: 'Callback error' },
23 source: {
24 scope: 'field',
25 validatorIndex: 0,
26 validatorType: 'callback',
27 },
28 sourceEvent: 'change',
29} satisfies DevtoolsFieldError
30β
31const serverError = {
32 error: { message: 'Server error' },
33 source: {
34 scope: 'form',
35 validatorIndex: 0,
36 validatorType: 'callback',
37 },
38 sourceEvent: 'server',
39} satisfies DevtoolsFieldError
40β
41describe('field error debug cases', () => {
42 it('recognizes errors hidden by the field error visibility policy', () => {
43 const form = new InternalFormApi({
44 defaultValues: { name: '' },
45 errorVisibility: () => false,
46 })
47 const field = form._getOrCreateFieldApi({ name: 'name' })
48 const unregister = field._register()
49β
50 try {
51 setFieldValidatorErrors(field, [{ message: 'Hidden error' }])
52β
53 expect(field.state.meta.errors).toEqual([])
54 expect(field.state.meta.original.errors).toHaveLength(1)
55 expect(
56 getFieldErrorDebugSuspicions({ field, error: callbackError }),
57 ).toEqual([
58 {
59 kind: 'errors-hidden',
60 evidence: { fieldPath: 'name' },
61 },
62 ])
63 } finally {
64 unregister()
65 }
66 })
67β
68 it('rejects visible errors and fields without errors for the hidden-errors check', () => {
69 const form = new InternalFormApi({ defaultValues: { name: '' } })
70 const field = form._getOrCreateFieldApi({ name: 'name' })
71 const unregister = field._register()
72β
73 try {
74 expect(
75 getFieldErrorDebugSuspicions({ field, error: callbackError }),
76 ).toEqual([])
77β
78 setFieldValidatorErrors(field, [{ message: 'Visible error' }])
79β
80 expect(field.state.meta.errors).toHaveLength(1)
81 expect(
82 getFieldErrorDebugSuspicions({ field, error: callbackError }),
83 ).toEqual([])
84 } finally {
85 unregister()
86 }
87 })
88β
89 it('recognizes server errors on unmounted fields', () => {
90 const form = new InternalFormApi({
91 defaultValues: { firstName: '' },
92 validators: [
93 {
94 triggers: ['server'],
95 run: () => undefined,
96 },
97 ],
98 })
99 const field = form._getOrCreateFieldApi({ name: 'firstName' })
100β
101 for (const validatorType of ['callback', 'schema'] as const) {
102 const error = {
103 ...serverError,
104 source: { ...serverError.source, validatorType },
105 }
106β
107 expect(getFieldErrorDebugSuspicions({ field, error })).toEqual([
108 {
109 kind: 'server-error-on-unmounted-field',
110 evidence: { fieldPath: 'firstName' },
111 },
112 ])
113 }
114 })
115β
116 it('requires an unmounted field, a server source event, and the matching server validator', () => {
117 const serverForm = new InternalFormApi({
118 defaultValues: { name: '' },
119 validators: [
120 {
121 triggers: ['server'],
122 run: () => undefined,
123 },
124 ],
125 })
126 const serverField = serverForm._getOrCreateFieldApi({ name: 'name' })
127 const unregister = serverField._register()
128 const changeError = { ...serverError, sourceEvent: 'change' }
129β
130 const changeForm = new InternalFormApi({
131 defaultValues: { name: '' },
132 validators: [
133 {
134 triggers: ['change'],
135 run: () => undefined,
136 },
137 ],
138 })
139 const changeField = changeForm._getOrCreateFieldApi({ name: 'name' })
140β
141 try {
142 expect(
143 getFieldErrorDebugSuspicions({
144 field: serverField,
145 error: serverError,
146 }),
147 ).toEqual([])
148 unregister()
149 expect(
150 getFieldErrorDebugSuspicions({
151 field: serverField,
152 error: changeError,
153 }),
154 ).toEqual([])
155 expect(
156 getFieldErrorDebugSuspicions({
157 field: changeField,
158 error: serverError,
159 }),
160 ).toEqual([])
161 } finally {
162 if (serverField._isMounted) unregister()
163 }
164 })
165β
166 it('uses the live trie to find the nearest mounted ancestor', () => {
167 const form = new InternalFormApi({
168 defaultValues: { grandparent: { parent: { child: '' } } },
169 })
170 const grandparent = form._getOrCreateFieldApi({ name: 'grandparent' })
171 form._getOrCreateFieldApi({ name: 'grandparent.parent' })
172 const child = form._getOrCreateFieldApi({
173 name: 'grandparent.parent.child',
174 })
175 const unregisterGrandparent = grandparent._register()
176β
177 try {
178 expect(
179 getFieldErrorDebugSuspicions({ field: child, error: schemaError }),
180 ).toEqual([
181 {
182 kind: 'schema-error-on-unmounted-field',
183 evidence: {
184 fieldPath: 'grandparent.parent.child',
185 mountedAncestorPath: 'grandparent',
186 },
187 },
188 ])
189 expect(
190 getFieldErrorDebugSuspicions({ field: child, error: callbackError }),
191 ).toEqual([])
192 } finally {
193 unregisterGrandparent()
194 }
195 })
196β
197 it('walks through an unmounted FormGroup backing field', () => {
198 const form = new InternalFormApi({
199 defaultValues: { stayDates: { dateRange: { to: '' } } },
200 })
201 const group = new InternalFormGroupApi({ form, name: 'stayDates' })
202 const dateRange = form._getOrCreateFieldApi({
203 name: 'stayDates.dateRange',
204 })
205 const child = form._getOrCreateFieldApi({
206 name: 'stayDates.dateRange.to',
207 })
208 const unregisterDateRange = dateRange._register()
209β
210 try {
211 expect(
212 getFieldErrorDebugSuspicions({ field: child, error: schemaError }),
213 ).toEqual([
214 {
215 kind: 'schema-error-on-unmounted-field',
216 evidence: {
217 fieldPath: 'stayDates.dateRange.to',
218 mountedAncestorPath: 'stayDates.dateRange',
219 },
220 },
221 ])
222 } finally {
223 unregisterDateRange()
224 group._cleanup()
225 }
226 })
227β
228 it('rejects mounted fields and fields without a mounted ancestor', () => {
229 const form = new InternalFormApi({
230 defaultValues: { parent: { child: '' }, standalone: '' },
231 })
232 const parent = form._getOrCreateFieldApi({ name: 'parent' })
233 const child = form._getOrCreateFieldApi({ name: 'parent.child' })
234 const standalone = form._getOrCreateFieldApi({ name: 'standalone' })
235 const unregisterChild = child._register()
236β
237 try {
238 expect(
239 getFieldErrorDebugSuspicions({ field: child, error: schemaError }),
240 ).toEqual([])
241 expect(
242 getFieldErrorDebugSuspicions({
243 field: standalone,
244 error: schemaError,
245 }),
246 ).toEqual([])
247 expect(parent._isMounted).toBe(false)
248 } finally {
249 unregisterChild()
250 }
251 })
252β
253 it('preserves evaluator registry order', () => {
254 const form = new InternalFormApi({ defaultValues: { name: '' } })
255 const field = form._getOrCreateFieldApi({ name: 'name' })
256 const cases: Array<FieldErrorDebugCase> = ['first', 'second'].map(
257 (fieldPath) => ({
258 evaluate: () => ({
259 kind: 'schema-error-on-unmounted-field',
260 evidence: { fieldPath, mountedAncestorPath: 'ancestor' },
261 }),
262 }),
263 )
264β
265 expect(
266 getFieldErrorDebugSuspicions({ field, error: schemaError }, cases).map(
267 ({ evidence }) => evidence.fieldPath,
268 ),
269 ).toEqual(['first', 'second'])
270 })
271})