@luvio/adapter-test-library 0.142.2 → 0.142.3

package/dist/umd/es5/test-library.js

@@ -1,818 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('sinon'), require('@luvio/engine')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'sinon', '@luvio/engine'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioAdapterTestLibrary = {}, global.sinon, global.engine));
-})(this, (function (exports, sinon, engine) { 'use strict';
-
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (g && (g = 0, op[0] && (_ = 0)), _) try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-                if (y = 0, t) op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0: case 1: t = op; break;
-                    case 4: _.label++; return { value: op[1], done: false };
-                    case 5: _.label++; y = op[1]; op = [0]; continue;
-                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                        if (t[2]) _.ops.pop();
-                        _.trys.pop(); continue;
-                }
-                op = body.call(thisArg, _);
-            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-
-    function isImmutable(value) {
-        return !doesThrow(function () {
-            // if verifyImmutable does not throw then the object is immutable
-            verifyImmutable(value, '$');
-        });
-    }
-    function verifyImmutable(value, path) {
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (Array.isArray(value)) {
-            if (doesThrow(function () {
-                var len = value.length;
-                value.push('__test');
-                if (len === value.length) {
-                    throw new Error('IE11 does not throw when mutating a frozen object');
-                }
-            }) === false) {
-                throw new Error("Unexpected mutable property found at ".concat(path, ": Array is extensible!"));
-            }
-            value.forEach(function (item, index) {
-                verifyImmutable(item, "".concat(path, ".").concat(index));
-            });
-            return;
-        }
-        if (doesThrow(function () {
-            value['__test_____'] = true;
-            if (value['__test_____'] !== true) {
-                throw new Error('IE11 does not throw when mutating a frozen object');
-            }
-        }) === false) {
-            throw new Error("Unexpected mutable property found at ".concat(path, ": Object is extensible!"));
-        }
-        Object.keys(value).forEach(function (key) {
-            if (doesThrow(function () {
-                var old = value[key];
-                value[key] = '_______foo';
-                if (value[key] === old) {
-                    throw new Error('IE11 does not throw when mutating a frozen object');
-                }
-            }) === false) {
-                throw new Error("Unexpected mutable property found at ".concat(path, ": \"").concat(path, ".").concat(key, "\" is mutable!"));
-            }
-            verifyImmutable(value[key], "".concat(path, ".").concat(key));
-        });
-    }
-
-    /**
-     * Clone an object
-     *
-     * @param {object} data The object to clone
-     * @returns {object} The cloned object
-     */
-    function clone(data) {
-        if (data === undefined) {
-            return undefined;
-        }
-        return JSON.parse(JSON.stringify(data));
-    }
-    /**
-     * Strips the given properties from an object. Useful for comparing data payloads
-     * where the given props may not be present in the data returned from an adapter.
-     *
-     * Does not mutate the passed in object.
-     *
-     * @param {object} obj The object from which to strip properties
-     * @param {string[]} props The properties to be removed
-     * @returns {object} The updated object with the given props stripped out
-     */
-    function stripProperties(obj, props) {
-        // don't mutate the original object
-        var cloned = clone(obj);
-        stripPropertiesMutating(cloned, props);
-        return cloned;
-    }
-    // private version of strip properties that mutates
-    function stripPropertiesMutating(obj, props) {
-        props.forEach(function (prop) {
-            delete obj[prop];
-        });
-        Object.keys(obj).forEach(function (key) {
-            var value = obj[key];
-            if (typeof value === 'object' && value !== null) {
-                stripPropertiesMutating(value, props);
-            }
-        });
-    }
-    function doesThrow(predicate) {
-        try {
-            predicate();
-        }
-        catch (e) {
-            return true;
-        }
-        return false;
-    }
-    function flushPromises() {
-        return new Promise(function (resolve) { return setTimeout(resolve, 0); });
-    }
-    // Copied from engine to avoid build time dependency
-    // BEGIN OF COPY BLOCK
-    var SnapshotState;
-    (function (SnapshotState) {
-        SnapshotState["Fulfilled"] = "Fulfilled";
-        SnapshotState["Unfulfilled"] = "Unfulfilled";
-        SnapshotState["Error"] = "Error";
-        SnapshotState["Pending"] = "Pending";
-        SnapshotState["Stale"] = "Stale";
-    })(SnapshotState || (SnapshotState = {}));
-    function isErrorSnapshot(snapshot) {
-        return snapshot.state === SnapshotState.Error;
-    }
-    function isFulfilledSnapshot(snapshot) {
-        return snapshot.state === SnapshotState.Fulfilled;
-    }
-    function isStaleSnapshot(snapshot) {
-        return snapshot.state === SnapshotState.Stale;
-    }
-    // END OF COPY BLOCK
-    var customMatchers = {
-        toEqualFulfilledSnapshotWithData: function (snapshot, expected, privateProperties) {
-            if (isFulfilledSnapshot(snapshot)) {
-                var expectedWithoutPrivateProperties = stripProperties(expected, privateProperties || []);
-                expect(snapshot.data).toEqual(expectedWithoutPrivateProperties);
-                expect(isImmutable(snapshot.data)).toBe(true);
-                return { pass: true, message: function () { return 'Snapshot is a FulfilledSnapshot'; } };
-            }
-            return {
-                pass: false,
-                message: function () { return 'Actual Snapshot is not a FulfilledSnapshot.'; },
-            };
-        },
-        toEqualStaleSnapshotWithData: function (snapshot, expected, privateProperties) {
-            if (isStaleSnapshot(snapshot)) {
-                var expectedWithoutPrivateProperties = stripProperties(expected, privateProperties || []);
-                expect(snapshot.data).toEqual(expectedWithoutPrivateProperties);
-                expect(isImmutable(snapshot.data)).toBe(true);
-                return { pass: true, message: function () { return 'Snapshot is a StaleSnapshot'; } };
-            }
-            return {
-                pass: false,
-                message: function () { return 'Actual Snapshot is not a StaleSnapshot.'; },
-            };
-        },
-        toEqualErrorSnapshot: function (actual, expectedStatus) {
-            if (isErrorSnapshot(actual)) {
-                expect(isImmutable(actual.error)).toBe(true);
-                expect(actual.data).toBeUndefined();
-                if (expectedStatus !== undefined) {
-                    expect(actual.error.status).toBe(expectedStatus);
-                }
-                return { pass: true, message: function () { return 'Snapshot is an ErrorSnapshot'; } };
-            }
-            return {
-                pass: false,
-                message: function () { return 'Actual Snapshot is not a ErrorSnapshot.'; },
-            };
-        },
-        toEqualOfflineErrorSnapshot: function (actual) {
-            if (isErrorSnapshot(actual)) {
-                expect(isImmutable(actual.error)).toBe(true);
-                expect(actual.data).toBeUndefined();
-                expect(actual.error).toBeInstanceOf(Error);
-                expect(actual.error.errorType).toBe('networkAdapterError');
-                return {
-                    pass: true,
-                    message: function () { return 'Snapshot is an ErrorSnapshot'; },
-                };
-            }
-            return {
-                pass: false,
-                message: function () { return 'Actual Snapshot is not a ErrorSnapshot.'; },
-            };
-        },
-        toHaveBeenHitTimes: function (mockNetworkAdapter, expected) {
-            var callCount = getMockNetworkAdapterCallCount(mockNetworkAdapter);
-            if (callCount !== expected) {
-                return {
-                    pass: false,
-                    message: function () {
-                        return "Number of network calls made are different. Actual ".concat(callCount, ", Expected ").concat(expected, ".");
-                    },
-                };
-            }
-            return { pass: true, message: function () { return "Network calls were made ".concat(expected, " times."); } };
-        },
-        toHaveBeenHitOnce: function (mockNetworkAdapter) {
-            var callCount = getMockNetworkAdapterCallCount(mockNetworkAdapter);
-            if (callCount !== 1) {
-                return {
-                    pass: false,
-                    message: function () { return "Number of network calls was not 1. Actual ".concat(callCount, "."); },
-                };
-            }
-            return { pass: true, message: function () { return 'Number of network calls was 1'; } };
-        },
-        toEqualFetchResponse: function (actual, expected) {
-            expect(actual).toEqual(__assign(__assign({}, expected), { errorType: 'fetchResponse' }));
-            expect(isImmutable(actual)).toBe(true);
-            return { pass: true, message: function () { return 'Actual response equals expected response'; } };
-        },
-    };
-
-    var networkConnectivityStateMap = new WeakMap();
-    exports.ConnectivityState = void 0;
-    (function (ConnectivityState) {
-        ConnectivityState[ConnectivityState["Online"] = 0] = "Online";
-        ConnectivityState[ConnectivityState["Offline"] = 1] = "Offline";
-    })(exports.ConnectivityState || (exports.ConnectivityState = {}));
-    var callCountMap = new WeakMap();
-    var mockPayloadsMap = new WeakMap();
-    function buildOfflineError() {
-        return new Error('Failed to fetch, request timeout');
-    }
-    function buildMockSetupError() {
-        return new Error('A mock network response was not setup for this request');
-    }
-    /**
-     * This function sorts two payloads based on number of parameters. It sorts in
-     * ascending order, meaning a MockPayload with fewer parameters in the networkArgs
-     * will come before a MockPayload with more parameters in the networkArgs.
-     *
-     * Sorting really only matters when a two networkArg objects have all the same
-     * fields except for uri/query/headers, so this sorting algorithm is simplistic.
-     * If two networkArg objects have different baseUri or basePath properties, for
-     * example, then the sinon matcher won't have a collision so sorting doesn't
-     * matter in that situation.
-     *
-     * @param {MockPayload} a
-     * @param {MockPayload} b
-     * @returns {number}
-     */
-    function sortPayloads(a, b) {
-        var _a = b.networkArgs, bUrlParams = _a.urlParams, bQueryParams = _a.queryParams, bHeaders = _a.headers;
-        var _b = a.networkArgs, aUrlParams = _b.urlParams, aQueryParams = _b.queryParams, aHeaders = _b.headers;
-        var aParams = Object.keys(aUrlParams !== null && aUrlParams !== void 0 ? aUrlParams : {}).length +
-            Object.keys(aQueryParams !== null && aQueryParams !== void 0 ? aQueryParams : {}).length +
-            Object.keys(aHeaders !== null && aHeaders !== void 0 ? aHeaders : {}).length;
-        var bParams = Object.keys(bUrlParams !== null && bUrlParams !== void 0 ? bUrlParams : {}).length +
-            Object.keys(bQueryParams !== null && bQueryParams !== void 0 ? bQueryParams : {}).length +
-            Object.keys(bHeaders !== null && bHeaders !== void 0 ? bHeaders : {}).length;
-        return aParams - bParams;
-    }
-    function isOkResponse(status) {
-        return status >= 200 && status <= 299;
-    }
-    /**
-     * Flushes any pending network requests.  Useful for tests that need to ensure all
-     * un-awaited background refreshes are complete
-     *
-     * @param _mockNetworkAdapter {NetworkAdapter} The network adapter instance to flush
-     */
-    function flushPendingNetworkRequests(_mockNetworkAdapter) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: 
-                    // since the network mock is actually synchronous (just returns things wrapped
-                    // in Promise.resolve/reject) the only thing necessary to flush any pending
-                    // network activity is to flush the pending microtask queue
-                    return [4 /*yield*/, flushPromises()];
-                    case 1:
-                        // since the network mock is actually synchronous (just returns things wrapped
-                        // in Promise.resolve/reject) the only thing necessary to flush any pending
-                        // network activity is to flush the pending microtask queue
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    }
-    function buildMockNetworkAdapter(mockPayloads) {
-        // any endpoints not setup with a fake will return a rejected promise
-        var networkAdapter = sinon.stub().rejects(buildMockSetupError());
-        callCountMap.set(networkAdapter, 0);
-        mockPayloadsMap.set(networkAdapter, mockPayloads);
-        setMockNetworkPayloads(networkAdapter, mockPayloads);
-        return networkAdapter;
-    }
-    function setNetworkConnectivity(mockNetworkAdapter, connectivityState) {
-        var stub = mockNetworkAdapter;
-        networkConnectivityStateMap.set(stub, connectivityState);
-    }
-    function onNetworkStubCalled(stub, response) {
-        var _a;
-        var body = response.body, status = response.status, statusText = response.statusText, ok = response.ok, headers = response.headers;
-        var currentCallCount = callCountMap.get(stub);
-        callCountMap.set(stub, currentCallCount ? currentCallCount + 1 : 1);
-        var connectivityState = (_a = networkConnectivityStateMap.get(stub)) !== null && _a !== void 0 ? _a : exports.ConnectivityState.Online;
-        if (connectivityState === exports.ConnectivityState.Offline) {
-            return Promise.reject(buildOfflineError());
-        }
-        return Promise.resolve({
-            status: status,
-            statusText: statusText,
-            ok: ok,
-            body: clone(body),
-            headers: clone(headers),
-        });
-    }
-    function setMockNetworkPayloads(mockNetworkAdapter, mockPayloads) {
-        var stub = mockNetworkAdapter;
-        // sort mock payloads so least-specific network args are registered first
-        mockPayloads.sort(sortPayloads).forEach(function (mockPayload) {
-            var networkArgs = mockPayload.networkArgs, response = mockPayload.response;
-            var args = sinon.match(networkArgs);
-            stub.withArgs(args).callsFake(function () {
-                return onNetworkStubCalled(stub, response);
-            });
-        });
-    }
-    /**
-     * Overrides the mock network adapter responses with the given "responses".  Each request to
-     * the network adapter will "pop" a response from the response array.  If more requests
-     * to the network adapter are made than responses in the given array then an error
-     * will be returned.
-     *
-     * This differs from setMockNetworkPayloads because it does not look at the incoming
-     * network request args to determine what the response should be, it just returns
-     * the response based on the request order.
-     *
-     * NOTE: this overrides any previously setup MockPayloads for the given network adapter
-     * until resetMockNetworkAdapter is called.
-     */
-    function overrideMockNetworkResponses(mockNetworkAdapter, responses) {
-        var stub = mockNetworkAdapter;
-        var index = 0;
-        stub.withArgs(sinon.match.any).callsFake(function () {
-            var response = responses[index++];
-            if (response === undefined) {
-                // if they have more requests than expected
-                return Promise.reject(buildMockSetupError());
-            }
-            return onNetworkStubCalled(stub, response);
-        });
-    }
-    function resetMockNetworkAdapter(mockNetworkAdapter, newPayloads) {
-        var stub = mockNetworkAdapter;
-        // reset stub in case a test modified payload responses
-        stub.reset();
-        // reset call count
-        callCountMap.set(stub, 0);
-        // set mock payloads up - Allow for the test to provide a different set of payloads
-        // Default behavior is to reset to the original payloads.
-        var payloads = newPayloads ? newPayloads : mockPayloadsMap.get(stub);
-        if (payloads) {
-            setMockNetworkPayloads(stub, payloads);
-        }
-    }
-    function getMockNetworkAdapterCallCount(mockNetworkAdapter) {
-        var stub = mockNetworkAdapter;
-        return callCountMap.get(stub);
-    }
-    function buildFetchResponse(body, status, statusText, headers) {
-        if (status === void 0) { status = 200; }
-        if (statusText === void 0) { statusText = 'Ok'; }
-        if (headers === void 0) { headers = {}; }
-        return {
-            headers: headers,
-            body: body,
-            status: status,
-            statusText: statusText,
-            ok: isOkResponse(status),
-        };
-    }
-    function buildSuccessMockPayload(networkArgs, body, headers) {
-        if (headers === void 0) { headers = {}; }
-        var mockPayload = {
-            networkArgs: networkArgs,
-            response: buildFetchResponse(body, 200, 'Ok', headers),
-        };
-        return mockPayload;
-    }
-    function buildErrorMockPayload(networkArgs, body, errorStatusCode, errorStatusText, headers) {
-        if (headers === void 0) { headers = {}; }
-        var mockPayload = {
-            networkArgs: networkArgs,
-            response: buildFetchResponse(body, errorStatusCode, errorStatusText, headers),
-        };
-        return mockPayload;
-    }
-
-    var mockFulfilledSnapshot = { state: 'Fulfilled' };
-    var mockFulfilledSnapshotPromise = {
-        then: function () {
-            return mockFulfilledSnapshot;
-        },
-    };
-    var mockLuvio = {
-        storeLookup: function () {
-            return mockFulfilledSnapshot;
-        },
-        snapshotAvailable: function () {
-            return true;
-        },
-        dispatchResourceRequest: function () {
-            return mockFulfilledSnapshotPromise;
-        },
-        applyCachePolicy: function () {
-            return mockFulfilledSnapshot;
-        },
-    };
-    function getMockLuvioWithFulfilledSnapshot() {
-        return mockLuvio;
-    }
-    function getMockFulfilledSnapshot() {
-        return mockFulfilledSnapshot;
-    }
-
-    function setupCustomLuvioMatchers() {
-        expect.extend(customMatchers);
-    }
-
-    var MemoryDurableStorePersistence = /** @class */ (function () {
-        function MemoryDurableStorePersistence() {
-            this.store = {};
-        }
-        MemoryDurableStorePersistence.prototype.get = function (key) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.store[key]];
-                });
-            });
-        };
-        MemoryDurableStorePersistence.prototype.set = function (key, value) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: 
-                        // simulate a more realistic durable store by making the write wait a
-                        // tick before actually setting the value
-                        return [4 /*yield*/, flushPromises()];
-                        case 1:
-                            // simulate a more realistic durable store by making the write wait a
-                            // tick before actually setting the value
-                            _a.sent();
-                            this.store[key] = value;
-                            return [2 /*return*/];
-                    }
-                });
-            });
-        };
-        MemoryDurableStorePersistence.prototype.delete = function (key) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    delete this.store[key];
-                    return [2 /*return*/];
-                });
-            });
-        };
-        MemoryDurableStorePersistence.prototype.flushPendingWork = function () {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: 
-                        // since this implementation does actual "IO" synchronously the only
-                        // thing necessary to await any pending IO is to flush the current
-                        // microtask queue
-                        return [4 /*yield*/, flushPromises()];
-                        case 1:
-                            // since this implementation does actual "IO" synchronously the only
-                            // thing necessary to await any pending IO is to flush the current
-                            // microtask queue
-                            _a.sent();
-                            return [2 /*return*/];
-                    }
-                });
-            });
-        };
-        return MemoryDurableStorePersistence;
-    }());
-
-    function waitForPromiseSet(set) {
-        // NOTE: we are building an array from the Set at this point in time.  If
-        // more Promises are added to the Set while this is awaiting it won't
-        // await the newly-added Promise.  That's what we want.
-        return Promise.all(Array.from(set)).then();
-    }
-    var MockDurableStore = /** @class */ (function () {
-        function MockDurableStore(persistence) {
-            // for read/write synchronization
-            this.writePromises = new Set();
-            this.listeners = new Set();
-            this.persistence = persistence || new MemoryDurableStorePersistence();
-        }
-        MockDurableStore.prototype.getEntries = function (entryIds, segment) {
-            return __awaiter(this, void 0, void 0, function () {
-                var entries, returnSource, _i, entryIds_1, entryId, entry;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!(this.writePromises.size > 0)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, waitForPromiseSet(this.writePromises)];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2: return [4 /*yield*/, this.persistence.get(segment)];
-                        case 3:
-                            entries = _a.sent();
-                            if (entries === undefined) {
-                                return [2 /*return*/, undefined];
-                            }
-                            returnSource = Object.create(null);
-                            for (_i = 0, entryIds_1 = entryIds; _i < entryIds_1.length; _i++) {
-                                entryId = entryIds_1[_i];
-                                entry = entries[entryId];
-                                if (entry !== undefined) {
-                                    returnSource[entryId] = clone(entry);
-                                }
-                            }
-                            return [2 /*return*/, returnSource];
-                    }
-                });
-            });
-        };
-        MockDurableStore.prototype.getAllEntries = function (segment) {
-            return __awaiter(this, void 0, void 0, function () {
-                var entries;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!(this.writePromises.size > 0)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, waitForPromiseSet(this.writePromises)];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2: return [4 /*yield*/, this.persistence.get(segment)];
-                        case 3:
-                            entries = _a.sent();
-                            return [2 /*return*/, entries];
-                    }
-                });
-            });
-        };
-        MockDurableStore.prototype.setEntries = function (entries, segment) {
-            return this.batchOperations([{ entries: entries, segment: segment, type: 'setEntries' }]);
-        };
-        MockDurableStore.prototype.evictEntries = function (ids, segment) {
-            return this.batchOperations([{ ids: ids, segment: segment, type: 'evictEntries' }]);
-        };
-        MockDurableStore.prototype.registerOnChangedListener = function (listener) {
-            var _this = this;
-            this.listeners.add(listener);
-            return function () {
-                _this.listeners.delete(listener);
-                return Promise.resolve();
-            };
-        };
-        MockDurableStore.prototype.batchOperations = function (operations) {
-            return __awaiter(this, void 0, void 0, function () {
-                var changes, writePromise, promises;
-                var _this = this;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!(this.writePromises.size > 0)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, waitForPromiseSet(this.writePromises)];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2:
-                            changes = [];
-                            writePromise = (function () { return __awaiter(_this, void 0, void 0, function () {
-                                var _i, operations_1, operation, _a, _b;
-                                return __generator(this, function (_c) {
-                                    switch (_c.label) {
-                                        case 0:
-                                            _i = 0, operations_1 = operations;
-                                            _c.label = 1;
-                                        case 1:
-                                            if (!(_i < operations_1.length)) return [3 /*break*/, 4];
-                                            operation = operations_1[_i];
-                                            _b = (_a = changes).push;
-                                            return [4 /*yield*/, this.performOperation(operation)];
-                                        case 2:
-                                            _b.apply(_a, [_c.sent()]);
-                                            _c.label = 3;
-                                        case 3:
-                                            _i++;
-                                            return [3 /*break*/, 1];
-                                        case 4: return [2 /*return*/];
-                                    }
-                                });
-                            }); })();
-                            this.writePromises.add(writePromise);
-                            _a.label = 3;
-                        case 3:
-                            _a.trys.push([3, , 5, 6]);
-                            return [4 /*yield*/, writePromise];
-                        case 4:
-                            _a.sent();
-                            return [3 /*break*/, 6];
-                        case 5:
-                            this.writePromises.delete(writePromise);
-                            return [7 /*endfinally*/];
-                        case 6:
-                            promises = [];
-                            this.listeners.forEach(function (listener) {
-                                promises.push(listener(changes));
-                            });
-                            return [2 /*return*/, Promise.all(promises).then(function () { return undefined; })];
-                    }
-                });
-            });
-        };
-        MockDurableStore.prototype.performOperation = function (operation) {
-            return __awaiter(this, void 0, void 0, function () {
-                var segment, rawEntries, entries, ids;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            segment = operation.segment;
-                            return [4 /*yield*/, this.persistence.get(segment)];
-                        case 1:
-                            rawEntries = _a.sent();
-                            entries = rawEntries === undefined ? {} : rawEntries;
-                            ids = [];
-                            switch (operation.type) {
-                                case 'setEntries':
-                                    ids = Object.keys(operation.entries);
-                                    ids.forEach(function (id) {
-                                        entries[id] = clone(operation.entries[id]);
-                                    });
-                                    break;
-                                case 'evictEntries':
-                                    ids = operation.ids;
-                                    ids.forEach(function (id) {
-                                        delete entries[id];
-                                    });
-                            }
-                            return [4 /*yield*/, this.persistence.set(operation.segment, entries)];
-                        case 2:
-                            _a.sent();
-                            return [2 /*return*/, { ids: ids, segment: segment, type: operation.type }];
-                    }
-                });
-            });
-        };
-        MockDurableStore.prototype.flushPendingOperations = function () {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: 
-                        // flush any pending read operations
-                        return [4 /*yield*/, this.persistence.flushPendingWork()];
-                        case 1:
-                            // flush any pending read operations
-                            _a.sent();
-                            _a.label = 2;
-                        case 2:
-                            if (!(this.writePromises.size > 0)) return [3 /*break*/, 4];
-                            return [4 /*yield*/, waitForPromiseSet(this.writePromises)];
-                        case 3:
-                            _a.sent();
-                            return [3 /*break*/, 2];
-                        case 4: return [2 /*return*/];
-                    }
-                });
-            });
-        };
-        return MockDurableStore;
-    }());
-
-    // Use this util if you want to configure multiple network mocks in your test code.
-    // If you're only mocking one, we suggest you use buildLuvioWithNetwork instead.
-    function buildLuvioInstance(mockNetworkAdapter) {
-        var store = new engine.InMemoryStore();
-        var env = new engine.Environment(store, mockNetworkAdapter);
-        return new engine.Luvio(env);
-    }
-    function testAdapterCompletesRoundtrip(params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var adapterSetup, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        adapterSetup = setupAdapter(params);
-                        return [4 /*yield*/, callAdapter(adapterSetup, params)];
-                    case 1:
-                        result = _a.sent();
-                        expect(result.data).toBeDefined();
-                        expect(result).toEqualFulfilledSnapshotWithData(params.type === 'network'
-                            ? params.expectedData || params.network.response
-                            : params.expectedData, params.privateProperties);
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    }
-    function setupAdapter(params) {
-        var luvio = params.type === 'network' ? buildLuvioWithNetwork(params.network).luvio : params.luvio;
-        return params.adapterFactory(luvio);
-    }
-    // Returns a tuple of the Luvio instance and network adapter so the test author may expect a number expected calls to the network.
-    function buildLuvioWithNetwork(networkConfig) {
-        // TODO: handle alternative expected network calls, errors and etc
-        var expectedNetwork = [
-            buildSuccessMockPayload(networkConfig.request, networkConfig.response),
-        ];
-        var mockNetworkAdapter = buildMockNetworkAdapter(expectedNetwork);
-        return { luvio: buildLuvioInstance(mockNetworkAdapter), networkAdapter: mockNetworkAdapter };
-    }
-    function callAdapter(adapter, params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var snapshotOrPromise;
-            return __generator(this, function (_a) {
-                snapshotOrPromise = adapter(params.adapterConfig);
-                if (snapshotOrPromise === null) {
-                    throw new Error('Result of calling the adapter was null. Is the adapter config valid?');
-                }
-                // Cache Miss - Check that the network call was right.
-                if (params.type === 'injectedLuvioNetwork' || params.type === 'network') {
-                    expect(snapshotOrPromise).toBeInstanceOf(Promise);
-                    return [2 /*return*/, snapshotOrPromise];
-                }
-                else {
-                    // Cache hit
-                    expect(snapshotOrPromise).not.toBeInstanceOf(Promise); // Expect cache hit to be synchronous
-                    return [2 /*return*/, Promise.resolve(snapshotOrPromise)];
-                }
-            });
-        });
-    }
-
-    exports.MemoryDurableStorePersistence = MemoryDurableStorePersistence;
-    exports.MockDurableStore = MockDurableStore;
-    exports.buildErrorMockPayload = buildErrorMockPayload;
-    exports.buildFetchResponse = buildFetchResponse;
-    exports.buildLuvioInstance = buildLuvioInstance;
-    exports.buildLuvioWithNetwork = buildLuvioWithNetwork;
-    exports.buildMockNetworkAdapter = buildMockNetworkAdapter;
-    exports.buildSuccessMockPayload = buildSuccessMockPayload;
-    exports.customMatchers = customMatchers;
-    exports.flushPendingNetworkRequests = flushPendingNetworkRequests;
-    exports.getMockFulfilledSnapshot = getMockFulfilledSnapshot;
-    exports.getMockLuvioWithFulfilledSnapshot = getMockLuvioWithFulfilledSnapshot;
-    exports.getMockNetworkAdapterCallCount = getMockNetworkAdapterCallCount;
-    exports.isImmutable = isImmutable;
-    exports.overrideMockNetworkResponses = overrideMockNetworkResponses;
-    exports.resetMockNetworkAdapter = resetMockNetworkAdapter;
-    exports.setMockNetworkPayloads = setMockNetworkPayloads;
-    exports.setNetworkConnectivity = setNetworkConnectivity;
-    exports.setupCustomLuvioMatchers = setupCustomLuvioMatchers;
-    exports.stripProperties = stripProperties;
-    exports.testAdapterCompletesRoundtrip = testAdapterCompletesRoundtrip;
-    exports.verifyImmutable = verifyImmutable;
-
-}));