@hubspot/cli 8.1.0 → 8.1.1-experimental.0

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

@@ -1,183 +0,0 @@
-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

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

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

@@ -1,245 +0,0 @@
-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

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