Pruebas unitarias para servicios

Observable

describe('Test for getObservableValue', () => {
    it('should return "my value"', (doneFn) => {
      service.getObservableValue().subscribe((value) => {
        expect(value).toBe('my value');
        doneFn();
      });
    })
  })

  describe('Test for getObservableValue Sync', () => {
    it('should return "my value"', async () => {
      const value = await firstValueFrom(service.getObservableValue());
      expect(value).toBe('my value');
    })
  })

async() quedo deprecado en angular 13, ahora debemos usar waitForAsync() que hace lo mismo.

primero creamos nuestro servicio

ng g s services/value

posteriormente ingresamos parametros y funcionalidades al servicio

value.service.ts

import { Injectable } from '@angular/core';
import { of } from 'rxjs';

@Injectable({
  providedIn: 'root'
})

export class ValueService {

	private value = 'my value';

  constructor() { }

  getValue() {
    return this.value;
  }

  setValue (value: string) {
    this.value = value;
  }

  getPromiseValue() {
    return Promise.resolve('value');
  }

  getObservableValue() {
    return of('observable value');
  }
}

configuramos nuestro set de pruebas para verificar funcionalidad el servicio con FOCUS en el.

value.service.spec.ts

import { ValueService } from './value.service';

fdescribe('ValueService', () => {
  let service: ValueService;
  
  beforeEach(() => {
    service = new ValueService();
  });

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

  describe('Test for getValue', () => {
    // AAA
    it('Should return "my value"', () => {
      expect(service.getValue()).toBe('my value');
    });
  });

  describe('Test for setValue', () => {
    // AAA
    it('Should change the value', () => {
      expect(service.getValue()).toBe('my value');
      service.setValue('change');
      expect(service.getValue()).toBe('change');
    });
  });

  describe('Test for getPromiseValue', () => {
    // AAA
    it('Should return "promise value" from promise', (doneFn) => {
      service.getPromiseValue()
      .then((value) => {
        // assert
        expect(value).toBe('promise value');
        doneFn();
      });
    });

    it('Should return "promise value" from promise using async', async() => {
     const rta = await service.getPromiseValue();
     expect(rta).toBe('promise value');
    });
  });
});

finalmente corremos el comando

ng test

para verificar fallas dentro del servicio

Cada escenario de prueba debería manejarse de manera isolated (aislada) de los otros escenarios de prueba

Cada que colocamos un it estamos indicando un escenario de prueba, cada escenario de prueba debería manejarse de manera insolada. Esto significa que una prueba no debería afectar a la siguiente o a otra prueba.

Lo que hacemos es crear las instancias que ocupamos para cada prueba, por ejemplo la creación del servicio. Para optimizar el codigo se usa la funcion beforeEach que va a ejecutarse antes de cada prueba.

Reto:

import { waitForAsync } from '@angular/core/testing';

  describe('Tests for getObservableValue', () => {
    //AAA
    it('should return "observable value" from a promise', waitForAsync(() => {
      service.getObservable().subscribe(
        {
          next: (v) => expect(v).toBe('obsevable value')
        }
      )
    }))
  });

para menjar la actividad del observable yo utilice “lastValueFrom” de rxjs, lo cual no se si es valido pero aqui lo dejo

describe('Test for Observable', () => {
		it('should return "observable test" from observable', async () => {
			const response = await lastValueFrom(service.getObservableValue());
			expect(response).toBe('observable test');
		});
	});

Algo interesante, que confirmo con este curso es que no hay forma de testear clases u objetos privados