@cratis/arc 20.1.3 → 20.1.5

package/identity/IdentityProvider.ts

@@ -77,7 +77,7 @@ export class IdentityProvider extends IIdentityProvider {
     }
 
     static async refresh<TDetails extends object = object>(type?: Constructor<TDetails>): Promise<IIdentity<TDetails>> {
-        IdentityProvider.clearCookie();
+        IdentityProvider.clearIdentityCookie();
         const origin = IdentityProvider.origin || Globals.origin || '';
         const apiBasePath = IdentityProvider.apiBasePath || Globals.apiBasePath || '';
         const route = joinPaths(apiBasePath, '/.cratis/me');
@@ -88,6 +88,10 @@ export class IdentityProvider extends IIdentityProvider {
             headers: IdentityProvider.httpHeadersCallback?.() ?? {}
         });
 
+        if (!response.ok) {
+            return IdentityProvider.notSet(type);
+        }
+
         const result = await response.json() as IdentityProviderResult;
         const details = type ? JsonSerializer.deserializeFromInstance(type, result.details) : result.details;
 
@@ -102,6 +106,18 @@ export class IdentityProvider extends IIdentityProvider {
         };
     }
 
+    private static notSet<TDetails extends object = object>(type?: Constructor<TDetails>): IIdentity<TDetails> {
+        return {
+            id: '',
+            name: '',
+            roles: [],
+            details: {} as TDetails,
+            isSet: false,
+            isInRole: () => false,
+            refresh: () => IdentityProvider.refresh(type)
+        };
+    }
+
     private static getCookie() {
         if (typeof document === 'undefined') return [];
         const decoded = decodeURIComponent(document.cookie);
@@ -114,7 +130,12 @@ export class IdentityProvider extends IIdentityProvider {
         return [];
     }
 
-    private static clearCookie() {
+    /**
+     * Clears the identity cookie used by Arc to cache the current identity.
+     * Call this when the user logs out to ensure subsequent requests and WebSocket
+     * connections do not carry stale credentials.
+     */
+    static clearIdentityCookie(): void {
         if (typeof document === 'undefined') return;
         document.cookie = `${IdentityProvider.CookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT`;
     }

package/identity/for_IdentityProvider/when_refreshing/with_unauthorized_response.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { IdentityProvider } from '../../IdentityProvider';
+import { IIdentity } from '../../IIdentity';
+import { an_identity_provider } from '../given/an_identity_provider';
+import { given } from '../../../given';
+
+describe('when refreshing with unauthorized response', given(an_identity_provider, context => {
+    let result: IIdentity;
+
+    beforeEach(async () => {
+        context.fetchStub.resolves({
+            ok: false,
+            status: 401,
+        } as Response);
+
+        result = await IdentityProvider.refresh();
+    });
+
+    it('should return identity with isSet false', () => result.isSet.should.be.false);
+    it('should return empty identity id', () => result.id.should.equal(''));
+    it('should return empty identity name', () => result.name.should.equal(''));
+    it('should return empty roles', () => result.roles.should.be.empty);
+    it('should provide a refresh method', () => result.refresh.should.be.a('function'));
+}));

package/package.json

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

package/queries/HubConnectionKeepAlive.ts

@@ -5,9 +5,15 @@
  * Manages keep-alive behavior for hub connections (both WebSocket and Server-Sent Events).
  *
  * Records connection activity (any message received or sent). An interval fires every
- * {@link intervalMs} milliseconds; if no activity has been recorded since the last tick the
- * provided {@link onIdle} callback is invoked — the caller decides whether to send a ping,
- * trigger a reconnect, or take some other action.
+ * {@link intervalMs} milliseconds; if no activity has been recorded since the last
+ * {@link idleThresholdMs} milliseconds the provided {@link onIdle} callback is invoked —
+ * the caller decides whether to send a ping, trigger a reconnect, or take some other action.
+ *
+ * The idle threshold defaults to the check interval but can be set higher to tolerate
+ * network latency between the server's keep-alive ping and the client's idle check.
+ * For SSE connections, where the idle callback triggers a reconnect, a tolerance of
+ * 1.5× the server's keep-alive interval prevents spurious reconnects caused by the
+ * client's timer firing just before the server's ping arrives.
  *
  * Both {@link WebSocketHubConnection} and {@link ServerSentEventHubConnection} own one instance
  * of this class so the keep-alive logic is written once and behaves identically for both
@@ -16,17 +22,25 @@
 export class HubConnectionKeepAlive {
     private _lastActivityTime = Date.now();
     private _timer?: ReturnType<typeof setInterval>;
+    private readonly _idleThresholdMs: number;
 
     /**
      * Initializes a new instance of {@link HubConnectionKeepAlive}.
      * @param {number} intervalMs How often (in milliseconds) to check for idle connections.
      * @param {() => void} onIdle Callback invoked when the interval fires and no activity has
-     *   been recorded in the last {@link intervalMs} milliseconds.
+     *   been recorded within the idle threshold.
+     * @param {number} idleThresholdMs Optional. How long (in milliseconds) without activity
+     *   before the connection is considered idle. Defaults to {@link intervalMs}. Set this
+     *   higher than {@link intervalMs} when the peer sends keep-alive messages on a similar
+     *   cadence to account for network latency and timer jitter.
      */
     constructor(
         private readonly _intervalMs: number,
         private readonly _onIdle: () => void,
-    ) {}
+        idleThresholdMs?: number,
+    ) {
+        this._idleThresholdMs = idleThresholdMs ?? _intervalMs;
+    }
 
     /**
      * Start the keep-alive timer. Safe to call multiple times — a running timer is stopped first.
@@ -35,7 +49,7 @@ export class HubConnectionKeepAlive {
         this.stop();
         this._lastActivityTime = Date.now();
         this._timer = setInterval(() => {
-            if (Date.now() - this._lastActivityTime >= this._intervalMs) {
+            if (Date.now() - this._lastActivityTime >= this._idleThresholdMs) {
                 this._onIdle();
             }
         }, this._intervalMs);

package/queries/QueryInstanceCache.ts

@@ -48,6 +48,13 @@ export interface QueryCacheEntry<TDataType> {
      * Whether an active subscription has been established for this entry.
      */
     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.
+     */
+    pendingCleanup?: ReturnType<typeof setTimeout>;
 }
 
 /**
@@ -60,6 +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.
+     */
+    constructor(development: boolean = false) {
+        this._development = development;
+    }
 
     /**
      * Builds the cache key for a query.
@@ -113,6 +131,8 @@ 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),
+     * 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}.
      */
@@ -120,6 +140,11 @@ export class QueryInstanceCache {
         const entry = this._entries.get(key);
 
         if (entry) {
+            if (entry.pendingCleanup !== undefined) {
+                clearTimeout(entry.pendingCleanup);
+                entry.pendingCleanup = undefined;
+            }
+
             entry.subscriberCount++;
         }
     }
@@ -207,6 +232,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.
      * @param key The cache key produced by {@link buildKey}.
      */
     release(key: QueryCacheKey): void {
@@ -216,18 +246,33 @@ export class QueryInstanceCache {
             entry.subscriberCount--;
 
             if (entry.subscriberCount <= 0) {
-                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);
+                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);
+                }
             }
         }
     }
