@angular/common
Version:
Angular - commonly needed directives and services
211 lines • 18.7 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} 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
*/
import { HttpEventType } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { TestRequest } from './request';
/**
* 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.
*
*
*/
export class HttpClientTestingBackend {
constructor() {
/**
* 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.
* @param {?} req
* @return {?}
*/
handle(req) {
return new Observable((/**
* @param {?} observer
* @return {?}
*/
(observer) => {
/** @type {?} */
const testReq = new TestRequest(req, observer);
this.open.push(testReq);
observer.next((/** @type {?} */ ({ type: HttpEventType.Sent })));
return (/**
* @return {?}
*/
() => { testReq._cancelled = true; });
}));
}
/**
* Helper function to search for requests in the list of open requests.
* @private
* @param {?} match
* @return {?}
*/
_match(match) {
if (typeof match === 'string') {
return this.open.filter((/**
* @param {?} testReq
* @return {?}
*/
testReq => testReq.request.urlWithParams === match));
}
else if (typeof match === 'function') {
return this.open.filter((/**
* @param {?} testReq
* @return {?}
*/
testReq => match(testReq.request)));
}
else {
return this.open.filter((/**
* @param {?} testReq
* @return {?}
*/
testReq => (!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.
* @param {?} match
* @return {?}
*/
match(match) {
/** @type {?} */
const results = this._match(match);
results.forEach((/**
* @param {?} result
* @return {?}
*/
result => {
/** @type {?} */
const 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.
* @param {?} match
* @param {?=} description
* @return {?}
*/
expectOne(match, description) {
description = description || this.descriptionFromMatcher(match);
/** @type {?} */
const 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.
* @param {?} match
* @param {?=} description
* @return {?}
*/
expectNone(match, description) {
description = description || this.descriptionFromMatcher(match);
/** @type {?} */
const 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.
* @param {?=} opts
* @return {?}
*/
verify(opts = {}) {
/** @type {?} */
let 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((/**
* @param {?} testReq
* @return {?}
*/
testReq => !testReq.cancelled));
}
if (open.length > 0) {
// Show the methods and URLs of open requests in the error, for convenience.
/** @type {?} */
const requests = open.map((/**
* @param {?} testReq
* @return {?}
*/
testReq => {
/** @type {?} */
const url = testReq.request.urlWithParams.split('?')[0];
/** @type {?} */
const method = testReq.request.method;
return `${method} ${url}`;
}))
.join(', ');
throw new Error(`Expected no open requests, found ${open.length}: ${requests}`);
}
}
/**
* @private
* @param {?} matcher
* @return {?}
*/
descriptionFromMatcher(matcher) {
if (typeof matcher === 'string') {
return `Match URL: ${matcher}`;
}
else if (typeof matcher === 'object') {
/** @type {?} */
const method = matcher.method || '(any)';
/** @type {?} */
const url = matcher.url || '(any)';
return `Match method: ${method}, URL: ${url}`;
}
else {
return `Match by function: ${matcher.name}`;
}
}
}
HttpClientTestingBackend.decorators = [
{ type: Injectable }
];
if (false) {
/**
* List of pending requests which have not yet been expected.
* @type {?}
* @private
*/
HttpClientTestingBackend.prototype.open;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backend.js","sourceRoot":"","sources":["../../../../../../../../packages/common/http/testing/src/backend.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {HttpBackend, HttpEvent, HttpEventType, HttpRequest} from '@angular/common/http';\nimport {Injectable} from '@angular/core';\nimport {Observable, Observer} from 'rxjs';\n\nimport {HttpTestingController, RequestMatch} from './api';\nimport {TestRequest} from './request';\n\n\n/**\n * A testing backend for `HttpClient` which both acts as an `HttpBackend`\n * and as the `HttpTestingController`.\n *\n * `HttpClientTestingBackend` works by keeping a list of all open requests.\n * As requests come in, they're added to the list. Users can assert that specific\n * requests were made and then flush them. In the end, a verify() method asserts\n * that no unexpected requests were made.\n *\n *\n */\n@Injectable()\nexport class HttpClientTestingBackend implements HttpBackend, HttpTestingController {\n  /**\n   * List of pending requests which have not yet been expected.\n   */\n  private open: TestRequest[] = [];\n\n  /**\n   * Handle an incoming request by queueing it in the list of open requests.\n   */\n  handle(req: HttpRequest<any>): Observable<HttpEvent<any>> {\n    return new Observable((observer: Observer<any>) => {\n      const testReq = new TestRequest(req, observer);\n      this.open.push(testReq);\n      observer.next({ type: HttpEventType.Sent } as HttpEvent<any>);\n      return () => { testReq._cancelled = true; };\n    });\n  }\n\n  /**\n   * Helper function to search for requests in the list of open requests.\n   */\n  private _match(match: string|RequestMatch|((req: HttpRequest<any>) => boolean)): TestRequest[] {\n    if (typeof match === 'string') {\n      return this.open.filter(testReq => testReq.request.urlWithParams === match);\n    } else if (typeof match === 'function') {\n      return this.open.filter(testReq => match(testReq.request));\n    } else {\n      return this.open.filter(\n          testReq => (!match.method || testReq.request.method === match.method.toUpperCase()) &&\n              (!match.url || testReq.request.urlWithParams === match.url));\n    }\n  }\n\n  /**\n   * Search for requests in the list of open requests, and return all that match\n   * without asserting anything about the number of matches.\n   */\n  match(match: string|RequestMatch|((req: HttpRequest<any>) => boolean)): TestRequest[] {\n    const results = this._match(match);\n    results.forEach(result => {\n      const index = this.open.indexOf(result);\n      if (index !== -1) {\n        this.open.splice(index, 1);\n      }\n    });\n    return results;\n  }\n\n  /**\n   * Expect that a single outstanding request matches the given matcher, and return\n   * it.\n   *\n   * Requests returned through this API will no longer be in the list of open requests,\n   * and thus will not match twice.\n   */\n  expectOne(match: string|RequestMatch|((req: HttpRequest<any>) => boolean), description?: string):\n      TestRequest {\n    description = description || this.descriptionFromMatcher(match);\n    const matches = this.match(match);\n    if (matches.length > 1) {\n      throw new Error(\n          `Expected one matching request for criteria \"${description}\", found ${matches.length} requests.`);\n    }\n    if (matches.length === 0) {\n      throw new Error(`Expected one matching request for criteria \"${description}\", found none.`);\n    }\n    return matches[0];\n  }\n\n  /**\n   * Expect that no outstanding requests match the given matcher, and throw an error\n   * if any do.\n   */\n  expectNone(match: string|RequestMatch|((req: HttpRequest<any>) => boolean), description?: string):\n      void {\n    description = description || this.descriptionFromMatcher(match);\n    const matches = this.match(match);\n    if (matches.length > 0) {\n      throw new Error(\n          `Expected zero matching requests for criteria \"${description}\", found ${matches.length}.`);\n    }\n  }\n\n  /**\n   * Validate that there are no outstanding requests.\n   */\n  verify(opts: {ignoreCancelled?: boolean} = {}): void {\n    let open = this.open;\n    // It's possible that some requests may be cancelled, and this is expected.\n    // The user can ask to ignore open requests which have been cancelled.\n    if (opts.ignoreCancelled) {\n      open = open.filter(testReq => !testReq.cancelled);\n    }\n    if (open.length > 0) {\n      // Show the methods and URLs of open requests in the error, for convenience.\n      const requests = open.map(testReq => {\n                             const url = testReq.request.urlWithParams.split('?')[0];\n                             const method = testReq.request.method;\n                             return `${method} ${url}`;\n                           })\n                           .join(', ');\n      throw new Error(`Expected no open requests, found ${open.length}: ${requests}`);\n    }\n  }\n\n  private descriptionFromMatcher(matcher: string|RequestMatch|\n                                 ((req: HttpRequest<any>) => boolean)): string {\n    if (typeof matcher === 'string') {\n      return `Match URL: ${matcher}`;\n    } else if (typeof matcher === 'object') {\n      const method = matcher.method || '(any)';\n      const url = matcher.url || '(any)';\n      return `Match method: ${method}, URL: ${url}`;\n    } else {\n      return `Match by function: ${matcher.name}`;\n    }\n  }\n}\n"]}