@hubspot/cli 7.10.0 → 7.10.1-experimental.0

package/lib/__tests__/projectProfiles.test.js

@@ -1,22 +1,26 @@
 import path from 'path';
-import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, } from '@hubspot/project-parsing-lib';
+import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, validateProfileVariables, } 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 { EXIT_CODES } from '../enums/exitCodes.js';
-import { logProfileHeader, logProfileFooter, loadProfile, exitIfUsingProfiles, } from '../projectProfiles.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';
 // 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');
-// Mock process.exit
-const mockExit = vi.spyOn(process, 'exit').mockImplementation(code => {
-    throw new Error(`Process.exit called with code ${code}`);
-});
+vi.mock('../projects/upload');
+vi.mock('../ui/SpinniesManager');
 const mockedLoadHsProfileFile = loadHsProfileFile;
 const mockedGetHsProfileFilename = getHsProfileFilename;
 const mockedGetAllHsProfiles = getAllHsProfiles;
+const mockedValidateProfileVariables = validateProfileVariables;
+const mockedGetConfigAccountById = getConfigAccountById;
 const mockedUiBetaTag = uiBetaTag;
 const mockedUiLine = uiLine;
 const mockedUiLogger = uiLogger;
@@ -68,62 +72,299 @@ describe('lib/projectProfiles', () => {
         const mockProfile = {
             accountId: 123,
         };
-        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);
+        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 return undefined when profile is not found', () => {
+        it('should throw error when project dir is missing', () => {
+            expect(() => loadProfile(mockProjectConfig, null, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        });
+        it('should throw error when profile is not found', () => {
             mockedLoadHsProfileFile.mockReturnValue(null);
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
-            expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
         });
-        it('should return undefined when profile has no account ID', () => {
+        it('should throw error when profile has no account ID', () => {
             mockedLoadHsProfileFile.mockReturnValue({});
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
-            expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
         });
-        it('should return undefined when profile loading fails', () => {
+        it('should throw error when profile loading fails', () => {
             mockedLoadHsProfileFile.mockImplementation(() => {
                 throw new Error('Load failed');
             });
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
-            expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(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));
         });
         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('exitIfUsingProfiles()', () => {
+    describe('enforceProfileUsage()', () => {
         const mockProjectConfig = {
             srcDir: 'src',
             name: 'test-project',
             platformVersion: '1.0.0',
         };
         const mockProjectDir = '/test/project';
-        it('should not exit when no profiles exist', async () => {
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should not throw when no profiles exist', async () => {
             mockedGetAllHsProfiles.mockResolvedValue([]);
-            await exitIfUsingProfiles(mockProjectConfig, mockProjectDir);
-            expect(mockedUiLogger.error).not.toHaveBeenCalled();
-            expect(mockExit).not.toHaveBeenCalled();
+            await expect(enforceProfileUsage(mockProjectConfig, mockProjectDir)).resolves.toBeUndefined();
         });
-        it('should exit with error when profiles exist', async () => {
+        it('should throw error when profiles exist', async () => {
             mockedGetAllHsProfiles.mockResolvedValue(['profile1', 'profile2']);
-            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);
+            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));
         });
     });
 });

package/lib/__tests__/sandboxSync.test.js

@@ -1,6 +1,6 @@
 import { uiLogger } from '../ui/logger.js';
 import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountIfExists, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { mockHubSpotHttpError } from '../testUtils.js';
 import { getAvailableSyncTypes } from '../sandboxes.js';
@@ -13,7 +13,8 @@ vi.mock('../sandboxes');
 vi.mock('../ui/SpinniesManager');
 const mockedUiLogger = uiLogger;
 const mockedInitiateSync = initiateSync;
-const mockedGetAccountId = getAccountId;
+const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
+const mockedGetConfigAccountById = getConfigAccountById;
 const mockedGetAvailableSyncTypes = getAvailableSyncTypes;
 const mockedSpinniesInit = SpinniesManager.init;
 const mockedSpinniesAdd = SpinniesManager.add;
@@ -23,22 +24,45 @@ describe('lib/sandboxSync', () => {
     const mockEnv = 'qa';
     const mockParentAccount = {
         name: 'Parent Account',
-        portalId: 123,
+        accountId: 123,
         accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
         env: mockEnv,
+        authType: 'personalaccesskey',
     };
     const mockChildAccount = {
         name: 'Child Account',
-        portalId: 456,
+        accountId: 456,
         accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         env: mockEnv,
+        authType: 'personalaccesskey',
+    };
+    const mockChildAccountWithMissingId = {
+        name: 'Child Account',
+        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        env: mockEnv,
+        authType: 'personalaccesskey',
     };
     const mockSyncTasks = [{ type: 'mock-sync-type' }];
     beforeEach(() => {
-        mockedGetAccountId
-            .mockReturnValueOnce(mockChildAccount.portalId)
-            .mockReturnValueOnce(mockParentAccount.portalId);
+        mockedGetConfigAccountIfExists
+            .mockReturnValueOnce(mockChildAccount)
+            .mockReturnValueOnce(mockParentAccount);
         mockedGetAvailableSyncTypes.mockResolvedValue(mockSyncTasks);
+        // Mock SpinniesManager methods to prevent spinner errors
+        mockedSpinniesInit.mockImplementation(() => { });
+        mockedSpinniesAdd.mockImplementation(() => { });
+        mockedSpinniesSucceed.mockImplementation(() => { });
+        mockedSpinniesFail.mockImplementation(() => { });
+        // Mock account config for uiAccountDescription calls
+        mockedGetConfigAccountById.mockImplementation(accountId => {
+            if (accountId === mockChildAccount.accountId) {
+                return mockChildAccount;
+            }
+            if (accountId === mockParentAccount.accountId) {
+                return mockParentAccount;
+            }
+            return undefined; // Don't throw, just return undefined for unknown accounts
+        });
     });
     describe('syncSandbox()', () => {
         it('successfully syncs a sandbox with provided sync tasks', async () => {
@@ -46,7 +70,7 @@ describe('lib/sandboxSync', () => {
             await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
             expect(mockedSpinniesInit).toHaveBeenCalled();
             expect(mockedSpinniesAdd).toHaveBeenCalled();
-            expect(mockedInitiateSync).toHaveBeenCalledWith(mockParentAccount.portalId, mockChildAccount.portalId, mockSyncTasks, mockChildAccount.portalId);
+            expect(mockedInitiateSync).toHaveBeenCalledWith(mockParentAccount.accountId, mockChildAccount.accountId, mockSyncTasks, mockChildAccount.accountId);
             expect(mockedSpinniesSucceed).toHaveBeenCalled();
         });
         it('fetches sync types when no tasks are provided', async () => {
@@ -57,10 +81,8 @@ describe('lib/sandboxSync', () => {
             expect(mockedInitiateSync).toHaveBeenCalled();
         });
         it('throws error when account IDs are missing', async () => {
-            mockedGetAccountId.mockReset();
-            mockedGetAccountId.mockReturnValue(null);
             const errorRegex = new RegExp(`because your account has been removed from`);
-            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
+            await expect(syncSandbox(mockChildAccountWithMissingId, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
         });
         it('handles sync in progress error', async () => {
             const error = mockHubSpotHttpError('', {

package/lib/__tests__/sandboxes.test.js

@@ -1,19 +1,23 @@
 import { uiLogger } from '../ui/logger.js';
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
-import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { getAllConfigAccounts, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { mockHubSpotHttpError } from '../testUtils.js';
 import { getSandboxTypeAsString, getHasSandboxesByType, getAvailableSyncTypes, validateSandboxUsageLimits, handleSandboxCreateError, } from '../sandboxes.js';
+import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
 vi.mock('../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/api/sandboxHubs');
 vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
 vi.mock('@hubspot/local-dev-lib/config');
-const mockedGetAccountId = getAccountId;
+vi.mock('@hubspot/local-dev-lib/errors/index');
+const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
 const mockedGetSandboxUsageLimits = getSandboxUsageLimits;
 const mockedFetchTypes = fetchTypes;
-const mockedGetConfigAccounts = getConfigAccounts;
+const mockedGetAllConfigAccounts = getAllConfigAccounts;
 const mockedUiLogger = uiLogger;
+const mockedIsMissingScopeError = isMissingScopeError;
+const mockedIsSpecifiedError = isSpecifiedError;
 describe('lib/sandboxes', () => {
     describe('getSandboxTypeAsString()', () => {
         it('returns "development" for development sandbox type', () => {
@@ -29,14 +33,13 @@ describe('lib/sandboxes', () => {
     describe('getHasSandboxesByType()', () => {
         const mockParentAccount = {
             name: 'Parent Account',
-            portalId: 123,
-            authType: undefined,
+            accountId: 123,
             accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
             env: 'qa',
         };
         it('returns true when sandbox of specified type exists', () => {
-            mockedGetAccountId.mockReturnValue(mockParentAccount.portalId);
-            mockedGetConfigAccounts.mockReturnValue([
+            mockedGetConfigAccountIfExists.mockReturnValue(mockParentAccount);
+            mockedGetAllConfigAccounts.mockReturnValue([
                 mockParentAccount,
                 {
                     ...mockParentAccount,
@@ -47,25 +50,25 @@ describe('lib/sandboxes', () => {
             expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(true);
         });
         it('returns false when no sandbox of specified type exists', () => {
-            mockedGetConfigAccounts.mockReturnValue([mockParentAccount]);
+            mockedGetAllConfigAccounts.mockReturnValue([mockParentAccount]);
             expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
         });
     });
     describe('getAvailableSyncTypes()', () => {
         const mockParentAccount = {
             name: 'Parent Account',
-            portalId: 123,
+            accountId: 123,
             env: 'qa',
         };
         const mockChildAccount = {
             ...mockParentAccount,
-            portalId: 456,
+            accountId: 456,
         };
         it('returns available sync types when fetch is successful', async () => {
             const mockSyncTypes = [{ name: 'type1' }, { name: 'type2' }];
-            mockedGetAccountId
-                .mockReturnValue(mockParentAccount.portalId)
-                .mockReturnValue(mockChildAccount.portalId);
+            mockedGetConfigAccountIfExists
+                .mockReturnValue(mockParentAccount.accountId)
+                .mockReturnValue(mockChildAccount.accountId);
             mockedFetchTypes.mockResolvedValue({
                 data: { results: mockSyncTypes },
             });
@@ -80,12 +83,11 @@ describe('lib/sandboxes', () => {
     describe('validateSandboxUsageLimits()', () => {
         const mockAccount = {
             name: 'Test Account',
-            portalId: 123,
-            authType: undefined,
+            accountId: 123,
             env: 'qa',
         };
         it('validates successfully when limits are not reached', async () => {
-            mockedGetAccountId.mockReturnValue(mockAccount.portalId);
+            mockedGetConfigAccountIfExists.mockReturnValue(mockAccount.accountId);
             mockedGetSandboxUsageLimits.mockResolvedValue({
                 data: {
                     usage: { DEVELOPER: { available: 1, limit: 3 } },
@@ -94,8 +96,8 @@ describe('lib/sandboxes', () => {
             await expect(validateSandboxUsageLimits(mockAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).resolves.not.toThrow();
         });
         it('throws error when development sandbox limit is reached', async () => {
-            mockedGetAccountId.mockReturnValue(mockAccount.portalId);
-            mockedGetConfigAccounts.mockReturnValue([]);
+            mockedGetConfigAccountIfExists.mockReturnValue(mockAccount.accountId);
+            mockedGetAllConfigAccounts.mockReturnValue([]);
             mockedGetSandboxUsageLimits.mockResolvedValue({
                 data: {
                     usage: { DEVELOPER: { available: 0, limit: 1 } },
@@ -116,6 +118,9 @@ describe('lib/sandboxes', () => {
                     category: 'MISSING_SCOPES',
                 },
             });
+            // Mock the error checking function to return true for missing scope error
+            mockedIsMissingScopeError.mockReturnValue(true);
+            mockedIsSpecifiedError.mockReturnValue(false);
             expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
             expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/The personal access key you provided doesn't include sandbox permissions/));
             expect(mockedUiLogger.info).toHaveBeenCalledWith(expect.stringMatching(/To update CLI permissions for/));
@@ -128,6 +133,9 @@ describe('lib/sandboxes', () => {
                     subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
                 },
             });
+            // Mock the error checking function to return true for this error type
+            mockedIsMissingScopeError.mockReturnValue(false);
+            mockedIsSpecifiedError.mockReturnValue(true);
             expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
             expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/your permission set doesn't allow you to create the sandbox/));
         });
@@ -139,8 +147,11 @@ describe('lib/sandboxes', () => {
                     subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
                 },
             });
+            // Mock the error checking function to return true for this error type
+            mockedIsMissingScopeError.mockReturnValue(false);
+            mockedIsSpecifiedError.mockReturnValue(true);
             expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/does not have access to development sandboxes/));
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't create.*because your account has been removed from.*or your permission set doesn't allow you to create/));
         });
     });
 });