@hubspot/cli 8.0.11-experimental.0 → 8.0.11-experimental.1

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,211 +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 { 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 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('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 {};

package/lib/__tests__/cliUpgradeUtils.test.js

@@ -1,131 +0,0 @@
-import updateNotifier from 'update-notifier';
-import { isCliGloballyInstalled, canCliBeAutoUpgraded, getLatestCliVersion, getCliUpgradeInfo, installCliVersion, } from '../cliUpgradeUtils.js';
-import { isGloballyInstalled, getLatestPackageVersion, executeInstall, isInstalledGloballyWithNPM, } from '../npm/npmCli.js';
-import { pkg } from '../jsonLoader.js';
-vi.mock('../npm/npmCli');
-vi.mock('update-notifier');
-vi.mock('../jsonLoader.js', () => ({
-    pkg: {
-        name: '@hubspot/cli',
-        version: '7.11.2',
-    },
-}));
-const mockedIsGloballyInstalled = vi.mocked(isGloballyInstalled);
-const mockedGetLatestPackageVersion = vi.mocked(getLatestPackageVersion);
-const mockedExecuteInstall = vi.mocked(executeInstall);
-const mockedUpdateNotifier = vi.mocked(updateNotifier);
-const mockedIsInstalledGloballyWithNPM = vi.mocked(isInstalledGloballyWithNPM);
-describe('lib/cliUpgradeUtils', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('isCliGloballyInstalled()', () => {
-        it('should return true when hs is globally installed', async () => {
-            mockedIsGloballyInstalled.mockResolvedValueOnce(true);
-            const result = await isCliGloballyInstalled();
-            expect(result).toBe(true);
-            expect(mockedIsGloballyInstalled).toHaveBeenCalledTimes(1);
-            expect(mockedIsGloballyInstalled).toHaveBeenCalledWith('hs');
-        });
-        it('should return false when hs is not globally installed', async () => {
-            mockedIsGloballyInstalled.mockResolvedValueOnce(false);
-            const result = await isCliGloballyInstalled();
-            expect(result).toBe(false);
-            expect(mockedIsGloballyInstalled).toHaveBeenCalledTimes(1);
-            expect(mockedIsGloballyInstalled).toHaveBeenCalledWith('hs');
-        });
-    });
-    describe('canCliBeAutoUpgraded()', () => {
-        it('should return true when package is installed globally via npm', async () => {
-            mockedIsInstalledGloballyWithNPM.mockResolvedValueOnce(true);
-            const result = await canCliBeAutoUpgraded();
-            expect(result).toBe(true);
-            expect(mockedIsInstalledGloballyWithNPM).toHaveBeenCalledTimes(1);
-            expect(mockedIsInstalledGloballyWithNPM).toHaveBeenCalledWith(pkg.name);
-        });
-        it('should return false when package is not installed globally via npm', async () => {
-            mockedIsInstalledGloballyWithNPM.mockResolvedValueOnce(false);
-            const result = await canCliBeAutoUpgraded();
-            expect(result).toBe(false);
-            expect(mockedIsInstalledGloballyWithNPM).toHaveBeenCalledTimes(1);
-            expect(mockedIsInstalledGloballyWithNPM).toHaveBeenCalledWith(pkg.name);
-        });
-    });
-    describe('getLatestCliVersion()', () => {
-        it('should return the latest CLI version', async () => {
-            const latest = '7.12.0';
-            const next = '7.12.0-beta.1';
-            mockedGetLatestPackageVersion.mockResolvedValueOnce({ latest, next });
-            const result = await getLatestCliVersion();
-            expect(result).toEqual({ latest, next });
-            expect(mockedGetLatestPackageVersion).toHaveBeenCalledTimes(1);
-            expect(mockedGetLatestPackageVersion).toHaveBeenCalledWith(pkg.name);
-        });
-        it('should throw errors from getLatestPackageVersion', async () => {
-            const errorMessage = 'Failed to get version';
-            mockedGetLatestPackageVersion.mockRejectedValueOnce(new Error(errorMessage));
-            await expect(getLatestCliVersion()).rejects.toThrow(errorMessage);
-            expect(mockedGetLatestPackageVersion).toHaveBeenCalledWith(pkg.name);
-        });
-    });
-    describe('getCliUpgradeInfo()', () => {
-        it('should return upgrade info when update is available', () => {
-            const mockNotifier = {
-                update: {
-                    current: '7.11.2',
-                    latest: '7.12.0',
-                    type: 'minor',
-                },
-            };
-            mockedUpdateNotifier.mockReturnValue(mockNotifier);
-            const result = getCliUpgradeInfo();
-            expect(result).toMatchObject({
-                current: '7.11.2',
-                latest: '7.12.0',
-                type: 'minor',
-            });
-            expect(mockedUpdateNotifier).toHaveBeenCalledWith({
-                pkg,
-                distTag: 'latest',
-                shouldNotifyInNpmScript: true,
-            });
-        });
-        it('should return cached info on subsequent calls', () => {
-            const mockNotifier = {
-                update: {
-                    current: '7.11.2',
-                    latest: '7.12.0',
-                    type: 'minor',
-                },
-            };
-            mockedUpdateNotifier.mockReturnValue(mockNotifier);
-            const firstCall = getCliUpgradeInfo();
-            const secondCall = getCliUpgradeInfo();
-            expect(firstCall).toEqual(secondCall);
-            expect(firstCall.current).toBe('7.11.2');
-            expect(firstCall.latest).toBe('7.12.0');
-            expect(firstCall.type).toBe('minor');
-        });
-    });
-    describe('installCliVersion()', () => {
-        it('should install latest version by default', async () => {
-            mockedExecuteInstall.mockResolvedValueOnce(undefined);
-            await installCliVersion();
-            expect(mockedExecuteInstall).toHaveBeenCalledTimes(1);
-            expect(mockedExecuteInstall).toHaveBeenCalledWith([`${pkg.name}@latest`], '-g');
-        });
-        it('should install a specific version when provided', async () => {
-            const version = '7.12.0';
-            mockedExecuteInstall.mockResolvedValueOnce(undefined);
-            await installCliVersion(version);
-            expect(mockedExecuteInstall).toHaveBeenCalledTimes(1);
-            expect(mockedExecuteInstall).toHaveBeenCalledWith([`${pkg.name}@${version}`], '-g');
-        });
-        it('should throw errors from executeInstall', async () => {
-            const errorMessage = 'Installation failed';
-            mockedExecuteInstall.mockRejectedValueOnce(new Error(errorMessage));
-            await expect(installCliVersion()).rejects.toThrow(errorMessage);
-            expect(mockedExecuteInstall).toHaveBeenCalledWith([`${pkg.name}@latest`], '-g');
-        });
-    });
-});

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

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

package/lib/__tests__/commandSuggestion.test.js

@@ -1,121 +0,0 @@
-import yargs from 'yargs';
-import { addCommandSuggestions, commandSuggestionMappings, } from '../commandSuggestion.js';
-import { uiLogger } from '../ui/logger.js';
-import { uiCommandReference } from '../ui/index.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-vi.mock('../ui/logger.js');
-vi.mock('../ui/index.js');
-const commandSpy = vi
-    .spyOn(yargs, 'command')
-    .mockReturnValue(yargs);
-describe('lib/commandSuggestion', () => {
-    const uiLoggerErrorMock = uiLogger.error;
-    const uiCommandReferenceMock = uiCommandReference;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        commandSpy.mockClear();
-        uiCommandReferenceMock.mockImplementation((command) => `\`${command}\``);
-    });
-    describe('addCommandSuggestions', () => {
-        it('adds all command suggestions to yargs instance', () => {
-            addCommandSuggestions(yargs);
-            expect(commandSpy).toHaveBeenCalledTimes(Object.keys(commandSuggestionMappings).length);
-        });
-        it('registers each mapping from commandSuggestionMappings', () => {
-            addCommandSuggestions(yargs);
-            Object.entries(commandSuggestionMappings).forEach(([oldCommand]) => {
-                expect(commandSpy).toHaveBeenCalledWith(expect.objectContaining({
-                    command: oldCommand,
-                }));
-            });
-        });
-        it('returns the yargs instance', () => {
-            const yargsInstance = yargs;
-            const result = addCommandSuggestions(yargsInstance);
-            expect(result).toBe(yargsInstance);
-        });
-        it('creates command modules with handler that logs error and exits', () => {
-            vi.spyOn(process, 'exit').mockImplementation(() => {
-                throw new Error(`process.exit called with ${EXIT_CODES.ERROR}`);
-            });
-            addCommandSuggestions(yargs);
-            // Get the first registered command module
-            const firstCall = commandSpy.mock.calls[0];
-            const commandModule = firstCall[0];
-            const firstMapping = Object.entries(commandSuggestionMappings)[0];
-            const [, newCommand] = firstMapping;
-            // Verify the command module structure
-            expect(commandModule).toHaveProperty('command');
-            expect(commandModule).toHaveProperty('handler');
-            expect(commandModule).toHaveProperty('builder');
-            // Invoke the handler to verify behavior
-            expect(() => {
-                commandModule.handler({});
-            }).toThrow('process.exit called');
-            expect(uiCommandReferenceMock).toHaveBeenCalledWith(newCommand);
-            expect(uiLoggerErrorMock).toHaveBeenCalledWith(`Did you mean \`${newCommand}\`?`);
-            expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            vi.restoreAllMocks();
-        });
-        it('creates command modules with builder that sets strict mode to false', async () => {
-            const yargsInstance = yargs;
-            const commandSpyForTest = vi
-                .spyOn(yargsInstance, 'command')
-                .mockReturnValue(yargsInstance);
-            addCommandSuggestions(yargsInstance);
-            // Get a command module and verify it has a builder
-            const firstCall = commandSpyForTest.mock.calls[0];
-            const commandModule = firstCall[0];
-            expect(commandModule).toHaveProperty('builder');
-            expect(typeof commandModule.builder).toBe('function');
-            // Create a mock yargs builder with strict method
-            const mockYargsBuilder = {
-                strict: vi.fn().mockReturnThis(),
-                help: vi.fn().mockReturnThis(),
-                version: vi.fn().mockReturnThis(),
-            };
-            await commandModule.builder(mockYargsBuilder);
-            expect(mockYargsBuilder.strict).toHaveBeenCalledWith(false);
-            commandSpyForTest.mockRestore();
-        });
-        it('handles commands with multiple words', () => {
-            vi.spyOn(process, 'exit').mockImplementation(() => {
-                throw new Error(`process.exit called with ${EXIT_CODES.ERROR}`);
-            });
-            // Find a multi-word command
-            const multiWordCommand = Object.entries(commandSuggestionMappings).find(([oldCommand]) => oldCommand.includes(' '));
-            expect(multiWordCommand).toBeDefined();
-            if (multiWordCommand) {
-                const [oldCommand, newCommand] = multiWordCommand;
-                const yargsInstance = yargs;
-                const commandSpyForTest = vi
-                    .spyOn(yargsInstance, 'command')
-                    .mockReturnValue(yargsInstance);
-                addCommandSuggestions(yargsInstance);
-                // Find the call for this multi-word command
-                const call = commandSpyForTest.mock.calls.find(call => call[0]
-                    .command === oldCommand);
-                expect(call).toBeDefined();
-                const commandModule = call[0];
-                expect(commandModule).toHaveProperty('handler');
-                // Invoke handler to verify it works with multi-word commands
-                expect(() => {
-                    commandModule.handler({});
-                }).toThrow('process.exit called');
-                expect(uiCommandReferenceMock).toHaveBeenCalledWith(newCommand);
-                expect(uiLoggerErrorMock).toHaveBeenCalledWith(`Did you mean \`${newCommand}\`?`);
-                commandSpyForTest.mockRestore();
-            }
-            vi.restoreAllMocks();
-        });
-    });
-    describe('commandSuggestionMappings', () => {
-        it('all mappings point to valid new commands', () => {
-            Object.entries(commandSuggestionMappings).forEach(([, newCommand]) => {
-                expect(newCommand).toMatch(/^hs /);
-                expect(typeof newCommand).toBe('string');
-                expect(newCommand.length).toBeGreaterThan(0);
-            });
-        });
-    });
-});

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

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

