@hubspot/cli 7.10.0-beta.1 → 7.10.0-experimental.0

package/lib/__tests__/commonOpts.test.js

@@ -1,9 +1,8 @@
 import { CMS_PUBLISH_MODE, DEFAULT_CMS_PUBLISH_MODE, } from '@hubspot/local-dev-lib/constants/files';
-import { getAndLoadConfigIfNeeded, getAccountConfig, loadConfigFromEnvironment, } from '@hubspot/local-dev-lib/config';
+import { getConfig, getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { getCmsPublishMode } from '../commonOpts.js';
-const mockedGetAccountConfig = getAccountConfig;
-const mockedGetAndLoadConfigIfNeeded = getAndLoadConfigIfNeeded;
-const mockedLoadConfigFromEnvironment = loadConfigFromEnvironment;
+const mockedGetConfigAccountById = getConfigAccountById;
+const mockedGetConfig = getConfig;
 function buildArguments(args) {
     return {
         _: [],
@@ -42,8 +41,8 @@ describe('lib/commonOpts', () => {
         describe('cms publish mode option precedence', () => {
             describe('1. --cmsPublishMode', () => {
                 it('should return the cms publish mode specified by the command option if present.', () => {
-                    mockedGetAndLoadConfigIfNeeded.mockReturnValue(configWithDefaultCmsPublishMode);
-                    mockedGetAccountConfig.mockReturnValue(devAccountConfig);
+                    mockedGetConfig.mockReturnValue(configWithDefaultCmsPublishMode);
+                    mockedGetConfigAccountById.mockReturnValue(devAccountConfig);
                     expect(getCmsPublishMode(buildArguments({
                         cmsPublishMode: CMS_PUBLISH_MODE.draft,
                     }))).toBe(CMS_PUBLISH_MODE.draft);
@@ -54,9 +53,8 @@ describe('lib/commonOpts', () => {
             });
             describe('2. hubspot.config.yml -> config.accounts[x].defaultCmsPublishMode', () => {
                 it('should return the defaultCmsPublishMode specified by the account specific config if present.', () => {
-                    mockedGetAndLoadConfigIfNeeded.mockReturnValue(configWithDefaultCmsPublishMode);
-                    mockedGetAccountConfig.mockReturnValue(devAccountConfig);
-                    mockedLoadConfigFromEnvironment.mockReturnValue(undefined);
+                    mockedGetConfig.mockReturnValue(configWithDefaultCmsPublishMode);
+                    mockedGetConfigAccountById.mockReturnValue(devAccountConfig);
                     expect(getCmsPublishMode(buildArguments({
                         account: accounts.DEV,
                     }))).toBe(CMS_PUBLISH_MODE.draft);
@@ -64,9 +62,8 @@ describe('lib/commonOpts', () => {
             });
             describe('3. hubspot.config.yml -> config.defaultCmsPublishMode', () => {
                 it('should return the defaultCmsPublishMode specified by the config if present.', () => {
-                    mockedGetAndLoadConfigIfNeeded.mockReturnValue(configWithDefaultCmsPublishMode);
-                    mockedGetAccountConfig.mockReturnValue(prodAccountConfig);
-                    mockedLoadConfigFromEnvironment.mockReturnValue(undefined);
+                    mockedGetConfig.mockReturnValue(configWithDefaultCmsPublishMode);
+                    mockedGetConfigAccountById.mockReturnValue(prodAccountConfig);
                     expect(getCmsPublishMode(buildArguments({
                         account: accounts.PROD,
                     }))).toBe(CMS_PUBLISH_MODE.draft);
@@ -74,7 +71,6 @@ describe('lib/commonOpts', () => {
             });
             describe('4. DEFAULT_CMS_PUBLISH_MODE', () => {
                 it('should return the defaultCmsPubishMode specified by the config if present.', () => {
-                    mockedLoadConfigFromEnvironment.mockReturnValue(undefined);
                     expect(getCmsPublishMode(buildArguments({
                         account: 'xxxxx',
                     }))).toBe(DEFAULT_CMS_PUBLISH_MODE);

package/lib/__tests__/developerTestAccounts.test.js

@@ -1,16 +1,18 @@
-import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { getAllConfigAccounts, getConfigAccountIfExists, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
 import { uiLogger } from '../ui/logger.js';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { mockHubSpotHttpError } from '../testUtils.js';
 import * as errorHandlers from '../errorHandlers/index.js';
 import { getHasDevTestAccounts, handleDeveloperTestAccountCreateError, validateDevTestAccountUsageLimits, } from '../developerTestAccounts.js';
+import { logError } from '../errorHandlers/index.js';
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/api/developerTestAccounts');
 vi.mock('../errorHandlers');
-const mockedGetAccountId = getAccountId;
-const mockedGetConfigAccounts = getConfigAccounts;
+const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
+const mockedGetAllConfigAccounts = getAllConfigAccounts;
+const mockedGetConfigAccountById = getConfigAccountById;
 const mockedFetchDeveloperTestAccounts = fetchDeveloperTestAccounts;
 const APP_DEVELOPER_ACCOUNT_1 = {
     name: 'app-developer-1',
@@ -33,41 +35,43 @@ const accounts = [
         parentAccountId: APP_DEVELOPER_ACCOUNT_1.accountId,
         accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         env: 'prod',
+        authType: 'personalaccesskey',
     },
 ];
 describe('lib/developerTestAccounts', () => {
     describe('getHasDevTestAccounts()', () => {
         it('should return true if there are developer test accounts associated with the account', () => {
-            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
-            mockedGetConfigAccounts.mockReturnValueOnce(accounts);
+            mockedGetAllConfigAccounts.mockReturnValueOnce(accounts);
             const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
             expect(result).toBe(true);
         });
         it('should return false if there are no developer test accounts associated with the account', () => {
-            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_2.accountId);
-            mockedGetConfigAccounts.mockReturnValueOnce(accounts);
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_2);
+            mockedGetAllConfigAccounts.mockReturnValueOnce(accounts);
             const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_2);
             expect(result).toBe(false);
         });
         it('should return false if there are no accounts configured', () => {
-            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
-            mockedGetConfigAccounts.mockReturnValueOnce(undefined);
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
+            mockedGetAllConfigAccounts.mockReturnValueOnce(undefined);
             const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
             expect(result).toBe(false);
         });
     });
     describe('validateDevTestAccountUsageLimits()', () => {
         afterEach(() => {
-            mockedGetAccountId.mockRestore();
+            mockedGetConfigAccountIfExists.mockRestore();
             mockedFetchDeveloperTestAccounts.mockRestore();
         });
         it('should return null if the account id is not found', async () => {
-            mockedGetAccountId.mockReturnValueOnce(undefined);
+            mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
+                data: null,
+            });
             const result = await validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1);
             expect(result).toBe(null);
         });
         it('should return null if there is no developer test account data', async () => {
-            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
             mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
                 data: null,
             });
@@ -75,7 +79,7 @@ describe('lib/developerTestAccounts', () => {
             expect(result).toBe(null);
         });
         it('should return the test account data if the account has not reached the limit', async () => {
-            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
             const testAccountData = {
                 maxTestPortals: 10,
                 results: [],
@@ -87,7 +91,7 @@ describe('lib/developerTestAccounts', () => {
             expect(result).toEqual(expect.objectContaining(testAccountData));
         });
         it('should throw an error if the account has reached the limit', async () => {
-            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
             mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
                 data: {
                     maxTestPortals: 0,
@@ -103,6 +107,14 @@ describe('lib/developerTestAccounts', () => {
         beforeEach(() => {
             loggerErrorSpy = vi.spyOn(uiLogger, 'error');
             logErrorSpy = vi.spyOn(errorHandlers, 'logError');
+            // Mock account config for uiAccountDescription calls
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: APP_DEVELOPER_ACCOUNT_1.accountId,
+                name: 'Test Account',
+                authType: 'personalaccesskey',
+                personalAccessKey: 'test-key',
+                env: 'prod',
+            });
         });
         afterEach(() => {
             loggerErrorSpy.mockRestore();
@@ -117,7 +129,7 @@ describe('lib/developerTestAccounts', () => {
                 },
             });
             expect(() => handleDeveloperTestAccountCreateError(missingScopesError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Missing scopes error');
-            expect(loggerErrorSpy).toHaveBeenCalled();
+            expect(uiLogger.error).toHaveBeenCalled();
         });
         it('should log and throw an error if the account is missing the required scopes', () => {
             const portalLimitReachedError = mockHubSpotHttpError('Portal limit reached error', {
@@ -128,7 +140,7 @@ describe('lib/developerTestAccounts', () => {
                 },
             });
             expect(() => handleDeveloperTestAccountCreateError(portalLimitReachedError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Portal limit reached error');
-            expect(loggerErrorSpy).toHaveBeenCalled();
+            expect(uiLogger.error).toHaveBeenCalled();
         });
         it('should log a generic error message for an unknown error type', () => {
             const someUnknownError = mockHubSpotHttpError('Some unknown error', {
@@ -139,7 +151,7 @@ describe('lib/developerTestAccounts', () => {
                 },
             });
             expect(() => handleDeveloperTestAccountCreateError(someUnknownError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Some unknown error');
-            expect(logErrorSpy).toHaveBeenCalled();
+            expect(logError).toHaveBeenCalled();
         });
     });
 });

package/lib/__tests__/importData.test.js

@@ -1,6 +1,6 @@
 import { uiLogger } from '../ui/logger.js';
 import { createImport } from '@hubspot/local-dev-lib/api/crm';
-import { getAccountConfig, getAccountId } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { handleImportData, handleTargetTestAccountSelectionFlow, } from '../importData.js';
 import { lib } from '../../lang/en.js';
 import { isDeveloperTestAccount, isStandardAccount, isAppDeveloperAccount, } from '../accountTypes.js';
@@ -13,8 +13,8 @@ vi.mock('../prompts/importDataTestAccountSelectPrompt');
 describe('lib/importData', () => {
     const mockUiLogger = vi.mocked(uiLogger);
     const mockCreateImport = vi.mocked(createImport);
-    const mockGetAccountConfig = vi.mocked(getAccountConfig);
-    const mockGetAccountId = vi.mocked(getAccountId);
+    const mockGetConfigAccountById = vi.mocked(getConfigAccountById);
+    const mockGetConfigAccountIfExists = vi.mocked(getConfigAccountIfExists);
     const mockIsDeveloperTestAccount = vi.mocked(isDeveloperTestAccount);
     const mockIsStandardAccount = vi.mocked(isStandardAccount);
     const mockIsAppDeveloperAccount = vi.mocked(isAppDeveloperAccount);
@@ -24,8 +24,8 @@ describe('lib/importData', () => {
         mockUiLogger.success.mockReset();
         mockUiLogger.error.mockReset();
         mockCreateImport.mockReset();
-        mockGetAccountConfig.mockReset();
-        mockGetAccountId.mockReset();
+        mockGetConfigAccountById.mockReset();
+        mockGetConfigAccountIfExists.mockReset();
         mockIsDeveloperTestAccount.mockReset();
         mockIsStandardAccount.mockReset();
         mockIsAppDeveloperAccount.mockReset();
@@ -56,32 +56,42 @@ describe('lib/importData', () => {
         const userProvidedAccountId = '1234';
         const derivedAccountId = 123456789;
         it('should error if the userProvidedAccountId is not the right account type', async () => {
-            mockGetAccountConfig.mockReturnValue({});
-            mockGetAccountId.mockReturnValue(1234);
+            mockGetConfigAccountIfExists.mockReturnValue({
+                accountId: 1234,
+            });
             mockIsDeveloperTestAccount.mockReturnValue(false);
             await expect(handleTargetTestAccountSelectionFlow(derivedAccountId, userProvidedAccountId)).rejects.toThrow(lib.importData.errors.notDeveloperTestAccount);
         });
         it('should error if the derivedAccountId belongs to the wrong account type', async () => {
-            mockGetAccountConfig.mockReturnValue({});
+            mockGetConfigAccountIfExists.mockReturnValue({
+                accountId: derivedAccountId,
+            });
+            mockGetConfigAccountById.mockReturnValue({
+                accountId: derivedAccountId,
+            });
             mockIsDeveloperTestAccount.mockReturnValue(false);
             mockIsStandardAccount.mockReturnValue(false);
             mockIsAppDeveloperAccount.mockReturnValue(false);
             await expect(handleTargetTestAccountSelectionFlow(derivedAccountId, undefined)).rejects.toThrow(lib.importData.errors.incorrectAccountType(derivedAccountId));
         });
         it('should return the derivedAccountId if it is a developer test account', async () => {
-            mockGetAccountConfig.mockReturnValue({});
             mockIsDeveloperTestAccount.mockReturnValue(true);
+            mockGetConfigAccountById.mockReturnValue({
+                accountId: derivedAccountId,
+            });
             const result = await handleTargetTestAccountSelectionFlow(derivedAccountId, undefined);
             expect(result).toBe(derivedAccountId);
         });
         it('should return the result of the importDataTestAccountSelectPrompt if the derivedAccountId is a standard or app developer account', async () => {
-            mockGetAccountConfig.mockReturnValue({});
             mockIsDeveloperTestAccount.mockReturnValue(false);
             mockIsStandardAccount.mockReturnValue(true);
             mockIsAppDeveloperAccount.mockReturnValue(true);
             mockImportDataTestAccountSelectPrompt.mockResolvedValue({
                 selectedAccountId: 890223,
             });
+            mockGetConfigAccountById.mockReturnValue({
+                accountId: derivedAccountId,
+            });
             const result = await handleTargetTestAccountSelectionFlow(derivedAccountId, undefined);
             expect(result).toBe(890223);
         });

package/lib/__tests__/oauth.test.js

@@ -1,7 +1,7 @@
 import express from 'express';
 import open from 'open';
 import { OAuth2Manager } from '@hubspot/local-dev-lib/models/OAuth2Manager';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+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';
@@ -15,18 +15,22 @@ vi.mock('@hubspot/local-dev-lib/oauth');
 vi.mock('../ui/logger.js');
 const mockedExpress = express;
 const mockedOAuth2Manager = OAuth2Manager;
-const mockedGetAccountConfig = getAccountConfig;
+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,
-        clientId: 'test-client-id',
-        clientSecret: 'test-client-secret',
-        scopes: ['test-scope'],
+        authType: 'oauth2',
         env: ENVIRONMENTS.PROD,
+        auth: {
+            clientId: 'test-client-id',
+            clientSecret: 'test-client-secret',
+            scopes: ['test-scope'],
+        },
     };
     beforeEach(() => {
         mockedExpress.mockReturnValue({
@@ -49,7 +53,7 @@ describe('lib/oauth', () => {
                 exchangeForTokens: vi.fn().mockResolvedValue({}),
             };
             mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
-            mockedGetAccountConfig.mockReturnValue({
+            mockedGetConfigAccountById.mockReturnValue({
                 env: ENVIRONMENTS.PROD,
             });
             await authenticateWithOauth(mockAccountConfig);
@@ -66,7 +70,10 @@ describe('lib/oauth', () => {
         it('should handle missing clientId', async () => {
             const invalidConfig = {
                 ...mockAccountConfig,
-                clientId: undefined,
+                auth: {
+                    ...mockAccountConfig.auth,
+                    clientId: undefined,
+                },
             };
             mockedOAuth2Manager.mockImplementation(() => ({
                 account: invalidConfig,
@@ -74,6 +81,7 @@ describe('lib/oauth', () => {
             const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {
                 throw new Error('exit');
             });
+            // @ts-expect-error Testing invalid config
             await expect(authenticateWithOauth(invalidConfig)).rejects.toThrow('exit');
             expect(uiLogger.error).toHaveBeenCalled();
             expect(exitSpy).toHaveBeenCalled();
@@ -82,7 +90,10 @@ describe('lib/oauth', () => {
         it('should use default scopes when none provided', async () => {
             const configWithoutScopes = {
                 ...mockAccountConfig,
-                scopes: undefined,
+                auth: {
+                    ...mockAccountConfig.auth,
+                    scopes: [],
+                },
             };
             const mockOAuth2Manager = {
                 account: configWithoutScopes,

package/lib/__tests__/sandboxSync.test.js

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

package/lib/__tests__/sandboxes.test.js

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

package/lib/__tests__/usageTracking.test.js

@@ -1,5 +1,5 @@
 import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
-import { isTrackingAllowed, getAccountConfig, } from '@hubspot/local-dev-lib/config';
+import { getConfig, getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { API_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
 import { uiLogger } from '../ui/logger.js';
 import { trackCommandUsage, trackHelpUsage, trackConvertFieldsUsage, trackAuthAction, trackCommandMetadataUsage, } from '../usageTracking.js';
@@ -9,14 +9,14 @@ vi.mock('@hubspot/local-dev-lib/trackUsage');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../ui/logger.js');
 const mockedTrackUsage = trackUsage;
-const mockedIsTrackingAllowed = isTrackingAllowed;
-const mockedGetAccountConfig = getAccountConfig;
+const mockedGetConfig = getConfig;
+const mockedGetConfigAccountById = getConfigAccountById;
 const mockedUiLogger = uiLogger;
 describe('lib/usageTracking', () => {
     const mockPlatform = 'darwin';
     const mockNodeVersion = 'v16.14.0';
     beforeEach(() => {
-        mockedIsTrackingAllowed.mockReturnValue(true);
+        mockedGetConfig.mockReturnValue({ allowUsageTracking: true });
         Object.defineProperty(process, 'platform', { value: mockPlatform });
         Object.defineProperty(process, 'version', { value: mockNodeVersion });
     });
@@ -24,7 +24,7 @@ describe('lib/usageTracking', () => {
         const mockCommand = 'test-command';
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackCommandUsage(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
@@ -41,7 +41,7 @@ describe('lib/usageTracking', () => {
             }), mockAccountId);
         });
         it('should track command usage with custom auth type', async () => {
-            mockedGetAccountConfig.mockReturnValue({ authType: 'oauth2' });
+            mockedGetConfigAccountById.mockReturnValue({ authType: 'oauth2' });
             await trackCommandUsage(mockCommand, {}, mockAccountId);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 authType: 'oauth2',
@@ -59,7 +59,7 @@ describe('lib/usageTracking', () => {
     describe('trackHelpUsage()', () => {
         const mockCommand = 'help-command';
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackHelpUsage(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
@@ -82,7 +82,7 @@ describe('lib/usageTracking', () => {
     describe('trackConvertFieldsUsage()', () => {
         const mockCommand = 'convert-fields-command';
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackConvertFieldsUsage(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
@@ -104,7 +104,7 @@ describe('lib/usageTracking', () => {
         const mockStep = 'init';
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
@@ -127,7 +127,7 @@ describe('lib/usageTracking', () => {
         const mockMeta = { assetType: 'test-asset' };
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });