@hubspot/cli 7.6.0-beta.5 → 7.6.0-beta.7

package/lib/__tests__/dependencyManagement.test.js

@@ -1,15 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = __importDefault(require("util"));
-const dependencyManagement_1 = require("../dependencyManagement");
-const fs_1 = require("@hubspot/local-dev-lib/fs");
-const path_1 = __importDefault(require("path"));
-const config_1 = require("../projects/config");
-const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
-const fs_2 = __importDefault(require("fs"));
+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');
@@ -22,14 +17,14 @@ vi.mock('../ui/SpinniesManager', () => ({
         fail: vi.fn(),
     },
 }));
-const mockedFs = vi.mocked(fs_2.default);
+const mockedFs = vi.mocked(fs);
 describe('lib/dependencyManagement', () => {
     let execMock;
-    const projectDir = path_1.default.join('path', 'to', 'project');
+    const projectDir = path.join('path', 'to', 'project');
     const srcDir = 'src';
-    const appDir = path_1.default.join(projectDir, srcDir, 'app');
-    const appFunctionsDir = path_1.default.join(appDir, 'app.functions');
-    const extensionsDir = path_1.default.join(appDir, 'exensions');
+    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) {
@@ -37,11 +32,11 @@ describe('lib/dependencyManagement', () => {
             .fn()
             .mockReturnValue(execMock);
     }
-    const mockedWalk = fs_1.walk;
-    const mockedGetProjectConfig = config_1.getProjectConfig;
+    const mockedWalk = walk;
+    const mockedGetProjectConfig = getProjectConfig;
     beforeEach(() => {
         execMock = vi.fn();
-        util_1.default.promisify = mockedPromisify(execMock);
+        util.promisify = mockedPromisify(execMock);
         mockedGetProjectConfig.mockResolvedValue({
             projectDir,
             projectConfig: {
@@ -55,31 +50,31 @@ describe('lib/dependencyManagement', () => {
     describe('installPackages()', () => {
         it('should setup a loading spinner', async () => {
             const packages = ['package1', 'package2'];
-            await (0, dependencyManagement_1.installPackages)({ packages, installLocations });
-            expect(SpinniesManager_1.default.init).toHaveBeenCalledTimes(installLocations.length);
-            expect(SpinniesManager_1.default.add).toHaveBeenCalledTimes(installLocations.length);
-            expect(SpinniesManager_1.default.succeed).toHaveBeenCalledTimes(installLocations.length);
+            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 (0, dependencyManagement_1.installPackages)({ packages, installLocations });
+            await installPackages({ packages, installLocations });
             expect(execMock).toHaveBeenCalledTimes(installLocations.length);
-            expect(SpinniesManager_1.default.add).toHaveBeenCalledTimes(installLocations.length);
-            expect(SpinniesManager_1.default.succeed).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_1.default.add).toHaveBeenCalledWith(`installingDependencies-${location}`, {
+                expect(SpinniesManager.add).toHaveBeenCalledWith(`installingDependencies-${location}`, {
                     text: `Installing [package1, package2] in ${location}`,
                 });
-                expect(SpinniesManager_1.default.succeed).toHaveBeenCalledWith(`installingDependencies-${location}`, {
+                expect(SpinniesManager.succeed).toHaveBeenCalledWith(`installingDependencies-${location}`, {
                     text: `Installed dependencies in ${location}`,
                 });
             }
         });
         it('should use the provided install locations', async () => {
-            await (0, dependencyManagement_1.installPackages)({ installLocations });
+            await installPackages({ installLocations });
             expect(execMock).toHaveBeenCalledTimes(installLocations.length);
             expect(execMock).toHaveBeenCalledWith(`npm install `, {
                 cwd: appFunctionsDir,
@@ -90,8 +85,8 @@ describe('lib/dependencyManagement', () => {
         });
         it('should locate the projects package.json files when install locations is not provided', async () => {
             const installLocations = [
-                path_1.default.join(appFunctionsDir, 'package.json'),
-                path_1.default.join(extensionsDir, 'package.json'),
+                path.join(appFunctionsDir, 'package.json'),
+                path.join(extensionsDir, 'package.json'),
             ];
             mockedWalk.mockResolvedValue(installLocations);
             mockedGetProjectConfig.mockResolvedValue({
@@ -100,7 +95,7 @@ describe('lib/dependencyManagement', () => {
                     srcDir,
                 },
             });
-            await (0, dependencyManagement_1.installPackages)({});
+            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 `, {
@@ -117,23 +112,23 @@ describe('lib/dependencyManagement', () => {
                 }
                 throw new Error('OH NO');
             });
-            util_1.default.promisify = mockedPromisify(execMock);
+            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_1.default.join(projectDir, srcDir)) {
+                    pathStr === path.join(projectDir, srcDir)) {
                     return true;
                 }
                 return false;
             });
-            await expect(() => (0, dependencyManagement_1.installPackages)({ installLocations: [appFunctionsDir, extensionsDir] })).rejects.toThrowError(`Installing dependencies for ${appFunctionsDir} failed`);
-            expect(SpinniesManager_1.default.fail).toHaveBeenCalledTimes(installLocations.length);
-            expect(SpinniesManager_1.default.fail).toHaveBeenCalledWith(`installingDependencies-${appFunctionsDir}`, {
+            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_1.default.fail).toHaveBeenCalledWith(`installingDependencies-${extensionsDir}`, {
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`installingDependencies-${extensionsDir}`, {
                 text: `Installing dependencies for ${extensionsDir} failed`,
             });
         });
@@ -141,39 +136,39 @@ describe('lib/dependencyManagement', () => {
     describe('getProjectPackageJsonFiles()', () => {
         it('should throw an error when ran outside the boundary of a project', async () => {
             mockedGetProjectConfig.mockResolvedValue({});
-            await expect(() => (0, dependencyManagement_1.getProjectPackageJsonLocations)()).rejects.toThrowError('No project detected. Run this command from a project directory.');
+            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_1.default.promisify = mockedPromisify(execMock);
-            await expect(() => (0, dependencyManagement_1.getProjectPackageJsonLocations)()).rejects.toThrowError(/This command depends on npm, install/);
+            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(() => (0, dependencyManagement_1.getProjectPackageJsonLocations)()).rejects.toThrowError(new RegExp(`No dependencies to install. The project ${projectName} folder might be missing component or subcomponent files.`));
+            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_1.default.join(appDir, 'node_modules');
-            const viteDir = path_1.default.join(appDir, '.vite');
+            const nodeModulesDir = path.join(appDir, 'node_modules');
+            const viteDir = path.join(appDir, '.vite');
             const installLocations = [
-                path_1.default.join(appFunctionsDir, 'package.json'),
-                path_1.default.join(extensionsDir, 'package.json'),
-                path_1.default.join(viteDir, 'package.json'),
-                path_1.default.join(nodeModulesDir, 'package.json'),
+                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_1.default.join(projectDir, srcDir)) {
+                    pathStr === path.join(projectDir, srcDir)) {
                     return true;
                 }
                 return false;
             });
-            const actual = await (0, dependencyManagement_1.getProjectPackageJsonLocations)();
+            const actual = await getProjectPackageJsonLocations();
             expect(actual).toEqual([appFunctionsDir, extensionsDir]);
         });
     });

package/lib/__tests__/developerTestAccounts.test.js

@@ -1,62 +1,27 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const config_1 = require("@hubspot/local-dev-lib/config");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const config_2 = require("@hubspot/local-dev-lib/constants/config");
-const developerTestAccounts_1 = require("@hubspot/local-dev-lib/api/developerTestAccounts");
-const testUtils_1 = require("../testUtils");
-const errorHandlers = __importStar(require("../errorHandlers"));
-const developerTestAccounts_2 = require("../developerTestAccounts");
+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 = config_1.getAccountId;
-const mockedGetConfigAccounts = config_1.getConfigAccounts;
-const mockedFetchDeveloperTestAccounts = developerTestAccounts_1.fetchDeveloperTestAccounts;
+const mockedGetAccountId = getAccountId;
+const mockedGetConfigAccounts = getConfigAccounts;
+const mockedFetchDeveloperTestAccounts = fetchDeveloperTestAccounts;
 const APP_DEVELOPER_ACCOUNT_1 = {
     name: 'app-developer-1',
     accountId: 123,
-    accountType: config_2.HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
     env: 'prod',
 };
 const APP_DEVELOPER_ACCOUNT_2 = {
     name: 'app-developer-2',
     accountId: 456,
-    accountType: config_2.HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
     env: 'prod',
 };
 const accounts = [
@@ -66,7 +31,7 @@ const accounts = [
         name: 'test-account',
         accountId: 789,
         parentAccountId: APP_DEVELOPER_ACCOUNT_1.accountId,
-        accountType: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         env: 'prod',
     },
 ];
@@ -75,19 +40,19 @@ describe('lib/developerTestAccounts', () => {
         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 = (0, developerTestAccounts_2.getHasDevTestAccounts)(APP_DEVELOPER_ACCOUNT_1);
+            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 = (0, developerTestAccounts_2.getHasDevTestAccounts)(APP_DEVELOPER_ACCOUNT_2);
+            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 = (0, developerTestAccounts_2.getHasDevTestAccounts)(APP_DEVELOPER_ACCOUNT_1);
+            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
             expect(result).toBe(false);
         });
     });
@@ -98,7 +63,7 @@ describe('lib/developerTestAccounts', () => {
         });
         it('should return null if the account id is not found', async () => {
             mockedGetAccountId.mockReturnValueOnce(undefined);
-            const result = await (0, developerTestAccounts_2.validateDevTestAccountUsageLimits)(APP_DEVELOPER_ACCOUNT_1);
+            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 () => {
@@ -106,7 +71,7 @@ describe('lib/developerTestAccounts', () => {
             mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
                 data: null,
             });
-            const result = await (0, developerTestAccounts_2.validateDevTestAccountUsageLimits)(APP_DEVELOPER_ACCOUNT_1);
+            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 () => {
@@ -118,7 +83,7 @@ describe('lib/developerTestAccounts', () => {
             mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
                 data: testAccountData,
             });
-            const result = await (0, developerTestAccounts_2.validateDevTestAccountUsageLimits)(APP_DEVELOPER_ACCOUNT_1);
+            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 () => {
@@ -129,14 +94,14 @@ describe('lib/developerTestAccounts', () => {
                     results: [{}],
                 },
             });
-            await expect((0, developerTestAccounts_2.validateDevTestAccountUsageLimits)(APP_DEVELOPER_ACCOUNT_1)).rejects.toThrow();
+            await expect(validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1)).rejects.toThrow();
         });
     });
     describe('handleDeveloperTestAccountCreateError()', () => {
         let loggerErrorSpy;
         let logErrorSpy;
         beforeEach(() => {
-            loggerErrorSpy = vi.spyOn(logger_1.logger, 'error');
+            loggerErrorSpy = vi.spyOn(logger, 'error');
             logErrorSpy = vi.spyOn(errorHandlers, 'logError');
         });
         afterEach(() => {
@@ -144,36 +109,36 @@ describe('lib/developerTestAccounts', () => {
             logErrorSpy.mockRestore();
         });
         it('should log and throw an error if the account is missing the required scopes', () => {
-            const missingScopesError = (0, testUtils_1.mockHubSpotHttpError)('Missing scopes error', {
+            const missingScopesError = mockHubSpotHttpError('Missing scopes error', {
                 status: 403,
                 data: {
                     message: 'Missing scopes error',
                     category: 'MISSING_SCOPES',
                 },
             });
-            expect(() => (0, developerTestAccounts_2.handleDeveloperTestAccountCreateError)(missingScopesError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Missing scopes error');
+            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 = (0, testUtils_1.mockHubSpotHttpError)('Portal limit reached error', {
+            const portalLimitReachedError = mockHubSpotHttpError('Portal limit reached error', {
                 status: 400,
                 data: {
                     message: 'Portal limit reached error',
                     errorType: 'TEST_PORTAL_LIMIT_REACHED',
                 },
             });
-            expect(() => (0, developerTestAccounts_2.handleDeveloperTestAccountCreateError)(portalLimitReachedError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Portal limit reached error');
+            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 = (0, testUtils_1.mockHubSpotHttpError)('Some unknown error', {
+            const someUnknownError = mockHubSpotHttpError('Some unknown error', {
                 status: 400,
                 data: {
                     message: 'Some unknown error',
                     category: 'SOME_UNKNOWN_ERROR',
                 },
             });
-            expect(() => (0, developerTestAccounts_2.handleDeveloperTestAccountCreateError)(someUnknownError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('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.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const localDevAuth_1 = require("@hubspot/local-dev-lib/api/localDevAuth");
-const hasFeature_1 = require("../hasFeature");
+import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { hasFeature } from '../hasFeature.js';
 vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
-const mockedFetchEnabledFeatures = localDevAuth_1.fetchEnabledFeatures;
+const mockedFetchEnabledFeatures = fetchEnabledFeatures;
 describe('lib/hasFeature', () => {
     describe('hasFeature()', () => {
         const accountId = 123;
@@ -20,17 +18,17 @@ describe('lib/hasFeature', () => {
         });
         it('should return true if the feature is enabled', async () => {
             // @ts-expect-error test data
-            const result = await (0, hasFeature_1.hasFeature)(accountId, 'feature-1');
+            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 (0, hasFeature_1.hasFeature)(accountId, 'feature-2');
+            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 (0, hasFeature_1.hasFeature)(accountId, 'feature-4');
+            const result = await hasFeature(accountId, 'feature-4');
             expect(result).toBe(false);
         });
     });

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.js

@@ -1,11 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = __importDefault(require("util"));
-const npm_1 = require("../npm");
-const package_json_1 = __importDefault(require("../../package.json"));
+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', () => {
@@ -17,24 +12,24 @@ describe('lib/npm', () => {
     }
     beforeEach(() => {
         execMock = vi.fn();
-        util_1.default.promisify = mockedPromisify(execMock);
+        util.promisify = mockedPromisify(execMock);
     });
     describe('isGloballyInstalled()', () => {
         it('should return true when exec is successful', async () => {
-            const actual = await (0, npm_1.isGloballyInstalled)(npm_1.DEFAULT_PACKAGE_MANAGER);
+            const actual = await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER);
             expect(actual).toBe(true);
             expect(execMock).toHaveBeenCalledTimes(1);
-            expect(execMock).toHaveBeenCalledWith(`${npm_1.DEFAULT_PACKAGE_MANAGER} --version`);
+            expect(execMock).toHaveBeenCalledWith(`${DEFAULT_PACKAGE_MANAGER} --version`);
         });
         it('should return false when exec is unsuccessful', async () => {
             execMock.mockImplementationOnce(() => {
                 throw new Error('unsuccessful');
             });
-            util_1.default.promisify = mockedPromisify(execMock);
-            const actual = await (0, npm_1.isGloballyInstalled)(npm_1.DEFAULT_PACKAGE_MANAGER);
+            util.promisify = mockedPromisify(execMock);
+            const actual = await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER);
             expect(actual).toBe(false);
             expect(execMock).toHaveBeenCalledTimes(1);
-            expect(execMock).toHaveBeenCalledWith(`${npm_1.DEFAULT_PACKAGE_MANAGER} --version`);
+            expect(execMock).toHaveBeenCalledWith(`${DEFAULT_PACKAGE_MANAGER} --version`);
         });
     });
     describe('getLatestCliVersion()', () => {
@@ -44,19 +39,19 @@ describe('lib/npm', () => {
             execMock.mockResolvedValueOnce({
                 stdout: JSON.stringify({ latest, next }),
             });
-            util_1.default.promisify = mockedPromisify(execMock);
-            const actual = await (0, npm_1.getLatestCliVersion)();
+            util.promisify = mockedPromisify(execMock);
+            const actual = await getLatestCliVersion();
             expect(actual).toEqual({ latest, next });
-            expect(execMock).toHaveBeenCalledWith(`npm info ${package_json_1.default.name} dist-tags --json`);
+            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_1.default.promisify = mockedPromisify(execMock);
-            await expect(() => (0, npm_1.getLatestCliVersion)()).rejects.toThrow(errorMessage);
-            expect(execMock).toHaveBeenCalledWith(`npm info ${package_json_1.default.name} dist-tags --json`);
+            util.promisify = mockedPromisify(execMock);
+            await expect(() => getLatestCliVersion()).rejects.toThrow(errorMessage);
+            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
         });
     });
 });