@cratis/arc 20.1.3 → 20.1.5

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

package/queries/for_QueryInstanceCache/when_tearing_down_all_subscriptions/with_no_subscriptions.ts

@@ -0,0 +1,18 @@
+// 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 no subscriptions', () => {
+    let cache: QueryInstanceCache;
+
+    beforeEach(() => {
+        cache = new QueryInstanceCache();
+        cache.getOrCreate('MyQuery::', () => ({}));
+
+        cache.teardownAllSubscriptions();
+    });
+
+    it('should keep the entry', () => cache.has('MyQuery::').should.be.true);
+    it('should still report as not subscribed', () => cache.isSubscribed('MyQuery::').should.be.false);
+});

package/queries/for_QueryInstanceCache/when_tearing_down_all_subscriptions/with_pending_deferred_cleanup.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 tearing down all subscriptions with pending deferred cleanup', () => {
+    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; });
+
+        // Release the only subscriber — in dev mode this defers cleanup.
+        cache.release('MyQuery::');
+
+        // Tear down all before the deferred timer fires.
+        cache.teardownAllSubscriptions();
+        vi.advanceTimersByTime(0);
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it('should call teardown', () => teardownCalled.should.be.true);
+    it('should keep the entry', () => cache.has('MyQuery::').should.be.true);
+    it('should mark the entry as not subscribed', () => cache.isSubscribed('MyQuery::').should.be.false);
+});

package/queries/for_ReconnectPolicy/when_scheduling/and_rescheduled_before_first_fires/cancels_previous_timer.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 sinon from 'sinon';
+import { ReconnectPolicy } from '../../../ReconnectPolicy';
+
+describe('when scheduling twice before the first timer fires', () => {
+    let policy: ReconnectPolicy;
+    let clock: sinon.SinonFakeTimers;
+    let firstCallback: sinon.SinonStub;
+    let secondCallback: sinon.SinonStub;
+
+    beforeEach(() => {
+        clock = sinon.useFakeTimers();
+        policy = new ReconnectPolicy(100, 500, 500, 10_000);
+        firstCallback = sinon.stub();
+        secondCallback = sinon.stub();
+
+        policy.schedule(firstCallback, 'first');
+        // Schedule again before the first timer fires.
+        policy.schedule(secondCallback, 'second');
+
+        // Advance past both potential delays:
+        // Attempt 1: min(500+500*1, 10_000) = 1000ms
+        // Attempt 2: min(500+500*2, 10_000) = 1500ms
+        clock.tick(2000);
+    });
+
+    afterEach(() => {
+        clock.restore();
+        sinon.restore();
+    });
+
+    it('should cancel the first timer so it never fires', () => firstCallback.called.should.be.false);
+    it('should fire the second timer', () => secondCallback.calledOnce.should.be.true);
+});

package/queries/for_ServerSentEventHubConnection/when_keep_alive_is_idle/triggers_reconnect.ts

