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 HTTP en Angular con HTTP Client Testing Module

36/38
Recursos

¿Cómo utilizar servicios en Angular para realizar peticiones HTTP?

Angular facilita la conexión con servidores a través del uso de servicios HTTP, una herramienta esencial para el desarrollo moderno de aplicaciones web. El AppyService es un ejemplo de un servicio que permite estas conexiones mediante métodos HTTP, proporcionando las operaciones comunes: GET, POST, PUT y DELETE. Este enfoque no solo estructura nuestras solicitudes, sino que también mejora la eficiencia de desarrollo.

¿Cómo configurar un entorno de pruebas con Angular?

Para garantizar el correcto funcionamiento de las aplicaciones, es importante configurar un entorno de pruebas robusto. Angular ofrece un módulo de prueba que simula la funcionalidad de HTTP, conocido como HTTPClientTestingModule. La inyección de este módulo permite realizar pruebas sin la necesidad de un servidor real, asegurando así un desarrollo más eficiente y efectivo.

¿Qué pasos seguir para probar un servicio HTTP?

Los pasos esenciales para probar un servicio HTTP en Angular incluyen configurar variables globales y establecer el HTTPClientTestingModule. Aquí te muestro cómo se realiza:

  1. Importación y configuración:

    import { TestBed } from '@angular/core/testing';
    import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
    import { AppyService } from './appy.service';
    
    let service: AppyService;
    let httpMock: HttpTestingController;
    
    beforeEach(() => {
      TestBed.configureTestingModule({
        imports: [HttpClientTestingModule],
        providers: [AppyService]
      });
    
      service = TestBed.inject(AppyService);
      httpMock = TestBed.inject(HttpTestingController);
    });
    
  2. Crear una prueba unitario para GET:

    it('should perform GET request', () => {
      const expectedData = { /* datos esperados */ };
      const testURL = '/api/test';
    
      service.getData(testURL).subscribe(result => {
        expect(result).toEqual(expectedData);
      });
    
      const req = httpMock.expectOne(testURL);
      expect(req.request.method).toBe('GET');
      req.flush(expectedData);
    });
    
  3. Limpieza de entorno: Asegúrate de limpiar las referencias al finalizar cada prueba para evitar problemas de memoria:

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

¿Cómo funcionan los controladores de pruebas?

El HttpTestingController es crucial para validar que se realicen las solicitudes HTTP necesarias. Proporciona el método expectOne para verificar las solicitudes y el método flush para simular una respuesta del servidor.

¿Cómo se abordan las peticiones sin headers?

Al construir una prueba para una petición GET sin headers, es esencial definir claramente el punto de prueba y verificar que el método ejecutado es el esperado. En un contexto donde los headers no son relevantes:

it('should execute GET request without headers', () => {
  const resultData = { key: 'value' };

  service.getData('/path/test').subscribe(response => {
    expect(response).toEqual(resultData);
  });

  const req = httpMock.expectOne((request) => request.method === 'GET');
  expect(req.request.method).toBe('GET');
  req.flush(resultData);
});

Este enfoque garantiza pruebas HTTP efectivas, confirmando que las solicitudes se hagan y respondan correctamente.

Al conocer y aplicar estos principios, los desarrolladores están bien equipados para llevar a cabo pruebas exhaustivas en aplicaciones Angular, asegurando que la funcionalidad deseada se entregue con alta calidad y eficiencia. El camino del aprendizaje continúa, y siguientes sesiones abordarán las pruebas de POST y el manejo de headers, profundizando en la robustez del proceso de testing. Mantente motivado y sigue explorando este fascinante mundo del desarrollo web.

Aportes 5

Preguntas 0

Ordenar por:

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

En general no se le entiende al profesor, únicamente cuenta lo que hace, pero no explica en profundidad porque en una prueba se utiliza esto o aquello, simplemente dice “aquí usaremos esto, por aquí lo necesitamos”, pero por qué? Le falta más explicación en detalle. Escribiendo el código por mi cuenta se aprende algo, pero quedo con un mal sabor de boca al ser tan superficial la explicación.

No entendi el final, para que sirve el req.flush??

Me marca error en httpMock.expectOne . Aguien que me ayude.

import { TestBed, getTestBed } from '@angular/core/testing';
import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
import { ApiService } from './api.service';
import { Server } from 'http';
import { environment } from 'src/environments/environment';

fdescribe('ApiService', () => {
  let service: ApiService;
  let injector: TestBed;
  let httpMock: HttpClientTestingModule;

  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [ApiService],
      imports: [HttpClientTestingModule],
    });
  });

  beforeEach(() => {
    injector= getTestBed();
    service = TestBed.get(ApiService);
    httpMock = injector.get(HttpTestingController);
  });

  afterAll( () => {
    injector = null;
    service = null;
    httpMock = null;
  })
  it('Should be created', () =>{
    expect(service).toBeTruthy();
  })

  describe('GET', () => {
    it('Should execute GET', () => {
      const result = 'testing';
      service.get('/test').subscribe( response => {
        expect(response).toBe(result);
      })

      const req = httpMock.expectOne(environment.apiEndpoint + '/test');
      console.log(req)
      expect(req.request.method).toBe('GET')
      req.flush(result)
      
    })
  })

});

https://angular.io/api/common/http/testing/HttpTestingController

En que parte del codigo le estoy diciendo que si la ruta es /test me tiene que retornar “testing”, no entendi eso.

  service.get('/test').subscribe(response => {
    console.log(response);
    expect(response).toBe(result);
  });

Para profundizar les recomiendo revisar la documentación de Angular sobre Testing Http Requests.