Merge branch 'master' of github.com:Automattic/mongoose

Author: vkarpov15

lib/schema/number.js

@@ -26,6 +26,7 @@ const CastError = SchemaType.CastError;
  */
 
 function SchemaNumber(key, options, _schemaOptions, parentSchema) {
+  this.enumValues = [];
   SchemaType.call(this, key, options, 'Number', parentSchema);
 }
 
@@ -316,8 +317,12 @@ SchemaNumber.prototype.enum = function(values, message) {
     this.validators = this.validators.filter(function(v) {
       return v.validator !== this.enumValidator;
     }, this);
+    this.enumValidator = false;
   }
 
+  if (values === void 0 || values === false) {
+    return this;
+  }
 
   if (!Array.isArray(values)) {
     const isObjectSyntax = utils.isPOJO(values) && values.values != null;
@@ -337,12 +342,19 @@ SchemaNumber.prototype.enum = function(values, message) {
 
   message = message == null ? MongooseError.messages.Number.enum : message;
 
-  this.enumValidator = v => v == null || values.indexOf(v) !== -1;
+  for (const value of values) {
+    if (value !== undefined) {
+      this.enumValues.push(this.cast(value));
+    }
+  }
+
+  const vals = this.enumValues;
+  this.enumValidator = v => v == null || vals.indexOf(v) !== -1;
   this.validators.push({
     validator: this.enumValidator,
     message: message,
     type: 'enum',
-    enumValues: values
+    enumValues: vals
   });
 
   return this;

lib/utils.js

@@ -875,15 +875,7 @@ exports.buffer.areEqual = function(a, b) {
   if (!Buffer.isBuffer(b)) {
     return false;
   }
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0, len = a.length; i < len; ++i) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-  return true;
+  return a.equals(b);
 };
 
 exports.getFunctionName = getFunctionName;

test/schema.validation.test.js

@@ -97,6 +97,56 @@ describe('schema', function() {
       await Test.path('state').doValidate('open');
     });
 
+    it('number enum', async function() {
+      const Test = new Schema({
+        status: { type: Number, enum: [1, 2, 3, null] },
+        priority: { type: Number }
+      });
+
+      assert.ok(Test.path('status') instanceof SchemaTypes.Number);
+      assert.deepEqual(Test.path('status').enumValues, [1, 2, 3, null]);
+      assert.equal(Test.path('status').validators.length, 1);
+
+      Test.path('status').enum(4, 5);
+
+      assert.deepEqual(Test.path('status').enumValues, [1, 2, 3, null, 4, 5]);
+
+      // with SchemaTypes validate method
+      Test.path('priority').enum({
+        values: [10, 20, 30],
+        message: 'enum validator failed for path `{PATH}`: test'
+      });
+
+      assert.equal(Test.path('priority').validators.length, 1);
+      assert.deepEqual(Test.path('priority').enumValues, [10, 20, 30]);
+
+      await assert.rejects(Test.path('status').doValidate(6), ValidatorError);
+
+      // allow unsetting enums
+      await Test.path('status').doValidate(undefined);
+
+      await Test.path('status').doValidate(null);
+
+      await assert.rejects(
+        Test.path('status').doValidate(99),
+        ValidatorError
+      );
+
+      await assert.rejects(
+        Test.path('priority').doValidate(40),
+        err => {
+          assert.ok(err instanceof ValidatorError);
+          assert.equal(err.message,
+            'enum validator failed for path `priority`: test');
+          return true;
+        }
+      );
+
+      await Test.path('status').doValidate(1);
+
+      await Test.path('status').doValidate(2);
+    });
+
     it('string regexp', async function() {
       const Test = new Schema({
         simple: { type: String, match: /[a-z]/ }