@hubspot/cli 7.6.0-beta.0 → 7.6.0-beta.10

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 {};

package/lib/__tests__/developerTestAccounts.test.js

@@ -0,0 +1,145 @@
+import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { logger } from '@hubspot/local-dev-lib/logger';
+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';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/developerTestAccounts');
+vi.mock('../errorHandlers');
+const mockedGetAccountId = getAccountId;
+const mockedGetConfigAccounts = getConfigAccounts;
+const mockedFetchDeveloperTestAccounts = fetchDeveloperTestAccounts;
+const APP_DEVELOPER_ACCOUNT_1 = {
+    name: 'app-developer-1',
+    accountId: 123,
+    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+    env: 'prod',
+};
+const APP_DEVELOPER_ACCOUNT_2 = {
+    name: 'app-developer-2',
+    accountId: 456,
+    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+    env: 'prod',
+};
+const accounts = [
+    APP_DEVELOPER_ACCOUNT_1,
+    APP_DEVELOPER_ACCOUNT_2,
+    {
+        name: 'test-account',
+        accountId: 789,
+        parentAccountId: APP_DEVELOPER_ACCOUNT_1.accountId,
+        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        env: 'prod',
+    },
+];
+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);
+            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);
+            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);
+            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
+            expect(result).toBe(false);
+        });
+    });
+    describe('validateDevTestAccountUsageLimits()', () => {
+        afterEach(() => {
+            mockedGetAccountId.mockRestore();
+            mockedFetchDeveloperTestAccounts.mockRestore();
+        });
+        it('should return null if the account id is not found', async () => {
+            mockedGetAccountId.mockReturnValueOnce(undefined);
+            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);
+            mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
+                data: null,
+            });
+            const result = await validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1);
+            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);
+            const testAccountData = {
+                maxTestPortals: 10,
+                results: [],
+            };
+            mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
+                data: testAccountData,
+            });
+            const result = await validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1);
+            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);
+            mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
+                data: {
+                    maxTestPortals: 0,
+                    results: [{}],
+                },
+            });
+            await expect(validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1)).rejects.toThrow();
+        });
+    });
+    describe('handleDeveloperTestAccountCreateError()', () => {
+        let loggerErrorSpy;
+        let logErrorSpy;
+        beforeEach(() => {
+            loggerErrorSpy = vi.spyOn(logger, 'error');
+            logErrorSpy = vi.spyOn(errorHandlers, 'logError');
+        });
+        afterEach(() => {
+            loggerErrorSpy.mockRestore();
+            logErrorSpy.mockRestore();
+        });
+        it('should log and throw an error if the account is missing the required scopes', () => {
+            const missingScopesError = mockHubSpotHttpError('Missing scopes error', {
+                status: 403,
+                data: {
+                    message: 'Missing scopes error',
+                    category: 'MISSING_SCOPES',
+                },
+            });
+            expect(() => handleDeveloperTestAccountCreateError(missingScopesError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Missing scopes error');
+            expect(loggerErrorSpy).toHaveBeenCalled();
+        });
+        it('should log and throw an error if the account is missing the required scopes', () => {
+            const portalLimitReachedError = mockHubSpotHttpError('Portal limit reached error', {
+                status: 400,
+                data: {
+                    message: 'Portal limit reached error',
+                    errorType: 'TEST_PORTAL_LIMIT_REACHED',
+                },
+            });
+            expect(() => handleDeveloperTestAccountCreateError(portalLimitReachedError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Portal limit reached error');
+            expect(loggerErrorSpy).toHaveBeenCalled();
+        });
+        it('should log a generic error message for an unknown error type', () => {
+            const someUnknownError = mockHubSpotHttpError('Some unknown error', {
+                status: 400,
+                data: {
+                    message: 'Some unknown error',
+                    category: 'SOME_UNKNOWN_ERROR',
+                },
+            });
+            expect(() => handleDeveloperTestAccountCreateError(someUnknownError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Some unknown error');
+            expect(logErrorSpy).toHaveBeenCalled();
+        });
+    });
+});

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

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

package/lib/__tests__/hasFeature.test.js

@@ -0,0 +1,35 @@
+import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { hasFeature } from '../hasFeature.js';
+vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
+const mockedFetchEnabledFeatures = fetchEnabledFeatures;
+describe('lib/hasFeature', () => {
+    describe('hasFeature()', () => {
+        const accountId = 123;
+        beforeEach(() => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-1': true,
+                        'feature-2': false,
+                        'feature-3': true,
+                    },
+                },
+            });
+        });
+        it('should return true if the feature is enabled', async () => {
+            // @ts-expect-error test data
+            const result = await hasFeature(accountId, 'feature-1');
+            expect(result).toBe(true);
+        });
+        it('should return false if the feature is not enabled', async () => {
+            // @ts-expect-error test data
+            const result = await hasFeature(accountId, 'feature-2');
+            expect(result).toBe(false);
+        });
+        it('should return false if the feature is not present', async () => {
+            // @ts-expect-error test data
+            const result = await hasFeature(accountId, 'feature-4');
+            expect(result).toBe(false);
+        });
+    });
+});

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

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

package/lib/__tests__/importData.test.js

