@hubspot/cli 7.10.1-experimental.0 → 7.11.0-beta.0

package/commands/project/validate.js

@@ -8,19 +8,13 @@ import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { validateSourceDirectory, handleTranslate, } from '../../lib/projects/upload.js';
 import { commands } from '../../lang/en.js';
-import { validateProjectForProfile } from '../../lib/projectProfiles.js';
+import { loadAndValidateProfile } from '../../lib/projectProfiles.js';
 import { logError } from '../../lib/errorHandlers/index.js';
-import { getAllHsProfiles } from '@hubspot/project-parsing-lib';
-import SpinniesManager from '../../lib/ui/SpinniesManager.js';
 const command = 'validate';
 const describe = commands.project.validate.describe;
 async function handler(args) {
-    SpinniesManager.init();
     const { derivedAccountId, profile } = args;
     const { projectConfig, projectDir } = await getProjectConfig();
-    const accountConfig = getConfigAccountById(derivedAccountId);
-    const accountType = accountConfig && accountConfig.accountType;
-    trackCommandUsage('project-validate', { type: accountType }, derivedAccountId);
     if (!projectConfig || !projectDir) {
         uiLogger.error(commands.project.validate.mustBeRanWithinAProject);
         process.exit(EXIT_CODES.ERROR);
@@ -36,79 +30,25 @@ async function handler(args) {
         logError(error);
         process.exit(EXIT_CODES.ERROR);
     }
-    let validationSucceeded = true;
+    let targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
+    targetAccountId = targetAccountId || derivedAccountId;
+    const accountConfig = getConfigAccountById(targetAccountId);
+    const accountType = accountConfig && accountConfig.accountType;
+    trackCommandUsage('project-validate', { type: accountType }, targetAccountId);
     const srcDir = path.resolve(projectDir, projectConfig.srcDir);
-    // Get all of the profiles except the provided profile
-    const profiles = (await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir))).filter(profileName => profileName !== profile);
-    // If a profile is specified, only validate that profile
-    if (profile) {
-        const validationErrors = await validateProjectForProfile(projectConfig, projectDir, profile, derivedAccountId);
-        if (validationErrors.length) {
-            validationErrors.forEach(error => {
-                uiLogger.log('');
-                if (error instanceof Error) {
-                    logError(error);
-                }
-                else {
-                    uiLogger.error(error);
-                }
-            });
-            validationSucceeded = false;
-        }
-    }
-    else if (profiles.length > 0) {
-        // If no profile was specified and the project has profiles, validate all of them
-        SpinniesManager.add('validatingAllProfiles', {
-            text: commands.project.validate.spinners.validatingAllProfiles,
-        });
-        const errors = [];
-        for (const profileName of profiles) {
-            const validationErrors = await validateProjectForProfile(projectConfig, projectDir, profileName, derivedAccountId, true);
-            if (validationErrors.length) {
-                errors.push(...validationErrors);
-                validationSucceeded = false;
-            }
-        }
-        if (validationSucceeded) {
-            SpinniesManager.succeed('validatingAllProfiles', {
-                text: commands.project.validate.spinners.allProfilesValidationSucceeded,
-            });
-        }
-        else {
-            SpinniesManager.fail('validatingAllProfiles', {
-                text: commands.project.validate.spinners.allProfilesValidationFailed,
-            });
-        }
-        errors.forEach(error => {
-            uiLogger.log('');
-            if (error instanceof Error) {
-                logError(error);
-            }
-            else {
-                uiLogger.error(error);
-            }
-        });
-    }
-    else if (profiles.length === 0) {
-        // If the project has no profiles, validate the project without a profile
-        try {
-            await handleTranslate(projectDir, projectConfig, derivedAccountId, false, undefined);
-        }
-        catch (e) {
-            uiLogger.error(commands.project.validate.failure(projectConfig.name));
-            logError(e);
-            validationSucceeded = false;
-            uiLogger.log('');
-        }
+    try {
+        await validateSourceDirectory(srcDir, projectConfig, projectDir);
     }
-    if (!validationSucceeded) {
+    catch (e) {
+        logError(e);
         process.exit(EXIT_CODES.ERROR);
     }
     try {
-        await validateSourceDirectory(srcDir, projectConfig, projectDir);
+        await handleTranslate(projectDir, projectConfig, targetAccountId, false, profile);
     }
     catch (e) {
         logError(e);
+        uiLogger.error(commands.project.validate.failure(projectConfig.name));
         process.exit(EXIT_CODES.ERROR);
     }
     uiLogger.success(commands.project.validate.success(projectConfig.name));

package/lang/en.d.ts

@@ -1366,8 +1366,10 @@ export declare const commands: {
             };
             logs: {
                 success: (projectName: string, projectDest: string) => string;
-                welcomeMessage: string;
             };
+            creatingComponent: (isProjectEmpty: boolean, projectName: string) => string;
+            success: (isProjectEmpty: boolean, projectName: string) => string;
+            failure: (isProjectEmpty: boolean, projectName: string) => string;
             prompts: {
                 parentComponents: string;
                 emptyProject: string;
@@ -1508,7 +1510,8 @@ export declare const commands: {
                 };
             };
             creatingComponent: (projectName: string) => string;
-            success: (componentName: string, multiple?: boolean) => string;
+            success: (projectName: string) => string;
+            failure: (projectName: string) => string;
             error: {
                 failedToDownloadComponent: string;
                 invalidComponentType: (componentType: string) => string;
@@ -1802,16 +1805,7 @@ export declare const commands: {
                 default: string;
             };
             success: (projectName: string) => string;
-            failure: (projectName: string, profileName?: string) => string;
-            spinners: {
-                validatingProfile: (profileName: string) => string;
-                profileValidationFailed: (profileName: string) => string;
-                profileValidationSucceeded: (profileName: string) => string;
-                invalidWithProfile: (profileName: string, projectName: string) => string;
-                validatingAllProfiles: string;
-                allProfilesValidationSucceeded: string;
-                allProfilesValidationFailed: string;
-            };
+            failure: (projectName: string) => string;
             options: {
                 profile: {
                     describe: string;
@@ -2990,9 +2984,7 @@ export declare const lib: {
                 noProjectConfig: string;
                 profileNotFound: (profileName: string) => string;
                 missingAccountId: (profileName: string) => string;
-                listedAccountNotFound: (accountId: number, profileName: string) => string;
                 failedToLoadProfile: (profileName: string) => string;
-                profileNotValid: (profileName: string, errors: string[]) => string;
             };
         };
     };
@@ -3049,6 +3041,18 @@ export declare const lib: {
             feedbackHeader: string;
             feedbackMessage: string;
         };
+        components: {
+            unableToGetUidFromHsmeta: string;
+            buildSuccessMessage: {
+                seeOurDocs: string;
+                docsUrl: string;
+                headerCreated: (projectName: string, projectDest: string) => string;
+                headerAdded: (featureText: string, uid: string, plural: boolean) => string;
+                docsDetails: (docsLink: string) => string;
+                uploadPrompt: string;
+                devPrompt: string;
+            };
+        };
     };
     projectBuildAndDeploy: {
         makePollTaskStatusFunc: {
@@ -3657,6 +3661,7 @@ export declare const lib: {
             unknownErrorOccurred: string;
             configTimeoutErrorOccurred: (timeout: number, configSetCommand: string) => string;
             genericTimeoutErrorOccurred: string;
+            additionalDebugContext: string;
         };
         suppressErrors: {
             platformVersionErrors: {

package/lang/en.js

@@ -1381,8 +1381,10 @@ export const commands = {
             },
             logs: {
                 success: (projectName, projectDest) => `Project ${chalk.bold(projectName)} was successfully created in ${projectDest}`,
-                welcomeMessage: `\n${chalk.bold('Welcome to HubSpot Developer Projects!')}`,
             },
+            creatingComponent: (isProjectEmpty, projectName) => `${isProjectEmpty ? `Creating empty project [${chalk.bold(projectName)}]` : `Adding feature(s) to app [${chalk.bold(projectName)}]`}\n`,
+            success: (isProjectEmpty, projectName) => `${isProjectEmpty ? `Created empty project [${chalk.bold(projectName)}]` : `Added feature(s) to app [${chalk.bold(projectName)}]`}\n`,
+            failure: (isProjectEmpty, projectName) => `${isProjectEmpty ? `Failed to create project [${chalk.bold(projectName)}]` : `Failed to add feature(s) to app [${chalk.bold(projectName)}]`}\n`,
             prompts: {
                 parentComponents: '[--project-base] Choose what to include in your project:',
                 emptyProject: 'Empty Project',
@@ -1522,8 +1524,9 @@ export const commands = {
                     describe: 'Which features to include with the application.',
                 },
             },
-            creatingComponent: (projectName) => `\nAdding a new app feature to ${chalk.bold(projectName)}\n`,
-            success: (componentName, multiple = false) => `${componentName || 'An app'} ${multiple ? 'were' : 'was'} successfully added to your ${componentName ? 'app' : 'project'}.`,
+            creatingComponent: (projectName) => `Adding feature(s) to app [${chalk.bold(projectName)}]\n`,
+            success: (projectName) => `Added feature(s) to app [${chalk.bold(projectName)}]\n`,
+            failure: (projectName) => `Failed to add feature(s) to app [${chalk.bold(projectName)}]\n`,
             error: {
                 failedToDownloadComponent: 'Failed to download project. Please try again later.',
                 invalidComponentType: (componentType) => `'${componentType}' is not a valid project component type.`,
@@ -1824,19 +1827,10 @@ export const commands = {
                 default: 'Validate the project before uploading',
             },
             success: (projectName) => `Project ${projectName} is valid and ready to upload`,
-            failure: (projectName, profileName) => `Project ${projectName} is invalid${profileName ? `with profile ${profileName} applied` : ''}`,
-            spinners: {
-                validatingProfile: (profileName) => `Validating project with profile "${profileName}"`,
-                profileValidationFailed: (profileName) => `Profile "${profileName}" failed validation`,
-                profileValidationSucceeded: (profileName) => `Project valid with profile "${profileName}" applied`,
-                invalidWithProfile: (profileName, projectName) => `Project is invalid with profile "${profileName}" applied \n ${commands.project.validate.failure(projectName)}`,
-                validatingAllProfiles: 'Validating the project with all profiles',
-                allProfilesValidationSucceeded: 'Project profile validation succeeded',
-                allProfilesValidationFailed: 'Project profile validation failed',
-            },
+            failure: (projectName) => `Project ${projectName} is invalid`,
             options: {
                 profile: {
-                    describe: 'The profile to target for this validation.  If no profile is provided, all profiles will be validated.',
+                    describe: 'The profile to target for this validation',
                 },
             },
         },
@@ -3012,9 +3006,7 @@ export const lib = {
                 noProjectConfig: 'No project config found. Please run this command from a project directory.',
                 profileNotFound: (profileName) => `Profile ${chalk.bold(profileName)} not found.`,
                 missingAccountId: (profileName) => `Profile ${chalk.bold(profileName)} is missing an account id.`,
-                listedAccountNotFound: (accountId, profileName) => `The account ${uiAccountDescription(accountId)} is defined in your profile ${chalk.bold(profileName)}, but is missing in your config file`,
                 failedToLoadProfile: (profileName) => `Failed to load profile ${chalk.bold(profileName)}.`,
-                profileNotValid: (profileName, errors) => `Profile "${profileName}" is not valid:\n\t- ${errors.join('\n\t- ')}`,
             },
         },
     },
@@ -3071,6 +3063,18 @@ export const lib = {
             feedbackHeader: "We'd love to hear your feedback!",
             feedbackMessage: `How are you liking the new projects and developer tools? \n > Run ${uiCommandReference('hs feedback')} to let us know what you think!\n`,
         },
+        components: {
+            unableToGetUidFromHsmeta: 'Unable to get UID from hsmeta',
+            buildSuccessMessage: {
+                seeOurDocs: 'See our docs',
+                docsUrl: 'https://developers.hubspot.com/docs/apps/developer-platform/build-apps/overview',
+                headerCreated: (projectName, projectDest) => `${chalk.bold(projectName)} was successfully created in ${projectDest}`,
+                headerAdded: (featureText, uid, plural) => `${featureText} ${plural ? 'were' : 'was'} successfully added to ${uid}:`,
+                docsDetails: (docsLink) => `📖 ${docsLink} for more details about building and testing these features.`,
+                uploadPrompt: `🚀 Run ${uiCommandReference('hs project upload')} when you're ready to deploy.`,
+                devPrompt: `🧪 Run ${uiCommandReference('hs project dev')} to start local development.`,
+            },
+        },
     },
     projectBuildAndDeploy: {
         makePollTaskStatusFunc: {
@@ -3679,6 +3683,7 @@ export const lib = {
             unknownErrorOccurred: 'An unknown error has occurred.',
             configTimeoutErrorOccurred: (timeout, configSetCommand) => `This error occurred because a request exceeded the default HTTP timeout of ${timeout}ms. To increase the default HTTP timeout, run ${uiCommandReference(configSetCommand)}.`,
             genericTimeoutErrorOccurred: 'This error occurred because an HTTP request timed out. Re-running the command may resolve this issue.',
+            additionalDebugContext: chalk.bold(`For more information, run the command again with the ${uiCommandReference('--debug')} flag.`),
         },
         suppressErrors: {
             platformVersionErrors: {

package/lib/__tests__/projectProfiles.test.js

@@ -1,26 +1,22 @@
 import path from 'path';
-import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, validateProfileVariables, } from '@hubspot/project-parsing-lib';
+import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, } from '@hubspot/project-parsing-lib';
 import { lib } from '../../lang/en.js';
 import { uiBetaTag, uiLine } from '../ui/index.js';
 import { uiLogger } from '../ui/logger.js';
-import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { logProfileHeader, logProfileFooter, loadProfile, enforceProfileUsage, loadAndValidateProfile, validateProjectForProfile, } from '../projectProfiles.js';
-import { handleTranslate } from '../projects/upload.js';
-import SpinniesManager from '../ui/SpinniesManager.js';
-import { commands } from '../../lang/en.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { logProfileHeader, logProfileFooter, loadProfile, exitIfUsingProfiles, } from '../projectProfiles.js';
 // Mock dependencies
 vi.mock('@hubspot/project-parsing-lib');
-vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../ui');
 vi.mock('../ui/logger');
 vi.mock('../../lang/en');
-vi.mock('../projects/upload');
-vi.mock('../ui/SpinniesManager');
+// Mock process.exit
+const mockExit = vi.spyOn(process, 'exit').mockImplementation(code => {
+    throw new Error(`Process.exit called with code ${code}`);
+});
 const mockedLoadHsProfileFile = loadHsProfileFile;
 const mockedGetHsProfileFilename = getHsProfileFilename;
 const mockedGetAllHsProfiles = getAllHsProfiles;
-const mockedValidateProfileVariables = validateProfileVariables;
-const mockedGetConfigAccountById = getConfigAccountById;
 const mockedUiBetaTag = uiBetaTag;
 const mockedUiLine = uiLine;
 const mockedUiLogger = uiLogger;
@@ -72,299 +68,62 @@ describe('lib/projectProfiles', () => {
         const mockProfile = {
             accountId: 123,
         };
-        beforeEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should throw error when project config is missing', () => {
-            expect(() => loadProfile(null, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.noProjectConfig);
-        });
-        it('should throw error when project dir is missing', () => {
-            expect(() => loadProfile(mockProjectConfig, null, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        it('should return undefined when project config is missing', () => {
+            const result = loadProfile(null, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.noProjectConfig);
         });
-        it('should throw error when profile is not found', () => {
+        it('should return undefined when profile is not found', () => {
             mockedLoadHsProfileFile.mockReturnValue(null);
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
         });
-        it('should throw error when profile has no account ID', () => {
+        it('should return undefined when profile has no account ID', () => {
             mockedLoadHsProfileFile.mockReturnValue({});
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
         });
-        it('should throw error when profile loading fails', () => {
+        it('should return undefined when profile loading fails', () => {
             mockedLoadHsProfileFile.mockImplementation(() => {
                 throw new Error('Load failed');
             });
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
-        });
-        it('should throw error when account is not found in config', () => {
-            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
-            mockedGetConfigAccountById.mockImplementation(() => {
-                throw new Error('Account not found');
-            });
-            const filename = 'test-profile.hsprofile';
-            mockedGetHsProfileFilename.mockReturnValue(filename);
-            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.listedAccountNotFound(mockProfile.accountId, filename));
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
         });
         it('should return profile when loading succeeds', () => {
             mockedLoadHsProfileFile.mockReturnValue(mockProfile);
-            mockedGetConfigAccountById.mockReturnValue({
-                accountId: mockProfile.accountId,
-            });
             const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toEqual(mockProfile);
             expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
-            expect(mockedGetConfigAccountById).toHaveBeenCalledWith(mockProfile.accountId);
         });
     });
-    describe('enforceProfileUsage()', () => {
+    describe('exitIfUsingProfiles()', () => {
         const mockProjectConfig = {
             srcDir: 'src',
             name: 'test-project',
             platformVersion: '1.0.0',
         };
         const mockProjectDir = '/test/project';
-        beforeEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should not throw when no profiles exist', async () => {
+        it('should not exit when no profiles exist', async () => {
             mockedGetAllHsProfiles.mockResolvedValue([]);
-            await expect(enforceProfileUsage(mockProjectConfig, mockProjectDir)).resolves.toBeUndefined();
+            await exitIfUsingProfiles(mockProjectConfig, mockProjectDir);
+            expect(mockedUiLogger.error).not.toHaveBeenCalled();
+            expect(mockExit).not.toHaveBeenCalled();
         });
-        it('should throw error when profiles exist', async () => {
+        it('should exit with error when profiles exist', async () => {
             mockedGetAllHsProfiles.mockResolvedValue(['profile1', 'profile2']);
-            await expect(enforceProfileUsage(mockProjectConfig, mockProjectDir)).rejects.toThrow(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
-        });
-        it('should not throw when project config is null', async () => {
-            await expect(enforceProfileUsage(null, mockProjectDir)).resolves.toBeUndefined();
-        });
-        it('should not throw when project dir is null', async () => {
-            await expect(enforceProfileUsage(mockProjectConfig, null)).resolves.toBeUndefined();
-        });
-    });
-    describe('loadAndValidateProfile()', () => {
-        const mockProjectConfig = {
-            srcDir: 'src',
-            name: 'test-project',
-            platformVersion: '1.0.0',
-        };
-        const mockProjectDir = '/test/project';
-        const mockProfileName = 'test-profile';
-        const mockProfile = {
-            accountId: 123,
-            variables: {
-                key1: 'value1',
-                key2: 'value2',
-            },
-        };
-        beforeEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should enforce profile usage when no profile name provided', async () => {
-            mockedGetAllHsProfiles.mockResolvedValue([]);
-            const result = await loadAndValidateProfile(mockProjectConfig, mockProjectDir, undefined);
-            expect(result).toBeUndefined();
-            expect(mockedGetAllHsProfiles).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir));
-        });
-        it('should throw when profiles exist but no profile name provided', async () => {
-            mockedGetAllHsProfiles.mockResolvedValue(['profile1']);
-            await expect(loadAndValidateProfile(mockProjectConfig, mockProjectDir, undefined)).rejects.toThrow(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
-        });
-        it('should load and return account ID when profile is valid', async () => {
-            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
-            mockedGetConfigAccountById.mockReturnValue({
-                accountId: mockProfile.accountId,
-            });
-            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
-            mockedValidateProfileVariables.mockReturnValue({ success: true });
-            const result = await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName);
-            expect(result).toBe(mockProfile.accountId);
-            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
-            expect(mockedValidateProfileVariables).toHaveBeenCalledWith(mockProfile.variables, mockProfileName);
-        });
-        it('should log profile header and footer when not silent', async () => {
-            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
-            mockedGetConfigAccountById.mockReturnValue({
-                accountId: mockProfile.accountId,
-            });
-            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
-            mockedValidateProfileVariables.mockReturnValue({ success: true });
-            await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName, false);
-            expect(mockedUiBetaTag).toHaveBeenCalled();
-            expect(mockedUiLine).toHaveBeenCalled();
-            expect(mockedUiLogger.log).toHaveBeenCalled();
-        });
-        it('should not log when silent is true', async () => {
-            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
-            mockedGetConfigAccountById.mockReturnValue({
-                accountId: mockProfile.accountId,
-            });
-            mockedValidateProfileVariables.mockReturnValue({ success: true });
-            await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName, true);
-            expect(mockedUiBetaTag).not.toHaveBeenCalled();
-            expect(mockedUiLine).not.toHaveBeenCalled();
-        });
-        it('should throw error when profile variables are invalid', async () => {
-            const invalidProfile = {
-                accountId: 123,
-                variables: {
-                    invalid: 'value',
-                },
-            };
-            const validationErrors = ['Variable "invalid" is not allowed'];
-            mockedLoadHsProfileFile.mockReturnValue(invalidProfile);
-            mockedGetConfigAccountById.mockReturnValue({
-                accountId: invalidProfile.accountId,
-            });
-            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
-            mockedValidateProfileVariables.mockReturnValue({
-                success: false,
-                errors: validationErrors,
-            });
-            await expect(loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName)).rejects.toThrow(lib.projectProfiles.loadProfile.errors.profileNotValid('test-profile.hsprofile', validationErrors));
-        });
-        it('should not validate when profile has no variables', async () => {
-            const profileWithoutVars = {
-                accountId: 123,
-            };
-            mockedLoadHsProfileFile.mockReturnValue(profileWithoutVars);
-            mockedGetConfigAccountById.mockReturnValue({
-                accountId: profileWithoutVars.accountId,
-            });
-            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
-            const result = await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName);
-            expect(result).toBe(profileWithoutVars.accountId);
-            expect(mockedValidateProfileVariables).not.toHaveBeenCalled();
-        });
-    });
-    describe('validateProjectForProfile()', () => {
-        const mockProjectConfig = {
-            srcDir: 'src',
-            name: 'test-project',
-            platformVersion: '2025.2',
-        };
-        const mockProjectDir = '/test/project';
-        const mockProfileName = 'test-profile';
-        const mockDerivedAccountId = 123;
-        const mockProfileFilename = 'test-profile.hsprofile';
-        const mockProfile = {
-            accountId: mockDerivedAccountId,
-        };
-        beforeEach(() => {
-            vi.clearAllMocks();
-            mockedGetHsProfileFilename.mockReturnValue(mockProfileFilename);
-            vi.mocked(SpinniesManager.init);
-            vi.mocked(SpinniesManager.add);
-            vi.mocked(SpinniesManager.succeed);
-            vi.mocked(SpinniesManager.fail);
-            // Mock dependencies for loadAndValidateProfile
-            mockedGetAllHsProfiles.mockResolvedValue([]);
-            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
-            mockedGetConfigAccountById.mockReturnValue({
-                accountId: mockDerivedAccountId,
-            });
-            mockedValidateProfileVariables.mockReturnValue({ success: true });
-            vi.mocked(handleTranslate).mockResolvedValue(undefined);
-        });
-        it('should return empty array when validation succeeds', async () => {
-            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
-            expect(result).toEqual([]);
-            expect(SpinniesManager.init).toHaveBeenCalled();
-            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
-                text: commands.project.validate.spinners.validatingProfile(mockProfileFilename),
-                indent: 0,
-            });
-            expect(SpinniesManager.succeed).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
-                text: commands.project.validate.spinners.profileValidationSucceeded(mockProfileFilename),
-            });
-        });
-        it('should call handleTranslate with profile account ID from profile', async () => {
-            await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
-            expect(handleTranslate).toHaveBeenCalledWith(mockProjectDir, mockProjectConfig, mockDerivedAccountId, false, mockProfileName);
-        });
-        it('should call handleTranslate with different profile account ID when profile has different ID', async () => {
-            const profileAccountId = 456;
-            const profileWithDifferentId = {
-                accountId: profileAccountId,
-            };
-            mockedLoadHsProfileFile.mockReturnValue(profileWithDifferentId);
-            mockedGetConfigAccountById.mockReturnValue({
-                accountId: profileAccountId,
-            });
-            await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
-            expect(handleTranslate).toHaveBeenCalledWith(mockProjectDir, mockProjectConfig, profileAccountId, false, mockProfileName);
-        });
-        it('should return error when profile has no accountId', async () => {
-            // @ts-expect-error causing an error on purpose
-            const profileWithoutId = {};
-            mockedLoadHsProfileFile.mockReturnValue(profileWithoutId);
-            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
-            expect(result.length).toBeGreaterThan(0);
-            expect(SpinniesManager.fail).toHaveBeenCalled();
-            expect(handleTranslate).not.toHaveBeenCalled();
-        });
-        it('should indent spinners when indentSpinners is true', async () => {
-            await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId, true);
-            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
-                text: commands.project.validate.spinners.validatingProfile(mockProfileFilename),
-                indent: 4,
-            });
-        });
-        it('should not indent spinners when indentSpinners is false', async () => {
-            await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId, false);
-            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
-                text: commands.project.validate.spinners.validatingProfile(mockProfileFilename),
-                indent: 0,
-            });
-        });
-        it('should return error array when profile loading fails', async () => {
-            mockedLoadHsProfileFile.mockReturnValue(null);
-            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
-            expect(result.length).toBeGreaterThan(0);
-            expect(SpinniesManager.fail).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
-                text: commands.project.validate.spinners.profileValidationFailed(mockProfileFilename),
-            });
-            expect(handleTranslate).not.toHaveBeenCalled();
-        });
-        it('should return error when profile file loading throws', async () => {
-            mockedLoadHsProfileFile.mockImplementation(() => {
-                throw new Error('Failed to load profile file');
-            });
-            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
-            expect(result.length).toBeGreaterThan(0);
-            expect(SpinniesManager.fail).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
-                text: commands.project.validate.spinners.profileValidationFailed(mockProfileFilename),
-            });
-            expect(handleTranslate).not.toHaveBeenCalled();
-        });
-        it('should return error array when translation fails', async () => {
-            const error = new Error('Translation failed');
-            vi.mocked(handleTranslate).mockRejectedValue(error);
-            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
-            expect(result).toHaveLength(2);
-            expect(result[0]).toBe(commands.project.validate.failure(mockProjectConfig.name));
-            expect(result[1]).toBe(error);
-            expect(SpinniesManager.fail).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
-                text: commands.project.validate.spinners.invalidWithProfile(mockProfileFilename, mockProjectConfig.name),
-            });
-        });
-        it('should return string error when translation fails with non-Error', async () => {
-            const error = 'Translation error';
-            vi.mocked(handleTranslate).mockRejectedValue(error);
-            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
-            expect(result).toHaveLength(2);
-            expect(result[0]).toBe(commands.project.validate.failure(mockProjectConfig.name));
-            expect(result[1]).toBe(error);
-        });
-        it('should use correct spinner name based on profile name', async () => {
-            const customProfileName = 'custom-profile';
-            await validateProjectForProfile(mockProjectConfig, mockProjectDir, customProfileName, mockDerivedAccountId);
-            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${customProfileName}`, expect.any(Object));
-            expect(SpinniesManager.succeed).toHaveBeenCalledWith(`validatingProfile-${customProfileName}`, expect.any(Object));
+            await expect(exitIfUsingProfiles(mockProjectConfig, mockProjectDir)).rejects.toThrow(`Process.exit called with code ${EXIT_CODES.ERROR}`);
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+            expect(mockExit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
         });
     });
 });