@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

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

@@ -0,0 +1,185 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import DevServerManager from '../localDev/DevServerManager.js';
+import LocalDevState from '../localDev/LocalDevState.js';
+import LocalDevLogger from '../localDev/LocalDevLogger.js';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+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('@hubspot/local-dev-lib/portManager', () => ({
+    requestPorts: vi.fn().mockResolvedValue({ 'test-port': 8080 }),
+}));
+vi.mock('@hubspot/local-dev-lib/api/localDevAuth', () => ({
+    fetchAppInstallationData: vi.fn().mockResolvedValue({}),
+    LOCALDEVAUTH_ACCESS_TOKEN_PATH: '/localdevauth/v1/auth/accessToken',
+}));
+vi.mock('@hubspot/local-dev-lib/api/appsDev', () => ({
+    fetchAppMetadataByUid: vi.fn().mockResolvedValue({}),
+    fetchPublicAppProductionInstallCounts: vi.fn().mockResolvedValue({}),
+    installStaticAuthAppOnTestAccount: vi.fn().mockResolvedValue({}),
+}));
+vi.mock('@hubspot/local-dev-lib/config', () => ({
+    getAccountConfig: vi.fn().mockReturnValue({ accountId: 123 }),
+    configFileExists: vi.fn().mockReturnValue(true),
+    getAccountId: vi.fn().mockReturnValue(123),
+    hasLocalStateFlag: vi.fn().mockReturnValue(false),
+    getConfigDefaultAccount: vi.fn().mockReturnValue({ accountId: 123 }),
+    globalConfigFileExists: vi.fn().mockReturnValue(true),
+}));
+vi.mock('@hubspot/local-dev-lib/urls', () => ({
+    getHubSpotApiOrigin: vi.fn().mockReturnValue('https://api.hubspot.com'),
+    getHubSpotWebsiteOrigin: vi.fn().mockReturnValue('https://app.hubspot.com'),
+}));
+vi.mock('../../ui/SpinniesManager', () => ({
+    default: {
+        add: vi.fn(),
+        succeed: vi.fn(),
+        fail: vi.fn(),
+        init: vi.fn(),
+    },
+}));
+describe('DevServerManager', () => {
+    let devServerManager;
+    let localDevState;
+    let logger;
+    beforeEach(() => {
+        localDevState = new LocalDevState({
+            targetProjectAccountId: 123,
+            targetTestingAccountId: 456,
+            projectConfig: {
+                name: 'test-project',
+                srcDir: 'src',
+                platformVersion: '1.0.0',
+            },
+            projectDir: '/test/project',
+            projectData: {
+                name: 'test-project',
+                id: 123,
+                createdAt: Date.now(),
+                deletedAt: 0,
+                isLocked: false,
+                portalId: 123,
+                updatedAt: Date.now(),
+            },
+            debug: false,
+            initialProjectNodes: {},
+            initialProjectProfileData: {},
+            profile: 'test',
+            env: ENVIRONMENTS.QA,
+        });
+        logger = new LocalDevLogger(localDevState);
+        devServerManager = new DevServerManager({
+            localDevState,
+            logger,
+        });
+    });
+    describe('constructor', () => {
+        it('should initialize with correct state', async () => {
+            await expect(async () => {
+                await devServerManager.start();
+            }).rejects.toThrow('The Dev Server Manager must be initialized before it is started.');
+        });
+    });
+    describe('setup', () => {
+        it('should complete setup without errors', async () => {
+            await expect(devServerManager.setup()).resolves.not.toThrow();
+        });
+        it('should allow start after successful setup', async () => {
+            await devServerManager.setup();
+            await expect(devServerManager.start()).resolves.not.toThrow();
+        });
+        it('should call setup on dev servers sequentially', async () => {
+            const executionOrder = [];
+            const { DevModeUnifiedInterface } = await import('@hubspot/ui-extensions-dev-server');
+            const originalSetup = DevModeUnifiedInterface.setup;
+            DevModeUnifiedInterface.setup = vi.fn().mockImplementation(async () => {
+                executionOrder.push('UIExtensions-start');
+                await new Promise(resolve => setTimeout(resolve, 20));
+                executionOrder.push('UIExtensions-end');
+            });
+            const AppDevModeInterface = (await import('../localDev/AppDevModeInterface.js')).default;
+            const originalAppSetup = AppDevModeInterface.prototype.setup;
+            AppDevModeInterface.prototype.setup = vi
+                .fn()
+                .mockImplementation(async function () {
+                executionOrder.push('App-start');
+                await new Promise(resolve => setTimeout(resolve, 20));
+                executionOrder.push('App-end');
+            });
+            const testManager = new DevServerManager({
+                localDevState,
+                logger,
+            });
+            await testManager.setup();
+            expect(executionOrder).toEqual([
+                'App-start',
+                'App-end',
+                'UIExtensions-start',
+                'UIExtensions-end',
+            ]);
+            expect(AppDevModeInterface.prototype.setup).toHaveBeenCalledTimes(1);
+            expect(DevModeUnifiedInterface.setup).toHaveBeenCalledTimes(1);
+            // Restore original methods
+            DevModeUnifiedInterface.setup = originalSetup;
+            AppDevModeInterface.prototype.setup = originalAppSetup;
+        });
+    });
+    describe('start', () => {
+        it('should throw error when not initialized', async () => {
+            await expect(devServerManager.start()).rejects.toThrow();
+        });
+        it('should start successfully after setup', async () => {
+            await devServerManager.setup();
+            await expect(devServerManager.start()).resolves.not.toThrow();
+        });
+        it('should set started state correctly', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            await expect(devServerManager.fileChange({ filePath: 'test.js', event: 'change' })).resolves.not.toThrow();
+        });
+    });
+    describe('fileChange', () => {
+        it('should handle fileChange', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            await expect(devServerManager.fileChange({
+                filePath: 'src/test.js',
+                event: 'change',
+            })).resolves.not.toThrow();
+        });
+        it('should handle different file events', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            const testCases = [
+                { filePath: 'src/component.js', event: 'add' },
+                { filePath: 'src/style.css', event: 'change' },
+                { filePath: 'src/config.json', event: 'unlink' },
+            ];
+            for (const testCase of testCases) {
+                await expect(devServerManager.fileChange(testCase)).resolves.not.toThrow();
+            }
+        });
+        it('should handle concurrent fileChange calls', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            const fileChanges = [
+                devServerManager.fileChange({ filePath: 'file1.js', event: 'change' }),
+                devServerManager.fileChange({ filePath: 'file2.js', event: 'add' }),
+                devServerManager.fileChange({ filePath: 'file3.js', event: 'unlink' }),
+            ];
+            await expect(Promise.all(fileChanges)).resolves.not.toThrow();
+        });
+    });
+    describe('cleanup', () => {
+        it('should handle cleanup', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            await expect(devServerManager.cleanup()).resolves.not.toThrow();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,250 @@
+import { getActiveServers } from '@hubspot/local-dev-lib/portManager';
+import { devSessionHeartbeat, registerDevSession, deleteDevSession, } from '../localDev/helpers/devSessionsApi.js';
+import DevSessionManager from '../localDev/DevSessionManager.js';
+import { vi } from 'vitest';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+vi.mock('@hubspot/local-dev-lib/portManager');
+vi.mock('../localDev/helpers/devSessionsApi.js');
+vi.mock('../localDev/LocalDevState');
+vi.mock('../localDev/LocalDevLogger');
+const processExitSpy = vi.spyOn(process, 'exit');
+describe('DevSessionManager', () => {
+    let mockTargetTestingAccountId;
+    let mockLocalDevLogger;
+    let devSessionManager;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.useFakeTimers();
+        mockTargetTestingAccountId = 456;
+        mockLocalDevLogger = {
+            devSessionRegistrationError: vi.fn(),
+            devSessionMissingSessionIdError: vi.fn(),
+            devSessionHeartbeatError: vi.fn(),
+            devSessionDeletionError: vi.fn(),
+        };
+        devSessionManager = new DevSessionManager({
+            targetTestingAccountId: mockTargetTestingAccountId,
+            localDevLogger: mockLocalDevLogger,
+        });
+        // Spy on clearInterval but let it actually work
+        vi.spyOn(global, 'clearInterval');
+    });
+    afterEach(() => {
+        // Clear any remaining intervals
+        // @ts-expect-error accessing private property for testing
+        if (devSessionManager._heartbeatInterval) {
+            // @ts-expect-error accessing private property for testing
+            clearInterval(devSessionManager._heartbeatInterval);
+        }
+        vi.useRealTimers();
+    });
+    describe('constructor', () => {
+        it('should initialize with provided options', () => {
+            expect(devSessionManager.targetTestingAccountId).toBe(mockTargetTestingAccountId);
+            expect(devSessionManager.localDevLogger).toBe(mockLocalDevLogger);
+            // @ts-expect-error accessing private property for testing
+            expect(devSessionManager._devSessionId).toBeUndefined();
+            // @ts-expect-error accessing private property for testing
+            expect(devSessionManager._heartbeatInterval).toBeUndefined();
+            // @ts-expect-error accessing private property for testing
+            expect(devSessionManager._heartbeatRetries).toBe(0);
+        });
+    });
+    describe('registerDevSession()', () => {
+        it('should successfully register dev session and initialize heartbeat', async () => {
+            const mockActiveServers = {
+                'server-1': 3000,
+                'server-2': 3001,
+            };
+            const mockSessionId = 789;
+            getActiveServers.mockResolvedValue(mockActiveServers);
+            registerDevSession.mockResolvedValue({
+                data: { sessionId: mockSessionId },
+            });
+            const result = await devSessionManager.registerSession();
+            expect(getActiveServers).toHaveBeenCalled();
+            expect(registerDevSession).toHaveBeenCalledWith(mockTargetTestingAccountId, [
+                { serverId: 'server-1', port: 3000 },
+                { serverId: 'server-2', port: 3001 },
+            ]);
+            // @ts-expect-error accessing private property for testing
+            expect(devSessionManager._devSessionId).toBe(mockSessionId);
+            expect(result).toBe(true);
+            // @ts-expect-error accessing private property for testing
+            expect(devSessionManager._heartbeatInterval).toBeDefined();
+        });
+        it('should return false and log error when registration fails', async () => {
+            const error = new Error('Registration failed');
+            getActiveServers.mockResolvedValue({});
+            registerDevSession.mockRejectedValue(error);
+            const result = await devSessionManager.registerSession();
+            expect(mockLocalDevLogger.devSessionRegistrationError).toHaveBeenCalledWith(error);
+            expect(result).toBe(false);
+            // @ts-expect-error accessing private property for testing
+            expect(devSessionManager._devSessionId).toBeUndefined();
+        });
+        it('should exit if session ID is missing after registration', async () => {
+            getActiveServers.mockResolvedValue({});
+            registerDevSession.mockResolvedValue({
+                data: { sessionId: undefined },
+            });
+            await expect(devSessionManager.registerSession()).rejects.toThrow();
+            expect(mockLocalDevLogger.devSessionMissingSessionIdError).toHaveBeenCalled();
+        });
+        it('should handle empty active servers', async () => {
+            const mockSessionId = 789;
+            getActiveServers.mockResolvedValue({});
+            registerDevSession.mockResolvedValue({
+                data: { sessionId: mockSessionId },
+            });
+            const result = await devSessionManager.registerSession();
+            expect(registerDevSession).toHaveBeenCalledWith(mockTargetTestingAccountId, []);
+            expect(result).toBe(true);
+        });
+    });
+    describe('deleteDevSession()', () => {
+        it('should successfully delete dev session when session ID exists', async () => {
+            // @ts-expect-error accessing private property for testing
+            devSessionManager._devSessionId = 789;
+            const mockInterval = setInterval(() => { }, 30000);
+            // @ts-expect-error accessing private property for testing
+            devSessionManager._heartbeatInterval = mockInterval;
+            deleteDevSession.mockResolvedValue(undefined);
+            const result = await devSessionManager.deleteDevSession();
+            expect(deleteDevSession).toHaveBeenCalledWith(mockTargetTestingAccountId, 789);
+            expect(clearInterval).toHaveBeenCalledWith(mockInterval);
+            expect(result).toBe(true);
+        });
+        it('should return true when no session ID exists', async () => {
+            // @ts-expect-error accessing private property for testing
+            devSessionManager._devSessionId = undefined;
+            const result = await devSessionManager.deleteDevSession();
+            expect(deleteDevSession).not.toHaveBeenCalled();
+            expect(result).toBe(true);
+        });
+        it('should return false and log error when deletion fails', async () => {
+            const error = new Error('Deletion failed');
+            // @ts-expect-error accessing private property for testing
+            devSessionManager._devSessionId = 789;
+            // @ts-expect-error accessing private property for testing
+            devSessionManager._heartbeatInterval = setInterval(() => { }, 30000);
+            deleteDevSession.mockRejectedValue(error);
+            const result = await devSessionManager.deleteDevSession();
+            expect(mockLocalDevLogger.devSessionDeletionError).toHaveBeenCalledWith(error);
+            expect(result).toBe(false);
+        });
+    });
+    describe('heartbeat', () => {
+        it('should send heartbeat every 30 seconds after registration', async () => {
+            const mockSessionId = 789;
+            getActiveServers.mockResolvedValue({});
+            registerDevSession.mockResolvedValue({
+                data: { sessionId: mockSessionId },
+            });
+            devSessionHeartbeat.mockResolvedValue(undefined);
+            // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+            processExitSpy.mockImplementation(() => { });
+            await devSessionManager.registerSession();
+            // Fast-forward time to trigger heartbeat
+            await vi.advanceTimersByTimeAsync(30000);
+            expect(devSessionHeartbeat).toHaveBeenCalledWith(mockTargetTestingAccountId, mockSessionId);
+            // Reset mock to count only the second call
+            devSessionHeartbeat.mockClear();
+            // Fast-forward again to trigger another heartbeat
+            await vi.advanceTimersByTimeAsync(30000);
+            expect(devSessionHeartbeat).toHaveBeenCalledTimes(1);
+            // Clean up interval
+            // @ts-expect-error accessing private property for testing
+            if (devSessionManager._heartbeatInterval) {
+                // @ts-expect-error accessing private property for testing
+                clearInterval(devSessionManager._heartbeatInterval);
+            }
+        });
+        it('should retry heartbeat on failure up to 3 times', async () => {
+            const mockSessionId = 789;
+            const error = new Error('Heartbeat failed');
+            getActiveServers.mockResolvedValue({});
+            registerDevSession.mockResolvedValue({
+                data: { sessionId: mockSessionId },
+            });
+            devSessionHeartbeat.mockRejectedValue(error);
+            // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+            processExitSpy.mockImplementation(() => { });
+            await devSessionManager.registerSession();
+            // Fast-forward to trigger 3 failed heartbeats
+            for (let i = 0; i < 3; i++) {
+                await vi.advanceTimersByTimeAsync(30000);
+            }
+            // @ts-expect-error accessing private property for testing
+            expect(devSessionManager._heartbeatRetries).toBe(3);
+            expect(devSessionHeartbeat).toHaveBeenCalledTimes(3);
+            // Advance timers - the error will be captured by errorPromise
+            await vi.advanceTimersByTimeAsync(30000);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(mockLocalDevLogger.devSessionHeartbeatError).toHaveBeenCalledWith(error);
+        });
+        it('should reset retry count on successful heartbeat', async () => {
+            const mockSessionId = 789;
+            const error = new Error('Heartbeat failed');
+            getActiveServers.mockResolvedValue({});
+            registerDevSession.mockResolvedValue({
+                data: { sessionId: mockSessionId },
+            });
+            // First heartbeat fails, then succeeds
+            devSessionHeartbeat
+                .mockRejectedValueOnce(error)
+                .mockResolvedValue(undefined);
+            await devSessionManager.registerSession();
+            // Trigger first failed heartbeat
+            await vi.advanceTimersByTimeAsync(30000);
+            // @ts-expect-error accessing private property for testing
+            expect(devSessionManager._heartbeatRetries).toBe(1);
+            // Trigger successful heartbeat
+            await vi.advanceTimersByTimeAsync(30000);
+            // @ts-expect-error accessing private property for testing
+            expect(devSessionManager._heartbeatRetries).toBe(1); // Should not reset, but next failure should increment
+            // Clean up interval
+            // @ts-expect-error accessing private property for testing
+            if (devSessionManager._heartbeatInterval) {
+                // @ts-expect-error accessing private property for testing
+                clearInterval(devSessionManager._heartbeatInterval);
+            }
+        });
+        it('should exit if session ID is missing during heartbeat', async () => {
+            const mockSessionId = 789;
+            getActiveServers.mockResolvedValue({});
+            registerDevSession.mockResolvedValue({
+                data: { sessionId: mockSessionId },
+            });
+            devSessionHeartbeat.mockResolvedValue(undefined);
+            await devSessionManager.registerSession();
+            // Clear the session ID to simulate missing session
+            // @ts-expect-error accessing private property for testing
+            devSessionManager._devSessionId = undefined;
+            // Advance timers - the error will be captured by errorPromise
+            await vi.advanceTimersByTimeAsync(30000);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(mockLocalDevLogger.devSessionMissingSessionIdError).toHaveBeenCalled();
+        });
+        it('should clear heartbeat interval when session is deleted', async () => {
+            const mockSessionId = 789;
+            getActiveServers.mockResolvedValue({});
+            registerDevSession.mockResolvedValue({
+                data: { sessionId: mockSessionId },
+            });
+            devSessionHeartbeat.mockResolvedValue(undefined);
+            deleteDevSession.mockResolvedValue(undefined);
+            await devSessionManager.registerSession();
+            // @ts-expect-error accessing private property for testing
+            const intervalId = devSessionManager._heartbeatInterval;
+            expect(intervalId).toBeDefined();
+            // Reset mock to count calls after deletion
+            devSessionHeartbeat.mockClear();
+            await devSessionManager.deleteDevSession();
+            expect(clearInterval).toHaveBeenCalledWith(intervalId);
+            // Fast-forward time - heartbeat should not be called
+            await vi.advanceTimersByTimeAsync(30000);
+            expect(devSessionHeartbeat).not.toHaveBeenCalled();
+        });
+    });
+});

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

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