@hubspot/cli 8.1.0 → 8.1.1-experimental.0

package/lib/__tests__/accountAuth.test.js

@@ -1,258 +0,0 @@
-import { updateConfigAccount, createEmptyConfigFile, getConfigFilePath, localConfigFileExists, globalConfigFileExists, setConfigAccountAsDefault, } from '@hubspot/local-dev-lib/config';
-import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
-import { toKebabCase } from '@hubspot/local-dev-lib/text';
-import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
-import { handleMerge, handleMigration } from '../configMigrate.js';
-import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
-import { cliAccountNamePrompt } from '../prompts/accountNamePrompt.js';
-import { setAsDefaultAccountPrompt } from '../prompts/setAsDefaultAccountPrompt.js';
-import { authenticateNewAccount } from '../accountAuth.js';
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('@hubspot/local-dev-lib/personalAccessKey');
-vi.mock('@hubspot/local-dev-lib/text');
-vi.mock('../configMigrate.js');
-vi.mock('../errorHandlers/index.js');
-vi.mock('../prompts/personalAccessKeyPrompt.js');
-vi.mock('../prompts/accountNamePrompt.js');
-vi.mock('../prompts/setAsDefaultAccountPrompt.js');
-vi.mock('../ui/logger.js', () => ({
-    uiLogger: {
-        log: vi.fn(),
-        error: vi.fn(),
-        success: vi.fn(),
-    },
-}));
-const mockedUpdateConfigAccount = updateConfigAccount;
-const mockedCreateEmptyConfigFile = createEmptyConfigFile;
-const mockedGetConfigFilePath = getConfigFilePath;
-const mockedLocalConfigFileExists = localConfigFileExists;
-const mockedGlobalConfigFileExists = globalConfigFileExists;
-const mockedSetConfigAccountAsDefault = setConfigAccountAsDefault;
-const mockedGetAccessToken = getAccessToken;
-const mockedUpdateConfigWithAccessToken = updateConfigWithAccessToken;
-const mockedToKebabCase = toKebabCase;
-const mockedHandleMerge = handleMerge;
-const mockedHandleMigration = handleMigration;
-const mockedPersonalAccessKeyPrompt = personalAccessKeyPrompt;
-const mockedCliAccountNamePrompt = cliAccountNamePrompt;
-const mockedSetAsDefaultAccountPrompt = setAsDefaultAccountPrompt;
-describe('lib/accountAuth', () => {
-    describe('authenticateNewAccount()', () => {
-        const mockAccessToken = {
-            portalId: 123456,
-            accessToken: 'test-token',
-            expiresAt: '2025-01-01',
-            scopeGroups: ['test-scope'],
-            enabledFeatures: { 'test-feature': 1 },
-            encodedOAuthRefreshToken: 'test-refresh-token',
-            hubName: 'Test Hub',
-            accountType: 'STANDARD',
-        };
-        const mockAccountConfig = {
-            name: 'test-hub',
-            accountId: 123456,
-            env: 'prod',
-            accountType: 'STANDARD',
-            authType: PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
-            personalAccessKey: 'test-key',
-            auth: {
-                tokenInfo: {
-                    accessToken: 'test-token',
-                    expiresAt: '2025-01-01',
-                },
-            },
-        };
-        beforeEach(() => {
-            vi.clearAllMocks();
-            mockedLocalConfigFileExists.mockReturnValue(false);
-            mockedGlobalConfigFileExists.mockReturnValue(false);
-            mockedGetAccessToken.mockResolvedValue(mockAccessToken);
-            mockedUpdateConfigWithAccessToken.mockResolvedValue(mockAccountConfig);
-            mockedToKebabCase.mockReturnValue('test-hub');
-            mockedCliAccountNamePrompt.mockResolvedValue({ name: 'test-hub' });
-            mockedGetConfigFilePath.mockReturnValue('/path/to/config');
-            mockedPersonalAccessKeyPrompt.mockResolvedValue({
-                personalAccessKey: 'test-key',
-            });
-        });
-        it('should create config file if it does not exist', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(false);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCreateEmptyConfigFile).toHaveBeenCalledWith(true);
-        });
-        it('should not create config file if it already exists', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCreateEmptyConfigFile).not.toHaveBeenCalled();
-        });
-        it('should use provided personal access key without prompting', async () => {
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedPersonalAccessKeyPrompt).not.toHaveBeenCalled();
-            expect(mockedGetAccessToken).toHaveBeenCalledWith('test-key', 'prod');
-        });
-        it('should prompt for personal access key if not provided', async () => {
-            await authenticateNewAccount({
-                env: 'prod',
-                accountId: 123456,
-            });
-            expect(mockedPersonalAccessKeyPrompt).toHaveBeenCalledWith({
-                env: 'prod',
-                account: 123456,
-            });
-            expect(mockedGetAccessToken).toHaveBeenCalledWith('test-key', 'prod');
-        });
-        it('should prompt for account name if config does not exist', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(false);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCliAccountNamePrompt).toHaveBeenCalledWith('test-hub');
-        });
-        it('should not prompt for account name if config already exists', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCliAccountNamePrompt).not.toHaveBeenCalled();
-        });
-        it('should set account as default when setAsDefaultAccount is true', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-                setAsDefaultAccount: true,
-            });
-            expect(mockedSetConfigAccountAsDefault).toHaveBeenCalledWith('test-hub');
-        });
-        it('should prompt to set as default when setAsDefaultAccount is not provided and config exists', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedSetAsDefaultAccountPrompt).toHaveBeenCalledWith('test-hub');
-        });
-        it('should return the updated account config on success', async () => {
-            const result = await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(result).toEqual(mockAccountConfig);
-        });
-        it('should return null if access token fetch fails', async () => {
-            mockedGetAccessToken.mockRejectedValue(new Error('Invalid token'));
-            const result = await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(result).toBeNull();
-        });
-        it('should return null if config update fails', async () => {
-            mockedUpdateConfigWithAccessToken.mockResolvedValue(null);
-            const result = await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(result).toBeNull();
-        });
-        it('should handle missing account name and prompt for it', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            mockedUpdateConfigWithAccessToken.mockResolvedValue({
-                ...mockAccountConfig,
-                name: undefined,
-            });
-            mockedCliAccountNamePrompt.mockResolvedValue({
-                name: 'new-account-name',
-            });
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCliAccountNamePrompt).toHaveBeenCalledWith('test-hub');
-            expect(mockedUpdateConfigAccount).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'new-account-name',
-            }));
-        });
-        describe('config migration', () => {
-            it('should handle migration when local config exists and global does not', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(false);
-                mockedHandleMigration.mockResolvedValue(true);
-                await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(mockedHandleMigration).toHaveBeenCalled();
-                expect(mockedHandleMerge).not.toHaveBeenCalled();
-            });
-            it('should handle merge when both local and global configs exist', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(true);
-                mockedHandleMerge.mockResolvedValue(true);
-                await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(mockedHandleMerge).toHaveBeenCalled();
-                expect(mockedHandleMigration).not.toHaveBeenCalled();
-            });
-            it('should return null if migration is not confirmed', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(false);
-                mockedHandleMigration.mockResolvedValue(false);
-                const result = await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(result).toBeNull();
-            });
-            it('should return null if merge is not confirmed', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(true);
-                mockedHandleMerge.mockResolvedValue(false);
-                const result = await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(result).toBeNull();
-            });
-            it('should return null if migration throws error', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(false);
-                mockedHandleMigration.mockRejectedValue(new Error('Migration failed'));
-                const result = await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(result).toBeNull();
-            });
-        });
-    });
-});

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

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

