Pruebas para POST

Clase 18 de 25 • Curso de Angular: Unit Testing para Servicios

Miguel Angel Coy Triana

student•

Reto

  describe('Test for update product', () => {
    it('#update, should update a product', (doneFn) => {
      // Arrange
      const mockData = generateOneProduct();
      const productId = '1';
      const dto: UpdateProductDTO = {
        title: 'Product edited',
        price: 1000,
        images: ['img'],
        description: 'This is a product edited',
        categoryId: 12,
      };
      // Act
      service.update(productId, { ...dto }).subscribe((data) => {
        // Assert
        expect(data).toEqual(mockData);
        doneFn();
      });
      // Http Config
      const url = `${environment.API_URL}/api/v1/products/${productId}`;
      const req = httpController.expectOne(`${url}`);
      req.flush(mockData);
      expect(req.request.body).toEqual(dto);
      expect(req.request.method).toEqual('PUT');
    });
  });

  describe('Test for delete product', () => {
    it('#Delete, should delete a product', (doneFn) => {
      // Arrange
      const productId = '1';
      // Act
      service.delete(productId).subscribe((data) => {
        // Assert
        expect(data).toBe(true);
        doneFn();
      });
      // Http Config
      const url = `${environment.API_URL}/api/v1/products/${productId}`;
      const req = httpController.expectOne(`${url}`);
      req.flush(true);
      expect(req.request.method).toEqual('DELETE');
    });
  });

Juan Luna

student•

Sugerencia

Que bueno sería poder chatear con el profe en un horario x, presolicitando una entrada en el chat para cuestiones varias, dudas preguntas, sobre el tema que él proponga, ...

Los cursos online de todas las plataformas mundiales no tienen ese acercamiento del profe hacia sus alumnos, hacemos preguntas y son o no contestadas en un tiempo X, si a alguna de estas plataformas se le courriera hacer esto, sería un producto diferenciador del resto, ahí lo dejo, ...

Cesar Elías Armendariz Ruano

student•

Ahora veremos pruebas en post, put y delete.

product.service.spec.ts

afterEach(() => {
    httpController.verify();
  });
  
 describe('test for create', () => {
      it('should return a new product', (doneFn) => {
        // Arrange
        const mockData = generateOneProduct();
        const dto: CreateProductDTO = {
          title: 'new Product',
          price: 100,
          images: ['img'],
          description: 'bla bla bla',
          categoryId: 12,
        };
        // Act
        productsService.create({...dto}).subscribe((data) => {
          // Assert
          expect(data).toEqual(mockData);
          doneFn();
        });
        //http config
        const url = `${environment.API_URL}/api/v1/products`;
        const req = httpController.expectOne(url);
        req.flush(mockData);
        expect(req.request.body).toEqual(dto);
        expect(req.request.method).toEqual('POST');
      });
  });

    describe('test for update', () => {
      it('should return an updated product', (doneFn) => {
        // Arrange
        const mockData = generateOneProduct();
        const id = '1';
        const dto: UpdateProductDTO = {
          title: 'update Product',
          price: 200,
          images: ['img'],
          description: 'bla bla bla bla',
          categoryId: 12,
        };
        // Act
        productsService.update(id, {...dto}).subscribe((data) => {
          // Assert
          expect(data).toEqual(mockData);
          doneFn();
        });
        //http config
        const url = `${environment.API_URL}/api/v1/products/${id}`;
        const req = httpController.expectOne(url);
        req.flush(mockData);
        expect(req.request.body).toEqual(dto);
        expect(req.request.method).toEqual('PUT');
      });
  });

    describe('test for delete', () => {
      it('should delete a product', (doneFn) => {
        // Arrange
        const id = '1';
        // Act
        productsService.delete(id).subscribe((data) => {
          // Assert
          expect(data).toBe(true);
          doneFn();
        });
        //http config
        const url = `${environment.API_URL}/api/v1/products/${id}`;
        const req = httpController.expectOne(url);
        req.flush(true);
        expect(req.request.method).toEqual('DELETE');
      });
  });

Rodrigo de La Barrera

student•

hola a todos y todas, podrían ayudarme a como hacer el expect del request.body pero usando el createSpyObj de Jasmine ?

Juan Luna

student•

Buenas a todos (ahí están incluidos todos, todas, todes, tod@s, es redundante decir buenas a todos y todas lo define la propia Real Academia de la Lengua).. dicho esto

Refrente al afterEach(): ¿ejecutar este método después de cada prueba it(), no dará problemas precisamente en la primera prueba que está debajo del afterEach(), la del 'should be create' ?

