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

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

@@ -0,0 +1,328 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import chalk from 'chalk';
+import { pollBuildStatus, pollDeployStatus, } from '../pollProjectBuildAndDeploy.js';
+import { getBuildStatus, getBuildStructure, getDeployStatus, getDeployStructure, } from '@hubspot/local-dev-lib/api/projects';
+import SpinniesManager from '../../ui/SpinniesManager.js';
+import { uiLogger } from '../../ui/logger.js';
+// Mock external dependencies
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../ui/SpinniesManager.js');
+vi.mock('../../ui/index.js', async (importOriginal) => {
+    const actual = (await importOriginal());
+    return {
+        ...actual,
+        uiLine: vi.fn(),
+        uiLink: vi.fn((text) => text),
+        uiAccountDescription: vi.fn((accountId) => `account ${accountId}`),
+    };
+});
+vi.mock('../../errorHandlers/index.js');
+const mockGetBuildStatus = vi.mocked(getBuildStatus);
+const mockGetBuildStructure = vi.mocked(getBuildStructure);
+const mockGetDeployStatus = vi.mocked(getDeployStatus);
+const mockGetDeployStructure = vi.mocked(getDeployStructure);
+describe('lib/projects/pollProjectBuildAndDeploy', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.useFakeTimers();
+        // Mock SpinniesManager methods
+        vi.mocked(SpinniesManager.init).mockImplementation(() => { });
+        vi.mocked(SpinniesManager.add).mockImplementation(() => { });
+        vi.mocked(SpinniesManager.update).mockImplementation(() => { });
+        vi.mocked(SpinniesManager.succeed).mockImplementation(() => { });
+        vi.mocked(SpinniesManager.fail).mockImplementation(() => { });
+        vi.mocked(SpinniesManager.remove).mockImplementation(() => { });
+        vi.mocked(SpinniesManager.pick).mockReturnValue(undefined);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('pollBuildStatus', () => {
+        it('logs correct INITIALIZE message when build starts', async () => {
+            const mockBuild = {
+                buildId: 123,
+                status: 'SUCCESS',
+                subbuildStatuses: [],
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 12345,
+                projectName: 'test-project',
+                // @ts-expect-error - Testing with minimal Build object, activitySource not relevant for this test
+                activitySource: undefined,
+                // @ts-expect-error - Testing with minimal Build object, createdAt not relevant for this test
+                createdAt: undefined,
+                // @ts-expect-error - Testing with minimal Build object, deployableState not relevant for this test
+                deployableState: undefined,
+                // @ts-expect-error - Testing successful build without deploy locator
+                deployStatusTaskLocator: undefined,
+                source: 'HUBSPOT_USER',
+                isAutoDeployEnabled: false,
+                autoDeployId: 0,
+            };
+            mockGetBuildStatus.mockResolvedValue({ data: mockBuild });
+            mockGetBuildStructure.mockResolvedValue({
+                data: { topLevelComponentsWithChildren: {} },
+            });
+            pollBuildStatus(12345, 'test-project', 123, null, true);
+            // Wait for initial async setup to complete
+            await vi.waitFor(() => {
+                expect(SpinniesManager.update).toHaveBeenCalled();
+            });
+            // Check that SpinniesManager.update was called with correct INITIALIZE message
+            expect(SpinniesManager.update).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                text: expect.stringContaining(`Building ${chalk.bold('test-project')} #123`),
+            }));
+            // Complete the polling
+            vi.mocked(SpinniesManager.hasActiveSpinners).mockReturnValue(true);
+            await vi.runOnlyPendingTimersAsync();
+        });
+        it('logs correct SUCCESS message when build completes', async () => {
+            const mockBuild = {
+                buildId: 456,
+                status: 'SUCCESS',
+                subbuildStatuses: [],
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 12345,
+                projectName: 'my-project',
+                // @ts-expect-error - Testing with minimal Build object, non-essential fields omitted
+                activitySource: undefined,
+                // @ts-expect-error - Testing with minimal Build object, non-essential fields omitted
+                createdAt: undefined,
+                // @ts-expect-error - Testing with minimal Build object, non-essential fields omitted
+                deployableState: undefined,
+                // @ts-expect-error - Testing successful build without deploy locator
+                deployStatusTaskLocator: undefined,
+                source: 'HUBSPOT_USER',
+                isAutoDeployEnabled: false,
+                autoDeployId: 0,
+            };
+            mockGetBuildStatus.mockResolvedValue({ data: mockBuild });
+            mockGetBuildStructure.mockResolvedValue({
+                data: { topLevelComponentsWithChildren: {} },
+            });
+            vi.mocked(SpinniesManager.hasActiveSpinners).mockReturnValue(true);
+            pollBuildStatus(12345, 'my-project', 456, null, true);
+            // Wait for polling to complete
+            vi.mocked(SpinniesManager.hasActiveSpinners).mockReturnValue(true);
+            await vi.runOnlyPendingTimersAsync();
+            // Check that SpinniesManager.succeed was called with correct SUCCESS message
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                text: `Built ${chalk.bold('my-project')} #456`,
+            }));
+        });
+        it('logs correct FAIL message when build fails', async () => {
+            const mockBuild = {
+                buildId: 789,
+                status: 'FAILURE',
+                subbuildStatuses: [],
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 12345,
+                projectName: 'failed-project',
+                // @ts-expect-error - Testing with minimal Build object, non-essential fields omitted
+                activitySource: undefined,
+                // @ts-expect-error - Testing with minimal Build object, non-essential fields omitted
+                createdAt: undefined,
+                // @ts-expect-error - Testing with minimal Build object, non-essential fields omitted
+                deployableState: undefined,
+                // @ts-expect-error - Testing failed build without deploy locator
+                deployStatusTaskLocator: undefined,
+                source: 'HUBSPOT_USER',
+                isAutoDeployEnabled: false,
+                autoDeployId: 0,
+            };
+            mockGetBuildStatus.mockResolvedValue({ data: mockBuild });
+            mockGetBuildStructure.mockResolvedValue({
+                data: { topLevelComponentsWithChildren: {} },
+            });
+            vi.mocked(SpinniesManager.hasActiveSpinners).mockReturnValue(true);
+            pollBuildStatus(12345, 'failed-project', 789, null, true);
+            // Wait for polling to complete
+            await vi.runOnlyPendingTimersAsync();
+            // Check that SpinniesManager.fail was called with correct FAIL message
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                text: `Failed to build ${chalk.bold('failed-project')} #789`,
+            }));
+        });
+        it('logs correct SUBTASK_FAIL message with proper parameter order', async () => {
+            const mockBuild = {
+                buildId: 999,
+                status: 'FAILURE',
+                subbuildStatuses: [
+                    {
+                        id: 'sub-1',
+                        buildName: 'api-component',
+                        buildType: 'APP',
+                        status: 'FAILURE',
+                        visible: true,
+                        errorMessage: 'Build failed',
+                        standardError: null,
+                        finishedAt: '2023-01-01T00:05:00Z',
+                        rootPath: '/src',
+                        startedAt: '2023-01-01T00:01:00Z',
+                    },
+                ],
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 12345,
+                projectName: 'test-project',
+                // @ts-expect-error - Testing with minimal Build object, non-essential fields omitted
+                activitySource: undefined,
+                // @ts-expect-error - Testing with minimal Build object, non-essential fields omitted
+                createdAt: undefined,
+                // @ts-expect-error - Testing with minimal Build object, non-essential fields omitted
+                deployableState: undefined,
+                // @ts-expect-error - Testing failed build without deploy locator
+                deployStatusTaskLocator: undefined,
+                source: 'HUBSPOT_USER',
+                isAutoDeployEnabled: false,
+                autoDeployId: 0,
+            };
+            mockGetBuildStatus.mockResolvedValue({ data: mockBuild });
+            mockGetBuildStructure.mockResolvedValue({
+                data: { topLevelComponentsWithChildren: { 'sub-1': [] } },
+            });
+            vi.mocked(SpinniesManager.hasActiveSpinners).mockReturnValue(true);
+            pollBuildStatus(12345, 'test-project', 999, null, false);
+            // Wait for polling to complete
+            await vi.runOnlyPendingTimersAsync();
+            // Verify SUBTASK_FAIL message has correct parameter order (name first, buildId second)
+            // The message should be: "Build #999 failed because there was a problem\nbuilding api-component"
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('Build #999 failed because there was a problem'));
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining(`building ${chalk.bold('api-component')}`));
+        });
+    });
+    describe('pollDeployStatus', () => {
+        it('logs correct INITIALIZE message when deploy starts', async () => {
+            const mockDeploy = {
+                deployId: 123,
+                buildId: 100,
+                status: 'SUCCESS',
+                subdeployStatuses: [],
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 12345,
+                projectName: 'test-project',
+                userId: 456,
+                source: 'HUBSPOT_USER',
+            };
+            mockGetDeployStatus.mockResolvedValue({ data: mockDeploy });
+            mockGetDeployStructure.mockResolvedValue({
+                data: { topLevelComponentsWithChildren: {} },
+            });
+            pollDeployStatus(12345, 'test-project', 123, 100, true);
+            // Wait for initial async setup to complete
+            await vi.waitFor(() => {
+                expect(SpinniesManager.update).toHaveBeenCalled();
+            });
+            // Check that SpinniesManager.update was called with correct INITIALIZE message
+            expect(SpinniesManager.update).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                text: expect.stringContaining(`Deploying build #100 in ${chalk.bold('test-project')}`),
+            }));
+            // Complete the polling
+            vi.mocked(SpinniesManager.hasActiveSpinners).mockReturnValue(true);
+            await vi.runOnlyPendingTimersAsync();
+        });
+        it('logs correct SUCCESS message when deploy completes', async () => {
+            const mockDeploy = {
+                deployId: 456,
+                buildId: 200,
+                status: 'SUCCESS',
+                subdeployStatuses: [],
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 12345,
+                projectName: 'my-project',
+                userId: 456,
+                source: 'HUBSPOT_USER',
+            };
+            mockGetDeployStatus.mockResolvedValue({ data: mockDeploy });
+            mockGetDeployStructure.mockResolvedValue({
+                data: { topLevelComponentsWithChildren: {} },
+            });
+            vi.mocked(SpinniesManager.hasActiveSpinners).mockReturnValue(true);
+            pollDeployStatus(12345, 'my-project', 456, 200, true);
+            // Wait for polling to complete
+            await vi.runOnlyPendingTimersAsync();
+            // Check that SpinniesManager.succeed was called with correct SUCCESS message
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                text: `Deployed build #200 in ${chalk.bold('my-project')}`,
+            }));
+        });
+        it('logs correct FAIL message when deploy fails', async () => {
+            const mockDeploy = {
+                deployId: 789,
+                buildId: 300,
+                status: 'FAILURE',
+                subdeployStatuses: [],
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 12345,
+                projectName: 'failed-project',
+                userId: 456,
+                source: 'HUBSPOT_USER',
+            };
+            mockGetDeployStatus.mockResolvedValue({ data: mockDeploy });
+            mockGetDeployStructure.mockResolvedValue({
+                data: { topLevelComponentsWithChildren: {} },
+            });
+            vi.mocked(SpinniesManager.hasActiveSpinners).mockReturnValue(true);
+            pollDeployStatus(12345, 'failed-project', 789, 300, true);
+            // Wait for polling to complete
+            await vi.runOnlyPendingTimersAsync();
+            // Check that SpinniesManager.fail was called with correct FAIL message
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                text: `Failed to deploy build #300 in ${chalk.bold('failed-project')}`,
+            }));
+        });
+        it('logs correct SUBTASK_FAIL message with proper parameter order', async () => {
+            const mockDeploy = {
+                deployId: 888,
+                buildId: 999,
+                status: 'FAILURE',
+                subdeployStatuses: [
+                    {
+                        id: 'sub-1',
+                        deployName: 'api-component',
+                        deployType: 'APP',
+                        status: 'FAILURE',
+                        visible: true,
+                        errorMessage: 'Deploy failed',
+                        standardError: null,
+                        action: 'DEPLOY',
+                        finishedAt: '2023-01-01T00:05:00Z',
+                        startedAt: '2023-01-01T00:01:00Z',
+                    },
+                ],
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 12345,
+                projectName: 'test-project',
+                userId: 456,
+                source: 'HUBSPOT_USER',
+            };
+            mockGetDeployStatus.mockResolvedValue({ data: mockDeploy });
+            mockGetDeployStructure.mockResolvedValue({
+                data: { topLevelComponentsWithChildren: { 'sub-1': [] } },
+            });
+            vi.mocked(SpinniesManager.hasActiveSpinners).mockReturnValue(true);
+            pollDeployStatus(12345, 'test-project', 888, 999, false);
+            // Wait for polling to complete
+            await vi.runOnlyPendingTimersAsync();
+            // Verify SUBTASK_FAIL message has correct parameter order (name first, deployedBuildId second)
+            // The message should be: "Deploy for build #999 failed because there was a\nproblem deploying api-component"
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('Deploy for build #999 failed because there was a'));
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining(`deploying ${chalk.bold('api-component')}`));
+        });
+    });
+});

