Post Top Ad

Your Ad Spot

martes, 18 de agosto de 2020

Pruebas unitarias con Mocha y Chai

Mocha  es un marco de prueba para  NodeJs , que simplifica las pruebas asincrónicas. Las pruebas de Mocha se ejecutan en serie.
Chai es una biblioteca de aserciones BDD / TDD para el nodo y el navegador que se puede emparejar con cualquier marco de prueba JS.
Este artículo tiene como objetivo proporcionar una comprensión básica de la ejecución de mocha / chai en Node JS Apps, escribir pruebas con Mocha y configurar pruebas unitarias con Mocha y Chai . Probaremos una aplicación de usuario simple, usando Mocha y Chai.
Mi suposición es que el usuario tiene un conocimiento básico de  NodeJs .
Requisitos
- Nodo instalado (al menos v6 y superior)
- MongoDB instalado
- Editor de texto
El código fuente de la aplicación se puede encontrar  aquí .
La estructura de la aplicación
Estructura de la aplicación

package.json
En la raíz de su proyecto, ejecute  npm init para crear un archivo package.json. Actualice el archivo con el siguiente contenido:
{
  "nombre": "prueba de moca",
  "versión": "1.0.0",
  "description": "Artículo de prueba de Mocha",
  "main": "index.js",
  "guiones": {
    "inicio": "nodo index.js",
    "prueba": "moca"
  },
  "autor": "Collins",
  "licencia": "ISC",
  "dependencias": {
    "body-parser": "^ 1.15.1",
    "config": "^ 1.20.1",
    "express": "^ 4.13.4",
    "mangosta": "^ 4.4.15",
    "morgan": "^ 1.7.0"
  },
  "devDependencies": {
    "chai": "^ 3.5.0",
    "chai-http": "^ 2.0.1",
    "moca": "^ 2.4.5"
  }
}

Controladores
Esta carpeta contiene un archivo  user.js que alberga varias funciones de la aplicación. Actualice el archivo con el siguiente contenido:
let mangosta = require ('mangosta');
let User = require ('../ modelos / usuario');

function createUser (req, res) {
var newUser = nuevo usuario (req.body);
newUser.save ((err, usuario) => {
if (err) {
res.send (err);
}
else {
res.json ({mensaje: "Usuario creado correctamente", usuario});
}
});
}

function getUsers (req, res) {
let query = User.find ({});
query.exec ((err, usuarios) => {
if (err) res.send (err);
res.json (usuarios);
});
}

function updateUser (req, res) {
User.findById ({_ id: req.params.id}, (err, usuario) => {
if (err) res.send (err);
Object.assign (usuario, req.body) .save ((err, usuario) => {
if (err) res.send (err);
res.json ({mensaje: 'Usuario actualizado', usuario});
});
});
}

function deleteUser (req, res) {
User.remove ({_ id: req.params.id}, (err, result) => {
res.json ({mensaje: "Usuario eliminado", resultado});
});
}

module.exports = {getUsers, createUser, deleteUser, updateUser};
index.js
Este archivo contiene toda la configuración del servidor. Llene el archivo con lo siguiente:
let express = require ('express');
dejar app = express ();
let mangosta = require ('mangosta');
let morgan = require ('morgan');
let bodyParser = require ('body-parser');
let port = 5000;
let user = require ('./ controllers / user');
     
mongoose.connect ("127.0.0.1:27017");
                                     
app.use (bodyParser.json ());                                    
app.use (bodyParser.urlencoded ({extendido: verdadero}));              
app.use (bodyParser.text ());                                    
app.use (bodyParser.json ({tipo: 'aplicación / json'}));  

app.get ("/", (req, res) => res.json ({mensaje: "Aplicación de administración de usuarios"}));

app.route ("/ usuario")
.get (usuario.getUsers)
.post (usuario.createUser);
app.route ("/ usuario /: id")
.delete (usuario.deleteUser)
.put (usuario.updateUser);
app.listen (puerto);
module.exports = aplicación;


Modelos
A continuación, crearemos modelos para nuestra aplicación. Cree una carpeta llamada modelos  y dentro de esta carpeta, cree un archivo llamado user.js . Complete el archivo con el contenido a continuación:
let mangosta = require ('mangosta');
deje Schema = mongoose.Schema;

let UserSchema = new Schema (
  {
    firstName: {type: String, required: true},
    lastName: {type: String, required: true},
    emailAddress: {type: String, required: true},
    nombre de usuario: {tipo: Cadena, obligatorio: verdadero},
    contraseña: {tipo: Cadena, obligatorio: verdadero},    
  },
  {
    versionKey: falso
  }
);

module.exports = mongoose.model ('usuario', UserSchema);
Es hora de ejecutar nuestra aplicación. En primer lugar, instale los paquetes necesarios, es decir, npm install, luego ejecute la aplicación, npm start. Puede navegar por la aplicación en el puerto 5000 usando Postman. Por ejemplo:

CREAR:
CREAR:
LEER 
LEER

ACTUALIZAR 
Las pruebas anteriores pueden engañarlo diciendo que la aplicación es 100% funcional, sin fallas. Este no es el caso. Deberíamos escribir pruebas para demostrar que nuestra aplicación funciona como se esperaba.
Pruebas
Mocha espera por defecto una carpeta llamada test . Vamos a crear la carpeta, y dentro de esta carpeta, crear un archivo de prueba llamada user.js . Complete el archivo con el siguiente contenido:

