@luvio/adapter-test-library 0.142.2 → 0.142.4

package/src/network.ts

@@ -1,240 +0,0 @@
-import type { NetworkAdapter, ResourceRequest, FetchResponse, Headers } from '@luvio/engine';
-import sinon from 'sinon';
-
-import { clone, flushPromises } from './utils';
-
-const networkConnectivityStateMap = new WeakMap<sinon.SinonStub, ConnectivityState>();
-
-export enum ConnectivityState {
-    Online,
-    Offline,
-}
-
-export interface MockPayload {
-    // the args for the endpoint that will result in this payload
-    networkArgs: Partial<ResourceRequest>;
-
-    // mock response to be returned from calling the network adapter
-    response: FetchResponse<any>;
-}
-
-const callCountMap = new WeakMap<sinon.SinonStub, number>();
-const mockPayloadsMap = new WeakMap<sinon.SinonStub, MockPayload[]>();
-
-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: MockPayload, b: MockPayload) {
-    const {
-        networkArgs: { urlParams: bUrlParams, queryParams: bQueryParams, headers: bHeaders },
-    } = b;
-    const {
-        networkArgs: { urlParams: aUrlParams, queryParams: aQueryParams, headers: aHeaders },
-    } = a;
-
-    const aParams =
-        Object.keys(aUrlParams ?? {}).length +
-        Object.keys(aQueryParams ?? {}).length +
-        Object.keys(aHeaders ?? {}).length;
-    const bParams =
-        Object.keys(bUrlParams ?? {}).length +
-        Object.keys(bQueryParams ?? {}).length +
-        Object.keys(bHeaders ?? {}).length;
-
-    return aParams - bParams;
-}
-
-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());
-    callCountMap.set(networkAdapter, 0);
-    mockPayloadsMap.set(networkAdapter, mockPayloads);
-
-    setMockNetworkPayloads(networkAdapter, mockPayloads);
-
-    return networkAdapter as NetworkAdapter;
-}
-
-export function setNetworkConnectivity(
-    mockNetworkAdapter: NetworkAdapter,
-    connectivityState: ConnectivityState
-) {
-    const stub = mockNetworkAdapter as sinon.SinonStub;
-    networkConnectivityStateMap.set(stub, connectivityState);
-}
-
-function onNetworkStubCalled(stub: sinon.SinonStub, response: FetchResponse<any>) {
-    const { body, status, statusText, ok, headers } = response;
-
-    const currentCallCount = callCountMap.get(stub);
-    callCountMap.set(stub, currentCallCount ? currentCallCount + 1 : 1);
-
-    const connectivityState = networkConnectivityStateMap.get(stub) ?? ConnectivityState.Online;
-
-    if (connectivityState === ConnectivityState.Offline) {
-        return Promise.reject(buildOfflineError());
-    }
-
-    return Promise.resolve({
-        status,
-        statusText,
-        ok,
-        body: clone(body),
-        headers: clone(headers),
-    });
-}
-
-export function setMockNetworkPayloads(
-    mockNetworkAdapter: NetworkAdapter,
-    mockPayloads: MockPayload[]
-) {
-    const stub = mockNetworkAdapter as sinon.SinonStub;
-
-    // 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.
- */
-export function overrideMockNetworkResponses(
-    mockNetworkAdapter: NetworkAdapter,
-    responses: FetchResponse<any>[]
-) {
-    const stub = mockNetworkAdapter as sinon.SinonStub;
-    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);
-    });
-}
-
-export function resetMockNetworkAdapter(
-    mockNetworkAdapter: NetworkAdapter,
-    newPayloads?: MockPayload[]
-): void {
-    const stub = mockNetworkAdapter as sinon.SinonStub;
-
-    // reset stub in case a test modified payload responses
-    stub.reset();
-
-    // reset call count
-    callCountMap.set(stub, 0);
-
-    // set mock payloads up - Allow for the test to provide a different set of payloads
-    // Default behavior is to reset to the original payloads.
-    const payloads = newPayloads ? newPayloads : mockPayloadsMap.get(stub);
-    if (payloads) {
-        setMockNetworkPayloads(stub, payloads);
-    }
-}
-
-export function getMockNetworkAdapterCallCount(
-    mockNetworkAdapter: NetworkAdapter
-): number | undefined {
-    const stub = mockNetworkAdapter as sinon.SinonStub;
-    return callCountMap.get(stub);
-}
-
-export function buildFetchResponse<T>(
-    body: T,
-    status = 200,
-    statusText = 'Ok',
-    headers: Headers = {}
-): FetchResponse<T> {
-    return {
-        headers,
-        body,
-        status,
-        statusText,
-        ok: isOkResponse(status),
-    };
-}
-
-export function buildSuccessMockPayload(
-    networkArgs: Partial<ResourceRequest>,
-    body: any,
-    headers: Headers = {}
-): MockPayload {
-    const mockPayload: MockPayload = {
-        networkArgs,
-        response: buildFetchResponse(body, 200, 'Ok', headers),
-    };
-    return mockPayload;
-}
-
-export function buildErrorMockPayload(
-    networkArgs: Partial<ResourceRequest>,
-    body: any,
-    errorStatusCode: number,
-    errorStatusText: string,
-    headers: Headers = {}
-): MockPayload {
-    const mockPayload: MockPayload = {
-        networkArgs,
-        response: buildFetchResponse(body, errorStatusCode, errorStatusText, headers),
-    };
-    return mockPayload;
-}

