Pruebas del Método PAUSE en Desarrollo Web

Clase 22 de 38 • Curso de Unit Testing para MEAN con Jasmine

Contenido del curso

Bienvenida e Introducción

Creando un framework de pruebas básico

Análisis estático de código

Trabajando con Jasmine en el frontend

Probando Nodejs apps con Jasmine

Probando Angular apps con Jasmine

Pruebas de integración de Angular apps con Jasmine

Tomar examen

Resumen

Vamos a usar axios: una librería que nos ayuda a consultar y enviar datos a las URLs que le indiquemos con una sintaxis un poco diferente a la de la librería request. Podemos usarla, por ejemplo, para hacer consultas a nuestra propia aplicación para comprobar que obtenemos la información que esperamos.

Instalación de axios:

npm install axios --save-dev

Vamos a probar el caso de éxito del método POST de nuestra API: la aplicación debe responder correctamente cuando los usuarios envían URLs de archivos PDF o páginas con código HTML común y corriente.

En este caso, vamos a utilizar datos "falsos" para correr las pruebas: en vez de descargar los recursos para consumir un PDFs o una páginas web, nosotros mismos vamos a escribir los datos con los que interactúa nuestro código para comprobar que la aplicación responde correctamente.

Comentarios

Jaime Quintero Rodríguez

student•

En el callFake el primer parametro que recibe es Pin, por lo que si no lo pones da error el test con respuesta 500.

spyOn(Pins, 'create').and.callFake((pin, callBack )=> { callBack(false, {}); });```

Tambien falta declarar

var requestPromise = require(‘request-promise-native’);

Creo que esta explicación se podría mejorar, es mas una demostración de sus conocimientos que una guía para aprender porque se hacen las cosas

Edward Fuentes

student•

no lo pudiste decir mejor.

Rodrigo Roldan

student•

Coincido, hay varias lineas que no logro entender del todo.

Mario Alejandro Cortez Salinas

student•

Yo hice el ejercicio con request pero no entendí para que era el objeto post

it("200", done => {
      spyOn(Pins, "create").and.callFake((pin, callBack) => {
        callBack(false, {});
      });
      spyOn(requestPromise, "get").and.returnValue(
        Promise.resolve(
          '<title>Platzi</title><meta name="description" content="Platzi description">'
        )
      );

      const assets = [{ url: "http://platzi.com" }];

      request.post(
        "http://localhost:3000/api",
        {
          json: {
            title: "title",
            author: "author",
            description: "description",
            assets
          }
        },
        (error, response, body) => {
          expect(response.statusCode).toBe(200);
          done();
        }
      );
    });```

Yilmer Ramiro Guativa Rincón

student•

Era para colocar en cambio de objeto json en el metodo post

María Auxiliadora de Jesús Andrade R

student•

Quiero hacer una prueba de un caso más complejo. tengo el la siguiente clase Trxs:

const Mysql2Base = require("./Mysql2Base");
const TrxDetails = require("./../TrxDynamo");
const AuthorizationHelper = require("./../../helpers/authorization.helper");


class Trxs extends Mysql2Base {
   constructor() {
        super();
        this.table = "trxs";
        this.services_table = "servicios";
   } 

   getAll(data){
        return new Promise((resolve, reject) => {    
        let query = 'some_query'
            this.write(query).then( async queryResult => {
                try{             
                    queryResult.forEach((element, idx, arr) => {
                        queryResult[idx]["url"]= this.getCompleteUrl(element.idTrx, element.id_session);
                        let trxDetail = new TrxDetails(element.idTrx);
                        let getTrxDetail = await trxDetail.getTrxDetails();
                        if(getTrxDetail.Count > 0 ){
                           /*
				Codigo...
			   */
                        }else{
                            /*
				Codigo...
			   */
                        }
                    });
		    resolve(queryResult);          
                }catch(error){
                    console.log("ERROR", error);
                    reject(error);
                }    
            }).catch(errorQuery => {
                reject(errorQuery);
            });                   
        }   
   }

    getCompleteUrl(id, idSession) {
        return 'http://example.com' + AuthorizationHelper.generateAuthHeader(id, idSession);
    }

}

module.exports = Trxs;

La clase TrxDynamo (llamada TrxDetails en el codigo anterior) es así:

const Trxs = require("./DYNAMODB/Trxs");

class TrxDynamo extends Trxs{
    constructor(idTrx) {
        super();
        this.idTrx = idTrx;
    }
  
    getTrxDetails() {
        return super.getTrxDetails(this.idTrx);
    }
}

module.exports = TrxDynamo;

'super.getTrxDetails()' es un método de la clase Trxs (distinta a la primera) que es así:

const DynamoBase = require("./DynamoBase");

class Trxs extends DynamoBase{

    constructor() {
        super();
        this.table = `tabla_trx_dynamo`;
    }
   