package/lib/projects/__tests__/projectInfo.test.d.ts

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

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

@@ -0,0 +1,114 @@
+import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
+import { getProjectInfo } from '../projectInfo.js';
+import { getProjectDetailUrl } from '../urls.js';
+vi.mock('@hubspot/local-dev-lib/api/appsDev');
+vi.mock('../urls');
+vi.mock('../../errorHandlers/index.js');
+const mockedFetchAppMetadataBySourceId = vi.mocked(fetchAppMetadataBySourceId);
+const mockedGetProjectDetailUrl = vi.mocked(getProjectDetailUrl);
+const mockProject = {
+    id: 42,
+    name: 'my-project',
+    deployedBuild: {
+        buildId: 7,
+        isAutoDeployEnabled: true,
+        subbuildStatuses: [
+            {
+                buildName: 'my-app',
+                buildType: 'APPLICATION',
+            },
+            {
+                buildName: 'card-one',
+                buildType: 'APP_CARD',
+                userDefinedId: 'card-one-uid',
+            },
+            {
+                buildName: 'func-one',
+                buildType: 'SERVERLESS_FUNCTION',
+            },
+        ],
+    },
+};
+const mockAppMetadata = {
+    name: 'My App',
+    id: 99,
+    authType: 'OAUTH',
+    distributionType: 'PRIVATE',
+};
+describe('lib/projects/projectInfo', () => {
+    beforeEach(() => {
+        mockedGetProjectDetailUrl.mockReturnValue('https://app.hubspot.com/project/my-project');
+        mockedFetchAppMetadataBySourceId.mockResolvedValue({
+            data: mockAppMetadata,
+        });
+    });
+    describe('getProjectInfo', () => {
+        it('should return project metadata', async () => {
+            const result = await getProjectInfo(mockProject, '2025.2', 100);
+            expect(result.projectName).toEqual('my-project');
+            expect(result.platformVersion).toEqual('2025.2');
+            expect(result.projectId).toEqual(42);
+            expect(result.deployedBuildId).toEqual(7);
+            expect(result.autoDeployEnabled).toEqual(true);
+        });
+        it('should include projectUrl when available', async () => {
+            const result = await getProjectInfo(mockProject, '2025.2', 100);
+            expect(result.projectUrl).toEqual('https://app.hubspot.com/project/my-project');
+        });
+        it('should not include projectUrl when getProjectDetailUrl returns undefined', async () => {
+            mockedGetProjectDetailUrl.mockReturnValue(undefined);
+            const result = await getProjectInfo(mockProject, '2025.2', 100);
+            expect(result.projectUrl).toBeUndefined();
+        });
+        it('should fetch and include app metadata for APPLICATION subbuild', async () => {
+            const result = await getProjectInfo(mockProject, '2025.2', 100);
+            expect(mockedFetchAppMetadataBySourceId).toHaveBeenCalledWith(42, 'my-app', 100);
+            expect(result.app).toEqual({
+                name: 'My App',
+                id: 99,
+                uid: 'my-app',
+                authType: 'OAUTH',
+                distributionType: 'PRIVATE',
+            });
+        });
+        it('should gracefully handle app metadata fetch failure', async () => {
+            mockedFetchAppMetadataBySourceId.mockRejectedValue(new Error('App fetch failed'));
+            const result = await getProjectInfo(mockProject, '2025.2', 100);
+            expect(result.app).toBeUndefined();
+        });
+        it('should not fetch app metadata when no APPLICATION subbuild exists', async () => {
+            const projectWithoutApp = {
+                ...mockProject,
+                deployedBuild: {
+                    ...mockProject.deployedBuild,
+                    subbuildStatuses: [
+                        {
+                            buildName: 'card-one',
+                            buildType: 'APP_CARD',
+                            userDefinedId: 'card-one-uid',
+                        },
+                    ],
+                },
+            };
+            const result = await getProjectInfo(projectWithoutApp, '2025.2', 100);
+            expect(mockedFetchAppMetadataBySourceId).not.toHaveBeenCalled();
+            expect(result.app).toBeUndefined();
+        });
+        it('should use userDefinedId for component uid when available', async () => {
+            const result = await getProjectInfo(mockProject, '2025.2', 100);
+            const cardComponent = result.components.find(c => c.type === 'APP_CARD');
+            expect(cardComponent?.uid).toEqual('card-one-uid');
+        });
+        it('should fall back to buildName when userDefinedId is not present', async () => {
+            const result = await getProjectInfo(mockProject, '2025.2', 100);
+            const funcComponent = result.components.find(c => c.type === 'SERVERLESS_FUNCTION');
+            expect(funcComponent?.uid).toEqual('func-one');
+        });
+        it('should exclude APPLICATION subbuild from components list', async () => {
+            const result = await getProjectInfo(mockProject, '2025.2', 100);
+            const appComponent = result.components.find(c => c.type === 'APPLICATION');
+            expect(appComponent).toBeUndefined();
+            expect(result.components).toHaveLength(2);
+        });
+    });
+});

package/lib/projects/__tests__/projectProfiles.test.d.ts

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