@cratis/arc 22.0.2 → 22.1.0

package/queries/for_WebSocketHubConnection/when_reconnecting/resubscribes_all_queries.ts

@@ -5,39 +5,75 @@ 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 { ReconnectCallback } from '../../IReconnectPolicy';
-
-describe('when reconnecting after a drop', given(a_web_socket_hub_connection, context => {
-    const queryId = 'q1';
-    let callbackStub: sinon.SinonStub;
-
-    beforeEach(() => {
-        callbackStub = sinon.stub();
-        context.setup();
-        context.connection.subscribe(queryId, { queryName: 'MyQuery' }, callbackStub);
-        context.simulateOpen();
-
-        // Simulate drop and policy-driven reconnect
-        context.simulateClose();
-        const reconnectCallback = (context.policy.schedule as sinon.SinonStub).getCall(0).args[0] as ReconnectCallback;
-        context.fakeSocket.send.reset();
-        (context.policy.reset as sinon.SinonStub).reset();
-        reconnectCallback();
-
-        // The new socket opens
-        context.simulateOpen();
-    });
-
-    afterEach(() => sinon.restore());
-
-    it('should re-send all active subscriptions', () => {
-        context.fakeSocket.send.calledOnce.should.be.true;
-        const msg = JSON.parse(context.fakeSocket.send.getCall(0).args[0]);
-        msg.type.should.equal(HubMessageType.Subscribe);
-        msg.queryId.should.equal(queryId);
-    });
-
-    it('should reset the reconnect policy on successful open', () => {
-        (context.policy.reset as sinon.SinonStub).calledOnce.should.be.true;
-    });
-}));
+import type { ReconnectCallback } from '../../IReconnectPolicy';
+
+describe(
+    'when reconnecting after a drop',
+    given(a_web_socket_hub_connection, (context) => {
+        const queryId = 'q1';
+        let callbackStub: sinon.SinonStub;
+
+        beforeEach(() => {
+            callbackStub = sinon.stub();
+            context.setup();
+            context.connection.subscribe(queryId, { queryName: 'MyQuery' }, callbackStub);
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                supportsSubscriptionRevisions: true,
+            });
+
+            // Simulate drop and policy-driven reconnect
+            context.simulateClose();
+            const reconnectCallback = (
+                context.policy.schedule as sinon.SinonStub
+            ).getCall(0).args[0] as ReconnectCallback;
+            context.fakeSocket.send.reset();
+            (context.policy.reset as sinon.SinonStub).reset();
+            reconnectCallback();
+
+            // The new socket opens in legacy mode, then upgrades when the new handshake arrives.
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                supportsSubscriptionRevisions: true,
+            });
+        });
+
+        afterEach(() => sinon.restore());
+
+        it('should reset to a legacy subscription on the new socket', () => {
+            const msg = getSentMessage(0);
+            msg.type.should.equal(HubMessageType.Subscribe);
+            msg.queryId.should.equal(queryId);
+            (msg.revision === undefined).should.equal(true);
+        });
+
+        it('should upgrade the reconnect subscription after the new handshake', () => {
+            const msg = getSentMessage(1);
+            msg.type.should.equal(HubMessageType.Subscribe);
+            msg.queryId.should.equal(queryId);
+            (msg.revision ?? 0).should.be.greaterThan(0);
+        });
+
+        it('should reset the reconnect policy on successful open', () => {
+            (context.policy.reset as sinon.SinonStub).calledOnce.should.be.true;
+        });
+
+        function getSentMessage(index: number): {
+            type: HubMessageType;
+            queryId: string;
+            revision?: number;
+        } {
+            try {
+                return JSON.parse(context.fakeSocket.send.getCall(index).args[0]) as {
+                    type: HubMessageType;
+                    queryId: string;
+                    revision?: number;
+                };
+            } catch (error) {
+                throw new Error('Expected a valid hub message', { cause: error });
+            }
+        }
+    }),
+);

package/queries/for_WebSocketHubConnection/when_replacing_a_subscription/ignores_stale_result_unauthorized_and_error.ts

