UNPKG

@angular/http

Version:
257 lines (249 loc) 8.59 kB
/** * @license Angular v7.2.16 * (c) 2010-2019 Google LLC. https://angular.io/ * License: MIT */ import { Injectable } from '@angular/core'; import { ReadyState, Request } from '@angular/http'; import { ReplaySubject, Subject } from 'rxjs'; import { take } from 'rxjs/operators'; /** * @fileoverview added by tsickle * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc */ /** * * Mock Connection to represent a {\@link Connection} for tests. * * \@usageNotes * ### Example of `mockRespond()` * * ``` * var connection; * backend.connections.subscribe(c => connection = c); * http.request('data.json').subscribe(res => console.log(res.text())); * connection.mockRespond(new Response(new ResponseOptions({ body: 'fake response' }))); //logs * 'fake response' * ``` * * ### Example of `mockError()` * * ``` * var connection; * backend.connections.subscribe(c => connection = c); * http.request('data.json').subscribe(res => res, err => console.log(err))); * connection.mockError(new Error('error')); * ``` * * @deprecated see https://angular.io/guide/http * \@publicApi */ class MockConnection { /** * @param {?} req */ constructor(req) { this.response = (/** @type {?} */ (new ReplaySubject(1).pipe(take(1)))); this.readyState = ReadyState.Open; this.request = req; } /** * Sends a mock response to the connection. This response is the value that is emitted to the * {\@link EventEmitter} returned by {\@link Http}. * * @param {?} res * @return {?} */ mockRespond(res) { if (this.readyState === ReadyState.Done || this.readyState === ReadyState.Cancelled) { throw new Error('Connection has already been resolved'); } this.readyState = ReadyState.Done; this.response.next(res); this.response.complete(); } /** * Not yet implemented! * * Sends the provided {\@link Response} to the `downloadObserver` of the `Request` * associated with this connection. * @param {?} res * @return {?} */ mockDownload(res) { // this.request.downloadObserver.onNext(res); // if (res.bytesLoaded === res.totalBytes) { // this.request.downloadObserver.onCompleted(); // } } // TODO(jeffbcross): consider using Response type /** * Emits the provided error object as an error to the {\@link Response} {\@link EventEmitter} * returned * from {\@link Http}. * * @param {?=} err * @return {?} */ mockError(err) { // Matches ResourceLoader semantics this.readyState = ReadyState.Done; this.response.error(err); } } /** * A mock backend for testing the {\@link Http} service. * * This class can be injected in tests, and should be used to override providers * to other backends, such as {\@link XHRBackend}. * * \@usageNotes * ### Example * * ``` * import {Injectable, Injector} from '\@angular/core'; * import {async, fakeAsync, tick} from '\@angular/core/testing'; * import {BaseRequestOptions, ConnectionBackend, Http, RequestOptions} from '\@angular/http'; * import {Response, ResponseOptions} from '\@angular/http'; * import {MockBackend, MockConnection} from '\@angular/http/testing'; * * const HERO_ONE = 'HeroNrOne'; * const HERO_TWO = 'WillBeAlwaysTheSecond'; * * \@Injectable() * class HeroService { * constructor(private http: Http) {} * * getHeroes(): Promise<String[]> { * return this.http.get('myservices.de/api/heroes') * .toPromise() * .then(response => response.json().data) * .catch(e => this.handleError(e)); * } * * private handleError(error: any): Promise<any> { * console.error('An error occurred', error); * return Promise.reject(error.message || error); * } * } * * describe('MockBackend HeroService Example', () => { * beforeEach(() => { * this.injector = Injector.create([ * {provide: ConnectionBackend, useClass: MockBackend}, * {provide: RequestOptions, useClass: BaseRequestOptions}, * Http, * HeroService, * ]); * this.heroService = this.injector.get(HeroService); * this.backend = this.injector.get(ConnectionBackend) as MockBackend; * this.backend.connections.subscribe((connection: any) => this.lastConnection = connection); * }); * * it('getHeroes() should query current service url', () => { * this.heroService.getHeroes(); * expect(this.lastConnection).toBeDefined('no http service connection at all?'); * expect(this.lastConnection.request.url).toMatch(/api\/heroes$/, 'url invalid'); * }); * * it('getHeroes() should return some heroes', fakeAsync(() => { * let result: String[]; * this.heroService.getHeroes().then((heroes: String[]) => result = heroes); * this.lastConnection.mockRespond(new Response(new ResponseOptions({ * body: JSON.stringify({data: [HERO_ONE, HERO_TWO]}), * }))); * tick(); * expect(result.length).toEqual(2, 'should contain given amount of heroes'); * expect(result[0]).toEqual(HERO_ONE, ' HERO_ONE should be the first hero'); * expect(result[1]).toEqual(HERO_TWO, ' HERO_TWO should be the second hero'); * })); * * it('getHeroes() while server is down', fakeAsync(() => { * let result: String[]; * let catchedError: any; * this.heroService.getHeroes() * .then((heroes: String[]) => result = heroes) * .catch((error: any) => catchedError = error); * this.lastConnection.mockError(new Response(new ResponseOptions({ * status: 404, * statusText: 'URL not Found', * }))); * tick(); * expect(result).toBeUndefined(); * expect(catchedError).toBeDefined(); * })); * }); * ``` * * @deprecated see https://angular.io/guide/http * \@publicApi */ class MockBackend { // Subject<MockConnection> constructor() { this.connectionsArray = []; this.connections = new Subject(); this.connections.subscribe((connection) => this.connectionsArray.push(connection)); this.pendingConnections = new Subject(); } /** * Checks all connections, and raises an exception if any connection has not received a response. * * This method only exists in the mock implementation, not in real Backends. * @return {?} */ verifyNoPendingRequests() { /** @type {?} */ let pending = 0; this.pendingConnections.subscribe((c) => pending++); if (pending > 0) throw new Error(`${pending} pending connections to be resolved`); } /** * Can be used in conjunction with `verifyNoPendingRequests` to resolve any not-yet-resolve * connections, if it's expected that there are connections that have not yet received a response. * * This method only exists in the mock implementation, not in real Backends. * @return {?} */ resolveAllConnections() { this.connections.subscribe((c) => c.readyState = 4); } /** * Creates a new {\@link MockConnection}. This is equivalent to calling `new * MockConnection()`, except that it also will emit the new `Connection` to the `connections` * emitter of this `MockBackend` instance. This method will usually only be used by tests * against the framework itself, not by end-users. * @param {?} req * @return {?} */ createConnection(req) { if (!req || !(req instanceof Request)) { throw new Error(`createConnection requires an instance of Request, got ${req}`); } /** @type {?} */ const connection = new MockConnection(req); this.connections.next(connection); return connection; } } MockBackend.decorators = [ { type: Injectable } ]; /** @nocollapse */ MockBackend.ctorParameters = () => []; /** * @fileoverview added by tsickle * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc */ /** * @fileoverview added by tsickle * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc */ /** * @fileoverview added by tsickle * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc */ /** * Generated bundle index. Do not edit. */ export { MockConnection, MockBackend }; //# sourceMappingURL=testing.js.map