@cratis/arc 20.3.1 → 20.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/arc",
-    "version": "20.3.1",
+    "version": "20.3.2",
     "description": "",
     "author": "Cratis",
     "license": "MIT",

package/queries/ObservableQueryConnectionFactory.ts

@@ -87,9 +87,30 @@ function createDirectSSEConnection<TDataType>(descriptor: QueryConnectionDescrip
 
 // ---- Multiplexed mode: centralized endpoint, multiple queries share connections ----
 
+/**
+ * Maximum number of SSE hub connections that fits safely within the HTTP/1.1 browser
+ * per-origin connection limit (typically 6 for Chrome/Firefox). Each SSE EventSource
+ * occupies one persistent connection slot indefinitely. Exceeding this cap blocks the
+ * subscribe/unsubscribe POST requests that share the same pool, causing queries to hang.
+ * Servers configured for HTTP/2 do not have this restriction.
+ */
+const MAX_SAFE_SSE_CONNECTIONS = 4;
+
 function createMultiplexedConnection<TDataType>(descriptor: QueryConnectionDescriptor, isSSE: boolean): IObservableQueryConnection<TDataType> {
     const transport = isSSE ? 'sse' : 'ws';
-    const cacheKey = `${Globals.queryConnectionCount}|${transport}|${descriptor.origin}|${descriptor.apiBasePath}|${descriptor.microservice}`;
+    const requestedCount = Globals.queryConnectionCount;
+    const effectiveCount = isSSE ? Math.min(requestedCount, MAX_SAFE_SSE_CONNECTIONS) : requestedCount;
+
+    if (isSSE && requestedCount > MAX_SAFE_SSE_CONNECTIONS) {
+        console.warn(
+            `[Arc] queryConnectionCount (${requestedCount}) exceeds the safe limit for SSE transport (${MAX_SAFE_SSE_CONNECTIONS}). ` +
+            `HTTP/1.1 browsers allow at most 6 concurrent connections per origin; ` +
+            `using more SSE connections blocks subscribe/unsubscribe requests, causing queries to hang. ` +
+            `Capping at ${MAX_SAFE_SSE_CONNECTIONS}. Enable HTTP/2 on your server to use a higher connection count.`
+        );
+    }
+
+    const cacheKey = `${requestedCount}|${transport}|${descriptor.origin}|${descriptor.apiBasePath}|${descriptor.microservice}`;
 
     const multiplexer = getOrCreateMultiplexer(() => {
         if (isSSE) {
@@ -112,7 +133,7 @@ function createMultiplexedConnection<TDataType>(descriptor: QueryConnectionDescr
             const wsUrl = `${secure ? 'wss' : 'ws'}://${hubUrl.host}${hubUrl.pathname}${hubUrl.search}`;
             return new WebSocketHubConnection(wsUrl, descriptor.microservice);
         }
-    }, cacheKey);
+    }, cacheKey, effectiveCount);
 
     return new MultiplexedObservableQueryConnection<TDataType>(multiplexer, descriptor.queryName);
 }

package/queries/ObservableQueryMultiplexer.ts

@@ -190,15 +190,16 @@ let _sharedMultiplexerKey = '';
  * configuration (connection count, origin, base path, microservice, transport) changes.
  * @param {() => IObservableQueryHubConnection} connectionFactory Factory to create individual connections.
  * @param {string} cacheKey A string that identifies the current configuration for invalidation.
+ * @param {number} size Number of physical connections to create. Defaults to {@link Globals.queryConnectionCount}.
  * @returns The shared multiplexer instance.
  */
