Bienvenida e Introducción

1

Pruebas unitarias con Jasmine para JavaScript

2

Pruebas Unitarias: Mejora y Seguridad en Desarrollo de Software

Creando un framework de pruebas básico

3

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

4

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

5

Refactorización de Pruebas JavaScript con Framework Personalizado

6

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

Análisis estático de código

7

Herramientas para Mejorar la Calidad del Código en JavaScript

8

Configuración de ESLint en VS Code paso a paso

9

Configuración de Prettier en Proyectos JavaScript

10

Tipado Estricto en TypeScript para Aplicaciones Angular

Trabajando con Jasmine en el frontend

11

Pruebas Unitarias con Jasmine: Uso de spyOn para Simular Funciones

12

Configuración de Jasmine para Pruebas de Frontend

13

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

14

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

15

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

Probando Nodejs apps con Jasmine

16

Pruebas Unitarias con Jasmine en Node.js y Angular

17

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

18

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

19

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

20

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

21

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

22

Pruebas del Método PAUSE en Desarrollo Web

23

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

Probando Angular apps con Jasmine

24

Pruebas Unitarias e Integración en Angular con Jasmine

25

Pruebas Unitarias de Componentes en Angular con Jasmine

26

Pruebas Unitarias en Angular: Rutas y Ciclos de Vida con Jasmine

27

Pruebas Unitarias en Angular: Simulación de Servicios y Componentes

28

Pruebas Unitarias en Formularios Reactivos con Angular

29

Pruebas Unitarias Avanzadas en Formularios Reactivos de Angular

30

Pruebas Unitarias en Angular: Navegación y Outputs HTML

31

Pruebas Unitarias en Angular: Testeo de Componentes y Servicios

32

Pruebas Unitarias en Jasmine: Espías y Stubs en Angular

33

Pruebas de Espionaje en Objetos Globales y Métodos en JavaScript

Pruebas de integración de Angular apps con Jasmine

34

Pruebas de integración con Jasmine y Angular

35

Pruebas de Navegación con Angular y RouterTestingModule

36

Pruebas HTTP en Angular con HTTP Client Testing Module

37

Pruebas Unitarias: Cobertura Completa de Métodos HTTP en API

38

Buenas prácticas de Unit Testing con Jasmine

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Unit Testing para MEAN con Jasmine

Curso de Unit Testing para MEAN con Jasmine

Cristian Daniel Marquez Barrios

Cristian Daniel Marquez Barrios

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

21/38
Recursos

En la clase anterior probamos el código 200, lo que significa que todo está bien y nuestro servidor responde correctamente. En esta clase vamos a probar que nuestro servidor no funcione, nuestra prueba solo debe pasar si devuelve un error con el código 500, un error del servidor.

El reto de la clase es volver a probar el método get pero, esta vez, recibiendo parámetros. La lógica es casi la misma pero la ruta va a ser diferente y tenemos que cambiar algunos métodos como el find por el findById.

