@hubspot/cli 7.7.21-experimental.0 → 7.7.21-experimental.1

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

@@ -1,49 +1,55 @@
-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';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const config_1 = require("@hubspot/local-dev-lib/constants/config");
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+// import { HsProfileFile } from '@hubspot/project-parsing-lib/src/lib/types';
+const config_2 = require("@hubspot/local-dev-lib/config");
+const environment_1 = require("@hubspot/local-dev-lib/environment");
+const errorHandlers_1 = require("../../../lib/errorHandlers");
+const ensureProjectExists_1 = require("../../../lib/projects/ensureProjectExists");
+const helpers_1 = require("../../../lib/projects/localDev/helpers");
+const projectDevTargetAccountPrompt_1 = require("../../../lib/prompts/projectDevTargetAccountPrompt");
+const SpinniesManager_1 = __importDefault(require("../../../lib/ui/SpinniesManager"));
+const LocalDevProcess_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevProcess"));
+const LocalDevWatcher_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevWatcher"));
+const LocalDevWebsocketServer_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevWebsocketServer"));
+const process_1 = require("../../../lib/process");
+const accountTypes_1 = require("../../../lib/accountTypes");
+const ui_1 = require("../../../lib/ui");
+const logger_1 = require("../../../lib/ui/logger");
+const en_1 = require("../../../lang/en");
+const unifiedFlow_1 = require("../dev/unifiedFlow");
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+const vitest_1 = require("vitest");
 // Mock @hubspot/ui-extensions-dev-server
