@cratis/arc 19.11.1 → 20.0.0

package/queries/for_ServerSentEventHubConnection/when_reconnecting/after_error.ts

@@ -0,0 +1,62 @@
+// 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 { ReconnectCallback } from '../../IReconnectPolicy';
+
+describe('when connection errors', given(a_server_sent_event_hub_connection, context => {
+    const queryId = 'q1';
+
+    beforeEach(() => {
+        context.setup();
+        context.connection.subscribe(queryId, { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+        context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-1' });
+        context.simulateError();
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should close the EventSource', () => context.fakeEventSource.close.calledOnce.should.be.true);
+
+    it('should delegate to the reconnect policy', () => {
+        (context.policy.schedule as sinon.SinonStub).calledOnce.should.be.true;
+    });
+
+    describe('when the policy fires the reconnect callback', () => {
+        let newEventSourceCreated: boolean;
+
+        beforeEach(() => {
+            newEventSourceCreated = false;
+            // Replace the global EventSource with a stub that records construction
+            // 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;
+            (globalThis as Record<string, unknown>)['EventSource'] = FakeClass;
+
+            const reconnectCallback = (context.policy.schedule as sinon.SinonStub).getCall(0).args[0] as ReconnectCallback;
+            reconnectCallback();
+        });
+
+        it('should open a new EventSource', () => newEventSourceCreated.should.be.true);
+    });
+
+    describe('when Connected arrives after reconnect', () => {
+        beforeEach(() => {
+            const reconnectCallback = (context.policy.schedule as sinon.SinonStub).getCall(0).args[0] as ReconnectCallback;
+            reconnectCallback();
+            context.fetchStub.resetHistory();
+            context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-2' });
+        });
+
+        it('should re-subscribe all active queries', () => context.fetchStub.calledOnce.should.be.true);
+    });
+}));

package/queries/for_ServerSentEventHubConnection/when_subscribing/queues_until_connected.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 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 subscribing before Connected arrives', given(a_server_sent_event_hub_connection, context => {
+    const queryId = 'q1';
+
+    beforeEach(() => {
+        // Subscribe before Connected message — no connectionId yet
+        context.setup();
+        context.connection.subscribe(queryId, { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+        // No Connected message yet
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should not POST before the Connected message arrives', () => context.fetchStub.callCount.should.equal(0));
+
+    describe('when Connected message arrives', () => {
+        beforeEach(() => {
+            context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-1' });
+        });
+
+        it('should drain the pending subscription with a POST', () => context.fetchStub.calledOnce.should.be.true);
+    });
+}));

package/queries/for_ServerSentEventHubConnection/when_subscribing/sends_subscribe_post.ts

@@ -0,0 +1,42 @@
+// 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 subscribing sends the subscribe POST after Connected', given(a_server_sent_event_hub_connection, context => {
+    const queryId = 'q1';
+    const connectionId = 'conn-abc';
+
+    beforeEach(() => {
+        context.setup();
+        context.connection.subscribe(queryId, { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+        context.simulateMessage({ type: HubMessageType.Connected, payload: connectionId });
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should POST to the subscribe URL', () => context.fetchStub.calledOnce.should.be.true);
+    it('should pass the connection id in the request body', () => {
+        const body = JSON.parse(context.fetchStub.getCall(0).args[1].body);
+        body.connectionId.should.equal(connectionId);
+    });
+    it('should pass the query id in the request body', () => {
+        const body = JSON.parse(context.fetchStub.getCall(0).args[1].body);
+        body.queryId.should.equal(queryId);
+    });
+
+    describe('when a query result message arrives', () => {
+        const result = { isSuccess: true, data: ['x'] };
+
+        beforeEach(() => {
+            context.simulateMessage({ type: HubMessageType.QueryResult, queryId, payload: result });
+        });
+
+        // The callback passed to subscribe during beforeEach is a stub — re-verify via query count
+        it('should have one active subscription', () => context.connection.queryCount.should.equal(1));
+    });
+}));

package/queries/for_ServerSentEventHubConnection/when_unsubscribing/the_only_query.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 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 unsubscribing the only query', given(a_server_sent_event_hub_connection, context => {
+    beforeEach(async () => {
+        context.setup();
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+        context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-abc' });
+
+        context.connection.unsubscribe('q1');
+
+        // Allow the micro-task queue to drain so the async fetch completes.
+        await Promise.resolve();
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should close the event source', () => context.fakeEventSource.close.calledOnce.should.be.true);
+
+    it('should send an unsubscribe POST request', () => {
+        const unsubscribeCalls = context.fetchStub.args.filter(
+            (args: unknown[]) => typeof args[0] === 'string' && (args[0] as string).includes('unsubscribe')
+        );
+        unsubscribeCalls.length.should.equal(1);
+    });
+}));

package/queries/for_ServerSentEventQueryConnection/when_connecting/with_query_arguments.ts

@@ -0,0 +1,63 @@
+// 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 { ServerSentEventQueryConnection } from '../../ServerSentEventQueryConnection';
+import { QueryResult } from '../../QueryResult';
+
+interface FakeEventSource {
+    url: string;
+    onmessage: ((event: MessageEvent) => void) | null;
+    onerror: (() => void) | null;
+    close: sinon.SinonStub;
+}
+
+describe('when connecting with query arguments', () => {
+    let fakeEventSource: FakeEventSource;
+    let connection: ServerSentEventQueryConnection<string[]>;
+    let receivedData: QueryResult<string[]>[];
+
+    beforeEach(() => {
+        fakeEventSource = {
+            url: '',
+            onmessage: null,
+            onerror: null,
+            close: sinon.stub(),
+        };
+
+        const FakeEventSourceClass = function (this: FakeEventSource, url: string) {
+            fakeEventSource.url = url;
+            Object.assign(fakeEventSource, { onmessage: null, onerror: null });
+            return fakeEventSource;
+        };
+
+        (globalThis as Record<string, unknown>)['EventSource'] = FakeEventSourceClass;
+
+        receivedData = [];
+        connection = new ServerSentEventQueryConnection<string[]>(
+            new URL('http://localhost/.cratis/queries/sse?query=Test')
+        );
+        connection.connect(
+            (result: QueryResult<string[]>) => receivedData.push(result),
+            { category: 'books' }
+        );
+    });
+
+    afterEach(() => {
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+        sinon.restore();
+    });
+
+    it('should append query arguments to the URL', () => fakeEventSource.url.should.contain('category=books'));
+
+    describe('when a message arrives', () => {
+        const result = { data: ['a', 'b'], isSuccess: true, isAuthorized: true, isValid: true, hasExceptions: false, hasData: true, validationResults: [], exceptionMessages: [], exceptionStackTrace: '', paging: { page: 0, size: 0, totalItems: 0, totalPages: 0 } };
+
+        beforeEach(() => {
+            fakeEventSource.onmessage!({ data: JSON.stringify(result) } as MessageEvent);
+        });
+
+        it('should deliver the payload to the callback', () => receivedData.length.should.equal(1));
+        it('should pass through the raw QueryResult in direct mode', () => receivedData[0]!.isSuccess.should.be.true);
+    });
+});

package/queries/for_ServerSentEventQueryConnection/when_connecting/without_event_source_available.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 sinon from 'sinon';
+import { ServerSentEventQueryConnection } from '../../ServerSentEventQueryConnection';
+import { QueryResult } from '../../QueryResult';
+
+describe('when connecting in an environment where EventSource is not available', () => {
+    let originalEventSource: typeof EventSource;
+    let connection: ServerSentEventQueryConnection<string[]>;
+    let dataReceivedStub: sinon.SinonStub;
+
+    beforeEach(() => {
+        originalEventSource = (globalThis as Record<string, unknown>)['EventSource'] as typeof EventSource;
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+
+        dataReceivedStub = sinon.stub();
+        connection = new ServerSentEventQueryConnection<string[]>(new URL('http://localhost/.cratis/queries/sse?query=Test'));
+        connection.connect(dataReceivedStub as unknown as (result: QueryResult<string[]>) => void);
+    });
+
+    afterEach(() => {
+        if (originalEventSource !== undefined) {
+            (globalThis as Record<string, unknown>)['EventSource'] = originalEventSource;
+        }
+        sinon.restore();
+    });
+
+    it('should not call data received', () => dataReceivedStub.called.should.be.false);
+    it('should not throw', () => true.should.be.true);
+});

package/queries/for_ServerSentEventQueryConnection/when_disconnecting/after_connecting.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 { ServerSentEventQueryConnection } from '../../ServerSentEventQueryConnection';
+import { QueryResult } from '../../QueryResult';
+
+describe('when disconnecting closes the EventSource', () => {
+    let closeStub: sinon.SinonStub;
+    let connection: ServerSentEventQueryConnection<string[]>;
+
+    beforeEach(() => {
+        closeStub = sinon.stub();
+
+        const FakeEventSourceClass = function (this: Record<string, unknown>) {
+            this.onmessage = null;
+            this.onerror = null;
+            this.close = closeStub;
+        };
+
+        (globalThis as Record<string, unknown>)['EventSource'] = FakeEventSourceClass;
+
+        connection = new ServerSentEventQueryConnection<string[]>(
+            new URL('http://localhost/.cratis/queries/sse?query=Test')
+        );
+        connection.connect((_: QueryResult<string[]>) => _);
+        connection.disconnect();
+    });
+
+    afterEach(() => {
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+        sinon.restore();
+    });
+
+    it('should call close on the EventSource', () => closeStub.calledOnce.should.be.true);
+});

package/queries/for_ServerSentEventQueryConnection/when_disconnecting/before_message_arrives.ts

@@ -0,0 +1,38 @@
+// 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 { ServerSentEventQueryConnection } from '../../ServerSentEventQueryConnection';
+
+describe('when disconnecting prevents further message delivery', () => {
+    let fakeEventSource: Record<string, unknown>;
+    let connection: ServerSentEventQueryConnection<string[]>;
+    let receivedCount: number;
+
+    beforeEach(() => {
+        fakeEventSource = { onmessage: null, onerror: null, close: sinon.stub() };
+
+        (globalThis as Record<string, unknown>)['EventSource'] = function () {
+            return fakeEventSource;
+        };
+
+        receivedCount = 0;
+        connection = new ServerSentEventQueryConnection<string[]>(
+            new URL('http://localhost/.cratis/queries/sse?query=Test')
+        );
+        connection.connect(() => { receivedCount++; });
+
+        // Disconnect first, then send a message
+        connection.disconnect();
+        (fakeEventSource['onmessage'] as ((event: MessageEvent) => void) | null)?.(
+            { data: JSON.stringify({ isSuccess: true }) } as MessageEvent
+        );
+    });
+
+    afterEach(() => {
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+        sinon.restore();
+    });
+
+    it('should not deliver messages after disconnect', () => receivedCount.should.equal(0));
+});

package/queries/for_WebSocketHubConnection/given/a_web_socket_hub_connection.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 { WebSocketHubConnection } from '../../WebSocketHubConnection';
+import { IReconnectPolicy } from '../../IReconnectPolicy';
+import { ReconnectCallback } from '../../IReconnectPolicy';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export class a_web_socket_hub_connection {
+    connection!: WebSocketHubConnection;
+    fakeSocket!: {
+        onopen: (() => void) | null;
+        onclose: (() => void) | null;
+        onerror: ((error: Event) => void) | null;
+        onmessage: ((ev: MessageEvent) => void) | null;
+        send: sinon.SinonStub;
+        close: sinon.SinonStub;
+        readyState: number;
+    };
+    policy!: sinon.SinonStubbedInstance<IReconnectPolicy>;
+    WebSocketStub!: sinon.SinonStub;
+
+    constructor() {
+        this.setup();
+    }
+
+    /**
+     * Re-initializes stubs and creates a fresh {@link WebSocketHubConnection}.
+     * Call this at the start of each {@code beforeEach} to prevent stub-call
+     * accumulation across tests sharing the same context instance.
+     */
+    setup(): void {
+        this.fakeSocket = {
+            onopen: null,
+            onclose: null,
+            onerror: null,
+            onmessage: null,
+            send: sinon.stub(),
+            close: sinon.stub(),
+            readyState: 0, // CONNECTING
+        };
+
+        this.WebSocketStub = sinon.stub().returns(this.fakeSocket);
+        (globalThis as any)['WebSocket'] = this.WebSocketStub;
+        // WebSocket ready-state constants (numeric values matching the spec)
+        (globalThis as any)['WebSocket'].CONNECTING = 0;
+        (globalThis as any)['WebSocket'].OPEN = 1;
+        (globalThis as any)['WebSocket'].CLOSING = 2;
+        (globalThis as any)['WebSocket'].CLOSED = 3;
+
+        this.policy = {
+            attempt: 0,
+            schedule: sinon.stub<[ReconnectCallback, string], boolean>().returns(true),
+            reset: sinon.stub(),
+            cancel: sinon.stub(),
+        };
+
+        this.connection = new WebSocketHubConnection(
+            'ws://localhost/.cratis/queries/ws',
+            '',
+            undefined,
+            this.policy
+        );
+    }
+
+    simulateOpen(): void {
+        this.fakeSocket.readyState = 1; // OPEN
+        this.fakeSocket.onopen?.();
+    }
+
+    simulateClose(): void {
+        this.fakeSocket.readyState = 3; // CLOSED
+        this.fakeSocket.onclose?.();
+    }
+
+    simulateMessage(payload: object): void {
+        this.fakeSocket.onmessage?.({ data: JSON.stringify(payload) } as MessageEvent);
+    }
+}

package/queries/for_WebSocketHubConnection/when_disposing/cleans_up_resources.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 sinon from 'sinon';
+import { a_web_socket_hub_connection } from '../given/a_web_socket_hub_connection';
+import { given } from '../../../given';
+
+describe('when disposing the hub connection', given(a_web_socket_hub_connection, context => {
+    beforeEach(() => {
+        context.setup();
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+        context.connection.dispose();
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should close the socket', () => context.fakeSocket.close.calledOnce.should.be.true);
+    it('should cancel the reconnect policy', () => (context.policy.cancel as sinon.SinonStub).calledOnce.should.be.true);
+
+    describe('when the socket fires onclose after dispose', () => {
+        beforeEach(() => {
+            (context.policy.schedule as sinon.SinonStub).reset();
+            context.simulateClose();
+        });
+
+        it('should not schedule a reconnect', () => {
+            (context.policy.schedule as sinon.SinonStub).callCount.should.equal(0);
+        });
+    });
+}));

package/queries/for_WebSocketHubConnection/when_keep_alive_is_idle/sends_a_ping.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';
+
+const PING_INTERVAL_MS = 500;
+
+describe('when keep-alive interval elapses without any message', given(a_web_socket_hub_connection, context => {
+    let clock: sinon.SinonFakeTimers;
+
+    beforeEach(() => {
+        clock = sinon.useFakeTimers();
+        context.setup();
+
+        // Construct a new connection with a short ping interval so tests are fast.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+        const { WebSocketHubConnection } = require('../../WebSocketHubConnection');
+        context.connection = new WebSocketHubConnection(
+            'ws://localhost/.cratis/queries/ws',
+            '',
+            PING_INTERVAL_MS,
+            context.policy
+        );
+
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+
+        // Advance past the ping interval without sending any messages.
+        clock.tick(PING_INTERVAL_MS + 1);
+    });
+
+    afterEach(() => {
+        clock.restore();
+        sinon.restore();
+    });
+
+    it('should send a ping message', () => {
+        const sentMessages: string[] = context.fakeSocket.send.args.map((a: string[]) => a[0]);
+        const pingMessages = sentMessages
+            .map((m: string) => JSON.parse(m))
+            .filter((m: { type: HubMessageType }) => m.type === HubMessageType.Ping);
+        pingMessages.length.should.be.greaterThan(0);
+    });
+}));

package/queries/for_WebSocketHubConnection/when_receiving_a_message/resets_keep_alive_timer.ts

@@ -0,0 +1,53 @@
+// 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';
+
+const PING_INTERVAL_MS = 500;
+
+describe('when a message is received and then keep-alive interval elapses', given(a_web_socket_hub_connection, context => {
+    let clock: sinon.SinonFakeTimers;
+
+    beforeEach(() => {
+        clock = sinon.useFakeTimers();
+        context.setup();
+
+        // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+        const { WebSocketHubConnection } = require('../../WebSocketHubConnection');
+        context.connection = new WebSocketHubConnection(
+            'ws://localhost/.cratis/queries/ws',
+            '',
+            PING_INTERVAL_MS,
+            context.policy
+        );
+
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+
+        // Advance to just before the ping interval.
+        clock.tick(PING_INTERVAL_MS - 50);
+
+        // A message arrives — this resets the inactivity timer.
+        context.simulateMessage({ type: HubMessageType.QueryResult, queryId: 'q1', payload: { items: [], totalItems: 0 } });
+
+        // Advance another half interval — total elapsed is PING_INTERVAL_MS + PING_INTERVAL_MS/2 - 50,
+        // but only PING_INTERVAL_MS/2 has passed since the last activity.
+        clock.tick(PING_INTERVAL_MS / 2);
+    });
+
+    afterEach(() => {
+        clock.restore();
+        sinon.restore();
+    });
+
+    it('should not send a ping', () => {
+        const sentMessages: string[] = context.fakeSocket.send.args.map((a: string[]) => a[0]);
+        const pingMessages = sentMessages
+            .map((m: string) => JSON.parse(m))
+            .filter((m: { type: HubMessageType }) => m.type === HubMessageType.Ping);
+        pingMessages.length.should.equal(0);
+    });
+}));

package/queries/for_WebSocketHubConnection/when_reconnecting/after_unexpected_close.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_web_socket_hub_connection } from '../given/a_web_socket_hub_connection';
+import { given } from '../../../given';
+import { ReconnectCallback } from '../../IReconnectPolicy';
+
+describe('when the connection closes unexpectedly', given(a_web_socket_hub_connection, context => {
+    beforeEach(() => {
+        context.setup();
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+        context.simulateClose();
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should delegate to the reconnect policy', () => {
+        (context.policy.schedule as sinon.SinonStub).calledOnce.should.be.true;
+    });
+
+    describe('when the policy fires the reconnect callback', () => {
+        let secondSocketCreated: boolean;
+
+        beforeEach(() => {
+            secondSocketCreated = false;
+            context.WebSocketStub.callsFake(() => {
+                secondSocketCreated = true;
+                return context.fakeSocket;
+            });
+
+            // Simulate the policy invoking the callback immediately
+            const scheduleCall = (context.policy.schedule as sinon.SinonStub).getCall(0);
+            const reconnectCallback = scheduleCall.args[0] as ReconnectCallback;
+            reconnectCallback();
+        });
+
+        it('should open a new WebSocket', () => secondSocketCreated.should.be.true);
+    });
+}));

package/queries/for_WebSocketHubConnection/when_reconnecting/resubscribes_all_queries.ts

@@ -0,0 +1,43 @@
+// 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 { 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;
+    });
+}));