Como está familiarizado con JS, en el bloque de código anterior, solo estoy importando los paquetes y archivos necesarios para que nuestras pruebas se ejecuten correctamente. 
A continuación, cree el bloque principal para las pruebas:
Pruebas

Queremos que la base de datos se borre antes de que se ejecute cada prueba. Mocha tiene lo que llamamos beforeEach . Esto ejecuta un bloque de código antes de cada prueba en una descripción. 
Pruebas
A continuación, agreguemos una prueba que probará la creación de un usuario: 
Pruebas
El bloque de código anterior asegura primero que no se pueda crear un usuario sin una dirección de correo electrónico. También demuestra que, en realidad, cuando se publican datos válidos en el punto final / user , se crea un usuario correctamente. 
Probemos esto. Ejecute la  prueba npm. El resultado debería ser el siguiente:
Pruebas
A continuación se muestra un archivo de prueba user.js completo , que tiene pruebas de direccionamiento, CREAR, LEER, ACTUALIZAR Y ELIMINAR. El código se explica por sí mismo. Copie el código y actualice el archivo de prueba que tiene hasta ahora.
let mangosta = require ("mangosta");
let User = require ('../ modelos / usuario');
let chai = require ('chai');
let chaiHttp = require ('chai-http');
let server = require ('../ index');
let should = chai.should ();


chai.use (chaiHttp);

describe ('Usuarios', () => {
beforeEach ((hecho) => {
User.remove ({}, (err) => {
   hecho();  
});
    });
 
    describe ('/ usuario POST', () => {
        it ('no debería crear un usuario sin dirección de correo electrónico', (hecho) => {
            dejar usuario = {
                nombre: "Juan",
                apellido: "Doe",
              nombre de usuario: "usuario",
              contraseña: "pasar"
            }
              chai.request (servidor)
              .post ('/ usuario')
              .send (usuario)
              .end ((err, res) => {
                    res.debe.tener.estatus (200);
                    res.body.should.be.a ('objeto');
                    res.body.should.have.property ('errores');
                    res.body.errors.emailAddress.should.have.property ('kind'). eql ('required');
                hecho();
              });
        });
       
        it ('debería crear un usuario', (hecho) => {
          dejar usuario = {
              nombre: "Juan",
              apellido: "Doe",
              emailAddress: "doe@email.com",
              nombre de usuario: "yo",
              contraseña: "pasar"
          }
              chai.request (servidor)
              .post ('/ usuario')
              .send (usuario)
              .end ((err, res) => {
                    res.debe.tener.estatus (200);
                    res.body.should.be.a ('objeto');
                    res.body.should.have.property ('mensaje'). eql ('Usuario creado correctamente');
                    res.body.user.should.have.property ('nombre');
                    res.body.user.should.have.property ('apellido');
                    res.body.user.should.have.property ('emailAddress');
                    res.body.user.should.have.property ('nombre de usuario');
                hecho();
              });
        });
    });

  describe ('/ GET user', () => {
  it ('debería OBTENER a todos los usuarios', (hecho) => {
chai.request (servidor)
    .get ('/ usuario')
    .end ((err, res) => {
  res.debe.tener.estatus (200);
  res.body.should.be.a ('matriz');
  res.body.length.should.be.eql (0);
      hecho();
    });
  });
  });


  describe ('/ PUT /: id user', () => {
  it ('debería actualizar a un usuario con una identificación', (hecho) => {
  let user = new User ({firstName: "John", lastName: "Doe", emailAddress: "doe@email.com", username: "user", password: "pass"})
  user.save ((err, usuario) => {
chai.request (servidor)
    .put ('/ usuario /' + user.id)
    .send ({firstName: "John", lastName: "Doe", emailAddress: "john@email.com", username: "user", password: "pass"})
    .end ((err, res) => {
  res.debe.tener.estatus (200);
  res.body.should.be.a ('objeto');
  res.body.should.have.property ('mensaje'). eql ('Usuario actualizado');
  res.body.user.should.have.property ('emailAddress'). eql ("john@email.com");
      hecho();
    });
  });
  });
  });

  describe ('/ DELETE /: id user', () => {
  it ('debería eliminar a un usuario dado una identificación', (hecho) => {
  let user = new User ({firstName: "John", lastName: "Doe", emailAddress: "doe@email.com", username: "user", password: "pass"})
  user.save ((err, usuario) => {
chai.request (servidor)
    .delete ('/ usuario /' + user.id)
    .end ((err, res) => {
  res.debe.tener.estatus (200);
  res.body.should.be.a ('objeto');
  res.body.should.have.property ('mensaje'). eql ('Usuario eliminado');
      hecho();
    });
  });
  });
  });
});

Al ejecutar las pruebas, debería tener algo similar a:
Pruebas
Conclusión
Si ha seguido con atención los pasos anteriores desde la instalación de Mocha y Chai en Node JS hasta la prueba del código de Node JS con Mocha y Chai , debería tener una aplicación funcional con pruebas aprobadas.
Este tutorial no cubre exhaustivamente las pruebas de Mocha. Hay otros conceptos que no he ilustrado aquí. Para una comprensión más profunda, puede dirigirse a los  documentos .
No confunda lo anterior con TDD. Después de comprender cómo  probar una aplicación , podemos crear una aplicación utilizando los principios de TDD. Con suerte, ese es mi próximo tutorial. ¡Manténganse al tanto!

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

outbrain

Páginas