multiple validator errors

lib/errors/validator.js

@@ -8,28 +8,39 @@ var MongooseError = require('../error');
  * Schema validator error
  *
  * @param {String} path
- * @param {String} msg
+ * @param {String|Array} type or array of validator errors
  * @inherits MongooseError
  * @api private
  */
 
 function ValidatorError (path, type) {
-  var msg = type
-    ? '"' + type + '" '
-    : '';
-  MongooseError.call(this, 'Validator ' + msg + 'failed for path ' + path);
+  if (Array.isArray(type)) {
+    this.errors = type;
+    MongooseError.call(this, 'Validators failed for path ' + path);
+  } else {
+    var msg = type
+      ? '"' + type + '" '
+      : '';
+    MongooseError.call(this, 'Validator ' + msg + 'failed for path ' + path);
+    this.type = type;
+  };
   Error.captureStackTrace(this, arguments.callee);
   this.name = 'ValidatorError';
   this.path = path;
-  this.type = type;
 };
 
 /*!
  * toString helper
  */
 
 ValidatorError.prototype.toString = function () {
-  return this.message;
+  if (this.errors) {
+    return this.name + ': ' + this.errors.map(function (value) {
+      return String(value);
+    }, this).join(', ');
+  } else {
+    return this.message;
+  }
 }
 
 /*!

lib/schematype.js

@@ -541,20 +541,33 @@ SchemaType.prototype.select = function select (val) {
  */
 
 SchemaType.prototype.doValidate = function (value, fn, scope) {
-  var err = false
+  var err = null
     , path = this.path
     , count = this.validators.length;
 
-  if (!count) return fn(null);
+  if (!count) return fn(err);
 
   function validate (val, msg) {
-    if (err) return;
-    if (val === undefined || val) {
-      --count || fn(null);
-    } else {
-      fn(err = new ValidatorError(path, msg));
-    }
-  }
+    --count;
+    if (val !== undefined && !val) {
+      if (err && !Array.isArray(err)) {
+        var errArray = [err];
+        err = errArray;
+      } else if (!err) {
+        err = new ValidatorError(path, msg);
+      };
+      if (Array.isArray(err)) {
+        err.push(new ValidatorError(path, msg));
+      };
+    };
+    if (!count) {
+      if (Array.isArray(err)) {
+        return fn(new ValidatorError(path, err));
+      } else {
+        return fn(err);
+      };
+    };
+  };
 
   this.validators.forEach(function (v) {
     var validator = v[0]

test/schema.test.js

@@ -465,6 +465,22 @@ describe('schema', function(){
       done();
     });
 
+    it('multiple errors', function(done){
+      var MultipleTest = new Schema({
+          testProperty: { type: Number, required: true, min: 1, max: 5 } 
+      });
+
+      MultipleTest.path('testProperty').doValidate(undefined, function (err) {
+        assert.ok(err instanceof ValidatorError);
+        assert.equal(true, Array.isArray(err.errors));
+        assert.equal(err.errors.length, 3);
+        for (var i = 0; i < err.errors.length; i += 1) {
+          assert.ok(err.errors[i] instanceof ValidatorError);
+        };
+        done();
+      });
+    });
+
     describe('async', function(){
       it('works', function(done){
         var executed = 0;