@hubspot/cli 7.7.19-experimental.3 → 7.7.21-experimental.0

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

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

package/lib/__tests__/accountTypes.test.js

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

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

package/lib/__tests__/buildAccount.test.js

@@ -0,0 +1,196 @@
+import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
+import { accountNameExistsInConfig, updateAccountConfig, writeConfig, getAccountId, } from '@hubspot/local-dev-lib/config';
+import { createDeveloperTestAccount } from '@hubspot/local-dev-lib/api/developerTestAccounts';
+import { createSandbox } 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';
+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('@hubspot/local-dev-lib/logger');
+vi.mock('../prompts/personalAccessKeyPrompt');
+vi.mock('../prompts/accountNamePrompt');
+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 mockedAccountNameExistsInConfig = accountNameExistsInConfig;
+const mockedUpdateAccountConfig = updateAccountConfig;
+const mockedWriteConfig = writeConfig;
+const mockedCliAccountNamePrompt = cliAccountNamePrompt;
+const mockedGetAccountId = getAccountId;
+const mockedCreateDeveloperTestAccount = createDeveloperTestAccount;
+const mockedCreateSandbox = createSandbox;
+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);
+            mockedAccountNameExistsInConfig.mockResolvedValue(false);
+            mockedUpdateAccountConfig.mockReturnValue(undefined);
+            mockedWriteConfig.mockReturnValue(undefined);
+        });
+        afterEach(() => {
+            vi.clearAllMocks();
+        });
+        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(mockedUpdateAccountConfig).toHaveBeenCalledWith(expect.objectContaining(mockAccountConfig));
+            expect(mockedWriteConfig).toHaveBeenCalled();
+            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(mockedUpdateAccountConfig).toHaveBeenCalledWith(expect.objectContaining(mockAccountConfig));
+            expect(mockedWriteConfig).toHaveBeenCalled();
+            expect(result).toBe(mockAccountConfig.name);
+        });
+        it('should handle duplicate account names', async () => {
+            const mockAccountConfigWithNoName = {
+                ...mockAccountConfig,
+                name: undefined,
+            };
+            mockedUpdateConfigWithAccessToken.mockResolvedValue(mockAccountConfigWithNoName);
+            mockedAccountNameExistsInConfig.mockResolvedValue(true);
+            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('buildDeveloperTestAccount()', () => {
+        const mockParentAccountConfig = {
+            name: 'Developer Test Account',
+            accountId: 123456,
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+            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);
+            mockedGetAccountId.mockReturnValue(mockParentAccountConfig.accountId);
+            mockedCreateDeveloperTestAccount.mockResolvedValue({
+                data: mockDeveloperTestAccount,
+            });
+        });
+        afterEach(() => {
+            vi.clearAllMocks();
+        });
+        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 throw error if account ID is not found', async () => {
+            mockedGetAccountId.mockReturnValue(null);
+            await expect(buildAccount.buildDeveloperTestAccount(mockDeveloperTestAccount.accountName, mockParentAccountConfig, mockParentAccountConfig.env, 10)).rejects.toThrow();
+        });
+        it('should handle API errors when creating developer test account', async () => {
+            mockedCreateDeveloperTestAccount.mockRejectedValue(new Error('test-error'));
+            await expect(buildAccount.buildDeveloperTestAccount(mockDeveloperTestAccount.accountName, mockParentAccountConfig, mockParentAccountConfig.env, 10)).rejects.toThrow();
+        });
+    });
+    describe('buildSandbox()', () => {
+        const mockParentAccountConfig = {
+            name: 'Developer Test Account',
+            accountId: 123456,
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+            env: 'prod',
+        };
+        const mockSandbox = {
+            sandboxHubId: 56789,
+            parentHubId: 123456,
+            createdAt: '2025-01-01',
+            type: 'sandbox',
+            archived: false,
+            name: 'Test Sandbox',
+            domain: 'test-sandbox.hubspot.com',
+            createdByUser: {
+                id: 123456,
+                email: 'test@test.com',
+                firstName: 'Test',
+                lastName: 'User',
+            },
+        };
+        beforeEach(() => {
+            vi.spyOn(buildAccount, 'saveAccountToConfig').mockResolvedValue(mockParentAccountConfig.name);
+            mockedGetAccountId.mockReturnValue(mockParentAccountConfig.accountId);
+            mockedCreateSandbox.mockResolvedValue({
+                data: { sandbox: mockSandbox, personalAccessKey: 'test-key' },
+            });
+        });
+        afterEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should create a standard sandbox successfully', async () => {
+            const result = await buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, mockParentAccountConfig.env, false);
+            expect(result).toEqual({
+                name: mockSandbox.name,
+                personalAccessKey: 'test-key',
+                sandbox: mockSandbox,
+            });
+        });
+        it('should create a development sandbox successfully', async () => {
+            const result = await buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, mockParentAccountConfig.env);
+            expect(result).toEqual({
+                name: mockSandbox.name,
+                personalAccessKey: 'test-key',
+                sandbox: mockSandbox,
+            });
+        });
+        it('should throw error if account ID is not found', async () => {
+            mockedGetAccountId.mockReturnValue(null);
+            await expect(buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, mockParentAccountConfig.env)).rejects.toThrow();
+        });
+        it('should handle API errors when creating sandbox', async () => {
+            mockedCreateSandbox.mockRejectedValue(new Error('test-error'));
+            await expect(buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, mockParentAccountConfig.env, false)).rejects.toThrow();
+        });
+    });
+});

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

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

