El alojamiento de una API conlleva la responsabilidad de asegurarse de que funcione. No hay una manera mejor o más fácil de hacerlo que las pruebas automatizadas con una herramienta como Mocha.

El desarrollo de software moderno hace un gran uso de las API. Sirven como un enlace crucial entre las aplicaciones del lado del cliente y las aplicaciones de back-end, así como entre diferentes aplicaciones internas o externas.

Las API permiten una comunicación y un intercambio de datos fluidos, lo que permite que los componentes de software interactúen entre sí sin problemas. Garantizar la confiabilidad, la funcionalidad y el rendimiento de estas API es de suma importancia para brindar una experiencia de usuario perfecta y mantener la integridad general del sistema.

Por lo tanto, es importante probar exhaustivamente sus API para marcar y corregir errores durante el desarrollo para evitar posibles fallas del sistema en entornos de producción.

Prueba de las API de Node.js con Mocha, Chai y Chai-HTTP

instagram viewer

Moca es un marco de prueba ampliamente utilizado que es compatible con varios Marcos de JavaScript. Una de sus características clave es un ejecutor de pruebas flexible que simplifica el proceso de gestión y ejecución de casos de prueba de manera eficaz.

También es compatible con varios estilos de prueba, incluidas las pruebas sincrónicas y asincrónicas, lo que permite una amplia gama de escenarios de prueba.

Por otro lado, Chai y Chai-HTTP son bibliotecas de aserciones que puede usar junto con Mocha. Chai proporciona una amplia gama de interfaces de afirmación expresivas y legibles, como debería, esperar y afirmar. Mientras que Chai-HTTP, una extensión de Chai, proporciona una interfaz diseñada específicamente para probar solicitudes HTTP y afirmar sus respuestas.

Al usar Mocha junto con Chai y Chai-HTTP, puede probar las API de manera efectiva. El flujo de trabajo de prueba implica:

  • Realización de solicitudes HTTP a los puntos finales de la API especificados.
  • Definición de las respuestas esperadas.
  • Validación de los datos recibidos de la fuente especificada, los códigos de estado HTTP y más.

También puede simular escenarios de prueba de errores de API que pueden surgir en tales situaciones y qué acciones deberían desencadenarse en caso de que ocurran.

Puedes encontrar el código de este proyecto en su repositorio GitHub.

Configurar el proyecto Express.js y la base de datos MongoDB

Para empezar, crear un servidor web Expresse instale estos paquetes:

npm instalar cors dotenv mongoose mongodb

Próximo, crear una base de datos MongoDB o configurar un clúster MongoDB en la nube. Luego copie la URL de conexión de la base de datos, cree una .env en el directorio raíz y pegue la cadena de conexión de la base de datos:

CONNECTION_STRING="cadena de conexión"

Para finalizar el proceso de configuración, debe configurar la conexión de la base de datos y definir los modelos de datos para sus datos de usuario. Consulte el código en el repositorio de GitHub de este proyecto para:

  • Configurar la conexión a la base de datos, en utils/db.js.
  • Defina el esquema de datos de usuario en modelos/usuario.modelo.js.

Definir las funciones del controlador para las rutas API

Las funciones del controlador gestionarán la adición y recuperación de datos de usuario en la base de datos. Para garantizar la funcionalidad de estas funciones de controlador, probará si pueden publicar y obtener datos de la base de datos correctamente.

En el directorio raíz, cree un controladores/controladores de usuario.js archivo y agregue el siguiente código:

constante Usuario = requerir('../modelos/usuario.modelo');
exportaciones.registerUser = asíncrono (requerido, res) => {
constante { nombre de usuario, contraseña } = req.body;


intentar {
esperar Usuario.create({nombre de usuario, contraseña});
 res.status(201).enviar({ mensaje: 'Usuario registrado con éxito' });
 } atrapar (error) {
consola.log (error);
 res.status(500).enviar({ mensaje: '¡¡Ocurrió un error!! ' });
 }
};
exportaciones.getUsers = asíncrono (requerido, res) => {
intentar {
constante usuarios = esperar Usuario.find({});
 res.json (usuarios);
 } atrapar (error) {
consola.log (error);
 res.status(500).enviar({ mensaje: '¡¡Ocurrió un error!!' });
 }
};

Definir las rutas API

Crear un nuevo rutas/rutas de usuario.js archivo en el directorio raíz y agregue el siguiente código.

constante expresar = requerir('expresar');
constante enrutador = expreso. enrutador();
constante controladores de usuario = requerir('../controladores/usuarioControladores');
enrutador.post('/api/registrar', controladores de usuario.registerUser);
enrutador.get('/api/usuarios', UserControllers.getUsers);
módulo.exportaciones = enrutador;

Defina el punto de entrada de su servidor

Actualiza tu servidor.js archivo con el siguiente código.

constante expresar = requerir('expresar');
constante corazones = requerir('corazón');
constante aplicación = expreso();
constante puerto = 5000;
requerir('dotenv').config();
constante conectarDB = requerir('./utils/db');
conectarDB();


aplicación.uso (express.json());
app.use (express.urlencoded({ extendido: verdadero }));
app.use (cors());


