@apollo/client 3.13.9-rc.0 → 3.13.9

package/testing/core/core.cjs.native.js

@@ -0,0 +1,370 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var globals = require('../../utilities/globals');
+var equality = require('@wry/equality');
+var core = require('../../link/core');
+var utilities = require('../../utilities');
+var core$1 = require('../../core');
+var cache = require('../../cache');
+
+function requestToKey(request, addTypename) {
+    var queryString = request.query &&
+        utilities.print(addTypename ? utilities.addTypenameToDocument(request.query) : request.query);
+    var requestKey = { query: queryString };
+    return JSON.stringify(requestKey);
+}
+var MockLink =  (function (_super) {
+    tslib.__extends(MockLink, _super);
+    function MockLink(mockedResponses, addTypename, options) {
+        if (addTypename === void 0) { addTypename = true; }
+        if (options === void 0) { options = Object.create(null); }
+        var _a;
+        var _this = _super.call(this) || this;
+        _this.addTypename = true;
+        _this.showWarnings = true;
+        _this.mockedResponsesByKey = {};
+        _this.addTypename = addTypename;
+        _this.showWarnings = (_a = options.showWarnings) !== null && _a !== void 0 ? _a : true;
+        if (mockedResponses) {
+            mockedResponses.forEach(function (mockedResponse) {
+                _this.addMockedResponse(mockedResponse);
+            });
+        }
+        return _this;
+    }
+    MockLink.prototype.addMockedResponse = function (mockedResponse) {
+        var normalizedMockedResponse = this.normalizeMockedResponse(mockedResponse);
+        var key = requestToKey(normalizedMockedResponse.request, this.addTypename);
+        var mockedResponses = this.mockedResponsesByKey[key];
+        if (!mockedResponses) {
+            mockedResponses = [];
+            this.mockedResponsesByKey[key] = mockedResponses;
+        }
+        mockedResponses.push(normalizedMockedResponse);
+    };
+    MockLink.prototype.request = function (operation) {
+        var _this = this;
+        var _a;
+        this.operation = operation;
+        var key = requestToKey(operation, this.addTypename);
+        var unmatchedVars = [];
+        var requestVariables = operation.variables || {};
+        var mockedResponses = this.mockedResponsesByKey[key];
+        var responseIndex = mockedResponses ?
+            mockedResponses.findIndex(function (res, index) {
+                var mockedResponseVars = res.request.variables || {};
+                if (equality.equal(requestVariables, mockedResponseVars)) {
+                    return true;
+                }
+                if (res.variableMatcher && res.variableMatcher(operation.variables)) {
+                    return true;
+                }
+                unmatchedVars.push(mockedResponseVars);
+                return false;
+            })
+            : -1;
+        var response = responseIndex >= 0 ? mockedResponses[responseIndex] : void 0;
+        var delay = (response === null || response === void 0 ? void 0 : response.delay) === Infinity ? 0 : (_a = response === null || response === void 0 ? void 0 : response.delay) !== null && _a !== void 0 ? _a : 0;
+        var configError;
+        if (!response) {
+            configError = new Error("No more mocked responses for the query: ".concat(utilities.print(operation.query), "\nExpected variables: ").concat(stringifyForDebugging(operation.variables), "\n").concat(unmatchedVars.length > 0 ?
+                "\nFailed to match ".concat(unmatchedVars.length, " mock").concat(unmatchedVars.length === 1 ? "" : "s", " for this query. The mocked response had the following variables:\n").concat(unmatchedVars.map(function (d) { return "  ".concat(stringifyForDebugging(d)); }).join("\n"), "\n")
+                : ""));
+            if (this.showWarnings) {
+                console.warn(configError.message +
+                    "\nThis typically indicates a configuration error in your mocks " +
+                    "setup, usually due to a typo or mismatched variable.");
+            }
+        }
+        else {
+            if (response.maxUsageCount && response.maxUsageCount > 1) {
+                response.maxUsageCount--;
+            }
+            else {
+                mockedResponses.splice(responseIndex, 1);
+            }
+            var newData = response.newData;
+            if (newData) {
+                response.result = newData(operation.variables);
+                mockedResponses.push(response);
+            }
+            if (!response.result && !response.error && response.delay !== Infinity) {
+                configError = new Error("Mocked response should contain either `result`, `error` or a `delay` of `Infinity`: ".concat(key));
+            }
+        }
+        return new utilities.Observable(function (observer) {
+            var timer = setTimeout(function () {
+                if (configError) {
+                    try {
+                        if (_this.onError(configError, observer) !== false) {
+                            throw configError;
+                        }
+                    }
+                    catch (error) {
+                        observer.error(error);
+                    }
+                }
+                else if (response && response.delay !== Infinity) {
+                    if (response.error) {
+                        observer.error(response.error);
+                    }
+                    else {
+                        if (response.result) {
+                            observer.next(typeof response.result === "function" ?
+                                response.result(operation.variables)
+                                : response.result);
+                        }
+                        observer.complete();
+                    }
+                }
+            }, delay);
+            return function () {
+                clearTimeout(timer);
+            };
+        });
+    };
+    MockLink.prototype.normalizeMockedResponse = function (mockedResponse) {
+        var _a;
+        var newMockedResponse = utilities.cloneDeep(mockedResponse);
+        var queryWithoutClientOnlyDirectives = utilities.removeDirectivesFromDocument([{ name: "connection" }, { name: "nonreactive" }, { name: "unmask" }], utilities.checkDocument(newMockedResponse.request.query));
+        globals.invariant(queryWithoutClientOnlyDirectives, 75);
+        newMockedResponse.request.query = queryWithoutClientOnlyDirectives;
+        var query = utilities.removeClientSetsFromDocument(newMockedResponse.request.query);
+        if (query) {
+            newMockedResponse.request.query = query;
+        }
+        mockedResponse.maxUsageCount = (_a = mockedResponse.maxUsageCount) !== null && _a !== void 0 ? _a : 1;
+        globals.invariant(mockedResponse.maxUsageCount > 0, 76, mockedResponse.maxUsageCount);
+        this.normalizeVariableMatching(newMockedResponse);
+        return newMockedResponse;
+    };
+    MockLink.prototype.normalizeVariableMatching = function (mockedResponse) {
+        var request = mockedResponse.request;
+        if (mockedResponse.variableMatcher && request.variables) {
+            throw new Error("Mocked response should contain either variableMatcher or request.variables");
+        }
+        if (!mockedResponse.variableMatcher) {
+            request.variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(utilities.getOperationDefinition(request.query))), request.variables);
+            mockedResponse.variableMatcher = function (vars) {
+                var requestVariables = vars || {};
+                var mockedResponseVariables = request.variables || {};
+                return equality.equal(requestVariables, mockedResponseVariables);
+            };
+        }
+    };
+    return MockLink;
+}(core.ApolloLink));
+function mockSingleLink() {
+    var mockedResponses = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        mockedResponses[_i] = arguments[_i];
+    }
+    var maybeTypename = mockedResponses[mockedResponses.length - 1];
+    var mocks = mockedResponses.slice(0, mockedResponses.length - 1);
+    if (typeof maybeTypename !== "boolean") {
+        mocks = mockedResponses;
+        maybeTypename = true;
+    }
+    return new MockLink(mocks, maybeTypename);
+}
+function stringifyForDebugging(value, space) {
+    if (space === void 0) { space = 0; }
+    var undefId = utilities.makeUniqueId("undefined");
+    var nanId = utilities.makeUniqueId("NaN");
+    return JSON.stringify(value, function (_, value) {
+        if (value === void 0) {
+            return undefId;
+        }
+        if (Number.isNaN(value)) {
+            return nanId;
+        }
+        return value;
+    }, space)
+        .replace(new RegExp(JSON.stringify(undefId), "g"), "<undefined>")
+        .replace(new RegExp(JSON.stringify(nanId), "g"), "NaN");
+}
+
+var MockSubscriptionLink =  (function (_super) {
+    tslib.__extends(MockSubscriptionLink, _super);
+    function MockSubscriptionLink() {
+        var _this = _super.call(this) || this;
+        _this.unsubscribers = [];
+        _this.setups = [];
+        _this.observers = [];
+        return _this;
+    }
+    MockSubscriptionLink.prototype.request = function (operation) {
+        var _this = this;
+        this.operation = operation;
+        return new utilities.Observable(function (observer) {
+            _this.setups.forEach(function (x) { return x(); });
+            _this.observers.push(observer);
+            return function () {
+                _this.unsubscribers.forEach(function (x) { return x(); });
+            };
+        });
+    };
+    MockSubscriptionLink.prototype.simulateResult = function (result, complete) {
+        var _this = this;
+        if (complete === void 0) { complete = false; }
+        setTimeout(function () {
+            var observers = _this.observers;
+            if (!observers.length)
+                throw new Error("subscription torn down");
+            observers.forEach(function (observer) {
+                if (result.result && observer.next)
+                    observer.next(result.result);
+                if (result.error && observer.error)
+                    observer.error(result.error);
+                if (complete && observer.complete)
+                    observer.complete();
+            });
+        }, result.delay || 0);
+    };
+    MockSubscriptionLink.prototype.simulateComplete = function () {
+        var observers = this.observers;
+        if (!observers.length)
+            throw new Error("subscription torn down");
+        observers.forEach(function (observer) {
+            if (observer.complete)
+                observer.complete();
+        });
+    };
+    MockSubscriptionLink.prototype.onSetup = function (listener) {
+        this.setups = this.setups.concat([listener]);
+    };
+    MockSubscriptionLink.prototype.onUnsubscribe = function (listener) {
+        this.unsubscribers = this.unsubscribers.concat([listener]);
+    };
+    return MockSubscriptionLink;
+}(core.ApolloLink));
+function mockObservableLink() {
+    return new MockSubscriptionLink();
+}
+
+function createMockClient(data, query, variables) {
+    if (variables === void 0) { variables = {}; }
+    return new core$1.ApolloClient({
+        link: mockSingleLink({
+            request: { query: query, variables: variables },
+            result: { data: data },
+        }).setOnError(function (error) {
+            throw error;
+        }),
+        cache: new cache.InMemoryCache({ addTypename: false }),
+    });
+}
+
+function subscribeAndCount(reject, observable, cb) {
+    var queue = Promise.resolve();
+    var handleCount = 0;
+    var subscription = utilities.asyncMap(observable, function (result) {
+        return (queue = queue
+            .then(function () {
+            return cb(++handleCount, result);
+        })
+            .catch(error));
+    }).subscribe({ error: error });
+    function error(e) {
+        subscription.unsubscribe();
+        reject(e);
+    }
+    return subscription;
+}
+
+function wrap(key) {
+    return function (message, callback, timeout) {
+        return (key ? it[key] : it)(message, function () {
+            var _this = this;
+            return new Promise(function (resolve, reject) {
+                return callback.call(_this, resolve, reject);
+            });
+        }, timeout);
+    };
+}
+var wrappedIt = wrap();
+var itAsync = Object.assign(function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return wrappedIt.apply(this, args);
+}, {
+    only: wrap("only"),
+    skip: wrap("skip"),
+    todo: wrap("todo"),
+});
+
+function wait(ms) {
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        return tslib.__generator(this, function (_a) {
+            return [2 , new Promise(function (resolve) { return setTimeout(resolve, ms); })];
+        });
+    });
+}
+function tick() {
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        return tslib.__generator(this, function (_a) {
+            return [2 , wait(0)];
+        });
+    });
+}
+
+function wrapTestFunction(fn, consoleMethodName) {
+    return function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var spy = jest.spyOn(console, consoleMethodName);
+        spy.mockImplementation(function () { });
+        return new Promise(function (resolve) {
+            resolve(fn === null || fn === void 0 ? void 0 : fn.apply(_this, args));
+        }).finally(function () {
+            expect(spy).toMatchSnapshot();
+            spy.mockReset();
+        });
+    };
+}
+function withErrorSpy(it) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    args[1] = wrapTestFunction(args[1], "error");
+    return it.apply(void 0, args);
+}
+function withWarningSpy(it) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    args[1] = wrapTestFunction(args[1], "warn");
+    return it.apply(void 0, args);
+}
+function withLogSpy(it) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    args[1] = wrapTestFunction(args[1], "log");
+    return it.apply(void 0, args);
+}
+
+exports.MockLink = MockLink;
+exports.MockSubscriptionLink = MockSubscriptionLink;
+exports.createMockClient = createMockClient;
+exports.itAsync = itAsync;
+exports.mockObservableLink = mockObservableLink;
+exports.mockSingleLink = mockSingleLink;
+exports.subscribeAndCount = subscribeAndCount;
+exports.tick = tick;
+exports.wait = wait;
+exports.withErrorSpy = withErrorSpy;
+exports.withLogSpy = withLogSpy;
+exports.withWarningSpy = withWarningSpy;
+//# sourceMappingURL=core.cjs.map

