@luvio/adapter-test-library 0.104.0 → 0.106.0

package/babel.config.js

@@ -0,0 +1 @@
+module.exports = require('../../../babel.config');

package/dist/es/es2018/{durableStore.d.ts → MockDurableStore.d.ts}

@@ -1,14 +1,16 @@
-import type { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation, DurableStoreChange } from '@luvio/environments';
+import type { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation } from '@luvio/environments';
 import type { DurableStorePersistence } from './durableStorePersistence';
 export declare class MockDurableStore implements DurableStore {
+    private writePromises;
     listeners: Set<OnDurableStoreChangedListener>;
     persistence: DurableStorePersistence;
     constructor(persistence?: DurableStorePersistence);
     getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T>>;
+    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
     setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
     evictEntries(ids: string[], segment: string): Promise<void>;
     registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;
     batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void>;
-    performOperation<T>(operation: DurableStoreOperation<T>): Promise<DurableStoreChange>;
+    private performOperation;
+    flushPendingOperations(): Promise<void>;
 }

package/dist/es/es2018/durableStorePersistence.d.ts

@@ -2,10 +2,12 @@ export interface DurableStorePersistence {
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
+    flushPendingWork(): Promise<void>;
 }
 export declare class MemoryDurableStorePersistence implements DurableStorePersistence {
     private store;
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
+    flushPendingWork(): Promise<void>;
 }

package/dist/es/es2018/main.d.ts

@@ -1,6 +1,6 @@
-export { MockPayload, ConnectivityState, buildMockNetworkAdapter, resetMockNetworkAdapter, getMockNetworkAdapterCallCount, buildSuccessMockPayload, buildErrorMockPayload, setMockNetworkPayloads, setNetworkConnectivity, buildFetchResponse, overrideMockNetworkResponses, } from './network';
+export { MockPayload, ConnectivityState, buildMockNetworkAdapter, resetMockNetworkAdapter, getMockNetworkAdapterCallCount, buildSuccessMockPayload, buildErrorMockPayload, setMockNetworkPayloads, setNetworkConnectivity, buildFetchResponse, overrideMockNetworkResponses, flushPendingNetworkRequests, } from './network';
 export { verifyImmutable, isImmutable } from './verification';
 export { getMockLuvioWithFulfilledSnapshot, getMockFulfilledSnapshot } from './mocks';
 export { stripProperties } from './utils';
-export { MockDurableStore } from './durableStore';
+export { MockDurableStore } from './MockDurableStore';
 export { MemoryDurableStorePersistence, DurableStorePersistence } from './durableStorePersistence';

package/dist/es/es2018/network.d.ts

@@ -7,6 +7,13 @@ export interface MockPayload {
     networkArgs: Partial<ResourceRequest>;
     response: FetchResponse<any>;
 }
+/**
+ * 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
+ */
+export declare function flushPendingNetworkRequests(_mockNetworkAdapter: NetworkAdapter): Promise<void>;
 export declare function buildMockNetworkAdapter(mockPayloads: MockPayload[]): NetworkAdapter;
 export declare function setNetworkConnectivity(mockNetworkAdapter: NetworkAdapter, connectivityState: ConnectivityState): void;
 export declare function setMockNetworkPayloads(mockNetworkAdapter: NetworkAdapter, mockPayloads: MockPayload[]): void;

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

@@ -1,5 +1,4 @@
 import sinon from 'sinon';
