@luvio/adapter-test-library 0.137.4 → 0.138.0

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

@@ -0,0 +1,35 @@
+import type { AdapterFactory, NetworkAdapter } from '@luvio/engine';
+import { Luvio } from '@luvio/engine';
+import type { MockPayload } from './network';
+export declare function buildLuvioInstance(mockNetworkAdapter: NetworkAdapter): Luvio;
+declare type AdapterRoundtripTestParams<C, D> = AdapterNetworkRoundtripTestParams<C, D> | AdapterNetworkRoundtripWithLuvioTestParams<C, D> | AdapterCacheHitRoundtripTestParams<C, D>;
+declare type AdapterTest<C, D> = {
+    adapterFactory: AdapterFactory<C, D>;
+    adapterConfig: C;
+    privateProperties?: string[];
+};
+declare type AdapterTestWithInjectedLuvio<C, D> = AdapterTest<C, D> & {
+    luvio: Luvio;
+    expectedData: D;
+};
+declare type NetworkConfig = {
+    request: MockPayload['networkArgs'];
+    response: any;
+};
+declare type AdapterNetworkRoundtripTestParams<C, D> = AdapterTest<C, D> & {
+    type: 'network';
+    network: NetworkConfig;
+    expectedData?: D;
+};
+declare type AdapterNetworkRoundtripWithLuvioTestParams<C, D> = AdapterTestWithInjectedLuvio<C, D> & {
+    type: 'injectedLuvioNetwork';
+};
+declare type AdapterCacheHitRoundtripTestParams<C, D> = AdapterTestWithInjectedLuvio<C, D> & {
+    type: 'cache';
+};
+export declare function testAdapterCompletesRoundtrip<C = any, D = any>(params: AdapterRoundtripTestParams<C, D>): Promise<void>;
+export declare function buildLuvioWithNetwork(networkConfig: NetworkConfig): {
+    luvio: Luvio;
+    networkAdapter: NetworkAdapter;
+};
+export {};

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

@@ -0,0 +1,10 @@
+import type { FetchResponse } from '@luvio/engine';
+export interface LuvioCustomMatchers<R> {
+    toEqualFulfilledSnapshotWithData: (expected: any, privateProperties?: string[]) => R;
+    toEqualStaleSnapshotWithData: (expected: any, privateProperties?: string[]) => R;
+    toEqualErrorSnapshot: (expectedStatus?: number) => R;
+    toEqualOfflineErrorSnapshot: () => R;
+    toHaveBeenHitTimes: (expected: Number) => R;
+    toHaveBeenHitOnce: () => R;
+    toEqualFetchResponse: (expected: FetchResponse<unknown>) => R;
+}

package/dist/es/es2018/jest.setup.d.ts

@@ -0,0 +1 @@
+export declare function setupCustomLuvioMatchers(): void;

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

@@ -1,6 +1,9 @@
 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 { stripProperties, customMatchers } from './utils';
+export { setupCustomLuvioMatchers } from './jest.setup';
 export { MockDurableStore } from './MockDurableStore';
 export { MemoryDurableStorePersistence, DurableStorePersistence } from './durableStorePersistence';
+export { testAdapterCompletesRoundtrip, buildLuvioWithNetwork, buildLuvioInstance, } from './adapterRoundtrip';
+export { LuvioCustomMatchers } from './customMatchers';

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