package/testing/core/core.d.cts

@@ -0,0 +1 @@
+export * from "./index.d.ts";

package/testing/core/index.d.ts

@@ -0,0 +1,9 @@
+export type { MockedResponse, MockLinkOptions, ResultFunction, } from "./mocking/mockLink.js";
+export { MockLink, mockSingleLink } from "./mocking/mockLink.js";
+export { MockSubscriptionLink, mockObservableLink, } from "./mocking/mockSubscriptionLink.js";
+export { createMockClient } from "./mocking/mockClient.js";
+export { default as subscribeAndCount } from "./subscribeAndCount.js";
+export { itAsync } from "./itAsync.js";
+export { wait, tick } from "./wait.js";
+export * from "./withConsoleSpy.js";
+//# sourceMappingURL=index.d.ts.map

package/testing/core/index.js

@@ -0,0 +1,8 @@
+export { MockLink, mockSingleLink } from "./mocking/mockLink.js";
+export { MockSubscriptionLink, mockObservableLink, } from "./mocking/mockSubscriptionLink.js";
+export { createMockClient } from "./mocking/mockClient.js";
+export { default as subscribeAndCount } from "./subscribeAndCount.js";
+export { itAsync } from "./itAsync.js";
+export { wait, tick } from "./wait.js";
+export * from "./withConsoleSpy.js";
+//# sourceMappingURL=index.js.map

