@hubspot/cli 8.1.0 → 8.1.1-experimental.0

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

@@ -1,541 +0,0 @@
-import { vi } from 'vitest';
-// Mock the ui-extensions-dev-server module
-vi.mock('@hubspot/ui-extensions-dev-server', () => {
-    return {
-        DevModeUnifiedInterface: {
-            setup: vi.fn().mockResolvedValue(undefined),
-            start: vi.fn().mockResolvedValue(undefined),
-            fileChange: vi.fn().mockResolvedValue(undefined),
-            cleanup: vi.fn().mockResolvedValue(undefined),
-        },
-    };
-});
-import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { fetchAppMetadataBySourceId, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
-import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import AppDevModeInterface from '../localDev/AppDevModeInterface.js';
-import LocalDevState from '../localDev/LocalDevState.js';
-import LocalDevLogger from '../localDev/LocalDevLogger.js';
-import { installAppAutoPrompt, installAppBrowserPrompt, } from '../../prompts/installAppPrompt.js';
-import { confirmPrompt } from '../../prompts/promptUtils.js';
-import { getOauthAppInstallUrl, getStaticAuthAppInstallUrl, } from '../../app/urls.js';
-import { isDeveloperTestAccount, isSandbox } from '../../accountTypes.js';
-import { logError } from '../../errorHandlers/index.js';
-import { isServerRunningAtUrl } from '../../http.js';
-import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, APP_INSTALLATION_STATES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
-import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
-vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
-vi.mock('@hubspot/local-dev-lib/api/appsDev');
-vi.mock('@hubspot/local-dev-lib/portManager');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../../prompts/installAppPrompt');
-vi.mock('../../prompts/promptUtils');
-vi.mock('../../app/urls');
-vi.mock('../../accountTypes');
-vi.mock('../../errorHandlers/index');
-vi.mock('../localDev/LocalDevState');
-vi.mock('../localDev/LocalDevLogger');
-vi.mock('../../ui/SpinniesManager');
-vi.mock('../../http');
-describe('AppDevModeInterface', () => {
-    let appDevModeInterface;
-    let mockLocalDevState;
-    let mockLocalDevLogger;
-    const mockProjectConfig = {
-        name: 'test-project',
-        srcDir: 'src',
-        platformVersion: '1.0.0',
-    };
-    const mockProjectData = {
-        createdAt: 123,
-        deletedAt: 123,
-        id: 123,
-        isLocked: false,
-        name: 'my-project',
-        portalId: 123,
-        updatedAt: 123,
-    };
-    const mockAppNode = {
-        uid: 'test-app-uid',
-        componentType: 'APPLICATION',
-        config: {
-            name: 'Test App',
-            description: 'Test app description',
-            logo: 'logo.png',
-            auth: {
-                type: APP_AUTH_TYPES.STATIC,
-                requiredScopes: ['test-scope'],
-                optionalScopes: [],
-                conditionallyRequiredScopes: [],
-                redirectUrls: ['http://localhost:3000'],
-            },
-            distribution: APP_DISTRIBUTION_TYPES.PRIVATE,
-        },
-        localDev: {
-            componentRoot: '/test/path',
-            componentConfigPath: '/test/path/config.json',
-            configUpdatedSinceLastUpload: false,
-            removed: false,
-            parsingErrors: [],
-        },
-        componentDeps: {},
-        metaFilePath: '/test/path',
-        files: [],
-    };
-    const mockAppData = {
-        id: 123,
-        clientId: 'test-client-id',
-        name: 'Test App',
-        installationState: APP_INSTALLATION_STATES.NOT_INSTALLED,
-        scopeGroupIds: [1, 2, 3],
-    };
-    const mockPublicApp = {
-        id: 123,
-        clientId: 'test-client-id',
-        name: 'Test App',
-        sourceId: 'test-app-uid',
-        scopeGroupIds: [1, 2, 3],
-    };
-    beforeEach(() => {
-        mockLocalDevState = {
-            targetProjectAccountId: 12345,
-            targetTestingAccountId: 67890,
-            projectConfig: mockProjectConfig,
-            projectDir: '/test/project',
-            projectData: mockProjectData,
-            projectId: 999,
-            env: ENVIRONMENTS.PROD,
-            projectNodes: { [mockAppNode.uid]: mockAppNode },
-            getAppDataByUid: vi.fn(),
-            setAppDataForUid: vi.fn(),
-            addListener: vi.fn(),
-            addUploadWarning: vi.fn(),
-            removeListener: vi.fn(),
-        };
-        mockLocalDevLogger = {};
-        // Mock constructors
-        LocalDevState.mockImplementation(() => mockLocalDevState);
-        LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
-        // Mock external dependencies
-        fetchAppMetadataBySourceId.mockResolvedValue({
-            data: mockPublicApp,
-        });
-        fetchPublicAppProductionInstallCounts.mockResolvedValue({
-            data: { uniquePortalInstallCount: 5 },
-        });
-        fetchAppInstallationData.mockResolvedValue({
-            data: {
-                isInstalledWithScopeGroups: true,
-                previouslyAuthorizedScopeGroups: [],
-            },
-        });
-        getConfigAccountById.mockReturnValue({
-            parentAccountId: 12345,
-        });
-        isDeveloperTestAccount.mockReturnValue(true);
-        isSandbox.mockReturnValue(false);
-        getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
-        getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
-        installAppAutoPrompt.mockResolvedValue(true);
-        installAppBrowserPrompt.mockImplementation(async () => {
-            setTimeout(() => {
-                const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
-                if (addListenerCall) {
-                    const callback = addListenerCall[1];
-                    callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
-                }
-            }, 0);
-            return undefined;
-        });
-        confirmPrompt.mockResolvedValue(true);
-        installStaticAuthAppOnTestAccount.mockResolvedValue(undefined);
-        isServerRunningAtUrl.mockResolvedValue(true);
-        // Mock process.exit
-        vi.spyOn(global.process, 'exit').mockImplementation((code) => {
-            throw new Error(`Process.exit called with code ${code}`);
-        });
-        appDevModeInterface = new AppDevModeInterface({
-            localDevState: mockLocalDevState,
-            localDevLogger: mockLocalDevLogger,
-        });
-    });
-    describe('constructor', () => {
-        it('should initialize with valid state', () => {
-            expect(appDevModeInterface).toBeInstanceOf(AppDevModeInterface);
-            expect(appDevModeInterface.localDevState).toBe(mockLocalDevState);
-            expect(appDevModeInterface.localDevLogger).toBe(mockLocalDevLogger);
-        });
-        it('should exit if targetProjectAccountId is missing', () => {
-            const mockLocalDevStateWithoutAccountId = {
-                ...mockLocalDevState,
-                targetProjectAccountId: null,
-            };
-            expect(() => {
-                new AppDevModeInterface({
-                    localDevState: mockLocalDevStateWithoutAccountId,
-                    localDevLogger: mockLocalDevLogger,
-                });
-            }).toThrow('Process.exit called with code 1');
-        });
-        it('should exit if projectConfig is missing', () => {
-            const mockLocalDevStateWithoutConfig = {
-                ...mockLocalDevState,
-                projectConfig: null,
-            };
-            expect(() => {
-                new AppDevModeInterface({
-                    localDevState: mockLocalDevStateWithoutConfig,
-                    localDevLogger: mockLocalDevLogger,
-                });
-            }).toThrow('Process.exit called with code 1');
-        });
-        it('should exit if projectDir is missing', () => {
-            const mockLocalDevStateWithoutDir = {
-                ...mockLocalDevState,
-                projectDir: null,
-            };
-            expect(() => {
-                new AppDevModeInterface({
-                    localDevState: mockLocalDevStateWithoutDir,
-                    localDevLogger: mockLocalDevLogger,
-                });
-            }).toThrow('Process.exit called with code 1');
-        });
-    });
-    describe('setup()', () => {
-        beforeEach(() => {
-            mockLocalDevState.getAppDataByUid.mockReturnValue(mockAppData);
-        });
-        it('should return early if no app node exists', async () => {
-            mockLocalDevState.projectNodes = {};
-            await appDevModeInterface.setup();
-            expect(fetchAppMetadataBySourceId).not.toHaveBeenCalled();
-        });
-        it('should setup successfully with private app', async () => {
-            await appDevModeInterface.setup();
-            expect(fetchAppMetadataBySourceId).toHaveBeenCalledWith(123, 'test-app-uid', 12345);
-            expect(fetchPublicAppProductionInstallCounts).toHaveBeenCalledWith(123, 12345);
-            expect(fetchAppInstallationData).toHaveBeenCalledWith(67890, 999, 'test-app-uid', ['test-scope'], []);
-        });
-        it('should show marketplace warning for marketplace apps', async () => {
-            const marketplaceAppNode = {
-                ...mockAppNode,
-                config: {
-                    ...mockAppNode.config,
-                    distribution: APP_DISTRIBUTION_TYPES.MARKETPLACE,
-                },
-            };
-            mockLocalDevState.projectNodes = {
-                [marketplaceAppNode.uid]: marketplaceAppNode,
-            };
-            await appDevModeInterface.setup();
-            expect(confirmPrompt).toHaveBeenCalled();
-            expect(mockLocalDevState.addUploadWarning).toHaveBeenCalled();
-        });
-        it('should exit if user declines marketplace warning', async () => {
-            const marketplaceAppNode = {
-                ...mockAppNode,
-                config: {
-                    ...mockAppNode.config,
-                    distribution: APP_DISTRIBUTION_TYPES.MARKETPLACE,
-                },
-            };
-            mockLocalDevState.projectNodes = {
-                [marketplaceAppNode.uid]: marketplaceAppNode,
-            };
-            // Set up conditions to trigger marketplace warning
-            fetchPublicAppProductionInstallCounts.mockResolvedValue({
-                data: { uniquePortalInstallCount: 5 },
-            });
-            mockLocalDevState.getAppDataByUid.mockReturnValue(mockAppData);
-            confirmPrompt.mockResolvedValue(false);
-            // Create a new instance to trigger the exit during setup
-            const newAppDevModeInterface = new AppDevModeInterface({
-                localDevState: mockLocalDevState,
-                localDevLogger: mockLocalDevLogger,
-            });
-            // process.exit throws in tests, so we need to catch the error
-            try {
-                await newAppDevModeInterface.setup();
-            }
-            catch {
-                // Expected - process.exit throws in tests
-            }
-            expect(process.exit).toHaveBeenCalledWith(0);
-        });
-        it('should auto-install static auth app on test account', async () => {
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            await appDevModeInterface.setup();
-            expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(123, 67890, [1, 2, 3]);
-        });
-        it('should open browser for OAuth app installation', async () => {
-            const oauthAppNode = {
-                ...mockAppNode,
-                config: {
-                    ...mockAppNode.config,
-                    auth: {
-                        ...mockAppNode.config.auth,
-                        type: APP_AUTH_TYPES.OAUTH,
-                    },
-                },
-            };
-            mockLocalDevState.projectNodes = { [oauthAppNode.uid]: oauthAppNode };
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            await appDevModeInterface.setup();
-            expect(getOauthAppInstallUrl).toHaveBeenCalledWith({
-                targetAccountId: 67890,
-                env: ENVIRONMENTS.PROD,
-                clientId: 'test-client-id',
-                scopes: ['test-scope'],
-                redirectUrls: ['http://localhost:3000'],
-            });
-            expect(installAppBrowserPrompt).toHaveBeenCalled();
-        });
-        it('should handle app reinstallation', async () => {
-            // Set up conditions for non-automatic installation
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: ['old-scope'],
-                },
-            });
-            // Make it not automatically installable by making it not a test account
-            isDeveloperTestAccount.mockReturnValue(false);
-            await appDevModeInterface.setup();
-            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true);
-        });
-        it('should handle errors during setup', async () => {
-            const error = new Error('Setup failed');
-            fetchAppMetadataBySourceId.mockRejectedValue(error);
-            // process.exit throws in tests, so we need to catch the error
-            try {
-                await appDevModeInterface.setup();
-            }
-            catch {
-                // Expected - process.exit throws in tests
-            }
-            expect(logError).toHaveBeenCalledWith(error);
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-        it('should exit if user declines auto-install', async () => {
-            // Set up conditions for automatic installation
-            getConfigAccountById.mockReturnValue({
-                parentAccountId: 12345, // matches targetProjectAccountId
-            });
-            isDeveloperTestAccount.mockReturnValue(true);
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            installAppAutoPrompt.mockResolvedValue(false);
-            // Create a new instance to trigger the exit during setup
-            const newAppDevModeInterface = new AppDevModeInterface({
-                localDevState: mockLocalDevState,
-                localDevLogger: mockLocalDevLogger,
-            });
-            // process.exit throws in tests, so we need to catch the error
-            try {
-                await newAppDevModeInterface.setup();
-            }
-            catch {
-                // Expected - process.exit throws in tests
-            }
-            expect(process.exit).toHaveBeenCalledWith(0);
-        });
-        it('should fallback to browser install if auto-install fails', async () => {
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            installStaticAuthAppOnTestAccount.mockRejectedValue(new Error('Install failed'));
-            await appDevModeInterface.setup();
-            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', false);
-        });
-    });
-    describe('start()', () => {
-        it('should add state listeners', async () => {
-            await appDevModeInterface.start();
-            expect(mockLocalDevState.addListener).toHaveBeenCalledWith('projectNodes', 
-            // @ts-expect-error access private method for testing
-            appDevModeInterface.onChangeProjectNodes);
-        });
-    });
-    describe('cleanup()', () => {
-        it('should remove state listeners', async () => {
-            await appDevModeInterface.cleanup();
-            expect(mockLocalDevState.removeListener).toHaveBeenCalledWith('devServerMessage', 
-            // @ts-expect-error access private method for testing
-            appDevModeInterface.onDevServerMessage);
-            expect(mockLocalDevState.removeListener).toHaveBeenCalledWith('projectNodes', 
-            // @ts-expect-error
-            appDevModeInterface.onChangeProjectNodes);
-        });
-    });
-    describe('isAutomaticallyInstallable()', () => {
-        it('should return true for static auth app on test account with correct parent', () => {
-            // This is testing private method behavior through setup()
-            expect(appDevModeInterface).toBeDefined();
-        });
-        it('should return false if target account config is missing', async () => {
-            // Reset mocks to ensure clean state
-            // Set up basic mocks
-            fetchAppMetadataBySourceId.mockResolvedValue({
-                data: mockPublicApp,
-            });
-            fetchPublicAppProductionInstallCounts.mockResolvedValue({
-                data: { uniquePortalInstallCount: 5 },
-            });
-            getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
-            getConfigAccountById.mockReturnValue({
-                parentAccountId: 12345,
-            });
-            isDeveloperTestAccount.mockReturnValue(true);
-            isSandbox.mockReturnValue(false);
-            installAppAutoPrompt.mockResolvedValue(true);
-            confirmPrompt.mockResolvedValue(true);
-            installStaticAuthAppOnTestAccount.mockResolvedValue(undefined);
-            isServerRunningAtUrl.mockResolvedValue(true);
-            installAppBrowserPrompt.mockImplementation(async () => {
-                const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
-                if (addListenerCall) {
-                    const callback = addListenerCall[1];
-                    callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
-                }
-                return undefined;
-            });
-            // Reset the mock LocalDevState
-            mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
-            mockLocalDevState.setAppDataForUid = vi.fn();
-            mockLocalDevState.addListener = vi.fn();
-            // Target account config is missing - make it not a test account so isAutomaticallyInstallable returns false
-            isDeveloperTestAccount.mockReturnValue(false);
-            // App is not installed
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            // Create a new instance to avoid interference from previous test setup
-            const newAppDevModeInterface = new AppDevModeInterface({
-                localDevState: mockLocalDevState,
-                localDevLogger: mockLocalDevLogger,
-            });
-            // Remove the spy to see if that's causing the timeout
-            await newAppDevModeInterface.setup();
-            expect(installAppBrowserPrompt).toHaveBeenCalled();
-        });
-        it('should return false for OAuth app', async () => {
-            // Reset mocks to ensure clean state
-            // Set up basic mocks
-            fetchAppMetadataBySourceId.mockResolvedValue({
-                data: mockPublicApp,
-            });
-            fetchPublicAppProductionInstallCounts.mockResolvedValue({
-                data: { uniquePortalInstallCount: 5 },
-            });
-            getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
-            installAppBrowserPrompt.mockImplementation(async () => {
-                setTimeout(() => {
-                    const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
-                    if (addListenerCall) {
-                        const callback = addListenerCall[1];
-                        callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
-                    }
-                }, 0);
-                return undefined;
-            });
-            // Reset the mock LocalDevState
-            mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
-            mockLocalDevState.setAppDataForUid = vi.fn();
-            mockLocalDevState.addListener = vi.fn();
-            const oauthAppNode = {
-                ...mockAppNode,
-                config: {
-                    ...mockAppNode.config,
-                    auth: {
-                        ...mockAppNode.config.auth,
-                        type: APP_AUTH_TYPES.OAUTH,
-                    },
-                },
-            };
-            mockLocalDevState.projectNodes = { [oauthAppNode.uid]: oauthAppNode };
-            // App is not installed
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            // Create a new instance to avoid interference from previous test setup
-            const newAppDevModeInterface = new AppDevModeInterface({
-                localDevState: mockLocalDevState,
-                localDevLogger: mockLocalDevLogger,
-            });
-            await newAppDevModeInterface.setup();
-            expect(installAppBrowserPrompt).toHaveBeenCalled();
-        });
-    });
-    describe('websocket server message handling', () => {
-        it('should check app installation when websocket server connects', async () => {
-            // Reset mocks to ensure clean state
-            // Set up basic mocks
-            fetchAppMetadataBySourceId.mockResolvedValue({
-                data: mockPublicApp,
-            });
-            fetchPublicAppProductionInstallCounts.mockResolvedValue({
-                data: { uniquePortalInstallCount: 5 },
-            });
-            getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
-            installAppBrowserPrompt.mockImplementation(async () => {
-                setTimeout(() => {
-                    const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
-                    if (addListenerCall) {
-                        const callback = addListenerCall[1];
-                        callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
-                    }
-                }, 0);
-                return undefined;
-            });
-            // Reset the mock LocalDevState
-            mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
-            mockLocalDevState.setAppDataForUid = vi.fn();
-            mockLocalDevState.addListener = vi.fn();
-            // App is not installed so fetchAppInstallationData will be called
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            // Create a new instance to avoid interference from previous test setup
-            const newAppDevModeInterface = new AppDevModeInterface({
-                localDevState: mockLocalDevState,
-                localDevLogger: mockLocalDevLogger,
-            });
-            await newAppDevModeInterface.setup();
-            // Simulate websocket server connection
-            const addListenerCall = mockLocalDevState.addListener.mock
-                .calls[0];
-            const [eventType, callback] = addListenerCall;
-            expect(eventType).toBe('devServerMessage');
-            // Call the callback with websocket connection message
-            await callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
-            expect(fetchAppInstallationData).toHaveBeenCalledTimes(2); // Once in setup, once in listener
-        });
-    });
-});

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

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