-export function getOrCreateMultiplexer(connectionFactory: () => IObservableQueryHubConnection, cacheKey: string): ObservableQueryMultiplexer {
+export function getOrCreateMultiplexer(connectionFactory: () => IObservableQueryHubConnection, cacheKey: string, size: number = Globals.queryConnectionCount): ObservableQueryMultiplexer {
     if (_sharedMultiplexer && _sharedMultiplexerKey === cacheKey) {
         return _sharedMultiplexer;
     }
 
     _sharedMultiplexer?.dispose();
-    _sharedMultiplexer = new ObservableQueryMultiplexer(Globals.queryConnectionCount, connectionFactory);
+    _sharedMultiplexer = new ObservableQueryMultiplexer(size, connectionFactory);
     _sharedMultiplexerKey = cacheKey;
     return _sharedMultiplexer;
 }

package/queries/QueryInstanceCache.ts

@@ -50,9 +50,9 @@ export interface QueryCacheEntry<TDataType> {
     subscribed: boolean;
 
     /**
-     * Timer handle for deferred cleanup when running in development mode.
-     * Allows React StrictMode re-mounts to cancel the pending teardown
-     * so the connection is reused instead of torn down and recreated.
+     * Timer handle for deferred cleanup. Allows React StrictMode re-mounts (in any build
+     * environment) to cancel the pending teardown so the connection is reused instead of
+     * torn down and recreated.
      */
     pendingCleanup?: ReturnType<typeof setTimeout>;
 }
@@ -67,16 +67,17 @@ export interface QueryCacheEntry<TDataType> {
  */
 export class QueryInstanceCache {
     private readonly _entries = new Map<QueryCacheKey, QueryCacheEntry<unknown>>();
-    private readonly _development: boolean;
     private _pendingDispose?: ReturnType<typeof setTimeout>;
 
     /**
      * Initializes a new instance of {@link QueryInstanceCache}.
-     * @param development When true, teardown is deferred on release so React StrictMode
-     *   re-mounts can re-acquire the entry without an unnecessary disconnect/reconnect cycle.
+     * @param development Accepted for API compatibility. No longer changes teardown behavior —
+     *   teardown is always deferred to handle React StrictMode re-mounts in any environment.
      */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     constructor(development: boolean = false) {
-        this._development = development;
+        // The development parameter is kept for API compatibility only.
+        // Teardown is always deferred regardless of this flag.
     }
 
     /**
@@ -131,7 +132,7 @@ export class QueryInstanceCache {
 
     /**
      * Increments the active subscriber count for the given key.
-     * If a deferred cleanup was pending (from a recent {@link release} in development mode),
+     * If a deferred cleanup was pending (from a recent {@link release}),
      * it is cancelled so the existing subscription is reused.
      * Call from `useEffect` setup to pair with {@link release} in the cleanup.
      * @param key The cache key produced by {@link buildKey}.
@@ -230,13 +231,11 @@ export class QueryInstanceCache {
     }
 
     /**
-     * Decrements the subscriber count for the given key. When the count reaches zero the teardown
-     * function is called (if set) and the entry is evicted.
-     *
-     * In development mode, both teardown and eviction are deferred by one microtask so that
-     * React StrictMode re-mounts can re-acquire the entry and cancel the cleanup. This prevents
-     * an unnecessary disconnect/reconnect cycle during the synthetic unmount/remount that
-     * StrictMode performs in development builds.
+     * Decrements the subscriber count for the given key. When the count reaches zero, both teardown
+     * and eviction are deferred by one microtask so that React StrictMode re-mounts — in any build
+     * environment — can re-acquire the entry and cancel the cleanup before the timeout fires. This
+     * prevents an unnecessary disconnect/reconnect cycle during the synthetic unmount/remount that
+     * StrictMode performs.
      * @param key The cache key produced by {@link buildKey}.
      */
     release(key: QueryCacheKey): void {
@@ -246,33 +245,19 @@ export class QueryInstanceCache {
             entry.subscriberCount--;
 
             if (entry.subscriberCount <= 0) {
-                if (this._development) {
-                    // Defer both teardown and deletion so StrictMode re-mounts can cancel.
-                    entry.pendingCleanup = setTimeout(() => {
-                        const current = this._entries.get(key);
-
-                        if (current && current.subscriberCount <= 0) {
-                            current.subscribed = false;
-                            current.teardown?.();
-                            current.teardown = undefined;
-                            current.pendingCleanup = undefined;
-                            this._entries.delete(key);
-                        }
-                    }, 0);
-                } else {
-                    entry.subscribed = false;
-                    entry.teardown?.();
-                    entry.teardown = undefined;
-
-                    // Defer deletion so React Strict Mode re-mounts can re-acquire the entry.
-                    setTimeout(() => {
-                        const current = this._entries.get(key);
-
-                        if (current && current.subscriberCount <= 0) {
-                            this._entries.delete(key);
-                        }
-                    }, 0);
-                }
+                // Defer both teardown and deletion so React StrictMode re-mounts in any environment
+                // can cancel by calling acquire() before the timeout fires.
+                entry.pendingCleanup = setTimeout(() => {
+                    const current = this._entries.get(key);
+
+                    if (current && current.subscriberCount <= 0) {
+                        current.subscribed = false;
+                        current.teardown?.();
+                        current.teardown = undefined;
+                        current.pendingCleanup = undefined;
+                        this._entries.delete(key);
+                    }
+                }, 0);
             }
         }
     }

package/queries/for_ObservableQueryConnectionFactory/when_creating/with_hub_mode_and_sse_transport_and_connection_count_exceeding_safe_limit.ts

@@ -0,0 +1,69 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_descriptor } from '../given/a_descriptor';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import { QueryTransportMethod } from '../../QueryTransportMethod';
+import { createObservableQueryConnection } from '../../ObservableQueryConnectionFactory';
+import { MultiplexedObservableQueryConnection, resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+import { IObservableQueryConnection } from '../../IObservableQueryConnection';
+
+import * as sinon from 'sinon';
+
+describe('when creating with hub mode and SSE transport and connection count exceeding safe limit', given(a_descriptor, context => {
+    let connection: IObservableQueryConnection<unknown>;
+    let warnStub: sinon.SinonStub;
+    let originalConnectionCount: number;
+
+    beforeEach(() => {
+        originalConnectionCount = Globals.queryConnectionCount;
+        Globals.queryDirectMode = false;
+        Globals.queryTransportMethod = QueryTransportMethod.ServerSentEvents;
+        Globals.queryConnectionCount = 10;
+
+        warnStub = sinon.stub(console, 'warn');
+
+        const FakeEventSourceConstructor = function (this: EventSource) {
+            Object.assign(this, {
+                onopen: null,
+                onerror: null,
+                onmessage: null,
+                close: sinon.stub(),
+                addEventListener: sinon.stub(),
+                removeEventListener: sinon.stub(),
+                readyState: 0,
+            });
+        };
+        (globalThis as Record<string, unknown>)['EventSource'] = FakeEventSourceConstructor;
+        (globalThis as Record<string, unknown>)['fetch'] = sinon.stub().resolves({ ok: true } as Response);
+
+        connection = createObservableQueryConnection(context.descriptor);
+    });
+
+    afterEach(() => {
+        Globals.queryDirectMode = context.originalDirectMode;
+        Globals.queryTransportMethod = context.originalTransportMethod;
+        Globals.queryConnectionCount = originalConnectionCount;
+        warnStub.restore();
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+        delete (globalThis as Record<string, unknown>)['fetch'];
+        resetSharedMultiplexer();
+    });
+
+    it('should return a MultiplexedObservableQueryConnection', () => {
+        connection.should.be.instanceOf(MultiplexedObservableQueryConnection);
+    });
+
+    it('should log a warning about the connection count limit', () => {
+        warnStub.calledOnce.should.be.true;
+    });
+
+    it('should mention the requested connection count in the warning', () => {
+        warnStub.firstCall.args[0].should.include('10');
+    });
+
+    it('should mention the safe limit in the warning', () => {
+        warnStub.firstCall.args[0].should.include('4');
+    });
+}));

package/queries/for_ObservableQueryConnectionFactory/when_creating/with_hub_mode_and_sse_transport_and_connection_count_within_safe_limit.ts

@@ -0,0 +1,61 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_descriptor } from '../given/a_descriptor';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import { QueryTransportMethod } from '../../QueryTransportMethod';
+import { createObservableQueryConnection } from '../../ObservableQueryConnectionFactory';
+import { MultiplexedObservableQueryConnection, resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+import { IObservableQueryConnection } from '../../IObservableQueryConnection';
+
+import * as sinon from 'sinon';
+
+describe('when creating with hub mode and SSE transport and connection count within safe limit', given(a_descriptor, context => {
+    let connection: IObservableQueryConnection<unknown>;
+    let warnStub: sinon.SinonStub;
+    let originalConnectionCount: number;
+
+    beforeEach(() => {
+        originalConnectionCount = Globals.queryConnectionCount;
+        Globals.queryDirectMode = false;
+        Globals.queryTransportMethod = QueryTransportMethod.ServerSentEvents;
+        Globals.queryConnectionCount = 4;
+
+        warnStub = sinon.stub(console, 'warn');
+
+        const FakeEventSourceConstructor = function (this: EventSource) {
+            Object.assign(this, {
+                onopen: null,
+                onerror: null,
+                onmessage: null,
+                close: sinon.stub(),
+                addEventListener: sinon.stub(),
+                removeEventListener: sinon.stub(),
+                readyState: 0,
+            });
+        };
+        (globalThis as Record<string, unknown>)['EventSource'] = FakeEventSourceConstructor;
+        (globalThis as Record<string, unknown>)['fetch'] = sinon.stub().resolves({ ok: true } as Response);
+
+        connection = createObservableQueryConnection(context.descriptor);
+    });
+
+    afterEach(() => {
+        Globals.queryDirectMode = context.originalDirectMode;
+        Globals.queryTransportMethod = context.originalTransportMethod;
+        Globals.queryConnectionCount = originalConnectionCount;
+        warnStub.restore();
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+        delete (globalThis as Record<string, unknown>)['fetch'];
+        resetSharedMultiplexer();
+    });
+
+    it('should return a MultiplexedObservableQueryConnection', () => {
+        connection.should.be.instanceOf(MultiplexedObservableQueryConnection);
+    });
+
+    it('should not log a warning', () => {
+        warnStub.called.should.be.false;
+    });
+}));

package/queries/for_ObservableQueryConnectionFactory/when_creating/with_hub_mode_and_websocket_transport_and_high_connection_count.ts

@@ -0,0 +1,60 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_descriptor } from '../given/a_descriptor';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import { QueryTransportMethod } from '../../QueryTransportMethod';
+import { createObservableQueryConnection } from '../../ObservableQueryConnectionFactory';
+import { MultiplexedObservableQueryConnection, resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+import { IObservableQueryConnection } from '../../IObservableQueryConnection';
+
+import * as sinon from 'sinon';
+
+describe('when creating with hub mode and WebSocket transport and high connection count', given(a_descriptor, context => {
+    let connection: IObservableQueryConnection<unknown>;
+    let warnStub: sinon.SinonStub;
+    let originalConnectionCount: number;
+    let originalWebSocket: typeof WebSocket;
+
+    beforeEach(() => {
+        originalConnectionCount = Globals.queryConnectionCount;
+        Globals.queryDirectMode = false;
+        Globals.queryTransportMethod = QueryTransportMethod.WebSocket;
+        Globals.queryConnectionCount = 10;
+
+        warnStub = sinon.stub(console, 'warn');
+
+        originalWebSocket = global.WebSocket;
+        (global as Record<string, unknown>).WebSocket = function () {
+            return {
+                onopen: null,
+                onclose: null,
+                onerror: null,
+                onmessage: null,
+                close: sinon.stub(),
+                send: sinon.stub(),
+                readyState: 0,
+            };
+        };
+
+        connection = createObservableQueryConnection(context.descriptor);
+    });
+
+    afterEach(() => {
+        Globals.queryDirectMode = context.originalDirectMode;
+        Globals.queryTransportMethod = context.originalTransportMethod;
+        Globals.queryConnectionCount = originalConnectionCount;
+        warnStub.restore();
+        global.WebSocket = originalWebSocket;
+        resetSharedMultiplexer();
+    });
+
+    it('should return a MultiplexedObservableQueryConnection', () => {
+        connection.should.be.instanceOf(MultiplexedObservableQueryConnection);
+    });
+
+    it('should not log a warning', () => {
+        warnStub.called.should.be.false;
+    });
+}));

package/queries/for_ObservableQueryMultiplexer/when_getting_or_creating/with_a_changed_cache_key.ts

@@ -0,0 +1,42 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { IObservableQueryHubConnection } from '../../IObservableQueryHubConnection';
+import { getOrCreateMultiplexer, resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+describe('when getting or creating with a changed cache key', () => {
+    let factoryCallCount: number;
+    let disposedConnectionCount: number;
+
+    beforeEach(() => {
+        factoryCallCount = 0;
+        disposedConnectionCount = 0;
+        const factory = (): IObservableQueryHubConnection => {
+            factoryCallCount++;
+            return {
+                queryCount: 0,
+                lastPingLatency: 0,
+                averageLatency: 0,
+                subscribe: () => {},
+                unsubscribe: () => {},
+                dispose: () => { disposedConnectionCount++; },
+            };
+        };
+        getOrCreateMultiplexer(factory, 'key-one', 1);
+        getOrCreateMultiplexer(factory, 'key-two', 1);
+    });
+
+    afterEach(() => {
+        resetSharedMultiplexer();
+    });
+
+    it('should dispose the connections of the previous multiplexer', () => {
+        disposedConnectionCount.should.be.greaterThan(0);
+    });
+
+    it('should create connections for both multiplexers', () => {
+        factoryCallCount.should.equal(2);
+    });
+});

package/queries/for_ObservableQueryMultiplexer/when_getting_or_creating/with_a_new_cache_key.ts

@@ -0,0 +1,34 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { IObservableQueryHubConnection } from '../../IObservableQueryHubConnection';
+import { getOrCreateMultiplexer, ObservableQueryMultiplexer, resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+describe('when getting or creating with a new cache key', () => {
+    let multiplexer: ObservableQueryMultiplexer;
+    let factoryCallCount: number;
+
+    beforeEach(() => {
+        factoryCallCount = 0;
+        const factory = (): IObservableQueryHubConnection => {
+            factoryCallCount++;
+            return { queryCount: 0, lastPingLatency: 0, averageLatency: 0, subscribe: () => {}, unsubscribe: () => {}, dispose: () => {} };
+        };
+        multiplexer = getOrCreateMultiplexer(factory, 'test-key', 1);
+    });
+
+    afterEach(() => {
+        resetSharedMultiplexer();
+    });
+
+    it('should return a multiplexer', () => {
+        multiplexer.should.be.instanceOf(ObservableQueryMultiplexer);
+    });
+
+    it('should call the factory to create connections', () => {
+        factoryCallCount.should.be.greaterThan(0);
+    });
+});
+

package/queries/for_ObservableQueryMultiplexer/when_getting_or_creating/with_an_explicit_size.ts

@@ -0,0 +1,33 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { IObservableQueryHubConnection } from '../../IObservableQueryHubConnection';
+import { getOrCreateMultiplexer, ObservableQueryMultiplexer, resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+describe('when getting or creating with an explicit size', () => {
+    let multiplexer: ObservableQueryMultiplexer;
+    let factoryCallCount: number;
+
+    beforeEach(() => {
+        factoryCallCount = 0;
+        const factory = (): IObservableQueryHubConnection => {
+            factoryCallCount++;
+            return { queryCount: 0, lastPingLatency: 0, averageLatency: 0, subscribe: () => {}, unsubscribe: () => {}, dispose: () => {} };
+        };
+        multiplexer = getOrCreateMultiplexer(factory, 'test-key', 3);
+    });
+
+    afterEach(() => {
+        resetSharedMultiplexer();
+    });
+
+    it('should create a multiplexer with the given size', () => {
+        multiplexer.size.should.equal(3);
+    });
+
+    it('should create exactly that many connections', () => {
+        factoryCallCount.should.equal(3);
+    });
+});

package/queries/for_ObservableQueryMultiplexer/when_getting_or_creating/with_the_same_cache_key.ts

@@ -0,0 +1,35 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { IObservableQueryHubConnection } from '../../IObservableQueryHubConnection';
+import { getOrCreateMultiplexer, ObservableQueryMultiplexer, resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+describe('when getting or creating with the same cache key', () => {
+    let first: ObservableQueryMultiplexer;
+    let second: ObservableQueryMultiplexer;
+    let factoryCallCount: number;
+
+    beforeEach(() => {
+        factoryCallCount = 0;
+        const factory = (): IObservableQueryHubConnection => {
+            factoryCallCount++;
+            return { queryCount: 0, lastPingLatency: 0, averageLatency: 0, subscribe: () => {}, unsubscribe: () => {}, dispose: () => {} };
+        };
+        first = getOrCreateMultiplexer(factory, 'test-key', 1);
+        second = getOrCreateMultiplexer(factory, 'test-key', 1);
+    });
+
+    afterEach(() => {
+        resetSharedMultiplexer();
+    });
+
+    it('should return the same instance', () => {
+        second.should.equal(first);
+    });
+
+    it('should only call the factory once', () => {
+        factoryCallCount.should.equal(1);
+    });
+});

package/queries/for_QueryInstanceCache/when_acquiring/after_release.ts

@@ -0,0 +1,31 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryInstanceCache } from '../../QueryInstanceCache';
+
+describe('when acquiring after release', () => {
+    let cache: QueryInstanceCache;
+    let teardownCalled: boolean;
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+        teardownCalled = false;
+        cache = new QueryInstanceCache();
+        cache.getOrCreate('MyQuery::', () => ({}));
+        cache.acquire('MyQuery::');
+        cache.setTeardown('MyQuery::', () => { teardownCalled = true; });
+        cache.release('MyQuery::');
+
+        // Re-acquire before the deferred timer fires (simulates StrictMode re-mount).
+        cache.acquire('MyQuery::');
+        vi.advanceTimersByTime(0);
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it('should not call teardown', () => teardownCalled.should.be.false);
+    it('should keep the entry', () => cache.has('MyQuery::').should.be.true);
+    it('should still report as subscribed', () => cache.isSubscribed('MyQuery::').should.be.true);
+});

package/queries/for_QueryInstanceCache/when_releasing/the_only_subscriber_outside_development_mode.ts

@@ -21,13 +21,16 @@ describe('when releasing the only subscriber outside development mode', () => {
         vi.useRealTimers();
     });
 
-    it('should call teardown synchronously', () => teardownCalled.should.be.true);
+    it('should not call teardown synchronously', () => teardownCalled.should.be.false);
+    it('should keep the entry before the timer fires', () => cache.has('MyQuery::').should.be.true);
+    it('should still report as subscribed before the timer fires', () => cache.isSubscribed('MyQuery::').should.be.true);
 
     describe('and the deferred timer fires', () => {
         beforeEach(() => {
             vi.advanceTimersByTime(0);
         });
 
+        it('should call teardown', () => teardownCalled.should.be.true);
         it('should evict the entry', () => cache.has('MyQuery::').should.be.false);
     });
 });