@hubspot/cli 8.0.11-experimental.0 → 8.0.11-experimental.2

package/commands/project/__tests__/devUnifiedFlow.test.js

@@ -1,434 +0,0 @@
-import path from 'path';
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { translateForLocalDev } from '@hubspot/project-parsing-lib/translate';
-import { getAllConfigAccounts, getConfigAccountById, getConfigAccountEnvironment, } from '@hubspot/local-dev-lib/config';
-import { getValidEnv } from '@hubspot/local-dev-lib/environment';
-import { getServerPortByInstanceId } from '@hubspot/local-dev-lib/portManager';
-import { logError } from '../../../lib/errorHandlers/index.js';
-import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
-import { createInitialBuildForNewProject, createNewProjectForLocalDev, } from '../../../lib/projects/localDev/helpers/project.js';
-import { useExistingDevTestAccount, createDeveloperTestAccountForLocalDev, selectAccountTypePrompt, } from '../../../lib/projects/localDev/helpers/account.js';
-import { selectDeveloperTestTargetAccountPrompt, selectSandboxTargetAccountPrompt, } from '../../../lib/prompts/projectDevTargetAccountPrompt.js';
-import SpinniesManager from '../../../lib/ui/SpinniesManager.js';
-import LocalDevProcess from '../../../lib/projects/localDev/LocalDevProcess.js';
-import LocalDevWatcher from '../../../lib/projects/localDev/LocalDevWatcher.js';
-import LocalDevWebsocketServer from '../../../lib/projects/localDev/LocalDevWebsocketServer.js';
-import { handleExit, handleKeypress } from '../../../lib/process.js';
-import { isTestAccountOrSandbox, isUnifiedAccount, } from '../../../lib/accountTypes.js';
-import { uiLine } from '../../../lib/ui/index.js';
-import { uiLogger } from '../../../lib/ui/logger.js';
-import { commands } from '../../../lang/en.js';
-import { unifiedProjectDevFlow } from '../dev/unifiedFlow.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),
-    },
-}));
-// Mock all dependencies
-vi.mock('@hubspot/project-parsing-lib/translate');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('@hubspot/local-dev-lib/environment');
-vi.mock('@hubspot/local-dev-lib/portManager');
-vi.mock('../../../lib/errorHandlers');
-vi.mock('../../../lib/projects/ensureProjectExists');
-vi.mock('../../../lib/projects/localDev/helpers/project');
-vi.mock('../../../lib/projects/localDev/helpers/account');
-vi.mock('../../../lib/prompts/projectDevTargetAccountPrompt');
-vi.mock('../../../lib/ui/SpinniesManager');
-vi.mock('../../../lib/projects/localDev/LocalDevProcess');
-vi.mock('../../../lib/projects/localDev/LocalDevWatcher');
-vi.mock('../../../lib/projects/localDev/LocalDevWebsocketServer');
-vi.mock('../../../lib/process');
-vi.mock('../../../lib/accountTypes');
-vi.mock('../../../lib/ui');
-describe('unifiedProjectDevFlow', () => {
-    const mockArgs = {
-        profile: 'test-profile',
-        d: false,
-        debug: false,
-        derivedAccountId: 123,
-        userProvidedAccount: undefined,
-        testingAccount: undefined,
-        projectAccount: undefined,
-        _: [],
-        $0: 'hs',
-    };
-    const mockProjectConfig = {
-        name: 'test-project',
-        srcDir: 'src',
-        platformVersion: '1.0.0',
-    };
-    const mockProjectDir = '/test/project.js';
-    const mockTargetProjectAccountId = 123;
-    const mockProvidedTargetTestingAccountId = 456;
-    // const mockProfileConfig: HsProfileFile = {
-    //   accountId: 789,
-    // };
-    const mockAccountConfig = {
-        accountId: 123,
-        name: 'test-account',
-        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-        env: ENVIRONMENTS.PROD,
-    };
-    const mockProject = {
-        id: 1,
-        name: 'test-project',
-        deployedBuild: {
-            buildId: 123,
-            status: 'SUCCESS',
-        },
-        sourceIntegration: null,
-    };
-    const mockProjectNodes = {
-        component1: {
-            uid: 'component1',
-            componentType: 'APP',
-            localDev: {
-                componentRoot: '/test/path',
-                componentConfigPath: '/test/path/config.json',
-                configUpdatedSinceLastUpload: false,
-            },
-        },
-    };
-    const mockLocalDevProcess = {
-        start: vi.fn().mockResolvedValue(undefined),
-        stop: vi.fn().mockResolvedValue(undefined),
-    };
-    const mockLocalDevWatcher = {
-        start: vi.fn(),
-        stop: vi.fn().mockResolvedValue(undefined),
-    };
-    const mockWebsocketServer = {
-        start: vi.fn().mockResolvedValue(undefined),
-        shutdown: vi.fn().mockResolvedValue(undefined),
-    };
-    beforeEach(() => {
-        // Mock process.exit
-        vi.spyOn(global.process, 'exit').mockImplementation((code) => {
-            throw new Error(`Process.exit called with code ${code}`);
-        });
-        // Setup default mocks
-        getValidEnv.mockReturnValue(ENVIRONMENTS.PROD);
-        translateForLocalDev.mockResolvedValue({
-            intermediateNodesIndexedByUid: mockProjectNodes,
-        });
-        getConfigAccountById.mockReturnValue(mockAccountConfig);
-        getConfigAccountEnvironment.mockReturnValue(ENVIRONMENTS.PROD);
-        getAllConfigAccounts.mockReturnValue([mockAccountConfig]);
-        isUnifiedAccount.mockResolvedValue(true);
-        isTestAccountOrSandbox.mockReturnValue(false);
-        ensureProjectExists.mockResolvedValue({
-            projectExists: true,
-            project: mockProject,
-        });
-        SpinniesManager.init.mockImplementation(() => { });
-        LocalDevProcess.mockImplementation(() => mockLocalDevProcess);
-        LocalDevWatcher.mockImplementation(() => mockLocalDevWatcher);
-        LocalDevWebsocketServer.mockImplementation(() => mockWebsocketServer);
-        handleKeypress.mockImplementation(() => { });
-        handleExit.mockImplementation(() => { });
-        uiLogger.debug.mockImplementation(() => { });
-        uiLogger.error.mockImplementation(() => { });
-        uiLogger.log.mockImplementation(() => { });
-        uiLine.mockImplementation(() => { });
-        getServerPortByInstanceId.mockRejectedValue(new Error('No server running'));
-    });
-    describe('successful flow', () => {
-        it('should complete successfully with existing project and provided testing account', async () => {
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(translateForLocalDev).toHaveBeenCalledWith({
-                projectSourceDir: path.join(mockProjectDir, mockProjectConfig.srcDir),
-                platformVersion: mockProjectConfig.platformVersion,
-                accountId: mockTargetProjectAccountId,
-            }, { profile: mockArgs.profile });
-            expect(mockLocalDevProcess.start).toHaveBeenCalled();
-            expect(mockLocalDevWatcher.start).toHaveBeenCalled();
-            expect(mockWebsocketServer.start).toHaveBeenCalled();
-        });
-        // TODO: Restore test once we've switched back to using profile account for testing
-        // it('should complete successfully with profile config', async () => {
-        //   await unifiedProjectDevFlow({
-        //     args: mockArgs,
-        //     targetProjectAccountId: mockTargetProjectAccountId,
-        //     projectConfig: mockProjectConfig,
-        //     projectDir: mockProjectDir,
-        //     profileConfig: mockProfileConfig,
-        //   });
-        //   expect(LocalDevProcess).toHaveBeenCalledWith(
-        //     expect.objectContaining({
-        //       targetTestingAccountId: mockProfileConfig.accountId,
-        //     })
-        //   );
-        // });
-        it('should use target project account as testing account when it is a test account', async () => {
-            isTestAccountOrSandbox.mockReturnValue(true);
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
-                targetTestingAccountId: mockTargetProjectAccountId,
-            }));
-        });
-    });
-    describe('error handling', () => {
-        it('should exit with error code when translation fails', async () => {
-            const translationError = new Error('Translation failed');
-            translateForLocalDev.mockRejectedValue(translationError);
-            await expect(unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            })).rejects.toThrow('Process.exit called with code 1');
-            expect(logError).toHaveBeenCalledWith(translationError);
-        });
-        it('should exit with success when no runnable components found', async () => {
-            translateForLocalDev.mockResolvedValue({
-                intermediateNodesIndexedByUid: {},
-            });
-            await expect(unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            })).rejects.toThrow('Process.exit called with code 0');
-            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.dev.errors.noRunnableComponents);
-        });
-        it('should exit with error when account config not found', async () => {
-            getConfigAccountById.mockReturnValue(null);
-            await expect(unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            })).rejects.toThrow('Process.exit called with code 1');
-            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.dev.errors.noAccount(mockTargetProjectAccountId));
-        });
-        it('should exit with error when account is not combined and no profile', async () => {
-            isUnifiedAccount.mockResolvedValue(false);
-            await expect(unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            })).rejects.toThrow('Process.exit called with code 1');
-            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.dev.errors.accountNotCombined);
-        });
-    });
-    describe('account type selection and prompting', () => {
-        beforeEach(() => {
-            // Reset to require prompting
-            isTestAccountOrSandbox.mockReturnValue(false);
-        });
-        it('should prompt for account type when no testing account provided', async () => {
-            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
-            selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
-                targetAccountId: 456,
-            });
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(selectAccountTypePrompt).toHaveBeenCalledWith(mockAccountConfig);
-            expect(selectDeveloperTestTargetAccountPrompt).toHaveBeenCalled();
-        });
-        it('should handle developer test account creation', async () => {
-            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
-            selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
-                createNestedAccount: true,
-            });
-            createDeveloperTestAccountForLocalDev.mockResolvedValue(999);
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(createDeveloperTestAccountForLocalDev).toHaveBeenCalledWith(mockTargetProjectAccountId, mockAccountConfig, ENVIRONMENTS.PROD, true);
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
-                targetTestingAccountId: 999,
-            }));
-        });
-        it('should handle existing developer test account not in config', async () => {
-            const notInConfigAccount = { accountId: 777, name: 'external-account' };
-            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
-            selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
-                notInConfigAccount,
-            });
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(useExistingDevTestAccount).toHaveBeenCalledWith(ENVIRONMENTS.PROD, notInConfigAccount);
-        });
-        it('should handle sandbox account selection', async () => {
-            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
-            selectSandboxTargetAccountPrompt.mockResolvedValue({
-                targetAccountId: 888,
-            });
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(selectSandboxTargetAccountPrompt).toHaveBeenCalled();
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
-                targetTestingAccountId: 888,
-            }));
-        });
-    });
-    describe('project creation', () => {
-        it('should create new project when project does not exist', async () => {
-            ensureProjectExists.mockResolvedValue({
-                projectExists: false,
-                project: null,
-            });
-            createNewProjectForLocalDev.mockResolvedValue(mockProject);
-            createInitialBuildForNewProject.mockResolvedValue({
-                buildId: 456,
-            });
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(createNewProjectForLocalDev).toHaveBeenCalledWith(mockProjectConfig, mockTargetProjectAccountId, false, false);
-            expect(createInitialBuildForNewProject).toHaveBeenCalledWith(mockProjectConfig, mockProjectDir, mockTargetProjectAccountId, true, mockArgs.profile);
-        });
-        it('should use existing project and build when project exists', async () => {
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(createNewProjectForLocalDev).not.toHaveBeenCalled();
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
-                projectData: mockProject,
-            }));
-        });
-    });
-    describe('local dev process setup', () => {
-        it('should initialize LocalDevProcess with correct parameters', async () => {
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(LocalDevProcess).toHaveBeenCalledWith({
-                initialProjectNodes: mockProjectNodes,
-                debug: mockArgs.debug,
-                profile: mockArgs.profile,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                targetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-                projectData: mockProject,
-                env: ENVIRONMENTS.PROD,
-            });
-        });
-        it('should set up keypress and exit handlers', async () => {
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(handleKeypress).toHaveBeenCalledWith(expect.any(Function));
-            expect(handleExit).toHaveBeenCalledWith(expect.any(Function));
-        });
-        it('should start all required services', async () => {
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(mockLocalDevProcess.start).toHaveBeenCalled();
-            expect(mockLocalDevWatcher.start).toHaveBeenCalled();
-            expect(mockWebsocketServer.start).toHaveBeenCalled();
-        });
-    });
-    describe('UI messaging', () => {
-        beforeEach(() => {
-            isTestAccountOrSandbox.mockReturnValue(false);
-        });
-        it('should log info message when default account is a sandbox or test account', async () => {
-            isTestAccountOrSandbox.mockReturnValue(true);
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.defaultSandboxOrDevTestTestingAccountExplanation(mockTargetProjectAccountId));
-        });
-        it('should log info message when testingAccount flag is provided', async () => {
-            const providedTestingAccountId = 999;
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: providedTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.testingAccountFlagExplanation(providedTestingAccountId));
-        });
-    });
-    describe('confirmLocalDevIsNotRunning', () => {
-        it('should exit with error when local dev is already running', async () => {
-            getServerPortByInstanceId.mockResolvedValue(3000);
-            const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
-                throw new Error('Process.exit called');
-            });
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.dev.errors.localDevAlreadyRunning);
-            expect(mockExit).toHaveBeenCalledWith(1);
-            mockExit.mockRestore();
-        });
-        it('should continue when local dev is not running', async () => {
-            getServerPortByInstanceId.mockRejectedValue(new Error('No server running'));
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(mockLocalDevProcess.start).toHaveBeenCalled();
-        });
-    });
-});

