@cratis/arc 22.0.1 → 22.1.0

package/queries/for_ServerSentEventHubConnection/given/a_server_sent_event_hub_connection.ts

@@ -16,6 +16,7 @@ export class a_server_sent_event_hub_connection {
         close: sinon.SinonStub;
         readyState: number;
     };
+    eventSources!: Array<typeof this.fakeEventSource>;
     policy!: sinon.SinonStubbedInstance<IReconnectPolicy>;
     fetchStub!: sinon.SinonStub;
 
@@ -29,20 +30,28 @@ export class a_server_sent_event_hub_connection {
      * accumulation across tests sharing the same context instance.
      */
     setup(): void {
+        this.eventSources = [];
         this.fakeEventSource = {
             onopen: null,
             onmessage: null,
             onerror: null,
             close: sinon.stub(),
-            readyState: 0, // CONNECTING
+            readyState: 0,
         };
 
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
         const FakeEventSourceClass = function (this: any) {
-            Object.assign(self.fakeEventSource, { onopen: null, onmessage: null, onerror: null });
-            self.fakeEventSource.readyState = 0; // CONNECTING
-            return self.fakeEventSource;
+            const eventSource = {
+                onopen: null,
+                onmessage: null,
+                onerror: null,
+                close: sinon.stub(),
+                readyState: 0, // CONNECTING
+            };
+            self.eventSources.push(eventSource);
+            self.fakeEventSource = eventSource;
+            return eventSource;
         };
         (globalThis as any)['EventSource'] = FakeEventSourceClass;
         (globalThis as any)['EventSource'].CONNECTING = 0;
@@ -66,7 +75,7 @@ export class a_server_sent_event_hub_connection {
             '',
             undefined,
             undefined,
-            this.policy
+            this.policy,
         );
     }
 
@@ -75,8 +84,10 @@ export class a_server_sent_event_hub_connection {
         this.fakeEventSource.onopen?.();
     }
 
-    simulateMessage(payload: object): void {
-        this.fakeEventSource.onmessage?.({ data: JSON.stringify(payload) } as MessageEvent);
+    simulateMessage(payload: Record<string, unknown>): void {
+        this.fakeEventSource.onmessage?.({
+            data: JSON.stringify(payload),
+        } as MessageEvent);
     }
 
     simulateError(): void {

package/queries/for_ServerSentEventHubConnection/when_a_retired_event_source_fires/ignores_connected_and_error_callbacks.ts

@@ -0,0 +1,59 @@
+// 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 a retired EventSource fires connected and error callbacks',
+    given(a_server_sent_event_hub_connection, (context) => {
+        let staleMessage: (event: MessageEvent) => void;
+        let staleError: () => void;
+        let currentSource: typeof context.fakeEventSource;
+
+        beforeEach(() => {
+            context.setup();
+            sinon.stub(console, 'warn');
+            context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-a',
+            });
+
+            const retiredSource = context.eventSources[0];
+            staleMessage = retiredSource.onmessage!;
+            staleError = retiredSource.onerror!;
+            staleError();
+
+            const reconnect = (context.policy.schedule as sinon.SinonStub).firstCall
+                .args[0] as () => void;
+            reconnect();
+            currentSource = context.eventSources[1];
+            context.simulateOpen();
+            context.simulateMessage({
+                type: HubMessageType.Connected,
+                payload: 'connection-b',
+            });
+
+            staleMessage({
+                data: JSON.stringify({
+                    type: HubMessageType.Connected,
+                    payload: 'stale-connection',
+                }),
+            } as MessageEvent);
+            staleError();
+        });
+
+        afterEach(() => sinon.restore());
+
+        it('should not send another subscription for stale connected', () =>
+            context.fetchStub.callCount.should.equal(2));
+        it('should keep the current EventSource open', () =>
+            currentSource.close.called.should.be.false);
+        it('should not schedule another reconnect for stale error', () =>
+            (context.policy.schedule as sinon.SinonStub).calledOnce.should.be.true);
+    }),
+);

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