package/testing/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/testing/core/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EACL,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACvC,cAAc,qBAAqB,CAAC","sourcesContent":["export type {\n  MockedResponse,\n  MockLinkOptions,\n  ResultFunction,\n} from \"./mocking/mockLink.js\";\nexport { MockLink, mockSingleLink } from \"./mocking/mockLink.js\";\nexport {\n  MockSubscriptionLink,\n  mockObservableLink,\n} from \"./mocking/mockSubscriptionLink.js\";\nexport { createMockClient } from \"./mocking/mockClient.js\";\nexport { default as subscribeAndCount } from \"./subscribeAndCount.js\";\nexport { itAsync } from \"./itAsync.js\";\nexport { wait, tick } from \"./wait.js\";\nexport * from \"./withConsoleSpy.js\";\n"]}

package/testing/core/itAsync.d.ts

@@ -0,0 +1,6 @@
+export declare const itAsync: ((this: unknown, message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number | undefined) => void) & {
+    only: (message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number) => void;
+    skip: (message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number) => void;
+    todo: (message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number) => void;
+};
+//# sourceMappingURL=itAsync.d.ts.map

package/testing/core/itAsync.js

@@ -0,0 +1,23 @@
+function wrap(key) {
+    return function (message, callback, timeout) {
+        return (key ? it[key] : it)(message, function () {
+            var _this = this;
+            return new Promise(function (resolve, reject) {
+                return callback.call(_this, resolve, reject);
+            });
+        }, timeout);
+    };
+}
+var wrappedIt = wrap();
+export var itAsync = Object.assign(function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return wrappedIt.apply(this, args);
+}, {
+    only: wrap("only"),
+    skip: wrap("skip"),
+    todo: wrap("todo"),
+});
+//# sourceMappingURL=itAsync.js.map

