unit-testing - unit test express api

Probando las validaciones de MongooseJs

Question

¿Alguien sabe cómo probar Validaciones de Mangosta?

Ejemplo, tengo 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 método validateEmail 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);
}

Quiero 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

Deberías usar el método validate () como una promesa y probarlo con una herramienta que hace aseveraciones de cosas asincrónicas (por ejemplo, Chai as Promised ).

En primer lugar, solicite una biblioteca de promesas y cambie al proveedor de la promesa (por ejemplo, Q):

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

Luego solo, usa afirmaciones sobre 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: ''[email protected]''
});
return expect(user.validate()).to.be.fulfilled;
});

Answer 2

Tuve el mismo problema recientemente.

Primero, recomendaría probar los validadores por sí mismos. Simplemente muévalos a un archivo separado y exporte las funciones de validación que tiene.

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

Aquí hay un ejemplo de probar los validadores por su propia cuenta:

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

Aquí hay una prueba de muestra para esto (usando mocha + should):

// 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 para la parte más difícil :)

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

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

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 = "[email protected]"
user.validate(function(err){
assert.equal(err, null)
})
})
}) 

La devolución de llamada del validador devuelve un objeto de error que se parece a 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 mongoose, pero así es como estoy probando mis modelos + validadores y parece estar funcionando bastante bien hasta ahora.