| /** |
| * @license Angular v5.2.0 |
| * (c) 2010-2018 Google, Inc. https://angular.io/ |
| * License: MIT |
| */ |
| import { HttpBackend, HttpClientModule, HttpErrorResponse, HttpEventType, HttpHeaders, HttpResponse } from '@angular/common/http'; |
| import { Injectable, NgModule } from '@angular/core'; |
| import { Observable } from 'rxjs/Observable'; |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes} checked by tsc |
| */ |
| /** |
| * @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 |
| */ |
| /** |
| * Defines a matcher for requests based on URL, method, or both. |
| * |
| * \@stable |
| * @record |
| */ |
| |
| /** |
| * Controller to be injected into tests, that allows for mocking and flushing |
| * of requests. |
| * |
| * \@stable |
| * @abstract |
| */ |
| var HttpTestingController = /** @class */ (function () { |
| function HttpTestingController() { |
| } |
| return HttpTestingController; |
| }()); |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes} checked by tsc |
| */ |
| /** |
| * @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 |
| */ |
| /** |
| * A mock requests that was received and is ready to be answered. |
| * |
| * This interface allows access to the underlying `HttpRequest`, and allows |
| * responding with `HttpEvent`s or `HttpErrorResponse`s. |
| * |
| * \@stable |
| */ |
| var TestRequest = /** @class */ (function () { |
| function TestRequest(request, observer) { |
| this.request = request; |
| this.observer = observer; |
| /** |
| * \@internal set by `HttpClientTestingBackend` |
| */ |
| this._cancelled = false; |
| } |
| Object.defineProperty(TestRequest.prototype, "cancelled", { |
| /** |
| * Whether the request was cancelled after it was sent. |
| */ |
| get: /** |
| * Whether the request was cancelled after it was sent. |
| * @return {?} |
| */ |
| function () { return this._cancelled; }, |
| enumerable: true, |
| configurable: true |
| }); |
| /** |
| * Resolve the request by returning a body plus additional HTTP information (such as response |
| * headers) if provided. |
| * |
| * Both successful and unsuccessful responses can be delivered via `flush()`. |
| */ |
| /** |
| * Resolve the request by returning a body plus additional HTTP information (such as response |
| * headers) if provided. |
| * |
| * Both successful and unsuccessful responses can be delivered via `flush()`. |
| * @param {?} body |
| * @param {?=} opts |
| * @return {?} |
| */ |
| TestRequest.prototype.flush = /** |
| * Resolve the request by returning a body plus additional HTTP information (such as response |
| * headers) if provided. |
| * |
| * Both successful and unsuccessful responses can be delivered via `flush()`. |
| * @param {?} body |
| * @param {?=} opts |
| * @return {?} |
| */ |
| function (body, opts) { |
| if (opts === void 0) { opts = {}; } |
| if (this.cancelled) { |
| throw new Error("Cannot flush a cancelled request."); |
| } |
| var /** @type {?} */ url = this.request.urlWithParams; |
| var /** @type {?} */ headers = (opts.headers instanceof HttpHeaders) ? opts.headers : new HttpHeaders(opts.headers); |
| body = _maybeConvertBody(this.request.responseType, body); |
| var /** @type {?} */ statusText = opts.statusText; |
| var /** @type {?} */ status = opts.status !== undefined ? opts.status : 200; |
| if (opts.status === undefined) { |
| if (body === null) { |
| status = 204; |
| statusText = statusText || 'No Content'; |
| } |
| else { |
| statusText = statusText || 'OK'; |
| } |
| } |
| if (statusText === undefined) { |
| throw new Error('statusText is required when setting a custom status.'); |
| } |
| if (status >= 200 && status < 300) { |
| this.observer.next(new HttpResponse({ body: body, headers: headers, status: status, statusText: statusText, url: url })); |
| this.observer.complete(); |
| } |
| else { |
| this.observer.error(new HttpErrorResponse({ error: body, headers: headers, status: status, statusText: statusText, url: url })); |
| } |
| }; |
| /** |
| * Resolve the request by returning an `ErrorEvent` (e.g. simulating a network failure). |
| */ |
| /** |
| * Resolve the request by returning an `ErrorEvent` (e.g. simulating a network failure). |
| * @param {?} error |
| * @param {?=} opts |
| * @return {?} |
| */ |
| TestRequest.prototype.error = /** |
| * Resolve the request by returning an `ErrorEvent` (e.g. simulating a network failure). |
| * @param {?} error |
| * @param {?=} opts |
| * @return {?} |
| */ |
| function (error, opts) { |
| if (opts === void 0) { opts = {}; } |
| if (this.cancelled) { |
| throw new Error("Cannot return an error for a cancelled request."); |
| } |
| if (opts.status && opts.status >= 200 && opts.status < 300) { |
| throw new Error("error() called with a successful status."); |
| } |
| var /** @type {?} */ headers = (opts.headers instanceof HttpHeaders) ? opts.headers : new HttpHeaders(opts.headers); |
| this.observer.error(new HttpErrorResponse({ |
| error: error, |
| headers: headers, |
| status: opts.status || 0, |
| statusText: opts.statusText || '', |
| url: this.request.urlWithParams, |
| })); |
| }; |
| /** |
| * Deliver an arbitrary `HttpEvent` (such as a progress event) on the response stream for this |
| * request. |
| */ |
| /** |
| * Deliver an arbitrary `HttpEvent` (such as a progress event) on the response stream for this |
| * request. |
| * @param {?} event |
| * @return {?} |
| */ |
| TestRequest.prototype.event = /** |
| * Deliver an arbitrary `HttpEvent` (such as a progress event) on the response stream for this |
| * request. |
| * @param {?} event |
| * @return {?} |
| */ |
| function (event) { |
| if (this.cancelled) { |
| throw new Error("Cannot send events to a cancelled request."); |
| } |
| this.observer.next(event); |
| }; |
| return TestRequest; |
| }()); |
| /** |
| * Helper function to convert a response body to an ArrayBuffer. |
| * @param {?} body |
| * @return {?} |
| */ |
| function _toArrayBufferBody(body) { |
| if (typeof ArrayBuffer === 'undefined') { |
| throw new Error('ArrayBuffer responses are not supported on this platform.'); |
| } |
| if (body instanceof ArrayBuffer) { |
| return body; |
| } |
| throw new Error('Automatic conversion to ArrayBuffer is not supported for response type.'); |
| } |
| /** |
| * Helper function to convert a response body to a Blob. |
| * @param {?} body |
| * @return {?} |
| */ |
| function _toBlob(body) { |
| if (typeof Blob === 'undefined') { |
| throw new Error('Blob responses are not supported on this platform.'); |
| } |
| if (body instanceof Blob) { |
| return body; |
| } |
| if (ArrayBuffer && body instanceof ArrayBuffer) { |
| return new Blob([body]); |
| } |
| throw new Error('Automatic conversion to Blob is not supported for response type.'); |
| } |
| /** |
| * Helper function to convert a response body to JSON data. |
| * @param {?} body |
| * @param {?=} format |
| * @return {?} |
| */ |
| function _toJsonBody(body, format) { |
| if (format === void 0) { format = 'JSON'; } |
| if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer) { |
| throw new Error("Automatic conversion to " + format + " is not supported for ArrayBuffers."); |
| } |
| if (typeof Blob !== 'undefined' && body instanceof Blob) { |
| throw new Error("Automatic conversion to " + format + " is not supported for Blobs."); |
| } |
| if (typeof body === 'string' || typeof body === 'number' || typeof body === 'object' || |
| Array.isArray(body)) { |
| return body; |
| } |
| throw new Error("Automatic conversion to " + format + " is not supported for response type."); |
| } |
| /** |
| * Helper function to convert a response body to a string. |
| * @param {?} body |
| * @return {?} |
| */ |
| function _toTextBody(body) { |
| if (typeof body === 'string') { |
| return body; |
| } |
| if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer) { |
| throw new Error('Automatic conversion to text is not supported for ArrayBuffers.'); |
| } |
| if (typeof Blob !== 'undefined' && body instanceof Blob) { |
| throw new Error('Automatic conversion to text is not supported for Blobs.'); |
| } |
| return JSON.stringify(_toJsonBody(body, 'text')); |
| } |
| /** |
| * Convert a response body to the requested type. |
| * @param {?} responseType |
| * @param {?} body |
| * @return {?} |
| */ |
| function _maybeConvertBody(responseType, body) { |
| switch (responseType) { |
| case 'arraybuffer': |
| if (body === null) { |
| return null; |
| } |
| return _toArrayBufferBody(body); |
| case 'blob': |
| if (body === null) { |
| return null; |
| } |
| return _toBlob(body); |
| case 'json': |
| if (body === null) { |
| return 'null'; |
| } |
| return _toJsonBody(body); |
| case 'text': |
| if (body === null) { |
| return null; |
| } |
| return _toTextBody(body); |
| default: |
| throw new Error("Unsupported responseType: " + responseType); |
| } |
| } |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes} checked by tsc |
| */ |
| /** |
| * @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 |
| */ |
| /** |
| * A testing backend for `HttpClient` which both acts as an `HttpBackend` |
| * and as the `HttpTestingController`. |
| * |
| * `HttpClientTestingBackend` works by keeping a list of all open requests. |
| * As requests come in, they're added to the list. Users can assert that specific |
| * requests were made and then flush them. In the end, a verify() method asserts |
| * that no unexpected requests were made. |
| * |
| * \@stable |
| */ |
| var HttpClientTestingBackend = /** @class */ (function () { |
| function HttpClientTestingBackend() { |
| /** |
| * List of pending requests which have not yet been expected. |
| */ |
| this.open = []; |
| } |
| /** |
| * Handle an incoming request by queueing it in the list of open requests. |
| */ |
| /** |
| * Handle an incoming request by queueing it in the list of open requests. |
| * @param {?} req |
| * @return {?} |
| */ |
| HttpClientTestingBackend.prototype.handle = /** |
| * Handle an incoming request by queueing it in the list of open requests. |
| * @param {?} req |
| * @return {?} |
| */ |
| function (req) { |
| var _this = this; |
| return new Observable(function (observer) { |
| var /** @type {?} */ testReq = new TestRequest(req, observer); |
| _this.open.push(testReq); |
| observer.next(/** @type {?} */ ({ type: HttpEventType.Sent })); |
| return function () { testReq._cancelled = true; }; |
| }); |
| }; |
| /** |
| * Helper function to search for requests in the list of open requests. |
| * @param {?} match |
| * @return {?} |
| */ |
| HttpClientTestingBackend.prototype._match = /** |
| * Helper function to search for requests in the list of open requests. |
| * @param {?} match |
| * @return {?} |
| */ |
| function (match) { |
| if (typeof match === 'string') { |
| return this.open.filter(function (testReq) { return testReq.request.urlWithParams === match; }); |
| } |
| else if (typeof match === 'function') { |
| return this.open.filter(function (testReq) { return match(testReq.request); }); |
| } |
| else { |
| return this.open.filter(function (testReq) { |
| return (!match.method || testReq.request.method === match.method.toUpperCase()) && |
| (!match.url || testReq.request.urlWithParams === match.url); |
| }); |
| } |
| }; |
| /** |
| * Search for requests in the list of open requests, and return all that match |
| * without asserting anything about the number of matches. |
| */ |
| /** |
| * Search for requests in the list of open requests, and return all that match |
| * without asserting anything about the number of matches. |
| * @param {?} match |
| * @return {?} |
| */ |
| HttpClientTestingBackend.prototype.match = /** |
| * Search for requests in the list of open requests, and return all that match |
| * without asserting anything about the number of matches. |
| * @param {?} match |
| * @return {?} |
| */ |
| function (match) { |
| var _this = this; |
| var /** @type {?} */ results = this._match(match); |
| results.forEach(function (result) { |
| var /** @type {?} */ index = _this.open.indexOf(result); |
| if (index !== -1) { |
| _this.open.splice(index, 1); |
| } |
| }); |
| return results; |
| }; |
| /** |
| * Expect that a single outstanding request matches the given matcher, and return |
| * it. |
| * |
| * Requests returned through this API will no longer be in the list of open requests, |
| * and thus will not match twice. |
| */ |
| /** |
| * Expect that a single outstanding request matches the given matcher, and return |
| * it. |
| * |
| * Requests returned through this API will no longer be in the list of open requests, |
| * and thus will not match twice. |
| * @param {?} match |
| * @param {?=} description |
| * @return {?} |
| */ |
| HttpClientTestingBackend.prototype.expectOne = /** |
| * Expect that a single outstanding request matches the given matcher, and return |
| * it. |
| * |
| * Requests returned through this API will no longer be in the list of open requests, |
| * and thus will not match twice. |
| * @param {?} match |
| * @param {?=} description |
| * @return {?} |
| */ |
| function (match, description) { |
| description = description || this.descriptionFromMatcher(match); |
| var /** @type {?} */ matches = this.match(match); |
| if (matches.length > 1) { |
| throw new Error("Expected one matching request for criteria \"" + description + "\", found " + matches.length + " requests."); |
| } |
| if (matches.length === 0) { |
| throw new Error("Expected one matching request for criteria \"" + description + "\", found none."); |
| } |
| return matches[0]; |
| }; |
| /** |
| * Expect that no outstanding requests match the given matcher, and throw an error |
| * if any do. |
| */ |
| /** |
| * Expect that no outstanding requests match the given matcher, and throw an error |
| * if any do. |
| * @param {?} match |
| * @param {?=} description |
| * @return {?} |
| */ |
| HttpClientTestingBackend.prototype.expectNone = /** |
| * Expect that no outstanding requests match the given matcher, and throw an error |
| * if any do. |
| * @param {?} match |
| * @param {?=} description |
| * @return {?} |
| */ |
| function (match, description) { |
| description = description || this.descriptionFromMatcher(match); |
| var /** @type {?} */ matches = this.match(match); |
| if (matches.length > 0) { |
| throw new Error("Expected zero matching requests for criteria \"" + description + "\", found " + matches.length + "."); |
| } |
| }; |
| /** |
| * Validate that there are no outstanding requests. |
| */ |
| /** |
| * Validate that there are no outstanding requests. |
| * @param {?=} opts |
| * @return {?} |
| */ |
| HttpClientTestingBackend.prototype.verify = /** |
| * Validate that there are no outstanding requests. |
| * @param {?=} opts |
| * @return {?} |
| */ |
| function (opts) { |
| if (opts === void 0) { opts = {}; } |
| var /** @type {?} */ open = this.open; |
| // It's possible that some requests may be cancelled, and this is expected. |
| // The user can ask to ignore open requests which have been cancelled. |
| if (opts.ignoreCancelled) { |
| open = open.filter(function (testReq) { return !testReq.cancelled; }); |
| } |
| if (open.length > 0) { |
| // Show the methods and URLs of open requests in the error, for convenience. |
| var /** @type {?} */ requests = open.map(function (testReq) { |
| var /** @type {?} */ url = testReq.request.urlWithParams.split('?')[0]; |
| var /** @type {?} */ method = testReq.request.method; |
| return method + " " + url; |
| }) |
| .join(', '); |
| throw new Error("Expected no open requests, found " + open.length + ": " + requests); |
| } |
| }; |
| /** |
| * @param {?} matcher |
| * @return {?} |
| */ |
| HttpClientTestingBackend.prototype.descriptionFromMatcher = /** |
| * @param {?} matcher |
| * @return {?} |
| */ |
| function (matcher) { |
| if (typeof matcher === 'string') { |
| return "Match URL: " + matcher; |
| } |
| else if (typeof matcher === 'object') { |
| var /** @type {?} */ method = matcher.method || '(any)'; |
| var /** @type {?} */ url = matcher.url || '(any)'; |
| return "Match method: " + method + ", URL: " + url; |
| } |
| else { |
| return "Match by function: " + matcher.name; |
| } |
| }; |
| HttpClientTestingBackend.decorators = [ |
| { type: Injectable }, |
| ]; |
| /** @nocollapse */ |
| HttpClientTestingBackend.ctorParameters = function () { return []; }; |
| return HttpClientTestingBackend; |
| }()); |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes} checked by tsc |
| */ |
| /** |
| * @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 |
| */ |
| /** |
| * Configures `HttpClientTestingBackend` as the `HttpBackend` used by `HttpClient`. |
| * |
| * Inject `HttpTestingController` to expect and flush requests in your tests. |
| * |
| * \@stable |
| */ |
| var HttpClientTestingModule = /** @class */ (function () { |
| function HttpClientTestingModule() { |
| } |
| HttpClientTestingModule.decorators = [ |
| { type: NgModule, args: [{ |
| imports: [ |
| HttpClientModule, |
| ], |
| providers: [ |
| HttpClientTestingBackend, |
| { provide: HttpBackend, useExisting: HttpClientTestingBackend }, |
| { provide: HttpTestingController, useExisting: HttpClientTestingBackend }, |
| ], |
| },] }, |
| ]; |
| /** @nocollapse */ |
| HttpClientTestingModule.ctorParameters = function () { return []; }; |
| return HttpClientTestingModule; |
| }()); |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes} checked by tsc |
| */ |
| /** |
| * @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 |
| */ |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes} checked by tsc |
| */ |
| /** |
| * Generated bundle index. Do not edit. |
| */ |
| |
| export { HttpTestingController, HttpClientTestingModule, TestRequest, HttpClientTestingBackend as ɵa }; |
| //# sourceMappingURL=testing.js.map |