@@ -240,4 +285,80 @@ export class QueryInstanceCache {
     has(key: QueryCacheKey): boolean {
         return this._entries.has(key);
     }
+
+    /**
+     * Tears down all active subscriptions and marks every entry as not subscribed,
+     * but preserves entries, subscriber counts, and listeners. This allows
+     * hooks whose effects re-run afterward to detect that the entry is no longer
+     * subscribed and re-establish a fresh connection.
+     *
+     * Use this when the underlying transport must be replaced (e.g. after an
+     * authentication change that requires new WebSocket connections with updated
+     * credentials).
+     */
+    teardownAllSubscriptions(): void {
+        for (const [, entry] of this._entries) {
+            if (entry.pendingCleanup !== undefined) {
+                clearTimeout(entry.pendingCleanup);
+                entry.pendingCleanup = undefined;
+            }
+
+            entry.subscribed = false;
+            entry.teardown?.();
+            entry.teardown = undefined;
+        }
+    }
+
+    /**
+     * Immediately tears down all subscriptions, cancels any pending deferred cleanups,
+     * and evicts all entries. Call when the owning component (e.g. the {@link Arc} provider)
+     * unmounts permanently so that all query connections are closed synchronously.
+     */
+    dispose(): void {
+        for (const [, entry] of this._entries) {
+            if (entry.pendingCleanup !== undefined) {
+                clearTimeout(entry.pendingCleanup);
+                entry.pendingCleanup = undefined;
+            }
+
+            entry.subscribed = false;
+            entry.teardown?.();
+            entry.teardown = undefined;
+        }
+
+        this._entries.clear();
+    }
+
+    /**
+     * Schedules a deferred {@link dispose} using {@code setTimeout(0)}.
+     *
+     * This allows React StrictMode re-mounts to call {@link cancelPendingDispose}
+     * before the dispose fires, avoiding the destruction of cache entries that child
+     * effects are about to re-acquire.
+     *
+     * If a deferred dispose is already pending, it is replaced.
+     */
+    deferDispose(): void {
+        if (this._pendingDispose !== undefined) {
+            clearTimeout(this._pendingDispose);
+        }
+
+        this._pendingDispose = setTimeout(() => {
+            this._pendingDispose = undefined;
+            this.dispose();
+        }, 0);
+    }
+
+    /**
+     * Cancels a pending deferred dispose scheduled by {@link deferDispose}.
+     *
+     * Call from the {@code useEffect} setup phase so that a StrictMode re-mount
+     * prevents the synthetic unmount's deferred dispose from firing.
+     */
+    cancelPendingDispose(): void {
+        if (this._pendingDispose !== undefined) {
+            clearTimeout(this._pendingDispose);
+            this._pendingDispose = undefined;
+        }
+    }
 }