@@ -0,0 +1,88 @@
+// 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 { type HubMessage, HubMessageType } from '../../WebSocketHubConnection';
+
+describe(
+    'when stale frames arrive after a WebSocket subscription is replaced',
+    given(a_web_socket_hub_connection, (context) => {
+        const queryId = 'query-a';
+        let originalCallback: sinon.SinonStub;
+        let replacementCallback: sinon.SinonStub;
+
+        beforeEach(() => {
+            context.setup();
+            sinon.stub(console, 'warn');
+            sinon.stub(console, 'error');
+            originalCallback = sinon.stub();
+            replacementCallback = sinon.stub();
+
+            context.connection.subscribe(
+                queryId,
+                { queryName: 'Original' },
+                originalCallback,
+            );
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                supportsSubscriptionRevisions: true,
+            });
+            const originalRevision = sentMessage(1).revision!;
+
+            context.connection.subscribe(
+                queryId,
+                { queryName: 'Replacement' },
+                replacementCallback,
+            );
+            const replacementRevision = sentMessage(2).revision!;
+
+            context.simulateMessage({
+                type: HubMessageType.QueryResult,
+                queryId,
+                revision: originalRevision,
+                payload: { data: ['stale'] },
+            });
+            context.simulateMessage({
+                type: HubMessageType.Unauthorized,
+                queryId,
+                revision: originalRevision,
+            });
+            context.simulateMessage({
+                type: HubMessageType.Error,
+                queryId,
+                revision: originalRevision,
+                payload: 'stale',
+            });
+            context.simulateMessage({
+                type: HubMessageType.QueryResult,
+                queryId,
+                revision: replacementRevision,
+                payload: { data: ['current'] },
+            });
+        });
+
+        afterEach(() => sinon.restore());
+
+        it('should not deliver the stale result', () =>
+            originalCallback.called.should.be.false);
+        it('should deliver the replacement result', () =>
+            replacementCallback.calledOnce.should.be.true);
+        it('should retain the replacement after stale unauthorized', () =>
+            context.connection.queryCount.should.equal(1));
+        it('should not log the stale error', () =>
+            (console.error as sinon.SinonStub).called.should.be.false);
+
+        function sentMessage(index: number): HubMessage {
+            try {
+                return JSON.parse(
+                    context.fakeSocket.send.getCall(index).args[0],
+                ) as HubMessage;
+            } catch (error) {
+                throw new Error('Expected a valid hub message', { cause: error });
+            }
+        }
+    }),
+);

package/queries/for_WebSocketHubConnection/when_subscribing/to_a_query.ts

@@ -6,37 +6,64 @@ import { a_web_socket_hub_connection } from '../given/a_web_socket_hub_connectio
 import { given } from '../../../given';
 import { HubMessageType } from '../../WebSocketHubConnection';
 
