Bienvenida e Introducción

1

¿Qué son las pruebas unitarias?

2

¿Por qué hacer pruebas unitarias?

Creando un framework de pruebas básico

3

Mi primera prueba unitaria en JavaScript

4

Las funciones expect() y it()

5

Organizando el código para correr en la web

6

Organizando el código para correr utilizando nodejs

Análisis estático de código

7

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

8

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

9

Herramientas de corrección de estilo

10

Herramientas de tipado

Trabajando con Jasmine en el frontend

11

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

12

Configurar un ambiente de trabajo para trabajar con el framework jasmine

13

Configurar Jasmine utilizando Node.js

14

Primer set de pruebas con Jasmine

15

Diccionario Jasmine

Probando Nodejs apps con Jasmine

16

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

17

Configurando el proyecto Jasmine utilizando npm

18

Agregando Plugins a Jasmine

19

Configurando nuestro reporter

20

Pruebas en el servidor: Verificando un status 200 en GET

21

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

22

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

23

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

Probando Angular apps con Jasmine

24

Tipos de pruebas

25

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

26

Configurando los ciclos de vida

27

Creando las pruebas del formulario: Configuración

28

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

29

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

30

Trabajando con event emitters

31

Testeando ngZone y navegación.

32

Configurando el TestBed de el componente PINs

33

Creando un espia sobre el objecto window

Pruebas de integración de Angular apps con Jasmine

34

Ejecutando funciones a través de eventos en el template

35

Probando la navegación

36

Probando servicios con HTTP

37

Completando las pruebas del servicio HTTP

38

Cierre del curso

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

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 en el servidor: Probando el método GET y Reto con FindByID

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? Crea una cuenta o inicia sesión.

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