Creación de tests para nuestros endpoints

Clase 38 de 48 • Curso de Backend con Node.js 2019

Comentarios

Beatriz Pérez Santana

student•

mocha: nos ayuda a correr los test
supertest: levanta un servidor temporal
sinon: crea mocks para tests
proxyquire inyecta los mocks cuando se requieren los paquetes

Carlos Enrique Ramírez Flores

student•

gracias!

Manuel Alejandro Blanco Lamas

student•

Por si no quieren tipar mucho npm i -D mocha supertest sinon proxyquire

Javier Armando Vargas Vega

student•

La clase no estuvo muy clara. A mi parecer faltó explicar con más claridad lo relacionado con los test en javascript para poder entender más fácilmente lo que se estaba estudiando. Este profesor sabe mucho del tema pero explica demasiado rápido y no se alcanza a entender muchas de las cosas que habla.

Freddy Barrios

student•

Si, tiene que ser más pausado

Kamerr Ezz

student•

lo mismo pienso, me perdi para que son los test o las dependencias

Félix Andersson

student•

Investigué las documentaciones de las librerías para entender la clase y estos son mis apuntes por si les sirven. ⠀

Flujo de tests Mocha

⠀

Consideramos un test it(mensaje, function () {});

⠀ Si dentro del callback se lanza un error, el test se da por fallido y se pasa al siguiente test.

En caso de que la ejecución del callback termine sin errores entonces se pasa al siguiente test automáticamente. ⠀ Si en la ejecución del callback llamamos a una función asíncrona, debemos pasarle una función 'done' como parámetro (el nombre es arbitrario). ⠀ Si pasamos ese parámetro mocha sabrá que debe esperar a que la ejecutemos para pasar al siguiente test y darlo como aprobado. O en caso de que ejecutemos done(error), sabrá que debe pasar al siguiente pero dándolo como fallido.

it(mensaje, function (done) {
	setInmediate(() => done());
});

En caso de tengamos una promesa podemos simplemente retornarla y mocha esperará a que la promesa se complete, dando el test como aprobado o fallido dependiendo de si se resuelve correctamente o no. ⠀ Debemos utilizar el callback done o retornar una promesa, pero no utilizar ambos o se producirá un error.

it(mensaje, async function () {
	return Promise.resolve('hola');
});

⠀ También podemos realizar un test asíncrono y tratarlo como síncrono con async/await. En este caso, al igual que en el caso síncrono, el test depende de si la función finaliza correctamente o finaliza con un error. ⠀⠀

it(mensaje, async function () {
	const promesa = Promise.resolve('hola');

	await promesa;
});

⠀ Como no envolvemos el await en un try/catch, este lanzará un error en caso de que la promesa sea rechazada, por lo tento el test pasará fallido. ⠀

Testing de endpoints HTTP

⠀ Para esto utilizamos una librería llamada supertest, la cual sirve para testear servidores HTTP NODE.js, nos permite envíar solicitudes HTTP de tipo GET, POST, PATCH, PUT, y DELETE, y recibir la respuesta. ⠀ supertest nos provee una función a la que le debemos pasar nuestra app express como parámetro (con sus rutas establecidas), y nos retornará un objeto por el cual podemos relizar solicitudes y validaciones. ⠀

const createRequester = require('supertest');
const request = createRequester(app);

request
    .get('/user')
    .expect('Content-Type', /json/)
    .expect('Content-Length', '15')
    .expect(200)
    .end(function(err, res) {
        if (err) throw err;
    });

⠀ Si estamos en un test mocha, podemos pasar el done a la función end. ⠀

request
    .get('/user')
    .expect(200)
    .end(done);

⠀ De esta manera, si hay un error mocha recibirá un done con el error y el test fallará, y si no hay error, no fallará porque done no recibirá un error. End recibe un error first callback. ⠀ Si no usamos la función end, los expect lanzarán errores en el segundo parámetro y podemos capturarlos de la siguiente manera... ⠀

request
    .get('/user')
    .expect(200, done);

⠀ Para leer la respuesta podemos usar un then ⠀

request
    .get('/user')
    .then(response => {
        assert(response.body.email, 'foo@bar.com');
    });

Bruno Amadori

student•

Fabuloso, muy claro el hilado de conceptos. Gracias compañero.

Alver Alexander Grisales Ortega

student•

Les recomiendo jest para los test unitarios, tanto en el front como en el back

Markoz Peña Mendez

student•

Totalmente de acuerdo !

Ginnio Sarabia

student•

Aprendí muy poco en esta clase. . Voy a leer los comentarios, y ver de nuevo la clase. . De aquí salgo aprendiendo- . VUAAAAAAAAAAMOS