    getTrxDetails(idTrx) {
        return new Promise((resolve, reject) => {
            let params = {
                TableName: this.table,
                KeyConditionExpression: "#idTrxs = :id",
                ExpressionAttributeNames: {
                    "#idTrxs": "idTrxs",
                },
                ExpressionAttributeValues: {
                    ":id": `${idTrx}`,
  
                },
            };

            super.executeQuery(params).then(saveResult => {
                console.log(saveResult);
                resolve(saveResult);
            }).catch(errorSave => {
                console.log("No se pudo obtener los datos getTrxDetails");
                reject(errorSave);
            });
        });
    }

}

module.exports = Trxs;

En el spec tengo lo siguiente:

const express = require('express');
const http = require('http');
const Trxs = require('./../models/MYSQL/Trxs');
const TrxDetails = require('./../models/DYNAMODB/Trxs');

app.use(express.json());
app.set('port', 3000);

describe('Transacciones', function() {
	let server;
	let trxs;
	let trxDetail;
	let data = {
		idServicio: '468',
		limit: '10'
	};
	let exampleObject = [
		{
			idTrx: 'id1',
			estado: 'COMPLETADA',
			source: 'WebpayPST'
		},
		{
			idTrx: 'id2',
			estado: 'PENDING',
			source: 'WebpayPST'
		}
	];

	beforeAll(() => {
		server = http.createServer(app);
		server.listen(3000);
		trxs = new Trxs();
		trxDetail = new TrxDetails('id1');
		spyOn(trxs, 'write').and.returnValue(Promise.resolve(exampleObject));
		spyOn(trxDetail, 'getTrxDetails').and.returnValue(Promise.resolve({}));
		trxs.getAll(data);
	});

	afterAll(() => 
		server.close();
	});
	it('debe escribir en trx', function(done) {
		expect(trxs.write).toHaveBeenCalled();
		done();
	});
	it('debe obtener detalles de trx', function(done) {
		expect(trxDetail.getTrxDetails).toHaveBeenCalled();
		done();
	});
	it('debe retornar algo', (done) => {
		expect(trxs.getAll).toBeTruthy();
		done();
	});
});

Al método 'getCompleteUrl' puedo acceder mediante spyOn porque es de la misma clase. Y el método 'write' pertenece a la clase Mysql2Base que está inicializada en el constructor con el super(), por lo tanto no tengo problema tampoco. Sin embargo, quiero aplicar spyOn al método 'getTrxDetails' de la clase Trxs (en el spec lo llamo TrxDetails) que está definido en la segunda clase Trxs que mencioné, es decir, desde getAll() se llama a getTrxDetails y de ahí se llama al getTrxDetails que quiero espiar y no funciona. Obtengo este resultado:

Transacciones getTrxDetails id1 . ✔ debe escribir en trx (22ms) F ✖ debe obtener detalles de trx (1 failure) (2ms) . ✔ debe retornar algo (1ms) Failed Specs:
Transacciones : debe obtener detalles de trx Expected spy getTrxDetails to have been called. at <Jasmine> at UserContext.<anonymous> /home/mauxi/Documentos/ebs-api-dashboard/spec/server.spec.js:64:35 at <Jasmine>

¿Cómo manejo este casos?

María Auxiliadora de Jesús Andrade R

student•

Conseguí la respuesta aquí https://stackoverflow.com/questions/31364930/jasmine-how-to-spyon-instance-methods/31365042#31365042?newreg=778be54021bc4785a1b7a8c157568c59 Sería un buen caso para incluir en el curso.

Nicolas Ticona Valdivia

student•

Entiendo que el SPY creado para el requestPromise no se llega a ejecutar en este ejemplo, pero creo comprender que en caso ese código en la lógica de la ruta sea ejecutado entonces devolvería el código visto en clase.

En ese caso es correcto decir que para respuestas asíncronas toca crear SPYs en el test para poder manejar una respuesta controlada en la ejecución del código?

