Angular Unit Testing
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.
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.
Matcher equal.
Pruebar con arrays.
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.
Vamos a realizar nuestras pruebas.
- Primero vamos a realizar una prueba a una clase.
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.
- 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.
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.
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.
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.
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.
Si observamos en nuestro html, si el usuario necesita login sale Login dentro del elemento a ahora si no dice logout.
- Debemos importar nuevas clases que nos ayuden a interartuar con las vistas de nuestros componentes. DebugElement and By.
- Ahora tenemos una nueva variable “el” que la vamos a utilizar para obtener los componentes de nuestra vista.
- 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.
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)
Ejemplo el siguiente caso.
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.
En este caso como usamos el detectChanges() el si toma el cambio y debería arrojar el Logout.
Ahora el código completo.
Hacer pruebas con código asíncrono. Vamos a modificar nuestro AuthService.
Y Nuestro logincomponent.
Ahora veamos nuestra prueba.
- Hacemos el primer detectChanges para que tome el ultimo cambio y no devuelve ‘’.
- Aca esperamos que nos devuelva login el elemento a.
- En este paso simulamos que nuestra clase retorna true.
- Llamamos nuestro ngoninit para que tome el cambio.
- Ejecutamos nuestro segundo detectChanges.
- 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().
- A la prueba le pasamos un método el cual es el done().
- Podemos llamar un función usando spy la cual es llamada una vez que la promesa devuelva el valor.
- 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.
- Nosotros agregamos otro parámetro en nuestra función de prueba, y es la función async.
- Colocamos nuestro prueba una vez llamemos el método isAuthenticated.
Por ultimo podemos usar el fakeasyn y el tick.
- 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.
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.
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.
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.
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’);
}));
});







