@cratis/arc 22.0.2 → 22.1.0

package/queries/for_ServerSentEventHubConnection/when_connection_changes_while_subscribe_is_in_flight/and_the_query_is_replaced.ts

@@ -0,0 +1,113 @@
+// 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_deferred_promise } from '../given/a_deferred_promise';
+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 a query is replaced while its subscribe request is in flight and the connection changes',
+    given(a_server_sent_event_hub_connection, (context) => {
+        const queryId = 'q1';
+        const replacementRequest = { queryName: 'ReplacementQuery' };
+        let clock: sinon.SinonFakeTimers;
+        let originalCallback: sinon.SinonStub;
+        let replacementCallback: sinon.SinonStub;
+
+        beforeEach(async () => {
+            context.setup();
+            clock = sinon.useFakeTimers({ toFake: ['setTimeout'] });
+            sinon.stub(console, 'warn');
+            const firstSubscribe = new a_deferred_promise<{
+                ok: boolean;
+                status: number;
+            }>();
+            context.fetchStub.onFirstCall().returns(firstSubscribe.promise);
+            originalCallback = sinon.stub();
+            replacementCallback = sinon.stub();
+
+            context.connection.subscribe(
+                queryId,
+                { queryName: 'OriginalQuery' },
+                originalCallback,
+            );
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-a',
+                supportsSubscriptionRevisions: true,
+            });
+            context.connection.subscribe(
+                queryId,
+                replacementRequest,
+                replacementCallback,
+            );
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-b',
+                supportsSubscriptionRevisions: true,
+            });
+
+            firstSubscribe.resolve({ ok: false, status: 404 });
+            await Promise.resolve();
+            clock.tick(1000);
+            await Promise.resolve();
+            context.simulateMessage({
+                type: HubMessageType.QueryResult,
+                queryId,
+                revision: getSubscribeBody(2).revision,
+                payload: { isSuccess: true },
+            });
+        });
+
+        afterEach(() => {
+            clock.restore();
+            sinon.restore();
+        });
+
+        it('should send only the replacement on connection B', () => {
+            const body = getSubscribeBody(2);
+            body.connectionId.should.equal('connection-b');
+            body.queryId.should.equal(queryId);
+            body.request.should.deep.equal(replacementRequest);
+            body.revision.should.be.greaterThan(0);
+        });
+
+        it('should not retry the obsolete subscription', () =>
+            context.fetchStub.callCount.should.equal(3));
+
+        it('should notify only the replacement callback', () => {
+            originalCallback.called.should.equal(false);
+            replacementCallback.calledOnce.should.equal(true);
+        });
+
+        it('should not reconnect', () =>
+            (context.policy.schedule as sinon.SinonStub).called.should.be.false);
+
+        it('should retain one active subscription', () =>
+            context.connection.queryCount.should.equal(1));
+
+        function getSubscribeBody(callIndex: number): {
+            connectionId: string;
+            queryId: string;
+            request: object;
+            revision: number;
+        } {
+            const rawBody = context.fetchStub.getCall(callIndex).args[1].body as string;
+            try {
+                return JSON.parse(rawBody) as {
+                    connectionId: string;
+                    queryId: string;
+                    request: object;
+                    revision: number;
+                };
+            } catch (error) {
+                throw new Error('Expected a valid subscribe request body', {
+                    cause: error,
+                });
+            }
+        }
+    }),
+);

package/queries/for_ServerSentEventHubConnection/when_connection_changes_while_subscribe_is_in_flight/and_the_query_is_unsubscribed.ts