-vi.mock('@hubspot/ui-extensions-dev-server', () => ({
+vitest_1.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),
+        setup: vitest_1.vi.fn().mockResolvedValue(undefined),
+        start: vitest_1.vi.fn().mockResolvedValue(undefined),
+        fileChange: vitest_1.vi.fn().mockResolvedValue(undefined),
+        cleanup: vitest_1.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');
+vitest_1.vi.mock('@hubspot/project-parsing-lib');
+vitest_1.vi.mock('@hubspot/local-dev-lib/config');
+vitest_1.vi.mock('@hubspot/local-dev-lib/environment');
+vitest_1.vi.mock('../../../lib/errorHandlers');
+vitest_1.vi.mock('../../../lib/projects/ensureProjectExists');
+vitest_1.vi.mock('../../../lib/projects/localDev/helpers');
+vitest_1.vi.mock('../../../lib/prompts/projectDevTargetAccountPrompt');
+vitest_1.vi.mock('../../../lib/ui/SpinniesManager');
+vitest_1.vi.mock('../../../lib/projects/localDev/LocalDevProcess');
+vitest_1.vi.mock('../../../lib/projects/localDev/LocalDevWatcher');
+vitest_1.vi.mock('../../../lib/projects/localDev/LocalDevWebsocketServer');
+vitest_1.vi.mock('../../../lib/process');
+vitest_1.vi.mock('../../../lib/accountTypes');
+vitest_1.vi.mock('../../../lib/ui');
+vitest_1.vi.mock('../../../lib/ui/logger');
 describe('unifiedProjectDevFlow', () => {
     const mockArgs = {
         profile: 'test-profile',
@@ -61,16 +67,16 @@ describe('unifiedProjectDevFlow', () => {
         srcDir: 'src',
         platformVersion: '1.0.0',
     };
-    const mockProjectDir = '/test/project.js';
+    const mockProjectDir = '/test/project';
     const mockTargetProjectAccountId = 123;
     const mockProvidedTargetTestingAccountId = 456;
-    const mockProfileConfig = {
-        accountId: 789,
-    };
+    // const mockProfileConfig: HsProfileFile = {
+    //   accountId: 789,
+    // };
     const mockAccountConfig = {
         accountId: 123,
         name: 'test-account',
-        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+        accountType: config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD,
     };
     const mockProject = {
         id: 1,
@@ -93,58 +99,58 @@ describe('unifiedProjectDevFlow', () => {
         },
     };
     const mockLocalDevProcess = {
-        start: vi.fn().mockResolvedValue(undefined),
-        stop: vi.fn().mockResolvedValue(undefined),
+        start: vitest_1.vi.fn().mockResolvedValue(undefined),
+        stop: vitest_1.vi.fn().mockResolvedValue(undefined),
     };
     const mockLocalDevWatcher = {
-        start: vi.fn(),
-        stop: vi.fn().mockResolvedValue(undefined),
+        start: vitest_1.vi.fn(),
+        stop: vitest_1.vi.fn().mockResolvedValue(undefined),
     };
     const mockWebsocketServer = {
-        start: vi.fn().mockResolvedValue(undefined),
-        shutdown: vi.fn().mockResolvedValue(undefined),
+        start: vitest_1.vi.fn().mockResolvedValue(undefined),
+        shutdown: vitest_1.vi.fn().mockResolvedValue(undefined),
     };
     beforeEach(() => {
-        vi.clearAllMocks();
+        vitest_1.vi.clearAllMocks();
         // Mock process.exit
-        vi.spyOn(global.process, 'exit').mockImplementation((code) => {
+        vitest_1.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({
+        environment_1.getValidEnv.mockReturnValue(environments_1.ENVIRONMENTS.PROD);
+        project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
             intermediateNodesIndexedByUid: mockProjectNodes,
         });
-        getAccountConfig.mockReturnValue(mockAccountConfig);
-        getConfigAccounts.mockReturnValue([mockAccountConfig]);
-        isUnifiedAccount.mockResolvedValue(true);
-        isTestAccountOrSandbox.mockReturnValue(false);
-        ensureProjectExists.mockResolvedValue({
+        config_2.getAccountConfig.mockReturnValue(mockAccountConfig);
+        config_2.getConfigAccounts.mockReturnValue([mockAccountConfig]);
+        accountTypes_1.isUnifiedAccount.mockResolvedValue(true);
+        accountTypes_1.isTestAccountOrSandbox.mockReturnValue(false);
+        ensureProjectExists_1.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(() => { });
+        SpinniesManager_1.default.init.mockImplementation(() => { });
+        LocalDevProcess_1.default.mockImplementation(() => mockLocalDevProcess);
+        LocalDevWatcher_1.default.mockImplementation(() => mockLocalDevWatcher);
+        LocalDevWebsocketServer_1.default.mockImplementation(() => mockWebsocketServer);
+        process_1.handleKeypress.mockImplementation(() => { });
+        process_1.handleExit.mockImplementation(() => { });
+        logger_1.uiLogger.debug.mockImplementation(() => { });
+        logger_1.uiLogger.error.mockImplementation(() => { });
+        logger_1.uiLogger.log.mockImplementation(() => { });
+        ui_1.uiLine.mockImplementation(() => { });
     });
     describe('successful flow', () => {
         it('should complete successfully with existing project and provided testing account', async () => {
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(translateForLocalDev).toHaveBeenCalledWith({
-                projectSourceDir: path.join(mockProjectDir, mockProjectConfig.srcDir),
+            expect(project_parsing_lib_1.translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path_1.default.join(mockProjectDir, mockProjectConfig.srcDir),
                 platformVersion: mockProjectConfig.platformVersion,
                 accountId: mockTargetProjectAccountId,
             }, { profile: mockArgs.profile });
@@ -152,27 +158,30 @@ describe('unifiedProjectDevFlow', () => {
             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,
-            }));
-        });
+        // 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({
+            accountTypes_1.isTestAccountOrSandbox.mockReturnValue(true);
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
                 targetTestingAccountId: mockTargetProjectAccountId,
             }));
         });
@@ -180,145 +189,145 @@ describe('unifiedProjectDevFlow', () => {
     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({
+            project_parsing_lib_1.translateForLocalDev.mockRejectedValue(translationError);
+            await expect((0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             })).rejects.toThrow('Process.exit called with code 1');
-            expect(logError).toHaveBeenCalledWith(translationError);
+            expect(errorHandlers_1.logError).toHaveBeenCalledWith(translationError);
         });
         it('should exit with success when no runnable components found', async () => {
-            translateForLocalDev.mockResolvedValue({
+            project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
                 intermediateNodesIndexedByUid: {},
             });
-            await expect(unifiedProjectDevFlow({
+            await expect((0, unifiedFlow_1.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);
+            expect(logger_1.uiLogger.error).toHaveBeenCalledWith(en_1.commands.project.dev.errors.noRunnableComponents);
         });
         it('should exit with error when account config not found', async () => {
-            getAccountConfig.mockReturnValue(null);
-            await expect(unifiedProjectDevFlow({
+            config_2.getAccountConfig.mockReturnValue(null);
+            await expect((0, unifiedFlow_1.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));
+            expect(logger_1.uiLogger.error).toHaveBeenCalledWith(en_1.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({
+            accountTypes_1.isUnifiedAccount.mockResolvedValue(false);
+            await expect((0, unifiedFlow_1.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);
+            expect(logger_1.uiLogger.error).toHaveBeenCalledWith(en_1.commands.project.dev.errors.accountNotCombined);
         });
     });
     describe('account type selection and prompting', () => {
         beforeEach(() => {
             // Reset to require prompting
-            isTestAccountOrSandbox.mockReturnValue(false);
+            accountTypes_1.isTestAccountOrSandbox.mockReturnValue(false);
         });
         it('should prompt for account type when no testing account provided', async () => {
-            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
-            selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
+            projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
                 targetAccountId: 456,
             });
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(selectAccountTypePrompt).toHaveBeenCalledWith(mockAccountConfig);
-            expect(selectDeveloperTestTargetAccountPrompt).toHaveBeenCalled();
+            expect(helpers_1.selectAccountTypePrompt).toHaveBeenCalledWith(mockAccountConfig);
+            expect(projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt).toHaveBeenCalled();
         });
         it('should handle developer test account creation', async () => {
-            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
-            selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
+            projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
                 createNestedAccount: true,
             });
-            createDeveloperTestAccountForLocalDev.mockResolvedValue(999);
-            await unifiedProjectDevFlow({
+            helpers_1.createDeveloperTestAccountForLocalDev.mockResolvedValue(999);
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(createDeveloperTestAccountForLocalDev).toHaveBeenCalledWith(mockTargetProjectAccountId, mockAccountConfig, ENVIRONMENTS.PROD);
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
+            expect(helpers_1.createDeveloperTestAccountForLocalDev).toHaveBeenCalledWith(mockTargetProjectAccountId, mockAccountConfig, environments_1.ENVIRONMENTS.PROD, true);
+            expect(LocalDevProcess_1.default).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({
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
+            projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
                 notInConfigAccount,
             });
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(useExistingDevTestAccount).toHaveBeenCalledWith(ENVIRONMENTS.PROD, notInConfigAccount);
+            expect(helpers_1.useExistingDevTestAccount).toHaveBeenCalledWith(environments_1.ENVIRONMENTS.PROD, notInConfigAccount);
         });
         it('should handle sandbox account selection', async () => {
-            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
-            selectSandboxTargetAccountPrompt.mockResolvedValue({
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
+            projectDevTargetAccountPrompt_1.selectSandboxTargetAccountPrompt.mockResolvedValue({
                 targetAccountId: 888,
             });
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(selectSandboxTargetAccountPrompt).toHaveBeenCalled();
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
+            expect(projectDevTargetAccountPrompt_1.selectSandboxTargetAccountPrompt).toHaveBeenCalled();
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
                 targetTestingAccountId: 888,
             }));
         });
     });
     describe('project creation', () => {
         it('should create new project when project does not exist', async () => {
-            ensureProjectExists.mockResolvedValue({
+            ensureProjectExists_1.ensureProjectExists.mockResolvedValue({
                 projectExists: false,
                 project: null,
             });
-            createNewProjectForLocalDev.mockResolvedValue(mockProject);
-            createInitialBuildForNewProject.mockResolvedValue({
+            helpers_1.createNewProjectForLocalDev.mockResolvedValue(mockProject);
+            helpers_1.createInitialBuildForNewProject.mockResolvedValue({
                 buildId: 456,
             });
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.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);
+            expect(helpers_1.createNewProjectForLocalDev).toHaveBeenCalledWith(mockProjectConfig, mockTargetProjectAccountId, false, false);
+            expect(helpers_1.createInitialBuildForNewProject).toHaveBeenCalledWith(mockProjectConfig, mockProjectDir, mockTargetProjectAccountId, true, mockArgs.profile);
         });
         it('should use existing project and build when project exists', async () => {
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(createNewProjectForLocalDev).not.toHaveBeenCalled();
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
+            expect(helpers_1.createNewProjectForLocalDev).not.toHaveBeenCalled();
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
                 deployedBuild: mockProject.deployedBuild,
                 projectId: mockProject.id,
                 projectName: mockProject.name,
@@ -329,32 +338,32 @@ describe('unifiedProjectDevFlow', () => {
                 ...mockProject,
                 sourceIntegration: { source: 'GITHUB' },
             };
-            ensureProjectExists.mockResolvedValue({
+            ensureProjectExists_1.ensureProjectExists.mockResolvedValue({
                 projectExists: true,
                 project: githubLinkedProject,
             });
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
                 isGithubLinked: true,
             }));
         });
     });
     describe('local dev process setup', () => {
         it('should initialize LocalDevProcess with correct parameters', async () => {
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(LocalDevProcess).toHaveBeenCalledWith({
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith({
                 initialProjectNodes: mockProjectNodes,
                 debug: mockArgs.debug,
                 deployedBuild: mockProject.deployedBuild,
@@ -366,22 +375,22 @@ describe('unifiedProjectDevFlow', () => {
                 projectDir: mockProjectDir,
                 projectName: mockProject.name,
                 projectId: mockProject.id,
-                env: ENVIRONMENTS.PROD,
+                env: environments_1.ENVIRONMENTS.PROD,
             });
         });
         it('should set up keypress and exit handlers', async () => {
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(handleKeypress).toHaveBeenCalledWith(expect.any(Function));
-            expect(handleExit).toHaveBeenCalledWith(expect.any(Function));
+            expect(process_1.handleKeypress).toHaveBeenCalledWith(expect.any(Function));
+            expect(process_1.handleExit).toHaveBeenCalledWith(expect.any(Function));
         });
         it('should start all required services', async () => {
-            await unifiedProjectDevFlow({
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
@@ -391,24 +400,24 @@ describe('unifiedProjectDevFlow', () => {
             expect(mockLocalDevProcess.start).toHaveBeenCalled();
             expect(mockLocalDevWatcher.start).toHaveBeenCalled();
             expect(mockWebsocketServer.start).toHaveBeenCalled();
-            expect(SpinniesManager.init).toHaveBeenCalled();
+            expect(SpinniesManager_1.default.init).toHaveBeenCalled();
         });
     });
     describe('UI messaging', () => {
         beforeEach(() => {
-            isTestAccountOrSandbox.mockReturnValue(false);
+            accountTypes_1.isTestAccountOrSandbox.mockReturnValue(false);
         });
         it('should display account type information when prompting', async () => {
-            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.STANDARD);
-            await unifiedProjectDevFlow({
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD);
+            await (0, unifiedFlow_1.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);
+            expect(ui_1.uiLine).toHaveBeenCalled();
+            expect(logger_1.uiLogger.log).toHaveBeenCalledWith(en_1.commands.project.dev.logs.accountTypeInformation);
+            expect(logger_1.uiLogger.log).toHaveBeenCalledWith(en_1.commands.project.dev.logs.learnMoreMessage);
         });
     });
 });

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

@@ -1,33 +1,38 @@
-import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
-import projectDownloadCommand from '../download.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yargs_1 = __importDefault(require("yargs"));
+const commonOpts_1 = require("../../../lib/commonOpts");
+const download_1 = __importDefault(require("../download"));
 vi.mock('../../../lib/commonOpts');
 describe('commands/project/download', () => {
-    const yargsMock = yargs;
+    const yargsMock = yargs_1.default;
     describe('command', () => {
         it('should have the correct command structure', () => {
-            expect(projectDownloadCommand.command).toEqual('download');
+            expect(download_1.default.command).toEqual('download');
         });
     });
     describe('describe', () => {
         it('should provide a description', () => {
-            expect(projectDownloadCommand.describe).toBeDefined();
+            expect(download_1.default.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);
+            download_1.default.builder(yargsMock);
+            expect(commonOpts_1.addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts_1.addAccountOptions).toHaveBeenCalledWith(yargsMock);
+            expect(commonOpts_1.addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts_1.addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(commonOpts_1.addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts_1.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);
+            download_1.default.builder(yargsMock);
             expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
                 project: expect.any(Object),
                 dest: expect.any(Object),