package/testing/core/itAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"itAsync.js","sourceRoot":"","sources":["../../../src/testing/core/itAsync.ts"],"names":[],"mappings":"AAAA,SAAS,IAAI,CAAC,GAA8B;IAC1C,OAAO,UACL,OAAe,EACf,QAGQ,EACR,OAAgB;QAEhB,OAAA,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAClB,OAAO,EACP;YAAA,iBAIC;YAHC,OAAO,IAAI,OAAO,CAAC,UAAC,OAAO,EAAE,MAAM;gBACjC,OAAA,QAAQ,CAAC,IAAI,CAAC,KAAI,EAAE,OAAO,EAAE,MAAM,CAAC;YAApC,CAAoC,CACrC,CAAC;QACJ,CAAC,EACD,OAAO,CACR;IARD,CAQC,CAAC;AACN,CAAC;AAED,IAAM,SAAS,GAAG,IAAI,EAAE,CAAC;AAEzB,MAAM,CAAC,IAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAClC;IAAyB,cAAqC;SAArC,UAAqC,EAArC,qBAAqC,EAArC,IAAqC;QAArC,yBAAqC;;IAC5D,OAAO,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACrC,CAAC,EACD;IACE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;IAClB,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;IAClB,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;CACnB,CACF,CAAC","sourcesContent":["function wrap(key?: \"only\" | \"skip\" | \"todo\") {\n  return (\n    message: string,\n    callback: (\n      resolve: (result?: any) => void,\n      reject: (reason?: any) => void\n    ) => any,\n    timeout?: number\n  ) =>\n    (key ? it[key] : it)(\n      message,\n      function (this: unknown) {\n        return new Promise((resolve, reject) =>\n          callback.call(this, resolve, reject)\n        );\n      },\n      timeout\n    );\n}\n\nconst wrappedIt = wrap();\n\nexport const itAsync = Object.assign(\n  function (this: unknown, ...args: Parameters<typeof wrappedIt>) {\n    return wrappedIt.apply(this, args);\n  },\n  {\n    only: wrap(\"only\"),\n    skip: wrap(\"skip\"),\n    todo: wrap(\"todo\"),\n  }\n);\n"]}

