@hubspot/cli 7.7.0-experimental.3 → 7.7.0

package/commands/open.js

@@ -1,49 +1,49 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const usageTracking_1 = require("../lib/usageTracking");
-const links_1 = require("../lib/links");
-const promptUtils_1 = require("../lib/prompts/promptUtils");
-const lang_1 = require("../lib/lang");
-const exitCodes_1 = require("../lib/enums/exitCodes");
-const yargsUtils_1 = require("../lib/yargsUtils");
+import { trackCommandUsage } from '../lib/usageTracking.js';
+import { logSiteLinks, getSiteLinksAsArray, openLink } from '../lib/links.js';
+import { promptUser } from '../lib/prompts/promptUtils.js';
+import { i18n } from '../lib/lang.js';
+import { EXIT_CODES } from '../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
 const separator = ' => ';
 async function createListPrompt(accountId) {
-    return (0, promptUtils_1.promptUser)([
-        {
-            type: 'rawlist',
-            name: 'open',
-            pageSize: 20,
-            message: (0, lang_1.i18n)('commands.open.selectLink'),
-            choices: (0, links_1.getSiteLinksAsArray)(accountId).map(l => `${l.shortcut}${separator}${l.url}`),
-            filter: val => val.split(separator)[0],
-        },
-    ]);
+    return promptUser({
+        name: 'open',
+        type: 'rawlist',
+        pageSize: 20,
+        message: i18n('commands.open.selectLink'),
+        choices: getSiteLinksAsArray(accountId)
+            .filter(l => !!l.url)
+            .map(l => ({
+            name: `${l.shortcut}${separator}${l.url}`,
+            value: l.shortcut,
+        })),
+    });
 }
 const command = 'open [shortcut]';