-import { DurableStoreOperationType } from '@luvio/environments';
 
 /**
  * Clone an object
@@ -49,6 +48,9 @@ function doesThrow(predicate) {
         return true;
     }
     return false;
+}
+function flushPromises() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
 }
 
 const networkConnectivityStateMap = new WeakMap();
@@ -94,6 +96,18 @@ function sortPayloads(a, b) {
 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());
@@ -281,53 +295,66 @@ class MemoryDurableStorePersistence {
         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) {
-        // NOTE: This mock class doesn't enforce read/write synchronization
+        // for read/write synchronization
+        this.writePromises = new Set();
         this.listeners = new Set();
         this.persistence = persistence || new MemoryDurableStorePersistence();
     }
-    getEntries(entryIds, segment) {
+    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);
-        return this.persistence.get(segment).then((entries) => {
-            if (entries === undefined) {
-                return undefined;
+        for (const entryId of entryIds) {
+            const entry = entries[entryId];
+            if (entry !== undefined) {
+                returnSource[entryId] = clone(entry);
             }
-            for (const entryId of entryIds) {
-                const entry = entries[entryId];
-                if (entry !== undefined) {
-                    returnSource[entryId] = clone(entry);
-                }
-            }
-            return returnSource;
-        });
+        }
+        return returnSource;
     }
-    getAllEntries(segment) {
-        const returnSource = Object.create(null);
-        return this.persistence.get(segment).then((rawEntries) => {
-            const entries = rawEntries === undefined ? {} : rawEntries;
-            for (const key of Object.keys(entries)) {
-                returnSource[key] = clone(entries[key]);
-            }
-            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: DurableStoreOperationType.SetEntries },
-        ]);
+        return this.batchOperations([{ entries, segment, type: 'setEntries' }]);
     }
     evictEntries(ids, segment) {
-        return this.batchOperations([
-            { ids, segment, type: DurableStoreOperationType.EvictEntries },
-        ]);
+        return this.batchOperations([{ ids, segment, type: 'evictEntries' }]);
     }
     registerOnChangedListener(listener) {
         this.listeners.add(listener);
@@ -337,9 +364,22 @@ class MockDurableStore {
         };
     }
     async batchOperations(operations) {
+        // await any current write operations
+        if (this.writePromises.size > 0) {
+            await waitForPromiseSet(this.writePromises);
+        }
         const changes = [];
-        for (let i = 0; i < operations.length; i++) {
-            changes.push(await this.performOperation(operations[i]));
+        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);
         }
         this.listeners.forEach((listener) => {
             listener(changes);
@@ -351,13 +391,13 @@ class MockDurableStore {
         const entries = rawEntries === undefined ? {} : rawEntries;
         let ids = [];
         switch (operation.type) {
-            case DurableStoreOperationType.SetEntries:
+            case 'setEntries':
                 ids = Object.keys(operation.entries);
                 ids.forEach((id) => {
                     entries[id] = clone(operation.entries[id]);
                 });
                 break;
-            case DurableStoreOperationType.EvictEntries:
+            case 'evictEntries':
                 ids = operation.ids;
                 ids.forEach((id) => {
                     delete entries[id];
@@ -366,6 +406,14 @@ class MockDurableStore {
         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);
+        }
+    }
 }
 
-export { ConnectivityState, MemoryDurableStorePersistence, MockDurableStore, buildErrorMockPayload, buildFetchResponse, buildMockNetworkAdapter, buildSuccessMockPayload, getMockFulfilledSnapshot, getMockLuvioWithFulfilledSnapshot, getMockNetworkAdapterCallCount, isImmutable, overrideMockNetworkResponses, resetMockNetworkAdapter, setMockNetworkPayloads, setNetworkConnectivity, stripProperties, verifyImmutable };
+export { ConnectivityState, MemoryDurableStorePersistence, MockDurableStore, buildErrorMockPayload, buildFetchResponse, buildMockNetworkAdapter, buildSuccessMockPayload, flushPendingNetworkRequests, getMockFulfilledSnapshot, getMockLuvioWithFulfilledSnapshot, getMockNetworkAdapterCallCount, isImmutable, overrideMockNetworkResponses, resetMockNetworkAdapter, setMockNetworkPayloads, setNetworkConnectivity, stripProperties, verifyImmutable };

package/dist/es/es2018/utils.d.ts

@@ -19,3 +19,4 @@ export declare function stripProperties(obj: {
     [s: string]: any;
 }, props: string[]): any;
 export declare function doesThrow(predicate: () => void): boolean;
+export declare function flushPromises(): Promise<unknown>;

package/dist/umd/es2018/{durableStore.d.ts → MockDurableStore.d.ts}

@@ -1,14 +1,16 @@
-import type { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation, DurableStoreChange } from '@luvio/environments';
+import type { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation } from '@luvio/environments';
 import type { DurableStorePersistence } from './durableStorePersistence';
 export declare class MockDurableStore implements DurableStore {
+    private writePromises;
     listeners: Set<OnDurableStoreChangedListener>;
     persistence: DurableStorePersistence;
     constructor(persistence?: DurableStorePersistence);
     getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T>>;
+    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
     setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
     evictEntries(ids: string[], segment: string): Promise<void>;
     registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;
     batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void>;
-    performOperation<T>(operation: DurableStoreOperation<T>): Promise<DurableStoreChange>;
+    private performOperation;
+    flushPendingOperations(): Promise<void>;
 }

package/dist/umd/es2018/durableStorePersistence.d.ts

@@ -2,10 +2,12 @@ export interface DurableStorePersistence {
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
+    flushPendingWork(): Promise<void>;
 }
 export declare class MemoryDurableStorePersistence implements DurableStorePersistence {
     private store;
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
+    flushPendingWork(): Promise<void>;
 }

package/dist/umd/es2018/main.d.ts

@@ -1,6 +1,6 @@
-export { MockPayload, ConnectivityState, buildMockNetworkAdapter, resetMockNetworkAdapter, getMockNetworkAdapterCallCount, buildSuccessMockPayload, buildErrorMockPayload, setMockNetworkPayloads, setNetworkConnectivity, buildFetchResponse, overrideMockNetworkResponses, } from './network';
+export { MockPayload, ConnectivityState, buildMockNetworkAdapter, resetMockNetworkAdapter, getMockNetworkAdapterCallCount, buildSuccessMockPayload, buildErrorMockPayload, setMockNetworkPayloads, setNetworkConnectivity, buildFetchResponse, overrideMockNetworkResponses, flushPendingNetworkRequests, } from './network';
 export { verifyImmutable, isImmutable } from './verification';
 export { getMockLuvioWithFulfilledSnapshot, getMockFulfilledSnapshot } from './mocks';
 export { stripProperties } from './utils';
-export { MockDurableStore } from './durableStore';
+export { MockDurableStore } from './MockDurableStore';
 export { MemoryDurableStorePersistence, DurableStorePersistence } from './durableStorePersistence';

package/dist/umd/es2018/network.d.ts

@@ -7,6 +7,13 @@ export interface MockPayload {
     networkArgs: Partial<ResourceRequest>;
     response: FetchResponse<any>;
 }
+/**
+ * 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
+ */
+export declare function flushPendingNetworkRequests(_mockNetworkAdapter: NetworkAdapter): Promise<void>;
 export declare function buildMockNetworkAdapter(mockPayloads: MockPayload[]): NetworkAdapter;
 export declare function setNetworkConnectivity(mockNetworkAdapter: NetworkAdapter, connectivityState: ConnectivityState): void;
 export declare function setMockNetworkPayloads(mockNetworkAdapter: NetworkAdapter, mockPayloads: MockPayload[]): void;

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

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('sinon'), require('@luvio/environments')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'sinon', '@luvio/environments'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioAdapterTestLibrary = {}, global.sinon, global.environments));
-})(this, (function (exports, sinon, environments) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('sinon')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'sinon'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioAdapterTestLibrary = {}, global.sinon));
+})(this, (function (exports, sinon) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -56,6 +56,9 @@
             return true;
         }
         return false;
+    }
+    function flushPromises() {
+        return new Promise((resolve) => setTimeout(resolve, 0));
     }
 
     const networkConnectivityStateMap = new WeakMap();
