Sitemap

Angular Unit Testing

13 min readMar 16, 2020

Las pruebas unitarias nos permiten tomar todo el proyecto en que estemos trabajando tomar esos bloques de código y descomponerlo en pequeñas partes que vamos a ir probando. De esta manera podemos ir certificando que está funcionando correctamente y que no. Angular nos proporciona 2 herramientas fuertes para realizar nuestras pruebas, Karma y Jasmine.

Jasmine, es un framework de Desarrollo Dirigido por Comportamientos (Behavior Driven Development) para realizar pruebas unitarias (Unit Testing) de código JavaScript. Cada día es más necesario hacer pruebas de nuestro código, para asegurar su estabilidad y hacerlo escalable. Actualmente existen muchas librerías y frameworks en diferentes lenguajes de programación que nos ayudan a lograrlo. Con Jasmine podemos hacer fácilmente nuestras pruebas, con una sintaxis idiomática inspirada en ScrewUnit, JSSpec, JSpec y RSpec (Ruby).

Las funciones principales de Jasmine para hacer pruebas son:

  • describe(a, b) donde “a” es la descripción de nuestra suite y “b” la función anónima donde se incluirá toda la suite o serie de especificaciones. (se le puede anteponer “f” para solo ejecutar ese pull de pruebas ó “x” para deshabilitarlo)
  • it(a, b) donde “a” es la descripción de la especificación y “b” la función anónima donde se incluirán las expectativas (expectations) que debe cumplir la aplicación. (también podemos usar fit, el cual nos sirve para solo correr esta prueba de un caso de pruebas, es decir si colocamos fit karma solo hace foco en esa prueba, también podemos usar xit que es lo contrario lo usamos para deshabilitar dicha prueba, importante cuando tenemos un proyecto grande y solo queremos realizar unas pruebas en específico)
  • expect(a) donde “a” es un valor que será probado, mediante argumentos en cadena (method chaining). Por ejemplo: expect(true).not.toBe(false).
  • beforeAll(a) donde “a” será la función que se ejecutará antes de iniciar las pruebas.
  • afterAll(a) donde “a” será la función que se ejecutará después de iniciar las pruebas.
  • beforeEach(a) donde “a” será la función que se ejecutará antes de cada prueba.
  • afterEach(a) donde “a” será la función que se ejecutará después de cada prueba.

Jasmine también usa los llamados matchers ó comparadores comunes que nos permiten realizar comparaciones para determinar si nuestras pruebas son correctas o no. Algunos matchers son;

expect(array).toContain(member);

expect(fn).toThrow(string);

expect(fn).toThrowError(string);

expect(instance).toBe(instance);

expect(mixed).toBeDefined();

expect(mixed).toBeFalsy();

expect(mixed).toBeNull();

expect(mixed).toBeTruthy();

expect(mixed).toBeUndefined();

expect(mixed).toEqual(mixed);

expect(mixed).toMatch(pattern);

expect(number).toBeCloseTo(number, decimalPlaces);

expect(number).toBeGreaterThan(number);

expect(number).toBeLessThan(number);

expect(number).toBeNaN();

expect(spy).toHaveBeenCalled();

expect(spy).toHaveBeenCalledTimes(number);

expect(spy).toHaveBeenCalledWith(…arguments);

Más adelante colocare unos ejemplos al respecto.

Karma, es sobre el cual corren las pruebas de jasmine, karma nos permite correr las pruebas sin necesidad de tener que refrescar nuestro navegador, si surge algún cambio en nuestros archivos de pruebas automáticamente karma ejecutara nuevamente nuestras pruebas.

Press enter or click to view image in full size

En esta prueba primero usamos el describe para definir este caso de pruebas, luego usamos la función beforeEach la cual se ejecuta antes de cada it y inicializamos la variable expected, ejecutamos la prueba y utilizamos el matcher toEqual para determinar si la función helloWorld que debería estar en nuestro .ts contiene el valor indicado.

Para correr nuestras pruebas debemos usar “ng test”.

Vamos a ver varios ejemplos de como usar los matchers ó comparadores comunes. (Estos ejemplos son en Jest, la única diferencia es que nosotros en vez de usar test debemos usar it)

Pruebas con strings.

Pruebas con números.

Prueba con cálculos.

Press enter or click to view image in full size

Matcher equal.

Pruebar con arrays.

Press enter or click to view image in full size

Pruebas de falso, verdadero y undefined.

