- Fixed bug in custom validation, including adding a test to detect it

Author: heath-freenome

packages/validator-ajv6/src/validator.ts

@@ -210,7 +210,7 @@ export default class AJV6Validator<T = any> implements ValidatorType<T> {
   ): ValidationData<T> {
     // Include form data with undefined values, which is required for validation.
     const rootSchema = schema;
-    const newFormData = getDefaultFormState(this, schema, formData, rootSchema, true);
+    const newFormData = getDefaultFormState(this, schema, formData, rootSchema, true) as T;
 
     let validationError: Error | null = null;
     try {
@@ -257,7 +257,7 @@ export default class AJV6Validator<T = any> implements ValidatorType<T> {
       return { errors, errorSchema };
     }
 
-    const errorHandler = customValidate(formData, this.createErrorHandler(formData));
+    const errorHandler = customValidate(newFormData, this.createErrorHandler(newFormData));
     const userErrorSchema = this.unwrapErrorHandler(errorHandler);
     const newErrorSchema: ErrorSchema<T> = mergeObjects(errorSchema, userErrorSchema, true) as ErrorSchema<T>;
     // XXX: The errors list produced is not fully compliant with the format

packages/validator-ajv6/test/validator.test.ts

@@ -247,36 +247,66 @@ describe('AJV6Validator', () => {
       describe('Custom validate function', () => {
         let errors: RJSFValidationError[];
         let errorSchema: ErrorSchema;
+        describe('formData is provided', () => {
+          beforeAll(() => {
+            const schema: RJSFSchema = {
+              type: 'object',
+              required: ['pass1', 'pass2'],
+              properties: {
+                pass1: { type: 'string' },
+                pass2: { type: 'string' },
+                foo: { type: 'array', items: { type: 'string' } } // Adding an array for test coverage
+              },
+            };
 
-        beforeAll(() => {
-          const schema: RJSFSchema = {
-            type: 'object',
-            required: ['pass1', 'pass2'],
-            properties: {
-              pass1: { type: 'string' },
-              pass2: { type: 'string' },
-              foo: { type: 'array', items: { type: 'string' } } // Adding an array for test coverage
-            },
-          };
-
-          const validate = (formData: any, errors: FormValidation<any>) => {
-            if (formData.pass1 !== formData.pass2) {
-              errors.pass2!.addError('passwords don`t match.');
-            }
-            return errors;
-          };
-          const formData = { pass1: 'a', pass2: 'b', foo: ['a'] };
-          const result = validator.validateFormData(formData, schema, validate);
-          errors = result.errors;
-          errorSchema = result.errorSchema;
-        });
-        it('should return an error list', () => {
-          expect(errors).toHaveLength(1);
-          expect(errors[0].stack).toEqual('pass2: passwords don`t match.');
+            const validate = (formData: any, errors: FormValidation<any>) => {
+              if (formData.pass1 !== formData.pass2) {
+                errors.pass2!.addError('passwords don`t match.');
+              }
+              return errors;
+            };
+            const formData = { pass1: 'a', pass2: 'b', foo: ['a'] };
+            const result = validator.validateFormData(formData, schema, validate);
+            errors = result.errors;
+            errorSchema = result.errorSchema;
+          });
+          it('should return an error list', () => {
+            expect(errors).toHaveLength(1);
+            expect(errors[0].stack).toEqual('pass2: passwords don`t match.');
+          });
+          it('should return an errorSchema', () => {
+            expect(errorSchema.pass2!.__errors).toHaveLength(1);
+            expect(errorSchema.pass2!.__errors![0]).toEqual('passwords don`t match.');
+          });
         });
-        it('should return an errorSchema', () => {
-          expect(errorSchema.pass2!.__errors).toHaveLength(1);
-          expect(errorSchema.pass2!.__errors![0]).toEqual('passwords don`t match.');
+        describe('formData is missing data', () => {
+          beforeAll(() => {
+            const schema: RJSFSchema = {
+              type: 'object',
+              properties: {
+                pass1: { type: 'string' },
+                pass2: { type: 'string' },
+              },
+            };
+            const validate = (formData: any, errors: FormValidation<any>) => {
+              if (formData.pass1 !== formData.pass2) {
+                errors.pass2!.addError('passwords don`t match.');
+              }
+              return errors;
+            };
+            const formData = { pass1: 'a' };
+            const result = validator.validateFormData(formData, schema, validate);
+            errors = result.errors;
+            errorSchema = result.errorSchema;
+          });
+          it('should return an error list', () => {
+            expect(errors).toHaveLength(1);
+            expect(errors[0].stack).toEqual('pass2: passwords don`t match.');
+          });
+          it('should return an errorSchema', () => {
+            expect(errorSchema.pass2!.__errors).toHaveLength(1);
+            expect(errorSchema.pass2!.__errors![0]).toEqual('passwords don`t match.');
+          });
         });
       });
       describe('Data-Url validation', () => {