package/lib/__tests__/accountTypes.test.js

@@ -1,98 +0,0 @@
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { isStandardAccount, isSandbox, isStandardSandbox, isDevelopmentSandbox, isDeveloperTestAccount, isAppDeveloperAccount, } from '../accountTypes.js';
-const STANDARD_ACCOUNT = {
-    name: 'standard-account',
-    accountId: 123,
-    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-    env: 'prod',
-};
-const DEVELOPMENT_SANDBOX_ACCOUNT = {
-    name: 'development-sandbox-account',
-    accountId: 456,
-    accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    env: 'prod',
-};
-const STANDARD_SANDBOX_ACCOUNT = {
-    name: 'sandbox-account',
-    accountId: 456,
-    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-    env: 'prod',
-};
-const DEVELOPER_TEST_ACCOUNT = {
-    name: 'developer-test-account',
-    accountId: 789,
-    accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
-    env: 'prod',
-};
-const APP_DEVELOPER_ACCOUNT = {
-    name: 'app-developer-account',
-    accountId: 1011,
-    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
-    env: 'prod',
-};
-describe('lib/accountTypes', () => {
-    describe('isStandardAccount()', () => {
-        it('should return true if the account is a standard account', () => {
-            const result = isStandardAccount(STANDARD_ACCOUNT);
-            expect(result).toBe(true);
-        });
-        it('should return false if the account is not a standard account', () => {
-            const result = isStandardAccount(DEVELOPER_TEST_ACCOUNT);
-            expect(result).toBe(false);
-        });
-    });
-    describe('isSandbox()', () => {
-        it('should return true if the account is a standard sandbox account', () => {
-            const result = isSandbox(STANDARD_SANDBOX_ACCOUNT);
-            expect(result).toBe(true);
-        });
-        it('should return true if the account is a development sandbox account', () => {
-            const result = isSandbox(DEVELOPMENT_SANDBOX_ACCOUNT);
-            expect(result).toBe(true);
-        });
-        it('should return false if the account is not a sandbox account', () => {
-            const result = isSandbox(STANDARD_ACCOUNT);
-            expect(result).toBe(false);
-        });
-    });
-    describe('isStandardSandbox()', () => {
-        it('should return true if the account is a standard sandbox account', () => {
-            const result = isStandardSandbox(STANDARD_SANDBOX_ACCOUNT);
-            expect(result).toBe(true);
-        });
-        it('should return false if the account is not a standard sandbox account', () => {
-            const result = isStandardSandbox(DEVELOPMENT_SANDBOX_ACCOUNT);
-            expect(result).toBe(false);
-        });
-    });
-    describe('isDevelopmentSandbox()', () => {
-        it('should return true if the account is a development sandbox account', () => {
-            const result = isDevelopmentSandbox(DEVELOPMENT_SANDBOX_ACCOUNT);
-            expect(result).toBe(true);
-        });
-        it('should return false if the account is not a development sandbox account', () => {
-            const result = isDevelopmentSandbox(STANDARD_ACCOUNT);
-            expect(result).toBe(false);
-        });
-    });
-    describe('isDeveloperTestAccount()', () => {
-        it('should return true if the account is a developer test account', () => {
-            const result = isDeveloperTestAccount(DEVELOPER_TEST_ACCOUNT);
-            expect(result).toBe(true);
-        });
-        it('should return false if the account is not a developer test account', () => {
-            const result = isDeveloperTestAccount(STANDARD_ACCOUNT);
-            expect(result).toBe(false);
-        });
-    });
-    describe('isAppDeveloperAccount()', () => {
-        it('should return true if the account is an app developer account', () => {
-            const result = isAppDeveloperAccount(APP_DEVELOPER_ACCOUNT);
-            expect(result).toBe(true);
-        });
-        it('should return false if the account is not an app developer account', () => {
-            const result = isAppDeveloperAccount(STANDARD_ACCOUNT);
-            expect(result).toBe(false);
-        });
-    });
-});

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

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