-const describe = (0, lang_1.i18n)('commands.open.describe');
+const describe = i18n('commands.open.describe');
 async function handler(args) {
     const { shortcut, list, derivedAccountId } = args;
-    (0, usageTracking_1.trackCommandUsage)('open', undefined, derivedAccountId);
+    trackCommandUsage('open', undefined, derivedAccountId);
     if (shortcut === undefined && !list) {
-        const choice = await createListPrompt(derivedAccountId);
-        (0, links_1.openLink)(derivedAccountId, choice.open);
+        const { open } = await createListPrompt(derivedAccountId);
+        openLink(derivedAccountId, open);
     }
     else if (list) {
-        (0, links_1.logSiteLinks)(derivedAccountId);
+        logSiteLinks(derivedAccountId);
     }
     else if (shortcut) {
-        (0, links_1.openLink)(derivedAccountId, shortcut);
+        openLink(derivedAccountId, shortcut);
     }
-    process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    process.exit(EXIT_CODES.SUCCESS);
 }
 function openBuilder(yargs) {
     yargs.positional('[shortcut]', {
-        describe: (0, lang_1.i18n)('commands.open.positionals.shortcut.describe'),
+        describe: i18n('commands.open.positionals.shortcut.describe'),
         type: 'string',
     });
     yargs.option('list', {
         alias: 'l',
-        describe: (0, lang_1.i18n)('commands.open.options.list.describe'),
+        describe: i18n('commands.open.options.list.describe'),
         type: 'boolean',
     });
     yargs.example([
@@ -55,7 +55,7 @@ function openBuilder(yargs) {
     ]);
     return yargs;
 }
-const builder = (0, yargsUtils_1.makeYargsBuilder)(openBuilder, command, describe, {
+const builder = makeYargsBuilder(openBuilder, command, describe, {
     useGlobalOptions: true,
     useConfigOptions: true,
     useAccountOptions: true,
@@ -67,6 +67,4 @@ const openCommand = {
     handler,
     builder,
 };
-exports.default = openCommand;
-// TODO Remove this legacy export once we've migrated all commands to TS
-module.exports = openCommand;
+export default openCommand;

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

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

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

@@ -0,0 +1,107 @@
+import yargs from 'yargs';
+import projectAddCommand from '../add.js';
+import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, } from '../../../lib/constants.js';
+import { v3AddComponent } from '../../../lib/projects/add/v3AddComponent.js';
+import { legacyAddComponent } from '../../../lib/projects/add/legacyAddComponent.js';
+import { getProjectConfig } from '../../../lib/projects/config.js';
+import { useV3Api } from '../../../lib/projects/platformVersion.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+vi.mock('../../../lib/commonOpts');
+vi.mock('../../../lib/projects/add/v3AddComponent');
+vi.mock('../../../lib/projects/add/legacyAddComponent');
+vi.mock('../../../lib/projects/config');
+vi.mock('../../../lib/projects/platformVersion');
+vi.mock('../../../lib/usageTracking');
+const mockedV3AddComponent = vi.mocked(v3AddComponent);
+const mockedLegacyAddComponent = vi.mocked(legacyAddComponent);
+const mockedGetProjectConfig = vi.mocked(getProjectConfig);
+const mockedUseV3Api = vi.mocked(useV3Api);
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
+describe('commands/project/add', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(projectAddCommand.command).toEqual('add');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(projectAddCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            projectAddCommand.builder(yargsMock);
+            expect(yargsMock.example).toHaveBeenCalledTimes(2);
+            expect(yargsMock.options).toHaveBeenCalledWith({
+                auth: expect.objectContaining({
+                    type: 'string',
+                    choices: expect.arrayContaining([staticAuth, oAuth]),
+                }),
+                distribution: expect.objectContaining({
+                    type: 'string',
+                    choices: expect.arrayContaining([
+                        privateDistribution,
+                        marketplaceDistribution,
+                    ]),
+                }),
+                features: expect.objectContaining({
+                    type: 'array',
+                }),
+                name: expect.objectContaining({
+                    type: 'string',
+                }),
+                type: expect.objectContaining({ type: 'string' }),
+            });
+        });
+    });
+    describe('handler', () => {
+        const mockProjectConfig = {
+            name: 'test-project',
+            srcDir: 'src',
+            platformVersion: 'v3',
+        };
+        const mockProjectDir = '/path/to/project';
+        const mockArgs = {
+            derivedAccountId: 123,
+            name: 'test-component',
+            type: 'module',
+        };
+        beforeEach(() => {
+            mockedGetProjectConfig.mockResolvedValue({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            mockedTrackCommandUsage.mockResolvedValue();
+            mockedV3AddComponent.mockResolvedValue();
+            mockedLegacyAddComponent.mockResolvedValue();
+            vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error('process.exit called');
+            });
+        });
+        it('should call v3AddComponent with accountId for v3 projects', async () => {
+            mockedUseV3Api.mockReturnValue(true);
+            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
+            expect(mockedV3AddComponent).toHaveBeenCalledWith(mockArgs, mockProjectDir, mockProjectConfig, 123);
+            expect(mockedLegacyAddComponent).not.toHaveBeenCalled();
+        });
+        it('should call legacyAddComponent for non-v3 projects', async () => {
+            mockedUseV3Api.mockReturnValue(false);
+            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
+            expect(mockedLegacyAddComponent).toHaveBeenCalledWith(mockArgs, mockProjectDir, mockProjectConfig, 123);
+            expect(mockedV3AddComponent).not.toHaveBeenCalled();
+        });
+        it('should exit with error when project config is not found', async () => {
+            mockedGetProjectConfig.mockResolvedValue({
+                projectConfig: null,
+                projectDir: null,
+            });
+            const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error('process.exit called');
+            });
+            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
+            expect(mockExit).toHaveBeenCalledWith(1);
+            mockExit.mockRestore();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,97 @@
+import yargs from 'yargs';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import projectCreateCommand from '../create.js';
+vi.mock('../../../lib/commonOpts');
+describe('commands/project/create', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(projectCreateCommand.command).toEqual(['create', 'init']);
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(projectCreateCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            projectCreateCommand.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 creation options', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            const exampleSpy = vi.spyOn(yargsMock, 'example');
+            const conflictsSpy = vi.spyOn(yargsMock, 'conflicts');
+            projectCreateCommand.builder(yargsMock);
+            expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
+                name: expect.any(Object),
+                dest: expect.any(Object),
+                template: expect.any(Object),
+                'template-source': expect.any(Object),
+                'platform-version': expect.any(Object),
+                'project-base': expect.any(Object),
+                distribution: expect.any(Object),
+                auth: expect.any(Object),
+                features: expect.any(Object),
+            }));
+            expect(conflictsSpy).toHaveBeenCalledWith('template', 'features');
+            expect(exampleSpy).toHaveBeenCalled();
+        });
+        it('should define platform version option with correct choices', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall['platform-version']).toEqual(expect.objectContaining({
+                describe: 'The target platform version for the new project.',
+                type: 'string',
+                choices: ['2023.2', '2025.1', '2025.2'],
+                default: '2025.2',
+            }));
+        });
+        it('should define project base option with correct choices', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall['project-base']).toEqual(expect.objectContaining({
+                describe: 'The top level component to include in the project.',
+                type: 'string',
+                choices: ['empty', 'app'],
+            }));
+        });
+        it('should define distribution option with correct choices', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall.distribution).toEqual(expect.objectContaining({
+                describe: 'How the app will be distributed.',
+                type: 'string',
+                choices: ['private', 'marketplace'],
+            }));
+        });
+        it('should define auth option with correct choices', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall.auth).toEqual(expect.objectContaining({
+                describe: 'Authentication model for the application.',
+                type: 'string',
+                choices: ['oauth', 'static'],
+            }));
+        });
+        it('should define features option as array', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall.features).toEqual(expect.objectContaining({
+                describe: 'Features to include in the project. Only valid if project-base is app',
+                type: 'array',
+            }));
+        });
+    });
+});

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

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

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

