@hubspot/cli 7.11.8-experimental.0 → 8.0.0-beta.1

package/lib/projects/__tests__/projectProfiles.test.js

@@ -0,0 +1,441 @@
+import path from 'path';
+import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, validateProfileVariables, } from '@hubspot/project-parsing-lib/profiles';
+import { lib } from '../../../lang/en.js';
+import { uiBetaTag, uiLine } from '../../ui/index.js';
+import { uiLogger } from '../../ui/logger.js';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { logProfileHeader, logProfileFooter, loadProfile, enforceProfileUsage, loadAndValidateProfile, validateProjectForProfile, } from '../projectProfiles.js';
+import { handleTranslate } from '../upload.js';
+import SpinniesManager from '../../ui/SpinniesManager.js';
+import { commands } from '../../../lang/en.js';
+// Mock dependencies
+vi.mock('@hubspot/project-parsing-lib/profiles');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../ui', async (importOriginal) => {
+    const actual = (await importOriginal());
+    return {
+        ...actual,
+        uiBetaTag: vi.fn(),
+        uiLine: vi.fn(),
+        indent: vi.fn((level) => '  '.repeat(level)),
+    };
+});
+vi.mock('../../../lang/en');
+vi.mock('../upload');
+vi.mock('../../ui/SpinniesManager');
+const mockedLoadHsProfileFile = loadHsProfileFile;
+const mockedGetHsProfileFilename = getHsProfileFilename;
+const mockedGetAllHsProfiles = getAllHsProfiles;
+const mockedValidateProfileVariables = validateProfileVariables;
+const mockedGetConfigAccountById = getConfigAccountById;
+const mockedUiBetaTag = uiBetaTag;
+const mockedUiLine = uiLine;
+const mockedUiLogger = uiLogger;
+describe('lib/projectProfiles', () => {
+    describe('logProfileHeader()', () => {
+        it('should log profile header with correct format', () => {
+            const profileName = 'test-profile';
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            logProfileHeader(profileName);
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiBetaTag).toHaveBeenCalledWith(lib.projectProfiles.logs.usingProfile(filename));
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+    });
+    describe('logProfileFooter()', () => {
+        const mockProfile = {
+            accountId: 123,
+            variables: {
+                key1: 'value1',
+                key2: 'value2',
+            },
+        };
+        it('should log profile footer with account ID', () => {
+            logProfileFooter(mockProfile);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+        it('should log variables when includeVariables is true', () => {
+            logProfileFooter(mockProfile, true);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileVariables);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('  key1: value1');
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('  key2: value2');
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+    });
+    describe('loadProfile()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '1.0.0',
+        };
+        const mockProjectDir = '/test/project';
+        const mockProfileName = 'test-profile';
+        const mockProfile = {
+            accountId: 123,
+        };
+        it('should throw error when project config is missing', () => {
+            expect(() => loadProfile(null, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        });
+        it('should throw error when project dir is missing', () => {
+            expect(() => loadProfile(mockProjectConfig, null, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        });
+        it('should throw error when profile is not found', () => {
+            mockedLoadHsProfileFile.mockReturnValue(null);
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
+        });
+        it('should throw error when profile has no account ID', () => {
+            mockedLoadHsProfileFile.mockReturnValue({});
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
+        });
+        it('should throw error when profile loading fails', () => {
+            mockedLoadHsProfileFile.mockImplementation(() => {
+                throw new Error('Load failed');
+            });
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
+        });
+        it('should throw error when account is not found in config', () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockImplementation(() => {
+                throw new Error('Account not found');
+            });
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.listedAccountNotFound(mockProfile.accountId, filename));
+        });
+        it('should return profile when loading succeeds', () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockProfile.accountId,
+            });
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toEqual(mockProfile);
+            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
+            expect(mockedGetConfigAccountById).toHaveBeenCalledWith(mockProfile.accountId);
+        });
+    });
+    describe('enforceProfileUsage()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '1.0.0',
+        };
+        const mockProjectDir = '/test/project';
+        it('should not throw when no profiles exist', async () => {
+            mockedGetAllHsProfiles.mockResolvedValue([]);
+            await expect(enforceProfileUsage(mockProjectConfig, mockProjectDir)).resolves.toBeUndefined();
+        });
+        it('should throw error when profiles exist', async () => {
+            mockedGetAllHsProfiles.mockResolvedValue(['profile1', 'profile2']);
+            await expect(enforceProfileUsage(mockProjectConfig, mockProjectDir)).rejects.toThrow(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+        });
+        it('should not throw when project config is null', async () => {
+            await expect(enforceProfileUsage(null, mockProjectDir)).resolves.toBeUndefined();
+        });
+        it('should not throw when project dir is null', async () => {
+            await expect(enforceProfileUsage(mockProjectConfig, null)).resolves.toBeUndefined();
+        });
+    });
+    describe('loadAndValidateProfile()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '1.0.0',
+        };
+        const mockProjectDir = '/test/project';
+        const mockProfileName = 'test-profile';
+        const mockProfile = {
+            accountId: 123,
+            variables: {
+                key1: 'value1',
+                key2: 'value2',
+            },
+        };
+        it('should enforce profile usage when no profile name provided', async () => {
+            mockedGetAllHsProfiles.mockResolvedValue([]);
+            const result = await loadAndValidateProfile(mockProjectConfig, mockProjectDir, undefined);
+            expect(result).toBeUndefined();
+            expect(mockedGetAllHsProfiles).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir));
+        });
+        it('should throw when profiles exist but no profile name provided', async () => {
+            mockedGetAllHsProfiles.mockResolvedValue(['profile1']);
+            await expect(loadAndValidateProfile(mockProjectConfig, mockProjectDir, undefined)).rejects.toThrow(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+        });
+        it('should load and return account ID when profile is valid', async () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockProfile.accountId,
+            });
+            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
+            mockedValidateProfileVariables.mockReturnValue({ success: true });
+            const result = await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBe(mockProfile.accountId);
+            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
+            expect(mockedValidateProfileVariables).toHaveBeenCalledWith(mockProfile.variables, mockProfileName);
+        });
+        it('should log profile header and footer when not silent', async () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockProfile.accountId,
+            });
+            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
+            mockedValidateProfileVariables.mockReturnValue({ success: true });
+            await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName, false);
+            expect(mockedUiBetaTag).toHaveBeenCalled();
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiLogger.log).toHaveBeenCalled();
+        });
+        it('should not log when silent is true', async () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockProfile.accountId,
+            });
+            mockedValidateProfileVariables.mockReturnValue({ success: true });
+            await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName, true);
+            expect(mockedUiBetaTag).not.toHaveBeenCalled();
+            expect(mockedUiLine).not.toHaveBeenCalled();
+        });
+        it('should throw error when profile variables are invalid', async () => {
+            const invalidProfile = {
+                accountId: 123,
+                variables: {
+                    invalid: 'value',
+                },
+            };
+            const validationErrors = ['Variable "invalid" is not allowed'];
+            mockedLoadHsProfileFile.mockReturnValue(invalidProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: invalidProfile.accountId,
+            });
+            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
+            mockedValidateProfileVariables.mockReturnValue({
+                success: false,
+                errors: validationErrors,
+            });
+            await expect(loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName)).rejects.toThrow(lib.projectProfiles.loadProfile.errors.profileNotValid('test-profile.hsprofile', validationErrors));
+        });
+        it('should not validate when profile has no variables', async () => {
+            const profileWithoutVars = {
+                accountId: 123,
+            };
+            mockedLoadHsProfileFile.mockReturnValue(profileWithoutVars);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: profileWithoutVars.accountId,
+            });
+            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
+            const result = await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBe(profileWithoutVars.accountId);
+            expect(mockedValidateProfileVariables).not.toHaveBeenCalled();
+        });
+    });
+    describe('validateProjectForProfile()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '2025.2',
+        };
+        const mockProjectDir = '/test/project';
+        const mockProfileName = 'test-profile';
+        const mockDerivedAccountId = 123;
+        const mockProfileFilename = 'test-profile.hsprofile';
+        const mockProfile = {
+            accountId: mockDerivedAccountId,
+        };
+        beforeEach(() => {
+            mockedGetHsProfileFilename.mockReturnValue(mockProfileFilename);
+            vi.mocked(SpinniesManager.init);
+            vi.mocked(SpinniesManager.add);
+            vi.mocked(SpinniesManager.succeed);
+            vi.mocked(SpinniesManager.fail);
+            // Mock dependencies for loadAndValidateProfile
+            mockedGetAllHsProfiles.mockResolvedValue([]);
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockDerivedAccountId,
+            });
+            mockedValidateProfileVariables.mockReturnValue({ success: true });
+            vi.mocked(handleTranslate).mockResolvedValue(undefined);
+        });
+        it('should return empty array when validation succeeds', async () => {
+            const result = await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+            });
+            expect(result).toEqual([]);
+            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.validatingProfile(mockProfileFilename),
+                indent: 0,
+            });
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.profileValidationSucceeded(mockProfileFilename),
+                succeedColor: 'white',
+            });
+        });
+        it('should call handleTranslate with profile account ID from profile', async () => {
+            await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+            });
+            expect(handleTranslate).toHaveBeenCalledWith({
+                projectDir: mockProjectDir,
+                projectConfig: mockProjectConfig,
+                accountId: mockDerivedAccountId,
+                skipValidation: false,
+                profile: mockProfileName,
+                includeTranslationErrorMessage: false,
+            });
+        });
+        it('should call handleTranslate with different profile account ID when profile has different ID', async () => {
+            const profileAccountId = 456;
+            const profileWithDifferentId = {
+                accountId: profileAccountId,
+            };
+            mockedLoadHsProfileFile.mockReturnValue(profileWithDifferentId);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: profileAccountId,
+            });
+            await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+            });
+            expect(handleTranslate).toHaveBeenCalledWith({
+                projectDir: mockProjectDir,
+                projectConfig: mockProjectConfig,
+                accountId: profileAccountId,
+                skipValidation: false,
+                profile: mockProfileName,
+                includeTranslationErrorMessage: false,
+            });
+        });
+        it('should return error when profile has no accountId', async () => {
+            // @ts-expect-error causing an error on purpose
+            const profileWithoutId = {};
+            mockedLoadHsProfileFile.mockReturnValue(profileWithoutId);
+            const result = await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+            });
+            expect(result.length).toBeGreaterThan(0);
+            expect(SpinniesManager.fail).toHaveBeenCalled();
+            expect(handleTranslate).not.toHaveBeenCalled();
+        });
+        it('should indent spinners when indentSpinners is true', async () => {
+            await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+                indentSpinners: true,
+            });
+            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.validatingProfile(mockProfileFilename),
+                indent: 2,
+            });
+        });
+        it('should not indent spinners when indentSpinners is false', async () => {
+            await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+                indentSpinners: false,
+            });
+            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.validatingProfile(mockProfileFilename),
+                indent: 0,
+            });
+        });
+        it('should return error array when profile loading fails', async () => {
+            mockedLoadHsProfileFile.mockReturnValue(null);
+            const result = await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+            });
+            expect(result.length).toBeGreaterThan(0);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.profileValidationFailed(mockProfileFilename),
+                failColor: 'white',
+            });
+            expect(handleTranslate).not.toHaveBeenCalled();
+        });
+        it('should return error when profile file loading throws', async () => {
+            mockedLoadHsProfileFile.mockImplementation(() => {
+                throw new Error('Failed to load profile file');
+            });
+            const result = await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+            });
+            expect(result.length).toBeGreaterThan(0);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.profileValidationFailed(mockProfileFilename),
+                failColor: 'white',
+            });
+            expect(handleTranslate).not.toHaveBeenCalled();
+        });
+        it('should return error array when translation fails', async () => {
+            const error = new Error('Translation failed');
+            vi.mocked(handleTranslate).mockRejectedValue(error);
+            const result = await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+            });
+            expect(result).toHaveLength(2);
+            expect(result[0]).toBe(commands.project.validate.failureWithProfile(mockProfileName));
+            expect(result[1]).toBe(`  ${error.message}\n`);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.invalidWithProfile(mockProfileName),
+                failColor: 'white',
+            });
+        });
+        it('should return string error when translation fails with non-Error', async () => {
+            const error = 'Translation error';
+            vi.mocked(handleTranslate).mockRejectedValue(error);
+            const result = await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: mockProfileName,
+                derivedAccountId: mockDerivedAccountId,
+            });
+            expect(result).toHaveLength(2);
+            expect(result[0]).toBe(commands.project.validate.failureWithProfile(mockProfileName));
+            expect(result[1]).toBe(`  ${error}\n`);
+        });
+        it('should use correct spinner name based on profile name', async () => {
+            const customProfileName = 'custom-profile';
+            await validateProjectForProfile({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileName: customProfileName,
+                derivedAccountId: mockDerivedAccountId,
+            });
+            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${customProfileName}`, expect.any(Object));
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith(`validatingProfile-${customProfileName}`, expect.any(Object));
+        });
+    });
+});

package/lib/projects/__tests__/projects.test.js

@@ -3,7 +3,6 @@ import os from 'os';
 import path from 'path';
 import { validateProjectConfig } from '../../projects/config.js';
 import ProjectValidationError from '../../errors/ProjectValidationError.js';
-vi.mock('../../ui/logger.js');
 describe('lib/projects', () => {
     describe('validateProjectConfig()', () => {
         let projectDir;

package/lib/projects/__tests__/structure.test.js

@@ -5,7 +5,6 @@ import { getComponentTypeFromConfigFile, loadConfigFile, getAppCardConfigs, getI
 import { ComponentTypes } from '../../../types/Projects.js';
 vi.mock('fs');
 vi.mock('@hubspot/local-dev-lib/fs');
-vi.mock('../../ui/logger.js');
 const mockedReadFileSync = fs.readFileSync;
 const mockedWalk = HSfs.walk;
 const getMockPrivateAppConfig = (cards = []) => ({

package/lib/projects/__tests__/uieLinting.test.js

@@ -4,7 +4,7 @@ import util from 'util';
 import { uiLogger } from '../../ui/logger.js';
 import * as dependencyManagement from '../../dependencyManagement.js';
 import { isEslintInstalled, areAllLintPackagesInstalled, getMissingLintPackages, lintPackages, lintPackagesInDirectory, displayLintResults, hasEslintConfig, hasDeprecatedEslintConfig, getDeprecatedEslintConfigFiles, createEslintConfig, } from '../uieLinting.js';
-vi.mock('../../ui/logger.js');
+import { clearPackageJsonCache } from '../../npm/packageJson.js';
 vi.mock('fs');
 vi.mock('../../dependencyManagement.js', async () => {
     const actual = await vi.importActual('../../dependencyManagement.js');
@@ -23,7 +23,7 @@ const mockExec = vi.fn();
 vi.mocked(util.promisify).mockReturnValue(mockExec);
 describe('lib/linting', () => {
     afterEach(() => {
-        vi.clearAllMocks();
+        clearPackageJsonCache();
     });
     describe('isEslintInstalled', () => {
         it('should return true if eslint is in package.json and node_modules', () => {
@@ -84,9 +84,6 @@ describe('lib/linting', () => {
         });
     });
     describe('areAllLintPackagesInstalled', () => {
-        beforeEach(() => {
-            vi.clearAllMocks();
-        });
         it('should return true if all packages are installed', () => {
             const directory = '/test/project/component1';
             const packageJson = JSON.stringify({
@@ -183,9 +180,6 @@ describe('lib/linting', () => {
         });
     });
     describe('getMissingLintPackages', () => {
-        beforeEach(() => {
-            vi.clearAllMocks();
-        });
         it('should return empty array if all packages are installed with correct versions', () => {
             const directory = '/test/project/component1';
             const packageJson = JSON.stringify({
@@ -442,9 +436,6 @@ describe('lib/linting', () => {
     });
     describe('createEslintConfig', () => {
         const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync');
-        afterEach(() => {
-            vi.clearAllMocks();
-        });
         it('should create eslint.config.mts with template content', () => {
             const directory = '/test/project/component1';
             const result = createEslintConfig(directory);

package/lib/projects/__tests__/upload.test.js

@@ -1,17 +1,38 @@
 import fs from 'fs-extra';
 import os from 'os';
 import path from 'path';
+import archiver from 'archiver';
+import tmp from 'tmp';
 import { vi } from 'vitest';
-import { validateSourceDirectory } from '../upload.js';
+import { validateSourceDirectory, handleProjectUpload } from '../upload.js';
 import { uiLogger } from '../../ui/logger.js';
 import { lib } from '../../../lang/en.js';
 import { isV2Project } from '../platformVersion.js';
 import ProjectValidationError from '../../errors/ProjectValidationError.js';
 import { walk } from '@hubspot/local-dev-lib/fs';
+import { uploadProject } from '@hubspot/local-dev-lib/api/projects';
+import { ensureProjectExists } from '../ensureProjectExists.js';
+import { projectContainsHsMetaFiles } from '@hubspot/project-parsing-lib/projects';
+import { shouldIgnoreFile } from '@hubspot/local-dev-lib/ignoreRules';
+import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
 // Mock dependencies
-vi.mock('../../ui/logger.js');
+vi.mock('../../ui/SpinniesManager');
 vi.mock('../platformVersion.js');
 vi.mock('@hubspot/local-dev-lib/fs');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('../ensureProjectExists.js');
+vi.mock('@hubspot/project-parsing-lib/projects');
+vi.mock('@hubspot/local-dev-lib/ignoreRules');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('archiver');
+vi.mock('tmp');
+vi.mock('fs-extra', async () => {
+    const actual = await vi.importActual('fs-extra');
+    return {
+        ...actual,
+        createWriteStream: vi.fn(),
+    };
+});
 describe('lib/projects/upload', () => {
     describe('validateSourceDirectory', () => {
         let tempDir;
@@ -26,7 +47,8 @@ describe('lib/projects/upload', () => {
                 srcDir: 'src',
                 platformVersion: '2025.2',
             };
-            vi.clearAllMocks();
+            // Mock config to prevent reading actual config file
+            vi.mocked(getConfigAccountIfExists).mockReturnValue(undefined);
         });
         afterEach(() => {
             fs.removeSync(tempDir);
@@ -79,4 +101,83 @@ describe('lib/projects/upload', () => {
             expect(uiLogger.warn).not.toHaveBeenCalled();
         });
     });
+    describe('handleProjectUpload', () => {
+        let tempDir;
+        let projectConfig;
+        let mockWriteStream;
+        let mockArchive;
+        beforeEach(() => {
+            tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'upload-test-'));
+            const srcDir = path.join(tempDir, 'src');
+            fs.mkdirSync(srcDir, { recursive: true });
+            fs.writeFileSync(path.join(srcDir, 'test.js'), 'test content');
+            projectConfig = {
+                name: 'test-project',
+                srcDir: 'src',
+                platformVersion: '2025.2',
+            };
+            // Mock config to prevent reading actual config file
+            vi.mocked(getConfigAccountIfExists).mockReturnValue(undefined);
+            vi.mocked(walk).mockResolvedValue([path.join(srcDir, 'test.js')]);
+            vi.mocked(shouldIgnoreFile).mockReturnValue(false);
+            vi.mocked(projectContainsHsMetaFiles).mockResolvedValue(false);
+            vi.mocked(isV2Project).mockReturnValue(false);
+            vi.mocked(tmp.fileSync).mockReturnValue({
+                name: path.join(tempDir, 'test.zip'),
+                fd: 1,
+                removeCallback: vi.fn(),
+            });
+            // Store close callback so archive.finalize() can trigger it
+            let closeCallback;
+            mockWriteStream = {
+                on: vi.fn((event, callback) => {
+                    if (event === 'close') {
+                        closeCallback = callback;
+                    }
+                }),
+            };
+            vi.spyOn(fs, 'createWriteStream').mockReturnValue(mockWriteStream);
+            mockArchive = {
+                pipe: vi.fn(),
+                directory: vi.fn(),
+                finalize: vi.fn(() => {
+                    // Trigger the close event when finalize is called
+                    if (closeCallback) {
+                        process.nextTick(closeCallback);
+                    }
+                }),
+                pointer: vi.fn().mockReturnValue(100),
+                on: vi.fn(),
+            };
+            vi.mocked(archiver).mockReturnValue(mockArchive);
+        });
+        afterEach(() => {
+            fs.removeSync(tempDir);
+        });
+        it('should upload project files and call callback when project exists', async () => {
+            const accountId = 123;
+            const buildId = 456;
+            const callbackResult = { success: true };
+            const callbackFunc = vi.fn().mockResolvedValue(callbackResult);
+            vi.mocked(ensureProjectExists).mockResolvedValue({
+                projectExists: true,
+            });
+            vi.mocked(uploadProject).mockResolvedValue({
+                data: { buildId },
+            });
+            const uploadPromise = handleProjectUpload({
+                accountId,
+                projectConfig,
+                projectDir: tempDir,
+                callbackFunc,
+                isUploadCommand: true,
+            });
+            // Trigger the close event by calling finalize
+            mockArchive.finalize();
+            const result = await uploadPromise;
+            expect(uploadProject).toHaveBeenCalled();
+            expect(callbackFunc).toHaveBeenCalled();
+            expect(result.result).toEqual(callbackResult);
+        });
+    });
 });

package/lib/projects/add/__tests__/legacyAddComponent.test.js

@@ -10,9 +10,7 @@ import { commands } from '../../../../lang/en.js';
 vi.mock('../../structure');
 vi.mock('../../create/legacy');
 vi.mock('../../../prompts/projectAddPrompt');
-vi.mock('../../../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/github');
-vi.mock('../../../usageTracking.js');
 const mockedFindProjectComponents = vi.mocked(findProjectComponents);
 const mockedGetProjectComponentListFromRepo = vi.mocked(getProjectComponentListFromRepo);
 const mockedProjectAddPrompt = vi.mocked(projectAddPrompt);

package/lib/projects/add/__tests__/v2AddComponent.test.js

@@ -5,7 +5,7 @@ import { createV2App } from '../../create/v2.js';
 import { confirmPrompt } from '../../../prompts/promptUtils.js';
 import { projectAddPromptV2 } from '../../../prompts/projectAddPrompt.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
-import { getProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
+import { getProjectMetadata } from '@hubspot/project-parsing-lib/projects';
 import { trackCommandUsage } from '../../../usageTracking.js';
 import { updateHsMetaFilesWithAutoGeneratedFields } from '../../components.js';
 import { commands } from '../../../../lang/en.js';
@@ -15,10 +15,8 @@ vi.mock('../../create/legacy');
 vi.mock('../../create/v2');
 vi.mock('../../../prompts/projectAddPrompt');
 vi.mock('@hubspot/local-dev-lib/github');
-vi.mock('../../../ui/logger.js');
 vi.mock('../../../ui/SpinniesManager.js');
-vi.mock('@hubspot/project-parsing-lib/src/lib/project');
-vi.mock('../../../usageTracking');
+vi.mock('@hubspot/project-parsing-lib/projects');
 vi.mock('../../components.js');
 const mockedFs = vi.mocked(fs);
 const mockedGetConfigForPlatformVersion = vi.mocked(getConfigForPlatformVersion);