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

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

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

package/lib/__tests__/developerTestAccounts.test.js

@@ -1,156 +0,0 @@
-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('@hubspot/local-dev-lib/api/developerTestAccounts');
-vi.mock('../errorHandlers');
-const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
-const mockedGetAllConfigAccounts = getAllConfigAccounts;
-const mockedGetConfigAccountById = getConfigAccountById;
-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',
-        authType: 'personalaccesskey',
-    },
-];
-describe('lib/developerTestAccounts', () => {
-    describe('getHasDevTestAccounts()', () => {
-        it('should return true if there are developer test accounts associated with the account', () => {
-            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', () => {
-            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', () => {
-            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
-            mockedGetAllConfigAccounts.mockReturnValueOnce(undefined);
-            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
-            expect(result).toBe(false);
-        });
-    });
-    describe('validateDevTestAccountUsageLimits()', () => {
-        afterEach(() => {
-            mockedGetConfigAccountIfExists.mockRestore();
-            mockedFetchDeveloperTestAccounts.mockRestore();
-        });
-        it('should return null if the account id is not found', async () => {
-            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 () => {
-            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
-            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 () => {
-            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
-            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 () => {
-            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
-            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(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();
-            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(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', {
-                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(uiLogger.error).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(logError).toHaveBeenCalled();
-        });
-    });
-});

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

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

package/lib/__tests__/hasFeature.test.js

@@ -1,167 +0,0 @@
-import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { http } from '@hubspot/local-dev-lib/http';
-import { hasFeature, hasUnfiedAppsAccess } from '../hasFeature.js';
-import { FEATURES } from '../constants.js';
-vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
-vi.mock('@hubspot/local-dev-lib/http');
-const mockedFetchEnabledFeatures = fetchEnabledFeatures;
-const mockedHttp = http;
-describe('lib/hasFeature', () => {
-    describe('hasFeature()', () => {
-        const accountId = 123;
-        it('should return true if the feature is enabled', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-1': true,
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const result = await hasFeature(accountId, 'feature-1');
-            expect(result).toBe(true);
-        });
-        it('should return false if the feature is disabled', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-2': false,
-                    },
-                },
-            });
-            // @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 () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {},
-                },
-            });
-            // @ts-expect-error test data
-            const result = await hasFeature(accountId, 'feature-4');
-            expect(result).toBe(false);
-        });
-        it('should return true for APPS_HOME feature when not present in enabled features (defaults on)', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {},
-                },
-            });
-            const result = await hasFeature(accountId, FEATURES.APPS_HOME);
-            expect(result).toBe(true);
-        });
-        it('should respect explicit setting for APPS_HOME feature even when it defaults on', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        [FEATURES.APPS_HOME]: false,
-                    },
-                },
-            });
-            const result = await hasFeature(accountId, FEATURES.APPS_HOME);
-            expect(result).toBe(false);
-        });
-        it('should handle truthy values correctly', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-truthy': 'yes',
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const truthyResult = await hasFeature(accountId, 'feature-truthy');
-            expect(truthyResult).toBe(true);
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-number': 1,
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const numberResult = await hasFeature(accountId, 'feature-number');
-            expect(numberResult).toBe(true);
-        });
-        it('should handle falsy values correctly', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-null': null,
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const nullResult = await hasFeature(accountId, 'feature-null');
-            expect(nullResult).toBe(false);
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-zero': 0,
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const zeroResult = await hasFeature(accountId, 'feature-zero');
-            expect(zeroResult).toBe(false);
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-empty': '',
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const emptyResult = await hasFeature(accountId, 'feature-empty');
-            expect(emptyResult).toBe(false);
-        });
-        it('should propagate errors from fetchEnabledFeatures', async () => {
-            const error = new Error('API error');
-            mockedFetchEnabledFeatures.mockRejectedValueOnce(error);
-            await expect(hasFeature(accountId, FEATURES.UNIFIED_APPS)).rejects.toThrow('API error');
-        });
-    });
-    describe('hasUnfiedAppsAccess()', () => {
-        const accountId = 123;
-        it('should return true when API returns true', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: true });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(true);
-            expect(mockedHttp.get).toHaveBeenCalledWith(accountId, {
-                url: 'developer-tooling/external/developer-portal/has-unified-dev-platform-access',
-            });
-        });
-        it('should return false when API returns false', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: false });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(false);
-        });
-        it('should handle truthy values correctly', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: 'yes' });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(true);
-        });
-        it('should handle falsy values correctly', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: null });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(false);
-        });
-        it('should handle undefined response data', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: undefined });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(false);
-        });
-        it('should propagate errors from http.get', async () => {
-            const error = new Error('Network error');
-            mockedHttp.get.mockRejectedValueOnce(error);
-            await expect(hasUnfiedAppsAccess(accountId)).rejects.toThrow('Network error');
-        });
-    });
-});

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

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

