@hubspot/cli 7.7.0-experimental.2 → 7.7.0

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

@@ -0,0 +1,365 @@
+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().mockResolvedValue({}),
+            sendDevServerMessage: vi.fn(),
+            projectData: {
+                name: 'test-project',
+                id: 123,
+                latestBuild: { id: 'build-1', status: 'SUCCESS' },
+                deployedBuild: { id: 'build-1', status: 'SUCCESS' },
+            },
+            targetProjectAccountId: 456,
+            targetTestingAccountId: 789,
+        };
+        // 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();
+        });
+        describe('valid origins', () => {
+            const validOrigins = [
+                'https://app.hubspot.com',
+                'https://app.hubspotqa.com',
+                'https://local.hubspot.com',
+                'https://local.hubspotqa.com',
+                'https://app-na2.hubspot.com',
+                'https://app-na2.hubspotqa.com',
+                'https://app-na3.hubspot.com',
+                'https://app-na3.hubspotqa.com',
+                'https://app-ap1.hubspot.com',
+                'https://app-ap1.hubspotqa.com',
+                'https://app-eu1.hubspot.com',
+                'https://app-eu1.hubspotqa.com',
+            ];
+            validOrigins.forEach(origin => {
+                it(`should accept connection from ${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 },
+                    });
+                    expect(mockWebSocket.on).toHaveBeenCalledWith('message', expect.any(Function));
+                    expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function));
+                    expect(mockWebSocket.close).not.toHaveBeenCalled();
+                });
+            });
+        });
+        describe('invalid origins', () => {
+            const invalidOrigins = [
+                'https://malicious-site.com',
+                'https://app.malicious-site.com',
+                'https://app.hubspot.com.evil.com',
+            ];
+            invalidOrigins.forEach(origin => {
+                it(`should reject connection from "${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 },
+                    });
+                    expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
+                    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-na3.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-na2.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', () => {
+            // Establish multiple connections
+            connectionCallback(mockWebSocket1, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            connectionCallback(mockWebSocket2, {
+                headers: { origin: 'https://app-eu1.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,
+                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
+                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
+                    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,
+                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
+                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
+                    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-ap1.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, appData, and uploadWarnings listeners
+            expect(closeCallbacks2).toHaveLength(3); // projectNodes, appData, and uploadWarnings listeners
+            // Simulate first connection closing (call all close callbacks)
+            closeCallbacks1.forEach(callback => callback());
+            // Should have removed listeners for first connection (3 listeners: projectNodes, appData, and uploadWarnings)
+            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://local.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,
+                        removed: false,
+                        parsingErrors: [],
+                    },
+                    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 {};

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

@@ -0,0 +1,189 @@
+import { ProjectLogsManager } from '../ProjectLogsManager.js';
+import { getProjectConfig } from '../config.js';
+import { ensureProjectExists } from '../ensureProjectExists.js';
+import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
+const SUBCOMPONENT_TYPES = {
+    APP_ID: 'APP_ID',
+    PACKAGE_LOCK_FILE: 'PACKAGE_LOCK_FILE',
+    CRM_CARD_V2: 'CRM_CARD_V2',
+    CARD_V2: 'CARD_V2',
+    SERVERLESS_PKG: 'SERVERLESS_PKG',
+    SERVERLESS_ROUTE: 'SERVERLESS_ROUTE',
+    SERVERLESS_FUNCTION: 'SERVERLESS_FUNCTION',
+    APP_FUNCTION: 'APP_FUNCTION',
+    AUTOMATION_ACTION: 'AUTOMATION_ACTION',
+    REACT_EXTENSION: 'REACT_EXTENSION',
+};
+vi.mock('../../projects/config');
+vi.mock('../../projects/ensureProjectExists');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+describe('lib/projects/ProjectLogsManager', () => {
+    const accountId = 12345678;
+    const appId = 999999;
+    const projectName = 'super cool test project';
+    const projectConfig = { projectConfig: { name: projectName } };
+    const projectId = 987654321;
+    const projectDetails = {
+        project: {
+            id: projectId,
+            deployedBuild: {
+                subbuildStatuses: {},
+            },
+        },
+    };
+    const function1 = {
+        componentName: 'function1',
+        type: {
+            name: SUBCOMPONENT_TYPES.APP_FUNCTION,
+        },
+        deployOutput: {
+            appId,
+            appFunctionName: 'function1',
+        },
+    };
+    const functions = [
+        function1,
+        {
+            componentName: 'function2',
+            type: {
+                name: SUBCOMPONENT_TYPES.APP_FUNCTION,
+            },
+            deployOutput: {
+                appId,
+                appFunctionName: 'function2',
+            },
+        },
+    ];
+    beforeEach(() => {
+        ProjectLogsManager.reset();
+        getProjectConfig.mockResolvedValue(projectConfig);
+        ensureProjectExists.mockResolvedValue(projectDetails);
+        fetchProjectComponentsMetadata.mockResolvedValue({
+            data: {
+                topLevelComponentMetadata: [
+                    {
+                        type: {
+                            name: 'PRIVATE_APP',
+                        },
+                        deployOutput: {
+                            appId,
+                        },
+                        featureComponents: [
+                            ...functions,
+                            {
+                                type: {
+                                    name: 'NOT_AN_APP_FUNCTION',
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+    });
+    describe('init', () => {
+        it('should load the project config', async () => {
+            await ProjectLogsManager.init(accountId);
+            expect(getProjectConfig).toHaveBeenCalledTimes(1);
+        });
+        it('should throw an error if there is a problem with the config', async () => {
+            getProjectConfig.mockResolvedValue({});
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow('No project detected. Run this command again from a project directory.');
+            expect(getProjectConfig).toHaveBeenCalledTimes(1);
+        });
+        it('should ensure the project exists', async () => {
+            await ProjectLogsManager.init(accountId);
+            expect(ensureProjectExists).toHaveBeenCalledTimes(1);
+            expect(ensureProjectExists).toHaveBeenCalledWith(accountId, projectName, {
+                allowCreate: false,
+            });
+        });
+        it('should throw an error if there is data missing from the project details', async () => {
+            ensureProjectExists.mockResolvedValue({});
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There was an error fetching project details/);
+        });
+        it('should set all of the expected fields correctly', async () => {
+            await ProjectLogsManager.init(accountId);
+            expect(ProjectLogsManager.projectId).toEqual(projectId);
+            expect(ProjectLogsManager.projectName).toEqual(projectName);
+            expect(ProjectLogsManager.accountId).toEqual(accountId);
+            expect(ProjectLogsManager.functions).toEqual(functions);
+        });
+    });
+    describe('fetchFunctionDetails', () => {
+        it('should throw an error if the projectId is null when the method is called', async () => {
+            await expect(async () => ProjectLogsManager.fetchFunctionDetails()).rejects.toThrow('No project detected. Run this command again from a project directory.');
+        });
+        it('should fetch the component metadata', async () => {
+            ProjectLogsManager.projectId = projectId;
+            ProjectLogsManager.accountId = accountId;
+            await ProjectLogsManager.fetchFunctionDetails();
+            expect(fetchProjectComponentsMetadata).toHaveBeenCalledTimes(1);
+            expect(fetchProjectComponentsMetadata).toHaveBeenCalledWith(accountId, projectId);
+        });
+        it('should set the functions correctly', async () => {
+            ProjectLogsManager.projectId = projectId;
+            ProjectLogsManager.accountId = accountId;
+            await ProjectLogsManager.fetchFunctionDetails();
+            expect(ProjectLogsManager.functions).toEqual(functions);
+        });
+    });
+    describe('getFunctionNames', () => {
+        it('should return an empty array if functions is empty', async () => {
+            ProjectLogsManager.functions = [];
+            expect(ProjectLogsManager.getFunctionNames()).toEqual([]);
+        });
+        it('should return an array of the componentNames', async () => {
+            ProjectLogsManager.functions = functions;
+            expect(ProjectLogsManager.getFunctionNames()).toEqual([
+                'function1',
+                'function2',
+            ]);
+        });
+    });
+    describe('setFunction', () => {
+        it('should throw an error when functions is empty', async () => {
+            ProjectLogsManager.functions = [];
+            expect(() => ProjectLogsManager.setFunction('foo')).toThrow(`There aren't any functions in this project`);
+        });
+        it('should throw an error when the provided function is invalid', async () => {
+            ProjectLogsManager.functions = functions;
+            const badName = 'foo';
+            expect(() => ProjectLogsManager.setFunction(badName)).toThrow(`No function with name "${badName}"`);
+        });
+        it('should set the data correctly for public functions', async () => {
+            const functionToChoose = {
+                componentName: 'function1',
+                type: {
+                    name: SUBCOMPONENT_TYPES.APP_FUNCTION,
+                },
+                deployOutput: {
+                    appId: 123,
+                    appFunctionName: 'function1',
+                    endpoint: { path: 'yooooooo', methods: ['GET'] },
+                },
+            };
+            ProjectLogsManager.functions = [functionToChoose];
+            ProjectLogsManager.setFunction('function1');
+            expect(ProjectLogsManager.functionName).toEqual('function1');
+            expect(ProjectLogsManager.endpointName).toEqual('yooooooo');
+            expect(ProjectLogsManager.selectedFunction).toEqual(functionToChoose);
+            expect(ProjectLogsManager.isPublicFunction).toEqual(true);
+        });
+        it('should set the data correctly for public functions', async () => {
+            ProjectLogsManager.functions = functions;
+            ProjectLogsManager.setFunction('function1');
+            expect(ProjectLogsManager.selectedFunction).toEqual(function1);
+            expect(ProjectLogsManager.functionName).toEqual('function1');
+            expect(ProjectLogsManager.isPublicFunction).toEqual(false);
+        });
+    });
+    describe('reset', () => {
+        it('should reset all the values', async () => {
+            ProjectLogsManager.projectName = 'value';
+            expect(ProjectLogsManager.projectName).toBeDefined();
+            ProjectLogsManager.reset();
+            expect(ProjectLogsManager.projectName).toBeUndefined();
+        });
+    });
+});

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

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