package/queries/QueryResult.ts

@@ -60,6 +60,25 @@ export class QueryResult<TDataType = object> implements IQueryResult<TDataType>
         }, Object, false);
     }
 
+    static unauthorized<TDataType>(): QueryResult<TDataType> {
+        return new QueryResult({
+            data: null as unknown as object,
+            isSuccess: false,
+            isAuthorized: false,
+            isValid: true,
+            hasExceptions: false,
+            validationResults: [],
+            exceptionMessages: [],
+            exceptionStackTrace: '',
+            paging: {
+                totalItems: 0,
+                totalPages: 0,
+                page: 0,
+                size: 0
+            }
+        }, Object, false);
+    }
+
     static noSuccess: QueryResult = new QueryResult({
         data: {},
         isSuccess: false,

package/queries/ReconnectPolicy.ts

@@ -45,6 +45,10 @@ export class ReconnectPolicy implements IReconnectPolicy {
             return false;
         }
 
+        // Cancel any pending reconnect timer so we don't fire multiple
+        // concurrent reconnect attempts when schedule() is called rapidly.
+        this.cancel();
+
         this._attempt++;
         const delay = Math.min(this._initialDelayMs + this._delayStepMs * this._attempt, this._maxDelayMs);
         console.log(`Reconnect: attempt ${this._attempt} in ${delay}ms for '${label}'`);

package/queries/ServerSentEventHubConnection.ts

@@ -62,13 +62,20 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
     ) {
         // SSE is server→client only: the client cannot send pings. Instead we watch for
         // inactivity — if the server stops sending messages (including its own keep-alive
-        // pings) for the entire interval, the connection is stale and we reconnect.
+        // pings) for the entire idle threshold, the connection is stale and we reconnect.
+        //
+        // The idle threshold is set to 1.5× the check interval so the server's keep-alive
+        // ping (which fires on the same cadence) has time to arrive over the network before
+        // the client declares the connection dead. Without this tolerance the client's timer
+        // and the server's timer race — the client often fires first and reconnects
+        // unnecessarily.
+        const idleThresholdMs = Math.round(keepAliveIntervalMs * 1.5);
         this._keepAlive = new HubConnectionKeepAlive(keepAliveIntervalMs, () => {
             if (!this._disconnected && this._subscriptions.size > 0) {
-                console.warn(`SSE hub: no messages received for ${keepAliveIntervalMs}ms, reconnecting '${this._sseUrl}'`);
+                console.warn(`SSE hub: no messages received for ${idleThresholdMs}ms, reconnecting '${this._sseUrl}'`);
                 this.reconnect();
             }
-        });
+        }, idleThresholdMs);
     }
 
     /** @inheritdoc */
