| /** |
| * @license Angular v8.0.0-beta.10+1.sha-a28b3e3 |
| * (c) 2010-2019 Google LLC. https://angular.io/ |
| * License: MIT |
| */ |
| |
| import { __decorate, __metadata } from 'tslib'; |
| import { Injectable } from '@angular/core'; |
| import { ReadyState, Request } from '@angular/http'; |
| import { ReplaySubject, Subject } from 'rxjs'; |
| import { take } from 'rxjs/operators'; |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * |
| * 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 |
| */ |
| var MockConnection = /** @class */ (function () { |
| function MockConnection(req) { |
| this.response = 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}. |
| * |
| */ |
| MockConnection.prototype.mockRespond = function (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. |
| */ |
| MockConnection.prototype.mockDownload = function (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}. |
| * |
| */ |
| MockConnection.prototype.mockError = function (err) { |
| // Matches ResourceLoader semantics |
| this.readyState = ReadyState.Done; |
| this.response.error(err); |
| }; |
| return MockConnection; |
| }()); |
| /** |
| * 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 |
| */ |
| var MockBackend = /** @class */ (function () { |
| function MockBackend() { |
| var _this = this; |
| this.connectionsArray = []; |
| this.connections = new Subject(); |
| this.connections.subscribe(function (connection) { return _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. |
| */ |
| MockBackend.prototype.verifyNoPendingRequests = function () { |
| var pending = 0; |
| this.pendingConnections.subscribe(function (c) { return 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. |
| */ |
| MockBackend.prototype.resolveAllConnections = function () { this.connections.subscribe(function (c) { return 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. |
| */ |
| MockBackend.prototype.createConnection = function (req) { |
| if (!req || !(req instanceof Request)) { |
| throw new Error("createConnection requires an instance of Request, got " + req); |
| } |
| var connection = new MockConnection(req); |
| this.connections.next(connection); |
| return connection; |
| }; |
| MockBackend = __decorate([ |
| Injectable(), |
| __metadata("design:paramtypes", []) |
| ], MockBackend); |
| return MockBackend; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| |
| /** |
| * Generated bundle index. Do not edit. |
| */ |
| |
| export { MockConnection, MockBackend }; |
| //# sourceMappingURL=testing.js.map |