Pruebas en el servidor: Probando el método POST (request to PDF)

Curso de Unit Testing para MEAN con Jasmine

Bienvenida e Introducción

¿Qué son las pruebas unitarias?

¿Por qué hacer pruebas unitarias?

Creando un framework de pruebas básico

Mi primera prueba unitaria en JavaScript

Las funciones expect() y it()

Organizando el código para correr en la web

Organizando el código para correr utilizando nodejs

Análisis estático de código

Herramientas de análisis estático de código

ESLint: Agregando alertas a nuestro código con ECMA Script

Herramientas de corrección de estilo

Herramientas de tipado

Trabajando con Jasmine en el frontend

Profundización en SpyOn: Comandos más utilizados y cómo ponerlos a prueba

Configurar un ambiente de trabajo para trabajar con el framework jasmine

Configurar Jasmine utilizando Node.js

Primer set de pruebas con Jasmine

Diccionario Jasmine

Probando Nodejs apps con Jasmine

Introducción al módulo de testing del lado del servidor

Configurando el proyecto Jasmine utilizando npm

Agregando Plugins a Jasmine

Configurando nuestro reporter

Pruebas en el servidor: Verificando un status 200 en GET

Pruebas en el servidor: Probando el método GET y Reto con FindByID

Pruebas en el servidor: Probando el método POST (request to server)

Pruebas en el servidor: Probando el método POST (request to PDF)

Probando Angular apps con Jasmine

Tipos de pruebas

Pruebas en el frontend: Probando el componente principal (App)

Configurando los ciclos de vida

Creando las pruebas del formulario: Configuración

Creando las pruebas necesarias para un formulario. (Primeras pruebas)

Probando el caso de exito al guardar un elemento en el servidor.

Trabajando con event emitters

Testeando ngZone y navegación.

Configurando el TestBed de el componente PINs

Creando un espia sobre el objecto window

Pruebas de integración de Angular apps con Jasmine

Ejecutando funciones a través de eventos en el template

Probando la navegación

Probando servicios con HTTP

Completando las pruebas del servicio HTTP

Cierre del curso

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Crear cuenta

Si ya tienes una cuenta,

Iniciar sesión

Recursos

Aportes 7

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

BRYAN ALEXANDER CONDOR DE LA CRUZ

hace 2 años

**Pruebas al 100% **

Aqui les comparto el archivo de pruebas, espero les ayude en algo

Archivo: server.spec.js

const express = require('express');
const morgan = require('morgan');
const { createServer } = require('http');
const request = require('request');
const requestPromise = require('request-promise-native');
const axios = require('axios').default;

const Pins = require('./models/Pins');
const routerPins = require('./routes/pins');


const app = express();

app.use(morgan('dev'));
app.use(express.json());
app.use('/api', routerPins.router);



