@hubspot/cli 8.1.0-beta.0 → 8.1.0-experimental.0

package/lib/__tests__/oauth.test.js

@@ -1,109 +0,0 @@
-import express from 'express';
-import open from 'open';
-import { OAuth2Manager } from '@hubspot/local-dev-lib/models/OAuth2Manager';
-import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
-import { uiLogger } from '../ui/logger.js';
-import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
-import { DEFAULT_OAUTH_SCOPES } from '@hubspot/local-dev-lib/constants/auth';
-import { authenticateWithOauth } from '../oauth.js';
-vi.mock('express');
-vi.mock('open');
-vi.mock('@hubspot/local-dev-lib/models/OAuth2Manager');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('@hubspot/local-dev-lib/oauth');
-const mockedExpress = express;
-const mockedOAuth2Manager = OAuth2Manager;
-const mockedGetConfigAccountById = getConfigAccountById;
-describe('lib/oauth', () => {
-    const mockExpressReq = {
-        query: { code: 'test-auth-code' },
-    };
-    const mockExpressResp = { send: vi.fn() };
-    const mockAccountConfig = {
-        name: 'test-account',
-        accountId: 123,
-        authType: 'oauth2',
-        env: ENVIRONMENTS.PROD,
-        auth: {
-            clientId: 'test-client-id',
-            clientSecret: 'test-client-secret',
-            scopes: ['test-scope'],
-        },
-    };
-    beforeEach(() => {
-        mockedExpress.mockReturnValue({
-            get: vi.fn().mockImplementation((path, callback) => {
-                if (path === '/oauth-callback') {
-                    callback(mockExpressReq, mockExpressResp);
-                }
-            }),
-            listen: vi.fn().mockReturnValue({ close: vi.fn() }),
-        });
-    });
-    describe('authenticateWithOauth()', () => {
-        it('should setup OAuth and authenticate successfully', async () => {
-            // Mock successful OAuth flow
-            const mockOAuth2Manager = {
-                account: mockAccountConfig,
-                exchangeForTokens: vi.fn().mockResolvedValue({}),
-            };
-            mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
-            mockedGetConfigAccountById.mockReturnValue({
-                env: ENVIRONMENTS.PROD,
-            });
-            await authenticateWithOauth(mockAccountConfig);
-            // Verify OAuth2Manager was initialized correctly
-            expect(mockedOAuth2Manager).toHaveBeenCalledWith({
-                ...mockAccountConfig,
-                env: ENVIRONMENTS.PROD,
-            });
-            // Verify logger was called
-            expect(uiLogger.log).toHaveBeenCalledWith('Authorizing');
-            // Verify OAuth tokens were added to config
-            expect(addOauthToAccountConfig).toHaveBeenCalledWith(mockOAuth2Manager);
-        });
-        it('should handle missing clientId', async () => {
-            const invalidConfig = {
-                ...mockAccountConfig,
-                auth: {
-                    ...mockAccountConfig.auth,
-                    clientId: undefined,
-                },
-            };
-            mockedOAuth2Manager.mockImplementation(() => ({
-                account: invalidConfig,
-            }));
-            // @ts-expect-error Testing invalid config
-            await expect(authenticateWithOauth(invalidConfig)).rejects.toThrow();
-        });
-        it('should use default scopes when none provided', async () => {
-            const configWithoutScopes = {
-                ...mockAccountConfig,
-                auth: {
-                    ...mockAccountConfig.auth,
-                    scopes: [],
-                },
-            };
-            const mockOAuth2Manager = {
-                account: configWithoutScopes,
-                exchangeForTokens: vi.fn().mockResolvedValue({}),
-            };
-            mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
-            await authenticateWithOauth(configWithoutScopes);
-            // Verify default scopes were used
-            expect(open).toHaveBeenCalledWith(expect.stringContaining(encodeURIComponent(DEFAULT_OAUTH_SCOPES.join(' '))), expect.anything());
-        });
-        it('should handle OAuth exchange failure', async () => {
-            const mockOAuth2Manager = {
-                account: mockAccountConfig,
-                exchangeForTokens: vi
-                    .fn()
-                    .mockRejectedValue(new Error('Exchange failed')),
-            };
-            mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
-            await authenticateWithOauth(mockAccountConfig);
-            expect(mockExpressResp.send).toHaveBeenCalledWith(expect.stringContaining('Authorization failed'));
-        });
-    });
-});

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

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

package/lib/__tests__/parsing.test.js

@@ -1,34 +0,0 @@
-import { parseStringToNumber } from '../parsing.js';
-describe('lib/parsing', () => {
-    describe('parseStringToNumber', () => {
-        it('should parse valid integer strings', () => {
-            expect(parseStringToNumber('123')).toBe(123);
-            expect(parseStringToNumber('0')).toBe(0);
-            expect(parseStringToNumber('-456')).toBe(-456);
-            expect(parseStringToNumber('999')).toBe(999);
-        });
-        it('should parse strings with leading zeros', () => {
-            expect(parseStringToNumber('007')).toBe(7);
-            expect(parseStringToNumber('0123')).toBe(123);
-        });
-        it('should throw error for strings with leading whitespace', () => {
-            expect(() => parseStringToNumber('  42')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('\t123')).toThrow('Unable to parse string to number');
-        });
-        it('should throw error for invalid number strings', () => {
-            expect(() => parseStringToNumber('abc')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('NaN')).toThrow('Unable to parse string to number');
-        });
-        it('should throw error for strings with non-numeric characters', () => {
-            expect(() => parseStringToNumber('123abc')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('456def')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('12.34')).toThrow('Unable to parse string to number');
-        });
-        it('should throw error for strings with mixed content', () => {
-            expect(() => parseStringToNumber('123 456')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('1,234')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('1.23e4')).toThrow('Unable to parse string to number');
-        });
-    });
-});

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

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