Ya que tenemos una idea de cómo es el funcionamiento, vamos a proceder a realizar pruebas directamente desde angular. Como nota importante antes de realizar pruebas a un componente debemos importar todos los servicios ó modulos que este utiliza ya que de lo contrario las pruebas nos darán error. A continuación un ejemplo de un componente con todas de las declaraciones e importaciones que necesita.

Press enter or click to view image in full size

Vamos a realizar nuestras pruebas.

  1. Primero vamos a realizar una prueba a una clase.
Press enter or click to view image in full size
Press enter or click to view image in full size

En este caso estamos importando la clase de AuthService para realizar prueba si el usuario esta autenticado o no. Antes de cada prueba inicializamos y borramos el servicio. Para la primera prueba creamos el token en el localstorage pero ya antes de arrancar la segunda removemos el token y para segunda prueba no estará autenticado por lo que resultara exitosa también la prueba.

  1. Pruebas con Spies and Mocks. Podemos realizar pruebas con clases reales o simplmente podemos usar spies ó mocks. Primero vamos a realziar pruebas con un componente y servicio real.
Press enter or click to view image in full size
Press enter or click to view image in full size
Press enter or click to view image in full size

Con la data real, igual que en la prueba anterior, en el before y after estamos inicializando y borrando el token del localstorage para satisfacer cada prueba.

Ahora también podemos realizar las mismas pruebas pero usando mocks o clases falsas.

Press enter or click to view image in full size
Press enter or click to view image in full size

El resultado es exactamente el mismo, podemos basarnos en este tipo de pruebas para no usar nuestros servicios reales.

Tambien podemos realizar pruebas con nuestras clases reales pero usando Spy. Con los spy nosotros simulamos lo que queremos que devuelva nuestro servicio sin necesidad de usarlo.

Press enter or click to view image in full size
Press enter or click to view image in full size

Ahora vamos a usar Angular TestBed, que nos permite realizar pruebas de una manera más sencilla ya que nos permite detectar el comportamiento de nuestro componente o servicios.

Press enter or click to view image in full size
Press enter or click to view image in full size

Si observan con TestBed nos podemos traer una instancia de los servicios que usa nuestro componente a diferencias de nuestra prueba anterior que teníamos que inicializar nuestro servicio en el before y luego en el after borrarlo, aca con el testbed no hay problema porque lo inicializa de una vez.

Ahora vamos a realizar pruebas con Change Detection, esta herramienta la usamos para cuando queremos detectar cambios en nuestro html, cada vez que hagamos un cambio en el html por algún cambio de texto debemos usar esta opción para que tome el cambio y asi verificar si este cambio es el correcto según nuestra prueba.

Buenos vamos a suponer que tenemos nuestro componente login.

Press enter or click to view image in full size

Si observamos en nuestro html, si el usuario necesita login sale Login dentro del elemento a ahora si no dice logout.

Press enter or click to view image in full size
Press enter or click to view image in full size
  1. Debemos importar nuevas clases que nos ayuden a interartuar con las vistas de nuestros componentes. DebugElement and By.
  2. Ahora tenemos una nueva variable “el” que la vamos a utilizar para obtener los componentes de nuestra vista.
  3. En la variable “el” hacemos referencia al DOM element que seleccionemos.

En nuestra primera prueba aunque por defecto la vista debería mostrar “Login” en nuestro a elemento, no es el caso en las pruebas ya que en nuestras pruebas todo carga vacio la primera vez, debemos ejecutar el ChangeDetention para que nos muestra el ultimo cambio.

Press enter or click to view image in full size

Ahora si ejecutamos detectChanges(), allí si va a actualizar nuestra vista. (Es como si se necesitara ejecutar el detectChanges() cada que se hag un cambio para verlo si no no lo veremos asi cambiamos los valores de las variables)

Press enter or click to view image in full size

Ejemplo el siguiente caso.

Press enter or click to view image in full size

En este caso ambas pruebas serán verdaderas pero no debería ser asi, ya que la ultima prueba debería tirar logout pero como no colocamos el detectChanges el sigue tomando el cambio anterior deberíamos hacer lo siguiente.

Press enter or click to view image in full size

En este caso como usamos el detectChanges() el si toma el cambio y debería arrojar el Logout.

Ahora el código completo.

Press enter or click to view image in full size
Press enter or click to view image in full size
Press enter or click to view image in full size

Hacer pruebas con código asíncrono. Vamos a modificar nuestro AuthService.

Press enter or click to view image in full size

Y Nuestro logincomponent.

