angular2
Version:
Angular 2 - a web framework for modern web apps
159 lines • 20.8 kB
JavaScript
;"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var core_1 = require('angular2/core');
var static_request_1 = require('../static_request');
var enums_1 = require('../enums');
var lang_1 = require('angular2/src/facade/lang');
var exceptions_1 = require('angular2/src/facade/exceptions');
var Subject_1 = require('rxjs/Subject');
var ReplaySubject_1 = require('rxjs/ReplaySubject');
var take_1 = require('rxjs/operator/take');
/**
*
* Mock Connection to represent a {@link Connection} for tests.
*
**/
var MockConnection = (function () {
function MockConnection(req) {
this.response = take_1.take.call(new ReplaySubject_1.ReplaySubject(1), 1);
this.readyState = enums_1.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}.
*
* ### 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'
* ```
*
*/
MockConnection.prototype.mockRespond = function (res) {
if (this.readyState === enums_1.ReadyState.Done || this.readyState === enums_1.ReadyState.Cancelled) {
throw new exceptions_1.BaseException('Connection has already been resolved');
}
this.readyState = enums_1.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 XHR semantics
this.readyState = enums_1.ReadyState.Done;
this.response.error(err);
};
return MockConnection;
}());
exports.MockConnection = 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}.
*
* ### Example
*
* ```
* import {BaseRequestOptions, Http} from 'angular2/http';
* import {MockBackend} from 'angular2/http/testing';
* it('should get some data', inject([AsyncTestCompleter], (async) => {
* var connection;
* var injector = Injector.resolveAndCreate([
* MockBackend,
* provide(Http, {useFactory: (backend, options) => {
* return new Http(backend, options);
* }, deps: [MockBackend, BaseRequestOptions]})]);
* 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.
**/
var MockBackend = (function () {
function MockBackend() {
var _this = this;
this.connectionsArray = [];
this.connections = new Subject_1.Subject();
this.connections.subscribe(function (connection) {
return _this.connectionsArray.push(connection);
});
this.pendingConnections = new Subject_1.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 exceptions_1.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.
*/
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 (!lang_1.isPresent(req) || !(req instanceof static_request_1.Request)) {
throw new exceptions_1.BaseException("createConnection requires an instance of Request, got " + req);
}
var connection = new MockConnection(req);
this.connections.next(connection);
return connection;
};
MockBackend = __decorate([
core_1.Injectable(),
__metadata('design:paramtypes', [])
], MockBackend);
return MockBackend;
}());
exports.MockBackend = MockBackend;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mock_backend.js","sourceRoot":"","sources":["diffing_plugin_wrapper-output_path-BRJer1J9.tmp/angular2/src/http/backends/mock_backend.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from 'angular2/core';\nimport {Request} from '../static_request';\nimport {Response} from '../static_response';\nimport {ReadyState} from '../enums';\nimport {Connection, ConnectionBackend} from '../interfaces';\nimport {isPresent} from 'angular2/src/facade/lang';\nimport {BaseException, WrappedException} from 'angular2/src/facade/exceptions';\nimport {Subject} from 'rxjs/Subject';\nimport {ReplaySubject} from 'rxjs/ReplaySubject';\nimport {take} from 'rxjs/operator/take';\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: ReadyState;\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: ReplaySubject<Response>;\n\n  constructor(req: Request) {\n    this.response = <any>take.call(new ReplaySubject(1), 1);\n    this.readyState = ReadyState.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 === ReadyState.Done || this.readyState === ReadyState.Cancelled) {\n      throw new BaseException('Connection has already been resolved');\n    }\n    this.readyState = ReadyState.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 = ReadyState.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 {BaseRequestOptions, Http} from 'angular2/http';\n * import {MockBackend} from 'angular2/http/testing';\n * it('should get some data', inject([AsyncTestCompleter], (async) => {\n *   var connection;\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 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 {Http, BaseRequestOptions} from 'angular2/http';\n   * import {MockBackend} from 'angular2/http/testing';\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: MockConnection) =>\n                                   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: MockConnection) => 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: MockConnection) => 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): MockConnection {\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"]}