@@ -101,6 +104,18 @@
     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__default["default"].stub().rejects(buildMockSetupError());
@@ -288,53 +303,66 @@
             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) {
-            // NOTE: This mock class doesn't enforce read/write synchronization
+            // for read/write synchronization
+            this.writePromises = new Set();
             this.listeners = new Set();
             this.persistence = persistence || new MemoryDurableStorePersistence();
         }
-        getEntries(entryIds, segment) {
+        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);
-            return this.persistence.get(segment).then((entries) => {
-                if (entries === undefined) {
-                    return undefined;
+            for (const entryId of entryIds) {
+                const entry = entries[entryId];
+                if (entry !== undefined) {
+                    returnSource[entryId] = clone(entry);
                 }
-                for (const entryId of entryIds) {
-                    const entry = entries[entryId];
-                    if (entry !== undefined) {
-                        returnSource[entryId] = clone(entry);
-                    }
-                }
-                return returnSource;
-            });
+            }
+            return returnSource;
         }
-        getAllEntries(segment) {
-            const returnSource = Object.create(null);
-            return this.persistence.get(segment).then((rawEntries) => {
-                const entries = rawEntries === undefined ? {} : rawEntries;
-                for (const key of Object.keys(entries)) {
-                    returnSource[key] = clone(entries[key]);
-                }
-                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: environments.DurableStoreOperationType.SetEntries },
-            ]);
+            return this.batchOperations([{ entries, segment, type: 'setEntries' }]);
         }
         evictEntries(ids, segment) {
-            return this.batchOperations([
-                { ids, segment, type: environments.DurableStoreOperationType.EvictEntries },
-            ]);
+            return this.batchOperations([{ ids, segment, type: 'evictEntries' }]);
         }
         registerOnChangedListener(listener) {
             this.listeners.add(listener);
@@ -344,9 +372,22 @@
             };
         }
         async batchOperations(operations) {
+            // await any current write operations
+            if (this.writePromises.size > 0) {
+                await waitForPromiseSet(this.writePromises);
+            }
             const changes = [];
-            for (let i = 0; i < operations.length; i++) {
-                changes.push(await this.performOperation(operations[i]));
+            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);
             }
             this.listeners.forEach((listener) => {
                 listener(changes);
@@ -358,13 +399,13 @@
             const entries = rawEntries === undefined ? {} : rawEntries;
             let ids = [];
             switch (operation.type) {
-                case environments.DurableStoreOperationType.SetEntries:
+                case 'setEntries':
                     ids = Object.keys(operation.entries);
                     ids.forEach((id) => {
                         entries[id] = clone(operation.entries[id]);
                     });
                     break;
-                case environments.DurableStoreOperationType.EvictEntries:
+                case 'evictEntries':
                     ids = operation.ids;
                     ids.forEach((id) => {
                         delete entries[id];
@@ -373,6 +414,14 @@
             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);
+            }
+        }
     }
 
     exports.MemoryDurableStorePersistence = MemoryDurableStorePersistence;
@@ -381,6 +430,7 @@
     exports.buildFetchResponse = buildFetchResponse;
     exports.buildMockNetworkAdapter = buildMockNetworkAdapter;
     exports.buildSuccessMockPayload = buildSuccessMockPayload;
+    exports.flushPendingNetworkRequests = flushPendingNetworkRequests;
     exports.getMockFulfilledSnapshot = getMockFulfilledSnapshot;
     exports.getMockLuvioWithFulfilledSnapshot = getMockLuvioWithFulfilledSnapshot;
     exports.getMockNetworkAdapterCallCount = getMockNetworkAdapterCallCount;

package/dist/umd/es2018/utils.d.ts

@@ -19,3 +19,4 @@ export declare function stripProperties(obj: {
     [s: string]: any;
 }, props: string[]): any;
 export declare function doesThrow(predicate: () => void): boolean;
+export declare function flushPromises(): Promise<unknown>;

package/dist/umd/es5/{durableStore.d.ts → MockDurableStore.d.ts}

@@ -1,14 +1,16 @@
-import type { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation, DurableStoreChange } from '@luvio/environments';
+import type { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation } from '@luvio/environments';
 import type { DurableStorePersistence } from './durableStorePersistence';
 export declare class MockDurableStore implements DurableStore {
+    private writePromises;
     listeners: Set<OnDurableStoreChangedListener>;
     persistence: DurableStorePersistence;
     constructor(persistence?: DurableStorePersistence);
     getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T>>;
+    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
     setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
     evictEntries(ids: string[], segment: string): Promise<void>;
     registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;
     batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void>;
-    performOperation<T>(operation: DurableStoreOperation<T>): Promise<DurableStoreChange>;
+    private performOperation;
+    flushPendingOperations(): Promise<void>;
 }

package/dist/umd/es5/durableStorePersistence.d.ts

@@ -2,10 +2,12 @@ export interface DurableStorePersistence {
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
+    flushPendingWork(): Promise<void>;
 }
 export declare class MemoryDurableStorePersistence implements DurableStorePersistence {
     private store;
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
+    flushPendingWork(): Promise<void>;
 }

package/dist/umd/es5/main.d.ts

@@ -1,6 +1,6 @@
-export { MockPayload, ConnectivityState, buildMockNetworkAdapter, resetMockNetworkAdapter, getMockNetworkAdapterCallCount, buildSuccessMockPayload, buildErrorMockPayload, setMockNetworkPayloads, setNetworkConnectivity, buildFetchResponse, overrideMockNetworkResponses, } from './network';
+export { MockPayload, ConnectivityState, buildMockNetworkAdapter, resetMockNetworkAdapter, getMockNetworkAdapterCallCount, buildSuccessMockPayload, buildErrorMockPayload, setMockNetworkPayloads, setNetworkConnectivity, buildFetchResponse, overrideMockNetworkResponses, flushPendingNetworkRequests, } from './network';
 export { verifyImmutable, isImmutable } from './verification';
 export { getMockLuvioWithFulfilledSnapshot, getMockFulfilledSnapshot } from './mocks';
 export { stripProperties } from './utils';
-export { MockDurableStore } from './durableStore';
+export { MockDurableStore } from './MockDurableStore';
 export { MemoryDurableStorePersistence, DurableStorePersistence } from './durableStorePersistence';

package/dist/umd/es5/network.d.ts

@@ -7,6 +7,13 @@ export interface MockPayload {
     networkArgs: Partial<ResourceRequest>;
     response: FetchResponse<any>;
 }
+/**
+ * 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
+ */
+export declare function flushPendingNetworkRequests(_mockNetworkAdapter: NetworkAdapter): Promise<void>;
 export declare function buildMockNetworkAdapter(mockPayloads: MockPayload[]): NetworkAdapter;
 export declare function setNetworkConnectivity(mockNetworkAdapter: NetworkAdapter, connectivityState: ConnectivityState): void;
 export declare function setMockNetworkPayloads(mockNetworkAdapter: NetworkAdapter, mockPayloads: MockPayload[]): void;