@@ -0,0 +1,109 @@
+// 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_deferred_promise } from '../given/a_deferred_promise';
+import { a_server_sent_event_hub_connection } from '../given/a_server_sent_event_hub_connection';
+import { given } from '../../../given';
+import { HubMessageType } from '../../WebSocketHubConnection';
+
+const subscribeUrl = 'http://localhost/.cratis/queries/sse/subscribe';
+
+describe(
+    'when a query is unsubscribed while its subscribe request is in flight and the connection changes',
+    given(a_server_sent_event_hub_connection, (context) => {
+        let clock: sinon.SinonFakeTimers;
+
+        beforeEach(async () => {
+            context.setup();
+            clock = sinon.useFakeTimers({ toFake: ['setTimeout'] });
+            sinon.stub(console, 'warn');
+            const firstSubscribe = new a_deferred_promise<{
+                ok: boolean;
+                status: number;
+            }>();
+            context.fetchStub.onFirstCall().returns(firstSubscribe.promise);
+
+            context.connection.subscribe(
+                'removed-query',
+                { queryName: 'RemovedQuery' },
+                sinon.stub(),
+            );
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-a',
+                supportsSubscriptionRevisions: true,
+            });
+            context.connection.subscribe(
+                'active-query',
+                { queryName: 'ActiveQuery' },
+                sinon.stub(),
+            );
+            context.connection.unsubscribe('removed-query');
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-b',
+                supportsSubscriptionRevisions: true,
+            });
+
+            firstSubscribe.resolve({ ok: false, status: 404 });
+            await Promise.resolve();
+            clock.tick(1000);
+            await Promise.resolve();
+        });
+
+        afterEach(() => {
+            clock.restore();
+            sinon.restore();
+        });
+
+        it('should not subscribe the removed query on connection B', () => {
+            const removedQueryCalls = context.fetchStub
+                .getCalls()
+                .filter((call) => call.args[0] === subscribeUrl)
+                .filter((call) =>
+                    (call.args[1].body as string).includes('"queryId":"removed-query"'),
+                );
+            removedQueryCalls.length.should.equal(1);
+            const body = parseBody(removedQueryCalls[0].args[1].body as string);
+            body.connectionId.should.equal('connection-a');
+            body.queryId.should.equal('removed-query');
+            body.request.should.deep.equal({ queryName: 'RemovedQuery' });
+            body.revision.should.be.greaterThan(0);
+        });
+
+        it('should subscribe the remaining query on connection B', () => {
+            const activeQueryBodies = context.fetchStub
+                .getCalls()
+                .filter((call) => call.args[0] === subscribeUrl)
+                .map((call) => parseBody(call.args[1].body as string))
+                .filter((body) => body.queryId === 'active-query');
+            activeQueryBodies
+                .map((body) => body.connectionId)
+                .should.deep.equal(['connection-a', 'connection-b']);
+            activeQueryBodies[0].revision.should.equal(activeQueryBodies[1].revision);
+        });
+
+        it('should not reconnect', () =>
+            (context.policy.schedule as sinon.SinonStub).called.should.be.false);
+
+        it('should retain only the remaining subscription', () =>
+            context.connection.queryCount.should.equal(1));
+
+        function parseBody(rawBody: string): {
+            connectionId: string;
+            queryId: string;
+            request: { queryName: string };
+            revision: number;
+        } {
+            try {
+                return JSON.parse(rawBody) as ReturnType<typeof parseBody>;
+            } catch (error) {
+                throw new Error('Expected a valid subscribe request body', {
+                    cause: error,
+                });
+            }
+        }
+    }),
+);

package/queries/for_ServerSentEventHubConnection/when_connection_changes_while_subscribe_is_in_flight/and_the_stale_request_is_rejected.ts

