@hubspot/cli 8.0.10-experimental.7 → 8.0.11-experimental.0

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

@@ -0,0 +1,183 @@
+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, 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/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;
+        let srcDir;
+        let projectConfig;
+        beforeEach(() => {
+            tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'upload-test-'));
+            srcDir = path.join(tempDir, 'src');
+            fs.mkdirSync(srcDir, { recursive: true });
+            projectConfig = {
+                name: 'test-project',
+                srcDir: 'src',
+                platformVersion: '2025.2',
+            };
+            // Mock config to prevent reading actual config file
+            vi.mocked(getConfigAccountIfExists).mockReturnValue(undefined);
+        });
+        afterEach(() => {
+            fs.removeSync(tempDir);
+        });
+        it('should throw ProjectValidationError when source directory is empty', async () => {
+            vi.mocked(walk).mockResolvedValue([]);
+            await expect(validateSourceDirectory(srcDir, projectConfig, tempDir)).rejects.toThrow(ProjectValidationError);
+            expect(walk).toHaveBeenCalledWith(srcDir, ['node_modules']);
+        });
+        it('should warn about legacy files in V2 projects', async () => {
+            vi.mocked(isV2Project).mockReturnValue(true);
+            const legacyFilePath = path.join(srcDir, 'app', 'serverless.json');
+            vi.mocked(walk).mockResolvedValue([legacyFilePath]);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app/serverless.json', '2025.2'));
+        });
+        it('should warn about multiple legacy files', async () => {
+            vi.mocked(isV2Project).mockReturnValue(true);
+            const filePaths = [
+                path.join(srcDir, 'app1', 'serverless.json'),
+                path.join(srcDir, 'app2', 'app.json'),
+                path.join(srcDir, 'app3', 'public-app.json'),
+            ];
+            vi.mocked(walk).mockResolvedValue(filePaths);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).toHaveBeenCalledTimes(3);
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app1/serverless.json', '2025.2'));
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app2/app.json', '2025.2'));
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app3/public-app.json', '2025.2'));
+        });
+        it('should not warn about non-legacy files', async () => {
+            vi.mocked(isV2Project).mockReturnValue(true);
+            const filePaths = [
+                path.join(srcDir, 'component.js'),
+                path.join(srcDir, 'config.json'),
+            ];
+            vi.mocked(walk).mockResolvedValue(filePaths);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).not.toHaveBeenCalled();
+        });
+        it('should not warn about legacy files in non-V2 projects', async () => {
+            vi.mocked(isV2Project).mockReturnValue(false);
+            projectConfig.platformVersion = '2025.1';
+            const filePaths = [
+                path.join(srcDir, 'app', 'serverless.json'),
+                path.join(srcDir, 'app', 'app.json'),
+            ];
+            vi.mocked(walk).mockResolvedValue(filePaths);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            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.d.ts

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

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

@@ -0,0 +1,245 @@
+import { legacyAddComponent } from '../legacyAddComponent.js';
+import { findProjectComponents } from '../../structure.js';
+import { getProjectComponentListFromRepo } from '../../create/legacy.js';
+import { projectAddPrompt } from '../../../prompts/projectAddPrompt.js';
+import { uiLogger } from '../../../ui/logger.js';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { trackCommandUsage } from '../../../usageTracking.js';
+import { ComponentTypes, } from '../../../../types/Projects.js';
+import { commands } from '../../../../lang/en.js';
+vi.mock('../../structure');
+vi.mock('../../create/legacy');
+vi.mock('../../../prompts/projectAddPrompt');
+vi.mock('@hubspot/local-dev-lib/github');
+const mockedFindProjectComponents = vi.mocked(findProjectComponents);
+const mockedGetProjectComponentListFromRepo = vi.mocked(getProjectComponentListFromRepo);
+const mockedProjectAddPrompt = vi.mocked(projectAddPrompt);
+const mockedUiLogger = vi.mocked(uiLogger);
+const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
+describe('lib/projects/add/legacyAddComponent', () => {
+    const mockProjectConfig = {
+        name: 'test-project',
+        srcDir: 'src',
+        platformVersion: 'v1',
+    };
+    const accountId = 1234567890;
+    const mockArgs = { name: 'test-component', type: 'module' };
+    const projectDir = '/path/to/project';
+    beforeEach(() => {
+        vi.resetAllMocks();
+        mockedTrackCommandUsage.mockResolvedValue();
+    });
+    describe('legacyAddComponent()', () => {
+        it('successfully adds a component to a project without public apps', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            const mockComponentList = [
+                { label: 'Test Component', path: 'test-component', type: 'module' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-component',
+                componentTemplate: {
+                    label: 'Test Component',
+                    path: 'template-path',
+                    type: 'module',
+                },
+            };
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId);
+            expect(mockedFindProjectComponents).toHaveBeenCalledWith(projectDir);
+            expect(mockedGetProjectComponentListFromRepo).toHaveBeenCalledWith('v1');
+            expect(mockedProjectAddPrompt).toHaveBeenCalledWith(mockComponentList, mockArgs);
+            expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), '/path/to/project/src/new-component', expect.objectContaining({
+                sourceDir: 'template-path',
+                branch: 'main',
+                hideLogs: true,
+            }));
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module',
+            }, accountId);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(commands.project.add.creatingComponent('test-project'));
+            expect(mockedUiLogger.success).toHaveBeenCalledWith(commands.project.add.success('test-project'));
+        });
+        it('throws an error when project contains a public app', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PublicApp,
+                    config: {
+                        name: 'public-app',
+                        uid: '',
+                        description: '',
+                        allowedUrls: [],
+                        auth: {
+                            redirectUrls: [],
+                            requiredScopes: [],
+                            optionalScopes: [],
+                            conditionallyRequiredScopes: [],
+                        },
+                        support: {
+                            supportEmail: '',
+                            documentationUrl: '',
+                            supportUrl: '',
+                            supportPhone: '',
+                        },
+                    },
+                    runnable: true,
+                    path: '/path/to/public-app',
+                },
+            ];
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.projectContainsPublicApp);
+            expect(mockedGetProjectComponentListFromRepo).not.toHaveBeenCalled();
+            expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('continues when findProjectComponents throws an error', async () => {
+            const mockComponentList = [
+                { label: 'Test Component', path: 'test-component', type: 'module' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-component',
+                componentTemplate: {
+                    label: 'Test Component',
+                    path: 'template-path',
+                    type: 'module',
+                },
+            };
+            mockedFindProjectComponents.mockRejectedValue(new Error('Find components error'));
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId);
+            expect(mockedGetProjectComponentListFromRepo).toHaveBeenCalledWith('v1');
+            expect(mockedProjectAddPrompt).toHaveBeenCalledWith(mockComponentList, mockArgs);
+            expect(mockedCloneGithubRepo).toHaveBeenCalled();
+        });
+        it('throws an error when component list is empty', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue([]);
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('throws an error when component list is null', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            // @ts-expect-error Breaking stuff on purpose
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(null);
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('throws an error when cloning fails', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            const mockComponentList = [
+                { label: 'Test Component', path: 'test-component', type: 'module' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-component',
+                componentTemplate: {
+                    label: 'Test Component',
+                    path: 'template-path',
+                    type: 'module',
+                },
+            };
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+            expect(mockedCloneGithubRepo).toHaveBeenCalled();
+            expect(mockedUiLogger.success).not.toHaveBeenCalled();
+        });
+        it('calls trackCommandUsage with correct component type', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            const mockComponentList = [
+                { label: 'Card Component', path: 'card-component', type: 'card' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-card',
+                componentTemplate: {
+                    label: 'Card Component',
+                    path: 'card-template-path',
+                    type: 'card',
+                },
+            };
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'card',
+            }, accountId);
+        });
+    });
+});

package/lib/projects/add/__tests__/v2AddComponent.test.d.ts

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