@hubspot/cli 7.6.0-beta.1 → 7.6.0-beta.11

package/lib/projects/__tests__/LocalDevProcess.test.js

@@ -0,0 +1,254 @@
+import path from 'path';
+import { translateForLocalDev } from '@hubspot/project-parsing-lib';
+import { handleProjectUpload } from '../upload.js';
+import { getProjectConfig } from '../config.js';
+import LocalDevProcess from '../localDev/LocalDevProcess.js';
+import LocalDevLogger from '../localDev/LocalDevLogger.js';
+import DevServerManagerV2 from '../localDev/DevServerManagerV2.js';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { vi } from 'vitest';
+// Mock @hubspot/ui-extensions-dev-server
+vi.mock('@hubspot/ui-extensions-dev-server', () => ({
+    DevModeUnifiedInterface: {
+        setup: vi.fn().mockResolvedValue(undefined),
+        start: vi.fn().mockResolvedValue(undefined),
+        fileChange: vi.fn().mockResolvedValue(undefined),
+        cleanup: vi.fn().mockResolvedValue(undefined),
+    },
+}));
+vi.mock('open');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('../upload');
+vi.mock('../config');
+vi.mock('../localDev/LocalDevLogger');
+vi.mock('../localDev/DevServerManagerV2');
+// Tests for LocalDevProcess and LocalDevState
+describe('LocalDevProcess', () => {
+    let mockLocalDevLogger;
+    let mockDevServerManager;
+    let process;
+    const mockProjectConfig = {
+        name: 'test-project',
+        srcDir: 'src',
+        platformVersion: '1.0.0',
+    };
+    const mockOptions = {
+        projectDir: '/test/project',
+        projectConfig: mockProjectConfig,
+        targetProjectAccountId: 123,
+        targetTestingAccountId: 456,
+        projectId: 789,
+        initialProjectNodes: {},
+        env: ENVIRONMENTS.PROD,
+        projectName: 'test-project',
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockLocalDevLogger = {
+            resetSpinnies: vi.fn(),
+            devServerSetupError: vi.fn(),
+            devServerStartError: vi.fn(),
+            devServerCleanupError: vi.fn(),
+            missingComponentsWarning: vi.fn(),
+            startupMessage: vi.fn(),
+            monitorConsoleOutput: vi.fn(),
+            cleanupStart: vi.fn(),
+            cleanupError: vi.fn(),
+            cleanupSuccess: vi.fn(),
+            uploadInitiated: vi.fn(),
+            projectConfigMismatch: vi.fn(),
+            uploadError: vi.fn(),
+            uploadSuccess: vi.fn(),
+            fileChangeError: vi.fn(),
+            uploadWarning: vi.fn(),
+        };
+        mockDevServerManager = {
+            setup: vi.fn().mockResolvedValue(undefined),
+            start: vi.fn().mockResolvedValue(undefined),
+            cleanup: vi.fn().mockResolvedValue(undefined),
+            fileChange: vi.fn().mockResolvedValue(undefined),
+        };
+        // Mock constructors
+        LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
+        DevServerManagerV2.mockImplementation(() => mockDevServerManager);
+        // Create process instance
+        process = new LocalDevProcess(mockOptions);
+        // Mock process.exit
+        vi.spyOn(global.process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process.exit called with code ${code}`);
+        });
+    });
+    describe('start()', () => {
+        it('should exit if dev server setup fails', async () => {
+            mockDevServerManager.setup.mockRejectedValue(new Error('Setup failed'));
+            await expect(process.start()).rejects.toThrow('Process.exit called with code 1');
+            expect(mockLocalDevLogger.devServerSetupError).toHaveBeenCalled();
+        });
+        it('should start successfully and compare project nodes', async () => {
+            await process.start();
+            expect(mockLocalDevLogger.startupMessage).toHaveBeenCalled();
+            expect(mockDevServerManager.start).toHaveBeenCalled();
+            expect(mockLocalDevLogger.monitorConsoleOutput).toHaveBeenCalled();
+            expect(mockLocalDevLogger.missingComponentsWarning).not.toHaveBeenCalled();
+        });
+    });
+    describe('stop()', () => {
+        it('should exit with error if cleanup fails', async () => {
+            mockDevServerManager.cleanup.mockRejectedValue(new Error('Cleanup failed'));
+            await expect(process.stop()).rejects.toThrow('Process.exit called with code 1');
+            expect(mockLocalDevLogger.cleanupError).toHaveBeenCalled();
+        });
+        it('should exit successfully after cleanup', async () => {
+            await expect(process.stop()).rejects.toThrow('Process.exit called with code 0');
+            expect(mockLocalDevLogger.cleanupSuccess).toHaveBeenCalled();
+        });
+        it('should not show progress messages when showProgress is false', async () => {
+            await expect(process.stop(false)).rejects.toThrow('Process.exit called with code 0');
+            expect(mockLocalDevLogger.cleanupStart).not.toHaveBeenCalled();
+            expect(mockLocalDevLogger.cleanupSuccess).not.toHaveBeenCalled();
+        });
+    });
+    describe('updateProjectNodes()', () => {
+        it('should update project nodes with translated representation', async () => {
+            const mockNodes = { node1: { uid: 'node1' } };
+            translateForLocalDev.mockResolvedValue({
+                intermediateNodesIndexedByUid: mockNodes,
+            });
+            // @ts-expect-error testing private method
+            await process.updateProjectNodes();
+            expect(translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
+                platformVersion: mockOptions.projectConfig.platformVersion,
+                accountId: mockOptions.targetProjectAccountId,
+            }, { projectNodesAtLastUpload: {} });
+            expect(process.projectNodes).toEqual(mockNodes);
+        });
+    });
+    describe('uploadProject()', () => {
+        it('should not upload if project config is invalid', async () => {
+            getProjectConfig.mockResolvedValue({
+                projectConfig: null,
+            });
+            await process.uploadProject();
+            expect(mockLocalDevLogger.projectConfigMismatch).toHaveBeenCalled();
+            expect(handleProjectUpload).not.toHaveBeenCalled();
+        });
+        it('should handle upload error', async () => {
+            getProjectConfig.mockResolvedValue({
+                projectConfig: mockOptions.projectConfig,
+            });
+            handleProjectUpload.mockResolvedValue({
+                uploadError: new Error('Upload failed'),
+            });
+            const success = await process.uploadProject();
+            expect(mockLocalDevLogger.uploadError).toHaveBeenCalledWith(new Error('Upload failed'));
+            expect(success).toBe(false);
+        });
+        it('should handle successful upload', async () => {
+            await process.handleConfigFileChange();
+            getProjectConfig.mockResolvedValue({
+                projectConfig: mockOptions.projectConfig,
+            });
+            handleProjectUpload.mockResolvedValue({
+                uploadError: null,
+            });
+            const success = await process.uploadProject();
+            expect(mockLocalDevLogger.uploadSuccess).toHaveBeenCalled();
+            // @ts-expect-error accessing private property for testing
+            expect(process.state.uploadWarnings.size).toBe(0);
+            expect(success).toBe(true);
+        });
+        it('should reset projectNodesAtLastUpload', async () => {
+            const mockNodes = { node1: { uid: 'node1' } };
+            const initialProjectNodes = { existingNode: { uid: 'existingNode' } };
+            // @ts-expect-error accessing private property for testing
+            process.state._projectNodesAtLastUpload = initialProjectNodes;
+            getProjectConfig.mockResolvedValue({
+                projectConfig: mockOptions.projectConfig,
+            });
+            handleProjectUpload.mockResolvedValue({
+                uploadError: null,
+            });
+            translateForLocalDev.mockResolvedValue({
+                intermediateNodesIndexedByUid: mockNodes,
+            });
+            const success = await process.uploadProject();
+            // Verify translateForLocalDev was called without projectNodesAtLastUpload option
+            expect(translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
+                platformVersion: mockOptions.projectConfig.platformVersion,
+                accountId: mockOptions.targetProjectAccountId,
+            }, { projectNodesAtLastUpload: undefined });
+            // Verify projectNodesAtLastUpload was reset to the new nodes
+            // @ts-expect-error accessing private property for testing
+            expect(process.state.projectNodesAtLastUpload).toEqual(mockNodes);
+            expect(success).toBe(true);
+        });
+    });
+    describe('handleFileChange()', () => {
+        it('should handle file change successfully', async () => {
+            const filePath = 'test/file.js';
+            const event = 'change';
+            await process.handleFileChange(filePath, event);
+            expect(mockDevServerManager.fileChange).toHaveBeenCalledWith({
+                filePath,
+                event,
+            });
+        });
+        it('should log error if file change fails', async () => {
+            const error = new Error('File change failed');
+            mockDevServerManager.fileChange.mockImplementation(() => {
+                throw error;
+            });
+            await process.handleFileChange('test/file.js', 'change');
+            expect(mockLocalDevLogger.fileChangeError).toHaveBeenCalledWith(error);
+        });
+    });
+    describe('handleConfigFileChange()', () => {
+        beforeEach(() => {
+            translateForLocalDev.mockResolvedValue({
+                intermediateNodesIndexedByUid: {},
+            });
+        });
+        it('should update project nodes and show upload warning', async () => {
+            await process.handleConfigFileChange();
+            expect(translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
+                platformVersion: mockOptions.projectConfig.platformVersion,
+                accountId: mockOptions.targetProjectAccountId,
+            }, { projectNodesAtLastUpload: {} });
+            expect(mockLocalDevLogger.uploadWarning).toHaveBeenCalled();
+        });
+    });
+    describe('addStateListener()', () => {
+        it('should add state listener', () => {
+            const listener = vi.fn();
+            const key = 'projectNodes';
+            process.addStateListener(key, listener);
+            // @ts-expect-error
+            process.state.projectNodes = {};
+            expect(listener).toHaveBeenCalled();
+        });
+        it('should call listener immediately', () => {
+            const listener = vi.fn();
+            const key = 'projectNodes';
+            process.addStateListener(key, listener);
+            expect(listener).toHaveBeenCalledWith(process.projectNodes);
+        });
+    });
+    describe('removeStateListener()', () => {
+        it('should remove state listener', () => {
+            const listener = vi.fn();
+            const key = 'projectNodes';
+            // Add the listener first
+            process.addStateListener(key, listener);
+            expect(listener).toHaveBeenCalledTimes(1);
+            // Remove the listener
+            process.removeStateListener(key, listener);
+            // Trigger state change again to verify listener is no longer called
+            // @ts-expect-error
+            process.state.projectNodes = { newNode: { uid: 'newNode' } };
+            expect(listener).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/lib/projects/__tests__/LocalDevWebsocketServer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/projects/__tests__/LocalDevWebsocketServer.test.js

@@ -0,0 +1,339 @@
+import { WebSocketServer } from 'ws';
+import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
+import LocalDevWebsocketServer from '../localDev/LocalDevWebsocketServer.js';
+import { lib } from '../../../lang/en.js';
+vi.mock('ws');
+vi.mock('@hubspot/local-dev-lib/portManager');
+vi.mock('@hubspot/local-dev-lib/logger');
+describe('LocalDevWebsocketServer', () => {
+    let mockLocalDevProcess;
+    let mockWebSocket;
+    let mockWebSocketServer;
+    let server;
+    beforeEach(() => {
+        // Reset all mocks
+        vi.clearAllMocks();
+        // Setup mock WebSocket
+        mockWebSocket = {
+            on: vi.fn(),
+            send: vi.fn(),
+            close: vi.fn(),
+        };
+        // Setup mock WebSocketServer
+        mockWebSocketServer = {
+            on: vi.fn(),
+            close: vi.fn(),
+        };
+        // Setup mock LocalDevProcess
+        mockLocalDevProcess = {
+            addStateListener: vi.fn(),
+            removeStateListener: vi.fn(),
+            uploadProject: vi.fn(),
+            sendDevServerMessage: vi.fn(),
+        };
+        // Mock WebSocketServer constructor
+        WebSocketServer.mockImplementation(() => mockWebSocketServer);
+        // Create server instance
+        server = new LocalDevWebsocketServer(mockLocalDevProcess, true);
+    });
+    describe('start()', () => {
+        it('should throw error if port manager is not running', async () => {
+            isPortManagerServerRunning.mockResolvedValue(false);
+            await expect(server.start()).rejects.toThrow();
+        });
+        it('should start websocket server successfully', async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                'local-dev-ui-websocket-server': 1234,
+            });
+            await server.start();
+            expect(WebSocketServer).toHaveBeenCalledWith({ port: 1234 });
+            expect(mockWebSocketServer.on).toHaveBeenCalledWith('connection', expect.any(Function));
+            expect(logger.log).toHaveBeenCalled();
+        });
+        it('should accept connection from valid origin', async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                'local-dev-ui-websocket-server': 1234,
+            });
+            await server.start();
+            // Get the connection callback
+            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
+            // Simulate connection from valid origin
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            expect(mockWebSocket.on).toHaveBeenCalledWith('message', expect.any(Function));
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function));
+            expect(mockWebSocket.close).not.toHaveBeenCalled();
+        });
+        it('should reject connection from invalid origin', async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                'local-dev-ui-websocket-server': 1234,
+            });
+            await server.start();
+            // Get the connection callback
+            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
+            // Simulate connection from invalid origin
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://malicious-site.com' },
+            });
+            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed('https://malicious-site.com'));
+            expect(mockWebSocket.on).not.toHaveBeenCalled();
+            expect(mockLocalDevProcess.addStateListener).not.toHaveBeenCalled();
+        });
+        it('should reject connection with no origin header', async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                'local-dev-ui-websocket-server': 1234,
+            });
+            await server.start();
+            // Get the connection callback
+            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
+            // Simulate connection with no origin header
+            connectionCallback(mockWebSocket, {
+                headers: {},
+            });
+            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed());
+            expect(mockWebSocket.on).not.toHaveBeenCalled();
+            expect(mockLocalDevProcess.addStateListener).not.toHaveBeenCalled();
+        });
+        it('should send WEBSOCKET_SERVER_CONNECTED message when valid connection is established', async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                'local-dev-ui-websocket-server': 1234,
+            });
+            await server.start();
+            // Get the connection callback
+            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
+            // Simulate connection from valid origin
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+        });
+    });
+    describe('message handling', () => {
+        beforeEach(async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                'local-dev-ui-websocket-server': 1234,
+            });
+            await server.start();
+            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+        });
+        it('should handle UPLOAD message type', () => {
+            const messageCallback = mockWebSocket.on.mock.calls[0][1];
+            const message = {
+                type: LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD,
+            };
+            messageCallback(JSON.stringify(message));
+            expect(mockLocalDevProcess.uploadProject).toHaveBeenCalled();
+        });
+        it('should log error for missing message type', () => {
+            const messageCallback = mockWebSocket.on.mock.calls[0][1];
+            const message = {};
+            messageCallback(JSON.stringify(message));
+            expect(logger.error).toHaveBeenCalled();
+        });
+        it('should log error for unknown message type', () => {
+            const messageCallback = mockWebSocket.on.mock.calls[0][1];
+            const message = {
+                type: 'UNKNOWN_TYPE',
+            };
+            messageCallback(JSON.stringify(message));
+            expect(logger.error).toHaveBeenCalled();
+        });
+        it('should log error for invalid JSON', () => {
+            const messageCallback = mockWebSocket.on.mock.calls[0][1];
+            const invalidJson = 'invalid json';
+            messageCallback(invalidJson);
+            expect(logger.error).toHaveBeenCalled();
+        });
+    });
+    describe('shutdown()', () => {
+        it('should close the websocket server', async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                'local-dev-ui-websocket-server': 1234,
+            });
+            await server.start();
+            server.shutdown();
+            expect(mockWebSocketServer.close).toHaveBeenCalled();
+        });
+    });
+    describe('multiple connections', () => {
+        let mockWebSocket1;
+        let mockWebSocket2;
+        let mockWebSocket3;
+        let connectionCallback;
+        beforeEach(async () => {
+            // Setup multiple mock WebSockets
+            mockWebSocket1 = {
+                on: vi.fn(),
+                send: vi.fn(),
+                close: vi.fn(),
+            };
+            mockWebSocket2 = {
+                on: vi.fn(),
+                send: vi.fn(),
+                close: vi.fn(),
+            };
+            mockWebSocket3 = {
+                on: vi.fn(),
+                send: vi.fn(),
+                close: vi.fn(),
+            };
+            // Start the server
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                'local-dev-ui-websocket-server': 1234,
+            });
+            await server.start();
+            // Get the connection callback
+            connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
+        });
+        it('should handle multiple valid connections simultaneously', () => {
+            // Establish three connections from valid origins
+            connectionCallback(mockWebSocket1, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            connectionCallback(mockWebSocket2, {
+                headers: { origin: 'https://app.hubspotqa.com' },
+            });
+            connectionCallback(mockWebSocket3, {
+                headers: { origin: 'https://local.hubspot.com' },
+            });
+            // All connections should be established with proper setup
+            expect(mockWebSocket1.on).toHaveBeenCalledWith('message', expect.any(Function));
+            expect(mockWebSocket2.on).toHaveBeenCalledWith('message', expect.any(Function));
+            expect(mockWebSocket3.on).toHaveBeenCalledWith('message', expect.any(Function));
+            // Each connection should trigger state listener setup
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(9); // 3 listeners per connection * 3 connections
+            // Each connection should trigger dev server message
+            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledTimes(3);
+            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+            // No connections should be closed
+            expect(mockWebSocket1.close).not.toHaveBeenCalled();
+            expect(mockWebSocket2.close).not.toHaveBeenCalled();
+            expect(mockWebSocket3.close).not.toHaveBeenCalled();
+        });
+        it('should send project data to each connection independently', () => {
+            // Setup mock project data properties as getters
+            Object.defineProperty(mockLocalDevProcess, 'projectName', {
+                get: () => 'test-project',
+                configurable: true,
+            });
+            Object.defineProperty(mockLocalDevProcess, 'projectId', {
+                get: () => 123,
+                configurable: true,
+            });
+            Object.defineProperty(mockLocalDevProcess, 'targetProjectAccountId', {
+                get: () => 456,
+                configurable: true,
+            });
+            Object.defineProperty(mockLocalDevProcess, 'targetTestingAccountId', {
+                get: () => 789,
+                configurable: true,
+            });
+            // Establish multiple connections
+            connectionCallback(mockWebSocket1, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            connectionCallback(mockWebSocket2, {
+                headers: { origin: 'https://app.hubspotqa.com' },
+            });
+            // Each websocket should receive project data
+            expect(mockWebSocket1.send).toHaveBeenCalledWith(JSON.stringify({
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+                data: {
+                    projectName: 'test-project',
+                    projectId: 123,
+                    targetProjectAccountId: 456,
+                    targetTestingAccountId: 789,
+                },
+            }));
+            expect(mockWebSocket2.send).toHaveBeenCalledWith(JSON.stringify({
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+                data: {
+                    projectName: 'test-project',
+                    projectId: 123,
+                    targetProjectAccountId: 456,
+                    targetTestingAccountId: 789,
+                },
+            }));
+        });
+        it('should properly cleanup listeners when connections close', () => {
+            // Establish connections
+            connectionCallback(mockWebSocket1, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            connectionCallback(mockWebSocket2, {
+                headers: { origin: 'https://app.hubspotqa.com' },
+            });
+            // Get all the close callbacks for both connections (there should be 2 per connection)
+            const closeCallbacks1 = mockWebSocket1.on.mock.calls
+                .filter(call => call[0] === 'close')
+                .map(call => call[1]);
+            const closeCallbacks2 = mockWebSocket2.on.mock.calls
+                .filter(call => call[0] === 'close')
+                .map(call => call[1]);
+            expect(closeCallbacks1).toHaveLength(3); // projectNodes and appData listeners
+            expect(closeCallbacks2).toHaveLength(3); // projectNodes and appData listeners
+            // Simulate first connection closing (call all close callbacks)
+            closeCallbacks1.forEach(callback => callback());
+            // Should have removed listeners for first connection (2 listeners: projectNodes and appData)
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(3);
+            // Simulate second connection closing
+            closeCallbacks2.forEach(callback => callback());
+            // Should have removed listeners for second connection as well
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(6);
+        });
+        it('should broadcast state changes to all connected clients', () => {
+            // Establish connections
+            connectionCallback(mockWebSocket1, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            connectionCallback(mockWebSocket2, {
+                headers: { origin: 'https://app.hubspotqa.com' },
+            });
+            // Get the projectNodes listeners that were registered
+            const projectNodesListeners = mockLocalDevProcess.addStateListener.mock.calls
+                .filter(call => call[0] === 'projectNodes')
+                .map(call => call[1]);
+            expect(projectNodesListeners).toHaveLength(2);
+            // Simulate a project nodes update by calling the listeners
+            const mockProjectNodes = {
+                component1: {
+                    uid: 'component1',
+                    componentType: 'APP',
+                    localDev: {
+                        componentRoot: '/test/path',
+                        componentConfigPath: '/test/path/config.json',
+                        configUpdatedSinceLastUpload: false,
+                    },
+                    componentDeps: {},
+                    metaFilePath: '/test/path',
+                    config: {},
+                    files: [],
+                },
+            };
+            projectNodesListeners.forEach(listener => listener(mockProjectNodes));
+            // Both websockets should receive the update
+            expect(mockWebSocket1.send).toHaveBeenCalledWith(JSON.stringify({
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
+                data: mockProjectNodes,
+            }));
+            expect(mockWebSocket2.send).toHaveBeenCalledWith(JSON.stringify({
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
+                data: mockProjectNodes,
+            }));
+        });
+    });
+});

package/lib/projects/__tests__/ProjectLogsManager.test.d.ts

@@ -0,0 +1 @@
+export {};