Press enter or click to view image in full size

Ahora veamos nuestra prueba.

Press enter or click to view image in full size
  1. Hacemos el primer detectChanges para que tome el ultimo cambio y no devuelve ‘’.
  2. Aca esperamos que nos devuelva login el elemento a.
  3. En este paso simulamos que nuestra clase retorna true.
  4. Llamamos nuestro ngoninit para que tome el cambio.
  5. Ejecutamos nuestro segundo detectChanges.
  6. Esperamos que devuelva logout.

Si ejecutamos esta prueba nos va a dar error, debido a que cuando esperamos el “isAuthenticated” la función aun no ha resulto el valor. Para ello contamos con varias opciones.

Done, Jasmine tiene una manera de manejar es tipo de casos y es con la función done().

Press enter or click to view image in full size
  1. A la prueba le pasamos un método el cual es el done().
  2. Podemos llamar un función usando spy la cual es llamada una vez que la promesa devuelva el valor.
  3. Cuando terminemos con nuestra tarea asíncrona le decimos a jasmine que ya termino usando el done().

Jasmine no provee otra manera de usar llamadas asíncronas y es via async y whenStable.

Press enter or click to view image in full size
  1. Nosotros agregamos otro parámetro en nuestra función de prueba, y es la función async.
  2. Colocamos nuestro prueba una vez llamemos el método isAuthenticated.

Por ultimo podemos usar el fakeasyn y el tick.

Press enter or click to view image in full size
  1. Agregamos a nuestra función de prueba el fakeAsync, y dentro de nuestra prueba una vez llamado el método isAutehticated usamos la función tick() con este la prueba espera a que el método asíncrono devuelva el valor.

Cabe destacar que debemos importar todos estos modulos para que funcione.

Press enter or click to view image in full size

Supongamos que queremos ahora probar un servicio desde un componente, pero no queremos probar el servicio real sino un mockservice, para ello debemos sobreescribir el servicio e indicarle que cuando hagamos referencia al servicio real, en realidad estará llamando al mockservice.

/* tslint:disable:no-unused-variable */

import {TestBed, ComponentFixture, inject} from ‘@angular/core/testing’;

import {LoginComponent} from ‘./login.component’;

import {AuthService} from “./auth.service”;

class MockAuthService extends AuthService {

isAuthenticated() {

return ‘Mocked’;

}

}

describe(‘Component: Login’, () => {

let component: LoginComponent;

let fixture: ComponentFixture<LoginComponent>;

let testBedService: AuthService;

let componentService: AuthService;

beforeEach(() => {

// refine the test module by declaring the test component

TestBed.configureTestingModule({

declarations: [LoginComponent],

providers: [AuthService]

});

// Configure the component with another set of Providers

TestBed.overrideComponent(

LoginComponent,

{set: {providers: [{provide: AuthService, useClass: MockAuthService}]}}

);

// create component and test fixture

fixture = TestBed.createComponent(LoginComponent);

// get test component from the fixture

component = fixture.componentInstance;

// AuthService provided to the TestBed

testBedService = TestBed.get(AuthService);

// AuthService provided by Component, (should return MockAuthService)

componentService = fixture.debugElement.injector.get(AuthService);

});

it(‘Service injected via inject(…) and TestBed.get(…) should be the same instance’,

inject([AuthService], (injectService: AuthService) => {

expect(injectService).toBe(testBedService);

})

);

it(‘Service injected via component should be and instance of MockAuthService’, () => {

expect(componentService instanceof MockAuthService).toBeTruthy();

});

});

Probando Formularios, a continuación un ejemplo de como podemos hacer pruebas con formularios.

Primero el componente login.

import {

Component,

EventEmitter,

Output

} from ‘@angular/core’;

import {

FormGroup,

Validators,

FormBuilder

} from “@angular/forms”;

export class User {

constructor(public email: string,

public password: string) {

}

}

@Component({

selector: ‘app-login’,

template: `

<form (ngSubmit)=”login()”

[formGroup]=”form”>

<label>Email</label>

<input type=”email”

formControlName=”email”>

<label>Password</label>

<input type=”password”

formControlName=”password”>

<button type=”submit”>Login</button>

</form>

`

})