Aportes 12

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Esta es mi solucion.

   // Get 200 FindById
    it("200 and findById pin", done => {
      const data = { id: 1 };
      /* Dentro del Objeto Pins queremos espiar el metodo findById y ejecutamos nuestro propio metodo */
      spyOn(Pins, "findById").and.callFake((id, callBack) => {
        data.param = id;
        callBack(false, data);
      });
  
      request.get("http://localhost:3000/api/21312", (error, response, body) => {
        expect(response.statusCode).toBe(200);
        expect(error).toBe(null);
        expect(JSON.parse(response.body)).toEqual({ id: 1, param: "21312" });
        expect(JSON.parse(response.body).id).toEqual(1);
        expect(JSON.parse(body).param).toEqual("21312");
        done();
      });
    });

    //GET 500 FindById
    it("500", done => {
      const data = [{ id: 1 }];
      /* Dentro del Objeto Pins queremos espiar el metodo find y ejecutamos nuestro propio metodo */
      spyOn(Pins, "findById").and.callFake((id, callBack) => {
        callBack(true, data);
      });

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

Acá la solución del reto

  describe('GET custom pin', () => {
    // GET 200
    const data = [{id: 1}];
    const elementId = '2132';

    it('should response with 200 and Get custom pin', (done) => {
      spyOn(Pins, 'findById').and.callFake((id, callBack) => {
        // callback = function(err, post)
        expect(elementId).toEqual(id);
        callBack(false, data); // error = false
      });
      request.get('http://localhost:3000/api/'+elementId, (error, response, body) => {
        expect(response.statusCode).toBe(200);
        expect(JSON.parse(response.body)).toEqual([{id: 1}]);
        done();
      });
    });


    // GET 500
    it('Should return 500 when error', (done) =>{
      spyOn(Pins, 'findById').and.callFake((id, callBack) => {
        // callback = function(err, post)
        callBack(true, data); // error = true
      });
      request.get('http://localhost:3000/api/'+elementId, (error, response, body) => {
        expect(response.statusCode).toBe(500);
        done();
      });
    });
  });

Yo lo hice de esta forma.

it('200 and find pin by Id', (done) => {
			spyOn(Pins, 'findById').and.callFake((id, callBack) => {
				callBack(false, id);
			});

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


Me encanta el curso por cierto.

// GET
    it("200 single ping by id", (done) => {
      const data = { id: 1 };
      const id = 1;
      spyOn(Pins, "findById").and.callFake((id, callback) => {
        callback(false, data);
      });
      request.get(
        `http://localhost:3000/api/${id}`,
        (error, response, body) => {
          expect(response.statusCode).toBe(200);
          expect(JSON.parse(response.body)).toEqual({ id: 1 });
          done();
        }
      );
    });

    // GET 500
    it("500", (done) => {
      const data = { id: 1 };
      const id = 1;
      spyOn(Pins, "findById").and.callFake((id, callback) => {
        callback(true, data);
      });
      request.get(
        `http://localhost:3000/api/${id}`,
        (error, response, body) => {
          expect(response.statusCode).toBe(500);
          done();
        }
      );
    });
it('200 and find by id', done => {
      const id = 1
      spyOn(Pins, 'findById').and.callFake((id, callBack) => {
        callBack(false)
      })

      request.get(`http://localhost:3000/api/${id}`, (error, response) => {
        expect(response.statusCode).toBe(200);
        expect(id).toEqual(1)
        done()
      })
    })

Como hago para validar el parametro que me llega por la url??

describe("GET SINGLE PIN BY ID", () => {
    // GET 200
    it("should return 200 and find pin by id", done => {
      const data = [{ _id: 1 }];
      spyOn(pinsModel, "findById").and.callFake((id, callback) => {
        callback(false, data);
      });
      request.get("http://localhost:3000/api/pin_id", (error, res, body) => {
        expect(pinsModel.findById).toHaveBeenCalledWith('pin_id', jasmine.any(Function))
        expect(res.statusCode).toBe(200);
        expect(JSON.parse(res.body)).toEqual([{ _id: 1 }]);
        done();
      });
    });

    // GET 500
    it("should return 500", done => {
      spyOn(pinsModel, "findById").and.callFake((id, callback) => {
        callback(true, null);
      });
      request.get("http://localhost:3000/api/pin_id", (error, res, body) => {
        expect(res.statusCode).toBe(500);
        done();
      });
    });
  });```

De dónde viene este callback?

Qué está llamando?

      spyOn(Pins, 'find').and.callFake((callBack) => {
        callBack(true, data);
      });
<code>
it("200 and pinById", (done) => {
    const data = [{ id: 1 }];
    const id = 1;

    spyOn(Pins, "findById").and.callFake((id, callBack) => {
      callBack(undefined, data);
    });

    request.get("http://localhost:3000/api/1", (error, response, body) => {
      expect(response.statusCode).toBe(200);
      expect(JSON.parse(body)).toEqual([{ id: 1 }]);
      done();
    });
  });
</code>
it('200 get by ID', (done) => {
      const idTest = '232'
      const data = {id: idTest}

      spyOn(Pins, 'findById').and.callFake((id, callBack) => {
        callBack(false, data)
      })

      request.get(`http://localhost:3000/api/${idTest}`, (error, response, body) => {
        expect(response.statusCode).toBe(200)        
        expect(JSON.parse(response.body)).toEqual(data)
        expect(JSON.parse(response.body).id).toEqual(idTest)
        done()
      })
    })

Aquí mi solución

it('should get the pin with the id indicated', (done) => {
                const pin = {id: 22};
                spyOn(Pins, 'findById').and.callFake((id, callBack) => {
                    callBack(false, pin);
                });
                request.get(`${apiUrl}/${pin.id}`, (error, response, body) => {
                    const bodyResponse = JSON.parse(response.body);
                    expect(error).toBeNull();
                    expect(response.statusCode).toBe(200);
                    expect(bodyResponse).toEqual(pin);
                    done();
                })
            });
            it('should get an error - get a pin', (done) => {
                const pin = {id: 22};
                spyOn(Pins, 'findById').and.callFake((id, callBack) => {
                    callBack(true, null);
                });
                request.get(`${apiUrl}/${pin.id}`, (error, response, body) => {
                    expect(response.statusCode).toBe(500);
                    done();
                });
            });
```

Aunque la verdad no se si realmente este bien
// GET BY ID
it(“200 and find pin”, (done) => {
const data = [{ id: 1234 }];
spyOn(Pins, “findById”).and.callFake((id, callBack) => {
callBack(false, data);
});

  request.get("https://localhost:3000/api/1234", (error, response, body) => {
    expect(response.statusCode).toBe(200);
    expect(JSON.parse(response.id)).toEqual([{ id: 1234 }]);
    done();
  });
});