package/lib/__tests__/commonOpts.test.js

@@ -0,0 +1,85 @@
+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 { getCmsPublishMode } from '../commonOpts.js';
+const mockedGetAccountConfig = getAccountConfig;
+const mockedGetAndLoadConfigIfNeeded = getAndLoadConfigIfNeeded;
+const mockedLoadConfigFromEnvironment = loadConfigFromEnvironment;
+function buildArguments(args) {
+    return {
+        _: [],
+        $0: '',
+        ...args,
+    };
+}
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/logger');
+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.', () => {
+                    mockedGetAndLoadConfigIfNeeded.mockReturnValue(configWithDefaultCmsPublishMode);
+                    mockedGetAccountConfig.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.', () => {
+                    mockedGetAndLoadConfigIfNeeded.mockReturnValue(configWithDefaultCmsPublishMode);
+                    mockedGetAccountConfig.mockReturnValue(devAccountConfig);
+                    mockedLoadConfigFromEnvironment.mockReturnValue(undefined);
+                    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.', () => {
+                    mockedGetAndLoadConfigIfNeeded.mockReturnValue(configWithDefaultCmsPublishMode);
+                    mockedGetAccountConfig.mockReturnValue(prodAccountConfig);
+                    mockedLoadConfigFromEnvironment.mockReturnValue(undefined);
+                    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.', () => {
+                    mockedLoadConfigFromEnvironment.mockReturnValue(undefined);
+                    expect(getCmsPublishMode(buildArguments({
+                        account: 'xxxxx',
+                    }))).toBe(DEFAULT_CMS_PUBLISH_MODE);
+                });
+            });
+        });
+    });
+});

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

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

package/lib/__tests__/dependencyManagement.test.js

