@hubspot/cli 7.7.19-experimental.3 → 7.7.21-experimental.0

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

@@ -0,0 +1,414 @@
+import path from 'path';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { translateForLocalDev } from '@hubspot/project-parsing-lib';
+import { getConfigAccounts, getAccountConfig, } from '@hubspot/local-dev-lib/config';
+import { getValidEnv } from '@hubspot/local-dev-lib/environment';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
+import { createInitialBuildForNewProject, createNewProjectForLocalDev, useExistingDevTestAccount, createDeveloperTestAccountForLocalDev, selectAccountTypePrompt, } from '../../../lib/projects/localDev/helpers.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');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/environment');
+vi.mock('../../../lib/errorHandlers');
+vi.mock('../../../lib/projects/ensureProjectExists');
+vi.mock('../../../lib/projects/localDev/helpers');
+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');
+vi.mock('../../../lib/ui/logger');
+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 = {
+        accountId: 789,
+    };
+    const mockAccountConfig = {
+        accountId: 123,
+        name: 'test-account',
+        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+    };
+    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(() => {
+        vi.clearAllMocks();
+        // 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,
+        });
+        getAccountConfig.mockReturnValue(mockAccountConfig);
+        getConfigAccounts.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(() => { });
+    });
+    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();
+        });
+        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 () => {
+            getAccountConfig.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);
+            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({
+                deployedBuild: mockProject.deployedBuild,
+                projectId: mockProject.id,
+                projectName: mockProject.name,
+            }));
+        });
+        it('should detect GitHub linked projects', async () => {
+            const githubLinkedProject = {
+                ...mockProject,
+                sourceIntegration: { source: 'GITHUB' },
+            };
+            ensureProjectExists.mockResolvedValue({
+                projectExists: true,
+                project: githubLinkedProject,
+            });
+            await unifiedProjectDevFlow({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
+                isGithubLinked: true,
+            }));
+        });
+    });
+    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,
+                deployedBuild: mockProject.deployedBuild,
+                isGithubLinked: false,
+                profile: mockArgs.profile,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                targetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                projectName: mockProject.name,
+                projectId: mockProject.id,
+                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();
+            expect(SpinniesManager.init).toHaveBeenCalled();
+        });
+    });
+    describe('UI messaging', () => {
+        beforeEach(() => {
+            isTestAccountOrSandbox.mockReturnValue(false);
+        });
+        it('should display account type information when prompting', async () => {
+            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.STANDARD);
+            await unifiedProjectDevFlow({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(uiLine).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.accountTypeInformation);
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.learnMoreMessage);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,39 @@
+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__/fixtures/exampleProject.json

@@ -0,0 +1,33 @@
+{
+    "latestBuild": {
+        "activitySource": {
+            "userId": 123,
+            "type": "HUBSPOT"
+        },
+        "buildId": 8,
+        "createdAt": "123456",
+        "deployableState": "DEPLOYABLE",
+        "deployStatusTaskLocator": {
+            "id": "123",
+            "links": []
+        },
+        "enqueuedAt": "123456",
+        "finishedAt": "123456",
+        "isAutoDeployEnabled": true,
+        "portalId": 123,
+        "projectName": "project name",
+        "startedAt": "123456",
+        "status": "SUCCESS",
+        "subbuildStatuses": [],
+        "uploadMessage": "Upload message",
+        "autoDeployId": 123
+    },
+    "deployedBuildId": 1,
+    "createdAt": 123456,
+    "deletedAt": 123456,
+    "updatedAt": 123456,
+    "id": 123,
+    "isLocked": false,
+    "name": "project name",
+    "portalId": 123
+}

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

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

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

@@ -0,0 +1,142 @@
+import yargs from 'yargs';
+import path from 'path';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import * as projectUtils from '../../../lib/projects/config.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import * as dependencyManagement from '../../../lib/dependencyManagement.js';
+import * as promptUtils from '../../../lib/prompts/promptUtils.js';
+import projectInstallDepsCommand from '../installDeps.js';
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../../lib/projects/config');
+vi.mock('../../../lib/dependencyManagement');
+vi.mock('../../../lib/prompts/promptUtils');
+vi.mock('../../../lib/usageTracking');
+vi.mock('../../../lib/commonOpts');
+const exampleSpy = vi.spyOn(yargs, 'example');
+const processExitSpy = vi.spyOn(process, 'exit');
+const getProjectConfigSpy = vi.spyOn(projectUtils, 'getProjectConfig');
+const promptUserSpy = vi.spyOn(promptUtils, 'promptUser');
+const getProjectPackageJsonLocationsSpy = vi.spyOn(dependencyManagement, 'getProjectPackageJsonLocations');
+const installPackagesSpy = vi.spyOn(dependencyManagement, 'installPackages');
+describe('commands/project/installDeps', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(projectInstallDepsCommand.command).toEqual('install-deps [packages..]');
+        });
+    });
+    describe('describe', () => {
+        it('should not provide a description', () => {
+            expect(projectInstallDepsCommand.describe).toEqual(expect.stringMatching(/Install the dependencies for your project, or add a dependency to a subcomponent of a project/));
+        });
+    });
+    describe('builder', () => {
+        it('should provide examples', () => {
+            projectInstallDepsCommand.builder(yargs);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                derivedAccountId: 999999,
+            };
+            // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+            processExitSpy.mockImplementation(() => { });
+        });
+        it('should track the command usage', async () => {
+            await projectInstallDepsCommand.handler(args);
+            expect(trackCommandUsage).toHaveBeenCalledTimes(1);
+            expect(trackCommandUsage).toHaveBeenCalledWith('project-install-deps', undefined, args.derivedAccountId);
+        });
+        it('should handle exceptions', async () => {
+            const error = new Error('Something went super wrong');
+            getProjectConfigSpy.mockImplementationOnce(() => {
+                throw error;
+            });
+            await projectInstallDepsCommand.handler(args);
+            expect(logger.error).toHaveBeenCalledTimes(1);
+            expect(logger.error).toHaveBeenCalledWith(error.message);
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should log an error and exit when the project config is not defined', async () => {
+            getProjectConfigSpy.mockResolvedValueOnce({
+                projectDir: null,
+                projectConfig: null,
+            });
+            await projectInstallDepsCommand.handler(args);
+            expect(logger.error).toHaveBeenCalledTimes(1);
+            expect(logger.error).toHaveBeenCalledWith('No project detected. Run this command from a project directory.');
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should log an error and exit when the project config has no projectDir', async () => {
+            getProjectConfigSpy.mockResolvedValueOnce({
+                projectDir: null,
+                projectConfig: null,
+            });
+            await projectInstallDepsCommand.handler(args);
+            expect(logger.error).toHaveBeenCalledTimes(1);
+            expect(logger.error).toHaveBeenCalledWith('No project detected. Run this command from a project directory.');
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should prompt for input when packages is defined', async () => {
+            const projectDir = 'src';
+            getProjectConfigSpy.mockResolvedValue({
+                projectDir,
+                projectConfig: null,
+            });
+            const packageJsonLocation = path.join(projectDir, 'directory1');
+            promptUserSpy.mockResolvedValueOnce({
+                selectedInstallLocations: packageJsonLocation,
+            });
+            getProjectPackageJsonLocationsSpy.mockResolvedValue([
+                packageJsonLocation,
+            ]);
+            await projectInstallDepsCommand.handler({
+                ...args,
+                packages: ['@hubspot/local-dev-lib'],
+            });
+            expect(getProjectPackageJsonLocationsSpy).toHaveBeenCalledTimes(1);
+            expect(promptUserSpy).toHaveBeenCalledTimes(1);
+            expect(promptUserSpy).toHaveBeenCalledWith([
+                {
+                    name: 'selectedInstallLocations',
+                    type: 'checkbox',
+                    when: expect.any(Function),
+                    choices: [
+                        {
+                            name: 'directory1',
+                            value: packageJsonLocation,
+                        },
+                    ],
+                    message: 'Choose the project components to install the dependencies:',
+                    validate: expect.any(Function),
+                },
+            ]);
+        });
+        it('should call installPackages correctly', async () => {
+            const projectDir = 'src';
+            const packageJsonLocation = path.join(projectDir, 'directory1');
+            const installLocations = [packageJsonLocation];
+            const packages = ['@hubspot/local-dev-lib'];
+            getProjectConfigSpy.mockResolvedValue({
+                projectDir,
+                projectConfig: null,
+            });
+            promptUserSpy.mockResolvedValueOnce({
+                selectedInstallLocations: packageJsonLocation,
+            });
+            getProjectPackageJsonLocationsSpy.mockResolvedValue(installLocations);
+            await projectInstallDepsCommand.handler({ ...args, packages });
+            expect(installPackagesSpy).toHaveBeenCalledTimes(1);
+            expect(installPackagesSpy).toHaveBeenCalledWith({
+                packages,
+                installLocations: packageJsonLocation,
+            });
+        });
+    });
+});

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

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