@luvio/adapter-test-library 0.105.0 → 0.108.0

package/src/__tests__/MockDurableStore.spec.ts

@@ -0,0 +1,53 @@
+import type { DurableStorePersistence } from '../durableStorePersistence';
+import { MockDurableStore } from '../MockDurableStore';
+
+describe('MockDurableStore', () => {
+    describe('read/write synchronization', () => {
+        it('allows parallel reads', async () => {
+            const persistence: DurableStorePersistence = {
+                get: jest.fn().mockResolvedValue(undefined),
+                set: jest.fn().mockResolvedValue(undefined),
+                delete: jest.fn().mockResolvedValue(undefined),
+            };
+            const ds = new MockDurableStore(persistence);
+            const segment = 'foo';
+
+            // kick off reads without awaiting, all should start
+            const promise1 = ds.getAllEntries(segment);
+            const promise2 = ds.getAllEntries(segment);
+            const promise3 = ds.getEntries(['123'], segment);
+
+            expect(persistence.get).toBeCalledTimes(3);
+
+            const result1 = await promise1;
+            const result2 = await promise2;
+            const result3 = await promise3;
+
+            expect(result1).toBe(undefined);
+            expect(result2).toBe(undefined);
+            expect(result3).toBe(undefined);
+        });
+
+        it('read then write then read will respect ordering', async () => {
+            const ds = new MockDurableStore();
+            const segment = 'foo';
+            const key = '123';
+            const value = {};
+
+            const read1Promise = ds.getEntries([key], segment);
+            const write1Promise = ds.setEntries({ [key]: { data: value } }, segment);
+            const read2Promise = ds.getEntries([key], segment);
+
+            // first read should be empty
+            const read1Result = await read1Promise;
+            expect(read1Result).toBe(undefined);
+
+            // wait for the write to finish
+            await write1Promise;
+
+            // second read should include data from the write
+            const read2Result = await read2Promise;
+            expect(read2Result).toEqual({ [key]: { data: value } });
+        });
+    });
+});

package/src/durableStorePersistence.ts

@@ -1,7 +1,10 @@
+import { flushPromises } from './utils';
+
 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 class MemoryDurableStorePersistence implements DurableStorePersistence {
@@ -12,10 +15,20 @@ export class MemoryDurableStorePersistence implements DurableStorePersistence {
     }
 
     async set<T>(key: string, value: T): Promise<void> {
+        // 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: string): Promise<void> {
         delete this.store[key];
     }
+
+    async flushPendingWork(): Promise<void> {
+        // 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();
+    }
 }

package/src/main.ts

@@ -10,9 +10,10 @@ export {
     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/src/network.ts

@@ -1,7 +1,7 @@
 import type { NetworkAdapter, ResourceRequest, FetchResponse, Headers } from '@luvio/engine';
 import sinon from 'sinon';
 
-import { clone } from './utils';
+import { clone, flushPromises } from './utils';
 
 const networkConnectivityStateMap = new WeakMap<sinon.SinonStub, ConnectivityState>();
 
@@ -68,6 +68,21 @@ function isOkResponse(status: number) {
     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
+ */
+export async function flushPendingNetworkRequests(
+    _mockNetworkAdapter: NetworkAdapter
+): Promise<void> {
+    // 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();
+}
+
 export function buildMockNetworkAdapter(mockPayloads: MockPayload[]) {
     // any endpoints not setup with a fake will return a rejected promise
     const networkAdapter = sinon.stub().rejects(buildMockSetupError());

package/src/utils.ts

@@ -51,3 +51,7 @@ export function doesThrow(predicate: () => void) {
     }
     return false;
 }
+
+export function flushPromises() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}

package/src/durableStore.ts

@@ -1,108 +0,0 @@
-import type {
-    DurableStore,
-    DurableStoreEntries,
-    OnDurableStoreChangedListener,
-    DurableStoreOperation,
-    DurableStoreChange,
-} from '@luvio/environments';
-import { DurableStoreOperationType } from '@luvio/environments';
-import { clone } from './utils';
-import type { DurableStorePersistence } from './durableStorePersistence';
-import { MemoryDurableStorePersistence } from './durableStorePersistence';
-export class MockDurableStore implements DurableStore {
-    // NOTE: This mock class doesn't enforce read/write synchronization
-
-    listeners = new Set<OnDurableStoreChangedListener>();
-    persistence: DurableStorePersistence;
-
-    constructor(persistence?: DurableStorePersistence) {
-        this.persistence = persistence || new MemoryDurableStorePersistence();
-    }
-
-    getEntries<T>(
-        entryIds: string[],
-        segment: string
-    ): Promise<DurableStoreEntries<T> | undefined> {
-        const returnSource = Object.create(null);
-        return this.persistence.get<DurableStoreEntries<T>>(segment).then((entries) => {
-            if (entries === undefined) {
-                return undefined;
-            }
-
-            for (const entryId of entryIds) {
-                const entry = entries[entryId];
-                if (entry !== undefined) {
-                    returnSource[entryId] = clone(entry);
-                }
-            }
-            return returnSource;
-        });
-    }
-
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T>> {
-        const returnSource = Object.create(null);
-
-        return this.persistence.get<DurableStoreEntries<T>>(segment).then((rawEntries) => {
-            const entries = rawEntries === undefined ? {} : rawEntries;
-
-            for (const key of Object.keys(entries)) {
-                returnSource[key] = clone(entries[key]);
-            }
-            return returnSource;
-        });
-    }
-
-    setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void> {
-        return this.batchOperations([
-            { entries, segment, type: DurableStoreOperationType.SetEntries },
-        ]);
-    }
-
-    evictEntries(ids: string[], segment: string): Promise<void> {
-        return this.batchOperations([
-            { ids, segment, type: DurableStoreOperationType.EvictEntries },
-        ]);
-    }
-
-    registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void> {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-            return Promise.resolve();
-        };
-    }
-
-    async batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void> {
-        const changes: DurableStoreChange[] = [];
-        for (let i = 0; i < operations.length; i++) {
-            changes.push(await this.performOperation(operations[i]));
-        }
-
-        this.listeners.forEach((listener) => {
-            listener(changes);
-        });
-    }
-
-    async performOperation<T>(operation: DurableStoreOperation<T>): Promise<DurableStoreChange> {
-        const segment = operation.segment;
-        const rawEntries = await this.persistence.get<DurableStoreEntries<T>>(segment);
-        const entries = rawEntries === undefined ? {} : rawEntries;
-        let ids: string[] = [];
-        switch (operation.type) {
-            case DurableStoreOperationType.SetEntries:
-                ids = Object.keys(operation.entries);
-                ids.forEach((id) => {
-                    entries[id] = clone(operation.entries[id]);
-                });
-                break;
-            case DurableStoreOperationType.EvictEntries:
-                ids = operation.ids;
-                ids.forEach((id) => {
-                    delete entries[id];
-                });
-        }
-
-        await this.persistence.set(operation.segment, entries);
-        return { ids, segment, type: operation.type };
-    }
-}