package/lib/__tests__/commonOpts.test.js

@@ -1,80 +0,0 @@
-import { CMS_PUBLISH_MODE, DEFAULT_CMS_PUBLISH_MODE, } from '@hubspot/local-dev-lib/constants/files';
-import { getConfig, getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { getCmsPublishMode } from '../commonOpts.js';
-const mockedGetConfigAccountById = getConfigAccountById;
-const mockedGetConfig = getConfig;
-function buildArguments(args) {
-    return {
-        _: [],
-        $0: '',
-        ...args,
-    };
-}
-vi.mock('@hubspot/local-dev-lib/config');
-describe('lib/commonOpts', () => {
-    describe('getCmsPublishMode()', () => {
-        const accounts = {
-            PROD: 123,
-            DEV: 456,
-        };
-        const devAccountConfig = {
-            accountId: accounts.DEV,
-            name: 'DEV',
-            defaultCmsPublishMode: CMS_PUBLISH_MODE.draft,
-        };
-        const prodAccountConfig = {
-            accountId: accounts.PROD,
-            name: 'PROD',
-        };
-        const config = {
-            defaultAccount: 'DEV',
-            accounts: [devAccountConfig, prodAccountConfig],
-        };
-        const configWithDefaultCmsPublishMode = {
-            ...config,
-            defaultCmsPublishMode: CMS_PUBLISH_MODE.draft,
-        };
-        afterEach(() => {
-            vi.resetAllMocks();
-        });
-        describe('cms publish mode option precedence', () => {
-            describe('1. --cmsPublishMode', () => {
-                it('should return the cms publish mode specified by the command option if present.', () => {
-                    mockedGetConfig.mockReturnValue(configWithDefaultCmsPublishMode);
-                    mockedGetConfigAccountById.mockReturnValue(devAccountConfig);
-                    expect(getCmsPublishMode(buildArguments({
-                        cmsPublishMode: CMS_PUBLISH_MODE.draft,
-                    }))).toBe(CMS_PUBLISH_MODE.draft);
-                    expect(getCmsPublishMode(buildArguments({
-                        cmsPublishMode: CMS_PUBLISH_MODE.publish,
-                    }))).toBe(CMS_PUBLISH_MODE.publish);
-                });
-            });
-            describe('2. hubspot.config.yml -> config.accounts[x].defaultCmsPublishMode', () => {
-                it('should return the defaultCmsPublishMode specified by the account specific config if present.', () => {
-                    mockedGetConfig.mockReturnValue(configWithDefaultCmsPublishMode);
-                    mockedGetConfigAccountById.mockReturnValue(devAccountConfig);
-                    expect(getCmsPublishMode(buildArguments({
-                        account: accounts.DEV,
-                    }))).toBe(CMS_PUBLISH_MODE.draft);
-                });
-            });
-            describe('3. hubspot.config.yml -> config.defaultCmsPublishMode', () => {
-                it('should return the defaultCmsPublishMode specified by the config if present.', () => {
-                    mockedGetConfig.mockReturnValue(configWithDefaultCmsPublishMode);
-                    mockedGetConfigAccountById.mockReturnValue(prodAccountConfig);
-                    expect(getCmsPublishMode(buildArguments({
-                        account: accounts.PROD,
-                    }))).toBe(CMS_PUBLISH_MODE.draft);
-                });
-            });
-            describe('4. DEFAULT_CMS_PUBLISH_MODE', () => {
-                it('should return the defaultCmsPubishMode specified by the config if present.', () => {
-                    expect(getCmsPublishMode(buildArguments({
-                        account: 'xxxxx',
-                    }))).toBe(DEFAULT_CMS_PUBLISH_MODE);
-                });
-            });
-        });
-    });
-});

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

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