Ginnio Sarabia

student•

3era vez que veo la clase: .

En esta clase usamos los test para verificar las rutas. Y las respuestas esperadas. .
Proxyquire: nos permite hacer "trampa" y modifcar un require dentro de un archivo, en este caso donde encuentre este require:

'../services/movies'

lo remplaza con:

'MoviesServiceMock'

done o done(): Es la forma de indicar que nuestro test es exitoso.

//Si el request obtiene un valor de 200 entonces es DONE --> TEST EXITOSO
request.get('/api/movies').expect(200, done)

Requerimos ASSERT para comparar objetos. Si el Assert falla el programa se termina, es decir el done() nunca se ejecuta. Por tanto el test falla.

assert.deepEqual(res.body, {
                    data: moviesMock,
                    message: 'movies listed'
                });
                done();

Félix Andersson

student•

VUAMOS GEREROS

César A. Guerrón

student•

Al ejecutar el script de test me dio un error porque faltaba setear la variable NODE_ENV

"test": "set NODE_ENV=development && mocha --exit"

Juan Sebastian Cortes Torres

student•

No olviden en test-server hacer uso del parse de express para formato json, el no hacerlo puede generarle error, en su defectoque la prueba falle.

const express = require('express')
const supertest = require('supertest')

function testServer(route){
    const app = express()
    app.use(express.json())
    route(app)
    return supertest(app)
}

module.exports = testServer

Samar Jaffal

student•

Algo que me di cuenta, es que es super importante que al hacer el deepEqual asegurarse que los datos que estan comparando sean exactamente iguales. En este caso tanto la data como el mensaje que se reciben. Me estaba dando errores porque en el mensaje que retornaba de las rutas era diferente al que comparaba en el test. Me salía este error:

. Así que hay que estar muy pendientes con este tipo de errores.

Diego Andres Cabrera Rojas

student•

si lo que pasa es que , se levanta el servidor con supertest y le pasas las rutas de movies a ese servidor y cuando le hagas un request.get(/api/movies) por ejemplo va a realizar ese llamado y acuerdate que nos devuelve un json con data, y message y eso lo compara con lo que le digamos para ver si se cumple o no el test , si no tienen los mismos datos , es porque esta mal y el test fallara.

Omar Flores Grimontt

student•

¿Alguien sabe por qué esto funciona

En 'routes/movies.js'

const MovieService = require('../services/MovieService')

En 'test/routes.movies.test.js'

const route = proxyquire('../routes/movies', {
        '../services/MovieService': MoviesServiceMock
})

Pero esto no:

En 'routes/movies.js'

const { MovieService } = require('../services/')

En 'test/routes.movies.test.js'

const route = proxyquire('../routes/movies', {
        '../services/': { MovieService: MoviesServiceMock }
})

Ezequiel Guerra

student•

Depende como lo estés exportando es decir,

aquí

const MovieService = require('../services/MovieService')

lo exportas así:

module.exports = MovieService

esto dentro de un archivo MovieService.js. Ahora si lo quieres exportar haciendo destructuring

debes exportarlo asi:

module.exports = {
	MovieService
}

Otra cosa a tener en cuenta es que en el ejemplo que no te funciona lo estas buscando dentro del directorio services sin indicar el nombre del archivo.

const { MovieService } = require('../services/')

para que esto funcione el archivo no debe llamarse MovieService debe ser services/index.js

y de nuevo debes exportarlo module.exports = MovieService y llamarlo

const MovieService  = require('../services/')

Cristian Orlando Rincon Bonilla

student•

Si alguno tuvo problemas con el deepEqual, es porque la función está deprecada, la correcta es :


assert.deepStrictEqual(res.body, {
                    data: moviesMock,
                    message: 'movies listed',
                });

Juan David Ruiz Cohen

student•

Tambien se puede utilizar el

assert.notStrictEqual

Daniel Sánchez

teacher•

Repositorio de la clase: https://github.com/glrodasz/platzi-backend-node/tree/creacion-de-tests-para-nuestros-endpoints

Jesus Adrian Berrio Valdes

student•

Implementar test en Node.js 🧪

Las dependencias que instalaremos solo se usarán en modo de desarrollo cuales son

mocha: nos ayuda a correr los test
supertest : no ayuda a levantar un sevidor temporal
sinon: nos ayuda a hacer mocks
proyquiere: nos ayuda a inyectar los mocks

El objetivo de esto es probar unicamente las rutas, no nos conectaremos a nuestros servicios como mongoDB si no que lo haremos a nuestros Mocks

Crearemos el archivo donde haremos los test

Importamos las dependencias que nos ayudarán

