Prueba de validación de MongooseJs

Question

¿Alguien sabe cómo probar las validaciones de mangosta?

ejemplo, he el siguiente esquema (como ejemplo):

var UserAccount = new Schema({ 
    user_name  : { type: String, required: true, lowercase: true, trim: true, index: { unique: true }, validate: [ validateEmail, "Email is not a valid email."] }, 
    password  : { type: String, required: true }, 
    date_created : { type: Date, required: true, default: Date.now } 
}); 

El validateEmail método se define como tal:

// Email Validator 
function validateEmail (val) { 
    return /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/.test(val); 
} 

I desea probar las validaciones. El resultado final es que quiero poder probar las validaciones y, dependiendo de lo que esté sucediendo, puedo escribir otras pruebas que prueben las interacciones entre esos fragmentos de código. Ejemplo: el usuario intenta registrarse con el mismo nombre de usuario que el que se tomó (el correo electrónico ya está en uso). Necesito una prueba que realmente pueda interceptar o ver que la validación está funcionando SIN golpear la base de datos. NO quiero pegarle a Mongo durante estas pruebas. Estas deberían ser pruebas UNIT NO pruebas de integración. :)

Gracias!

Answer 1

Tuve el mismo problema recientemente.

En primer lugar recomendaría probar los validadores por su propia cuenta. Simplemente muévalos a un archivo separado y exporte las funciones de validación que tenga.

Esto permite fácilmente que sus modelos se dividan en archivos separados porque puede compartir estos validadores en diferentes modelos.

Aquí es un ejemplo de las pruebas de los validadores por su cuenta:

// validators.js 
exports.validatePresenceOf = function(value){ ... } 
exports.validateEmail = function(value){ ... } 

Aquí es una prueba de muestra para esto (usando moca + debería):

// validators.tests.js 
var validator = require('./validators') 

// Example test 
describe("validateEmail", function(){ 
    it("should return false when invalid email", function(){ 
     validator.validateEmail("asdsa").should.equal(false) 
    })  
}) 

Ahora viene la parte más difícil:)

Para probar que sus modelos son válidos sin acceder a la base de datos, hay una función de validación que se puede invocar directamente en su modelo.

Aquí es un ejemplo de cómo actualmente lo hago:

describe("validating user", function(){ 
    it("should have errors when email is invalid", function(){ 
    var user = new User(); 
    user.email = "bad email!!" 
    user.validate(function(err){  
     err.errors.email.type.should.equal("Email is invalid") 
    }) 
    }) 

    it("should have no errors when email is valid", function(){ 
    var user = new User(); 
    user.email = "test123@email.com" 
    user.validate(function(err){ 
     assert.equal(err, null) 
    }) 
    }) 
}) 

La devolución de llamada recibe un validador de regreso objeto de error que se ve algo como esto:

{ message: 'Validation failed', 
    name: 'ValidationError', 
    errors: 
     { email: 
      { message: 'Validator "Email is invalid" failed for path email', 
      name: 'ValidatorError', 
      path: 'email', 
      type: 'Email is invalid' 
      } 
     } 
} 

todavía soy nuevo en nodejs y mangosta, pero así es como estoy probando mis modelos + validadores y parece estar funcionando bastante bien hasta ahora.

Answer 2

Debe usar el método validate() como una promesa y probarlo con una herramienta que hace aseveraciones de cosas asincrónicas (ej .: Chai as Promised).

En primer lugar, requiere una biblioteca promesa y cambiar a cabo con el proveedor de la promesa (por ejemplo Q):

mongoose.Promise = require('q').Promise; 

Después simplemente, el uso afirma acerca de las promesas:

it('should show errors on wrong email', function() { 
     user = new UserModel({ 
      email: 'wrong email adress' 
     }); 
     return expect(user.validate()).to.be.rejected; 
    }); 

    it('should not show errors on valid email adress', function() { 
     user = new UserModel({ 
      email: 'test@test.io' 
     }); 
     return expect(user.validate()).to.be.fulfilled; 
    });