factory-factory 0.3.21 → 0.4.1

package/dist/src/backend/routers/websocket/snapshots.handler.test.js

@@ -1,53 +1,37 @@
 import { EventEmitter } from 'node:events';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { WS_READY_STATE } from '../../../backend/constants/websocket.js';
-import { createSnapshotsUpgradeHandler, resetSnapshotsHandlerStateForTests, snapshotConnections, } from './snapshots.handler.js';
-import { validateWebSocketOrigin } from './upgrade-utils.js';
+import { createSnapshotsUpgradeHandler, disposeSnapshotsHandlerState, getSnapshotConnectionsForApplication, } from './snapshots.handler.js';
 const allowedOrigin = 'http://localhost:3000';
+const testApplications = new Set();
 class MockWebSocket extends EventEmitter {
     readyState = WS_READY_STATE.OPEN;
     send = vi.fn();
     close = vi.fn();
     terminate = vi.fn();
 }
-const { storeListeners, mockGetByProjectId, mockSendBadRequest } = vi.hoisted(() => ({
+const { storeListeners, mockGetByProjectId, mockGetCachedReviewCount, mockRefreshReviewCountIfStale, mockWaitForInProgress, } = vi.hoisted(() => ({
     storeListeners: new Map(),
     mockGetByProjectId: vi.fn(() => []),
-    mockSendBadRequest: vi.fn(),
+    mockGetCachedReviewCount: vi.fn(() => 5),
+    mockRefreshReviewCountIfStale: vi.fn(),
+    mockWaitForInProgress: vi.fn(() => Promise.resolve()),
 }));
-vi.mock('@/backend/services/workspace-snapshot-store.service', () => {
-    const { EventEmitter } = require('node:events');
-    const emitter = new EventEmitter();
-    const originalOn = emitter.on.bind(emitter);
-    return {
-        SNAPSHOT_CHANGED: 'snapshot_changed',
-        SNAPSHOT_REMOVED: 'snapshot_removed',
-        workspaceSnapshotStore: {
-            getByProjectId: mockGetByProjectId,
-            on: vi.fn((event, listener) => {
-                storeListeners.set(event, listener);
-                originalOn(event, listener);
-                return emitter;
-            }),
-        },
-    };
-});
-vi.mock('./upgrade-utils', () => ({
-    getOrCreateConnectionSet: vi.fn((map, key) => {
-        const existing = map.get(key);
-        if (existing) {
-            return existing;
-        }
-        const created = new Set();
-        map.set(key, created);
-        return created;
+const snapshotStoreEmitter = new EventEmitter();
+const workspaceSnapshotStore = {
+    getByProjectId: mockGetByProjectId,
+    on: vi.fn((event, listener) => {
+        storeListeners.set(event, listener);
+        snapshotStoreEmitter.on(event, listener);
+        return snapshotStoreEmitter;
     }),
-    markWebSocketAlive: vi.fn(),
-    sendBadRequest: mockSendBadRequest,
-    validateWebSocketOrigin: vi.fn(() => true),
-}));
-vi.mock('@/backend/app-context', () => ({
-    createAppContext: vi.fn(() => ({
+    off: vi.fn((event, listener) => {
+        snapshotStoreEmitter.off(event, listener);
+        return snapshotStoreEmitter;
+    }),
+};
+function createAppContextMock(overrides = {}) {
+    const application = {
         services: {
             createLogger: vi.fn(() => ({
                 debug: vi.fn(),
@@ -58,32 +42,32 @@ vi.mock('@/backend/app-context', () => ({
             configService: {
                 getCorsConfig: vi.fn(() => ({ allowedOrigins: [allowedOrigin] })),
             },
+            workspaceQueryService: overrides.workspaceQueryService ?? {
+                getCachedReviewCount: mockGetCachedReviewCount,
+                refreshReviewCountIfStale: mockRefreshReviewCountIfStale,
+            },
+            workspaceSnapshotStore: overrides.workspaceSnapshotStore ?? workspaceSnapshotStore,
         },
-    })),
-}));
-function createAppContextMock() {
-    return {
-        services: {
-            createLogger: vi.fn(() => ({
-                debug: vi.fn(),
-                info: vi.fn(),
-                warn: vi.fn(),
-                error: vi.fn(),
-            })),
-            configService: {
-                getCorsConfig: vi.fn(() => ({ allowedOrigins: [allowedOrigin] })),
+        lifecycle: {
+            snapshotReconciliation: {
+                waitForInProgress: mockWaitForInProgress,
             },
         },
     };
+    testApplications.add(application);
+    return application;
 }
 function createWssMock(ws) {
     return {
         handleUpgrade: vi.fn((_request, _socket, _head, callback) => callback(ws)),
     };
 }
-function callHandler(handler, ws, projectId) {
+function callHandler(handler, ws, projectId, requestOverrides = {}) {
     const wss = createWssMock(ws);
-    const request = { headers: { origin: allowedOrigin } };
+    const request = {
+        headers: { origin: requestOverrides.origin ?? allowedOrigin },
+        socket: { remoteAddress: requestOverrides.remoteAddress ?? '127.0.0.1' },
+    };
     const socket = { write: vi.fn(), destroy: vi.fn() };
     const wsAliveMap = new WeakMap();
     const urlStr = projectId
@@ -93,14 +77,24 @@ function callHandler(handler, ws, projectId) {
     handler(request, socket, Buffer.alloc(0), url, wss, wsAliveMap);
     return { wss, socket, wsAliveMap };
 }
+async function waitForInitialSnapshot(ws) {
+    await vi.waitFor(() => {
+        expect(ws.send).toHaveBeenCalled();
+    });
+}
 describe('createSnapshotsUpgradeHandler', () => {
+    beforeEach(() => {
+        mockGetCachedReviewCount.mockReturnValue(5);
+    });
     afterEach(() => {
-        snapshotConnections.clear();
-        resetSnapshotsHandlerStateForTests();
+        for (const application of testApplications) {
+            disposeSnapshotsHandlerState(application);
+        }
+        testApplications.clear();
         storeListeners.clear();
-        vi.mocked(validateWebSocketOrigin).mockReturnValue(true);
+        mockWaitForInProgress.mockImplementation(() => Promise.resolve());
     });
-    it('sends full snapshot on connect', () => {
+    it('sends full snapshot with review count on connect', async () => {
         const visibleEntry = {
             workspaceId: 'ws-1',
             projectId: 'proj-1',
@@ -116,35 +110,82 @@ describe('createSnapshotsUpgradeHandler', () => {
         const handler = createSnapshotsUpgradeHandler(createAppContextMock());
         const ws = new MockWebSocket();
         callHandler(handler, ws, 'proj-1');
-        expect(ws.send).toHaveBeenCalledWith(JSON.stringify({
-            type: 'snapshot_full',
-            projectId: 'proj-1',
-            entries: [visibleEntry],
-        }));
+        await vi.waitFor(() => {
+            expect(ws.send).toHaveBeenCalledWith(JSON.stringify({
+                type: 'snapshot_full',
+                projectId: 'proj-1',
+                entries: [visibleEntry],
+                reviewCount: 5,
+            }));
+        });
+        expect(mockRefreshReviewCountIfStale).toHaveBeenCalled();
+    });
+    it('omits review count from full snapshot when cache is not populated', async () => {
+        mockGetCachedReviewCount.mockReturnValue(undefined);
+        mockGetByProjectId.mockReturnValue([
+            {
+                workspaceId: 'ws-1',
+                projectId: 'proj-1',
+                name: 'Visible',
+                status: 'READY',
+            },
+        ]);
+        const handler = createSnapshotsUpgradeHandler(createAppContextMock());
+        const ws = new MockWebSocket();
+        callHandler(handler, ws, 'proj-1');
+        await vi.waitFor(() => {
+            expect(ws.send).toHaveBeenCalledWith(JSON.stringify({
+                type: 'snapshot_full',
+                projectId: 'proj-1',
+                entries: [
+                    {
+                        workspaceId: 'ws-1',
+                        projectId: 'proj-1',
+                        name: 'Visible',
+                        status: 'READY',
+                    },
+                ],
+            }));
+        });
+        expect(mockRefreshReviewCountIfStale).toHaveBeenCalled();
     });
     it('rejects connection without projectId', () => {
         const handler = createSnapshotsUpgradeHandler(createAppContextMock());
         const ws = new MockWebSocket();
         const { socket } = callHandler(handler, ws);
-        expect(mockSendBadRequest).toHaveBeenCalledWith(socket);
+        expect(socket.write).toHaveBeenCalledWith(expect.stringContaining('400 Bad Request'));
         expect(ws.send).not.toHaveBeenCalled();
     });
     it('rejects unauthorized origins before subscription setup and projectId checks', () => {
-        vi.mocked(validateWebSocketOrigin).mockReturnValueOnce(false);
         const handler = createSnapshotsUpgradeHandler(createAppContextMock());
         const ws = new MockWebSocket();
-        const { wss } = callHandler(handler, ws);
+        const { wss, socket } = callHandler(handler, ws, undefined, {
+            origin: 'https://attacker.example',
+        });
         expect(storeListeners.size).toBe(0);
-        expect(mockSendBadRequest).not.toHaveBeenCalled();
+        expect(socket.write).toHaveBeenCalledWith(expect.stringContaining('Unauthorized origin'));
         expect(wss.handleUpgrade).not.toHaveBeenCalled();
         expect(ws.send).not.toHaveBeenCalled();
     });
-    it('routes snapshot_changed to correct project clients', () => {
+    it('rejects untrusted local requests before subscription setup', () => {
+        const handler = createSnapshotsUpgradeHandler(createAppContextMock());
+        const ws = new MockWebSocket();
+        const { wss, socket } = callHandler(handler, ws, 'proj-1', {
+            remoteAddress: '203.0.113.10',
+        });
+        expect(storeListeners.size).toBe(0);
+        expect(socket.write).toHaveBeenCalledWith(expect.stringContaining('403 Forbidden'));
+        expect(wss.handleUpgrade).not.toHaveBeenCalled();
+        expect(ws.send).not.toHaveBeenCalled();
+    });
+    it('routes snapshot_changed with review count to correct project clients', async () => {
         const handler = createSnapshotsUpgradeHandler(createAppContextMock());
         const wsA = new MockWebSocket();
         const wsB = new MockWebSocket();
         callHandler(handler, wsA, 'proj-A');
         callHandler(handler, wsB, 'proj-B');
+        await waitForInitialSnapshot(wsA);
+        await waitForInitialSnapshot(wsB);
         wsA.send.mockClear();
         wsB.send.mockClear();
         const changedListener = storeListeners.get('snapshot_changed');
@@ -159,18 +200,117 @@ describe('createSnapshotsUpgradeHandler', () => {
                 status: 'READY',
             },
         };
-        changedListener(event);
+        await changedListener(event);
         expect(wsA.send).toHaveBeenCalledWith(JSON.stringify({
             type: 'snapshot_changed',
             workspaceId: 'ws-1',
             entry: event.entry,
+            reviewCount: 5,
         }));
         expect(wsB.send).not.toHaveBeenCalled();
+        expect(mockRefreshReviewCountIfStale).toHaveBeenCalled();
+    });
+    it('keeps snapshot delta dependencies scoped to each application', async () => {
+        const listenersA = new Map();
+        const listenersB = new Map();
+        const createStore = (listeners) => ({
+            getByProjectId: vi.fn(() => [
+                {
+                    workspaceId: 'baseline',
+                    projectId: 'project',
+                    name: 'Baseline',
+                    status: 'READY',
+                },
+            ]),
+            on: vi.fn((event, listener) => {
+                listeners.set(event, listener);
+            }),
+            off: vi.fn(),
+        });
+        const queryA = {
+            getCachedReviewCount: vi.fn(() => 11),
+            refreshReviewCountIfStale: vi.fn(),
+        };
+        const queryB = {
+            getCachedReviewCount: vi.fn(() => 22),
+            refreshReviewCountIfStale: vi.fn(),
+        };
+        const handlerA = createSnapshotsUpgradeHandler(createAppContextMock({
+            workspaceQueryService: queryA,
+            workspaceSnapshotStore: createStore(listenersA),
+        }));
+        const handlerB = createSnapshotsUpgradeHandler(createAppContextMock({
+            workspaceQueryService: queryB,
+            workspaceSnapshotStore: createStore(listenersB),
+        }));
+        const wsA = new MockWebSocket();
+        const wsB = new MockWebSocket();
+        callHandler(handlerA, wsA, 'project-a');
+        callHandler(handlerB, wsB, 'project-b');
+        await waitForInitialSnapshot(wsA);
+        await waitForInitialSnapshot(wsB);
+        wsA.send.mockClear();
+        wsB.send.mockClear();
+        queryA.getCachedReviewCount.mockClear();
+        queryB.getCachedReviewCount.mockClear();
+        const changedListenerB = listenersB.get('snapshot_changed');
+        expect(changedListenerB).toBeDefined();
+        await changedListenerB({
+            workspaceId: 'workspace-b',
+            projectId: 'project-b',
+            entry: {
+                workspaceId: 'workspace-b',
+                projectId: 'project-b',
+                name: 'B',
+                status: 'READY',
+            },
+        });
+        expect(wsB.send).toHaveBeenCalledWith(JSON.stringify({
+            type: 'snapshot_changed',
+            workspaceId: 'workspace-b',
+            entry: {
+                workspaceId: 'workspace-b',
+                projectId: 'project-b',
+                name: 'B',
+                status: 'READY',
+            },
+            reviewCount: 22,
+        }));
+        expect(wsA.send).not.toHaveBeenCalled();
+        expect(queryA.getCachedReviewCount).not.toHaveBeenCalled();
     });
-    it('routes ARCHIVING snapshot_changed as snapshot_removed', () => {
+    it('omits review count from snapshot_changed when cache is not populated', async () => {
+        mockGetCachedReviewCount.mockReturnValue(undefined);
         const handler = createSnapshotsUpgradeHandler(createAppContextMock());
         const ws = new MockWebSocket();
         callHandler(handler, ws, 'proj-1');
+        await waitForInitialSnapshot(ws);
+        ws.send.mockClear();
+        const changedListener = storeListeners.get('snapshot_changed');
+        expect(changedListener).toBeDefined();
+        const event = {
+            workspaceId: 'ws-1',
+            projectId: 'proj-1',
+            entry: {
+                workspaceId: 'ws-1',
+                projectId: 'proj-1',
+                name: 'Updated',
+                status: 'READY',
+            },
+        };
+        await changedListener(event);
+        expect(ws.send).toHaveBeenCalledWith(JSON.stringify({
+            type: 'snapshot_changed',
+            workspaceId: 'ws-1',
+            entry: event.entry,
+        }));
+        expect(mockRefreshReviewCountIfStale).toHaveBeenCalled();
+    });
+    it('routes ARCHIVING snapshot_changed as snapshot_removed with review count', async () => {
+        const handler = createSnapshotsUpgradeHandler(createAppContextMock());
+        const ws = new MockWebSocket();
+        callHandler(handler, ws, 'proj-1');
+        await waitForInitialSnapshot(ws);
         ws.send.mockClear();
         const changedListener = storeListeners.get('snapshot_changed');
         expect(changedListener).toBeDefined();
@@ -184,16 +324,18 @@ describe('createSnapshotsUpgradeHandler', () => {
                 status: 'ARCHIVING',
             },
         };
-        changedListener(event);
+        await changedListener(event);
         expect(ws.send).toHaveBeenCalledWith(JSON.stringify({
             type: 'snapshot_removed',
             workspaceId: 'ws-1',
+            reviewCount: 5,
         }));
     });
-    it('sends snapshot_removed to project clients', () => {
+    it('sends snapshot_removed with review count to project clients', async () => {
         const handler = createSnapshotsUpgradeHandler(createAppContextMock());
         const ws = new MockWebSocket();
         callHandler(handler, ws, 'proj-1');
+        await waitForInitialSnapshot(ws);
         ws.send.mockClear();
         const removedListener = storeListeners.get('snapshot_removed');
         expect(removedListener).toBeDefined();
@@ -201,44 +343,209 @@ describe('createSnapshotsUpgradeHandler', () => {
             workspaceId: 'ws-1',
             projectId: 'proj-1',
         };
-        removedListener(event);
+        await removedListener(event);
         expect(ws.send).toHaveBeenCalledWith(JSON.stringify({
             type: 'snapshot_removed',
             workspaceId: 'ws-1',
+            reviewCount: 5,
+        }));
+    });
+    it('buffers deltas emitted before snapshot_full and flushes them after it', async () => {
+        let resolveWait;
+        mockWaitForInProgress.mockReturnValueOnce(new Promise((resolve) => {
+            resolveWait = resolve;
+        }));
+        mockGetByProjectId.mockReturnValue([]);
+        const handler = createSnapshotsUpgradeHandler(createAppContextMock());
+        const ws = new MockWebSocket();
+        callHandler(handler, ws, 'proj-1');
+        const changedListener = storeListeners.get('snapshot_changed');
+        expect(changedListener).toBeDefined();
+        const event = {
+            workspaceId: 'ws-1',
+            projectId: 'proj-1',
+            entry: {
+                workspaceId: 'ws-1',
+                projectId: 'proj-1',
+                name: 'Early',
+                status: 'READY',
+            },
+        };
+        await changedListener(event);
+        expect(ws.send).not.toHaveBeenCalled();
+        resolveWait?.();
+        await vi.waitFor(() => {
+            expect(ws.send).toHaveBeenCalledTimes(2);
+        });
+        expect(ws.send.mock.calls[0]?.[0]).toContain('"type":"snapshot_full"');
+        expect(ws.send.mock.calls[1]?.[0]).toBe(JSON.stringify({
+            type: 'snapshot_changed',
+            workspaceId: 'ws-1',
+            entry: event.entry,
         }));
     });
-    it('does not send to non-OPEN sockets', () => {
+    it('keeps buffering deltas when the snapshot_full send fails', async () => {
+        mockGetByProjectId.mockReturnValue([
+            {
+                workspaceId: 'ws-1',
+                projectId: 'proj-1',
+                name: 'Visible',
+                status: 'READY',
+            },
+        ]);
+        const handler = createSnapshotsUpgradeHandler(createAppContextMock());
+        const ws = new MockWebSocket();
+        ws.send.mockImplementation(() => {
+            throw new Error('socket closing');
+        });
+        callHandler(handler, ws, 'proj-1');
+        await vi.waitFor(() => {
+            expect(ws.send).toHaveBeenCalledTimes(1);
+        });
+        const changedListener = storeListeners.get('snapshot_changed');
+        expect(changedListener).toBeDefined();
+        await changedListener({
+            workspaceId: 'ws-1',
+            projectId: 'proj-1',
+            entry: {
+                workspaceId: 'ws-1',
+                projectId: 'proj-1',
+                name: 'Updated',
+                status: 'READY',
+            },
+        });
+        expect(ws.send).toHaveBeenCalledTimes(1);
+    });
+    it('does not send to non-OPEN sockets', async () => {
         const handler = createSnapshotsUpgradeHandler(createAppContextMock());
         const ws = new MockWebSocket();
         callHandler(handler, ws, 'proj-1');
+        await waitForInitialSnapshot(ws);
         ws.send.mockClear();
         ws.readyState = WS_READY_STATE.CLOSED;
         const changedListener = storeListeners.get('snapshot_changed');
-        changedListener({
+        await changedListener({
             workspaceId: 'ws-1',
             projectId: 'proj-1',
             entry: { workspaceId: 'ws-1', status: 'READY' },
         });
         expect(ws.send).not.toHaveBeenCalled();
     });
-    it('cleans up connection set on close', () => {
+    it('continues snapshot_changed fan-out when one client send throws', async () => {
+        const handler = createSnapshotsUpgradeHandler(createAppContextMock());
+        const throwingWs = new MockWebSocket();
+        const healthyWs = new MockWebSocket();
+        callHandler(handler, throwingWs, 'proj-1');
+        callHandler(handler, healthyWs, 'proj-1');
+        await waitForInitialSnapshot(throwingWs);
+        await waitForInitialSnapshot(healthyWs);
+        throwingWs.send.mockClear();
+        healthyWs.send.mockClear();
+        throwingWs.send.mockImplementation(() => {
+            throw new Error('socket closing');
+        });
+        const changedListener = storeListeners.get('snapshot_changed');
+        expect(changedListener).toBeDefined();
+        const event = {
+            workspaceId: 'ws-1',
+            projectId: 'proj-1',
+            entry: {
+                workspaceId: 'ws-1',
+                projectId: 'proj-1',
+                name: 'Updated',
+                status: 'READY',
+            },
+        };
+        expect(() => changedListener(event)).not.toThrow();
+        expect(healthyWs.send).toHaveBeenCalledWith(JSON.stringify({
+            type: 'snapshot_changed',
+            workspaceId: 'ws-1',
+            entry: event.entry,
+            reviewCount: 5,
+        }));
+    });
+    it('continues snapshot_removed fan-out when one client send throws', async () => {
+        const handler = createSnapshotsUpgradeHandler(createAppContextMock());
+        const throwingWs = new MockWebSocket();
+        const healthyWs = new MockWebSocket();
+        callHandler(handler, throwingWs, 'proj-1');
+        callHandler(handler, healthyWs, 'proj-1');
+        await waitForInitialSnapshot(throwingWs);
+        await waitForInitialSnapshot(healthyWs);
+        throwingWs.send.mockClear();
+        healthyWs.send.mockClear();
+        throwingWs.send.mockImplementation(() => {
+            throw new Error('socket closing');
+        });
+        const removedListener = storeListeners.get('snapshot_removed');
+        expect(removedListener).toBeDefined();
+        const event = {
+            workspaceId: 'ws-1',
+            projectId: 'proj-1',
+        };
+        expect(() => removedListener(event)).not.toThrow();
+        expect(healthyWs.send).toHaveBeenCalledWith(JSON.stringify({
+            type: 'snapshot_removed',
+            workspaceId: 'ws-1',
+            reviewCount: 5,
+        }));
+    });
+    it('does not throw out of the upgrade callback when the initial snapshot send throws', () => {
+        mockGetByProjectId.mockReturnValue([
+            {
+                workspaceId: 'ws-1',
+                projectId: 'proj-1',
+                name: 'Visible',
+                status: 'READY',
+            },
+        ]);
         const handler = createSnapshotsUpgradeHandler(createAppContextMock());
         const ws = new MockWebSocket();
+        ws.send.mockImplementation(() => {
+            throw new Error('socket closing');
+        });
+        expect(() => callHandler(handler, ws, 'proj-1')).not.toThrow();
+        expect(ws.send).toHaveBeenCalled();
+    });
+    it('cleans up connection set on close', () => {
+        const application = createAppContextMock();
+        const handler = createSnapshotsUpgradeHandler(application);
+        const connections = getSnapshotConnectionsForApplication(application);
+        const ws = new MockWebSocket();
         callHandler(handler, ws, 'proj-1');
-        expect(snapshotConnections.get('proj-1')?.has(ws)).toBe(true);
+        expect(connections?.subscribers('proj-1').has(ws)).toBe(true);
         ws.emit('close');
-        expect(snapshotConnections.has('proj-1')).toBe(false);
+        expect(connections?.hasSubscribers('proj-1')).toBe(false);
     });
     it('retains project entry when other connections remain after close', () => {
-        const handler = createSnapshotsUpgradeHandler(createAppContextMock());
+        const application = createAppContextMock();
+        const handler = createSnapshotsUpgradeHandler(application);
+        const connections = getSnapshotConnectionsForApplication(application);
         const ws1 = new MockWebSocket();
         const ws2 = new MockWebSocket();
         callHandler(handler, ws1, 'proj-1');
         callHandler(handler, ws2, 'proj-1');
-        expect(snapshotConnections.get('proj-1')?.size).toBe(2);
+        expect(connections?.subscriberCount('proj-1')).toBe(2);
         ws1.emit('close');
-        expect(snapshotConnections.get('proj-1')?.size).toBe(1);
-        expect(snapshotConnections.get('proj-1')?.has(ws2)).toBe(true);
+        expect(connections?.subscriberCount('proj-1')).toBe(1);
+        expect(connections?.subscribers('proj-1').has(ws2)).toBe(true);
+    });
+    it('disposes store listeners and per-application connection state idempotently', () => {
+        const application = createAppContextMock();
+        const handler = createSnapshotsUpgradeHandler(application);
+        callHandler(handler, new MockWebSocket(), 'proj-1');
+        expect(snapshotStoreEmitter.listenerCount('snapshot_changed')).toBe(1);
+        expect(snapshotStoreEmitter.listenerCount('snapshot_removed')).toBe(1);
+        expect(getSnapshotConnectionsForApplication(application)).toBeDefined();
+        disposeSnapshotsHandlerState(application);
+        disposeSnapshotsHandlerState(application);
+        expect(snapshotStoreEmitter.listenerCount('snapshot_changed')).toBe(0);
+        expect(snapshotStoreEmitter.listenerCount('snapshot_removed')).toBe(0);
+        expect(getSnapshotConnectionsForApplication(application)).toBeUndefined();
+        const restartedHandler = createSnapshotsUpgradeHandler(application);
+        callHandler(restartedHandler, new MockWebSocket(), 'proj-1');
+        expect(snapshotStoreEmitter.listenerCount('snapshot_changed')).toBe(1);
+        expect(snapshotStoreEmitter.listenerCount('snapshot_removed')).toBe(1);
     });
 });
 //# sourceMappingURL=snapshots.handler.test.js.map