Validation should pass if form data is empty (#7)

Author: OxCom

src/Validator/Form.js

@@ -2,6 +2,7 @@ import { isArray }      from '../Utils/functions';
 import ViolationBuilder from '../Utils/ViolationBuilder';
 import Validator        from './Validator';
 
+const FORM_ERROR_FIELD = 'form';
 const MESSAGE_EXTRA_FIELDS = 'This form should not contain extra fields.';
 
 export default class Form {
@@ -22,6 +23,7 @@ export default class Form {
         this.violationBuilder = new ViolationBuilder();
         this.fields = {};
         this.data = {};
+        this.errors = {};
     }
 
     /**
@@ -65,50 +67,64 @@ export default class Form {
      * @return {Array}
      */
     validate(data) {
-        const errors = {};
-
+        this.errors = {};
         this.data = data;
 
         if (!this.options.extra_fields) {
-            let extra = this.hasExtraFields(data);
-            if (extra) {
-                errors['form'] = [extra];
-            }
+            this.checkExtraFields();
         }
 
-        if (Object.keys(errors).length > 0) {
-            return errors;
+        if (Object.keys(this.errors).length > 0) {
+            return this.errors;
         }
 
-        Object.keys(data).forEach((field) => {
-            const value = data[field];
+        Object.keys(this.fields).forEach((field) => {
+            const value = this.data[field];
+            const errors = this.validator.validate(value, this.fields[field].constants, {form: this});
 
-            if (typeof this.fields[field] === 'undefined') {
-                return true;
+            if (errors.length > 0) {
+                this.addValidationErrors(field, errors);
             }
+        });
 
-            const fieldErrors = this.validator.validate(value, this.fields[field].constants, {form: this});
+        return this.errors;
+    }
 
-            if (fieldErrors.length > 0) {
-                errors[field] = fieldErrors;
-            }
-        });
+    /**
+     * @param {string} field
+     * @param {Error|Error[]} error
+     * @return {Form}
+     */
+    addValidationErrors(field, error) {
+        if (!isArray(this.errors[field])) {
+            this.errors[field] = [];
+        }
 
-        return errors;
+        if (isArray(error)) {
+            this.errors[field] = this.errors[field].concat(error);
+        } else {
+            this.errors[field].push(error);
+        }
+
+        return this;
     }
 
     /**
-     * @param {Object} data
-     * @return {Error|undefined}
+     * @return {Form}
      */
-    hasExtraFields(data) {
-        for (const field of Object.keys(data)) {
+    checkExtraFields() {
+        for (const field of Object.keys(this.data)) {
             if (typeof this.fields[field] === 'undefined') {
-                return this.violationBuilder.build(this.options.extra_fields_message);
+                this.addValidationErrors(
+                    FORM_ERROR_FIELD,
+                    this.violationBuilder.build(this.options.extra_fields_message)
+                );
+
+                break;
             }
         }
 
-        return;
+        return this;
     }
 
     getData() {

tests/Validator/Form.spec.js

@@ -156,7 +156,7 @@ describe('Form', function () {
                 .add('email')
                 .add('password');
 
-            let e = form.validate({
+            const e = form.validate({
                 email: 'email@example.com',
                 password: '1234567',
                 ip: '8.8.8.8',
@@ -183,6 +183,20 @@ describe('Form', function () {
 
             assert.strictEqual(Object.keys(e).length, 0);
         });
+
+        it('Validation empty form data', function () {
+            const form = new Form({extra_fields: true});
+
+            form.add('email', [
+                new NotBlank(),
+                new Email(),
+                new Length({min: 17}),
+            ]);
+
+            let e = form.validate({});
+
+            assert.strictEqual(Object.keys(e).length, 1);
+        });
     });
 
     describe('#getData()', function () {