@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/lib/__tests__/polling.test.js

@@ -0,0 +1,76 @@
+import { poll, DEFAULT_POLLING_STATES } from '../polling.js';
+import { DEFAULT_POLLING_DELAY } from '../constants.js';
+// Helper to create a mock polling callback
+const createMockCallback = (responses) => {
+    let callCount = 0;
+    return vi.fn(() => {
+        const response = responses[callCount];
+        callCount++;
+        return Promise.resolve({ data: response });
+    });
+};
+describe('lib/polling', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('poll()', () => {
+        it('should resolve when status is SUCCESS', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.SUCCESS },
+            ]);
+            const pollPromise = poll(mockCallback);
+            // Fast-forward through two polling intervals
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            const result = await pollPromise;
+            expect(result.status).toBe(DEFAULT_POLLING_STATES.SUCCESS);
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+        it('should reject when status is ERROR', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.ERROR },
+            ]);
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: DEFAULT_POLLING_STATES.ERROR,
+            });
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+        it('should reject when status is FAILURE', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.FAILURE },
+            ]);
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: DEFAULT_POLLING_STATES.FAILURE,
+            });
+        });
+        it('should reject when status is REVERTED', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.REVERTED },
+            ]);
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: DEFAULT_POLLING_STATES.REVERTED,
+            });
+        });
+        it('should reject when callback throws an error', async () => {
+            const mockCallback = vi
+                .fn()
+                .mockRejectedValue(new Error('Network error'));
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY);
+            await expect(pollPromise).rejects.toThrow('Network error');
+            expect(mockCallback).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/lib/__tests__/process.test.d.ts

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

package/lib/__tests__/process.test.js

@@ -0,0 +1,85 @@
+import readline from 'readline';
+import { logger, setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
+import { handleExit, handleKeypress, TERMINATION_SIGNALS } from '../process.js';
+vi.mock('readline');
+vi.mock('@hubspot/local-dev-lib/logger');
+const mockedReadline = readline;
+const mockedLogger = logger;
+const mockedSetLogLevel = setLogLevel;
+const processRemoveListenerSpy = vi.spyOn(process, 'removeAllListeners');
+const processOnSpy = vi.spyOn(process, 'on');
+describe('lib/process', () => {
+    describe('handleExit()', () => {
+        const mockCallback = vi.fn();
+        it('should set up listeners for all termination signals', () => {
+            handleExit(mockCallback);
+            TERMINATION_SIGNALS.forEach(signal => {
+                expect(processRemoveListenerSpy).toHaveBeenCalledWith(signal);
+                expect(processOnSpy).toHaveBeenCalledWith(signal, expect.any(Function));
+            });
+        });
+        it('should handle SIGHUP signal correctly', async () => {
+            handleExit(mockCallback);
+            // Get the callback function passed to process.on for SIGHUP
+            const sighupCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGHUP')?.[1];
+            expect(sighupCallback).toBeDefined();
+            sighupCallback();
+            expect(mockedSetLogLevel).toHaveBeenCalledWith(LOG_LEVEL.NONE);
+            expect(mockCallback).toHaveBeenCalledWith({ isSIGHUP: true });
+            expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGHUP'));
+        });
+        it('should handle non-SIGHUP signals correctly', async () => {
+            handleExit(mockCallback);
+            // Get the callback function passed to process.on for SIGINT
+            const sigintCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGINT')?.[1];
+            expect(sigintCallback).toBeDefined();
+            sigintCallback();
+            expect(mockedSetLogLevel).not.toHaveBeenCalled();
+            expect(mockCallback).toHaveBeenCalledWith({ isSIGHUP: false });
+            expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGINT'));
+        });
+        it('should prevent duplicate exit handling', async () => {
+            handleExit(mockCallback);
+            // Get the callback function passed to process.on for SIGINT
+            const sigintCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGINT')?.[1];
+            expect(sigintCallback).toBeDefined();
+            sigintCallback();
+            sigintCallback(); // Second call should be ignored
+            expect(mockCallback).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('handleKeypress()', () => {
+        const mockCallback = vi.fn();
+        it('should set up keypress handling correctly', () => {
+            // Mock process.stdin
+            Object.defineProperty(process, 'stdin', {
+                value: {
+                    isTTY: true,
+                    setRawMode: vi.fn(),
+                    on: vi.fn(),
+                    removeAllListeners: vi.fn(),
+                },
+            });
+            mockedReadline.createInterface.mockReturnValue({});
+            mockedReadline.emitKeypressEvents.mockImplementation(() => { });
+            handleKeypress(mockCallback);
+            expect(mockedReadline.createInterface).toHaveBeenCalledWith(process.stdin, process.stdout);
+            expect(mockedReadline.emitKeypressEvents).toHaveBeenCalledWith(process.stdin);
+            expect(process.stdin.setRawMode).toHaveBeenCalledWith(true);
+            expect(process.stdin.removeAllListeners).toHaveBeenCalledWith('keypress');
+            expect(process.stdin.on).toHaveBeenCalledWith('keypress', expect.any(Function));
+        });
+        it('should not set raw mode when stdin is not TTY', () => {
+            // Mock process.stdin as non-TTY
+            Object.defineProperty(process, 'stdin', {
+                value: {
+                    isTTY: false,
+                    on: vi.fn(),
+                    removeAllListeners: vi.fn(),
+                },
+            });
+            handleKeypress(mockCallback);
+            expect(process.stdin.setRawMode).toBeUndefined();
+        });
+    });
+});

package/lib/__tests__/projectProfiles.test.d.ts

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

package/lib/__tests__/projectProfiles.test.js

@@ -0,0 +1,129 @@
+import path from 'path';
+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 { EXIT_CODES } from '../enums/exitCodes.js';
+import { logProfileHeader, logProfileFooter, loadProfile, exitIfUsingProfiles, } from '../projectProfiles.js';
+// Mock dependencies
+vi.mock('@hubspot/project-parsing-lib');
+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}`);
+});
+const mockedLoadHsProfileFile = loadHsProfileFile;
+const mockedGetHsProfileFilename = getHsProfileFilename;
+const mockedGetAllHsProfiles = getAllHsProfiles;
+const mockedUiBetaTag = uiBetaTag;
+const mockedUiLine = uiLine;
+const mockedUiLogger = uiLogger;
+describe('lib/projectProfiles', () => {
+    describe('logProfileHeader()', () => {
+        it('should log profile header with correct format', () => {
+            const profileName = 'test-profile';
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            logProfileHeader(profileName);
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiBetaTag).toHaveBeenCalledWith(lib.projectProfiles.logs.usingProfile(filename));
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+    });
+    describe('logProfileFooter()', () => {
+        const mockProfile = {
+            accountId: 123,
+            variables: {
+                key1: 'value1',
+                key2: 'value2',
+            },
+        };
+        it('should log profile footer with account ID', () => {
+            logProfileFooter(mockProfile);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+        it('should log variables when includeVariables is true', () => {
+            logProfileFooter(mockProfile, true);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileVariables);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('  key1: value1');
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('  key2: value2');
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+    });
+    describe('loadProfile()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '1.0.0',
+        };
+        const mockProjectDir = '/test/project';
+        const mockProfileName = 'test-profile';
+        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);
+        });
+        it('should return undefined 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));
+        });
+        it('should return undefined 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));
+        });
+        it('should return undefined 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));
+        });
+        it('should return profile when loading succeeds', () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toEqual(mockProfile);
+            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
+        });
+    });
+    describe('exitIfUsingProfiles()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '1.0.0',
+        };
+        const mockProjectDir = '/test/project';
+        it('should not exit when no profiles exist', async () => {
+            mockedGetAllHsProfiles.mockResolvedValue([]);
+            await exitIfUsingProfiles(mockProjectConfig, mockProjectDir);
+            expect(mockedUiLogger.error).not.toHaveBeenCalled();
+            expect(mockExit).not.toHaveBeenCalled();
+        });
+        it('should exit with 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);
+        });
+    });
+});

package/lib/__tests__/sandboxSync.test.d.ts

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

package/lib/__tests__/sandboxSync.test.js

@@ -0,0 +1,126 @@
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
+import { getAccountId } 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';
+import { syncSandbox } from '../sandboxSync.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../sandboxes');
+vi.mock('../ui/SpinniesManager');
+const mockedLogger = logger;
+const mockedInitiateSync = initiateSync;
+const mockedGetAccountId = getAccountId;
+const mockedGetAvailableSyncTypes = getAvailableSyncTypes;
+const mockedSpinniesInit = SpinniesManager.init;
+const mockedSpinniesAdd = SpinniesManager.add;
+const mockedSpinniesSucceed = SpinniesManager.succeed;
+const mockedSpinniesFail = SpinniesManager.fail;
+describe('lib/sandboxSync', () => {
+    const mockEnv = 'qa';
+    const mockParentAccount = {
+        name: 'Parent Account',
+        portalId: 123,
+        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        env: mockEnv,
+    };
+    const mockChildAccount = {
+        name: 'Child Account',
+        portalId: 456,
+        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        env: mockEnv,
+    };
+    const mockSyncTasks = [{ type: 'mock-sync-type' }];
+    beforeEach(() => {
+        mockedGetAccountId
+            .mockReturnValueOnce(mockChildAccount.portalId)
+            .mockReturnValueOnce(mockParentAccount.portalId);
+        mockedGetAvailableSyncTypes.mockResolvedValue(mockSyncTasks);
+    });
+    describe('syncSandbox()', () => {
+        it('successfully syncs a sandbox with provided sync tasks', async () => {
+            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
+            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
+            expect(mockedSpinniesInit).toHaveBeenCalled();
+            expect(mockedSpinniesAdd).toHaveBeenCalled();
+            expect(mockedInitiateSync).toHaveBeenCalledWith(mockParentAccount.portalId, mockChildAccount.portalId, mockSyncTasks, mockChildAccount.portalId);
+            expect(mockedSpinniesSucceed).toHaveBeenCalled();
+        });
+        it('fetches sync types when no tasks are provided', async () => {
+            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
+            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, []);
+            expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
+            expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
+            expect(mockedInitiateSync).toHaveBeenCalled();
+        });
+        it('throws error when account IDs are missing', async () => {
+            mockedGetAccountId.mockReset();
+            mockedGetAccountId.mockReturnValue(null);
+            const errorRegex = new RegExp(`Couldn't sync ${mockChildAccount.portalId} because your account has been removed from`);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
+        });
+        it('handles sync in progress error', async () => {
+            const error = mockHubSpotHttpError('', {
+                status: 429,
+                data: {
+                    category: 'RATE_LIMITS',
+                    subCategory: 'sandboxes-sync-api.SYNC_IN_PROGRESS',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because there's another sync in progress/));
+        });
+        it('handles invalid user error', async () => {
+            const error = mockHubSpotHttpError('', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USER',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/because your account has been removed from/));
+        });
+        it('handles not super admin error', async () => {
+            const error = mockHubSpotHttpError('', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USERID',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because you are not a super admin in/));
+        });
+        it('handles sandbox not found error', async () => {
+            const error = mockHubSpotHttpError('', {
+                status: 404,
+                data: {
+                    category: 'OBJECT_NOT_FOUND',
+                    subCategory: 'SandboxErrors.SANDBOX_NOT_FOUND',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/may have been deleted through the UI/));
+        });
+        it('displays slim info message when specified', async () => {
+            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
+            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks, true);
+            expect(mockedLogger.info).not.toHaveBeenCalled();
+            expect(mockedSpinniesSucceed).toHaveBeenCalledWith('sandboxSync', expect.objectContaining({
+                text: expect.stringMatching(/Initiated sync of object definitions from production to /),
+            }));
+        });
+    });
+});

package/lib/__tests__/sandboxes.test.d.ts

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

package/lib/__tests__/sandboxes.test.js

@@ -0,0 +1,146 @@
+import { logger } from '@hubspot/local-dev-lib/logger';
+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 { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { mockHubSpotHttpError } from '../testUtils.js';
+import { getSandboxTypeAsString, getHasSandboxesByType, getAvailableSyncTypes, validateSandboxUsageLimits, handleSandboxCreateError, } from '../sandboxes.js';
+vi.mock('@hubspot/local-dev-lib/logger');
+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;
+const mockedGetSandboxUsageLimits = getSandboxUsageLimits;
+const mockedFetchTypes = fetchTypes;
+const mockedGetConfigAccounts = getConfigAccounts;
+const mockedLogger = logger;
+describe('lib/sandboxes', () => {
+    describe('getSandboxTypeAsString()', () => {
+        it('returns "development" for development sandbox type', () => {
+            expect(getSandboxTypeAsString(HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe('development');
+        });
+        it('returns "standard" for standard sandbox type', () => {
+            expect(getSandboxTypeAsString(HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)).toBe('standard');
+        });
+        it('returns "standard" for undefined input', () => {
+            expect(getSandboxTypeAsString(undefined)).toBe('standard');
+        });
+    });
+    describe('getHasSandboxesByType()', () => {
+        const mockParentAccount = {
+            name: 'Parent Account',
+            portalId: 123,
+            authType: undefined,
+            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+            env: 'qa',
+        };
+        it('returns true when sandbox of specified type exists', () => {
+            mockedGetAccountId.mockReturnValue(mockParentAccount.portalId);
+            mockedGetConfigAccounts.mockReturnValue([
+                mockParentAccount,
+                {
+                    ...mockParentAccount,
+                    parentAccountId: 123,
+                    accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                },
+            ]);
+            expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(true);
+        });
+        it('returns false when no sandbox of specified type exists', () => {
+            mockedGetConfigAccounts.mockReturnValue([mockParentAccount]);
+            expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
+        });
+    });
+    describe('getAvailableSyncTypes()', () => {
+        const mockParentAccount = {
+            name: 'Parent Account',
+            portalId: 123,
+            env: 'qa',
+        };
+        const mockChildAccount = {
+            ...mockParentAccount,
+            portalId: 456,
+        };
+        it('returns available sync types when fetch is successful', async () => {
+            const mockSyncTypes = [{ name: 'type1' }, { name: 'type2' }];
+            mockedGetAccountId
+                .mockReturnValue(mockParentAccount.portalId)
+                .mockReturnValue(mockChildAccount.portalId);
+            mockedFetchTypes.mockResolvedValue({
+                data: { results: mockSyncTypes },
+            });
+            const result = await getAvailableSyncTypes(mockParentAccount, mockChildAccount);
+            expect(result).toEqual([{ type: 'type1' }, { type: 'type2' }]);
+        });
+        it('throws error when sync types fetch fails', async () => {
+            mockedFetchTypes.mockResolvedValue({ data: { results: null } });
+            await expect(getAvailableSyncTypes(mockParentAccount, mockChildAccount)).rejects.toThrow(/Unable to fetch available sandbox sync types/);
+        });
+    });
+    describe('validateSandboxUsageLimits()', () => {
+        const mockAccount = {
+            name: 'Test Account',
+            portalId: 123,
+            authType: undefined,
+            env: 'qa',
+        };
+        it('validates successfully when limits are not reached', async () => {
+            mockedGetAccountId.mockReturnValue(mockAccount.portalId);
+            mockedGetSandboxUsageLimits.mockResolvedValue({
+                data: {
+                    usage: { DEVELOPER: { available: 1, limit: 3 } },
+                },
+            });
+            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([]);
+            mockedGetSandboxUsageLimits.mockResolvedValue({
+                data: {
+                    usage: { DEVELOPER: { available: 0, limit: 1 } },
+                },
+            });
+            await expect(validateSandboxUsageLimits(mockAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).rejects.toThrow(/reached the limit of 1 development sandbox/);
+        });
+    });
+    describe('handleSandboxCreateError()', () => {
+        const mockEnv = 'qa';
+        const mockName = 'Test Sandbox';
+        const mockAccountId = 123;
+        it('handles missing scope error', () => {
+            const error = mockHubSpotHttpError('missing scopes error', {
+                status: 403,
+                data: {
+                    message: 'Missing scopes error',
+                    category: 'MISSING_SCOPES',
+                },
+            });
+            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/The personal access key you provided doesn't include sandbox permissions/));
+            expect(mockedLogger.info).toHaveBeenCalledWith(expect.stringMatching(/To update CLI permissions for/));
+        });
+        it('handles user access not allowed error', () => {
+            const error = mockHubSpotHttpError('user access not allowed error', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
+                },
+            });
+            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/your permission set doesn't allow you to create the sandbox/));
+        });
+        it('handles 403 gating error', () => {
+            const error = mockHubSpotHttpError('403 gating error', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
+                },
+            });
+            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/does not have access to development sandboxes/));
+        });
+    });
+});

package/lib/__tests__/serverlessLogs.test.d.ts

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