package/testing/core/mocking/mockClient.d.ts

@@ -0,0 +1,5 @@
+import type { DocumentNode } from "graphql";
+import { ApolloClient } from "../../../core/index.js";
+import type { NormalizedCacheObject } from "../../../cache/index.js";
+export declare function createMockClient<TData>(data: TData, query: DocumentNode, variables?: {}): ApolloClient<NormalizedCacheObject>;
+//# sourceMappingURL=mockClient.d.ts.map

package/testing/core/mocking/mockClient.js

@@ -0,0 +1,16 @@
+import { ApolloClient } from "../../../core/index.js";
+import { InMemoryCache } from "../../../cache/index.js";
+import { mockSingleLink } from "./mockLink.js";
+export function createMockClient(data, query, variables) {
+    if (variables === void 0) { variables = {}; }
+    return new ApolloClient({
+        link: mockSingleLink({
+            request: { query: query, variables: variables },
+            result: { data: data },
+        }).setOnError(function (error) {
+            throw error;
+        }),
+        cache: new InMemoryCache({ addTypename: false }),
+    });
+}
+//# sourceMappingURL=mockClient.js.map

package/testing/core/mocking/mockClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockClient.js","sourceRoot":"","sources":["../../../../src/testing/core/mocking/mockClient.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,MAAM,UAAU,gBAAgB,CAC9B,IAAW,EACX,KAAmB,EACnB,SAAc;IAAd,0BAAA,EAAA,cAAc;IAEd,OAAO,IAAI,YAAY,CAAC;QACtB,IAAI,EAAE,cAAc,CAAC;YACnB,OAAO,EAAE,EAAE,KAAK,OAAA,EAAE,SAAS,WAAA,EAAE;YAC7B,MAAM,EAAE,EAAE,IAAI,MAAA,EAAE;SACjB,CAAC,CAAC,UAAU,CAAC,UAAC,KAAK;YAClB,MAAM,KAAK,CAAC;QACd,CAAC,CAAC;QACF,KAAK,EAAE,IAAI,aAAa,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;KACjD,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { DocumentNode } from \"graphql\";\n\nimport { ApolloClient } from \"../../../core/index.js\";\nimport type { NormalizedCacheObject } from \"../../../cache/index.js\";\nimport { InMemoryCache } from \"../../../cache/index.js\";\nimport { mockSingleLink } from \"./mockLink.js\";\n\nexport function createMockClient<TData>(\n  data: TData,\n  query: DocumentNode,\n  variables = {}\n): ApolloClient<NormalizedCacheObject> {\n  return new ApolloClient({\n    link: mockSingleLink({\n      request: { query, variables },\n      result: { data },\n    }).setOnError((error) => {\n      throw error;\n    }),\n    cache: new InMemoryCache({ addTypename: false }),\n  });\n}\n"]}