-describe('when subscribing to a query', given(a_web_socket_hub_connection, context => {
-    const queryId = 'q1';
-    const request = { queryName: 'MyQuery', arguments: {} };
-    let callback: sinon.SinonStub;
+describe(
+    'when subscribing to a query',
+    given(a_web_socket_hub_connection, (context) => {
+        const queryId = 'q1';
+        const request = { queryName: 'MyQuery', arguments: {} };
+        let callback: sinon.SinonStub;
 
-    beforeEach(() => {
-        callback = sinon.stub();
-        context.setup();
-        context.connection.subscribe(queryId, request, callback);
-        context.simulateOpen();
-    });
+        beforeEach(() => {
+            callback = sinon.stub();
+            context.setup();
+            context.connection.subscribe(queryId, request, callback);
+            context.simulateOpen();
+        });
 
-    afterEach(() => sinon.restore());
+        afterEach(() => sinon.restore());
 
-    it('should open a WebSocket', () => context.WebSocketStub.calledOnce.should.be.true);
+        it('should open a WebSocket', () =>
+            context.WebSocketStub.calledOnce.should.be.true);
 
-    it('should send a subscribe message once the socket opens', () => {
-        context.fakeSocket.send.calledOnce.should.be.true;
-        const msg = JSON.parse(context.fakeSocket.send.getCall(0).args[0]);
-        msg.type.should.equal(HubMessageType.Subscribe);
-        msg.queryId.should.equal(queryId);
-    });
+        it('should send a legacy subscribe message once the socket opens', () => {
+            context.fakeSocket.send.calledOnce.should.equal(true);
+            const msg = getSentMessage();
+            msg.type.should.equal(HubMessageType.Subscribe);
+            msg.queryId.should.equal(queryId);
+            (msg.revision === undefined).should.equal(true);
+        });
 
-    describe('when a query result message arrives', () => {
-        const result = { isSuccess: true, data: [1, 2, 3] };
+        function getSentMessage(): {
+            type: HubMessageType;
+            queryId: string;
+            revision?: number;
+        } {
+            try {
+                return JSON.parse(context.fakeSocket.send.firstCall.args[0]) as {
+                    type: HubMessageType;
+                    queryId: string;
+                    revision?: number;
+                };
+            } catch (error) {
+                throw new Error('Expected a valid hub message', { cause: error });
+            }
+        }
 
-        beforeEach(() => {
-            context.simulateMessage({ type: HubMessageType.QueryResult, queryId, payload: result });
-        });
+        describe('when a query result message arrives', () => {
+            const result = { isSuccess: true, data: [1, 2, 3] };
+
+            beforeEach(() => {
+                context.simulateMessage({
+                    type: HubMessageType.QueryResult,
+                    queryId,
+                    payload: result,
+                });
+            });
 
-        it('should invoke the callback with the result', () => callback.calledOnce.should.be.true);
-        it('should pass the result payload', () => callback.getCall(0).args[0].should.deep.equal(result));
-    });
-}));
+            it('should invoke the callback with the result', () =>
+                callback.calledOnce.should.be.true);
+            it('should pass the result payload', () =>
+                callback.getCall(0).args[0].should.deep.equal(result));
+        });
+    }),
+);

package/queries/for_WebSocketHubConnection/when_subscription_revisions_are_supported/upgrades_active_subscriptions_to_strict_mode.ts

@@ -0,0 +1,72 @@
+// 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 { given } from '../../../given';
+import { type HubMessage, HubMessageType } from '../../WebSocketHubConnection';
+import { a_web_socket_hub_connection } from '../given/a_web_socket_hub_connection';
+
+describe(
+    'when the WebSocket server advertises subscription revision support',
+    given(a_web_socket_hub_connection, (context) => {
+        const queryId = 'query-1';
+        let callback: sinon.SinonStub;
+        let revision: number;
+
+        beforeEach(() => {
+            context.setup();
+            callback = sinon.stub();
+            context.connection.subscribe(queryId, { queryName: 'MyQuery' }, callback);
+            context.simulateOpen();
+
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                supportsSubscriptionRevisions: true,
+            });
+            const upgradedRevision = sentMessage(1).revision;
+            if (upgradedRevision === undefined) {
+                throw new Error('Expected the upgraded subscription to carry a revision');
+            }
+            revision = upgradedRevision;
+
+            context.simulateMessage({
+                type: HubMessageType.QueryResult,
+                queryId,
+                payload: { data: ['legacy'] },
+            });
+            context.simulateMessage({
+                type: HubMessageType.QueryResult,
+                queryId,
+                revision,
+                payload: { data: ['current'] },
+            });
+        });
+
+        afterEach(() => sinon.restore());
+
+        it('should initially subscribe without a revision for older servers', () =>
+            (sentMessage(0).revision === undefined).should.equal(true));
+
+        it('should replace the legacy subscription with its current revision', () => {
+            const message = sentMessage(1);
+            message.type.should.equal(HubMessageType.Subscribe);
+            (message.queryId === queryId).should.equal(true);
+            revision.should.be.greaterThan(0);
+        });
+
+        it('should ignore the temporary legacy result and deliver the strict result once', () => {
+            callback.calledOnce.should.equal(true);
+            callback.firstCall.args[0].should.deep.equal({ data: ['current'] });
+        });
+
+        function sentMessage(index: number): HubMessage {
+            try {
+                return JSON.parse(
+                    context.fakeSocket.send.getCall(index).args[0],
+                ) as HubMessage;
+            } catch (error) {
+                throw new Error('Expected a valid hub message', { cause: error });
+            }
+        }
+    }),
+);