@@ -0,0 +1,306 @@
+import { HttpStatusCode } from 'axios';
+import yargs from 'yargs';
+import chalk from 'chalk';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import * as configUtils from '@hubspot/local-dev-lib/config';
+import * as projectApiUtils from '@hubspot/local-dev-lib/api/projects';
+import * as ui from '../../../lib/ui/index.js';
+import { addAccountOptions, addConfigOptions, addJSONOutputOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import * as projectUtils from '../../../lib/projects/config.js';
+import * as projectUrlUtils from '../../../lib/projects/urls.js';
+import { pollDeployStatus } from '../../../lib/projects/pollProjectBuildAndDeploy.js';
+import * as projectNamePrompt from '../../../lib/prompts/projectNamePrompt.js';
+import * as promptUtils from '../../../lib/prompts/promptUtils.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import exampleProject from './fixtures/exampleProject.json' with { type: 'json' };
+import { mockHubSpotHttpResponse, mockHubSpotHttpError, } from '../../../lib/testUtils.js';
+import projectDeployCommand from '../deploy.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../lib/commonOpts');
+vi.mock('../../../lib/validation');
+vi.mock('../../../lib/projects/config');
+vi.mock('../../../lib/projects/urls');
+vi.mock('../../../lib/projects/pollProjectBuildAndDeploy');
+vi.mock('../../../lib/projects/platformVersion');
+vi.mock('../../../lib/prompts/projectNamePrompt');
+vi.mock('../../../lib/prompts/promptUtils');
+vi.mock('../../../lib/usageTracking');
+vi.mock('../../../lib/ui/logger');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.spyOn(ui, 'uiLine');
+const uiCommandReferenceSpy = vi.spyOn(ui, 'uiCommandReference');
+const uiAccountDescriptionSpy = vi.spyOn(ui, 'uiAccountDescription');
+const getProjectConfigSpy = vi.spyOn(projectUtils, 'getProjectConfig');
+const projectNamePromptSpy = vi.spyOn(projectNamePrompt, 'projectNamePrompt');
+const getProjectDetailUrlSpy = vi.spyOn(projectUrlUtils, 'getProjectDetailUrl');
+const fetchProjectSpy = vi.spyOn(projectApiUtils, 'fetchProject');
+const deployProjectSpy = vi.spyOn(projectApiUtils, 'deployProject');
+const getAccountConfigSpy = vi.spyOn(configUtils, 'getAccountConfig');
+const promptUserSpy = vi.spyOn(promptUtils, 'promptUser');
+const processExitSpy = vi.spyOn(process, 'exit');
+const optionsSpy = vi
+    .spyOn(yargs, 'options')
+    .mockReturnValue(yargs);
+const exampleSpy = vi
+    .spyOn(yargs, 'example')
+    .mockReturnValue(yargs);
+const conflictsSpy = vi
+    .spyOn(yargs, 'conflicts')
+    .mockReturnValue(yargs);
+describe('commands/project/deploy', () => {
+    const projectFlag = 'project';
+    const buildFlag = 'build';
+    const deployLatestBuildFlag = 'deployLatestBuild';
+    const profileFlag = 'profile';
+    const forceFlag = 'force';
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(projectDeployCommand.command).toEqual('deploy');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(projectDeployCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            projectDeployCommand.builder(yargs);
+            expect(conflictsSpy).toHaveBeenCalledTimes(2);
+            expect(conflictsSpy).toHaveBeenNthCalledWith(1, profileFlag, projectFlag);
+            expect(conflictsSpy).toHaveBeenNthCalledWith(2, profileFlag, 'account');
+            expect(optionsSpy).toHaveBeenCalledTimes(1);
+            expect(optionsSpy).toHaveBeenCalledWith({
+                [projectFlag]: expect.objectContaining({ type: 'string' }),
+                [buildFlag]: expect.objectContaining({
+                    alias: ['build-id'],
+                    type: 'number',
+                }),
+                [deployLatestBuildFlag]: expect.objectContaining({
+                    type: 'boolean',
+                    alias: ['deploy-latest-build'],
+                    default: false,
+                }),
+                [profileFlag]: expect.objectContaining({
+                    type: 'string',
+                    alias: ['p'],
+                    hidden: true,
+                }),
+                [forceFlag]: expect.objectContaining({
+                    type: 'boolean',
+                    alias: ['f'],
+                }),
+            });
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargs);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargs);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargs);
+            expect(addJSONOutputOptions).toHaveBeenCalledTimes(1);
+            expect(addJSONOutputOptions).toHaveBeenCalledWith(yargs);
+        });
+        it('should provide examples', () => {
+            projectDeployCommand.builder(yargs);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('handler', () => {
+        let projectConfig;
+        const accountType = 'STANDARD';
+        let args;
+        const projectNameFromPrompt = 'project name from prompt';
+        const deployDetails = {
+            id: 123,
+            buildResultType: 'DEPLOY_QUEUED',
+        };
+        const projectDetailUrl = 'http://project-details-page-url.com';
+        beforeEach(() => {
+            args = {
+                project: 'project name from options',
+                buildId: 2,
+                derivedAccountId: 1234567890,
+            };
+            projectConfig = {
+                name: 'project name from config',
+                srcDir: 'src',
+                platformVersion: '2025',
+            };
+            getProjectConfigSpy.mockResolvedValue({
+                projectConfig,
+                projectDir: 'projectDir',
+            });
+            projectNamePromptSpy.mockResolvedValue({
+                projectName: projectNameFromPrompt,
+            });
+            getProjectDetailUrlSpy.mockReturnValue(projectDetailUrl);
+            getAccountConfigSpy.mockReturnValue({ accountType, env: 'qa' });
+            fetchProjectSpy.mockReturnValue(mockHubSpotHttpResponse(exampleProject));
+            deployProjectSpy.mockReturnValue(mockHubSpotHttpResponse(deployDetails));
+            // Spy on process.exit so our tests don't close when it's called
+            // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+            processExitSpy.mockImplementation(() => { });
+        });
+        it('should load the account config for the correct account id', async () => {
+            await projectDeployCommand.handler(args);
+            expect(getAccountConfigSpy).toHaveBeenCalledTimes(1);
+            expect(getAccountConfigSpy).toHaveBeenCalledWith(args.derivedAccountId);
+        });
+        it('should track the command usage', async () => {
+            await projectDeployCommand.handler(args);
+            expect(trackCommandUsage).toHaveBeenCalledTimes(1);
+            expect(trackCommandUsage).toHaveBeenCalledWith('project-deploy', { type: accountType }, args.derivedAccountId);
+        });
+        it('should load the project config', async () => {
+            await projectDeployCommand.handler(args);
+            expect(getProjectConfigSpy).toHaveBeenCalledTimes(1);
+            expect(getProjectConfigSpy).toHaveBeenCalled();
+        });
+        it('should prompt for the project name', async () => {
+            await projectDeployCommand.handler(args);
+            expect(projectNamePromptSpy).toHaveBeenCalledTimes(1);
+            expect(projectNamePromptSpy).toHaveBeenCalledWith(args.derivedAccountId, {
+                project: args.project,
+            });
+        });
+        it('should use the project name from the config is a project args is not provided', async () => {
+            delete args.project;
+            await projectDeployCommand.handler(args);
+            expect(projectNamePromptSpy).toHaveBeenCalledTimes(1);
+            expect(projectNamePromptSpy).toHaveBeenCalledWith(args.derivedAccountId, {
+                project: projectConfig.name,
+            });
+        });
+        it('should fetch the project details', async () => {
+            await projectDeployCommand.handler(args);
+            expect(fetchProjectSpy).toHaveBeenCalledTimes(1);
+            expect(fetchProjectSpy).toHaveBeenCalledWith(args.derivedAccountId, projectNameFromPrompt);
+        });
+        it('should use the name from the prompt if no others are defined', async () => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { project: __project, ...argsWithoutProject } = args;
+            const promptProjectName = 'project name from the prompt';
+            projectNamePromptSpy.mockResolvedValue({
+                projectName: promptProjectName,
+            });
+            getProjectConfigSpy.mockResolvedValue({
+                projectConfig: null,
+                projectDir: null,
+            });
+            await projectDeployCommand.handler(argsWithoutProject);
+            expect(projectNamePromptSpy).toHaveBeenCalledTimes(1);
+            expect(projectNamePromptSpy).toHaveBeenCalledWith(args.derivedAccountId, {});
+            expect(fetchProjectSpy).toHaveBeenCalledTimes(1);
+            expect(fetchProjectSpy).toHaveBeenCalledWith(args.derivedAccountId, promptProjectName);
+        });
+        it('should log an error and exit when latest build is not defined', async () => {
+            fetchProjectSpy.mockReturnValue(mockHubSpotHttpResponse({}));
+            await projectDeployCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledWith('Deploy error: no builds for this project were found.');
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should log an error and exit when buildId option is not a valid build', async () => {
+            args.buildId = exampleProject.latestBuild.buildId + 1;
+            await projectDeployCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(`Build ${args.buildId} does not exist for project`));
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should log an error and exit when buildId option is already deployed', async () => {
+            args.buildId = exampleProject.deployedBuildId;
+            await projectDeployCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(`Build ${args.buildId} is already deployed. View project builds in HubSpot.`));
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should prompt for build id if no option is provided', async () => {
+            delete args.buildId;
+            promptUserSpy.mockResolvedValue({
+                buildId: exampleProject.latestBuild.buildId,
+            });
+            await projectDeployCommand.handler(args);
+            expect(promptUserSpy).toHaveBeenCalledTimes(1);
+        });
+        it('should log an error and exit if the prompted value is invalid', async () => {
+            delete args.buildId;
+            promptUserSpy.mockResolvedValue({});
+            await projectDeployCommand.handler(args);
+            expect(promptUserSpy).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledWith('You must specify a build to deploy');
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should deploy the project', async () => {
+            await projectDeployCommand.handler(args);
+            expect(deployProjectSpy).toHaveBeenCalledTimes(1);
+            expect(deployProjectSpy).toHaveBeenCalledWith(args.derivedAccountId, projectNameFromPrompt, args.buildId, undefined, undefined);
+        });
+        it('should log an error and exit when the deploy fails', async () => {
+            // @ts-expect-error Testing an edge case where the response is empty
+            deployProjectSpy.mockResolvedValue({});
+            await projectDeployCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledWith(`Deploy error: an unknown error occurred.`);
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should poll the deploy status', async () => {
+            await projectDeployCommand.handler(args);
+            expect(pollDeployStatus).toHaveBeenCalledTimes(1);
+            expect(pollDeployStatus).toHaveBeenCalledWith(args.derivedAccountId, projectNameFromPrompt, deployDetails.id, args.buildId);
+        });
+        it('log an error and exit if a 404 status is returned', async () => {
+            const commandReference = 'hs project upload';
+            const accountDescription = 'SuperCoolTestAccount';
+            uiCommandReferenceSpy.mockReturnValueOnce(commandReference);
+            uiAccountDescriptionSpy.mockReturnValueOnce(accountDescription);
+            fetchProjectSpy.mockImplementation(() => {
+                throw mockHubSpotHttpError('OH NO', {
+                    status: HttpStatusCode.NotFound,
+                    data: {},
+                });
+            });
+            await projectDeployCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledWith(`The project ${chalk.bold(projectNameFromPrompt)} does not exist in account ${accountDescription}. Run ${commandReference} to upload your project files to HubSpot.`);
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('log an error and exit if a 400 status is returned', async () => {
+            const errorMessage = 'Something bad happened';
+            fetchProjectSpy.mockImplementation(() => {
+                throw mockHubSpotHttpError(errorMessage, {
+                    status: HttpStatusCode.BadRequest,
+                    data: {},
+                });
+            });
+            await projectDeployCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledWith('The request was bad.');
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('log an error another unexpected status code is returned', async () => {
+            const errorMessage = 'Something bad happened';
+            fetchProjectSpy.mockImplementation(() => {
+                throw mockHubSpotHttpError(errorMessage, {
+                    status: HttpStatusCode.MethodNotAllowed,
+                    data: {},
+                });
+            });
+            await projectDeployCommand.handler(args);
+            expect(logger.error).toHaveBeenCalledTimes(1);
+            expect(logger.error).toHaveBeenCalledWith(`The request for 'project deploy' in account ${args.derivedAccountId} failed due to a client error.`);
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
+});

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

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