package/commands/project/__tests__/download.test.d.ts

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

package/commands/project/__tests__/download.test.js

@@ -1,39 +0,0 @@
-import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
-import projectDownloadCommand from '../download.js';
-vi.mock('../../../lib/commonOpts');
-describe('commands/project/download', () => {
-    const yargsMock = yargs;
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(projectDownloadCommand.command).toEqual('download');
-        });
-    });
-    describe('describe', () => {
-        it('should provide a description', () => {
-            expect(projectDownloadCommand.describe).toBeDefined();
-        });
-    });
-    describe('builder', () => {
-        it('should support the correct options', () => {
-            projectDownloadCommand.builder(yargsMock);
-            expect(addAccountOptions).toHaveBeenCalledTimes(1);
-            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addConfigOptions).toHaveBeenCalledTimes(1);
-            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
-        });
-        it('should define project, dest, and build options', () => {
-            const optionsSpy = vi.spyOn(yargsMock, 'options');
-            const exampleSpy = vi.spyOn(yargsMock, 'example');
-            projectDownloadCommand.builder(yargsMock);
-            expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
-                project: expect.any(Object),
-                dest: expect.any(Object),
-                build: expect.any(Object),
-            }));
-            expect(exampleSpy).toHaveBeenCalled();
-        });
-    });
-});