constante rutas de usuario = requerir('./rutas/rutasusuario');
aplicación.uso('/', rutas de usuario);


app.listen (puerto, () => {
consola.registro(`El servidor está escuchando en http://localhost:${puerto}`);
});
módulo.exportaciones = aplicación;

Escriba y ejecute los casos de prueba con Mocha

Con la API de usuario en su lugar, continúe y configure el entorno de prueba. Primero, instale estos paquetes como dependencias de desarrollo.

npm instalar mocha chai chai-http --save-dev

Ahora, agregue el siguiente script a su archivo package.json.

"guiones": {
"prueba": "moca --tiempo de espera 10000"
},

Este comando ejecutará los casos de prueba; agregar la propiedad de tiempo de espera con un valor apropiado le permite controlar el tiempo máximo permitido para que se ejecuten los casos de prueba individuales.

Esto puede ser útil para evitar que las pruebas se ejecuten indefinidamente o se completen demasiado rápido antes de que finalicen los casos de prueba.

Pruebe los puntos finales de la API

En el directorio raíz, cree una nueva carpeta y asígnele un nombre prueba. Dentro de esta carpeta, crea una nueva usuario.pruebas.js y agregue el siguiente código para el caso de prueba de punto final POST.

constante Chai = requerir('chai');
constante chaiHttp = requerir('chai-http');
constante aplicación = requerir('../servidor'); 
chai.uso (chaiHttp);
constante esperar = chai.esperar;


describir('API de usuario', () => {
 describir('POST /api/registrar', () => {
 él('debería manejar el registro de usuario', (hecho) => {
 chai.request (aplicación)
 .correo('/api/registrar')
 .enviar({ nombre de usuario: 'usuario de prueba', contraseña: 'contraseña de prueba' })
 .fin((err, res) => {
si (Error) {
 esperar (res).to.have.status(500);
 esperar (res.cuerpo).tener.propiedad('mensaje').que.es.igual('¡¡Ocurrió un error!!');
 } demás {
 esperar (res).to.have.status(201);
 esperar (res.cuerpo).tener.propiedad('mensaje').igual('Usuario registrado con éxito');
 }
 hecho();
 });
 });
 });
});

Este código define un caso de prueba usando Chai y Chai HTTP para probar la funcionalidad de registro de usuario de la API de usuario.

Envía una solicitud POST al punto final especificado y realiza afirmaciones sobre la respuesta API esperada, verificando si la funcionalidad de registro del usuario fue exitosa o si ocurrió un error.

Aquí hay un desglose de los componentes principales del caso de prueba:

  • esperar -Este objeto le permite usar los métodos de aserción de Chai para hacer aserciones sobre la respuesta esperada de la API.
  • describir - Describe juntos casos de prueba relacionados, en este caso, pruebas relacionadas con el API de usuario. El bloque de descripción anidado agrupa más casos de prueba relacionados, en este caso, el POST /api/registro. Esto ayuda a organizar los casos de prueba específicamente relacionados con una funcionalidad particular.
  • él - Esta función describe el comportamiento esperado del extremo de la API.
  • fin - Esta función envía la solicitud y proporciona una función de devolución de llamada para manejar la respuesta. La función de devolución de llamada realiza aserciones utilizando el esperar función para comprobar la respuesta recibida de la API.
  • hecho - Esta función se ejecuta para marcar el final del caso de prueba.

Finalmente, agregue el código para el caso de prueba de punto final GET justo después del caso de prueba de punto final POST.

describir('GET /api/usuarios', () => {
 él('debería obtener todos los datos del usuario', (hecho) => {
 chai.request (aplicación)
 .conseguir('/api/usuarios')
 .fin((err, res) => {
si (Error) {
 esperar (res).to.have.status(500);
 esperar (res.cuerpo).tener.propiedad('mensaje').que.es.igual('Se produjo un error al obtener los datos del usuario');
 } demás {
 esperar (res).to.have.status(200);
 esperar (res.cuerpo).ser.un('formación');
 }
 hecho();
 });
 });
});

Continúe y ejecute el script de prueba en su terminal para ejecutar los dos casos de prueba.

prueba npm

Si la ejecución de los casos de prueba no encuentra ningún error, debería ver un resultado similar que indica que las pruebas pasaron con éxito.

Las fallas de prueba pueden ocurrir debido a varias razones, como problemas de conectividad de red durante las solicitudes HTTP a la base de datos, falta de datos requeridos, errores lógicos y otros problemas.

Mocha hace un buen trabajo al identificar y resaltar tales errores, proporcionando informes de prueba claros y detallados en los registros que se muestran en la ventana de la terminal. Esto le permite identificar y diagnosticar fácilmente los problemas específicos que causaron las fallas en las pruebas.

Mocha no le da excusas para no probar sus API

Mientras que probar manualmente la funcionalidad de sus API usando herramientas como Postman es una prueba válida enfoque, aprovechar Mocha y otros marcos de prueba para pruebas automatizadas lo lleva al siguiente nivel.

Con estas herramientas de prueba, puede automatizar rápida y fácilmente las pruebas para cubrir una amplia gama de escenarios y casos extremos. Esto le permite detectar errores rápidamente y resolverlos antes de implementar sus API, lo que garantiza que envía software de alta calidad a producción.