@hubspot/cli 7.7.0-experimental.2 → 7.7.0

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

@@ -0,0 +1,205 @@
+import yargs from 'yargs';
+import { addUseEnvironmentOptions } from '../../../lib/commonOpts.js';
+import { ProjectLogsManager } from '../../../lib/projects/ProjectLogsManager.js';
+import * as projectLogsPrompt from '../../../lib/prompts/projectsLogsPrompt.js';
+import * as table from '../../../lib/ui/table.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import * as ui from '../../../lib/ui/index.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import projectLogsCommand from '../logs.js';
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../../lib/commonOpts');
+vi.mock('../../../lib/usageTracking');
+vi.mock('../../../lib/validation');
+vi.mock('../../../lib/projects/ProjectLogsManager');
+vi.mock('../../../lib/prompts/projectsLogsPrompt');
+vi.mock('../../../lib/ui/table');
+vi.mock('../../../lib/errorHandlers');
+const uiLinkSpy = vi.spyOn(ui, 'uiLink');
+const uiLineSpy = vi.spyOn(ui, 'uiLine');
+const processExitSpy = vi.spyOn(process, 'exit');
+const projectLogsPromptSpy = vi.spyOn(projectLogsPrompt, 'projectLogsPrompt');
+const projectLogsManagerSetFunctionSpy = vi.spyOn(ProjectLogsManager, 'setFunction');
+const projectLogsManagerGetFunctionNamesSpy = vi.spyOn(ProjectLogsManager, 'getFunctionNames');
+const projectLogsManagerInitSpy = vi.spyOn(ProjectLogsManager, 'init');
+const getTableHeaderSpy = vi.spyOn(table, 'getTableHeader');
+const getTableContentsSpy = vi.spyOn(table, 'getTableContents');
+const optionsSpy = vi
+    .spyOn(yargs, 'options')
+    .mockReturnValue(yargs);
+const conflictsSpy = vi
+    .spyOn(yargs, 'conflicts')
+    .mockReturnValue(yargs);
+const exampleSpy = vi
+    .spyOn(yargs, 'example')
+    .mockReturnValue(yargs);
+describe('commands/project/logs', () => {
+    beforeEach(() => {
+        // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+        processExitSpy.mockImplementation(() => { });
+    });
+    describe('command', () => {
+        it('should have the correct command structure', async () => {
+            expect(projectLogsCommand.command).toEqual('logs');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(projectLogsCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            projectLogsCommand.builder(yargs);
+            expect(optionsSpy).toHaveBeenCalledTimes(1);
+            expect(optionsSpy).toHaveBeenCalledWith({
+                function: expect.objectContaining({
+                    alias: 'function',
+                    requiresArg: true,
+                    type: 'string',
+                }),
+                latest: expect.objectContaining({
+                    alias: 'l',
+                    type: 'boolean',
+                }),
+                compact: expect.objectContaining({
+                    type: 'boolean',
+                }),
+                tail: expect.objectContaining({
+                    alias: ['t', 'follow'],
+                    type: 'boolean',
+                }),
+                limit: expect.objectContaining({
+                    type: 'number',
+                }),
+            });
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargs);
+        });
+        it('should set the correct conflicts', () => {
+            projectLogsCommand.builder(yargs);
+            expect(conflictsSpy).toHaveBeenCalledTimes(1);
+            expect(conflictsSpy).toHaveBeenCalledWith('tail', 'limit');
+        });
+        it('should provide examples', () => {
+            projectLogsCommand.builder(yargs);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('handler', () => {
+        let options;
+        beforeEach(() => {
+            options = {
+                derivedAccountId: 12345678,
+            };
+            projectLogsPromptSpy.mockResolvedValue({ functionName: 'foo' });
+        });
+        it('should track the command usage', async () => {
+            await projectLogsCommand.handler(options);
+            expect(trackCommandUsage).toHaveBeenCalledTimes(1);
+            expect(trackCommandUsage).toHaveBeenCalledWith('project-logs', undefined, options.derivedAccountId);
+        });
+        it('should initialize the ProjectLogsManager', async () => {
+            await projectLogsCommand.handler(options);
+            expect(projectLogsManagerInitSpy).toHaveBeenCalledTimes(1);
+            expect(projectLogsManagerInitSpy).toHaveBeenCalledWith(options.derivedAccountId);
+        });
+        it('should prompt the user for input', async () => {
+            const functionNames = ['function1', 'function2'];
+            projectLogsManagerGetFunctionNamesSpy.mockReturnValue(functionNames);
+            await projectLogsCommand.handler(options);
+            expect(projectLogsPromptSpy).toHaveBeenCalledTimes(1);
+            expect(projectLogsPromptSpy).toHaveBeenCalledWith({
+                functionChoices: functionNames,
+                promptOptions: options,
+            });
+        });
+        it('should set the function', async () => {
+            const selectedFunction = 'function1';
+            projectLogsManagerGetFunctionNamesSpy.mockReturnValue([
+                selectedFunction,
+                'function2',
+            ]);
+            projectLogsPromptSpy.mockResolvedValue({
+                functionName: selectedFunction,
+            });
+            await projectLogsCommand.handler(options);
+            expect(projectLogsManagerSetFunctionSpy).toHaveBeenCalledTimes(1);
+            expect(projectLogsManagerSetFunctionSpy).toHaveBeenCalledWith(selectedFunction);
+        });
+        it('should log public functions correctly', async () => {
+            const functionNames = ['function1', 'function2'];
+            const selectedFunction = 'function1';
+            projectLogsManagerGetFunctionNamesSpy.mockReturnValue(functionNames);
+            projectLogsPromptSpy.mockResolvedValue({
+                functionName: selectedFunction,
+            });
+            const tableHeaders = ['Header 1', 'Header 2'];
+            getTableHeaderSpy.mockReturnValue(tableHeaders);
+            ProjectLogsManager.isPublicFunction = true;
+            ProjectLogsManager.accountId = options.derivedAccountId;
+            ProjectLogsManager.functionName = selectedFunction;
+            ProjectLogsManager.endpointName = 'my-endpoint';
+            ProjectLogsManager.appId = 123456;
+            await projectLogsCommand.handler(options);
+            expect(getTableHeaderSpy).toHaveBeenCalledTimes(1);
+            expect(getTableHeaderSpy).toHaveBeenCalledWith([
+                'Account',
+                'Function',
+                'Endpoint',
+            ]);
+            expect(getTableContentsSpy).toHaveBeenCalledTimes(1);
+            expect(getTableContentsSpy).toHaveBeenCalledWith([
+                tableHeaders,
+                [
+                    ProjectLogsManager.accountId,
+                    ProjectLogsManager.functionName,
+                    ProjectLogsManager.endpointName,
+                ],
+            ], { border: { bodyLeft: '  ' } });
+            expect(uiLinkSpy).toHaveBeenCalledTimes(1);
+            expect(uiLinkSpy).toHaveBeenCalledWith('View function logs in HubSpot', `https://app.hubspot.com/private-apps/${options.derivedAccountId}/${ProjectLogsManager.appId}/logs/serverlessGatewayExecution?path=${ProjectLogsManager.endpointName}`);
+            expect(uiLineSpy).toHaveBeenCalledTimes(1);
+        });
+        it('should log private functions correctly', async () => {
+            const functionNames = ['function1', 'function2'];
+            const selectedFunction = 'function1';
+            projectLogsManagerGetFunctionNamesSpy.mockReturnValue(functionNames);
+            projectLogsPromptSpy.mockResolvedValue({
+                functionName: selectedFunction,
+            });
+            const tableHeaders = ['Header 1', 'Header 2'];
+            getTableHeaderSpy.mockReturnValue(tableHeaders);
+            ProjectLogsManager.isPublicFunction = false;
+            ProjectLogsManager.accountId = options.derivedAccountId;
+            ProjectLogsManager.functionName = selectedFunction;
+            ProjectLogsManager.appId = 456789;
+            await projectLogsCommand.handler(options);
+            expect(getTableHeaderSpy).toHaveBeenCalledTimes(1);
+            expect(getTableHeaderSpy).toHaveBeenCalledWith(['Account', 'Function']);
+            expect(getTableContentsSpy).toHaveBeenCalledTimes(1);
+            expect(getTableContentsSpy).toHaveBeenCalledWith([
+                tableHeaders,
+                [ProjectLogsManager.accountId, ProjectLogsManager.functionName],
+            ], { border: { bodyLeft: '  ' } });
+            expect(uiLinkSpy).toHaveBeenCalledWith('View function logs in HubSpot', `https://app.hubspot.com/private-apps/${options.derivedAccountId}/${ProjectLogsManager.appId}/logs/crm?serverlessFunction=${selectedFunction}`);
+            expect(uiLineSpy).toHaveBeenCalledTimes(1);
+        });
+        it('should handle errors correctly', async () => {
+            const error = new Error('Something went wrong');
+            projectLogsManagerInitSpy.mockImplementation(() => {
+                throw error;
+            });
+            ProjectLogsManager.projectName = 'Super cool project';
+            await projectLogsCommand.handler(options);
+            expect(logError).toHaveBeenCalledTimes(1);
+            expect(logError).toHaveBeenCalledWith(error, {
+                accountId: options.derivedAccountId,
+                projectName: ProjectLogsManager.projectName,
+            });
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,110 @@
+import yargs from 'yargs';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { PLATFORM_VERSIONS } from '@hubspot/local-dev-lib/constants/projects';
+import migrateCommand from '../migrate.js';
+import { migrateApp2025_2 } from '../../../lib/app/migrate.js';
+import { getProjectConfig } from '../../../lib/projects/config.js';
+import { commands } from '../../../lang/en.js';
+import { uiBetaTag, uiCommandReference } from '../../../lib/ui/index.js';
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../../lib/app/migrate');
+vi.mock('../../../lib/projects/config');
+vi.mock('../../../lib/ui');
+const { v2025_2 } = PLATFORM_VERSIONS;
+describe('commands/project/migrate', () => {
+    const yargsMock = yargs;
+    const optionsSpy = vi.spyOn(yargsMock, 'option').mockReturnValue(yargsMock);
+    // Mock the imported functions
+    const migrateApp2025_2Mock = migrateApp2025_2;
+    const getProjectConfigMock = getProjectConfig;
+    const uiBetaTagMock = uiBetaTag;
+    const uiCommandReferenceMock = uiCommandReference;
+    const mockExit = vi
+        .spyOn(process, 'exit')
+        .mockImplementation(() => undefined);
+    beforeEach(() => {
+        // Mock logger methods
+        vi.spyOn(logger, 'log').mockImplementation(() => { });
+        vi.spyOn(logger, 'error').mockImplementation(() => { });
+        migrateApp2025_2Mock.mockResolvedValue(undefined);
+        getProjectConfigMock.mockResolvedValue({
+            projectConfig: { name: 'test-project' },
+        });
+        uiBetaTagMock.mockReturnValue('beta test description');
+        uiCommandReferenceMock.mockReturnValue('command reference');
+        mockExit.mockClear();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(migrateCommand.command).toEqual('migrate');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(migrateCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            migrateCommand.builder(yargsMock);
+            expect(optionsSpy).toHaveBeenCalledWith('platform-version', {
+                type: 'string',
+                choices: [v2025_2],
+                default: v2025_2,
+            });
+            expect(optionsSpy).toHaveBeenCalledWith('unstable', {
+                type: 'boolean',
+                default: false,
+                hidden: true,
+            });
+        });
+    });
+    describe('handler', () => {
+        let options;
+        beforeEach(() => {
+            options = {
+                platformVersion: v2025_2,
+                unstable: false,
+                derivedAccountId: 123,
+            };
+        });
+        it('should exit with error if no project config exists', async () => {
+            getProjectConfigMock.mockResolvedValue({ projectConfig: null });
+            await migrateCommand.handler(options);
+            expect(logger.error).toHaveBeenCalledWith(commands.project.migrate.errors.noProjectConfig('command reference'));
+            expect(mockExit).toHaveBeenCalledWith(1);
+            expect(mockExit).toHaveBeenCalledTimes(1);
+        });
+        it('should call migrateApp2025_2 with correct parameters', async () => {
+            await migrateCommand.handler(options);
+            expect(migrateApp2025_2Mock).toHaveBeenCalledWith(123, {
+                ...options,
+                name: 'test-project',
+                platformVersion: v2025_2,
+            }, { projectConfig: { name: 'test-project' } });
+            expect(mockExit).toHaveBeenCalledWith(0);
+            expect(mockExit).toHaveBeenCalledTimes(1);
+        });
+        it('should use unstable platform version when unstable flag is true', async () => {
+            options.unstable = true;
+            await migrateCommand.handler(options);
+            expect(migrateApp2025_2Mock).toHaveBeenCalledWith(123, {
+                ...options,
+                name: 'test-project',
+                platformVersion: PLATFORM_VERSIONS.unstable,
+            }, { projectConfig: { name: 'test-project' } });
+            expect(mockExit).toHaveBeenCalledWith(0);
+            expect(mockExit).toHaveBeenCalledTimes(1);
+        });
+        it('should handle errors and exit with error code', async () => {
+            const error = new Error('Test error');
+            migrateApp2025_2Mock.mockRejectedValue(error);
+            await migrateCommand.handler(options);
+            expect(mockExit).toHaveBeenCalledWith(1);
+            expect(mockExit).toHaveBeenCalledTimes(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,81 @@
+import yargs from 'yargs';
+import { i18n } from '../../../lib/lang.js';
+import { uiCommandReference, uiDeprecatedTag } from '../../../lib/ui/index.js';
+import { handlerGenerator } from '../../app/migrate.js';
+import { PLATFORM_VERSIONS } from '@hubspot/local-dev-lib/constants/projects';
+import migrateAppCommand from '../migrateApp.js';
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../../lib/lang');
+vi.mock('../../../lib/ui');
+vi.mock('../../app/migrate');
+const { v2023_2, v2025_2 } = PLATFORM_VERSIONS;
+describe('commands/project/migrateApp', () => {
+    const yargsMock = yargs;
+    const optionsSpy = vi.spyOn(yargsMock, 'options').mockReturnValue(yargsMock);
+    const exampleSpy = vi.spyOn(yargsMock, 'example').mockReturnValue(yargsMock);
+    // Mock the imported functions
+    const i18nMock = i18n;
+    const uiDeprecatedTagMock = uiDeprecatedTag;
+    const uiCommandReferenceMock = uiCommandReference;
+    const handlerGeneratorMock = handlerGenerator;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        i18nMock.mockReturnValue('test description');
+        uiDeprecatedTagMock.mockReturnValue('deprecated test description');
+        uiCommandReferenceMock.mockReturnValue('command reference');
+        handlerGeneratorMock.mockReturnValue(vi.fn().mockResolvedValue(undefined));
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(migrateAppCommand.command).toEqual('migrate-app');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(migrateAppCommand.describe).toBe(undefined);
+        });
+        it('should be marked as deprecated', () => {
+            expect(migrateAppCommand.deprecated).toBe(true);
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            migrateAppCommand.builder(yargsMock);
+            expect(optionsSpy).toHaveBeenCalledWith({
+                name: expect.objectContaining({
+                    describe: expect.any(String),
+                    type: 'string',
+                }),
+                dest: expect.objectContaining({
+                    describe: expect.any(String),
+                    type: 'string',
+                }),
+                'app-id': expect.objectContaining({
+                    describe: expect.any(String),
+                    type: 'number',
+                }),
+                'platform-version': expect.objectContaining({
+                    type: 'string',
+                    choices: [v2023_2, v2025_2],
+                    default: v2025_2,
+                }),
+            });
+            expect(exampleSpy).toHaveBeenCalled();
+        });
+    });
+    describe('handler', () => {
+        let options;
+        const mockLocalHandler = vi.fn().mockResolvedValue(undefined);
+        beforeEach(() => {
+            options = {
+                platformVersion: v2023_2,
+            };
+            handlerGeneratorMock.mockReturnValue(mockLocalHandler);
+        });
+        it('should call the local handler with the provided options', async () => {
+            await migrateAppCommand.handler(options);
+            expect(handlerGeneratorMock).toHaveBeenCalledWith('migrate-app');
+            expect(mockLocalHandler).toHaveBeenCalledWith(options);
+        });
+    });
+});

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

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+import yargs from 'yargs';
+import add from '../profile/add.js';
+import deleteProfile from '../profile/delete.js';
+import profileCommand from '../profile.js';
+vi.mock('../profile/add');
+vi.mock('../profile/delete');
+vi.mock('../../../lib/commonOpts');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+const demandCommandSpy = vi
+    .spyOn(yargs, 'demandCommand')
+    .mockReturnValue(yargs);
+describe('commands/project', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(profileCommand.command).toEqual(['profile', 'profiles']);
+        });
+    });
+    describe('describe', () => {
+        it('should not provide a description', () => {
+            expect(profileCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        const subcommands = [add, deleteProfile];
+        it('should demand the command takes one positional argument', () => {
+            profileCommand.builder(yargs);
+            expect(demandCommandSpy).toHaveBeenCalledTimes(1);
+            expect(demandCommandSpy).toHaveBeenCalledWith(1, '');
+        });
+        it('should add the correct number of sub commands', () => {
+            profileCommand.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(subcommands.length);
+        });
+        it.each(subcommands)('should attach the %s subcommand', module => {
+            profileCommand.builder(yargs);
+            expect(module).toBeDefined();
+            expect(commandSpy).toHaveBeenCalledWith(module);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,43 @@
+import yargs from 'yargs';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addJSONOutputOptions, } from '../../../lib/commonOpts.js';
+import projectUploadCommand from '../upload.js';
+vi.mock('../../../lib/commonOpts');
+const optionsSpy = vi.spyOn(yargs, 'options');
+const exampleSpy = vi.spyOn(yargs, 'example');
+const conflictsSpy = vi.spyOn(yargs, 'conflicts');
+describe('commands/project/upload', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(projectUploadCommand.command).toEqual('upload');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(projectUploadCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            projectUploadCommand.builder(yargs);
+            expect(conflictsSpy).toHaveBeenCalledTimes(1);
+            expect(conflictsSpy).toHaveBeenCalledWith('profile', 'account');
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargs);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargs);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargs);
+            expect(addJSONOutputOptions).toHaveBeenCalledTimes(1);
+            expect(addJSONOutputOptions).toHaveBeenCalledWith(yargs);
+        });
+        it('should define force-create, message, and skip-validation options', () => {
+            projectUploadCommand.builder(yargs);
+            expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
+                'force-create': expect.any(Object),
+                message: expect.any(Object),
+                'skip-validation': expect.any(Object),
+            }));
+            expect(exampleSpy).toHaveBeenCalled();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,98 @@
+import path from 'path';
+import { vi } from 'vitest';
+import { validateSourceDirectory } from '../../../lib/projects/upload.js';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { commands } from '../../../lang/en.js';
+import { useV3Api } from '../../../lib/projects/platformVersion.js';
+import { loadAndValidateProfile } from '../../../lib/projectProfiles.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { handleTranslate } from '../../../lib/projects/upload.js';
+import projectValidateCommand from '../validate.js';
+// Mock dependencies
+vi.mock('../../../lib/projects/upload.js');
+vi.mock('../../../lib/projects/config.js');
+vi.mock('../../../lib/ui/logger.js');
+vi.mock('../../../lib/usageTracking.js');
+vi.mock('../../../lib/projectProfiles.js');
+vi.mock('../../../lib/errorHandlers/index.js');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../lib/projects/platformVersion.js');
+describe('commands/project/validate', () => {
+    const projectDir = '/test/project';
+    let exitSpy;
+    beforeEach(() => {
+        // Mock process.exit to throw to stop execution
+        exitSpy = vi.spyOn(process, 'exit').mockImplementation(code => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        exitSpy.mockRestore();
+    });
+    describe('project configuration validation', () => {
+        it('should exit with error when project config is null', async () => {
+            vi.mocked(getProjectConfig).mockResolvedValue({
+                projectConfig: null,
+                projectDir: null,
+            });
+            await expect(
+            // @ts-expect-error partial mock
+            projectValidateCommand.handler({
+                derivedAccountId: 123,
+                d: false,
+                debug: false,
+            })).rejects.toThrow('Process exited with code 1');
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.validate.mustBeRanWithinAProject);
+        });
+        it('should exit with error when project directory is null', async () => {
+            vi.mocked(getProjectConfig).mockResolvedValue({
+                projectConfig: {
+                    name: 'test',
+                    srcDir: 'src',
+                    platformVersion: '2025.2',
+                },
+                projectDir: null,
+            });
+            await expect(
+            // @ts-expect-error partial mock
+            projectValidateCommand.handler({
+                derivedAccountId: 123,
+                d: false,
+                debug: false,
+            })).rejects.toThrow('Process exited with code 1');
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.validate.mustBeRanWithinAProject);
+        });
+    });
+    it('should call validateSourceDirectory with correct parameters', async () => {
+        const mockProjectConfig = {
+            name: 'test-project',
+            srcDir: 'src',
+            platformVersion: '2025.2',
+        };
+        vi.mocked(getProjectConfig).mockResolvedValue({
+            projectConfig: mockProjectConfig,
+            projectDir,
+        });
+        vi.mocked(useV3Api).mockReturnValue(true);
+        vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+        vi.mocked(loadAndValidateProfile).mockResolvedValue(123);
+        vi.mocked(getAccountConfig).mockReturnValue({
+            accountType: 'STANDARD',
+            accountId: 123,
+            env: 'prod',
+        });
+        vi.mocked(trackCommandUsage);
+        vi.mocked(validateSourceDirectory).mockResolvedValue(undefined);
+        vi.mocked(handleTranslate).mockResolvedValue(undefined);
+        await expect(projectValidateCommand.handler({
+            derivedAccountId: 123,
+            d: false,
+            debug: false,
+        })).rejects.toThrow('Process exited with code 0');
+        const expectedSrcDir = path.resolve(projectDir, mockProjectConfig.srcDir);
+        expect(validateSourceDirectory).toHaveBeenCalledWith(expectedSrcDir, mockProjectConfig, projectDir);
+    });
+});

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

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