it("200", done => {
      spyOn(Pins, "create").and.callFake((pin, callBack) => {
        callBack(false, {});
      });
      spyOn(requestPromise, "get").and.returnValue(
        Promise.resolve(
          '<title>Platzi</title><meta name="description" content="Platzi description">'
        )
      );

      const assets = [{ url: "http://platzi.com" }];

      request.post(
        "http://localhost:3000/api",
        {
          json: {
            title: "title",
            author: "author",
            description: "description",
            assets
          }
        },
        (error, response, body) => {
          expect(response.statusCode).toBe(200);
          done();
        }
      );
    });```

const Mysql2Base = require("./Mysql2Base");
const TrxDetails = require("./../TrxDynamo");
const AuthorizationHelper = require("./../../helpers/authorization.helper");


class Trxs extends Mysql2Base {
   constructor() {
        super();
        this.table = "trxs";
        this.services_table = "servicios";
   } 

   getAll(data){
        return new Promise((resolve, reject) => {    
        let query = 'some_query'
            this.write(query).then( async queryResult => {
                try{             
                    queryResult.forEach((element, idx, arr) => {
                        queryResult[idx]["url"]= this.getCompleteUrl(element.idTrx, element.id_session);
                        let trxDetail = new TrxDetails(element.idTrx);
                        let getTrxDetail = await trxDetail.getTrxDetails();
                        if(getTrxDetail.Count > 0 ){
                           /*
				Codigo...
			   */
                        }else{
                            /*
				Codigo...
			   */
                        }
                    });
		    resolve(queryResult);          
                }catch(error){
                    console.log("ERROR", error);
                    reject(error);
                }    
            }).catch(errorQuery => {
                reject(errorQuery);
            });                   
        }   
   }

    getCompleteUrl(id, idSession) {
        return 'http://example.com' + AuthorizationHelper.generateAuthHeader(id, idSession);
    }

}

module.exports = Trxs;

const Trxs = require("./DYNAMODB/Trxs");

class TrxDynamo extends Trxs{
    constructor(idTrx) {
        super();
        this.idTrx = idTrx;
    }
  
    getTrxDetails() {
        return super.getTrxDetails(this.idTrx);
    }
}

module.exports = TrxDynamo;

const DynamoBase = require("./DynamoBase");

class Trxs extends DynamoBase{

    constructor() {
        super();
        this.table = `tabla_trx_dynamo`;
    }
   
    getTrxDetails(idTrx) {
        return new Promise((resolve, reject) => {
            let params = {
                TableName: this.table,
                KeyConditionExpression: "#idTrxs = :id",
                ExpressionAttributeNames: {
                    "#idTrxs": "idTrxs",
                },
                ExpressionAttributeValues: {
                    ":id": `${idTrx}`,
  
                },
            };

            super.executeQuery(params).then(saveResult => {
                console.log(saveResult);
                resolve(saveResult);
            }).catch(errorSave => {
                console.log("No se pudo obtener los datos getTrxDetails");
                reject(errorSave);
            });
        });
    }

}

module.exports = Trxs;

const express = require('express');
const http = require('http');
const Trxs = require('./../models/MYSQL/Trxs');
const TrxDetails = require('./../models/DYNAMODB/Trxs');

app.use(express.json());
app.set('port', 3000);

describe('Transacciones', function() {
	let server;
	let trxs;
	let trxDetail;
	let data = {
		idServicio: '468',
		limit: '10'
	};
	let exampleObject = [
		{
			idTrx: 'id1',
			estado: 'COMPLETADA',
			source: 'WebpayPST'
		},
		{
			idTrx: 'id2',
			estado: 'PENDING',
			source: 'WebpayPST'
		}
	];

	beforeAll(() => {
		server = http.createServer(app);
		server.listen(3000);
		trxs = new Trxs();
		trxDetail = new TrxDetails('id1');
		spyOn(trxs, 'write').and.returnValue(Promise.resolve(exampleObject));
		spyOn(trxDetail, 'getTrxDetails').and.returnValue(Promise.resolve({}));
		trxs.getAll(data);
	});

	afterAll(() => 
		server.close();
	});
	it('debe escribir en trx', function(done) {
		expect(trxs.write).toHaveBeenCalled();
		done();
	});
	it('debe obtener detalles de trx', function(done) {
		expect(trxDetail.getTrxDetails).toHaveBeenCalled();
		done();
	});
	it('debe retornar algo', (done) => {
		expect(trxs.getAll).toBeTruthy();
		done();
	});
});

Pruebas del Método PAUSE en Desarrollo Web

Bienvenida e Introducción

Pruebas unitarias con Jasmine para JavaScript

Pruebas Unitarias: Mejora y Seguridad en Desarrollo de Software

Creando un framework de pruebas básico

Pruebas Unitarias Básicas en JavaScript: Creación y Ejecución

Refactorización de Pruebas en JavaScript con Funciones expect e it

Refactorización de Pruebas JavaScript con Framework Personalizado

Adaptación de Frameworks JavaScript para Node.js y Browser

Análisis estático de código

Herramientas para Mejorar la Calidad del Código en JavaScript

Configuración de ESLint en VS Code paso a paso

Configuración de Prettier en Proyectos JavaScript

Tipado Estricto en TypeScript para Aplicaciones Angular

Trabajando con Jasmine en el frontend

Pruebas Unitarias con Jasmine: Uso de spyOn para Simular Funciones

Configuración de Jasmine para Pruebas de Frontend

Configuración de Jasmine en Node.js para Pruebas Unitarias

Pruebas Unitarias en JavaScript con Jasmine: Uso de Funciones Básicas

Pruebas Unitarias con Jasmine: Matchers, Espías y Ciclos de Vida

Probando Nodejs apps con Jasmine

Pruebas Unitarias con Jasmine en Node.js y Angular

Configuración de Pruebas Unitarias en Node.js con Jasmine

Configuración avanzada de Jasmine y reportes en Node.js

Implementación de Cobertura de Código con InstaBoot.js y NGC

Pruebas Unitarias de Servidor Express con Método GET en Node.js

Pruebas Unitarias de Código 500 en Métodos GET