package/lib/__tests__/polling.test.js

@@ -1,76 +0,0 @@
-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

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

package/lib/__tests__/process.test.js

@@ -1,89 +0,0 @@
-import readline from 'readline';
-import { uiLogger } from '../ui/logger.js';
-import { 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', async () => {
-    const logger = await vi.importActual('@hubspot/local-dev-lib/logger');
-    return { ...logger, setLogLevel: vi.fn() };
-});
-const mockedReadline = readline;
-const mockedUiLogger = uiLogger;
-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(mockedUiLogger.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(mockedUiLogger.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__/sandboxSync.test.d.ts

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

package/lib/__tests__/sandboxSync.test.js

@@ -1,147 +0,0 @@
-import { uiLogger } from '../ui/logger.js';
-import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
-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';
-import { syncSandbox } from '../sandboxSync.js';
-import SpinniesManager from '../ui/SpinniesManager.js';
-vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../sandboxes');
-vi.mock('../ui/SpinniesManager');
-const mockedUiLogger = uiLogger;
-const mockedInitiateSync = initiateSync;
-const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
-const mockedGetConfigAccountById = getConfigAccountById;
-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',
-        accountId: 123,
-        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-        env: mockEnv,
-        authType: 'personalaccesskey',
-    };
-    const mockChildAccount = {
-        name: 'Child Account',
-        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(() => {
-        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 () => {
-            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
-            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
-            expect(mockedSpinniesInit).toHaveBeenCalled();
-            expect(mockedSpinniesAdd).toHaveBeenCalled();
-            expect(mockedInitiateSync).toHaveBeenCalledWith(mockParentAccount.accountId, mockChildAccount.accountId, mockSyncTasks, mockChildAccount.accountId);
-            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 () => {
-            const errorRegex = new RegExp(`because your account has been removed from`);
-            await expect(syncSandbox(mockChildAccountWithMissingId, 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(mockedUiLogger.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(mockedUiLogger.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(mockedUiLogger.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(mockedUiLogger.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(mockedUiLogger.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

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

package/lib/__tests__/sandboxes.test.js

@@ -1,156 +0,0 @@
-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 { 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('@hubspot/local-dev-lib/api/sandboxHubs');
-vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('@hubspot/local-dev-lib/errors/index');
-const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
-const mockedGetSandboxUsageLimits = getSandboxUsageLimits;
-const mockedFetchTypes = fetchTypes;
-const mockedGetAllConfigAccounts = getAllConfigAccounts;
-const mockedUiLogger = uiLogger;
-const mockedIsMissingScopeError = isMissingScopeError;
-const mockedIsSpecifiedError = isSpecifiedError;
-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',
-            accountId: 123,
-            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-            env: 'qa',
-        };
-        it('returns true when sandbox of specified type exists', () => {
-            mockedGetConfigAccountIfExists.mockReturnValue(mockParentAccount);
-            mockedGetAllConfigAccounts.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', () => {
-            mockedGetAllConfigAccounts.mockReturnValue([mockParentAccount]);
-            expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
-        });
-    });
-    describe('getAvailableSyncTypes()', () => {
-        const mockParentAccount = {
-            name: 'Parent Account',
-            accountId: 123,
-            env: 'qa',
-        };
-        const mockChildAccount = {
-            ...mockParentAccount,
-            accountId: 456,
-        };
-        it('returns available sync types when fetch is successful', async () => {
-            const mockSyncTypes = [{ name: 'type1' }, { name: 'type2' }];
-            mockedGetConfigAccountIfExists
-                .mockReturnValue(mockParentAccount.accountId)
-                .mockReturnValue(mockChildAccount.accountId);
-            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',
-            accountId: 123,
-            env: 'qa',
-        };
-        it('validates successfully when limits are not reached', async () => {
-            mockedGetConfigAccountIfExists.mockReturnValue(mockAccount.accountId);
-            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 () => {
-            mockedGetConfigAccountIfExists.mockReturnValue(mockAccount.accountId);
-            mockedGetAllConfigAccounts.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 developer sandboxes/);
-        });
-    });
-    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',
-                },
-            });
-            // 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/));
-        });
-        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',
-                },
-            });
-            // 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/));
-        });
-        it('handles 403 gating error', () => {
-            const error = mockHubSpotHttpError('403 gating error', {
-                status: 403,
-                data: {
-                    category: 'BANNED',
-                    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(/Couldn't create.*because your account has been removed from.*or your permission set doesn't allow you to create/));
-        });
-    });
-});

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

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