@@ -238,6 +245,7 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
                     break;
                 case HubMessageType.Unauthorized:
                     console.warn(`SSE hub: query '${message.queryId}' unauthorized`);
+                    this.handleUnauthorized(message);
                     break;
                 case HubMessageType.Error:
                     console.error(`SSE hub: query '${message.queryId}' error:`, message.payload);
@@ -272,6 +280,17 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         sub.callback(result);
     }
 
+    private handleUnauthorized(message: HubMessage): void {
+        if (!message.queryId) return;
+
+        const sub = this._subscriptions.get(message.queryId);
+        if (!sub) return;
+
+        this._subscriptions.delete(message.queryId);
+        this._pendingSubscriptions.delete(message.queryId);
+        sub.callback(QueryResult.unauthorized());
+    }
+
     private sendSubscribe(queryId: string, request: SubscriptionRequest): void {
         if (!this._connectionId) return;
 
@@ -287,8 +306,14 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
             method: 'POST',
             headers: { 'Content-Type': 'application/json', ...customHeaders },
             body: JSON.stringify(body),
+        }).then(response => {
+            if (!response.ok) {
+                console.warn(`SSE hub: subscribe POST for '${queryId}' returned ${response.status}, reconnecting`);
+                this.reconnect();
+            }
         }).catch(error => {
-            console.error(`SSE hub: subscribe POST failed for '${queryId}'`, error);
+            console.error(`SSE hub: subscribe POST failed for '${queryId}', reconnecting`, error);
+            this.reconnect();
         });
     }
 

package/queries/WebSocketHubConnection.ts

