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

Curso de Unit Testing para MEAN con Jasmine

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

Pruebas del Método PAUSE en Desarrollo Web

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

Probando Angular apps con Jasmine

Pruebas Unitarias e Integración en Angular con Jasmine

Pruebas Unitarias de Componentes en Angular con Jasmine

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

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

Pruebas Unitarias en Formularios Reactivos con Angular

Pruebas Unitarias Avanzadas en Formularios Reactivos de Angular

Pruebas Unitarias en Angular: Navegación y Outputs HTML

Pruebas Unitarias en Angular: Testeo de Componentes y Servicios

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

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

Pruebas de integración de Angular apps con Jasmine

Pruebas de integración con Jasmine y Angular

Pruebas de Navegación con Angular y RouterTestingModule

Pruebas HTTP en Angular con HTTP Client Testing Module

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

Buenas prácticas de Unit Testing con Jasmine

No tienes acceso a esta clase

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

Si ya tienes una cuenta,

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?

Jaime Quintero Rodríguez

hace 6 años

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

David Behar

hace 5 años

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

mauxiandrade

hace 6 años

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.

Germán Arevalo Jerez

hace 3 años

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

Juan Carlos Huerta Barzola

hace 3 años

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

Damian Spizzirri

hace 6 años

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

Andrés Muñoz

hace 6 años

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

David Behar

hace 5 años

De dónde viene este callback?

Qué está llamando?

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

Vladyslav Kuchmenko

hace 5 años

<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>

Jose Luis Campos Bautista

hace 5 años

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

Carlos Alejandro Hernández Mejía

hace 5 años

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

Cesar Elías Armendariz Ruano

hace 4 años

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