describe('Testing Router', () => {

    let server;

    beforeAll(() => {
        server = createServer(app);
        server.listen(3000);
    });

    afterAll(() => {
        server.close();
    });


    describe('Testing GET', () => {

        it('Llama a recurso /api al método raíz esperando 200', done => {


            spyOn(Pins, 'find').and.callFake(callbackFromFind => {


                const pinsFake = [{ id: 1 }];
                callbackFromFind(false, pinsFake);
            });


            request.get('http://localhost:3000/api/', (error, response, bodyI) => {
                expect(response.statusCode).toBe(200);
                expect(JSON.parse(response.body)).toEqual([{ id: 1 }]);

            })
        });


        it('Llama a recurso /api/ esperando 500', done => {


            spyOn(Pins, 'find').and.callFake(callback => {
                callback(true, null);
            });

            request.get('http://localhost:3000/api/', (error, response, body) => {
                expect(response.statusCode).toBe(500);
                
                done();
            })
        });


        it('llamar a recurso /api/:id esperando 200', done => {

            spyOn(Pins, 'findById').and.callFake((id, callback) => {
                const pinsFake = [{ id: 1 }];
                callback(false, pinsFake);
            })

            request.get('http://localhost:3000/api/1001', (error, response, body) => {
                expect(response.statusCode).toBe(200);
                done();
            })
        });

        it('llamar a recurso /api/:id esperando 500', done => {

            spyOn(Pins, 'findById').and.callFake((id, callback) => {
                callback(true, null);
            })

            request.get('http://localhost:3000/api/1001', (error, response, body) => {
                expect(response.statusCode).toBe(500);
                done();
            })
        });


    });


    describe('Testing POST', () => {

        it('llamar a recurso /api/ esperando 200', done => {

            spyOn(Pins, 'create').and.callFake((pinFake, callback) => {
                callback(false, {})
            });

            spyOn(requestPromise, 'get').and.returnValue(
                Promise.resolve('<title>Platzi</title><meta name="description" content="Platzi reglas">')
            );

            const requestPost = {
                title: 'Titulo',
                author: 'Autor',
                description: 'Esta es una descripción',
                assets: [{ url: 'http://platzi.com' }]
            };

            request.post('http://localhost:3000/api/', { json: requestPost }, (error, response, body) => {
                expect(response.statusCode).toBe(200);
                done();
            });


        });


        it('llamar a recurso /api/ flujo cuando la url es un .pdf o .png esperando 200', done => {

            spyOn(Pins, 'create').and.callFake((pinFake, callback) => {
                callback(false, {})
            });

            spyOn(requestPromise, 'get').and.returnValue(
                Promise.resolve('<title>Platzi</title><meta name="description" content="Platzi reglas">')
            );

            const requestPost = {
                title: 'Titulo',
                author: 'Autor',
                description: 'Esta es una descripción',
                assets: [{ url: 'http://image.pdf' }]
            };

            request.post('http://localhost:3000/api/', { json: requestPost }, (error, response, body) => {
                expect(response.statusCode).toBe(200);
                done();
            })

        })


        it('llamar a recurso /api/ flujo cuando la url es un .pdf o .png esperando 500', done => {

            spyOn(Pins, 'create').and.callFake((pinFake, callback) => {
                callback(true, null);
            });

            request.post('http://localhost:3000/api/', { json: { assets: [] } }, (error, response, body) => {
                expect(response.statusCode).toBe(500);
                done();
            })
        });


        it('llamar a recurso /api/ flujo cuando la url es un .pdf o .png esperando 463', done => {

            spyOn(Pins, 'create').and.callFake((pinFake, callback) => {
                callback(false, {});
            });

            request.post('http://localhost:3000/api/', { json: { assets: [{ url: 'http://prueba.com' }] } }, (error, response, body) => {
                expect(response.statusCode).toBe(463);
                done();
            });
        });

    });


    describe('Testing PUT', () => {

        it('llamar a recurso /api/:id esperando 200', done => {

            spyOn(Pins, 'findByIdAndUpdate').and.callFake((id, body, callback) => {
                callback(false, {});
            });

            request.put('http://localhost:3000/api/1005', (error, response, body) => {
                expect(response.statusCode).toBe(200);
                done();
            });

        });

        it('llamar a recurso /api/:id esperando 500', done => {

            spyOn(Pins, 'findByIdAndUpdate').and.callFake((id, body, callback) => {
                callback(true, null);
            });

            request.put('http://localhost:3000/api/1005', (error, response, body) => {
                expect(response.statusCode).toBe(500);
                done();
            });

        });


    });


    describe('Testing DELETE', () => {

        it('llamar a recurso /api/:id esperando 200', done => {

            spyOn(Pins, 'findByIdAndRemove').and.callFake((id, body, callback) => {
                callback(false, {});
            });

            request.delete('http://localhost:3000/api/1006', (error, response, body) => {
                expect(response.statusCode).toBe(200);
                done();
            });

        });

        it('llamar a recurso /api/:id esperando 500', done => {

            spyOn(Pins, 'findByIdAndRemove').and.callFake((id, body, callback) => {
                callback(true, null);
            });

            request.delete('http://localhost:3000/api/1006', (error, response, body) => {
                expect(response.statusCode).toBe(500);
                done();
            });

        });

    });

})