package/commands/project/__tests__/info.test.d.ts

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

package/commands/project/__tests__/info.test.js

@@ -1,145 +0,0 @@
-import yargs from 'yargs';
-import projectInfoCommand from '../info.js';
-import { getProjectConfig } from '../../../lib/projects/config.js';
-import { isV2Project } from '../../../lib/projects/platformVersion.js';
-import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
-import { getProjectInfo, renderProjectInfo, } from '../../../lib/projects/projectInfo.js';
-import { uiLogger } from '../../../lib/ui/logger.js';
-import { trackCommandUsage } from '../../../lib/usageTracking.js';
-vi.mock('../../../lib/commonOpts');
-vi.mock('../../../lib/errorHandlers/index.js');
-vi.mock('../../../lib/projects/config');
-vi.mock('../../../lib/projects/platformVersion');
-vi.mock('../../../lib/projects/projectInfo');
-vi.mock('@hubspot/local-dev-lib/api/projects');
-const mockedGetProjectConfig = vi.mocked(getProjectConfig);
-const mockedIsV2Project = vi.mocked(isV2Project);
-const mockedFetchProject = vi.mocked(fetchProject);
-const mockedGetProjectInfo = vi.mocked(getProjectInfo);
-const mockedRenderProjectInfo = vi.mocked(renderProjectInfo);
-const mockedUiLogger = vi.mocked(uiLogger);
-const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
-const mockProjectConfig = {
-    name: 'my-project',
-    srcDir: 'src',
-    platformVersion: '2025.2',
-};
-const mockProject = {
-    id: 42,
-    name: 'my-project',
-    deployedBuild: {
-        buildId: 7,
-        isAutoDeployEnabled: true,
-        subbuildStatuses: [],
-    },
-};
-const mockProjectInfo = {
-    projectName: 'my-project',
-    platformVersion: '2025.2',
-    projectId: 42,
-    deployedBuildId: 7,
-    autoDeployEnabled: true,
-    projectUrl: 'https://app.hubspot.com/project/my-project',
-    app: {
-        name: 'My App',
-        id: 99,
-        uid: 'my-app',
-        authType: 'OAUTH',
-        distributionType: 'PRIVATE',
-    },
-    components: [
-        { uid: 'card-one-uid', type: 'APP_CARD' },
-        { uid: 'func-one', type: 'SERVERLESS_FUNCTION' },
-    ],
-};
-describe('commands/project/info', () => {
-    const yargsMock = yargs;
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(projectInfoCommand.command).toEqual('info');
-        });
-    });
-    describe('describe', () => {
-        it('should provide a description', () => {
-            expect(projectInfoCommand.describe).toBeDefined();
-        });
-    });
-    describe('builder', () => {
-        it('should define examples', () => {
-            const exampleSpy = vi.spyOn(yargsMock, 'example');
-            projectInfoCommand.builder(yargsMock);
-            expect(exampleSpy).toHaveBeenCalled();
-        });
-    });
-    describe('handler', () => {
-        const mockArgs = {
-            derivedAccountId: 100,
-            formatOutputAsJson: false,
-        };
-        beforeEach(() => {
-            mockedGetProjectConfig.mockResolvedValue({
-                projectConfig: mockProjectConfig,
-                projectDir: '/path/to/project',
-            });
-            mockedIsV2Project.mockReturnValue(true);
-            mockedFetchProject.mockResolvedValue({
-                data: mockProject,
-            });
-            mockedGetProjectInfo.mockResolvedValue(mockProjectInfo);
-            mockedRenderProjectInfo.mockResolvedValue(undefined);
-            mockedTrackCommandUsage.mockResolvedValue();
-            vi.spyOn(process, 'exit').mockImplementation(() => {
-                throw new Error('process.exit called');
-            });
-        });
-        it('should exit with error when no project config is found', async () => {
-            mockedGetProjectConfig.mockResolvedValue({
-                projectConfig: null,
-                projectDir: null,
-            });
-            await expect(projectInfoCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
-            expect(mockedUiLogger.error).toHaveBeenCalled();
-            expect(mockedFetchProject).not.toHaveBeenCalled();
-        });
-        it('should exit with error for unsupported platform version', async () => {
-            mockedIsV2Project.mockReturnValue(false);
-            await expect(projectInfoCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
-            expect(mockedUiLogger.error).toHaveBeenCalled();
-            expect(mockedFetchProject).not.toHaveBeenCalled();
-        });
-        it('should exit with error when project fetch fails', async () => {
-            mockedFetchProject.mockRejectedValue(new Error('Not found'));
-            await expect(projectInfoCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
-            expect(mockedUiLogger.error).toHaveBeenCalled();
-        });
-        it('should exit with error when project has no deployed build', async () => {
-            mockedFetchProject.mockResolvedValue({
-                data: { ...mockProject, deployedBuild: undefined },
-            });
-            await expect(projectInfoCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
-            expect(mockedUiLogger.error).toHaveBeenCalled();
-        });
-        it('should call getProjectInfo with correct arguments', async () => {
-            const jsonArgs = {
-                ...mockArgs,
-                formatOutputAsJson: true,
-            };
-            await projectInfoCommand.handler(jsonArgs);
-            expect(mockedGetProjectInfo).toHaveBeenCalledWith(mockProject, '2025.2', 100);
-        });
-        it('should output JSON when formatOutputAsJson is true', async () => {
-            const jsonArgs = {
-                ...mockArgs,
-                formatOutputAsJson: true,
-            };
-            await projectInfoCommand.handler(jsonArgs);
-            expect(mockedUiLogger.json).toHaveBeenCalledWith(mockProjectInfo);
-            expect(mockedRenderProjectInfo).not.toHaveBeenCalled();
-        });
-        it('should render inline output when not in JSON mode', async () => {
-            await projectInfoCommand.handler(mockArgs);
-            expect(mockedRenderProjectInfo).toHaveBeenCalledWith(mockProjectInfo);
-            expect(mockedUiLogger.json).not.toHaveBeenCalled();
-        });
-    });
-});

package/commands/project/__tests__/installDeps.test.d.ts

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