package/testing/core/mocking/mockFetch.d.ts

@@ -0,0 +1,24 @@
+import "whatwg-fetch";
+export interface MockedIResponse {
+    ok: boolean;
+    status: number;
+    statusText?: string;
+    json(): Promise<Object>;
+}
+export interface MockedFetchResponse {
+    url: string;
+    opts: RequestInit;
+    result: MockedIResponse;
+    delay?: number;
+}
+export declare function createMockedIResponse(result: Object, options?: any): MockedIResponse;
+export declare class MockFetch {
+    private mockedResponsesByKey;
+    constructor(...mockedResponses: MockedFetchResponse[]);
+    addMockedResponse(mockedResponse: MockedFetchResponse): void;
+    fetch(url: string, opts: RequestInit): Promise<unknown>;
+    fetchParamsToKey(url: string, opts: RequestInit): string;
+    getFetch(): (url: string, opts: RequestInit) => Promise<unknown>;
+}
+export declare function createMockFetch(...mockedResponses: MockedFetchResponse[]): (url: string, opts: RequestInit) => Promise<unknown>;
+//# sourceMappingURL=mockFetch.d.ts.map

package/testing/core/mocking/mockFetch.js

@@ -0,0 +1,87 @@
+import { __spreadArray } from "tslib";
+import "whatwg-fetch";
+export function createMockedIResponse(result, options) {
+    var status = (options && options.status) || 200;
+    var statusText = (options && options.statusText) || undefined;
+    return {
+        ok: status === 200,
+        status: status,
+        statusText: statusText,
+        json: function () {
+            return Promise.resolve(result);
+        },
+    };
+}
+var MockFetch = /** @class */ (function () {
+    function MockFetch() {
+        var mockedResponses = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            mockedResponses[_i] = arguments[_i];
+        }
+        var _this = this;
+        this.mockedResponsesByKey = {};
+        mockedResponses.forEach(function (mockedResponse) {
+            _this.addMockedResponse(mockedResponse);
+        });
+    }
+    MockFetch.prototype.addMockedResponse = function (mockedResponse) {
+        var key = this.fetchParamsToKey(mockedResponse.url, mockedResponse.opts);
+        var mockedResponses = this.mockedResponsesByKey[key];
+        if (!mockedResponses) {
+            mockedResponses = [];
+            this.mockedResponsesByKey[key] = mockedResponses;
+        }
+        mockedResponses.push(mockedResponse);
+    };
+    MockFetch.prototype.fetch = function (url, opts) {
+        var key = this.fetchParamsToKey(url, opts);
+        var responses = this.mockedResponsesByKey[key];
+        if (!responses || responses.length === 0) {
+            throw new Error("No more mocked fetch responses for the params ".concat(url, " and ").concat(opts));
+        }
+        var _a = responses.shift(), result = _a.result, delay = _a.delay;
+        if (!result) {
+            throw new Error("Mocked fetch response should contain a result.");
+        }
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                resolve(result);
+            }, delay ? delay : 0);
+        });
+    };
+    MockFetch.prototype.fetchParamsToKey = function (url, opts) {
+        return JSON.stringify({
+            url: url,
+            opts: sortByKey(opts),
+        });
+    };
+    // Returns a "fetch" function equivalent that mocks the given responses.
+    // The function by returned by this should be tacked onto the global scope
+    // in order to test functions that use "fetch".
+    MockFetch.prototype.getFetch = function () {
+        return this.fetch.bind(this);
+    };
+    return MockFetch;
+}());
+export { MockFetch };
+function sortByKey(obj) {
+    return Object.keys(obj)
+        .sort()
+        .reduce(function (ret, key) {
+        var _a;
+        return Object.assign((_a = {},
+            _a[key] = (Object.prototype.toString.call(obj[key]).slice(8, -1) ===
+                "Object") ?
+                sortByKey(obj[key])
+                : obj[key],
+            _a), ret);
+    }, {});
+}
+export function createMockFetch() {
+    var mockedResponses = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        mockedResponses[_i] = arguments[_i];
+    }
+    return new (MockFetch.bind.apply(MockFetch, __spreadArray([void 0], mockedResponses, false)))().getFetch();
+}
+//# sourceMappingURL=mockFetch.js.map

