@hubspot/cli 7.9.0 → 7.9.1-experimental.0

package/lib/__tests__/dependencyManagement.test.js

@@ -1,5 +1,5 @@
 import util from 'util';
-import { installPackages, getProjectPackageJsonLocations, } from '../dependencyManagement.js';
+import { installPackages, updatePackages, getProjectPackageJsonLocations, isPackageInstalled, } from '../dependencyManagement.js';
 import { walk } from '@hubspot/local-dev-lib/fs';
 import path from 'path';
 import { getProjectConfig } from '../projects/config.js';
@@ -105,6 +105,54 @@ describe('lib/dependencyManagement', () => {
                 cwd: extensionsDir,
             });
         });
+        it('should install packages as dev dependencies when dev flag is true', async () => {
+            const packages = ['eslint', 'prettier'];
+            await installPackages({ packages, installLocations, dev: true });
+            expect(execMock).toHaveBeenCalledTimes(installLocations.length);
+            for (const location of installLocations) {
+                expect(execMock).toHaveBeenCalledWith(`npm install --save-dev eslint prettier`, {
+                    cwd: location,
+                });
+            }
+        });
+        it('should install packages as regular dependencies when dev flag is false', async () => {
+            const packages = ['react', 'react-dom'];
+            await installPackages({ packages, installLocations, dev: false });
+            expect(execMock).toHaveBeenCalledTimes(installLocations.length);
+            for (const location of installLocations) {
+                expect(execMock).toHaveBeenCalledWith(`npm install react react-dom`, {
+                    cwd: location,
+                });
+            }
+        });
+        it('should install packages as regular dependencies when dev flag is not provided', async () => {
+            const packages = ['axios'];
+            await installPackages({ packages, installLocations });
+            expect(execMock).toHaveBeenCalledTimes(installLocations.length);
+            for (const location of installLocations) {
+                expect(execMock).toHaveBeenCalledWith(`npm install axios`, {
+                    cwd: location,
+                });
+            }
+        });
+        it('should not use --save-dev flag when dev is true but no packages are provided', async () => {
+            await installPackages({ installLocations, dev: true });
+            expect(execMock).toHaveBeenCalledTimes(installLocations.length);
+            for (const location of installLocations) {
+                expect(execMock).toHaveBeenCalledWith(`npm install `, {
+                    cwd: location,
+                });
+            }
+        });
+        it('should not use --save-dev flag when dev is true but packages array is empty', async () => {
+            await installPackages({ packages: [], installLocations, dev: true });
+            expect(execMock).toHaveBeenCalledTimes(installLocations.length);
+            for (const location of installLocations) {
+                expect(execMock).toHaveBeenCalledWith(`npm install `, {
+                    cwd: location,
+                });
+            }
+        });
         it('should throw an error when installing the dependencies fails', async () => {
             execMock = vi.fn().mockImplementation(command => {
                 if (command === 'npm --version') {
@@ -133,6 +181,92 @@ describe('lib/dependencyManagement', () => {
             });
         });
     });
+    describe('updatePackages()', () => {
+        it('should setup a loading spinner', async () => {
+            const packages = ['package1', 'package2'];
+            await updatePackages({ packages, installLocations });
+            expect(SpinniesManager.init).toHaveBeenCalledTimes(installLocations.length);
+            expect(SpinniesManager.add).toHaveBeenCalledTimes(installLocations.length);
+            expect(SpinniesManager.succeed).toHaveBeenCalledTimes(installLocations.length);
+        });
+        it('should update the provided packages in all the provided install locations', async () => {
+            const packages = ['package1', 'package2'];
+            await updatePackages({ packages, installLocations });
+            expect(execMock).toHaveBeenCalledTimes(installLocations.length);
+            expect(SpinniesManager.add).toHaveBeenCalledTimes(installLocations.length);
+            expect(SpinniesManager.succeed).toHaveBeenCalledTimes(installLocations.length);
+            for (const location of installLocations) {
+                expect(execMock).toHaveBeenCalledWith(`npm update package1 package2`, {
+                    cwd: location,
+                });
+                expect(SpinniesManager.add).toHaveBeenCalledWith(`updatingDependencies-${location}`, {
+                    text: `Updating [package1, package2] in ${location}`,
+                });
+                expect(SpinniesManager.succeed).toHaveBeenCalledWith(`updatingDependencies-${location}`, {
+                    text: `Updated dependencies in ${location}`,
+                });
+            }
+        });
+        it('should use the provided install locations', async () => {
+            await updatePackages({ installLocations });
+            expect(execMock).toHaveBeenCalledTimes(installLocations.length);
+            expect(execMock).toHaveBeenCalledWith(`npm update `, {
+                cwd: appFunctionsDir,
+            });
+            expect(execMock).toHaveBeenCalledWith(`npm update `, {
+                cwd: extensionsDir,
+            });
+        });
+        it('should locate the projects package.json files when install locations is not provided', async () => {
+            const installLocations = [
+                path.join(appFunctionsDir, 'package.json'),
+                path.join(extensionsDir, 'package.json'),
+            ];
+            mockedWalk.mockResolvedValue(installLocations);
+            mockedGetProjectConfig.mockResolvedValue({
+                projectDir,
+                projectConfig: {
+                    srcDir,
+                },
+            });
+            await updatePackages({});
+            // It's called once per each install location, plus once to check if npm installed
+            expect(execMock).toHaveBeenCalledTimes(installLocations.length + 1);
+            expect(execMock).toHaveBeenCalledWith(`npm update `, {
+                cwd: appFunctionsDir,
+            });
+            expect(execMock).toHaveBeenCalledWith(`npm update `, {
+                cwd: extensionsDir,
+            });
+        });
+        it('should throw an error when updating the dependencies fails', async () => {
+            execMock = vi.fn().mockImplementation(command => {
+                if (command === 'npm --version') {
+                    return;
+                }
+                throw new Error('OH NO');
+            });
+            util.promisify = mockedPromisify(execMock);
+            // Mock walk to return the directory paths instead of package.json paths
+            mockedWalk.mockResolvedValue([appFunctionsDir, extensionsDir]);
+            mockedFs.existsSync.mockImplementation(filePath => {
+                const pathStr = filePath.toString();
+                if (pathStr === projectDir ||
+                    pathStr === path.join(projectDir, srcDir)) {
+                    return true;
+                }
+                return false;
+            });
+            await expect(() => updatePackages({ installLocations: [appFunctionsDir, extensionsDir] })).rejects.toThrowError(`Updating dependencies for ${appFunctionsDir} failed`);
+            expect(SpinniesManager.fail).toHaveBeenCalledTimes(installLocations.length);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`updatingDependencies-${appFunctionsDir}`, {
+                text: `Updating dependencies for ${appFunctionsDir} failed`,
+            });
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`updatingDependencies-${extensionsDir}`, {
+                text: `Updating dependencies for ${extensionsDir} failed`,
+            });
+        });
+    });
     describe('getProjectPackageJsonFiles()', () => {
         it('should throw an error when ran outside the boundary of a project', async () => {
             mockedGetProjectConfig.mockResolvedValue({});
@@ -149,6 +283,30 @@ describe('lib/dependencyManagement', () => {
             mockedFs.existsSync.mockReturnValueOnce(false);
             await expect(() => getProjectPackageJsonLocations()).rejects.toThrowError(new RegExp(`No dependencies to install. The project ${projectName} folder might be missing component or subcomponent files.`));
         });
+        it('should throw "install" error message when isUpdate=false and no package.json files found', async () => {
+            mockedWalk.mockResolvedValue([]);
+            mockedFs.existsSync.mockImplementation(filePath => {
+                const pathStr = filePath.toString();
+                if (pathStr === projectDir ||
+                    pathStr === path.join(projectDir, srcDir)) {
+                    return true;
+                }
+                return false;
+            });
+            await expect(() => getProjectPackageJsonLocations(undefined, false)).rejects.toThrowError(new RegExp(`No dependencies to install. The project ${projectName} folder might be missing component or subcomponent files.`));
+        });
+        it('should throw "update" error message when isUpdate=true and no package.json files found', async () => {
+            mockedWalk.mockResolvedValue([]);
+            mockedFs.existsSync.mockImplementation(filePath => {
+                const pathStr = filePath.toString();
+                if (pathStr === projectDir ||
+                    pathStr === path.join(projectDir, srcDir)) {
+                    return true;
+                }
+                return false;
+            });
+            await expect(() => getProjectPackageJsonLocations(undefined, true)).rejects.toThrowError(new RegExp(`No dependencies to update. The project ${projectName} folder might be missing component or subcomponent files.`));
+        });
         it('should ignore package.json files in certain directories', async () => {
             const nodeModulesDir = path.join(appDir, 'node_modules');
             const viteDir = path.join(appDir, '.vite');
@@ -172,4 +330,118 @@ describe('lib/dependencyManagement', () => {
             expect(actual).toEqual([appFunctionsDir, extensionsDir]);
         });
     });
+    describe('isPackageInstalled()', () => {
+        const testDir = '/test/directory';
+        const readFileSyncSpy = vi.spyOn(fs, 'readFileSync');
+        const existsSyncSpy = vi.spyOn(fs, 'existsSync');
+        function mockNodeModulesExists(packageName, exists = true) {
+            existsSyncSpy.mockImplementation(filePath => {
+                const pathStr = filePath.toString();
+                return (exists && pathStr === path.join(testDir, 'node_modules', packageName));
+            });
+        }
+        beforeEach(() => {
+            vi.clearAllMocks();
+            readFileSyncSpy.mockReset();
+            existsSyncSpy.mockReset();
+        });
+        it('should return true if package is in dependencies and in node_modules', () => {
+            readFileSyncSpy.mockReturnValueOnce(JSON.stringify({
+                dependencies: {
+                    eslint: '^9.0.0',
+                },
+            }));
+            mockNodeModulesExists('eslint', true);
+            const result = isPackageInstalled(testDir, 'eslint');
+            expect(result).toBe(true);
+            expect(readFileSyncSpy).toHaveBeenCalledWith(path.join(testDir, 'package.json'), 'utf-8');
+            expect(existsSyncSpy).toHaveBeenCalledWith(path.join(testDir, 'node_modules', 'eslint'));
+        });
+        it('should return true if package is in devDependencies and in node_modules', () => {
+            readFileSyncSpy.mockReturnValueOnce(JSON.stringify({
+                devDependencies: {
+                    prettier: '^3.0.0',
+                },
+            }));
+            mockNodeModulesExists('prettier', true);
+            const result = isPackageInstalled(testDir, 'prettier');
+            expect(result).toBe(true);
+        });
+        it('should return false if package is in package.json but not in node_modules', () => {
+            readFileSyncSpy.mockReturnValueOnce(JSON.stringify({
+                dependencies: {
+                    react: '^18.0.0',
+                },
+            }));
+            mockNodeModulesExists('react', false);
+            const result = isPackageInstalled(testDir, 'react');
+            expect(result).toBe(false);
+        });
+        it('should return false if package is not in package.json but is in node_modules', () => {
+            readFileSyncSpy.mockReturnValueOnce(JSON.stringify({
+                dependencies: {
+                    typescript: '^5.0.0',
+                },
+            }));
+            mockNodeModulesExists('lodash', true);
+            const result = isPackageInstalled(testDir, 'lodash');
+            expect(result).toBe(false);
+        });
+        it('should return false if package is not in package.json and not in node_modules', () => {
+            readFileSyncSpy.mockReturnValueOnce(JSON.stringify({
+                dependencies: {},
+            }));
+            mockNodeModulesExists('nonexistent-package', false);
+            const result = isPackageInstalled(testDir, 'nonexistent-package');
+            expect(result).toBe(false);
+        });
+        it('should return false if package.json cannot be read', () => {
+            readFileSyncSpy.mockImplementationOnce(() => {
+                throw new Error('File not found');
+            });
+            const result = isPackageInstalled(testDir, 'eslint');
+            expect(result).toBe(false);
+        });
+        it('should return false if package.json has invalid JSON', () => {
+            readFileSyncSpy.mockReturnValueOnce('invalid json{');
+            const result = isPackageInstalled(testDir, 'eslint');
+            expect(result).toBe(false);
+        });
+        it('should return false if checking node_modules throws an error', () => {
+            readFileSyncSpy.mockReturnValueOnce(JSON.stringify({
+                dependencies: {
+                    eslint: '^9.0.0',
+                },
+            }));
+            existsSyncSpy.mockImplementation(() => {
+                throw new Error('Permission denied');
+            });
+            const result = isPackageInstalled(testDir, 'eslint');
+            expect(result).toBe(false);
+        });
+        it('should handle scoped packages correctly', () => {
+            readFileSyncSpy.mockReturnValueOnce(JSON.stringify({
+                dependencies: {
+                    '@typescript-eslint/parser': '^8.0.0',
+                },
+            }));
+            mockNodeModulesExists('@typescript-eslint/parser', true);
+            const result = isPackageInstalled(testDir, '@typescript-eslint/parser');
+            expect(result).toBe(true);
+            expect(existsSyncSpy).toHaveBeenCalledWith(path.join(testDir, 'node_modules', '@typescript-eslint/parser'));
+        });
+        it('should check both dependencies and devDependencies', () => {
+            readFileSyncSpy.mockReturnValueOnce(JSON.stringify({
+                dependencies: {
+                    react: '^18.0.0',
+                },
+                devDependencies: {
+                    eslint: '^9.0.0',
+                },
+            }));
+            mockNodeModulesExists('eslint', true);
+            const result = isPackageInstalled(testDir, 'eslint');
+            expect(result).toBe(true);
+        });
+    });
 });

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,