Edgar Moises Valdez Faria

hace 2 años

pienso que el profesor se complicó con el código en el backend, es difícil de entender que es lo que hace, por ende no se entiende lo que está probando. hubiese hecho un método get y post más simple.

Damian Spizzirri

hace 3 años

Hola, quiero testear que de error este get requestPromise.get({ url: asset.url });

Lo estoy haciendo asi, pero no anda, alguno me puede dar una mano??

    it("500", done => {
      const pins = { title: "Platzi", author: "Platzi", description: "Platzi rules", percentage: 0, tags: [],assets: []};

      spyOn(requestPromise, "get").and.returnValue(        
		Promise.reject(new Error("Ocurrio un error"))
      );

      const assets = [{ url: "http://platzi.com" }];
      axios
        .post("http://localhost:3000/api", {
          title: "title",
          author: "author",
          description: "description",
          assets
        })
          .catch(err => {
          console.log(err);
          expect(err.response.status).toBe(500);
          done();
        });
    });

Byron Mesias Cueva Cabrera

hace 2 años

Pruebas realizadas hasta el 97%, solo me falta el catch de la función getMetadataFromAssets

mario-salinas

hace 3 años

Les dejo la manera de hacer las petición con request

it("200 PDF", done => {
      spyOn(Pins, "create").and.callFake((pins, callBack) => {
        callBack(false, {});
      });

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

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

Nikolas Santis

hace 2 años

Lo hice así:

usando el error.response.status

// 500
    it('should return 500', done => {
      spyOn(Pins, 'create').and.callFake((pins, callBack) => {
        callBack(true, {})
      })

      const assets = [{ url: 'http://nikolas.com' }]

      axios.post(
        'http://localhost:3000/api',
        { title: 'title', author: 'author', description: 'description', assets })
        .catch(error => {
          expect(error.response.status).toBe(500)
          done()
        })
    })```

Carlos Alejandro Hernández Mejía

hace 2 años

Les dejo mi solución al reto.

describe('PUT', () => {
        it('should get 200 as status code', (done) => {
            const pin = {id: 22};
            spyOn(Pins, 'findByIdAndUpdate').and.callFake((id, body, callBack) => {
                callBack(false, pin);
            });
            request.put(`${apiUrl}/${pin.id}`, { json: pin }, (error, response, body) => {
                expect(error).toBeNull();
                expect(response.statusCode).toBe(200);
                expect(response.body).toEqual(pin);
                done();
            })
        });
        it('should get 500 as status code', (done) => {
            const pin = {id: 22};
            spyOn(Pins, 'findByIdAndUpdate').and.callFake((id, body, callBack) => {
                callBack(true, null);
            });
            request.put(`${apiUrl}/${pin.id}`, { json: pin }, (error, response, body) => {
                expect(response.statusCode).toBe(500);
                done();
            });
        });
    });
    describe('DELETE', () => {
        it('should get 200 as status code', (done) => {
            const pin = {id: 22};
            spyOn(Pins, 'findByIdAndRemove').and.callFake((id, body, callBack) => {
                callBack(false, pin);
            });
            request.delete(`${apiUrl}/${pin.id}`, { json: pin }, (error, response, body) => {
                expect(error).toBeNull();
                expect(response.statusCode).toBe(200);
                expect(response.body).toEqual(pin);
                done();
            })
        });
        it('should get 500 as status code', (done) => {
            const pin = {id: 22};
            spyOn(Pins, 'findByIdAndRemove').and.callFake((id, body, callBack) => {
                callBack(true, null);
            });
            request.delete(`${apiUrl}/${pin.id}`, { json: pin }, (error, response, body) => {
                expect(response.statusCode).toBe(500);
                done();
            });
        });
    });```