| /** |
| * @license Angular v8.0.0-beta.10+1.sha-a28b3e3 |
| * (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,missingOverride,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((/** |
| * @param {?} connection |
| * @return {?} |
| */ |
| (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((/** |
| * @param {?} c |
| * @return {?} |
| */ |
| (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((/** |
| * @param {?} c |
| * @return {?} |
| */ |
| (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,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc |
| */ |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc |
| */ |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc |
| */ |
| |
| /** |
| * Generated bundle index. Do not edit. |
| */ |
| |
| export { MockConnection, MockBackend }; |
| //# sourceMappingURL=testing.js.map |
