Pruebas de Métodos POST, PUT y DELETE en JavaScript Asíncrono

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

Resumen

¿Cómo probar métodos POST para URLs de PDF?

Al explorar el mundo del testing de métodos POST, es fundamental considerar los diferentes caminos que puede tomar nuestro código, como cuando manejamos URLs de tipo PDF. Cuando validamos URLs en nuestros metadatos, es esencial estar preparados para manejar distintos formatos y tipos de contenido. En este contexto, la prueba se enfoca especialmente en aquellas URLs que terminan en .pdf o corresponden a imágenes. El objetivo es garantizar que, aún en estos casos, nuestro código responde correctamente.

¿Cómo configurar un set de pruebas para URLs PDF?

Para empezar, es necesario crear un nuevo set de pruebas que cubra estos casos particulares. Recuerda que las pruebas serán asíncronas, y por lo tanto, requerirás del parámetro DOM. Aquí te mostramos cómo puedes organizar tu proceso:

Crear un espía para el método CREATE:
- Utiliza un espía para el método CREATE al igual que con los pines.
- Implementa un FAKE que devuelva una estructura sin errores, simulando un objeto de respuesta.
Configurar Axios para las solicitudes:
- Usa Axios, que trabaja con promesas, para manejar estas solicitudes.
- Asegúrate de que la URL a probar sea la que corresponde a un PDF, por ejemplo, usando un documento PDF de Platzi para la prueba.
- Verifica que al finalizar la solicitud, el estado devuelto sea 200, lo cual indica que la operación fue exitosa.

¿Cómo evaluar la efectividad de nuestras pruebas?

Revisar el estado y las métricas de tu reporte es parte esencial del proceso. Al ejecutar las pruebas, verifica que:

Las rutas del método POST sean recorridas como esperado con dos validaciones efectivas.
Se haya informado exitosamente a la base de datos en múltiples ocasiones.

Esto ayudará a recalcar que las pruebas son efectivas y se acercan a un estado óptimo.

Pruebas de POST frente a errores y caminos alternos

En este ámbito, no todo se trata de asegurar los caminos felices. Probar casos de error es igualmente esencial. Este ejercicio cumple la función de plantear un reto: ¿cómo preparar tus pruebas para los escenarios donde algo falla?

Explorar errores potenciales: Basándote en las pruebas del método POST, intenta probar casos no exitosos. Utiliza la lógica preexistente para encarar estos desafíos.
Implementar pruebas para métodos PUT y DELETE:
- Estas pruebas seguirán una lógica similar al método POST, pero apuntando específicamente a modificaciones y eliminaciones.
- El objetivo también es examinar cómo maneja tu aplicación cambios y eliminaciones en recursos.

¿Cómo ajustar espías y callbacks en pruebas PUT y DELETE?

Las pruebas de los métodos PUT y DELETE requieren una ajustada consideración de los espías y la implementación del callback:

En el caso de PUT y DELETE, presta atención a los parámetros de los espías.
La lógica difiere del método GET, dado que los dos primeros parámetros son variables y el callback es el tercero.
Asegúrate de ejecutar el callback de manera apropiada para garantizar la efectividad de las pruebas.

Siguiendo estos pasos, estarás cada vez más cerca de robustecer tus habilidades de testing y garantizar un código sólido y libre de errores. Continúa aprendiendo y poniendo a prueba tus conocimientos, y ¡verás cómo cada paso que das te acerca más a convertirte en un experto en pruebas de software!

Edgar Moises Valdez Faria

student•

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.

Ángel Alberto Rivas Álvarez

student•

Si siento que fue un overkill hacer un backend con esa clase de métodos, pero lo cierto es que si estás aprendiendo unit testing no eres necesariamente nuevo en desarrollo (por lo mismo está al final de la ruta). Si yo mismo hace un año quisiera hacer este curso saldría frustrado desde la 5ta clase... (pasó). Pero cuando ya tienes algo de experiencia desarrollando, no pasas más de unos minutos leyendo los archivos del backend para tener una muy buena idea de que está haciendo y como lo está haciendo. -- Personalmente te recomiendo que si todo el JS del backend te parece algo muy muy confuso, hagas primero los cursos de JS, al menos un par de ellos.

Bryan Condor

student•

**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();
            });

        });

    });

})

Damian Spizzirri

student•

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();
        });
    });

Wilson Alejandro Gonzalez Gaitan

student•

Que error sale

MAX CRISTOBAL borjas castillo

student•

yo lo hice de esta manera y salio

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

            spyOn(requestPromise, "get").and.returnValue(        
               
            );

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

        })

Byron Mesias Cueva Cabrera

student•

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

Juan Jose Vega

student•

Muy pro Comparte el código

Mario Alejandro Cortez Salinas

student•

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

student•

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()
        })
    })```

Byron Mesias Cueva Cabrera

student•

Profe realice las pruebas hasta el 97% ya esta correcto, pero me falta la parte del catch de la promesa getMetadataFromAssets, no se como implementar las pruebas para esa parte del código. Por favor me podría ayudar. Gracias

Carlos Alejandro Hernández Mejía

student•

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();
            });
        });
    });```