package/lib/__tests__/buildAccount.test.js

@@ -1,262 +0,0 @@
-import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
-import { getConfigAccountIfExists, updateConfigAccount, } from '@hubspot/local-dev-lib/config';
-import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, generateDeveloperTestAccountPersonalAccessKey, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
-import { createSandbox, createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
-import { cliAccountNamePrompt } from '../prompts/accountNamePrompt.js';
-import * as buildAccount from '../buildAccount.js';
-import { poll } from '../polling.js';
-vi.mock('@hubspot/local-dev-lib/personalAccessKey');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('@hubspot/local-dev-lib/api/developerTestAccounts');
-vi.mock('@hubspot/local-dev-lib/api/sandboxHubs');
-vi.mock('../errorHandlers/index.js');
-vi.mock('../prompts/personalAccessKeyPrompt');
-vi.mock('../prompts/accountNamePrompt');
-vi.mock('../polling.js');
-vi.mock('../ui/SpinniesManager', () => ({
-    default: {
-        init: vi.fn(),
-        add: vi.fn(),
-        succeed: vi.fn(),
-        fail: vi.fn(),
-    },
-}));
-const mockedPersonalAccessKeyPrompt = personalAccessKeyPrompt;
-const mockedGetAccessToken = getAccessToken;
-const mockedUpdateConfigWithAccessToken = updateConfigWithAccessToken;
-const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
-const mockedUpdateConfigAccount = updateConfigAccount;
-const mockedCliAccountNamePrompt = cliAccountNamePrompt;
-const mockedCreateDeveloperTestAccount = createDeveloperTestAccount;
-const mockedFetchDeveloperTestAccountGateSyncStatus = fetchDeveloperTestAccountGateSyncStatus;
-const mockedGenerateDeveloperTestAccountPersonalAccessKey = generateDeveloperTestAccountPersonalAccessKey;
-const mockedCreateSandbox = createSandbox;
-const mockedCreateV2Sandbox = createV2Sandbox;
-const mockedGetPersonalAccessKey = getSandboxPersonalAccessKey;
-const mockedPoll = poll;
-describe('lib/buildAccount', () => {
-    describe('saveAccountToConfig()', () => {
-        const mockAccountConfig = {
-            name: 'Test Account',
-            accountId: 123456,
-            accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
-            env: 'prod',
-        };
-        const accessToken = {
-            portalId: 123456,
-            accessToken: 'test-token',
-            expiresAt: '2025-01-01',
-            scopeGroups: ['test-scope'],
-            enabledFeatures: { 'test-feature': 1 },
-            encodedOAuthRefreshToken: 'test-refresh-token',
-            hubName: 'test-hub',
-            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-        };
-        beforeEach(() => {
-            mockedPersonalAccessKeyPrompt.mockResolvedValue({
-                personalAccessKey: 'test-key',
-                env: 'prod',
-            });
-            mockedGetAccessToken.mockResolvedValue(accessToken);
-            mockedUpdateConfigWithAccessToken.mockResolvedValue(mockAccountConfig);
-            mockedGetConfigAccountIfExists.mockResolvedValue(undefined);
-            mockedUpdateConfigAccount.mockReturnValue(undefined);
-        });
-        it('should save account with provided personal access key', async () => {
-            const result = await buildAccount.saveAccountToConfig(mockAccountConfig.accountId, mockAccountConfig.name, mockAccountConfig.env, 'test-key');
-            expect(mockedPersonalAccessKeyPrompt).not.toHaveBeenCalled();
-            expect(mockedUpdateConfigWithAccessToken).toHaveBeenCalledWith(accessToken, 'test-key', mockAccountConfig.env);
-            expect(mockedUpdateConfigAccount).toHaveBeenCalledWith(expect.objectContaining(mockAccountConfig));
-            expect(result).toBe(mockAccountConfig.name);
-        });
-        it('should prompt for personal access key if not provided', async () => {
-            const result = await buildAccount.saveAccountToConfig(mockAccountConfig.accountId, mockAccountConfig.name, mockAccountConfig.env);
-            expect(mockedPersonalAccessKeyPrompt).toHaveBeenCalledWith({
-                env: mockAccountConfig.env,
-                account: mockAccountConfig.accountId,
-            });
-            expect(mockedUpdateConfigWithAccessToken).toHaveBeenCalledWith(accessToken, 'test-key', mockAccountConfig.env);
-            expect(mockedUpdateConfigAccount).toHaveBeenCalledWith(expect.objectContaining(mockAccountConfig));
-            expect(result).toBe(mockAccountConfig.name);
-        });
-        it('should handle duplicate account names', async () => {
-            const mockAccountConfigWithNoName = {
-                ...mockAccountConfig,
-                name: undefined,
-            };
-            mockedUpdateConfigWithAccessToken.mockResolvedValue(mockAccountConfigWithNoName);
-            mockedGetConfigAccountIfExists.mockResolvedValue({ accountId: 123 });
-            mockedCliAccountNamePrompt.mockResolvedValue({
-                name: 'test-account-with-new-name',
-            });
-            const result = await buildAccount.saveAccountToConfig(mockAccountConfig.accountId, mockAccountConfig.name, mockAccountConfig.env, 'test-key');
-            expect(mockedCliAccountNamePrompt).toHaveBeenCalled();
-            expect(result).toBe('test-account-with-new-name');
-        });
-    });
-    describe('createDeveloperTestAccountV2()', () => {
-        const parentAccountId = 123456;
-        const mockDeveoperTestAccountConfig = {
-            accountName: 'Developer Test Account',
-            description: 'Test Account created by the HubSpot CLI',
-        };
-        beforeEach(() => {
-            vi.useFakeTimers();
-            mockedCreateDeveloperTestAccount.mockResolvedValue({
-                data: { id: 123456 },
-            });
-            mockedFetchDeveloperTestAccountGateSyncStatus.mockResolvedValue({
-                data: { status: 'SUCCESS' },
-            });
-            mockedGenerateDeveloperTestAccountPersonalAccessKey.mockResolvedValue({
-                data: { personalAccessKey: 'test-key' },
-            });
-            // Mock poll to resolve immediately with the success status
-            mockedPoll.mockResolvedValue({ status: 'SUCCESS' });
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-        });
-        it('should create a developer test account successfully', async () => {
-            const resultPromise = buildAccount.createDeveloperTestAccountV2(parentAccountId, mockDeveoperTestAccountConfig);
-            // Fast-forward the 5 second setTimeout
-            await vi.advanceTimersByTimeAsync(5000);
-            const result = await resultPromise;
-            expect(result).toEqual({
-                accountName: mockDeveoperTestAccountConfig.accountName,
-                accountId: 123456,
-                personalAccessKey: 'test-key',
-            });
-        });
-    });
-    describe('buildDeveloperTestAccount()', () => {
-        const mockParentAccountConfig = {
-            name: 'Developer Account',
-            accountId: 123456,
-            accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
-            env: 'prod',
-        };
-        const mockDeveloperTestAccount = {
-            testPortalId: 56789,
-            parentPortalId: 123456,
-            accountName: 'Developer Test Account',
-            createdAt: '2025-01-01',
-            updatedAt: '2025-01-01',
-            status: 'active',
-            id: 56789,
-        };
-        beforeEach(() => {
-            vi.spyOn(buildAccount, 'saveAccountToConfig').mockResolvedValue(mockParentAccountConfig.name);
-            mockedCreateDeveloperTestAccount.mockResolvedValue({
-                data: mockDeveloperTestAccount,
-            });
-        });
-        it('should create a developer test account successfully', async () => {
-            const result = await buildAccount.buildDeveloperTestAccount(mockDeveloperTestAccount.accountName, mockParentAccountConfig, mockParentAccountConfig.env, 10);
-            expect(result).toEqual(mockDeveloperTestAccount.id);
-        });
-        it('should handle API errors when creating developer test account', async () => {
-            mockedCreateDeveloperTestAccount.mockRejectedValue(new Error('test-error'));
-            await expect(buildAccount.buildDeveloperTestAccount(mockDeveloperTestAccount.accountName, mockParentAccountConfig, mockParentAccountConfig.env, 10)).rejects.toThrow();
-        });
-    });
-    describe('buildSandbox()', () => {
-        const mockParentAccountConfig = {
-            name: 'Prod account',
-            accountId: 123456,
-            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-            env: 'prod',
-        };
-        const mockSandbox = {
-            sandboxHubId: 56789,
-            parentHubId: 123456,
-            createdAt: '2025-01-01',
-            type: 'STANDARD',
-            version: 'V1',
-            archived: false,
-            name: 'Test Sandbox',
-            domain: 'test-sandbox.hubspot.com',
-            createdByUser: {
-                id: 123456,
-                email: 'test@test.com',
-                firstName: 'Test',
-                lastName: 'User',
-            },
-        };
-        beforeEach(() => {
-            vi.spyOn(buildAccount, 'saveAccountToConfig').mockResolvedValue(mockParentAccountConfig.name);
-            mockedCreateSandbox.mockResolvedValue({
-                data: { sandbox: mockSandbox, personalAccessKey: 'test-key' },
-            });
-        });
-        it('should create a standard sandbox successfully', async () => {
-            const result = await buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, mockParentAccountConfig.env, false);
-            expect(result).toEqual({
-                name: mockSandbox.name,
-                personalAccessKey: 'test-key',
-                sandbox: mockSandbox,
-            });
-        });
-        it('should create a development sandbox successfully', async () => {
-            const result = await buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, mockParentAccountConfig.env);
-            expect(result).toEqual({
-                name: mockSandbox.name,
-                personalAccessKey: 'test-key',
-                sandbox: mockSandbox,
-            });
-        });
-        it('should handle API errors when creating sandbox', async () => {
-            mockedCreateSandbox.mockRejectedValue(new Error('test-error'));
-            await expect(buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, mockParentAccountConfig.env, false)).rejects.toThrow();
-        });
-    });
-    describe('buildV2Sandbox()', () => {
-        const mockParentAccountConfig = {
-            name: 'Prod account',
-            accountId: 123456,
-            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-            env: 'prod',
-        };
-        const mockSandbox = {
-            sandboxHubId: 56789,
-            parentHubId: 123456,
-            createdAt: '2025-01-01',
-            type: 'STANDARD',
-            archived: false,
-            version: 'V2',
-            name: 'Test v2 Sandbox',
-            domain: 'test-v2-sandbox.hubspot.com',
-            createdByUser: {
-                id: 123456,
-                email: 'test@test.com',
-                firstName: 'Test',
-                lastName: 'User',
-            },
-        };
-        beforeEach(() => {
-            vi.spyOn(buildAccount, 'saveAccountToConfig').mockResolvedValue(mockParentAccountConfig.name);
-            mockedCreateV2Sandbox.mockResolvedValue({
-                data: mockSandbox,
-            });
-            mockedGetPersonalAccessKey.mockResolvedValue({
-                data: { personalAccessKey: { encodedOAuthRefreshToken: 'test-key' } },
-            });
-        });
-        it('should create a v2 standard sandbox successfully and fetch a personal access key', async () => {
-            const result = await buildAccount.buildV2Sandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, false, mockParentAccountConfig.env, false);
-            expect(result).toEqual({ sandbox: mockSandbox });
-            expect(mockedGetPersonalAccessKey).toHaveBeenCalledWith(mockParentAccountConfig.accountId, mockSandbox.sandboxHubId);
-        });
-        it('should create a development sandbox successfully and fetch a personal access key', async () => {
-            const result = await buildAccount.buildV2Sandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, false, mockParentAccountConfig.env, false);
-            expect(result).toEqual({ sandbox: mockSandbox });
-            expect(mockedGetPersonalAccessKey).toHaveBeenCalledWith(mockParentAccountConfig.accountId, mockSandbox.sandboxHubId);
-        });
-        it('should handle API errors when creating sandbox', async () => {
-            mockedCreateV2Sandbox.mockRejectedValue(new Error('test-error'));
-            await expect(buildAccount.buildV2Sandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, false, mockParentAccountConfig.env, false)).rejects.toThrow();
-        });
-    });
-});

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

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