package/src/utils.ts

@@ -1,207 +0,0 @@
-import type {
-    ErrorSnapshot,
-    FetchResponse,
-    FulfilledSnapshot,
-    NetworkAdapter,
-    Snapshot,
-    StaleSnapshot,
-} from '@luvio/engine';
-import { getMockNetworkAdapterCallCount } from './network';
-import { isImmutable } from './verification';
-
-/**
- * Clone an object
- *
- * @param {object} data The object to clone
- * @returns {object} The cloned object
- */
-export function clone<T>(data: T): T {
-    if (data === undefined) {
-        return undefined as T;
-    }
-
-    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
- */
-export function stripProperties(obj: { [s: string]: any }, props: string[]) {
-    // 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: { [s: string]: any }, props: string[]) {
-    props.forEach((prop) => {
-        delete obj[prop];
-    });
-
-    Object.keys(obj).forEach((key) => {
-        const value = obj[key];
-        if (typeof value === 'object' && value !== null) {
-            stripPropertiesMutating(value, props);
-        }
-    });
-}
-
-export function doesThrow(predicate: () => void) {
-    try {
-        predicate();
-    } catch (e) {
-        return true;
-    }
-    return false;
-}
-
-export function flushPromises() {
-    return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-type MatcherResult = { pass: boolean; message: () => string };
-// Copied from engine to avoid build time dependency
-// BEGIN OF COPY BLOCK
-enum SnapshotState {
-    Fulfilled = 'Fulfilled',
-    Unfulfilled = 'Unfulfilled',
-    Error = 'Error',
-    Pending = 'Pending',
-    Stale = 'Stale',
-}
-
-function isErrorSnapshot(snapshot: Snapshot<unknown, unknown>): snapshot is ErrorSnapshot {
-    return snapshot.state === SnapshotState.Error;
-}
-
-function isFulfilledSnapshot(
-    snapshot: Snapshot<unknown, unknown>
-): snapshot is FulfilledSnapshot<unknown, unknown> {
-    return snapshot.state === SnapshotState.Fulfilled;
-}
-
-function isStaleSnapshot(
-    snapshot: Snapshot<unknown, unknown>
-): snapshot is StaleSnapshot<unknown, unknown> {
-    return snapshot.state === SnapshotState.Stale;
-}
-// END OF COPY BLOCK
-
-export const customMatchers = {
-    toEqualFulfilledSnapshotWithData: (
-        snapshot: Snapshot<unknown, unknown>,
-        expected: any,
-        privateProperties?: string[]
-    ): MatcherResult => {
-        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: Snapshot<unknown, unknown>,
-        expected: any,
-        privateProperties?: string[]
-    ): MatcherResult => {
-        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: Snapshot<unknown, unknown>,
-        expectedStatus?: number
-    ): MatcherResult => {
-        if (isErrorSnapshot(actual)) {
-            expect(isImmutable(actual.error)).toBe(true);
-            expect(actual.data).toBeUndefined();
-            if (expectedStatus !== undefined) {
-                expect((actual.error as FetchResponse<unknown>).status).toBe(expectedStatus);
-            }
-            return { pass: true, message: () => 'Snapshot is an ErrorSnapshot' };
-        }
-
-        return {
-            pass: false,
-            message: () => 'Actual Snapshot is not a ErrorSnapshot.',
-        };
-    },
-    toEqualOfflineErrorSnapshot: (actual: Snapshot<unknown, unknown>): MatcherResult => {
-        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: NetworkAdapter, expected: Number): MatcherResult => {
-        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: NetworkAdapter): MatcherResult => {
-        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: FetchResponse<unknown>,
-        expected: FetchResponse<unknown>
-    ): MatcherResult => {
-        expect(actual).toEqual({ ...expected, errorType: 'fetchResponse' });
-        expect(isImmutable(actual)).toBe(true);
-
-        return { pass: true, message: () => 'Actual response equals expected response' };
-    },
-};

package/src/verification.ts

@@ -1,60 +0,0 @@
-import { doesThrow } from './utils';
-
-export function isImmutable(value: any): boolean {
-    return !doesThrow(() => {
-        // if verifyImmutable does not throw then the object is immutable
-        verifyImmutable(value, '$');
-    });
-}
-
-export function verifyImmutable(value: any, path: string): void {
-    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}`);
-    });
-}

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-    "extends": "../../../tsconfig.json",
-    "include": ["src", "matcher-types.d.ts"]
-}