package/queries/for_WebSocketHubConnection/when_unsubscribing/the_only_query.ts

@@ -6,25 +6,50 @@ import { a_web_socket_hub_connection } from '../given/a_web_socket_hub_connectio
 import { given } from '../../../given';
 import { HubMessageType } from '../../WebSocketHubConnection';
 
-describe('when unsubscribing the only query', given(a_web_socket_hub_connection, context => {
-    const queryId = 'q1';
+describe(
+    'when unsubscribing the only query',
+    given(a_web_socket_hub_connection, (context) => {
+        const queryId = 'q1';
 
-    beforeEach(() => {
-        context.setup();
-        context.connection.subscribe(queryId, { queryName: 'MyQuery' }, sinon.stub());
-        context.simulateOpen();
-        context.fakeSocket.send.reset();
-        context.connection.unsubscribe(queryId);
-    });
+        beforeEach(() => {
+            context.setup();
+            context.connection.subscribe(queryId, { queryName: 'MyQuery' }, sinon.stub());
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                supportsSubscriptionRevisions: true,
+            });
+            context.fakeSocket.send.reset();
+            context.connection.unsubscribe(queryId);
+        });
 
-    afterEach(() => sinon.restore());
+        afterEach(() => sinon.restore());
 
-    it('should send an unsubscribe message', () => {
-        context.fakeSocket.send.calledOnce.should.be.true;
-        const msg = JSON.parse(context.fakeSocket.send.getCall(0).args[0]);
-        msg.type.should.equal(HubMessageType.Unsubscribe);
-        msg.queryId.should.equal(queryId);
-    });
+        it('should send an unsubscribe message', () => {
+            context.fakeSocket.send.calledOnce.should.equal(true);
+            const msg = getUnsubscribeMessage();
+            msg.type.should.equal(HubMessageType.Unsubscribe);
+            msg.queryId.should.equal(queryId);
+            msg.revision.should.equal(1);
+        });
 
-    it('should close the underlying socket', () => context.fakeSocket.close.calledOnce.should.be.true);
-}));
+        it('should close the underlying socket', () =>
+            context.fakeSocket.close.calledOnce.should.be.true);
+
+        function getUnsubscribeMessage(): {
+            type: HubMessageType;
+            queryId: string;
+            revision: number;
+        } {
+            try {
+                return JSON.parse(context.fakeSocket.send.firstCall.args[0]) as {
+                    type: HubMessageType;
+                    queryId: string;
+                    revision: number;
+                };
+            } catch (error) {
+                throw new Error('Expected a valid unsubscribe message', { cause: error });
+            }
+        }
+    }),
+);

package/queries/for_WebSocketHubConnection/when_unsubscribing/with_revision_support_not_advertised.ts

@@ -0,0 +1,44 @@
+// 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 { given } from '../../../given';
+import { type HubMessage, HubMessageType } from '../../WebSocketHubConnection';
+import { a_web_socket_hub_connection } from '../given/a_web_socket_hub_connection';
+
+describe(
+    'when unsubscribing before the WebSocket server advertises revision support',
+    given(a_web_socket_hub_connection, (context) => {
+        const queryId = 'query-1';
+        let message: HubMessage;
+
+        beforeEach(() => {
+            context.setup();
+            context.connection.subscribe(queryId, { queryName: 'MyQuery' }, sinon.stub());
+            context.simulateOpen();
+            context.fakeSocket.send.resetHistory();
+            context.connection.unsubscribe(queryId);
+            message = sentMessage();
+        });
+
+        afterEach(() => sinon.restore());
+
+        it('should send a legacy unsubscribe', () => {
+            message.type.should.equal(HubMessageType.Unsubscribe);
+            (message.queryId === queryId).should.equal(true);
+            (message.revision === undefined).should.equal(true);
+        });
+
+        function sentMessage(): HubMessage {
+            try {
+                return JSON.parse(
+                    context.fakeSocket.send.firstCall.args[0],
+                ) as HubMessage;
+            } catch (error) {
+                throw new Error('Expected a valid unsubscribe message', {
+                    cause: error,
+                });
+            }
+        }
+    }),
+);