@ethlete/query 6.0.0-next.5 → 6.0.0-next.51

package/fesm2022/ethlete-query-testing.mjs

@@ -27,12 +27,12 @@ const setupAuthTest = (config) => {
     }), extractRefreshTokens = (response) => ({
         accessToken: response.accessToken,
         refreshToken: response.refreshToken,
-    }), features, bearerDecryptFn, multiTabSync = false, refreshStrategy, minRefreshInterval, refreshIfExpired, expiresInPropertyName, } = config;
+    }), buildRefreshArgs, features, bearerDecryptFn, refreshStrategy, minRefreshInterval, refreshIfExpired, expiresInPropertyName, onRefreshFailure, } = config;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const login = querySetup.createPost(loginPath, {});
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const refresh = querySetup.createPost(refreshPath, {});
-    const [, injectAuth] = createBearerAuthProvider({
+    const { inject: injectAuth } = createBearerAuthProvider({
         name: 'test-auth',
         queryClientRef: querySetup.queryClientRef,
         queries: [
@@ -43,16 +43,17 @@ const setupAuthTest = (config) => {
             withRefreshQuery('refresh', {
                 queryCreator: refresh,
                 extractTokens: extractRefreshTokens,
+                buildArgs: buildRefreshArgs,
                 autoRetryOn401,
                 refreshStrategy,
                 minRefreshInterval,
                 refreshIfExpired,
                 expiresInPropertyName,
+                onRefreshFailure,
             }),
         ],
         features: (features ?? []),
         bearerDecryptFn,
-        multiTabSync,
     });
     const auth = TestBed.runInInjectionContext(() => {
         const provider = injectAuth();
@@ -96,37 +97,356 @@ const setupAuthTest = (config) => {
     };
 };
 
-const setupQueryTest = (config) => {
-    const baseUrl = config?.baseUrl ?? 'https://api.test.com';
-    const name = config?.name ?? 'test';
-    const mockErrorHandler = config?.mockErrorHandler !== false;
-    // Suppress console.warn for auth-related warnings during tests
-    const originalWarn = console.warn;
-    console.warn = (...args) => {
-        const message = args[0];
-        if (typeof message === 'string' && message.includes('auto-refresh')) {
-            return; // Suppress auto-refresh warnings
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Replaces `globalThis.BroadcastChannel` with an in-memory bus.
+ *
+ * Messages are structured-cloned at post time (so a non-cloneable payload throws exactly like the
+ * real API does), delivered on a microtask (never synchronously), and never delivered back to the
+ * channel that posted them - all three matching browser behavior. `await Promise.resolve()` in a
+ * spec is enough to flush delivery.
+ */
+const installFakeBroadcastChannel = () => {
+    const original = globalThis.BroadcastChannel;
+    const instances = new Set();
+    const posted = [];
+    class FakeBroadcastChannel {
+        constructor(name) {
+            this.name = name;
+            this.closed = false;
+            this.onmessage = null;
+            instances.add(this);
         }
-        originalWarn(...args);
-    };
-    // Suppress console.error for expected error scenarios during tests
-    const originalError = console.error;
-    console.error = (...args) => {
-        const message = args[0];
-        // Suppress HttpErrorResponse logs
-        if (message && typeof message === 'object' && 'name' in message && message.name === 'HttpErrorResponse') {
-            return;
+        postMessage(data) {
+            if (this.closed)
+                throw new DOMException('Channel is closed', 'InvalidStateError');
+            const clone = structuredClone(data);
+            posted.push({ channel: this.name, data: clone });
+            for (const instance of instances) {
+                if (instance === this || instance.closed || instance.name !== this.name)
+                    continue;
+                queueMicrotask(() => {
+                    if (instance.closed)
+                        return;
+                    instance.onmessage?.({ data: structuredClone(clone) });
+                });
+            }
         }
-        // Suppress bearer token decryption errors
-        if (typeof message === 'string' && message.includes('Failed to decrypt bearer token')) {
-            return;
+        close() {
+            this.closed = true;
+            instances.delete(this);
         }
-        // Suppress token extraction errors
-        if (typeof message === 'string' && message.includes('Failed to extract tokens from')) {
+        addEventListener() {
+            throw new Error('The fake BroadcastChannel only supports `onmessage`.');
+        }
+    }
+    globalThis.BroadcastChannel = FakeBroadcastChannel;
+    return {
+        posted,
+        restore: () => {
+            for (const instance of [...instances]) {
+                instance.closed = true;
+            }
+            instances.clear();
+            globalThis.BroadcastChannel = original;
+        },
+    };
+};
+/**
+ * Installs an in-memory `navigator.locks` implementing exclusive locks: one holder per name, the
+ * rest queued FIFO, granted on a microtask (never synchronously), released when the callback's
+ * promise settles. `signal` is honored for queued requests and - as in the real API - ignored once a
+ * request has been granted.
+ *
+ * `ifAvailable` is a try-lock: a request that cannot be granted straight away runs its callback with
+ * `null` instead of queueing, exactly as the real API does. `steal` releases the current holder -
+ * rejecting its request with an `AbortError` - and is granted ahead of everything queued.
+ *
+ * `mode: 'shared'` is not implemented; nothing in the library uses it.
+ */
+const installFakeWebLocks = () => {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(navigator, 'locks');
+    const holders = new Map();
+    const queues = new Map();
+    const abortError = () => new DOMException('The lock request was aborted', 'AbortError');
+    const pump = (name) => {
+        if (holders.has(name))
+            return;
+        const waiter = queues.get(name)?.shift();
+        if (!waiter)
             return;
+        waiter.granted = true;
+        holders.set(name, waiter);
+        const settle = (settleWaiter) => {
+            // Only if this waiter is still the holder: a stolen lock already has a new one, and the callback
+            // of the tab it was taken from settles afterwards.
+            if (holders.get(name) === waiter)
+                holders.delete(name);
+            waiter.releaseSignal();
+            settleWaiter();
+            pump(name);
+        };
+        // `pump` itself only ever runs from a microtask, so calling the callback right here keeps the
+        // grant exactly one microtask away from the `request()` call - which is what makes a single
+        // `flushMultiTabSync()` per hop enough in specs.
+        try {
+            Promise.resolve(waiter.callback({ name, mode: 'exclusive' })).then((value) => settle(() => waiter.resolve(value)), (error) => settle(() => waiter.reject(error)));
+        }
+        catch (error) {
+            settle(() => waiter.reject(error));
+        }
+    };
+    const request = (name, optionsOrCallback, maybeCallback) => {
+        const options = (typeof optionsOrCallback === 'function' ? {} : (optionsOrCallback ?? {}));
+        const callback = (typeof optionsOrCallback === 'function' ? optionsOrCallback : maybeCallback);
+        return new Promise((resolve, reject) => {
+            if (options.signal?.aborted) {
+                reject(abortError());
+                return;
+            }
+            const waiter = { callback, resolve, reject, granted: false, releaseSignal: () => undefined };
+            const signal = options.signal;
+            if (signal) {
+                const onAbort = () => {
+                    waiter.releaseSignal();
+                    if (waiter.granted)
+                        return;
+                    const queue = queues.get(name);
+                    if (queue)
+                        queues.set(name, queue.filter((entry) => entry !== waiter));
+                    reject(abortError());
+                };
+                signal.addEventListener('abort', onAbort);
+                waiter.releaseSignal = () => {
+                    waiter.releaseSignal = () => undefined;
+                    signal.removeEventListener('abort', onAbort);
+                };
+            }
+            if (options.steal) {
+                queueMicrotask(() => {
+                    const holder = holders.get(name);
+                    if (holder) {
+                        holders.delete(name);
+                        holder.reject(abortError());
+                    }
+                    queues.set(name, [waiter, ...(queues.get(name) ?? [])]);
+                    pump(name);
+                });
+                return;
+            }
+            // Availability is decided a microtask out, not here: that is when the real API decides it too, so
+            // two try-locks requested in the same tick still resolve to one winner and one `null`.
+            if (options.ifAvailable) {
+                queueMicrotask(() => {
+                    if (holders.has(name) || (queues.get(name)?.length ?? 0) > 0) {
+                        waiter.releaseSignal();
+                        Promise.resolve(callback(null)).then(resolve, reject);
+                        return;
+                    }
+                    queues.set(name, [waiter]);
+                    pump(name);
+                });
+                return;
+            }
+            queues.set(name, [...(queues.get(name) ?? []), waiter]);
+            queueMicrotask(() => pump(name));
+        });
+    };
+    // Both lists are reported, because a queued request is how a tab that is *not* the holder still
+    // shows up - which is what the auth leader election counts its tabs by.
+    const query = () => Promise.resolve({
+        held: [...holders.keys()].map((name) => ({ name, mode: 'exclusive' })),
+        pending: [...queues.entries()].flatMap(([name, waiters]) => waiters.map(() => ({ name, mode: 'exclusive' }))),
+    });
+    Object.defineProperty(navigator, 'locks', {
+        value: {
+            request,
+            query,
+        },
+        configurable: true,
+        writable: true,
+    });
+    return {
+        heldNames: () => [...holders.keys()],
+        pendingNames: () => [...queues.entries()].filter(([, queue]) => queue.length > 0).map(([name]) => name),
+        restore: () => {
+            for (const waiter of [...holders.values(), ...[...queues.values()].flat()])
+                waiter.releaseSignal();
+            holders.clear();
+            queues.clear();
+            if (originalDescriptor) {
+                Object.defineProperty(navigator, 'locks', originalDescriptor);
+            }
+            else {
+                delete navigator.locks;
+            }
+        },
+    };
+};
+/**
+ * Flushes the microtask queue, which is where both fakes schedule their work - message delivery and
+ * lock grants. Awaiting it once is enough for a single hop; a grant that has to wait for another
+ * tab's release needs one await per hop.
+ */
+const flushMultiTabSync = () => Promise.resolve();
+
+const quotaError = () => new DOMException('The quota has been exceeded.', 'QuotaExceededError');
+const createFakeQueryPersistenceStore = () => {
+    const store = new Map();
+    const calls = { loadIndex: 0, read: 0, write: 0, remove: 0, clear: 0 };
+    const deferredReads = [];
+    const deferredLoadIndexes = [];
+    let failingWrites = 0;
+    let writeError = null;
+    let failingRemoves = 0;
+    let removeError = null;
+    let loadIndexError = null;
+    let isDeferringReads = false;
+    let isDeferringLoadIndex = false;
+    // Cloning on the way in and on the way out is not pedantry: a real store hands back a copy, so a
+    // spec (or the engine) mutating a hydrated body must not be able to change what is "on disk".
+    const clone = (value) => structuredClone(value);
+    const loadIndex = async () => {
+        calls.loadIndex++;
+        if (loadIndexError !== null) {
+            const error = loadIndexError;
+            loadIndexError = null;
+            throw error;
+        }
+        // Taken before the gate, not after: a real store answers with what it held when the read started,
+        // so anything that empties it while a deferred load is held must not change what that load returns.
+        const snapshot = Array.from(store.values()).map(({ body: _body, ...meta }) => clone(meta));
+        if (isDeferringLoadIndex) {
+            await new Promise((resolve) => deferredLoadIndexes.push(resolve));
+        }
+        return snapshot;
+    };
+    const read = async (key) => {
+        calls.read++;
+        if (isDeferringReads) {
+            await new Promise((resolve) => deferredReads.push(resolve));
         }
-        originalError(...args);
+        const entry = store.get(key);
+        return entry ? { body: clone(entry.body), version: entry.version } : null;
     };
+    const write = async (entries) => {
+        calls.write++;
+        if (failingWrites > 0) {
+            failingWrites--;
+            throw writeError ?? quotaError();
+        }
+        for (const entry of entries) {
+            store.set(entry.key, clone(entry));
+        }
+    };
+    const remove = async (keys) => {
+        calls.remove++;
+        if (failingRemoves > 0) {
+            failingRemoves--;
+            throw removeError ?? new Error('The removal failed.');
+        }
+        for (const key of keys) {
+            store.delete(key);
+        }
+    };
+    const clear = async () => {
+        calls.clear++;
+        store.clear();
+    };
+    return {
+        adapter: { loadIndex, read, write, remove, clear, isSupported: true },
+        seed: (entries) => {
+            for (const entry of entries) {
+                store.set(entry.key, clone(entry));
+            }
+        },
+        entries: () => Array.from(store.values()).map(clone),
+        entry: (key) => {
+            const entry = store.get(key);
+            return entry ? clone(entry) : undefined;
+        },
+        calls: () => ({ ...calls }),
+        failNextWrites: (count, error) => {
+            failingWrites = count;
+            writeError = error ?? null;
+        },
+        failNextRemoves: (count, error) => {
+            failingRemoves = count;
+            removeError = error ?? null;
+        },
+        failNextLoadIndex: (error) => {
+            loadIndexError = error ?? quotaError();
+        },
+        deferReads: () => {
+            isDeferringReads = true;
+        },
+        flushReads: async () => {
+            isDeferringReads = false;
+            const pending = deferredReads.splice(0, deferredReads.length);
+            for (const resolve of pending) {
+                resolve();
+            }
+            await Promise.resolve();
+        },
+        deferLoadIndex: () => {
+            isDeferringLoadIndex = true;
+        },
+        flushLoadIndex: async () => {
+            isDeferringLoadIndex = false;
+            const pending = deferredLoadIndexes.splice(0, deferredLoadIndexes.length);
+            for (const resolve of pending) {
+                resolve();
+            }
+            await Promise.resolve();
+        },
+    };
+};
+
+let originalWarn = null;
+let originalError = null;
+const filteredWarn = (...args) => {
+    const message = args[0];
+    if (typeof message === 'string' && message.includes('auto-refresh')) {
+        return;
+    }
+    originalWarn?.(...args);
+};
+const filteredError = (...args) => {
+    const message = args[0];
+    if (message && typeof message === 'object' && 'name' in message && message.name === 'HttpErrorResponse') {
+        return;
+    }
+    if (typeof message === 'string' && message.includes('Failed to decrypt bearer token')) {
+        return;
+    }
+    if (typeof message === 'string' && message.includes('Failed to extract tokens from')) {
+        return;
+    }
+    originalError?.(...args);
+};
+// Capture only what is not already the wrapper, so repeated calls reinstall the one filter instead
+// of nesting a new closure over the previous one and stranding the pristine handlers.
+const installConsoleFilters = () => {
+    if (console.warn !== filteredWarn)
+        originalWarn = console.warn;
+    if (console.error !== filteredError)
+        originalError = console.error;
+    console.warn = filteredWarn;
+    console.error = filteredError;
+};
+const restoreConsole = () => {
+    if (originalWarn && console.warn === filteredWarn)
+        console.warn = originalWarn;
+    if (originalError && console.error === filteredError)
+        console.error = originalError;
+    originalWarn = null;
+    originalError = null;
+};
+const setupQueryTest = (config) => {
+    const baseUrl = config?.baseUrl ?? 'https://api.test.com';
+    const name = config?.name ?? 'test';
+    const mockErrorHandler = config?.mockErrorHandler !== false;
+    installConsoleFilters();
     const providers = [
         provideHttpClient(),
         provideHttpClientTesting(),
@@ -140,8 +460,8 @@ const setupQueryTest = (config) => {
     }
     TestBed.configureTestingModule({ providers });
     const queryClientRef = createQueryClient({ baseUrl, name });
-    const setup = TestBed.runInInjectionContext(() => {
-        const [, inject] = queryClientRef;
+    return TestBed.runInInjectionContext(() => {
+        const { inject } = queryClientRef;
         const queryClient = inject();
         if (!queryClient) {
             throw new Error('Failed to create query client in test setup');
@@ -158,21 +478,104 @@ const setupQueryTest = (config) => {
             createPut: createPutQuery(queryClientRef),
             createPatch: createPatchQuery(queryClientRef),
             createDelete: createDeleteQuery(queryClientRef),
+            restoreConsole,
         };
     });
-    // Restore console.warn and console.error when tests are done
-    const restoreConsole = () => {
-        console.warn = originalWarn;
-        console.error = originalError;
+};
+
+/**
+ * A socket io test double, for specs around `createWebSocketClient` - which takes its `io` factory as
+ * an option precisely so a spec (or an app that never opens a socket) needs no `socket.io-client`.
+ *
+ * Nothing here connects on its own: the client's own `connect()` only flips
+ * {@link WebSocketTestDouble.state}, and it is {@link WebSocketTestDouble.serverConnect} that fires
+ * the `connect` listener. That split is what makes "joined a room while disconnected, and it was
+ * re-joined after a reconnect" testable.
+ */
+const createWebSocketTestDouble = () => {
+    const sent = [];
+    const delivered = [];
+    const buffered = [];
+    const listeners = new Map();
+    const anyListeners = [];
+    const outgoingListeners = [];
+    let connection = null;
+    let withCredentials = null;
+    let auth;
+    const handshakes = [];
+    let connectRequested = false;
+    let disconnected = false;
+    let connected = false;
+    let pingExpired = false;
+    let recovered = false;
+    const deliver = (message) => {
+        for (const listener of outgoingListeners)
+            listener(message.event, message.data);
+        delivered.push(message);
+    };
+    const socket = {
+        connect: () => void (connectRequested = true),
+        disconnect: () => void (disconnected = true),
+        emit: (event, data) => {
+            sent.push({ event, data });
+            if (connected && !pingExpired)
+                deliver({ event, data });
+            else
+                buffered.push({ event, data });
+        },
+        on: (event, listener) => void listeners.set(event, listener),
+        onAny: (listener) => void anyListeners.push(listener),
+        onAnyOutgoing: (listener) => void outgoingListeners.push(listener),
+        get recovered() {
+            return recovered;
+        },
+    };
+    return {
+        io: (url, options) => {
+            connection = { url, transports: options.transports };
+            withCredentials = options.withCredentials;
+            auth = options.auth;
+            return socket;
+        },
+        connection: () => connection,
+        withCredentials: () => withCredentials,
+        handshakes: () => [...handshakes],
+        sent: () => [...sent],
+        delivered: () => [...delivered],
+        state: () => ({ connectRequested, disconnected }),
+        serverConnect: (options) => {
+            if (auth)
+                auth((data) => handshakes.push(data));
+            else
+                handshakes.push(null);
+            recovered = options?.recovered ?? false;
+            connected = true;
+            pingExpired = false;
+            for (const message of buffered.splice(0))
+                deliver(message);
+            listeners.get('connect')?.();
+        },
+        serverDisconnect: () => {
+            connected = false;
+            pingExpired = false;
+            listeners.get('disconnect')?.();
+        },
+        serverPingExpire: () => void (pingExpired = true),
+        serverSend: (message) => {
+            const frame = JSON.stringify(message);
+            for (const listener of anyListeners)
+                listener('message', frame);
+        },
+        serverSendRaw: (frame) => {
+            for (const listener of anyListeners)
+                listener('message', frame);
+        },
     };
-    // Store the restore function for cleanup
-    setup._restoreConsole = restoreConsole;
-    return setup;
 };
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { expectAndFlush, expectFlushAndWait, setupAuthTest, setupQueryTest };
+export { createFakeQueryPersistenceStore, createWebSocketTestDouble, expectAndFlush, expectFlushAndWait, flushMultiTabSync, installFakeBroadcastChannel, installFakeWebLocks, setupAuthTest, setupQueryTest };
 //# sourceMappingURL=ethlete-query-testing.mjs.map