export class LoginComponent {

@Output() loggedIn = new EventEmitter<User>();

form: FormGroup;

constructor(private fb: FormBuilder) {

}

ngOnInit() {

this.form = this.fb.group({

email: [‘’, [

Validators.required,

Validators.pattern(“[^ @]*@[^ @]*”)]],

password: [‘’, [

Validators.required,

Validators.minLength(8)]],

});

}

login() {

console.log(`Login ${this.form.value}`);

if (this.form.valid) {

this.loggedIn.emit(

new User(

this.form.value.email,

this.form.value.password

)

);

}

}

}

Ahora el archivo de pruebas.

/* tslint:disable:no-unused-variable */

import {TestBed, ComponentFixture} from ‘@angular/core/testing’;

import {ReactiveFormsModule, FormsModule} from “@angular/forms”;

import {LoginComponent, User} from “./login.component”;

describe(‘Component: Login’, () => {

let component: LoginComponent;

let fixture: ComponentFixture<LoginComponent>;

beforeEach(() => {

// refine the test module by declaring the test component

TestBed.configureTestingModule({

imports: [ReactiveFormsModule, FormsModule],

declarations: [LoginComponent]

});

// create component and test fixture

fixture = TestBed.createComponent(LoginComponent);

// get test component from the fixture

Get JoséRigobertoPVito’s stories in your inbox

Join Medium for free to get updates from this writer.

component = fixture.componentInstance;

component.ngOnInit();

});

// Aca tenemos una prueba valida ya que al comiendo no es valido porque no hay data

it(‘form invalid when empty’, () => {

expect(component.form.valid).toBeFalsy();

});

//Aca realizamos varias pruebas con respect con el email usando el errors del campo email

it(‘email field validity’, () => {

let errors = {};

let email = component.form.controls[‘email’];

expect(email.valid).toBeFalsy();

// Email field is required

errors = email.errors || {};

expect(errors[‘required’]).toBeTruthy();

// Set email to something

email.setValue(“test”);

errors = email.errors || {};

expect(errors[‘required’]).toBeFalsy();

expect(errors[‘pattern’]).toBeTruthy();

// Set email to something correct

email.setValue(“test@example.com”);

errors = email.errors || {};

expect(errors[‘required’]).toBeFalsy();

expect(errors[‘pattern’]).toBeFalsy();

});

it(‘password field validity’, () => {

let errors = {};

let password = component.form.controls[‘password’];

// Email field is required

errors = password.errors || {};

expect(errors[‘required’]).toBeTruthy();

// Set email to something

password.setValue(“123456”);

errors = password.errors || {};

expect(errors[‘required’]).toBeFalsy();

expect(errors[‘minlength’]).toBeTruthy();

// Set email to something correct

password.setValue(“123456789”);

errors = password.errors || {};

expect(errors[‘required’]).toBeFalsy();

expect(errors[‘minlength’]).toBeFalsy();

});

it(‘submitting a form emits a user’, () => {

expect(component.form.valid).toBeFalsy();

component.form.controls[‘email’].setValue(“test@test.com”);

component.form.controls[‘password’].setValue(“123456789”);

expect(component.form.valid).toBeTruthy();

let user: User;

// Subscribe to the Observable and store the user in a local variable.

component.loggedIn.subscribe((value) => user = value);

// Trigger the login function

component.login();

// Now we can check to make sure the emitted value is correct

expect(user.email).toBe(“test@test.com”);

expect(user.password).toBe(“123456789”);

});

})

;

Realizar pruebas con Http. Vamos a crear un servicio llamado service el cual hará un llamado a una api de itunes.

import {Injectable} from ‘@angular/core’;

import {Jsonp} from ‘@angular/http’;

import ‘rxjs/add/operator/toPromise’;

class SearchItem {

constructor(public name: string,

public artist: string,

public thumbnail: string,

public artistId: string) {

}

}

@Injectable()

export class SearchService {

apiRoot: string = ‘https://itunes.apple.com/search';

results: SearchItem[];

constructor(private jsonp: Jsonp) {

this.results = [];

}

search(term: string) {

return new Promise((resolve, reject) => {

this.results = [];

let apiURL = `${this.apiRoot}?term=${term}&media=music&limit=20&callback=JSONP_CALLBACK`;

this.jsonp.request(apiURL)

.toPromise()

.then(

res => { // Success

this.results = res.json().results.map(item => {

console.log(item);

return new SearchItem(

item.trackName,

item.artistName,

item.artworkUrl60,

item.artistId

);

});

resolve(this.results);

},

msg => { // Error

reject(msg);

}

);

});

}

}

Ahora nuestro archivo de pruebas.

/* tslint:disable:no-unused-variable */

