| /** |
| * @license Angular v8.0.0-beta.10+1.sha-a28b3e3 |
| * (c) 2010-2019 Google LLC. https://angular.io/ |
| * License: MIT |
| */ |
| |
| import { Connection } from '@angular/http';
|
| import { ConnectionBackend } from '@angular/http';
|
| import { ReadyState } from '@angular/http';
|
| import { ReplaySubject } from 'rxjs';
|
| import { Request } from '@angular/http';
|
| import { Response } from '@angular/http';
|
|
|
| /**
|
| * 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
|
| */
|
| export declare class MockBackend implements ConnectionBackend {
|
| /**
|
| * {@link EventEmitter}
|
| * of {@link MockConnection} instances that have been created by this backend. Can be subscribed
|
| * to in order to respond to connections.
|
| *
|
| * This property only exists in the mock implementation, not in real Backends.
|
| */
|
| connections: any;
|
| /**
|
| * An array representation of `connections`. This array will be updated with each connection that
|
| * is created by this backend.
|
| *
|
| * This property only exists in the mock implementation, not in real Backends.
|
| */
|
| connectionsArray: MockConnection[];
|
| /**
|
| * {@link EventEmitter} of {@link MockConnection} instances that haven't yet been resolved (i.e.
|
| * with a `readyState`
|
| * less than 4). Used internally to verify that no connections are pending via the
|
| * `verifyNoPendingRequests` method.
|
| *
|
| * This property only exists in the mock implementation, not in real Backends.
|
| */
|
| pendingConnections: any;
|
| constructor();
|
| /**
|
| * 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.
|
| */
|
| verifyNoPendingRequests(): void;
|
| /**
|
| * 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.
|
| */
|
| resolveAllConnections(): void;
|
| /**
|
| * 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.
|
| */
|
| createConnection(req: Request): MockConnection;
|
| }
|
|
|
| /**
|
| *
|
| * 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
|
| */
|
| export declare class MockConnection implements Connection {
|
| /**
|
| * Describes the state of the connection, based on `XMLHttpRequest.readyState`, but with
|
| * additional states. For example, state 5 indicates an aborted connection.
|
| */
|
| readyState: ReadyState;
|
| /**
|
| * {@link Request} instance used to create the connection.
|
| */
|
| request: Request;
|
| /**
|
| * {@link EventEmitter} of {@link Response}. Can be subscribed to in order to be notified when a
|
| * response is available.
|
| */
|
| response: ReplaySubject<Response>;
|
| constructor(req: Request);
|
| /**
|
| * Sends a mock response to the connection. This response is the value that is emitted to the
|
| * {@link EventEmitter} returned by {@link Http}.
|
| *
|
| */
|
| mockRespond(res: Response): void;
|
| /**
|
| * Not yet implemented!
|
| *
|
| * Sends the provided {@link Response} to the `downloadObserver` of the `Request`
|
| * associated with this connection.
|
| */
|
| mockDownload(res: Response): void;
|
| /**
|
| * Emits the provided error object as an error to the {@link Response} {@link EventEmitter}
|
| * returned
|
| * from {@link Http}.
|
| *
|
| */
|
| mockError(err?: Error): void;
|
| }
|
|
|
| export { }
|
