@hubspot/cli 8.3.0 → 8.4.0-beta.0

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__/installDeps.test.d.ts

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

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

@@ -1,140 +0,0 @@
-import yargs from 'yargs';
-import path from 'path';
-import { uiLogger } from '../../../lib/ui/logger.js';
-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('../../../lib/projects/config');
-vi.mock('../../../lib/dependencyManagement');
-vi.mock('../../../lib/prompts/promptUtils');
-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(uiLogger.error).toHaveBeenCalledTimes(1);
-            expect(uiLogger.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(uiLogger.error).toHaveBeenCalledTimes(1);
-            expect(uiLogger.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(uiLogger.error).toHaveBeenCalledTimes(1);
-            expect(uiLogger.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__/lint.test.d.ts

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