Open History to see the last commit
1import { describe, expect, it, vi } from 'vitest'
2import {
3 isErrorResult,
4 isValidationErrorMap,
5 parseValidationResult,
6 reconcileRoutedFieldErrors,
7} from '../src/validation'
8import { InternalValidatorInstance } from '../src/ValidatorInstance.lib'
9import type { AnyInternalFieldApi } from '../src/FieldApi/FieldApi.lib'
10β
11function createTestValidatorInstance() {
12 return new InternalValidatorInstance({
13 definition: { run: () => null, triggers: [] },
14 owner: {},
15 scope: 'form',
16 })
17}
18describe('parseValidationResult', () => {
19 it('returns no stored errors for valid results', () => {
20 const validResults: Array<null | undefined | false | Array<never>> = [
21 null,
22 undefined,
23 false,
24 [],
25 ]
26β
27 for (const result of validResults) {
28 expect(parseValidationResult(result)).toEqual({
29 self: null,
30 subfields: null,
31 })
32 expect(isErrorResult(result)).toBe(false)
33 }
34 })
35β
36 it('normalizes errors owned by the validation boundary', () => {
37 const result = ['Required', { message: 'Must be valid' }]
38β
39 expect(parseValidationResult(result)).toEqual({
40 self: [{ message: 'Required' }, { message: 'Must be valid' }],
41 subfields: null,
42 })
43 expect(isErrorResult(result)).toBe(true)
44 })
45β
46 it('does not misinterpret an issue with fields metadata as an error map', () => {
47 const result = { message: 'Required', fields: {} }
48β
49 expect(isValidationErrorMap(result)).toBe(false)
50 expect(parseValidationResult(result)).toEqual({
51 self: [result],
52 subfields: null,
53 })
54 expect(isErrorResult(result)).toBe(true)
55 })
56β
57 it('normalizes and prunes error maps', () => {
58 const result = {
59 form: 'Form is invalid',
60 fields: {
61 name: 'Name is required',
62 age: [],
63 email: undefined,
64 },
65 }
66β
67 expect(isValidationErrorMap(result)).toBe(true)
68 expect(parseValidationResult(result)).toEqual({
69 self: [{ message: 'Form is invalid' }],
70 subfields: {
71 name: [{ message: 'Name is required' }],
72 },
73 })
74 expect(isErrorResult(result)).toBe(true)
75 })
76β
77 it('recognizes error maps with additional metadata keys', () => {
78 const result = {
79 form: 'Form is invalid',
80 fields: { name: 'Name is required' },
81 source: 'server',
82 }
83β
84 expect(isValidationErrorMap(result)).toBe(true)
85 expect(parseValidationResult(result)).toEqual({
86 self: [{ message: 'Form is invalid' }],
87 subfields: {
88 name: [{ message: 'Name is required' }],
89 },
90 })
91 expect(isErrorResult(result)).toBe(true)
92 })
93β
94 it('preserves an empty error map without storing an error', () => {
95 const result = { fields: {} }
96 const resultWithEmptyEntries = {
97 form: [],
98 fields: {
99 name: undefined,
100 age: [],
101 },
102 }
103β
104 expect(parseValidationResult(result)).toEqual({
105 self: null,
106 subfields: {},
107 })
108 expect(parseValidationResult(resultWithEmptyEntries)).toEqual({
109 self: null,
110 subfields: {},
111 })
112 expect(isErrorResult(result)).toBe(false)
113 expect(isErrorResult(resultWithEmptyEntries)).toBe(false)
114 })
115})
116β
117describe('reconcileRoutedFieldErrors', () => {
118 it('sets errors on already-resolved field refs', () => {
119 const validatorInstance = createTestValidatorInstance()
120 const field = { name: 'name' } as AnyInternalFieldApi
121 const errors = [{ message: 'Name is required' }]
122 const setFieldError = vi.fn()
123 const result = reconcileRoutedFieldErrors(
124 validatorInstance,
125 [[field, errors]],
126 undefined,
127 setFieldError,
128 vi.fn(),
129 )
130β
131 expect(setFieldError).toHaveBeenCalledWith(field, validatorInstance, errors)
132 expect(result.fieldRefs).toEqual(new Set([field]))
133 expect(result.affectedFields).toEqual(new Set([field]))
134 })
135β
136 it('reports unchanged refs when no new or old field refs exist', () => {
137 const validatorInstance = createTestValidatorInstance()
138 const result = reconcileRoutedFieldErrors(
139 validatorInstance,
140 [],
141 undefined,
142 vi.fn(),
143 vi.fn(),
144 )
145β
146 expect(result.didFieldRefsChange).toBe(false)
147 expect(result.fieldRefs.size).toBe(0)
148 expect(result.affectedFields.size).toBe(0)
149 })
150β
151 it('reports unchanged refs when the old field ref set is empty', () => {
152 const validatorInstance = createTestValidatorInstance()
153 const result = reconcileRoutedFieldErrors(
154 validatorInstance,
155 [],
156 new Set(),
157 vi.fn(),
158 vi.fn(),
159 )
160β
161 expect(result.didFieldRefsChange).toBe(false)
162 })
163β
164 it('clears stale old field refs when no new refs replace them', () => {
165 const validatorInstance = createTestValidatorInstance()
166 const field = { name: 'name' } as AnyInternalFieldApi
167 const clearFieldError = vi.fn()
168 const result = reconcileRoutedFieldErrors(
169 validatorInstance,
170 [],
171 new Set([field]),
172 vi.fn(),
173 clearFieldError,
174 )
175β
176 expect(result.didFieldRefsChange).toBe(true)
177 expect(result.affectedFields).toEqual(new Set([field]))
178 expect(clearFieldError).toHaveBeenCalledWith(field, validatorInstance)
179 })
180})