@hubspot/cli 8.1.0 → 8.1.1-experimental.0

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

@@ -1,185 +0,0 @@
-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

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

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

@@ -1,250 +0,0 @@
-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

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