@@ -0,0 +1,81 @@
+// 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_deferred_promise } from '../given/a_deferred_promise';
+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 the connection changes while a subscribe request is in flight and the stale request is rejected',
+    given(a_server_sent_event_hub_connection, (context) => {
+        const queryId = 'q1';
+        const request = { queryName: 'MyQuery' };
+        let clock: sinon.SinonFakeTimers;
+
+        beforeEach(async () => {
+            context.setup();
+            clock = sinon.useFakeTimers({ toFake: ['setTimeout'] });
+            sinon.stub(console, 'warn');
+            const firstSubscribe = new a_deferred_promise<{ ok: boolean }>();
+            context.fetchStub.onFirstCall().returns(firstSubscribe.promise);
+
+            context.connection.subscribe(queryId, request, sinon.stub());
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-a',
+                supportsSubscriptionRevisions: true,
+            });
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-b',
+                supportsSubscriptionRevisions: true,
+            });
+
+            firstSubscribe.reject(new Error('Connection A failed'));
+            await Promise.resolve();
+            await Promise.resolve();
+            clock.tick(1000);
+            await Promise.resolve();
+        });
+
+        afterEach(() => {
+            clock.restore();
+            sinon.restore();
+        });
+
+        it('should send the active subscription on connection B', () => {
+            const body = parseBody(context.fetchStub.getCall(1).args[1].body as string);
+            body.connectionId.should.equal('connection-b');
+            body.queryId.should.equal(queryId);
+            body.request.should.deep.equal(request);
+            body.revision.should.be.greaterThan(0);
+        });
+
+        it('should not retry the obsolete connection A request', () =>
+            context.fetchStub.callCount.should.equal(2));
+
+        it('should not reconnect', () =>
+            (context.policy.schedule as sinon.SinonStub).called.should.be.false);
+
+        it('should retain the active subscription', () =>
+            context.connection.queryCount.should.equal(1));
+
+        function parseBody(rawBody: string): {
+            connectionId: string;
+            queryId: string;
+            request: object;
+            revision: number;
+        } {
+            try {
+                return JSON.parse(rawBody) as ReturnType<typeof parseBody>;
+            } catch (error) {
+                throw new Error('Expected a valid subscribe request body', {
+                    cause: error,
+                });
+            }
+        }
+    }),
+);

package/queries/for_ServerSentEventHubConnection/when_connection_changes_while_subscribe_is_in_flight/and_the_stale_request_returns_non_ok.ts

@@ -0,0 +1,83 @@
+// 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_deferred_promise } from '../given/a_deferred_promise';
+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 the connection changes while a subscribe request is in flight and the stale request returns non-OK',
+    given(a_server_sent_event_hub_connection, (context) => {
+        const queryId = 'q1';
+        const request = { queryName: 'MyQuery' };
+        let clock: sinon.SinonFakeTimers;
+
+        beforeEach(async () => {
+            context.setup();
+            clock = sinon.useFakeTimers({ toFake: ['setTimeout'] });
+            sinon.stub(console, 'warn');
+            const firstSubscribe = new a_deferred_promise<{
+                ok: boolean;
+                status: number;
+            }>();
+            context.fetchStub.onFirstCall().returns(firstSubscribe.promise);
+
+            context.connection.subscribe(queryId, request, sinon.stub());
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-a',
+                supportsSubscriptionRevisions: true,
+            });
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-b',
+                supportsSubscriptionRevisions: true,
+            });
+
+            firstSubscribe.resolve({ ok: false, status: 404 });
+            await Promise.resolve();
+            clock.tick(1000);
+            await Promise.resolve();
+        });
+
+        afterEach(() => {
+            clock.restore();
+            sinon.restore();
+        });
+
+        it('should send the active subscription on connection B', () => {
+            const body = parseBody(context.fetchStub.getCall(1).args[1].body as string);
+            body.connectionId.should.equal('connection-b');
+            body.queryId.should.equal(queryId);
+            body.request.should.deep.equal(request);
+            body.revision.should.be.greaterThan(0);
+        });
+
+        it('should not retry the obsolete connection A request', () =>
+            context.fetchStub.callCount.should.equal(2));
+
+        it('should not reconnect', () =>
+            (context.policy.schedule as sinon.SinonStub).called.should.be.false);
+
+        it('should retain the active subscription', () =>
+            context.connection.queryCount.should.equal(1));
+
+        function parseBody(rawBody: string): {
+            connectionId: string;
+            queryId: string;
+            request: object;
+            revision: number;
+        } {
+            try {
+                return JSON.parse(rawBody) as ReturnType<typeof parseBody>;
+            } catch (error) {
+                throw new Error('Expected a valid subscribe request body', {
+                    cause: error,
+                });
+            }
+        }
+    }),
+);

package/queries/for_ServerSentEventHubConnection/when_disposing/cleans_up_resources.ts

@@ -6,29 +6,38 @@ import { a_server_sent_event_hub_connection } from '../given/a_server_sent_event
 import { given } from '../../../given';
 import { HubMessageType } from '../../WebSocketHubConnection';
 
