Pruebas para POST

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

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

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

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

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?

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