tutorial - Angular2: prueba de la unidad de llamada HTTP

unit test angular 5

Question

Soy un principiante de angular2.

Mi service.ts será,

import { Injectable } from ''@angular/core'';
import { Http, Response } from ''@angular/http'';
import {Headers, RequestOptions, URLSearchParams} from ''@angular/http'';
import {Observable} from ''rxjs/Observable'';
import ''rxjs/add/operator/map'';
import ''rxjs/add/operator/catch'';
import ''rxjs/add/observable/throw'';
@Injectable()
export class HomeService {
url : string;
constructor(private _http: Http) {}
getUserInfo(userId : string) {
this.url = "http://localhost:9080/GetUserData";
let content = new URLSearchParams();
content.set(''userId'', userId.toString());
let headers = new Headers();
headers.append(''Content-Type'', ''application/x-www-form-urlencoded'');
return this._http
.post(this.url, content.toString(), {headers: headers})
.map((res: Response) => res.json())
.catch(this.handleError);
}
handleError (error: Response | any) {
let errMsg: string;
if (error instanceof Response) {
const body = error.json() || '''';
const err = body.error || JSON.stringify(body);
errMsg = `${error.status} - ${error.statusText || ''''} ${err}`;
} else {
errMsg = error.message ? error.message : error.toString();
}
console.error(errMsg);
return Observable.throw(errMsg);
}
}

He escrito el caso de prueba unitaria como,

import { TestBed, async, inject } from ''@angular/core/testing'';
import { HomeService } from ''./home.service'';
import { BaseRequestOptions, Response, ResponseOptions, Http } from ''@angular/http'';
import { MockBackend, MockConnection } from ''@angular/http/testing'';
import {Observable} from ''rxjs/Observable'';
describe(''FacilityPopupService'', () => {
let subject: HomeService = null;
let backend: MockBackend = null;
let userid="UID1";
beforeEach(() => {
TestBed.configureTestingModule({
providers: [
HomeService,
Response,
BaseRequestOptions,
MockBackend,
{
provide: Http,
useFactory: (backend: MockBackend, defaultOptions: BaseRequestOptions) => {
return new Http(backend, defaultOptions);
},
deps: [MockBackend, BaseRequestOptions],
}
]
});
});
beforeEach(inject([HomeService, MockBackend], (userService: HomeService, mockBackend: MockBackend) => {
subject = userService;
backend = mockBackend;
}));
it(''get Facility list should call endpoint and return it/'s result'', (done) => {
backend.connections.subscribe((connection: MockConnection) => {
let options = new ResponseOptions({
body: JSON.stringify({ success: true })
});
connection.mockRespond(new Response(options));
});
subject.getUserInfo(userid)
.subscribe((response) => {
expect(response).toEqual({ success: true });
done();
});
});
});

Quiero escribir el caso de prueba para el caso de éxito y el caso de error. No sé cómo ejecutar el bloqueo catch . Además, no sé cómo escribir el caso de prueba para el método handleError .

No puedo, no puedo cubrir todos los escenarios posibles aquí. ¿Puede ayudarme a obtener una cobertura del 100% para el servicio?

Answer 1

Para cubrir el caso negativo, puede simular una respuesta con un código de estado que no sea 200. Puedes seguir este ejemplo MockBackend.

 it(''getUserInfo() while server is down'', fakeAsync(() => {
let result: any;
let catchedError: any;
this.userUser.getUserInfo(1)
.then((userInfo: any) => result = userInfo)
.catch((error: any) => catchedError = error);
this.lastConnection.mockRespond(new Response(new ResponseOptions({
status: 404, //here
statusText: ''URL not Found'',
})));
tick();
expect(result).toBeUndefined();
expect(catchedError).toBeDefined();
}));
});

Answer 2

Puede usar el siguiente código para el caso positivo.

describe(''HomeService'',() =>{
let homeService:HomeService,
mockHttp;
beforeEach(() => {
mockHttp=jasmine.createSpyObject(''mockHttp'',[''get''])
homeService=new HomeService(mockHttp);
});
describe(''GetbyID'', =>{
it(''should get the detail of user with passed id'', =>{
let user={id:1,name:''some Name''}
mockHttp.get.and.returnValue(Observable.of(false));
homeService.getUserInfo(1);
expect(mockHttp.get).toHaveBeenCalledWith(''your url'');
});
});
});

Para el caso negativo: comete un error en la URL y verifica si la llamada está fallando y si se invoca el método del manejador de errores o no.