Skip to content

Commit c2f6e16

Browse files
bocembocembocembocem
authored
test(unstable): add set-errors mutators tests (#304)
1 parent a77d51f commit c2f6e16

File tree

3 files changed

+340
-14
lines changed

3 files changed

+340
-14
lines changed

‎src/lib/unstable/__tests__/helpers.test.ts‎

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
import type {Tools} from 'final-form';
1+
import type {InternalFormState, MutableState, Tools} from 'final-form';
22

33
import {JsonSchemaType, SchemaRendererMode} from '../core/constants';
44
import type {
@@ -199,6 +199,16 @@ export function createMockSchema<T extends JsonSchema>(
199199
export const mockTools = {} as Tools<{}, {}>;
200200
export const mockServiceFieldName = 'mockServiceFieldName';
201201

202+
export const createMockMutableState = (fields: Record<string, any> = {}): MutableState<{}, {}> => {
203+
const mockFormState = {} as InternalFormState;
204+
205+
return {
206+
fields,
207+
formState: mockFormState,
208+
fieldSubscribers: {},
209+
};
210+
};
211+
202212
describe('helpers', () => {
203213
test('just empty test', () => {
204214
expect(true).toBe(true);

‎src/lib/unstable/core/mutators/async-validation/__tests__/async-validation.test.ts‎

Lines changed: 5 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
1-
import type {InternalFormState, MutableState} from 'final-form';
2-
3-
import {mockServiceFieldName, mockTools} from '../../../../__tests__/helpers.test';
1+
import {
2+
createMockMutableState,
3+
mockServiceFieldName,
4+
mockTools,
5+
} from '../../../../__tests__/helpers.test';
46
import {JsonSchemaType} from '../../../constants';
57
import {setValidationCache, setValidationWaiters} from '../async-validation';
68
import type {ValidationCache, ValidationWaiter} from '../types';
@@ -17,16 +19,6 @@ const createMockWaiterAndCache = (prefix = '') => {
1719
return {cache, fieldName, waiter};
1820
};
1921

20-
const createMockMutableState = (fields: Record<string, any> = {}): MutableState<{}, {}> => {
21-
const mockFormState = {} as InternalFormState;
22-
23-
return {
24-
fields,
25-
formState: mockFormState,
26-
fieldSubscribers: {},
27-
};
28-
};
29-
3022
describe('async-validation', () => {
3123
describe('setValidationWaiters', () => {
3224
it('should not modify state if service field does not exist', () => {

‎src/lib/unstable/core/mutators/set-errors/__tests__/set-errors.test.ts‎

Lines changed: 324 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,324 @@
1+
import omit from 'lodash/omit';
2+
3+
import {
4+
createMockMutableState,
5+
mockServiceFieldName,
6+
mockTools,
7+
} from '../../../../__tests__/helpers.test';
8+
import {removeErrors, setErrors} from '../set-errors';
9+
import type {ErrorsState} from '../types';
10+
11+
const createMockErrorsKit = (errorPrefix = '', fieldNamePrefix = '') => {
12+
const fieldName = `fieldName${fieldNamePrefix}`;
13+
14+
const errorsState: ErrorsState = {
15+
priorityErrors: {
16+
[fieldName]: `priorityError${errorPrefix}`,
17+
},
18+
regularErrors: {
19+
[fieldName]: `regularError${errorPrefix}`,
20+
},
21+
};
22+
23+
return {errorsState, fieldName};
24+
};
25+
26+
describe('set-errors', () => {
27+
describe('setErrors', () => {
28+
it('should not modify state if service field does not exist', () => {
29+
const errorsKit = createMockErrorsKit();
30+
const mutableState = createMockMutableState();
31+
32+
setErrors(
33+
[{serviceFieldName: mockServiceFieldName, ...errorsKit.errorsState}],
34+
mutableState,
35+
mockTools,
36+
);
37+
38+
expect(mutableState.fields).toEqual({});
39+
});
40+
41+
it('should not modify state if errors are not provided', () => {
42+
const mutableState = createMockMutableState({[mockServiceFieldName]: {data: {}}});
43+
44+
setErrors([{serviceFieldName: mockServiceFieldName}], mutableState, mockTools);
45+
46+
expect(mutableState.fields[mockServiceFieldName].data).toEqual({});
47+
});
48+
49+
it('should add priority errors to the errors state', () => {
50+
const existingErrorsKit = createMockErrorsKit();
51+
const errorsKit = createMockErrorsKit('2', '2');
52+
const mutableState = createMockMutableState({
53+
[mockServiceFieldName]: {data: existingErrorsKit.errorsState},
54+
});
55+
56+
setErrors(
57+
[
58+
{
59+
serviceFieldName: mockServiceFieldName,
60+
priorityErrors: errorsKit.errorsState.priorityErrors,
61+
},
62+
],
63+
mutableState,
64+
mockTools,
65+
);
66+
67+
expect(mutableState.fields[mockServiceFieldName].data.priorityErrors).toEqual({
68+
...existingErrorsKit.errorsState.priorityErrors,
69+
...errorsKit.errorsState.priorityErrors,
70+
});
71+
expect(mutableState.fields[mockServiceFieldName].data.regularErrors).toEqual(
72+
existingErrorsKit.errorsState.regularErrors,
73+
);
74+
});
75+
76+
it('should add regular errors to the errors state', () => {
77+
const existingErrorsKit = createMockErrorsKit();
78+
const errorsKit = createMockErrorsKit('2', '2');
79+
const mutableState = createMockMutableState({
80+
[mockServiceFieldName]: {data: existingErrorsKit.errorsState},
81+
});
82+
83+
setErrors(
84+
[
85+
{
86+
serviceFieldName: mockServiceFieldName,
87+
regularErrors: errorsKit.errorsState.regularErrors,
88+
},
89+
],
90+
mutableState,
91+
mockTools,
92+
);
93+
94+
expect(mutableState.fields[mockServiceFieldName].data.priorityErrors).toEqual(
95+
existingErrorsKit.errorsState.priorityErrors,
96+
);
97+
expect(mutableState.fields[mockServiceFieldName].data.regularErrors).toEqual({
98+
...existingErrorsKit.errorsState.regularErrors,
99+
...errorsKit.errorsState.regularErrors,
100+
});
101+
});
102+
103+
it('should add both priority and regular errors to the errors state', () => {
104+
const existingErrorsKit = createMockErrorsKit();
105+
const errorsKit = createMockErrorsKit('2', '2');
106+
const mutableState = createMockMutableState({
107+
[mockServiceFieldName]: {data: existingErrorsKit.errorsState},
108+
});
109+
110+
setErrors(
111+
[
112+
{
113+
serviceFieldName: mockServiceFieldName,
114+
...errorsKit.errorsState,
115+
},
116+
],
117+
mutableState,
118+
mockTools,
119+
);
120+
121+
expect(mutableState.fields[mockServiceFieldName].data.priorityErrors).toEqual({
122+
...existingErrorsKit.errorsState.priorityErrors,
123+
...errorsKit.errorsState.priorityErrors,
124+
});
125+
expect(mutableState.fields[mockServiceFieldName].data.regularErrors).toEqual({
126+
...existingErrorsKit.errorsState.regularErrors,
127+
...errorsKit.errorsState.regularErrors,
128+
});
129+
});
130+
131+
it('should override existing errors with the same field name', () => {
132+
const existingErrorsKit = createMockErrorsKit();
133+
const errorsKit = createMockErrorsKit('2');
134+
const mutableState = createMockMutableState({
135+
[mockServiceFieldName]: {data: existingErrorsKit.errorsState},
136+
});
137+
138+
setErrors(
139+
[
140+
{
141+
serviceFieldName: mockServiceFieldName,
142+
...errorsKit.errorsState,
143+
},
144+
],
145+
mutableState,
146+
mockTools,
147+
);
148+
149+
expect(mutableState.fields[mockServiceFieldName].data.priorityErrors).toEqual({
150+
...errorsKit.errorsState.priorityErrors,
151+
});
152+
expect(mutableState.fields[mockServiceFieldName].data.regularErrors).toEqual({
153+
...errorsKit.errorsState.regularErrors,
154+
});
155+
});
156+
});
157+
158+
describe('removeErrors', () => {
159+
it('should not modify state if service field does not exist', () => {
160+
const mutableState = createMockMutableState();
161+
162+
removeErrors(
163+
[
164+
{
165+
serviceFieldName: mockServiceFieldName,
166+
removeFunctionOrNames: ['fieldName', 'fieldName2'],
167+
},
168+
],
169+
mutableState,
170+
mockTools,
171+
);
172+
173+
expect(mutableState.fields).toEqual({});
174+
});
175+
176+
it('should not modify state if removeFunctionOrNames is not provided', () => {
177+
const existingErrorsKit = createMockErrorsKit();
178+
const mutableState = createMockMutableState({
179+
[mockServiceFieldName]: {data: existingErrorsKit.errorsState},
180+
});
181+
182+
removeErrors(
183+
[{serviceFieldName: mockServiceFieldName}] as any,
184+
mutableState,
185+
mockTools,
186+
);
187+
188+
expect(mutableState.fields[mockServiceFieldName].data).toEqual(
189+
existingErrorsKit.errorsState,
190+
);
191+
});
192+
193+
it('should not modify state if field names array is empty ', () => {
194+
const existingErrorsKit = createMockErrorsKit();
195+
const mutableState = createMockMutableState({
196+
[mockServiceFieldName]: {data: existingErrorsKit.errorsState},
197+
});
198+
199+
removeErrors(
200+
[{serviceFieldName: mockServiceFieldName, removeFunctionOrNames: []}],
201+
mutableState,
202+
mockTools,
203+
);
204+
205+
expect(mutableState.fields[mockServiceFieldName].data).toEqual(
206+
existingErrorsKit.errorsState,
207+
);
208+
});
209+
210+
it('should remove errors by field names', () => {
211+
const errorsKit1 = createMockErrorsKit('1', '1');
212+
const errorsKit2 = createMockErrorsKit('2', '2');
213+
const errorsKit3 = createMockErrorsKit('3', '3');
214+
215+
const mutableState = createMockMutableState({
216+
[mockServiceFieldName]: {
217+
data: {
218+
priorityErrors: {
219+
...errorsKit1.errorsState.priorityErrors,
220+
...errorsKit2.errorsState.priorityErrors,
221+
...errorsKit3.errorsState.priorityErrors,
222+
},
223+
regularErrors: {
224+
...errorsKit1.errorsState.regularErrors,
225+
...errorsKit2.errorsState.regularErrors,
226+
...errorsKit3.errorsState.regularErrors,
227+
},
228+
},
229+
},
230+
});
231+
232+
removeErrors(
233+
[
234+
{
235+
serviceFieldName: mockServiceFieldName,
236+
removeFunctionOrNames: [errorsKit1.fieldName, errorsKit2.fieldName],
237+
},
238+
],
239+
mutableState,
240+
mockTools,
241+
);
242+
243+
expect(mutableState.fields[mockServiceFieldName].data.priorityErrors).toEqual({
244+
...errorsKit3.errorsState.priorityErrors,
245+
});
246+
expect(mutableState.fields[mockServiceFieldName].data.regularErrors).toEqual({
247+
...errorsKit3.errorsState.regularErrors,
248+
});
249+
});
250+
251+
it('should remove errors using a custom function', () => {
252+
const errorsKit1 = createMockErrorsKit('1', '1');
253+
const errorsKit2 = createMockErrorsKit('2', '2');
254+
const errorsKit3 = createMockErrorsKit('3', '3');
255+
256+
const mutableState = createMockMutableState({
257+
[mockServiceFieldName]: {
258+
data: {
259+
priorityErrors: {
260+
...errorsKit1.errorsState.priorityErrors,
261+
...errorsKit2.errorsState.priorityErrors,
262+
...errorsKit3.errorsState.priorityErrors,
263+
},
264+
regularErrors: {
265+
...errorsKit1.errorsState.regularErrors,
266+
...errorsKit2.errorsState.regularErrors,
267+
...errorsKit3.errorsState.regularErrors,
268+
},
269+
},
270+
},
271+
});
272+
273+
const customRemoveFunction = (state: ErrorsState): ErrorsState => {
274+
return {
275+
priorityErrors: omit(state.priorityErrors, [errorsKit1.fieldName]),
276+
regularErrors: omit(state.regularErrors, [errorsKit2.fieldName]),
277+
};
278+
};
279+
280+
removeErrors(
281+
[
282+
{
283+
serviceFieldName: mockServiceFieldName,
284+
removeFunctionOrNames: customRemoveFunction,
285+
},
286+
],
287+
mutableState,
288+
mockTools,
289+
);
290+
291+
expect(mutableState.fields[mockServiceFieldName].data.priorityErrors).toEqual({
292+
...errorsKit2.errorsState.priorityErrors,
293+
...errorsKit3.errorsState.priorityErrors,
294+
});
295+
expect(mutableState.fields[mockServiceFieldName].data.regularErrors).toEqual({
296+
...errorsKit1.errorsState.regularErrors,
297+
...errorsKit3.errorsState.regularErrors,
298+
});
299+
});
300+
301+
it('should handle non-existent field names', () => {
302+
const nonExistentFieldName = 'nonExistentFieldName';
303+
const existingErrorsKit = createMockErrorsKit();
304+
const mutableState = createMockMutableState({
305+
[mockServiceFieldName]: {data: existingErrorsKit.errorsState},
306+
});
307+
308+
removeErrors(
309+
[
310+
{
311+
serviceFieldName: mockServiceFieldName,
312+
removeFunctionOrNames: [nonExistentFieldName],
313+
},
314+
],
315+
mutableState,
316+
mockTools,
317+
);
318+
319+
expect(mutableState.fields[mockServiceFieldName].data).toEqual(
320+
existingErrorsKit.errorsState,
321+
);
322+
});
323+
});
324+
});

0 commit comments

Comments
 (0)