const assert = require('assert');
const proxyquire = require('proxyquire');

Importamos el creador de sevidores temporales y los mocks

const { moviesMock, MoviesServiceMock } = require('../utils/mocks/movies.js');
const testServer = require('../utils/testServer');

El testServer se le tiene que pasar una funcion con las rutas

Esta funcion reemplazará el requiere del servicio de mongo por el de Mock que importamos

describe('routes - movies', function() {
  const route = proxyquire('../routes/movies', {
    '../services/movies': MoviesServiceMock
  });
// una vez realizado el cambio proxiquery nos 
// nos devuelve el mismo archivo pero con las 
// modificaciones, y esto lo podemos guardar 
// en una variable

Una vez el mock inyectado se lo pasamos a supertes que hará un servidor temporal

const request = testServer(route);

Creamos una prueba pero en vez de inyectar algo hará un unit test, le pasamos el nombre del test y la función a ejecutar

El done quiere fucionaría como un next, es decir termina aquí

describe('GET /movies', function() {
    it('should respond with status 200', function(done) {
      request.get('/api/movies').expect(200, done);
    });

it( una descripción de lo que deberia dar, funcion a ejecutar

it('should respond with status 200', function...

La función no es mas que un servidor temporal con el archivo modificado, dentro de este haremos un

routes.get(ruta a probar, expect(status esperado, done))

request.get('/api/movies').expect(200, done);

Ahora usaremos el .end que recibe una función que tiene el resultado de la petición y si hay algun error,

.end((err, res) => {
        assert.deepEqual(res.body, {
          data: moviesMock,
          message: 'movies listed'
        });

usaremos assert.deepEqual(valor 1, valor 2) cual comparará los datos

Carlos Enrique Ramírez Flores

student•

instalar:

npm i -D mocha supertest sinon proxyquire

Fernando Mellone

student•

Tal y como todo proxy sirve para interceptar procesos, proxyquire sirve para interceptar un módulo (require).

const route = proxyquire('../routes/movies', {
    '../services/movies': MoviesServiceMock,
  });

El primer parámetro representa la ruta del archivo donde pensamos interceptar el módulo (require) Ej.: '../routes/movies'.

El segundo parámetro son pares "llave-valor" en los cuales, respectivamente, cada llave representa el módulo que se quiere interceptar (Ej.: '../services/movies'), y cada valor representa el módulo (Ej.: MoviesServiceMock) por el cual se va a reemplazar el (módulo de la llave) que se está interceptando.

Utilizando lo que tenemos hasta ahora quedaría algo como esto:

const route = proxyquire('../routes/movies', {
    '../services/movies': require('../utils/mocks/movies').MoviesServiceMock,
  });

o más a fondo:

// en el archivo routes/movies.js quedaría algo así

const MoviesService = require('../services/movies');
const { MoviesServiceMock } = require('../services/mocks/movies')
const MoviesService = MoviesServiceMock;

// o sea sobrescribiendo el contenido del primer "MoviesService"

Espero no haber confundido más a nadie 🤣

Gustavo Muñoz

student•

creo que falta mas detalles sobre el tema de test, debería ser un modulo completo.

Hector Romero

student•

Si modificaron alguna parte del código con anterioridad y ahora tienen problemas con MOCHA, este código les puede ayudar.

require('dotenv').config();

const config = {
	dev: (process.env.NODE_ENV || '').trim() !== 'production',
	port: process.env.PORT || 3000,
	cors: process.env.CORS,
	dbUser: process.env.DB_USER,
	dbPass: process.env.DB_PASSWORD,
	dbHost: process.env.DB_HOST,
	dbName: process.env.DB_NAME,
};

module.exports = {
	config,
};

José Indalicio Carvajal Hernández

student•

gracias! me salvaste la noche!

Kamerr Ezz

student•

he encontrado esta informacion acerca de los tes ya que mas adelante podrias no entender nada.

Y si encuentras mi comentario en el siguiente video, me das un corazonsito <3

Luis Rodriguez

student•

Siempre es bueno escribir las cosas un@ mism@... pero a veces es más fácil con un simple copy/paste:

npm i -D mocha supertest sinon proxyquire

Cristofers Valdez Quintin

student•

cuando vayan a crear los 'servicios' de mock, asegúrense que las funciones tenga el mismo nombre que del servicio original (osea, si en su capa de servicio para obtener peliculas es getAll, en el mock coloquenlo igual), dure media hora con un error por culpa de una 's' :)

y realmente la consola no es que ayudo mucho para solucionar el error, ya que me daba a entender que el error estaba en el archivo de test en si, y no en el mock xd

Gaspar Dolcemascolo

student•

No me esta gustando el BackEnd. O el curso va muy rápido pero no entiendo casi nada de lo que hace. Me sale este error.

npm ERR! code EJSONPARSE
npm ERR! path C:\Users\Tassaroli\Desktop\gaspar\homevidoe-backend/package.json
npm ERR! JSON.parse Unexpected string in JSON at position 133 while parsing '{
npm ERR! JSON.parse   "name": "HomeVideo-backend",
npm ERR! JSON.parse   "ve'
npm ERR! JSON.parse Failed to parse JSON data.
npm ERR! JSON.parse Note: package.json must be actual JSON, not just JavaScript.

const createRequester = require('supertest');
const request = createRequester(app);

request
    .get('/user')
    .expect('Content-Type', /json/)
    .expect('Content-Length', '15')
    .expect(200)
    .end(function(err, res) {
        if (err) throw err;
    });

const express = require('express')
const supertest = require('supertest')

function testServer(route){
    const app = express()
    app.use(express.json())
    route(app)
    return supertest(app)
}

module.exports = testServer

describe('routes - movies', function() {
  const route = proxyquire('../routes/movies', {
    '../services/movies': MoviesServiceMock
  });
// una vez realizado el cambio proxiquery nos 
// nos devuelve el mismo archivo pero con las 
// modificaciones, y esto lo podemos guardar 
// en una variable

// en el archivo routes/movies.js quedaría algo así

const MoviesService = require('../services/movies');
const { MoviesServiceMock } = require('../services/mocks/movies')
const MoviesService = MoviesServiceMock;

// o sea sobrescribiendo el contenido del primer "MoviesService"

require('dotenv').config();

const config = {
	dev: (process.env.NODE_ENV || '').trim() !== 'production',
	port: process.env.PORT || 3000,
	cors: process.env.CORS,
	dbUser: process.env.DB_USER,
	dbPass: process.env.DB_PASSWORD,
	dbHost: process.env.DB_HOST,
	dbName: process.env.DB_NAME,
};

module.exports = {
	config,
};

npm ERR! code EJSONPARSE
npm ERR! path C:\Users\Tassaroli\Desktop\gaspar\homevidoe-backend/package.json
npm ERR! JSON.parse Unexpected string in JSON at position 133 while parsing '{
npm ERR! JSON.parse   "name": "HomeVideo-backend",
npm ERR! JSON.parse   "ve'
npm ERR! JSON.parse Failed to parse JSON data.
npm ERR! JSON.parse Note: package.json must be actual JSON, not just JavaScript.

Creación de tests para nuestros endpoints

Tu primera experiencia con Node.js

¿Dónde aprender backend con Node.js actualizado?

Todo lo que aprenderás sobre backend con Node.js

¿Qué es Node.js?

¿Qué es Node.js y para qué sirve?

Diferencias entre Node.js y JavaScript

Resumen: Diferencias Nodejs y Javascript

Instalación de Node.js

Arquitectura orientada a eventos

Node.js para la web

Manejo y uso de Streams con Node.js

Introducción a streams

Readable y Writable streams

Duplex y Transforms streams

Uso de utilidades de Node.js

Sistema operativo y sistema de archivos

Administrar directorios y archivos

Consola, utilidades y debugging

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

¿Qué es Express.js y para qué sirve?

Creando tu primer servidor con Express.js

Request y Response Objects

Aprende a crear un API con REST

Anatomía de una API Restful

Estructura de una película con Moockaru

Implementando un CRUD en Express.js

Métodos idempotentes del CRUD

Implementando una capa de servicios

Cómo conectarse con librerías externas en Express.js

Creación de una BD en MongoAtlas

Conexión a MongoAtlas una instancia de MongoDB

Conexión con Robot3T y MongoDB Compass a una BD

Implementación de las acciones de MongoDB

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

¿Qué es un middleware? Capa de manejo de errores usando un middleware

Manejo de errores asíncronos y síncronos en Express

Capa de validación de datos usando un middleware

¿Qué es Joi y Boom?

Implementando Boom

Implementando Joi

Probar la validación de nuestros endpoints

Middlewares populares en Express.js

Implementa tests en Node.js

Creación de tests para nuestros endpoints

Creación de tests para nuestros servicios

Creación de tests para nuestras utilidades

Agregando un comando para coverage

Debugging e inspect

Despliega tu primera aplicación en Express.js

Considerando las mejores prácticas para el despliegue

Variables de entorno, CORS y HTTPS

¿Cómo implementar una capa de manejo de caché?

¿Cómo contener tu aplicación en Docker?

Despliegue en Now

Conclusiones

¿Qué aprendiste en este curso?