package/lib/__tests__/http.test.js

@@ -1,40 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import http from 'http';
-import { isServerRunningAtUrl } from '../http.js';
-describe('isServerRunningAtUrl', () => {
-    let server;
-    let serverPort;
-    beforeAll(async () => {
-        server = http.createServer((req, res) => {
-            res.writeHead(200);
-            res.end('OK');
-        });
-        await new Promise(resolve => {
-            server.listen(0, () => {
-                serverPort = server.address().port;
-                resolve();
-            });
-        });
-    });
-    afterAll(async () => {
-        await new Promise(resolve => {
-            server.close(() => resolve());
-        });
-    });
-    it('should return true when a server is running', async () => {
-        const result = await isServerRunningAtUrl(`http://localhost:${serverPort}`);
-        expect(result).toBe(true);
-    });
-    it('should return false when connection is refused', async () => {
-        const result = await isServerRunningAtUrl('http://localhost:59999');
-        expect(result).toBe(false);
-    });
-    it('should return false for invalid URLs', async () => {
-        const result = await isServerRunningAtUrl('not-a-valid-url');
-        expect(result).toBe(false);
-    });
-    it('should handle different paths on the same server', async () => {
-        const result = await isServerRunningAtUrl(`http://localhost:${serverPort}/some/path`);
-        expect(result).toBe(true);
-    });
-});

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

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

package/lib/__tests__/importData.test.js

@@ -1,98 +0,0 @@
-import { uiLogger } from '../ui/logger.js';
-import { createImport } from '@hubspot/local-dev-lib/api/crm';
-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';
-import { importDataTestAccountSelectPrompt } from '../prompts/importDataTestAccountSelectPrompt.js';
-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 mockGetConfigAccountById = vi.mocked(getConfigAccountById);
-    const mockGetConfigAccountIfExists = vi.mocked(getConfigAccountIfExists);
-    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();
-        mockGetConfigAccountById.mockReset();
-        mockGetConfigAccountIfExists.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.info).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 () => {
-            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 () => {
-            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 () => {
-            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 () => {
-            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__/npmCli.test.d.ts

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

package/lib/__tests__/npmCli.test.js

@@ -1,84 +0,0 @@
-import util from 'util';
-import { isGloballyInstalled, getLatestPackageVersion, isInstalledGloballyWithNPM, DEFAULT_PACKAGE_MANAGER, } from '../npm/npmCli.js';
-import { pkg } from '../jsonLoader.js';
-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('getLatestPackageVersion()', () => {
-        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 getLatestPackageVersion(pkg.name);
-            expect(actual).toEqual({ latest, next });
-            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
-        });
-        it('should return null values when the check fails', async () => {
-            const errorMessage = 'unsuccessful';
-            execMock.mockImplementationOnce(() => {
-                throw new Error(errorMessage);
-            });
-            util.promisify = mockedPromisify(execMock);
-            const result = await getLatestPackageVersion(pkg.name);
-            expect(result).toEqual({ latest: null, next: null });
-            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
-        });
-    });
-    describe('isInstalledGloballyWithNPM()', () => {
-        it('should return true when npm is installed and package is in npm global list', async () => {
-            execMock.mockResolvedValueOnce({ stdout: '', stderr: '' }); // npm check
-            execMock.mockResolvedValueOnce({ stdout: '', stderr: '' }); // npm list succeeds
-            const result = await isInstalledGloballyWithNPM('@hubspot/cli');
-            expect(result).toBe(true);
-            expect(execMock).toHaveBeenCalledTimes(2);
-            expect(execMock).toHaveBeenNthCalledWith(1, 'npm --version');
-            expect(execMock).toHaveBeenNthCalledWith(2, 'npm list -g @hubspot/cli --depth=0');
-        });
-        it('should return false when npm is not globally installed', async () => {
-            execMock.mockRejectedValueOnce(new Error('npm not found')); // npm check fails
-            const result = await isInstalledGloballyWithNPM('@hubspot/cli');
-            expect(result).toBe(false);
-            expect(execMock).toHaveBeenCalledTimes(1);
-            expect(execMock).toHaveBeenCalledWith('npm --version');
-        });
-        it('should return false when npm list fails (package not installed via npm)', async () => {
-            execMock.mockResolvedValueOnce({ stdout: '', stderr: '' }); // npm check
-            execMock.mockRejectedValueOnce(new Error('Package not found')); // npm list fails
-            const result = await isInstalledGloballyWithNPM('@hubspot/cli');
-            expect(result).toBe(false);
-            expect(execMock).toHaveBeenCalledTimes(2);
-            expect(execMock).toHaveBeenNthCalledWith(1, 'npm --version');
-            expect(execMock).toHaveBeenNthCalledWith(2, 'npm list -g @hubspot/cli --depth=0');
-        });
-    });
-});

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

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