puesto que ahí no estamos haciendo uso del httpController

  afterEach(()=>{
    httpController.verify();
  });

  it('should be create', () => {
    expect(productsService).toBeTruthy();
  });

Ruben Ariel Villalobos

student•

Mas que una prueba unitaria no seria una prueba de integracion?

Andres Gallardo

student•

Hay alguna forma de evitar colocar en cada IT la configuracion del http?

Andres Felipe Pinto Becerra

student•

Una consulta para todos, parece que el beforesEach y afterEach se pueden usar también dentro de los describe anidados, es decir, dentro de un describe general tengo mas describes y uso esos métodos de antes y después. ¿Es buena práctica si es necesario usar los métodos beforesEach y afterEach dentro de cada describe anidado?

Kengya Moncada

student•

Top, Top ! ♥

Jorge Luis Silva Medina

student•

Reto

  describe('test for update', () => {
    it('should return a updated product', (doneFn) => {
      // Arange
      const mockData = generateOneProduct();
      const dto: UpdateProductDTO = {
        //id: '1',
        title: 'product title',
        price: 100,
        images: ['img', 'img'],
        description: 'desc',
        categoryId: 1,
      };
      const productId = '1';
      // Act
      service.update(productId, { ...dto }).subscribe((data) => {
        // Assert
        expect(data).toEqual(mockData);

        doneFn();
      });

      // http config
      const url = `${environment.API_URL}/api/v1/products/${productId}`;
      const req = httpController.expectOne(url);
      req.flush(mockData);
      expect(req.request.body).toEqual(dto);
      expect(req.request.method).toEqual('PUT');
    });
  });

  describe('test for delete', () => {
    it('should return boolean', (doneFn) => {
      // Arange
      const productId = '2';
      // Act
      service.delete(productId).subscribe((data) => {
        // Assert
        expect(data).toBeTruthy();
        doneFn();
      });

      // http config
      const url = `${environment.API_URL}/api/v1/products/${productId}`;
      const req = httpController.expectOne(url);
      req.flush(true);
      expect(req.request.method).toEqual('DELETE');
    });
  });

Juan Luna

student•

No se si esa lógica de los parámetros es totalmente correcta, pero después de hacer tests para casos como limit=0, y viendo que te devuelve todos los productos sin offset,

probarlo

llegué a la conclusión que los if que tenemos hasta ahora no limitan demasiado, por tanto creo que debería de ser en vez de esta forma:

if (limit && offset != null) {
        params = params.set('limit', limit);
        params = params.set('offset', offset);
    }

de esta otra:

if (limit != null && offset != null) {
      if(limit > 0){
        params = params.set('limit', limit);
        params = params.set('offset', offset);
      }
    }

¿Estáis de acuerdo?

David Mijael Sánchez Quispe

student•

Reto cumplido!

describe('test for update', () => {
    it('should return a update product', (doneFn) => {
      const returnProduct = generateOneProduct();
      const id = 'product-1';
      const dto: UpdateProductDTO = {
        title: 'update product',
        price: 500,
      };

      productsService.update(id, { ...dto }).subscribe((data) => {
        expect(data).toEqual(returnProduct);
        doneFn();
      });

      const req = httpController.expectOne(`${apiUrl}/products/${id}`);
      req.flush(returnProduct);
      expect(req.request.body).toEqual(dto);
      expect(req.request.url).toContain(id);
      expect(req.request.method).toEqual('PUT');
    });
  });

  describe('test for delete', () => {
    it('should return a delete product', (doneFn) => {
      const response = true;
      const id = 'product-1';

      productsService.delete(id).subscribe((data) => {
        expect(data).toEqual(response);
        doneFn();
      });

      const req = httpController.expectOne(`${apiUrl}/products/${id}`);
      req.flush(response);
      expect(req.request.url).toContain(id);
      expect(req.request.method).toEqual('DELETE');
    });
  });

Pruebas para POST

Introducción

Unit testing para servicios en Angular

Jest vs. Jasmine: entornos de testing para Angular

Fundamentos de unit testing en Angular

Tu primera prueba en Angular

Explorando matchers

Reporte de coverage

Mocha Report

Testing en servicios

Pruebas unitarias para servicios

Servicios con dependencias

Spies

Angular TestBed

TestBed + Spies

Proyecto

Setup y maquetación del proyecto

Product Service Http

Testing en consultas HTTP

HttpClientTestingModule

Generando Mocks

Pruebas para GET

Pruebas maliciosas para GET

Pruebas para POST

Pruebas para PUT y DELETE

Bonus

Pruebas a errores

Pruebas con interceptores

Pruebas al login

Pruebas a la API del navegador

GitHub Actions

Próximos pasos

Toma el Curso de Angular: Unit Testing para Componentes