package/testing/core/mocking/mockFetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockFetch.js","sourceRoot":"","sources":["../../../../src/testing/core/mocking/mockFetch.ts"],"names":[],"mappings":"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","sourcesContent":["import \"whatwg-fetch\";\n\n// This is an implementation of a mocked window.fetch implementation similar in\n// structure to the MockedNetworkInterface.\n\nexport interface MockedIResponse {\n  ok: boolean;\n  status: number;\n  statusText?: string;\n  json(): Promise<Object>;\n}\n\nexport interface MockedFetchResponse {\n  url: string;\n  opts: RequestInit;\n  result: MockedIResponse;\n  delay?: number;\n}\n\nexport function createMockedIResponse(\n  result: Object,\n  options?: any\n): MockedIResponse {\n  const status = (options && options.status) || 200;\n  const statusText = (options && options.statusText) || undefined;\n\n  return {\n    ok: status === 200,\n    status,\n    statusText,\n    json() {\n      return Promise.resolve<Object>(result);\n    },\n  };\n}\n\nexport class MockFetch {\n  private mockedResponsesByKey: { [key: string]: MockedFetchResponse[] };\n\n  constructor(...mockedResponses: MockedFetchResponse[]) {\n    this.mockedResponsesByKey = {};\n\n    mockedResponses.forEach((mockedResponse) => {\n      this.addMockedResponse(mockedResponse);\n    });\n  }\n\n  public addMockedResponse(mockedResponse: MockedFetchResponse) {\n    const key = this.fetchParamsToKey(mockedResponse.url, mockedResponse.opts);\n    let mockedResponses = this.mockedResponsesByKey[key];\n\n    if (!mockedResponses) {\n      mockedResponses = [];\n      this.mockedResponsesByKey[key] = mockedResponses;\n    }\n\n    mockedResponses.push(mockedResponse);\n  }\n\n  public fetch(url: string, opts: RequestInit) {\n    const key = this.fetchParamsToKey(url, opts);\n    const responses = this.mockedResponsesByKey[key];\n    if (!responses || responses.length === 0) {\n      throw new Error(\n        `No more mocked fetch responses for the params ${url} and ${opts}`\n      );\n    }\n\n    const { result, delay } = responses.shift()!;\n\n    if (!result) {\n      throw new Error(`Mocked fetch response should contain a result.`);\n    }\n\n    return new Promise((resolve) => {\n      setTimeout(\n        () => {\n          resolve(result);\n        },\n        delay ? delay : 0\n      );\n    });\n  }\n\n  public fetchParamsToKey(url: string, opts: RequestInit): string {\n    return JSON.stringify({\n      url,\n      opts: sortByKey(opts),\n    });\n  }\n\n  // Returns a \"fetch\" function equivalent that mocks the given responses.\n  // The function by returned by this should be tacked onto the global scope\n  // in order to test functions that use \"fetch\".\n  public getFetch() {\n    return this.fetch.bind(this);\n  }\n}\n\nfunction sortByKey(obj: any): Object {\n  return Object.keys(obj)\n    .sort()\n    .reduce(\n      (ret: any, key: string): Object =>\n        Object.assign(\n          {\n            [key]:\n              (\n                Object.prototype.toString.call(obj[key]).slice(8, -1) ===\n                \"Object\"\n              ) ?\n                sortByKey(obj[key])\n              : obj[key],\n          },\n          ret\n        ),\n      {}\n    );\n}\n\nexport function createMockFetch(...mockedResponses: MockedFetchResponse[]) {\n  return new MockFetch(...mockedResponses).getFetch();\n}\n"]}