import {

JsonpModule,

Jsonp,

BaseRequestOptions,

Response,

ResponseOptions,

Http

} from “@angular/http”;

import {TestBed, fakeAsync, tick} from ‘@angular/core/testing’;

import {MockBackend} from “@angular/http/testing”;

import {SearchService} from ‘./search.service’;

describe(‘Service: Search’, () => {

let service: SearchService;

let backend: MockBackend;

beforeEach(() => {

TestBed.configureTestingModule({

imports: [JsonpModule],

providers: [

SearchService,

MockBackend,

BaseRequestOptions,

{

provide: Jsonp,

useFactory: (backend, options) => new Jsonp(backend, options),

deps: [MockBackend, BaseRequestOptions]

}

]

});

// Get the MockBackend

backend = TestBed.get(MockBackend);

// Returns a service with the MockBackend so we can test with dummy responses

service = TestBed.get(SearchService);

});

it(‘search should return SearchItems’, fakeAsync(() => {

let response = {

“resultCount”: 1,

“results”: [

{

“artistId”: 78500,

“artistName”: “U2”,

“trackName”: “Beautiful Day”,

“artworkUrl60”: “image.jpg”,

}]

};

// When the request subscribes for results on a connection, return a fake response

backend.connections.subscribe(connection => {

connection.mockRespond(new Response(<ResponseOptions>{

body: JSON.stringify(response)

}));

});

// Perform a request and make sure we get the response we expect

service.search(“U2”);

tick();

expect(service.results.length).toBe(1);

expect(service.results[0].artist).toBe(“U2”);

expect(service.results[0].name).toBe(“Beautiful Day”);

expect(service.results[0].thumbnail).toBe(“image.jpg”);

expect(service.results[0].artistId).toBe(78500);

}));

});

Que tenemos de nuevo en este archivo.

Press enter or click to view image in full size

En esta parte importamos nuevas librerías para realizar pruebas con http, además usamos el servicio MockBackend para simular una respuesta fake de nuestros llamados.

Press enter or click to view image in full size

La imagen anterior muestra cómo hacemos un fake reponse del servicio que estamos haciendo. De esta manera ya cuando hagamos el llamado dentro del mismo it nos retornara es este fake reponse.

Press enter or click to view image in full size

Realizando pruebas con HTTP.

Primero la clase router.

import {Component} from “@angular/core”;

import {Routes} from “@angular/router”;

@Component({

template: `Search`

})

export class SearchComponent {

}

@Component({

template: `Home`

})

export class HomeComponent {

}

@Component({

template: `<router-outlet></router-outlet>`

})

export class AppComponent {

}

export const routes: Routes = [

// {path: ‘’, redirectTo: ‘home’, pathMatch: ‘full’},

{path: ‘home’, component: HomeComponent},

{path: ‘search’, component: SearchComponent}

];

Ahora el spec de ese router.

/* tslint:disable:no-unused-variable */

import {Location} from “@angular/common”;

import {TestBed, fakeAsync, tick} from ‘@angular/core/testing’;

import {RouterTestingModule} from “@angular/router/testing”;

import {Router} from “@angular/router”;

import {

HomeComponent,

SearchComponent,

AppComponent,

routes

} from “./router”

describe(‘Router: App’, () => {

let location: Location;

let router: Router;

let fixture;

beforeEach(() => {

TestBed.configureTestingModule({

imports: [ RouterTestingModule.withRoutes(routes)],

declarations: [

HomeComponent,

SearchComponent,

AppComponent

]

});

router = TestBed.get(Router);

location = TestBed.get(Location);

fixture = TestBed.createComponent(AppComponent);

router.initialNavigation();

});

it(‘fakeAsync works’, fakeAsync(() => {

let promise = new Promise((resolve) => {

setTimeout(resolve, 10)

});

let done = false;

promise.then(() => done = true);

tick(50);

expect(done).toBeTruthy();

}));

it(‘navigate to “” redirects you to /home’, fakeAsync(() => {

router.navigate([‘’]);

tick(50);

expect(location.path()).toBe(‘/home’);

}));

it(‘navigate to “search” takes you to /search’, fakeAsync(() => {

router.navigate([‘/search’]);

tick(50);

expect(location.path()).toBe(‘/search’);

}));

});

JoséRigobertoPVito
JoséRigobertoPVito

Written by JoséRigobertoPVito

Front-End & Back-End Developer, Freelancer, DBA. Chef Parrillero Frustrado xD. Fanático del Fútbol y Béisbol.