@@ -1,4 +1,52 @@
 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}`);
+    });
+}
 
 /**
  * Clone an object
@@ -51,7 +99,108 @@ function doesThrow(predicate) {
 }
 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;
@@ -213,53 +362,6 @@ function buildErrorMockPayload(networkArgs, body, errorStatusCode, errorStatusTe
     return mockPayload;
 }
 
-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}`);
-    });
-}
-
 const mockFulfilledSnapshot = { state: 'Fulfilled' };
 const mockFulfilledSnapshotPromise = {
     then() {
@@ -287,6 +389,10 @@ function getMockFulfilledSnapshot() {
     return mockFulfilledSnapshot;
 }
 
+function setupCustomLuvioMatchers() {
+    expect.extend(customMatchers);
+}
+
 class MemoryDurableStorePersistence {
     constructor() {
         this.store = {};
@@ -418,4 +524,49 @@ class MockDurableStore {
     }
 }
 
-export { ConnectivityState, MemoryDurableStorePersistence, MockDurableStore, buildErrorMockPayload, buildFetchResponse, buildMockNetworkAdapter, buildSuccessMockPayload, flushPendingNetworkRequests, getMockFulfilledSnapshot, getMockLuvioWithFulfilledSnapshot, getMockNetworkAdapterCallCount, isImmutable, overrideMockNetworkResponses, resetMockNetworkAdapter, setMockNetworkPayloads, setNetworkConnectivity, stripProperties, verifyImmutable };
+// 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 };

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

@@ -1,3 +1,4 @@
+import type { FetchResponse, NetworkAdapter, Snapshot } from '@luvio/engine';
 /**
  * Clone an object
  *
@@ -20,3 +21,17 @@ export declare function stripProperties(obj: {
 }, props: string[]): any;
 export declare function doesThrow(predicate: () => void): boolean;
 export declare function flushPromises(): Promise<unknown>;
+declare type MatcherResult = {
+    pass: boolean;
+    message: () => string;
+};
+export declare const customMatchers: {
+    toEqualFulfilledSnapshotWithData: (snapshot: Snapshot<unknown, unknown>, expected: any, privateProperties?: string[] | undefined) => MatcherResult;
+    toEqualStaleSnapshotWithData: (snapshot: Snapshot<unknown, unknown>, expected: any, privateProperties?: string[] | undefined) => MatcherResult;
+    toEqualErrorSnapshot: (actual: Snapshot<unknown, unknown>, expectedStatus?: number | undefined) => MatcherResult;
+    toEqualOfflineErrorSnapshot: (actual: Snapshot<unknown, unknown>) => MatcherResult;
+    toHaveBeenHitTimes: (mockNetworkAdapter: NetworkAdapter, expected: Number) => MatcherResult;
+    toHaveBeenHitOnce: (mockNetworkAdapter: NetworkAdapter) => MatcherResult;
+    toEqualFetchResponse: (actual: FetchResponse<unknown>, expected: FetchResponse<unknown>) => MatcherResult;
+};
+export {};

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

@@ -0,0 +1,35 @@
+import type { AdapterFactory, NetworkAdapter } from '@luvio/engine';
+import { Luvio } from '@luvio/engine';
+import type { MockPayload } from './network';
+export declare function buildLuvioInstance(mockNetworkAdapter: NetworkAdapter): Luvio;
+declare type AdapterRoundtripTestParams<C, D> = AdapterNetworkRoundtripTestParams<C, D> | AdapterNetworkRoundtripWithLuvioTestParams<C, D> | AdapterCacheHitRoundtripTestParams<C, D>;
+declare type AdapterTest<C, D> = {
+    adapterFactory: AdapterFactory<C, D>;
+    adapterConfig: C;
+    privateProperties?: string[];
+};
+declare type AdapterTestWithInjectedLuvio<C, D> = AdapterTest<C, D> & {
+    luvio: Luvio;
+    expectedData: D;
+};
+declare type NetworkConfig = {
+    request: MockPayload['networkArgs'];
+    response: any;
+};
+declare type AdapterNetworkRoundtripTestParams<C, D> = AdapterTest<C, D> & {
+    type: 'network';
+    network: NetworkConfig;
+    expectedData?: D;
+};
+declare type AdapterNetworkRoundtripWithLuvioTestParams<C, D> = AdapterTestWithInjectedLuvio<C, D> & {
+    type: 'injectedLuvioNetwork';
+};
+declare type AdapterCacheHitRoundtripTestParams<C, D> = AdapterTestWithInjectedLuvio<C, D> & {
+    type: 'cache';
+};
+export declare function testAdapterCompletesRoundtrip<C = any, D = any>(params: AdapterRoundtripTestParams<C, D>): Promise<void>;
+export declare function buildLuvioWithNetwork(networkConfig: NetworkConfig): {
+    luvio: Luvio;
+    networkAdapter: NetworkAdapter;
+};
+export {};

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

@@ -0,0 +1,10 @@
+import type { FetchResponse } from '@luvio/engine';
+export interface LuvioCustomMatchers<R> {
+    toEqualFulfilledSnapshotWithData: (expected: any, privateProperties?: string[]) => R;
+    toEqualStaleSnapshotWithData: (expected: any, privateProperties?: string[]) => R;
+    toEqualErrorSnapshot: (expectedStatus?: number) => R;
+    toEqualOfflineErrorSnapshot: () => R;
+    toHaveBeenHitTimes: (expected: Number) => R;
+    toHaveBeenHitOnce: () => R;
+    toEqualFetchResponse: (expected: FetchResponse<unknown>) => R;
+}

package/dist/umd/es2018/jest.setup.d.ts

@@ -0,0 +1 @@
+export declare function setupCustomLuvioMatchers(): void;

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

@@ -1,6 +1,9 @@
 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 { stripProperties, customMatchers } from './utils';
+export { setupCustomLuvioMatchers } from './jest.setup';
 export { MockDurableStore } from './MockDurableStore';
 export { MemoryDurableStorePersistence, DurableStorePersistence } from './durableStorePersistence';
+export { testAdapterCompletesRoundtrip, buildLuvioWithNetwork, buildLuvioInstance, } from './adapterRoundtrip';
+export { LuvioCustomMatchers } from './customMatchers';