@@ -257,6 +257,7 @@ export class WebSocketHubConnection {
                     break;
                 case HubMessageType.Unauthorized:
                     console.warn(`Hub: query '${message.queryId}' unauthorized`);
+                    this.handleUnauthorized(message);
                     break;
                 case HubMessageType.Error:
                     console.error(`Hub: query '${message.queryId}' error:`, message.payload);
@@ -277,6 +278,16 @@ export class WebSocketHubConnection {
         sub.callback(result);
     }
 
+    private handleUnauthorized(message: HubMessage): void {
+        if (!message.queryId) return;
+
+        const sub = this._subscriptions.get(message.queryId);
+        if (!sub) return;
+
+        this._subscriptions.delete(message.queryId);
+        sub.callback(QueryResult.unauthorized());
+    }
+
     private handlePong(message: HubMessage): void {
         if (message.timestamp && this._lastPingSentTime) {
             const latency = Date.now() - message.timestamp;

package/queries/for_HubConnectionKeepAlive/when_started_with_custom_idle_threshold/respects_threshold.ts

@@ -0,0 +1,46 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import sinon from 'sinon';
+import { HubConnectionKeepAlive } from '../../HubConnectionKeepAlive';
+
+describe('when started with a custom idle threshold larger than the check interval', () => {
+    let clock: sinon.SinonFakeTimers;
+    let onIdle: sinon.SinonStub;
+    let keepAlive: HubConnectionKeepAlive;
+
+    const checkIntervalMs = 500;
+    const idleThresholdMs = 750;
+
+    beforeEach(() => {
+        clock = sinon.useFakeTimers();
+        onIdle = sinon.stub();
+        keepAlive = new HubConnectionKeepAlive(checkIntervalMs, onIdle, idleThresholdMs);
+        keepAlive.start();
+    });
+
+    afterEach(() => {
+        keepAlive.stop();
+        clock.restore();
+        sinon.restore();
+    });
+
+    describe('and the check interval elapses but idle threshold has not', () => {
+        beforeEach(() => {
+            // Advance past the check interval (500ms) but not the idle threshold (750ms).
+            clock.tick(checkIntervalMs + 1);
+        });
+
+        it('should not invoke the onIdle callback', () => onIdle.called.should.be.false);
+    });
+
+    describe('and the idle threshold elapses', () => {
+        beforeEach(() => {
+            // Advance past the idle threshold. The second interval tick at 1000ms
+            // sees 1000ms of inactivity which exceeds the 750ms threshold.
+            clock.tick(checkIntervalMs * 2 + 1);
+        });
+
+        it('should invoke the onIdle callback', () => onIdle.calledOnce.should.be.true);
+    });
+});

package/queries/for_QueryInstanceCache/when_acquiring/after_release_in_development_mode.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 in development mode', () => {
+    let cache: QueryInstanceCache;
+    let teardownCalled: boolean;
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+        teardownCalled = false;
+        cache = new QueryInstanceCache(true);
+        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_deferring_dispose/with_cancellation_before_timeout.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 canceling deferred dispose before timeout fires', () => {
+    let cache: QueryInstanceCache;
+    let teardownCalled: boolean;
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+        teardownCalled = false;
+        cache = new QueryInstanceCache(true);
+        cache.getOrCreate('MyQuery::', () => ({}));
+        cache.acquire('MyQuery::');
+        cache.setTeardown('MyQuery::', () => { teardownCalled = true; });
+
+        // Simulates StrictMode: unmount defers dispose, remount cancels it.
+        cache.deferDispose();
+        cache.cancelPendingDispose();
+        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_deferring_dispose/without_cancellation.ts

@@ -0,0 +1,28 @@
+// 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 deferring dispose without cancellation', () => {
+    let cache: QueryInstanceCache;
+    let teardownCalled: boolean;
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+        teardownCalled = false;
+        cache = new QueryInstanceCache(true);
+        cache.getOrCreate('MyQuery::', () => ({}));
+        cache.acquire('MyQuery::');
+        cache.setTeardown('MyQuery::', () => { teardownCalled = true; });
+
+        cache.deferDispose();
+        vi.advanceTimersByTime(0);
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it('should call teardown', () => teardownCalled.should.be.true);
+    it('should evict the entry', () => cache.has('MyQuery::').should.be.false);
+});

package/queries/for_QueryInstanceCache/when_disposing/an_empty_cache.ts

@@ -0,0 +1,21 @@
+// 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 disposing an empty cache', () => {
+    let cache: QueryInstanceCache;
+    let threwError: boolean;
+
+    beforeEach(() => {
+        threwError = false;
+        cache = new QueryInstanceCache();
+        try {
+            cache.dispose();
+        } catch {
+            threwError = true;
+        }
+    });
+
+    it('should not throw', () => threwError.should.be.false);
+});

package/queries/for_QueryInstanceCache/when_disposing/with_active_subscriptions.ts

@@ -0,0 +1,30 @@
+// 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 disposing with active subscriptions', () => {
+    let cache: QueryInstanceCache;
+    let firstTeardownCalled: boolean;
+    let secondTeardownCalled: boolean;
+
+    beforeEach(() => {
+        firstTeardownCalled = false;
+        secondTeardownCalled = false;
+        cache = new QueryInstanceCache();
+        cache.getOrCreate('QueryA::', () => ({}));
+        cache.acquire('QueryA::');
+        cache.setTeardown('QueryA::', () => { firstTeardownCalled = true; });
+
+        cache.getOrCreate('QueryB::', () => ({}));
+        cache.acquire('QueryB::');
+        cache.setTeardown('QueryB::', () => { secondTeardownCalled = true; });
+
+        cache.dispose();
+    });
+
+    it('should call teardown for the first entry', () => firstTeardownCalled.should.be.true);
+    it('should call teardown for the second entry', () => secondTeardownCalled.should.be.true);
+    it('should evict the first entry', () => cache.has('QueryA::').should.be.false);
+    it('should evict the second entry', () => cache.has('QueryB::').should.be.false);
+});