-describe('when disposing the hub connection', given(a_server_sent_event_hub_connection, context => {
-    beforeEach(() => {
-        context.setup();
-        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
-        context.simulateOpen();
-        context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-1' });
-        context.connection.dispose();
-    });
+describe(
+    'when disposing the hub connection',
+    given(a_server_sent_event_hub_connection, (context) => {
+        beforeEach(() => {
+            context.setup();
+            context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'conn-1',
+            });
+            context.connection.dispose();
+        });
 
-    afterEach(() => sinon.restore());
+        afterEach(() => sinon.restore());
 
-    it('should close the EventSource', () => context.fakeEventSource.close.calledOnce.should.be.true);
-    it('should cancel the reconnect policy', () => (context.policy.cancel as sinon.SinonStub).calledOnce.should.be.true);
-    it('should report zero active subscriptions', () => context.connection.queryCount.should.equal(0));
+        it('should close the EventSource', () =>
+            context.fakeEventSource.close.calledOnce.should.be.true);
+        it('should cancel the reconnect policy', () =>
+            (context.policy.cancel as sinon.SinonStub).called.should.equal(true));
+        it('should report zero active subscriptions', () =>
+            context.connection.queryCount.should.equal(0));
 
-    describe('when an error event fires after dispose', () => {
-        beforeEach(() => {
-            (context.policy.schedule as sinon.SinonStub).reset();
-            context.simulateError();
-        });
+        describe('when an error event fires after dispose', () => {
+            beforeEach(() => {
+                (context.policy.schedule as sinon.SinonStub).reset();
+                context.simulateError();
+            });
 
-        it('should not schedule a reconnect', () => {
-            (context.policy.schedule as sinon.SinonStub).callCount.should.equal(0);
+            it('should not schedule a reconnect', () => {
+                (context.policy.schedule as sinon.SinonStub).callCount.should.equal(0);
+            });
         });
-    });
-}));
+    }),
+);

package/queries/for_ServerSentEventHubConnection/when_receiving_unauthorized/notifies_subscriber_and_removes_subscription.ts

@@ -7,45 +7,69 @@ 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';
+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();
+        beforeEach(() => {
+            context.setup();
+            callback = sinon.stub();
 
-        context.connection.subscribe(queryId, { queryName: 'SecureQuery' }, callback);
-        context.simulateOpen();
+            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 sends Connected message with the connection ID.
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: connectionId,
+                supportsSubscriptionRevisions: true,
+            });
+            const body = getSubscribeBody();
 
-        // Server replies with Unauthorized for this subscription.
-        context.simulateMessage({ type: HubMessageType.Unauthorized, queryId });
+            // Server replies with Unauthorized for this exact subscription.
+            context.simulateMessage({
+                type: HubMessageType.Unauthorized,
+                queryId,
+                revision: body.revision,
+            });
 
-        receivedResult = callback.firstCall?.args[0] as QueryResult<unknown> | undefined;
-    });
+            receivedResult = callback.firstCall?.args[0] as
+                | QueryResult<unknown>
+                | undefined;
+        });
 
-    afterEach(() => {
-        sinon.restore();
-    });
+        afterEach(() => {
+            sinon.restore();
+        });
 
-    it('should invoke the subscriber callback', () => {
-        callback.calledOnce.should.be.true;
-    });
+        function getSubscribeBody(): { revision: number } {
+            try {
+                return JSON.parse(context.fetchStub.firstCall.args[1].body as string) as {
+                    revision: number;
+                };
+            } catch (error) {
+                throw new Error('Expected a valid subscribe body', { cause: error });
+            }
+        }
 
-    it('should report isAuthorized as false', () => {
-        receivedResult!.isAuthorized.should.be.false;
-    });
+        it('should invoke the subscriber callback', () => {
+            callback.calledOnce.should.equal(true);
+        });
 
-    it('should report isSuccess as false', () => {
-        receivedResult!.isSuccess.should.be.false;
-    });
+        it('should report isAuthorized as false', () => {
+            receivedResult!.isAuthorized.should.equal(false);
+        });
 
