¿Cómo usar moca con mangosta?

Mocha: Mocha es un marco de prueba que se utiliza para realizar pruebas dentro de nuestra aplicación. Se asegura de que todo funcione correctamente.

‘Mocha en Node.js’ significa usar el marco de prueba de unidad mocha en el entorno de tiempo de ejecución de Node.js. Mocha tiene toneladas de excelentes funciones.

Características clave:

• Soporte asíncrono simple.
• Compatibilidad con el tiempo de espera de la prueba asíncrona.
• Use cualquier biblioteca de aserciones que desee
• Antes, después, antes de cada, después de cada gancho son muy útiles para limpiar el ambiente con cada prueba.

Si no está familiarizado con la mangosta , haga clic aquí .

A lo largo de un período de tiempo, nuestra aplicación tendrá una mayor cantidad de líneas de código para probar que la lógica real de la aplicación. Por lo tanto, siempre es algo por lo que estar agradecido por componer pruebas y seguir un enfoque de desarrollo basado en pruebas o TDD.

En esta publicación, configuraremos un conjunto de pruebas fundamental para realizar nuestro procedimiento Crear, leer, actualizar y eliminar (CRUD) en el conjunto de datos de MongoDB con la biblioteca Mongoose utilizando la estructura de prueba Mocha más conocida.

Instalación de módulos:

npm i mocha mongoose

Estructura de carpetas: crearemos todos los archivos de prueba en el directorio de prueba.

En nuestro proyecto Node.js-MongoDB, usaremos este archivo de ayuda para crear la conexión. Si es nuevo en MongoDB , consulte esta publicación .

// test/test_helper.js
  
const mongoose = require('mongoose');
  
// tells mongoose to use ES6 implementation of promises
mongoose.Promise = global.Promise;
const MONGODB_URI = 'mongodb://mongodb0.example.com:27017';
mongoose.connect(MONGODB_URI);
  
mongoose.connection
    .once('open', () => console.log('Connected!'))
    .on('error', (error) => {
        console.warn('Error : ', error);
    });
      
    // runs before each test
    beforeEach((done) => {
        mongoose.connection.collections.users.drop(() => {
        done();
       });
});

Usaremos el enlace beforeEach() para vaciar nuestra base de datos antes de que se ejecuten nuestras pruebas. La eliminación lleva tiempo, por lo que debemos mantener mocha antes de que finalice la operación. Llamar a la función done() indica que la operación ha terminado ahora y podemos continuar con la ejecución.

.on() y .once() son los controladores de eventos. Toman el evento como primer argumento y una función como segundo argumento que se ejecuta una vez que ocurre el evento.

Nuestro esquema MongoDB:

// Inside schema/user.js
  
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
  
const UserSchema = new Schema({
    name: {
        type: String,
        required: [true, 'Name is required.']
      },
    age: Integer
 })
   
// it represents the entire collection of User data
const User = mongoose.model('User', UserSchema);
module.exports = User;

Ahora, necesitamos un script en nuestro archivo package.json para iniciar la prueba.

"scripts": { 
  "test" : "mocha --recursive --exit"
 }

En –recursive significa que probará recursivamente dentro del directorio de prueba y –exit para salir cuando se hayan ejecutado todas las pruebas. Use el siguiente comando para ejecutar pruebas usando Mocha.

npm run test

Mocha nos proporciona una función describe() que toma una string como primer parámetro que se usa para identificar el grupo de pruebas que pasan o fallan, y la lógica de prueba se implementa como una función en el segundo parámetro de describe().

El describe() puede contener múltiples pruebas dentro de un método it() o también funciones anidadas de describe(). En nuestro caso, crearemos diferentes archivos para cada operación CRUD en MongoDB. Alternativamente, podríamos haber usado un solo archivo con diferentes bloques de descripción.

Como cada prueba necesita que afirmemos algo, Mocha nos permite usar muchas bibliotecas de aserción. Aquí usaremos el módulo de afirmación integrado de Node.js. 

Al agregar done() a it() en una devolución de llamada de prueba, Mocha sabrá que esta prueba se ha completado.
 

//import the User model
const User = require('../schema/user');
const assert = require('assert');
  
describe('Creating documents in MongoDB', () => {
    it('Creates a New User', (done) => {
        const newUser = new User({ name: 'Shriyam' });
        newUser.save() // returns a promise after some time
            .then(() => {
                //if the newUser is saved in db and it is not new
                assert(!newUser.isNew);
                done();
            });
    });
});

const User = require('../schema/user');
const assert = require('assert');
  
let user;
// this will run before running every test
beforeEach(() => {
    // Creating a new Instance of User Model
    user = new User({  name: 'Shriyam' });
    user.save()
        .then(() => done());
});
  
describe('Reading Details of User', () => {
    it('Finds user with the name', (done) => {
        User.findOne({ name: 'Shriyam' })
            .then((user) => {
                assert(user.name === 'Shriyam');
                done();
            });
    })
})

const User = require('../schema/user');
const assert = require('assert');
  
describe('Deleting a User', () => {
  
    let user;
    beforeEach((done), () => {
        // user is an instance of User Model
        user = new User({ name: 'Shriyam' });
        user.save()
            .then(() => done());
    });
  
    it('Removes a User using its instance', (done) => {
    User.remove()
        // Checking if the user was deleted from DB or not
        .then(() => User.findOne({ name: 'Shriyam' }))
        .then((user) => {
            assert(user === null);
            done();
        });
    });
  
    it('Removes a user', (done) => {
    User.findOneAndRemove({ name: 'Shriyam' })
        .then(() => User.findOne({ name: 'Shriyam' }))
        .then((user) => {
            assert(user === null);
            done();
        });
    });
  
    it('Removes a user using its id', (done) => {
    User.findIdAndRemove(user._id)
        .then(() => User.findOne({ name: 'Shriyam' }))
        .then((user) => {
            assert(user === null);
            done();
        });
    })
})

const Username = require('../schema/user');
const assert = require('assert');
  
describe('Deleting a user', () => {
  
    let user;
    beforeEach((done) => {
        user = new User({ name: 'Shriyam' });
        user.save()
            .then(() => done());
    });
  
    // Handling Redundant Code
    function helperFunc(assertion, done) {
    assertion
        .then(() => User.find({}))
        .then((users) => {
            assert(users.length === 1);
            assert(users[0].name === 'Updated Shriyam');
            done();
        });
    }
  
    it('Sets and saves a user using an instance', (done) => {
        // Not yet updated in MongoDb
        user.set('name', 'Updated Shriyam');
        helperFunc(user.save(), done);
    });
  
    it('Update a user using instance', (done) => {
        helperFunc(user.update({ name: 'Updated Shriyam' }), done);
    });
});

Entonces, ahora hemos aprendido cómo crear pruebas unitarias usando Mocha con Mongoose.
Sugerencia: use la biblioteca de mockgoose para usar una base de datos Dummy MongoDB para que su base de datos original se mantenga limpia.