@luvio/adapter-test-library 0.138.0 → 0.138.2

package/dist/es/es2018/test-library.js

@@ -1,572 +1,572 @@
 import sinon from 'sinon';
 import { InMemoryStore, Environment, Luvio } from '@luvio/engine';
 
-function isImmutable(value) {
-    return !doesThrow(() => {
-        // 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(() => {
-            const 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 ${path}: Array is extensible!`);
-        }
-        value.forEach((item, index) => {
-            verifyImmutable(item, `${path}.${index}`);
-        });
-        return;
-    }
-    if (doesThrow(() => {
-        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 ${path}: Object is extensible!`);
-    }
-    Object.keys(value).forEach((key) => {
-        if (doesThrow(() => {
-            const 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 ${path}: "${path}.${key}" is mutable!`);
-        }
-        verifyImmutable(value[key], `${path}.${key}`);
-    });
+function isImmutable(value) {
+    return !doesThrow(() => {
+        // 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(() => {
+            const 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 ${path}: Array is extensible!`);
+        }
+        value.forEach((item, index) => {
+            verifyImmutable(item, `${path}.${index}`);
+        });
+        return;
+    }
+    if (doesThrow(() => {
+        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 ${path}: Object is extensible!`);
+    }
+    Object.keys(value).forEach((key) => {
+        if (doesThrow(() => {
+            const 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 ${path}: "${path}.${key}" is mutable!`);
+        }
+        verifyImmutable(value[key], `${path}.${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
-    const cloned = clone(obj);
-    stripPropertiesMutating(cloned, props);
-    return cloned;
-}
-// private version of strip properties that mutates
-function stripPropertiesMutating(obj, props) {
-    props.forEach((prop) => {
-        delete obj[prop];
-    });
-    Object.keys(obj).forEach((key) => {
-        const 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((resolve) => 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
-const customMatchers = {
-    toEqualFulfilledSnapshotWithData: (snapshot, expected, privateProperties) => {
-        if (isFulfilledSnapshot(snapshot)) {
-            const expectedWithoutPrivateProperties = stripProperties(expected, privateProperties || []);
-            expect(snapshot.data).toEqual(expectedWithoutPrivateProperties);
-            expect(isImmutable(snapshot.data)).toBe(true);
-            return { pass: true, message: () => 'Snapshot is a FulfilledSnapshot' };
-        }
-        return {
-            pass: false,
-            message: () => 'Actual Snapshot is not a FulfilledSnapshot.',
-        };
-    },
-    toEqualStaleSnapshotWithData: (snapshot, expected, privateProperties) => {
-        if (isStaleSnapshot(snapshot)) {
-            const expectedWithoutPrivateProperties = stripProperties(expected, privateProperties || []);
-            expect(snapshot.data).toEqual(expectedWithoutPrivateProperties);
-            expect(isImmutable(snapshot.data)).toBe(true);
-            return { pass: true, message: () => 'Snapshot is a StaleSnapshot' };
-        }
-        return {
-            pass: false,
-            message: () => 'Actual Snapshot is not a StaleSnapshot.',
-        };
-    },
-    toEqualErrorSnapshot: (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: () => 'Snapshot is an ErrorSnapshot' };
-        }
-        return {
-            pass: false,
-            message: () => 'Actual Snapshot is not a ErrorSnapshot.',
-        };
-    },
-    toEqualOfflineErrorSnapshot: (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: () => 'Snapshot is an ErrorSnapshot',
-            };
-        }
-        return {
-            pass: false,
-            message: () => 'Actual Snapshot is not a ErrorSnapshot.',
-        };
-    },
-    toHaveBeenHitTimes: (mockNetworkAdapter, expected) => {
-        const callCount = getMockNetworkAdapterCallCount(mockNetworkAdapter);
-        if (callCount !== expected) {
-            return {
-                pass: false,
-                message: () => `Number of network calls made are different. Actual ${callCount}, Expected ${expected}.`,
-            };
-        }
-        return { pass: true, message: () => `Network calls were made ${expected} times.` };
-    },
-    toHaveBeenHitOnce: (mockNetworkAdapter) => {
-        const callCount = getMockNetworkAdapterCallCount(mockNetworkAdapter);
-        if (callCount !== 1) {
-            return {
-                pass: false,
-                message: () => `Number of network calls was not 1. Actual ${callCount}.`,
-            };
-        }
-        return { pass: true, message: () => 'Number of network calls was 1' };
-    },
-    toEqualFetchResponse: (actual, expected) => {
-        expect(actual).toEqual({ ...expected, errorType: 'fetchResponse' });
-        expect(isImmutable(actual)).toBe(true);
-        return { pass: true, message: () => 'Actual response equals expected response' };
-    },
+/**
+ * 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
+    const cloned = clone(obj);
+    stripPropertiesMutating(cloned, props);
+    return cloned;
+}
+// private version of strip properties that mutates
+function stripPropertiesMutating(obj, props) {
+    props.forEach((prop) => {
+        delete obj[prop];
+    });
+    Object.keys(obj).forEach((key) => {
+        const 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((resolve) => 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
+const customMatchers = {
+    toEqualFulfilledSnapshotWithData: (snapshot, expected, privateProperties) => {
+        if (isFulfilledSnapshot(snapshot)) {
+            const expectedWithoutPrivateProperties = stripProperties(expected, privateProperties || []);
+            expect(snapshot.data).toEqual(expectedWithoutPrivateProperties);
+            expect(isImmutable(snapshot.data)).toBe(true);
+            return { pass: true, message: () => 'Snapshot is a FulfilledSnapshot' };
+        }
+        return {
+            pass: false,
+            message: () => 'Actual Snapshot is not a FulfilledSnapshot.',
+        };
+    },
+    toEqualStaleSnapshotWithData: (snapshot, expected, privateProperties) => {
+        if (isStaleSnapshot(snapshot)) {
+            const expectedWithoutPrivateProperties = stripProperties(expected, privateProperties || []);
+            expect(snapshot.data).toEqual(expectedWithoutPrivateProperties);
+            expect(isImmutable(snapshot.data)).toBe(true);
+            return { pass: true, message: () => 'Snapshot is a StaleSnapshot' };
+        }
+        return {
+            pass: false,
+            message: () => 'Actual Snapshot is not a StaleSnapshot.',
+        };
+    },
+    toEqualErrorSnapshot: (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: () => 'Snapshot is an ErrorSnapshot' };
+        }
+        return {
+            pass: false,
+            message: () => 'Actual Snapshot is not a ErrorSnapshot.',
+        };
+    },
+    toEqualOfflineErrorSnapshot: (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: () => 'Snapshot is an ErrorSnapshot',
+            };
+        }
+        return {
+            pass: false,
+            message: () => 'Actual Snapshot is not a ErrorSnapshot.',
+        };
+    },
+    toHaveBeenHitTimes: (mockNetworkAdapter, expected) => {
+        const callCount = getMockNetworkAdapterCallCount(mockNetworkAdapter);
+        if (callCount !== expected) {
+            return {
+                pass: false,
+                message: () => `Number of network calls made are different. Actual ${callCount}, Expected ${expected}.`,
+            };
+        }
+        return { pass: true, message: () => `Network calls were made ${expected} times.` };
+    },
+    toHaveBeenHitOnce: (mockNetworkAdapter) => {
+        const callCount = getMockNetworkAdapterCallCount(mockNetworkAdapter);
+        if (callCount !== 1) {
+            return {
+                pass: false,
+                message: () => `Number of network calls was not 1. Actual ${callCount}.`,
+            };
+        }
+        return { pass: true, message: () => 'Number of network calls was 1' };
+    },
+    toEqualFetchResponse: (actual, expected) => {
+        expect(actual).toEqual({ ...expected, errorType: 'fetchResponse' });
+        expect(isImmutable(actual)).toBe(true);
+        return { pass: true, message: () => 'Actual response equals expected response' };
+    },
 };
 
-const networkConnectivityStateMap = new WeakMap();
-var ConnectivityState;
-(function (ConnectivityState) {
-    ConnectivityState[ConnectivityState["Online"] = 0] = "Online";
-    ConnectivityState[ConnectivityState["Offline"] = 1] = "Offline";
-})(ConnectivityState || (ConnectivityState = {}));
-const callCountMap = new WeakMap();
-const 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) {
-    const { networkArgs: { urlParams: bUrlParams, queryParams: bQueryParams, headers: bHeaders }, } = b;
-    const { networkArgs: { urlParams: aUrlParams, queryParams: aQueryParams, headers: aHeaders }, } = a;
-    const 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;
-    const 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
- */
-async function flushPendingNetworkRequests(_mockNetworkAdapter) {
-    // 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
-    await flushPromises();
-}
-function buildMockNetworkAdapter(mockPayloads) {
-    // any endpoints not setup with a fake will return a rejected promise
-    const networkAdapter = sinon.stub().rejects(buildMockSetupError());
-    callCountMap.set(networkAdapter, 0);
-    mockPayloadsMap.set(networkAdapter, mockPayloads);
-    setMockNetworkPayloads(networkAdapter, mockPayloads);
-    return networkAdapter;
-}
-function setNetworkConnectivity(mockNetworkAdapter, connectivityState) {
-    const stub = mockNetworkAdapter;
-    networkConnectivityStateMap.set(stub, connectivityState);
-}
-function onNetworkStubCalled(stub, response) {
-    var _a;
-    const { body, status, statusText, ok, headers } = response;
-    const currentCallCount = callCountMap.get(stub);
-    callCountMap.set(stub, currentCallCount ? currentCallCount + 1 : 1);
-    const connectivityState = (_a = networkConnectivityStateMap.get(stub)) !== null && _a !== void 0 ? _a : ConnectivityState.Online;
-    if (connectivityState === ConnectivityState.Offline) {
-        return Promise.reject(buildOfflineError());
-    }
-    return Promise.resolve({
-        status,
-        statusText,
-        ok,
-        body: clone(body),
-        headers: clone(headers),
-    });
-}
-function setMockNetworkPayloads(mockNetworkAdapter, mockPayloads) {
-    const stub = mockNetworkAdapter;
-    // sort mock payloads so least-specific network args are registered first
-    mockPayloads.sort(sortPayloads).forEach((mockPayload) => {
-        const { networkArgs, response } = mockPayload;
-        const args = sinon.match(networkArgs);
-        stub.withArgs(args).callsFake(() => {
-            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) {
-    const stub = mockNetworkAdapter;
-    let index = 0;
-    stub.withArgs(sinon.match.any).callsFake(() => {
-        const response = responses[index++];
-        if (response === undefined) {
-            // if they have more requests than expected
-            return Promise.reject(buildMockSetupError());
-        }
-        return onNetworkStubCalled(stub, response);
-    });
-}
-function resetMockNetworkAdapter(mockNetworkAdapter) {
-    const stub = mockNetworkAdapter;
-    // reset stub in case a test modified payload responses
-    stub.reset();
-    // reset call count
-    callCountMap.set(stub, 0);
-    // set original mock payloads up
-    const payloads = mockPayloadsMap.get(stub);
-    if (payloads) {
-        setMockNetworkPayloads(stub, payloads);
-    }
-}
-function getMockNetworkAdapterCallCount(mockNetworkAdapter) {
-    const stub = mockNetworkAdapter;
-    return callCountMap.get(stub);
-}
-function buildFetchResponse(body, status = 200, statusText = 'Ok', headers = {}) {
-    return {
-        headers,
-        body,
-        status,
-        statusText,
-        ok: isOkResponse(status),
-    };
-}
-function buildSuccessMockPayload(networkArgs, body, headers = {}) {
-    const mockPayload = {
-        networkArgs,
-        response: buildFetchResponse(body, 200, 'Ok', headers),
-    };
-    return mockPayload;
-}
-function buildErrorMockPayload(networkArgs, body, errorStatusCode, errorStatusText, headers = {}) {
-    const mockPayload = {
-        networkArgs,
-        response: buildFetchResponse(body, errorStatusCode, errorStatusText, headers),
-    };
-    return mockPayload;
+const networkConnectivityStateMap = new WeakMap();
+var ConnectivityState;
+(function (ConnectivityState) {
+    ConnectivityState[ConnectivityState["Online"] = 0] = "Online";
+    ConnectivityState[ConnectivityState["Offline"] = 1] = "Offline";
+})(ConnectivityState || (ConnectivityState = {}));
+const callCountMap = new WeakMap();
+const 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) {
+    const { networkArgs: { urlParams: bUrlParams, queryParams: bQueryParams, headers: bHeaders }, } = b;
+    const { networkArgs: { urlParams: aUrlParams, queryParams: aQueryParams, headers: aHeaders }, } = a;
+    const 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;
+    const 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
+ */
+async function flushPendingNetworkRequests(_mockNetworkAdapter) {
+    // 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
+    await flushPromises();
+}
+function buildMockNetworkAdapter(mockPayloads) {
+    // any endpoints not setup with a fake will return a rejected promise
+    const networkAdapter = sinon.stub().rejects(buildMockSetupError());
+    callCountMap.set(networkAdapter, 0);
+    mockPayloadsMap.set(networkAdapter, mockPayloads);
+    setMockNetworkPayloads(networkAdapter, mockPayloads);
+    return networkAdapter;
+}
+function setNetworkConnectivity(mockNetworkAdapter, connectivityState) {
+    const stub = mockNetworkAdapter;
+    networkConnectivityStateMap.set(stub, connectivityState);
+}
+function onNetworkStubCalled(stub, response) {
+    var _a;
+    const { body, status, statusText, ok, headers } = response;
+    const currentCallCount = callCountMap.get(stub);
+    callCountMap.set(stub, currentCallCount ? currentCallCount + 1 : 1);
+    const connectivityState = (_a = networkConnectivityStateMap.get(stub)) !== null && _a !== void 0 ? _a : ConnectivityState.Online;
+    if (connectivityState === ConnectivityState.Offline) {
+        return Promise.reject(buildOfflineError());
+    }
+    return Promise.resolve({
+        status,
+        statusText,
+        ok,
+        body: clone(body),
+        headers: clone(headers),
+    });
+}
+function setMockNetworkPayloads(mockNetworkAdapter, mockPayloads) {
+    const stub = mockNetworkAdapter;
+    // sort mock payloads so least-specific network args are registered first
+    mockPayloads.sort(sortPayloads).forEach((mockPayload) => {
+        const { networkArgs, response } = mockPayload;
+        const args = sinon.match(networkArgs);
+        stub.withArgs(args).callsFake(() => {
+            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) {
+    const stub = mockNetworkAdapter;
+    let index = 0;
+    stub.withArgs(sinon.match.any).callsFake(() => {
+        const response = responses[index++];
+        if (response === undefined) {
+            // if they have more requests than expected
+            return Promise.reject(buildMockSetupError());
+        }
+        return onNetworkStubCalled(stub, response);
+    });
+}
+function resetMockNetworkAdapter(mockNetworkAdapter) {
+    const stub = mockNetworkAdapter;
+    // reset stub in case a test modified payload responses
+    stub.reset();
+    // reset call count
+    callCountMap.set(stub, 0);
+    // set original mock payloads up
+    const payloads = mockPayloadsMap.get(stub);
+    if (payloads) {
+        setMockNetworkPayloads(stub, payloads);
+    }
+}
+function getMockNetworkAdapterCallCount(mockNetworkAdapter) {
+    const stub = mockNetworkAdapter;
+    return callCountMap.get(stub);
+}
+function buildFetchResponse(body, status = 200, statusText = 'Ok', headers = {}) {
+    return {
+        headers,
+        body,
+        status,
+        statusText,
+        ok: isOkResponse(status),
+    };
+}
+function buildSuccessMockPayload(networkArgs, body, headers = {}) {
+    const mockPayload = {
+        networkArgs,
+        response: buildFetchResponse(body, 200, 'Ok', headers),
+    };
+    return mockPayload;
+}
+function buildErrorMockPayload(networkArgs, body, errorStatusCode, errorStatusText, headers = {}) {
+    const mockPayload = {
+        networkArgs,
+        response: buildFetchResponse(body, errorStatusCode, errorStatusText, headers),
+    };
+    return mockPayload;
 }
 
-const mockFulfilledSnapshot = { state: 'Fulfilled' };
-const mockFulfilledSnapshotPromise = {
-    then() {
-        return mockFulfilledSnapshot;
-    },
-};
-const mockLuvio = {
-    storeLookup() {
-        return mockFulfilledSnapshot;
-    },
-    snapshotAvailable() {
-        return true;
-    },
-    dispatchResourceRequest() {
-        return mockFulfilledSnapshotPromise;
-    },
-    applyCachePolicy() {
-        return mockFulfilledSnapshot;
-    },
-};
-function getMockLuvioWithFulfilledSnapshot() {
-    return mockLuvio;
-}
-function getMockFulfilledSnapshot() {
-    return mockFulfilledSnapshot;
+const mockFulfilledSnapshot = { state: 'Fulfilled' };
+const mockFulfilledSnapshotPromise = {
+    then() {
+        return mockFulfilledSnapshot;
+    },
+};
+const mockLuvio = {
+    storeLookup() {
+        return mockFulfilledSnapshot;
+    },
+    snapshotAvailable() {
+        return true;
+    },
+    dispatchResourceRequest() {
+        return mockFulfilledSnapshotPromise;
+    },
+    applyCachePolicy() {
+        return mockFulfilledSnapshot;
+    },
+};
+function getMockLuvioWithFulfilledSnapshot() {
+    return mockLuvio;
+}
+function getMockFulfilledSnapshot() {
+    return mockFulfilledSnapshot;
 }
 
-function setupCustomLuvioMatchers() {
-    expect.extend(customMatchers);
+function setupCustomLuvioMatchers() {
+    expect.extend(customMatchers);
 }
 
-class MemoryDurableStorePersistence {
-    constructor() {
-        this.store = {};
-    }
-    async get(key) {
-        return this.store[key];
-    }
-    async set(key, value) {
-        // simulate a more realistic durable store by making the write wait a
-        // tick before actually setting the value
-        await flushPromises();
-        this.store[key] = value;
-    }
-    async delete(key) {
-        delete this.store[key];
-    }
-    async flushPendingWork() {
-        // since this implementation does actual "IO" synchronously the only
-        // thing necessary to await any pending IO is to flush the current
-        // microtask queue
-        await flushPromises();
-    }
+class MemoryDurableStorePersistence {
+    constructor() {
+        this.store = {};
+    }
+    async get(key) {
+        return this.store[key];
+    }
+    async set(key, value) {
+        // simulate a more realistic durable store by making the write wait a
+        // tick before actually setting the value
+        await flushPromises();
+        this.store[key] = value;
+    }
+    async delete(key) {
+        delete this.store[key];
+    }
+    async flushPendingWork() {
+        // since this implementation does actual "IO" synchronously the only
+        // thing necessary to await any pending IO is to flush the current
+        // microtask queue
+        await flushPromises();
+    }
 }
 
-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();
-}
-class MockDurableStore {
-    constructor(persistence) {
-        // for read/write synchronization
-        this.writePromises = new Set();
-        this.listeners = new Set();
-        this.persistence = persistence || new MemoryDurableStorePersistence();
-    }
-    async getEntries(entryIds, segment) {
-        // await any current write operations
-        if (this.writePromises.size > 0) {
-            await waitForPromiseSet(this.writePromises);
-        }
-        const entries = await this.persistence.get(segment);
-        if (entries === undefined) {
-            return undefined;
-        }
-        const returnSource = Object.create(null);
-        for (const entryId of entryIds) {
-            const entry = entries[entryId];
-            if (entry !== undefined) {
-                returnSource[entryId] = clone(entry);
-            }
-        }
-        return returnSource;
-    }
-    async getAllEntries(segment) {
-        // await any current write operations
-        if (this.writePromises.size > 0) {
-            await waitForPromiseSet(this.writePromises);
-        }
-        const entries = await this.persistence.get(segment);
-        return entries;
-    }
-    setEntries(entries, segment) {
-        return this.batchOperations([{ entries, segment, type: 'setEntries' }]);
-    }
-    evictEntries(ids, segment) {
-        return this.batchOperations([{ ids, segment, type: 'evictEntries' }]);
-    }
-    registerOnChangedListener(listener) {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-            return Promise.resolve();
-        };
-    }
-    async batchOperations(operations) {
-        // await any current write operations
-        if (this.writePromises.size > 0) {
-            await waitForPromiseSet(this.writePromises);
-        }
-        const changes = [];
-        const writePromise = (async () => {
-            for (const operation of operations) {
-                changes.push(await this.performOperation(operation));
-            }
-        })();
-        this.writePromises.add(writePromise);
-        try {
-            await writePromise;
-        }
-        finally {
-            this.writePromises.delete(writePromise);
-        }
-        const promises = [];
-        this.listeners.forEach((listener) => {
-            promises.push(listener(changes));
-        });
-        return Promise.all(promises).then(() => undefined);
-    }
-    async performOperation(operation) {
-        const segment = operation.segment;
-        const rawEntries = await this.persistence.get(segment);
-        const entries = rawEntries === undefined ? {} : rawEntries;
-        let ids = [];
-        switch (operation.type) {
-            case 'setEntries':
-                ids = Object.keys(operation.entries);
-                ids.forEach((id) => {
-                    entries[id] = clone(operation.entries[id]);
-                });
-                break;
-            case 'evictEntries':
-                ids = operation.ids;
-                ids.forEach((id) => {
-                    delete entries[id];
-                });
-        }
-        await this.persistence.set(operation.segment, entries);
-        return { ids, segment, type: operation.type };
-    }
-    async flushPendingOperations() {
-        // flush any pending read operations
-        await this.persistence.flushPendingWork();
-        // wait for any pending writes to finish
-        while (this.writePromises.size > 0) {
-            await waitForPromiseSet(this.writePromises);
-        }
-    }
+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();
+}
+class MockDurableStore {
+    constructor(persistence) {
+        // for read/write synchronization
+        this.writePromises = new Set();
+        this.listeners = new Set();
+        this.persistence = persistence || new MemoryDurableStorePersistence();
+    }
+    async getEntries(entryIds, segment) {
+        // await any current write operations
+        if (this.writePromises.size > 0) {
+            await waitForPromiseSet(this.writePromises);
+        }
+        const entries = await this.persistence.get(segment);
+        if (entries === undefined) {
+            return undefined;
+        }
+        const returnSource = Object.create(null);
+        for (const entryId of entryIds) {
+            const entry = entries[entryId];
+            if (entry !== undefined) {
+                returnSource[entryId] = clone(entry);
+            }
+        }
+        return returnSource;
+    }
+    async getAllEntries(segment) {
+        // await any current write operations
+        if (this.writePromises.size > 0) {
+            await waitForPromiseSet(this.writePromises);
+        }
+        const entries = await this.persistence.get(segment);
+        return entries;
+    }
+    setEntries(entries, segment) {
+        return this.batchOperations([{ entries, segment, type: 'setEntries' }]);
+    }
+    evictEntries(ids, segment) {
+        return this.batchOperations([{ ids, segment, type: 'evictEntries' }]);
+    }
+    registerOnChangedListener(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+            return Promise.resolve();
+        };
+    }
+    async batchOperations(operations) {
+        // await any current write operations
+        if (this.writePromises.size > 0) {
+            await waitForPromiseSet(this.writePromises);
+        }
+        const changes = [];
+        const writePromise = (async () => {
+            for (const operation of operations) {
+                changes.push(await this.performOperation(operation));
+            }
+        })();
+        this.writePromises.add(writePromise);
+        try {
+            await writePromise;
+        }
+        finally {
+            this.writePromises.delete(writePromise);
+        }
+        const promises = [];
+        this.listeners.forEach((listener) => {
+            promises.push(listener(changes));
+        });
+        return Promise.all(promises).then(() => undefined);
+    }
+    async performOperation(operation) {
+        const segment = operation.segment;
+        const rawEntries = await this.persistence.get(segment);
+        const entries = rawEntries === undefined ? {} : rawEntries;
+        let ids = [];
+        switch (operation.type) {
+            case 'setEntries':
+                ids = Object.keys(operation.entries);
+                ids.forEach((id) => {
+                    entries[id] = clone(operation.entries[id]);
+                });
+                break;
+            case 'evictEntries':
+                ids = operation.ids;
+                ids.forEach((id) => {
+                    delete entries[id];
+                });
+        }
+        await this.persistence.set(operation.segment, entries);
+        return { ids, segment, type: operation.type };
+    }
+    async flushPendingOperations() {
+        // flush any pending read operations
+        await this.persistence.flushPendingWork();
+        // wait for any pending writes to finish
+        while (this.writePromises.size > 0) {
+            await waitForPromiseSet(this.writePromises);
+        }
+    }
 }
 
-// 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) {
-    const store = new InMemoryStore();
-    const env = new Environment(store, mockNetworkAdapter);
-    return new Luvio(env);
-}
-async function testAdapterCompletesRoundtrip(params) {
-    const adapterSetup = setupAdapter(params);
-    const result = await callAdapter(adapterSetup, params);
-    expect(result.data).toBeDefined();
-    expect(result).toEqualFulfilledSnapshotWithData(params.type === 'network'
-        ? params.expectedData || params.network.response
-        : params.expectedData, params.privateProperties);
-}
-function setupAdapter(params) {
-    const 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
-    const expectedNetwork = [
-        buildSuccessMockPayload(networkConfig.request, networkConfig.response),
-    ];
-    const mockNetworkAdapter = buildMockNetworkAdapter(expectedNetwork);
-    return { luvio: buildLuvioInstance(mockNetworkAdapter), networkAdapter: mockNetworkAdapter };
-}
-async function callAdapter(adapter, params) {
-    const 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 snapshotOrPromise;
-    }
-    else {
-        // Cache hit
-        expect(snapshotOrPromise).not.toBeInstanceOf(Promise); // Expect cache hit to be synchronous
-        return Promise.resolve(snapshotOrPromise);
-    }
+// 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) {
+    const store = new InMemoryStore();
+    const env = new Environment(store, mockNetworkAdapter);
+    return new Luvio(env);
+}
+async function testAdapterCompletesRoundtrip(params) {
+    const adapterSetup = setupAdapter(params);
+    const result = await callAdapter(adapterSetup, params);
+    expect(result.data).toBeDefined();
+    expect(result).toEqualFulfilledSnapshotWithData(params.type === 'network'
+        ? params.expectedData || params.network.response
+        : params.expectedData, params.privateProperties);
+}
+function setupAdapter(params) {
+    const 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
+    const expectedNetwork = [
+        buildSuccessMockPayload(networkConfig.request, networkConfig.response),
+    ];
+    const mockNetworkAdapter = buildMockNetworkAdapter(expectedNetwork);
+    return { luvio: buildLuvioInstance(mockNetworkAdapter), networkAdapter: mockNetworkAdapter };
+}
+async function callAdapter(adapter, params) {
+    const 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 snapshotOrPromise;
+    }
+    else {
+        // Cache hit
+        expect(snapshotOrPromise).not.toBeInstanceOf(Promise); // Expect cache hit to be synchronous
+        return Promise.resolve(snapshotOrPromise);
+    }
 }
 
 export { ConnectivityState, MemoryDurableStorePersistence, MockDurableStore, buildErrorMockPayload, buildFetchResponse, buildLuvioInstance, buildLuvioWithNetwork, buildMockNetworkAdapter, buildSuccessMockPayload, customMatchers, flushPendingNetworkRequests, getMockFulfilledSnapshot, getMockLuvioWithFulfilledSnapshot, getMockNetworkAdapterCallCount, isImmutable, overrideMockNetworkResponses, resetMockNetworkAdapter, setMockNetworkPayloads, setNetworkConnectivity, setupCustomLuvioMatchers, stripProperties, testAdapterCompletesRoundtrip, verifyImmutable };