-    it('should remove the subscription', () => {
-        context.connection.queryCount.should.equal(0);
-    });
-}));
+        it('should report isSuccess as false', () => {
+            receivedResult!.isSuccess.should.equal(false);
+        });
+
+        it('should remove the subscription', () => {
+            context.connection.queryCount.should.equal(0);
+        });
+    }),
+);

package/queries/for_ServerSentEventHubConnection/when_reconnecting/after_error.ts

@@ -14,7 +14,11 @@ describe('when connection errors', given(a_server_sent_event_hub_connection, con
         context.setup();
         context.connection.subscribe(queryId, { queryName: 'MyQuery' }, sinon.stub());
         context.simulateOpen();
-        context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-1' });
+        context.simulateMessage({
+            type: HubMessageType.Connected,
+            payload: 'conn-1',
+            supportsSubscriptionRevisions: true,
+        });
         context.simulateError();
     });
 
@@ -31,15 +35,14 @@ describe('when connection errors', given(a_server_sent_event_hub_connection, con
 
         beforeEach(() => {
             newEventSourceCreated = false;
-            // Replace the global EventSource with a stub that records construction
+            // Replace the global EventSource with a stub that records construction.
+            // SAFETY: This test double supplies the EventSource constructor and static ready-state shape used by the client.
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const FakeClass = function (this: any) {
                 newEventSourceCreated = true;
                 return context.fakeEventSource;
             } as unknown as new (url: string) => EventSource;
-            (FakeClass as unknown as Record<string, unknown>)['CONNECTING'] = 0;
-            (FakeClass as unknown as Record<string, unknown>)['OPEN'] = 1;
-            (FakeClass as unknown as Record<string, unknown>)['CLOSED'] = 2;
+            Object.assign(FakeClass, { CONNECTING: 0, OPEN: 1, CLOSED: 2 });
             (globalThis as Record<string, unknown>)['EventSource'] = FakeClass;
 
             const reconnectCallback = (context.policy.schedule as sinon.SinonStub).getCall(0).args[0] as ReconnectCallback;
@@ -57,6 +60,20 @@ describe('when connection errors', given(a_server_sent_event_hub_connection, con
             context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-2' });
         });
 
-        it('should re-subscribe all active queries', () => context.fetchStub.calledOnce.should.be.true);
+        it('should re-subscribe all active queries', () =>
+            context.fetchStub.calledOnce.should.equal(true));
+
+        it('should reset to legacy mode until the new connection advertises capabilities', () => {
+            const rawBody = context.fetchStub.firstCall.args[1].body as string;
+            let body: { revision?: number };
+            try {
+                body = JSON.parse(rawBody) as { revision?: number };
+            } catch (error) {
+                throw new Error('Expected a valid subscribe request body', {
+                    cause: error,
+                });
+            }
+            (body.revision === undefined).should.equal(true);
+        });
     });
 }));

package/queries/for_ServerSentEventHubConnection/when_reconnecting/and_an_immediate_open_wins_the_backoff_race.ts

@@ -0,0 +1,41 @@
+// 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 type { ReconnectCallback } from '../../IReconnectPolicy';
+
+describe(
+    'when an immediate SSE open wins a pending backoff race',
+    given(a_server_sent_event_hub_connection, (context) => {
+        beforeEach(() => {
+            context.setup();
+            sinon.stub(console, 'warn');
+            context.connection.subscribe(
+                'query-a',
+                { queryName: 'QueryA' },
+                sinon.stub(),
+            );
+            context.simulateError();
+
+            const delayedReconnect = context.policy.schedule.firstCall
+                .args[0] as ReconnectCallback;
+            context.connection.subscribe(
+                'query-b',
+                { queryName: 'QueryB' },
+                sinon.stub(),
+            );
+            delayedReconnect();
+        });
+
+        afterEach(() => sinon.restore());
+
+        it('should create only the retired and immediate event sources', () =>
+            context.eventSources.length.should.equal(2));
+        it('should cancel the pending backoff when the immediate open wins', () =>
+            context.policy.cancel.called.should.equal(true));
+        it('should leave the immediate source connecting', () =>
+            context.eventSources[1].readyState.should.equal(EventSource.CONNECTING));
+    }),
+);