@angular/common
Version:
Angular - commonly needed directives and services
143 lines • 18 kB
JavaScript
/**
* @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 * as tslib_1 from "tslib";
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.
*
*
*/
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.
*/
HttpClientTestingBackend.prototype.handle = function (req) {
var _this = this;
return new Observable(function (observer) {
var testReq = new TestRequest(req, observer);
_this.open.push(testReq);
observer.next({ type: HttpEventType.Sent });
return function () { testReq._cancelled = true; };
});
};
/**
* Helper function to search for requests in the list of open requests.
*/
HttpClientTestingBackend.prototype._match = 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.
*/
HttpClientTestingBackend.prototype.match = function (match) {
var _this = this;
var results = this._match(match);
results.forEach(function (result) {
var 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.
*/
HttpClientTestingBackend.prototype.expectOne = function (match, description) {
description = description || this.descriptionFromMatcher(match);
var 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.
*/
HttpClientTestingBackend.prototype.expectNone = function (match, description) {
description = description || this.descriptionFromMatcher(match);
var 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.
*/
HttpClientTestingBackend.prototype.verify = function (opts) {
if (opts === void 0) { opts = {}; }
var 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 requests = open.map(function (testReq) {
var url = testReq.request.urlWithParams.split('?')[0];
var method = testReq.request.method;
return method + " " + url;
})
.join(', ');
throw new Error("Expected no open requests, found " + open.length + ": " + requests);
}
};
HttpClientTestingBackend.prototype.descriptionFromMatcher = function (matcher) {
if (typeof matcher === 'string') {
return "Match URL: " + matcher;
}
else if (typeof matcher === 'object') {
var method = matcher.method || '(any)';
var url = matcher.url || '(any)';
return "Match method: " + method + ", URL: " + url;
}
else {
return "Match by function: " + matcher.name;
}
};
HttpClientTestingBackend = tslib_1.__decorate([
Injectable()
], HttpClientTestingBackend);
return HttpClientTestingBackend;
}());
export { HttpClientTestingBackend };
//# 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"]}