angular2
Version:
Angular 2 - a web framework for modern web apps
150 lines • 20.1 kB
JavaScript
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
switch (arguments.length) {
case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { Injectable } from 'angular2/core';
import { Request } from '../static_request';
import { ReadyStates } from '../enums';
import { isPresent } from 'angular2/src/facade/lang';
import { BaseException } from 'angular2/src/facade/exceptions';
import { Subject, ReplaySubject } from '@reactivex/rxjs/dist/cjs/Rx';
/**
*
* Mock Connection to represent a {@link Connection} for tests.
*
**/
export class MockConnection {
constructor(req) {
this.response = new ReplaySubject(1).take(1);
this.readyState = ReadyStates.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}.
*
* ### Example
*
* ```
* var connection;
* backend.connections.subscribe(c => connection = c);
* http.request('data.json').subscribe(res => console.log(res.text()));
* connection.mockRespond(new Response('fake response')); //logs 'fake response'
* ```
*
*/
mockRespond(res) {
if (this.readyState === ReadyStates.Done || this.readyState === ReadyStates.Cancelled) {
throw new BaseException('Connection has already been resolved');
}
this.readyState = ReadyStates.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.
*/
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}.
*/
mockError(err) {
// Matches XHR semantics
this.readyState = ReadyStates.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}.
*
* ### Example
*
* ```
* import {MockBackend, DefaultOptions, Http} from 'angular2/http';
* it('should get some data', inject([AsyncTestCompleter], (async) => {
* var connection;
* var injector = Injector.resolveAndCreate([
* MockBackend,
* provide(Http, {useFactory: (backend, defaultOptions) => {
* return new Http(backend, defaultOptions)
* }, deps: [MockBackend, DefaultOptions]})]);
* var http = injector.get(Http);
* var backend = injector.get(MockBackend);
* //Assign any newly-created connection to local variable
* backend.connections.subscribe(c => connection = c);
* http.request('data.json').subscribe((res) => {
* expect(res.text()).toBe('awesome');
* async.done();
* });
* connection.mockRespond(new Response('awesome'));
* }));
* ```
*
* This method only exists in the mock implementation, not in real Backends.
**/
export let MockBackend = class {
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.
*/
verifyNoPendingRequests() {
let pending = 0;
this.pendingConnections.subscribe(c => pending++);
if (pending > 0)
throw new BaseException(`${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.
*/
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.
*/
createConnection(req) {
if (!isPresent(req) || !(req instanceof Request)) {
throw new BaseException(`createConnection requires an instance of Request, got ${req}`);
}
let connection = new MockConnection(req);
this.connections.next(connection);
return connection;
}
};
MockBackend = __decorate([
Injectable(),
__metadata('design:paramtypes', [])
], MockBackend);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mock_backend.js","sourceRoot":"","sources":["angular2/src/http/backends/mock_backend.ts"],"names":["MockConnection","MockConnection.constructor","MockConnection.mockRespond","MockConnection.mockDownload","MockConnection.mockError","MockBackend","MockBackend.constructor","MockBackend.verifyNoPendingRequests","MockBackend.resolveAllConnections","MockBackend.createConnection"],"mappings":"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","sourcesContent":["import {Injectable} from 'angular2/core';\nimport {Request} from '../static_request';\nimport {Response} from '../static_response';\nimport {ReadyStates} from '../enums';\nimport {Connection, ConnectionBackend} from '../interfaces';\nimport {isPresent} from 'angular2/src/facade/lang';\nimport {BaseException, WrappedException} from 'angular2/src/facade/exceptions';\nimport {Subject, ReplaySubject} from '@reactivex/rxjs/dist/cjs/Rx';\n\n/**\n *\n * Mock Connection to represent a {@link Connection} for tests.\n *\n **/\nexport class MockConnection implements Connection {\n  // TODO Name `readyState` should change to be more generic, and states could be made to be more\n  // descriptive than XHR states.\n  /**\n   * Describes the state of the connection, based on `XMLHttpRequest.readyState`, but with\n   * additional states. For example, state 5 indicates an aborted connection.\n   */\n  readyState: ReadyStates;\n\n  /**\n   * {@link Request} instance used to create the connection.\n   */\n  request: Request;\n\n  /**\n   * {@link EventEmitter} of {@link Response}. Can be subscribed to in order to be notified when a\n   * response is available.\n   */\n  response: any;  // Subject<Response>\n\n  constructor(req: Request) {\n    this.response = new ReplaySubject(1).take(1);\n    this.readyState = ReadyStates.Open;\n    this.request = req;\n  }\n\n  /**\n   * Sends a mock response to the connection. This response is the value that is emitted to the\n   * {@link EventEmitter} returned by {@link Http}.\n   *\n   * ### Example\n   *\n   * ```\n   * var connection;\n   * backend.connections.subscribe(c => connection = c);\n   * http.request('data.json').subscribe(res => console.log(res.text()));\n   * connection.mockRespond(new Response('fake response')); //logs 'fake response'\n   * ```\n   *\n   */\n  mockRespond(res: Response) {\n    if (this.readyState === ReadyStates.Done || this.readyState === ReadyStates.Cancelled) {\n      throw new BaseException('Connection has already been resolved');\n    }\n    this.readyState = ReadyStates.Done;\n    this.response.next(res);\n    this.response.complete();\n  }\n\n  /**\n   * Not yet implemented!\n   *\n   * Sends the provided {@link Response} to the `downloadObserver` of the `Request`\n   * associated with this connection.\n   */\n  mockDownload(res: Response) {\n    // this.request.downloadObserver.onNext(res);\n    // if (res.bytesLoaded === res.totalBytes) {\n    //   this.request.downloadObserver.onCompleted();\n    // }\n  }\n\n  // TODO(jeffbcross): consider using Response type\n  /**\n   * Emits the provided error object as an error to the {@link Response} {@link EventEmitter}\n   * returned\n   * from {@link Http}.\n   */\n  mockError(err?: Error) {\n    // Matches XHR semantics\n    this.readyState = ReadyStates.Done;\n    this.response.error(err);\n  }\n}\n\n/**\n * A mock backend for testing the {@link Http} service.\n *\n * This class can be injected in tests, and should be used to override providers\n * to other backends, such as {@link XHRBackend}.\n *\n * ### Example\n *\n * ```\n * import {MockBackend, DefaultOptions, Http} from 'angular2/http';\n * it('should get some data', inject([AsyncTestCompleter], (async) => {\n *   var connection;\n *   var injector = Injector.resolveAndCreate([\n *     MockBackend,\n *     provide(Http, {useFactory: (backend, defaultOptions) => {\n *       return new Http(backend, defaultOptions)\n *     }, deps: [MockBackend, DefaultOptions]})]);\n *   var http = injector.get(Http);\n *   var backend = injector.get(MockBackend);\n *   //Assign any newly-created connection to local variable\n *   backend.connections.subscribe(c => connection = c);\n *   http.request('data.json').subscribe((res) => {\n *     expect(res.text()).toBe('awesome');\n *     async.done();\n *   });\n *   connection.mockRespond(new Response('awesome'));\n * }));\n * ```\n *\n * This method only exists in the mock implementation, not in real Backends.\n **/\n@Injectable()\nexport class MockBackend implements ConnectionBackend {\n  /**\n   * {@link EventEmitter}\n   * of {@link MockConnection} instances that have been created by this backend. Can be subscribed\n   * to in order to respond to connections.\n   *\n   * ### Example\n   *\n   * ```\n   * import {MockBackend, Http, BaseRequestOptions} from 'angular2/http';\n   * import {Injector} from 'angular2/core';\n   *\n   * it('should get a response', () => {\n   *   var connection; //this will be set when a new connection is emitted from the backend.\n   *   var text; //this will be set from mock response\n   *   var injector = Injector.resolveAndCreate([\n   *     MockBackend,\n   *     provide(Http, {useFactory: (backend, options) {\n   *       return new Http(backend, options);\n   *     }, deps: [MockBackend, BaseRequestOptions]}]);\n   *   var backend = injector.get(MockBackend);\n   *   var http = injector.get(Http);\n   *   backend.connections.subscribe(c => connection = c);\n   *   http.request('something.json').subscribe(res => {\n   *     text = res.text();\n   *   });\n   *   connection.mockRespond(new Response({body: 'Something'}));\n   *   expect(text).toBe('Something');\n   * });\n   * ```\n   *\n   * This property only exists in the mock implementation, not in real Backends.\n   */\n  connections: any;  //<MockConnection>\n\n  /**\n   * An array representation of `connections`. This array will be updated with each connection that\n   * is created by this backend.\n   *\n   * This property only exists in the mock implementation, not in real Backends.\n   */\n  connectionsArray: MockConnection[];\n  /**\n   * {@link EventEmitter} of {@link MockConnection} instances that haven't yet been resolved (i.e.\n   * with a `readyState`\n   * less than 4). Used internally to verify that no connections are pending via the\n   * `verifyNoPendingRequests` method.\n   *\n   * This property only exists in the mock implementation, not in real Backends.\n   */\n  pendingConnections: any;  // Subject<MockConnection>\n  constructor() {\n    this.connectionsArray = [];\n    this.connections = new Subject();\n    this.connections.subscribe(connection => this.connectionsArray.push(connection));\n    this.pendingConnections = new Subject();\n  }\n\n  /**\n   * Checks all connections, and raises an exception if any connection has not received a response.\n   *\n   * This method only exists in the mock implementation, not in real Backends.\n   */\n  verifyNoPendingRequests() {\n    let pending = 0;\n    this.pendingConnections.subscribe(c => pending++);\n    if (pending > 0) throw new BaseException(`${pending} pending connections to be resolved`);\n  }\n\n  /**\n   * Can be used in conjunction with `verifyNoPendingRequests` to resolve any not-yet-resolve\n   * connections, if it's expected that there are connections that have not yet received a response.\n   *\n   * This method only exists in the mock implementation, not in real Backends.\n   */\n  resolveAllConnections() { this.connections.subscribe(c => c.readyState = 4); }\n\n  /**\n   * Creates a new {@link MockConnection}. This is equivalent to calling `new\n   * MockConnection()`, except that it also will emit the new `Connection` to the `connections`\n   * emitter of this `MockBackend` instance. This method will usually only be used by tests\n   * against the framework itself, not by end-users.\n   */\n  createConnection(req: Request): Connection {\n    if (!isPresent(req) || !(req instanceof Request)) {\n      throw new BaseException(`createConnection requires an instance of Request, got ${req}`);\n    }\n    let connection = new MockConnection(req);\n    this.connections.next(connection);\n    return connection;\n  }\n}\n"]}