@@ -0,0 +1,175 @@
+import util from 'util';
+import { installPackages, getProjectPackageJsonLocations, } from '../dependencyManagement.js';
+import { walk } from '@hubspot/local-dev-lib/fs';
+import path from 'path';
+import { getProjectConfig } from '../projects/config.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import fs from 'fs';
+vi.mock('../projects/config');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/fs');
+vi.mock('fs');
+vi.mock('../ui/SpinniesManager', () => ({
+    default: {
+        init: vi.fn(),
+        add: vi.fn(),
+        succeed: vi.fn(),
+        fail: vi.fn(),
+    },
+}));
+const mockedFs = vi.mocked(fs);
+describe('lib/dependencyManagement', () => {
+    let execMock;
+    const projectDir = path.join('path', 'to', 'project');
+    const srcDir = 'src';
+    const appDir = path.join(projectDir, srcDir, 'app');
+    const appFunctionsDir = path.join(appDir, 'app.functions');
+    const extensionsDir = path.join(appDir, 'exensions');
+    const projectName = 'super cool test project';
+    const installLocations = [appFunctionsDir, extensionsDir];
+    function mockedPromisify(execMock) {
+        return vi
+            .fn()
+            .mockReturnValue(execMock);
+    }
+    const mockedWalk = walk;
+    const mockedGetProjectConfig = getProjectConfig;
+    beforeEach(() => {
+        execMock = vi.fn();
+        util.promisify = mockedPromisify(execMock);
+        mockedGetProjectConfig.mockResolvedValue({
+            projectDir,
+            projectConfig: {
+                srcDir,
+                name: projectName,
+            },
+        });
+        mockedFs.existsSync.mockReturnValue(true); // Default to true, override in specific tests
+        vi.clearAllMocks();
+    });
+    describe('installPackages()', () => {
+        it('should setup a loading spinner', async () => {
+            const packages = ['package1', 'package2'];
+            await installPackages({ packages, installLocations });
+            expect(SpinniesManager.init).toHaveBeenCalledTimes(installLocations.length);
+            expect(SpinniesManager.add).toHaveBeenCalledTimes(installLocations.length);
+            expect(SpinniesManager.succeed).toHaveBeenCalledTimes(installLocations.length);
+        });
+        it('should install the provided packages in all the provided install locations', async () => {
+            const packages = ['package1', 'package2'];
+            await installPackages({ 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 install package1 package2`, {
+                    cwd: location,
+                });
+                expect(SpinniesManager.add).toHaveBeenCalledWith(`installingDependencies-${location}`, {
+                    text: `Installing [package1, package2] in ${location}`,
+                });
+                expect(SpinniesManager.succeed).toHaveBeenCalledWith(`installingDependencies-${location}`, {
+                    text: `Installed dependencies in ${location}`,
+                });
+            }
+        });
+        it('should use the provided install locations', async () => {
+            await installPackages({ installLocations });
+            expect(execMock).toHaveBeenCalledTimes(installLocations.length);
+            expect(execMock).toHaveBeenCalledWith(`npm install `, {
+                cwd: appFunctionsDir,
+            });
+            expect(execMock).toHaveBeenCalledWith(`npm install `, {
+                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 installPackages({});
+            // 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 install `, {
+                cwd: appFunctionsDir,
+            });
+            expect(execMock).toHaveBeenCalledWith(`npm install `, {
+                cwd: extensionsDir,
+            });
+        });
+        it('should throw an error when installing 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(() => installPackages({ installLocations: [appFunctionsDir, extensionsDir] })).rejects.toThrowError(`Installing dependencies for ${appFunctionsDir} failed`);
+            expect(SpinniesManager.fail).toHaveBeenCalledTimes(installLocations.length);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`installingDependencies-${appFunctionsDir}`, {
+                text: `Installing dependencies for ${appFunctionsDir} failed`,
+            });
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`installingDependencies-${extensionsDir}`, {
+                text: `Installing dependencies for ${extensionsDir} failed`,
+            });
+        });
+    });
+    describe('getProjectPackageJsonFiles()', () => {
+        it('should throw an error when ran outside the boundary of a project', async () => {
+            mockedGetProjectConfig.mockResolvedValue({});
+            await expect(() => getProjectPackageJsonLocations()).rejects.toThrowError('No project detected. Run this command from a project directory.');
+        });
+        it('should throw an error if npm is not globally installed', async () => {
+            execMock = vi.fn().mockImplementation(() => {
+                throw new Error('OH NO');
+            });
+            util.promisify = mockedPromisify(execMock);
+            await expect(() => getProjectPackageJsonLocations()).rejects.toThrowError(/This command depends on npm, install/);
+        });
+        it('should throw an error if the project directory does not exist', async () => {
+            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 ignore package.json files in certain directories', async () => {
+            const nodeModulesDir = path.join(appDir, 'node_modules');
+            const viteDir = path.join(appDir, '.vite');
+            const installLocations = [
+                path.join(appFunctionsDir, 'package.json'),
+                path.join(extensionsDir, 'package.json'),
+                path.join(viteDir, 'package.json'),
+                path.join(nodeModulesDir, 'package.json'),
+            ];
+            mockedWalk.mockResolvedValue(installLocations);
+            mockedFs.existsSync.mockImplementation(filePath => {
+                // Return true for project directory and src directory
+                const pathStr = filePath.toString();
+                if (pathStr === projectDir ||
+                    pathStr === path.join(projectDir, srcDir)) {
+                    return true;
+                }
+                return false;
+            });
+            const actual = await getProjectPackageJsonLocations();
+            expect(actual).toEqual([appFunctionsDir, extensionsDir]);
+        });
+    });
+});

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

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