@@ -0,0 +1,89 @@
+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 { handleImportData, handleTargetTestAccountSelectionFlow, } from '../importData.js';
+import { lib } from '../../lang/en.js';
+import { isDeveloperTestAccount, isStandardAccount, isAppDeveloperAccount, } from '../accountTypes.js';
+import { importDataTestAccountSelectPrompt } from '../prompts/importDataTestAccountSelectPrompt.js';
+vi.mock('../ui/logger');
+vi.mock('@hubspot/local-dev-lib/api/crm');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../accountTypes');
+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 mockIsDeveloperTestAccount = vi.mocked(isDeveloperTestAccount);
+    const mockIsStandardAccount = vi.mocked(isStandardAccount);
+    const mockIsAppDeveloperAccount = vi.mocked(isAppDeveloperAccount);
+    const mockImportDataTestAccountSelectPrompt = vi.mocked(importDataTestAccountSelectPrompt);
+    beforeEach(() => {
+        mockUiLogger.info.mockReset();
+        mockUiLogger.success.mockReset();
+        mockUiLogger.error.mockReset();
+        mockCreateImport.mockReset();
+        mockGetAccountConfig.mockReset();
+        mockGetAccountId.mockReset();
+        mockIsDeveloperTestAccount.mockReset();
+        mockIsStandardAccount.mockReset();
+        mockIsAppDeveloperAccount.mockReset();
+        mockImportDataTestAccountSelectPrompt.mockReset();
+    });
+    describe('handleImportData', () => {
+        const targetAccountId = 123456789;
+        const dataFileNames = ['test-file.json'];
+        const importRequest = {
+            name: 'test-import',
+        };
+        it('should log the correct success message', async () => {
+            // @ts-expect-error - mockCreateImport is not typed correctly
+            mockCreateImport.mockResolvedValue({
+                data: { id: '123' },
+            });
+            await handleImportData(targetAccountId, dataFileNames, importRequest);
+            expect(mockUiLogger.success).toHaveBeenCalledWith(lib.importData.viewImportLink('https://app.hubspot.com', targetAccountId, '123'));
+        });
+        it('should log the correct error message', async () => {
+            mockCreateImport.mockRejectedValue(new Error('test-error'));
+            // weird because we catch the error, log a specific message, and then throw it again
+            await expect(handleImportData(targetAccountId, dataFileNames, importRequest)).rejects.toThrow('test-error');
+            expect(mockUiLogger.error).toHaveBeenCalledWith(lib.importData.errors.failedToImportData);
+        });
+    });
+    describe('handleTargetTestAccountSelectionFlow', () => {
+        const userProvidedAccountId = '1234';
+        const derivedAccountId = 123456789;
+        it('should error if the userProvidedAccountId is not the right account type', async () => {
+            mockGetAccountConfig.mockReturnValue({});
+            mockGetAccountId.mockReturnValue(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({});
+            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);
+            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,
+            });
+            const result = await handleTargetTestAccountSelectionFlow(derivedAccountId, undefined);
+            expect(result).toBe(890223);
+        });
+    });
+});

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

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

package/lib/__tests__/npm.test.js

@@ -0,0 +1,57 @@
+import util from 'util';
+import { isGloballyInstalled, getLatestCliVersion, DEFAULT_PACKAGE_MANAGER, } from '../npm.js';
+import pkg from '../../package.json' with { type: 'json' };
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../ui/SpinniesManager');
+describe('lib/npm', () => {
+    let execMock;
+    function mockedPromisify(execMock) {
+        return vi
+            .fn()
+            .mockReturnValue(execMock);
+    }
+    beforeEach(() => {
+        execMock = vi.fn();
+        util.promisify = mockedPromisify(execMock);
+    });
+    describe('isGloballyInstalled()', () => {
+        it('should return true when exec is successful', async () => {
+            const actual = await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER);
+            expect(actual).toBe(true);
+            expect(execMock).toHaveBeenCalledTimes(1);
+            expect(execMock).toHaveBeenCalledWith(`${DEFAULT_PACKAGE_MANAGER} --version`);
+        });
+        it('should return false when exec is unsuccessful', async () => {
+            execMock.mockImplementationOnce(() => {
+                throw new Error('unsuccessful');
+            });
+            util.promisify = mockedPromisify(execMock);
+            const actual = await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER);
+            expect(actual).toBe(false);
+            expect(execMock).toHaveBeenCalledTimes(1);
+            expect(execMock).toHaveBeenCalledWith(`${DEFAULT_PACKAGE_MANAGER} --version`);
+        });
+    });
+    describe('getLatestCliVersion()', () => {
+        it('should return the version correctly', async () => {
+            const latest = '1.0.0';
+            const next = '1.0.0.beta.1';
+            execMock.mockResolvedValueOnce({
+                stdout: JSON.stringify({ latest, next }),
+            });
+            util.promisify = mockedPromisify(execMock);
+            const actual = await getLatestCliVersion();
+            expect(actual).toEqual({ latest, next });
+            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
+        });
+        it('should throw any errors that encounter with the check', async () => {
+            const errorMessage = 'unsuccessful';
+            execMock.mockImplementationOnce(() => {
+                throw new Error(errorMessage);
+            });
+            util.promisify = mockedPromisify(execMock);
+            await expect(() => getLatestCliVersion()).rejects.toThrow(errorMessage);
+            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
+        });
+    });
+});

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

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

package/lib/__tests__/oauth.test.js

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

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

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

package/lib/__tests__/parsing.test.js

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