@@ -33,8 +33,11 @@ describe('when keep-alive interval elapses without any server message', given(a_
         // Deliver Connected so the connection is fully established.
         context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-123' });
 
-        // Advance past the keep-alive interval without any further messages.
-        clock.tick(KEEP_ALIVE_MS + 1);
+        // Advance past the idle threshold (1.5× keep-alive interval) without any further messages.
+        // The check interval fires every KEEP_ALIVE_MS; the idle threshold is KEEP_ALIVE_MS * 1.5.
+        // After the first interval tick (500ms) the elapsed idle time (500ms) is below the
+        // threshold (750ms). At the second tick (1000ms) the elapsed time exceeds the threshold.
+        clock.tick(KEEP_ALIVE_MS * 2 + 1);
     });
 
     afterEach(() => {

package/queries/for_ServerSentEventHubConnection/when_receiving_unauthorized/notifies_subscriber_and_removes_subscription.ts

@@ -0,0 +1,51 @@
+// 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 { a_server_sent_event_hub_connection } from '../given/a_server_sent_event_hub_connection';
+import { given } from '../../../given';
+import { HubMessageType } from '../../WebSocketHubConnection';
+import { QueryResult } from '../../QueryResult';
+
+describe('when receiving unauthorized for a subscribed query', given(a_server_sent_event_hub_connection, context => {
+    let callback: sinon.SinonStub;
+    let receivedResult: QueryResult<unknown> | undefined;
+    const queryId = 'q-auth-1';
+    const connectionId = 'conn-123';
+
+    beforeEach(() => {
+        context.setup();
+        callback = sinon.stub();
+
+        context.connection.subscribe(queryId, { queryName: 'SecureQuery' }, callback);
+        context.simulateOpen();
+
+        // Server sends Connected message with the connection ID.
+        context.simulateMessage({ type: HubMessageType.Connected, payload: connectionId });
+
+        // Server replies with Unauthorized for this subscription.
+        context.simulateMessage({ type: HubMessageType.Unauthorized, queryId });
+
+        receivedResult = callback.firstCall?.args[0] as QueryResult<unknown> | undefined;
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    it('should invoke the subscriber callback', () => {
+        callback.calledOnce.should.be.true;
+    });
+
+    it('should report isAuthorized as false', () => {
+        receivedResult!.isAuthorized.should.be.false;
+    });
+
+    it('should report isSuccess as false', () => {
+        receivedResult!.isSuccess.should.be.false;
+    });
+
+    it('should remove the subscription', () => {
+        context.connection.queryCount.should.equal(0);
+    });
+}));

package/queries/for_ServerSentEventHubConnection/when_subscribing/and_subscribe_post_fails.ts

@@ -0,0 +1,51 @@
+// 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 { a_server_sent_event_hub_connection } from '../given/a_server_sent_event_hub_connection';
+import { given } from '../../../given';
+import { HubMessageType } from '../../WebSocketHubConnection';
+
+describe('when subscribe POST returns a non-OK status', given(a_server_sent_event_hub_connection, context => {
+    beforeEach(async () => {
+        context.setup();
+
+        // Make the subscribe POST resolve with a 404 (connection not found on server).
+        context.fetchStub.resolves({ ok: false, status: 404 });
+
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+        context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-abc' });
+
+        // Allow the fetch promise chain (.then) to execute.
+        await new Promise(resolve => setTimeout(resolve, 0));
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should schedule a reconnect via the policy', () => {
+        (context.policy.schedule as sinon.SinonStub).calledOnce.should.be.true;
+    });
+}));
+
+describe('when subscribe POST rejects with a network error', given(a_server_sent_event_hub_connection, context => {
+    beforeEach(async () => {
+        context.setup();
+
+        // Make the subscribe POST reject (network failure).
+        context.fetchStub.rejects(new Error('Network error'));
+
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+        context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-abc' });
+
+        // Allow the fetch promise chain (.catch) to execute.
+        await new Promise(resolve => setTimeout(resolve, 0));
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should schedule a reconnect via the policy', () => {
+        (context.policy.schedule as sinon.SinonStub).calledOnce.should.be.true;
+    });
+}));

package/queries/for_WebSocketHubConnection/when_receiving_unauthorized/notifies_subscriber_and_removes_subscription.ts

@@ -0,0 +1,47 @@
+// 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 { a_web_socket_hub_connection } from '../given/a_web_socket_hub_connection';
+import { given } from '../../../given';
+import { HubMessageType } from '../../WebSocketHubConnection';
+import { QueryResult } from '../../QueryResult';
+
+describe('when receiving unauthorized for a subscribed query', given(a_web_socket_hub_connection, context => {
+    let callback: sinon.SinonStub;
+    let receivedResult: QueryResult<unknown> | undefined;
+    const queryId = 'q-auth-1';
+
+    beforeEach(() => {
+        context.setup();
+        callback = sinon.stub();
+
+        context.connection.subscribe(queryId, { queryName: 'SecureQuery' }, callback);
+        context.simulateOpen();
+
+        // Server replies with Unauthorized for this subscription.
+        context.simulateMessage({ type: HubMessageType.Unauthorized, queryId });
+
+        receivedResult = callback.firstCall?.args[0] as QueryResult<unknown> | undefined;
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    it('should invoke the subscriber callback', () => {
+        callback.calledOnce.should.be.true;
+    });
+
+    it('should report isAuthorized as false', () => {
+        receivedResult!.isAuthorized.should.be.false;
+    });
+
+    it('should report isSuccess as false', () => {
+        receivedResult!.isSuccess.should.be.false;
+    });
+
+    it('should remove the subscription', () => {
+        context.connection.queryCount.should.equal(0);
+    });
+}));