@cratis/arc 20.1.1 → 20.1.4

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.1",
+    "version": "20.1.4",
     "description": "",
     "author": "Cratis",
     "license": "MIT",

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/ServerSentEventHubConnection.ts

@@ -238,6 +238,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 +273,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;
 
@@ -281,9 +293,11 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
             request,
         };
 
+        const customHeaders = Globals.httpHeadersCallback?.() ?? {};
+
         fetch(this._subscribeUrl, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: { 'Content-Type': 'application/json', ...customHeaders },
             body: JSON.stringify(body),
         }).catch(error => {
             console.error(`SSE hub: subscribe POST failed for '${queryId}'`, error);
@@ -298,9 +312,11 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
             queryId,
         };
 
+        const customHeaders = Globals.httpHeadersCallback?.() ?? {};
+
         fetch(this._unsubscribeUrl, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: { 'Content-Type': 'application/json', ...customHeaders },
             body: JSON.stringify(body),
         }).catch(error => {
             console.error(`SSE hub: unsubscribe POST failed for '${queryId}'`, error);

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_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);
+});

package/queries/for_QueryInstanceCache/when_disposing/with_pending_deferred_cleanup.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 disposing with pending deferred cleanup', () => {
+    let cache: QueryInstanceCache;
+    let teardownCalled: number;
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+        teardownCalled = 0;
+        cache = new QueryInstanceCache(true);
+        cache.getOrCreate('MyQuery::', () => ({}));
+        cache.acquire('MyQuery::');
+        cache.setTeardown('MyQuery::', () => { teardownCalled++; });
+        cache.release('MyQuery::');
+
+        // At this point a deferred cleanup is pending. Dispose should
+        // tear down immediately and cancel the deferred cleanup.
+        cache.dispose();
+        vi.advanceTimersByTime(0);
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it('should call teardown exactly once', () => teardownCalled.should.equal(1));
+    it('should evict the entry', () => cache.has('MyQuery::').should.be.false);
+});

package/queries/for_QueryInstanceCache/when_releasing/the_only_subscriber_in_development_mode.ts

@@ -0,0 +1,36 @@
+// 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 releasing the only subscriber 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::');
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    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);
+    });
+});

package/queries/for_QueryInstanceCache/when_releasing/the_only_subscriber_outside_development_mode.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 { QueryInstanceCache } from '../../QueryInstanceCache';
+
+describe('when releasing the only subscriber outside development mode', () => {
+    let cache: QueryInstanceCache;
+    let teardownCalled: boolean;
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+        teardownCalled = false;
+        cache = new QueryInstanceCache(false);
+        cache.getOrCreate('MyQuery::', () => ({}));
+        cache.acquire('MyQuery::');
+        cache.setTeardown('MyQuery::', () => { teardownCalled = true; });
+        cache.release('MyQuery::');
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it('should call teardown synchronously', () => teardownCalled.should.be.true);
+
+    describe('and the deferred timer fires', () => {
+        beforeEach(() => {
+            vi.advanceTimersByTime(0);
+        });
+
+        it('should evict the entry', () => cache.has('MyQuery::').should.be.false);
+    });
+});

package/queries/for_QueryInstanceCache/when_tearing_down_all_subscriptions/with_active_subscriptions.ts

@@ -0,0 +1,32 @@
+// 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 tearing down all subscriptions 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.teardownAllSubscriptions();
+    });
+
+    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 keep the first entry', () => cache.has('QueryA::').should.be.true);
+    it('should keep the second entry', () => cache.has('QueryB::').should.be.true);
+    it('should mark the first entry as not subscribed', () => cache.isSubscribed('QueryA::').should.be.false);
+    it('should mark the second entry as not subscribed', () => cache.isSubscribed('QueryB::').should.be.false);
+});