@hubspot/cli 7.7.19-experimental.3 → 7.7.20-experimental.0

package/lib/app/__tests__/migrate.test.js

@@ -0,0 +1,495 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const path_1 = require("@hubspot/local-dev-lib/path");
+const archive_1 = require("@hubspot/local-dev-lib/archive");
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const projects_1 = require("@hubspot/local-dev-lib/constants/projects");
+const Migration_1 = require("@hubspot/local-dev-lib/types/Migration");
+const projects_2 = require("@hubspot/local-dev-lib/api/projects");
+const fs_1 = __importDefault(require("fs"));
+const promptUtils_1 = require("../../prompts/promptUtils");
+const ensureProjectExists_1 = require("../../projects/ensureProjectExists");
+const polling_1 = require("../../polling");
+const migrate_1 = require("../../../api/migrate");
+const en_1 = require("../../../lang/en");
+const hasFeature_1 = require("../../hasFeature");
+const migrate_2 = require("../migrate");
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/path');
+vi.mock('@hubspot/local-dev-lib/archive');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('inquirer');
+vi.mock('../../prompts/promptUtils');
+vi.mock('../../projects/config');
+vi.mock('../../projects/ensureProjectExists');
+vi.mock('../../ui/SpinniesManager');
+vi.mock('../../polling');
+vi.mock('../../../api/migrate');
+vi.mock('../../hasFeature');
+vi.mock('../../projects/urls');
+vi.mock('fs');
+const mockedLogger = logger_1.logger;
+const mockedGetCwd = path_1.getCwd;
+const mockedSanitizeFileName = path_1.sanitizeFileName;
+const mockedExtractZipArchive = archive_1.extractZipArchive;
+const mockedValidateUid = project_parsing_lib_1.validateUid;
+const mockedDownloadProject = projects_2.downloadProject;
+const mockedConfirmPrompt = promptUtils_1.confirmPrompt;
+const mockedInputPrompt = promptUtils_1.inputPrompt;
+const mockedListPrompt = promptUtils_1.listPrompt;
+const mockedEnsureProjectExists = ensureProjectExists_1.ensureProjectExists;
+const mockedPoll = polling_1.poll;
+const mockedListAppsForMigration = migrate_1.listAppsForMigration;
+const mockedInitializeMigration = migrate_1.initializeMigration;
+const mockedContinueMigration = migrate_1.continueMigration;
+const mockedHasFeature = hasFeature_1.hasFeature;
+const mockedFs = fs_1.default;
+const createMockMigratableApp = (id, name, projectName) => ({
+    appId: id,
+    appName: name,
+    isMigratable: true,
+    migrationComponents: [],
+    ...(projectName && { projectName }),
+});
+const createMockUnmigratableApp = (id, name, reason) => ({
+    appId: id,
+    appName: name,
+    isMigratable: false,
+    // @ts-expect-error
+    unmigratableReason: reason,
+    migrationComponents: [],
+});
+const createLoadedProjectConfig = (name) => ({
+    projectConfig: { name },
+    projectDir: MOCK_PROJECT_DIR,
+});
+const ACCOUNT_ID = 123;
+const PROJECT_NAME = 'Test Project';
+const APP_ID = 1;
+const PLATFORM_VERSION = '2025.2';
+const MIGRATION_ID = 456;
+const BUILD_ID = 789;
+const PROJECT_DEST = '/mock/dest';
+const MOCK_CWD = '/mock/cwd';
+const MOCK_PROJECT_DIR = '/mock/project/dir';
+const mockUnmigratableApps = [
+    createMockUnmigratableApp(3, 'App 3', projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE),
+    createMockUnmigratableApp(4, 'App 4', projects_1.UNMIGRATABLE_REASONS.IS_A_PRIVATE_APP),
+];
+describe('lib/app/migrate', () => {
+    beforeEach(() => {
+        mockedGetCwd.mockReturnValue(MOCK_CWD);
+        mockedSanitizeFileName.mockImplementation(name => name);
+        mockedValidateUid.mockReturnValue(undefined);
+        mockedHasFeature.mockResolvedValue(true);
+        mockedFs.renameSync.mockImplementation(() => { });
+    });
+    describe('getUnmigratableReason', () => {
+        const testCases = [
+            {
+                name: 'UP_TO_DATE',
+                reason: projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.upToDate,
+            },
+            {
+                name: 'IS_A_PRIVATE_APP',
+                reason: projects_1.UNMIGRATABLE_REASONS.IS_A_PRIVATE_APP,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.isPrivateApp,
+            },
+            {
+                name: 'LISTED_IN_MARKETPLACE',
+                reason: projects_1.UNMIGRATABLE_REASONS.LISTED_IN_MARKETPLACE,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.listedInMarketplace,
+            },
+            {
+                name: 'PROJECT_CONNECTED_TO_GITHUB',
+                reason: projects_1.UNMIGRATABLE_REASONS.PROJECT_CONNECTED_TO_GITHUB,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.projectConnectedToGitHub(PROJECT_NAME, ACCOUNT_ID),
+            },
+            {
+                name: 'PART_OF_PROJECT_ALREADY',
+                reason: migrate_1.CLI_UNMIGRATABLE_REASONS.PART_OF_PROJECT_ALREADY,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.partOfProjectAlready,
+            },
+            {
+                name: 'UNKNOWN_REASON',
+                reason: 'UNKNOWN_REASON',
+                expected: en_1.lib.migrate.errors.unmigratableReasons.generic('UNKNOWN_REASON'),
+            },
+        ];
+        testCases.forEach(testCase => {
+            it(`should return the correct message for ${testCase.name}`, () => {
+                const result = (0, migrate_2.getUnmigratableReason)(testCase.reason, PROJECT_NAME, ACCOUNT_ID);
+                expect(result).toBe(testCase.expected);
+            });
+        });
+    });
+    describe('generateFilterAppsByProjectNameFunction', () => {
+        it('should return a function that filters by project name when projectConfig is provided', () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            const filterFn = (0, migrate_2.generateFilterAppsByProjectNameFunction)(projectConfig);
+            const matchingApp = createMockMigratableApp(1, 'App 1', PROJECT_NAME);
+            const nonMatchingApp = createMockMigratableApp(2, 'App 2', 'Other Project');
+            expect(filterFn(matchingApp)).toBe(true);
+            expect(filterFn(nonMatchingApp)).toBe(false);
+        });
+        it('should return a function that always returns true when projectConfig is not provided', () => {
+            const filterFn = (0, migrate_2.generateFilterAppsByProjectNameFunction)(undefined);
+            const app1 = createMockMigratableApp(1, 'App 1', PROJECT_NAME);
+            const app2 = createMockMigratableApp(2, 'App 2', 'Other Project');
+            expect(filterFn(app1)).toBe(true);
+            expect(filterFn(app2)).toBe(true);
+        });
+    });
+    describe('buildErrorMessageFromMigrationStatus', () => {
+        it('should return projectErrorDetail when there are no component errors', () => {
+            const error = {
+                id: 123,
+                status: Migration_1.MIGRATION_STATUS.FAILURE,
+                projectErrorDetail: 'Project error',
+                componentErrors: [],
+            };
+            const result = (0, migrate_2.buildErrorMessageFromMigrationStatus)(error);
+            expect(result).toBe('Project error');
+        });
+        it('should return formatted error message with component errors', () => {
+            const error = {
+                id: 123,
+                status: Migration_1.MIGRATION_STATUS.FAILURE,
+                projectErrorDetail: 'Project error',
+                componentErrors: [
+                    {
+                        componentType: 'CARD',
+                        developerSymbol: 'card1',
+                        errorMessage: 'Card error',
+                    },
+                    {
+                        componentType: 'FUNCTION',
+                        errorMessage: 'Function error',
+                    },
+                ],
+            };
+            const result = (0, migrate_2.buildErrorMessageFromMigrationStatus)(error);
+            expect(result).toBe('Project error: \n\t- CARD (card1): Card error\n\t- FUNCTION: Function error');
+        });
+    });
+    describe('fetchMigrationApps', () => {
+        const setupMockApps = (migratableApps = [], unmigratableApps = []) => {
+            // @ts-expect-error
+            mockedListAppsForMigration.mockResolvedValue({
+                data: {
+                    migratableApps,
+                    unmigratableApps,
+                },
+            });
+        };
+        beforeEach(() => {
+            setupMockApps([
+                createMockMigratableApp(1, 'App 1', PROJECT_NAME),
+                createMockMigratableApp(2, 'App 2', PROJECT_NAME),
+            ], [createMockUnmigratableApp(3, 'App 3', projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE)]);
+        });
+        it('should return all apps when no projectConfig is provided', async () => {
+            setupMockApps([createMockMigratableApp(1, 'App 1')]);
+            const result = await (0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION);
+            expect(result).toHaveLength(1);
+            expect(result[0].appId).toBe(1);
+        });
+        it('should filter apps by project name when projectConfig is provided', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            setupMockApps([createMockMigratableApp(1, 'App 1', PROJECT_NAME)]);
+            const result = await (0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig);
+            expect(result).toHaveLength(1);
+            expect(result[0].projectName).toBe(PROJECT_NAME);
+        });
+        it('should throw an error when multiple apps are found for a project', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            setupMockApps([
+                createMockMigratableApp(1, 'App 1', PROJECT_NAME),
+                createMockMigratableApp(2, 'App 2', PROJECT_NAME),
+            ]);
+            await expect((0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig)).rejects.toThrow(en_1.lib.migrate.errors.project.multipleApps);
+        });
+        it('should throw an error when no apps are found for a project', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            setupMockApps([], []);
+            await expect((0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig)).rejects.toThrow(en_1.lib.migrate.errors.noAppsForProject(PROJECT_NAME));
+        });
+        it('should throw an error when no migratable apps are found', async () => {
+            setupMockApps([], mockUnmigratableApps);
+            await expect((0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION)).rejects.toThrow(/No apps in account/);
+        });
+        it('should throw an error when appId is provided but not found', async () => {
+            await expect((0, migrate_2.fetchMigrationApps)(999, ACCOUNT_ID, PLATFORM_VERSION)).rejects.toThrow(/No apps in account/);
+        });
+    });
+    describe('promptForAppToMigrate', () => {
+        const mockApps = [
+            createMockMigratableApp(1, 'App 1'),
+            createMockUnmigratableApp(2, 'App 2', projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE),
+        ];
+        beforeEach(() => {
+            mockedListPrompt.mockResolvedValue(mockApps[0]);
+        });
+        it('should prompt the user to select an app', async () => {
+            await (0, migrate_2.promptForAppToMigrate)(mockApps, ACCOUNT_ID);
+            expect(mockedListPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.chooseApp, expect.any(Object));
+        });
+        it('should return the selected app', async () => {
+            mockedListPrompt.mockResolvedValue({ appId: mockApps[0].appId });
+            const result = await (0, migrate_2.promptForAppToMigrate)(mockApps, ACCOUNT_ID);
+            expect(result).toBe(mockApps[0].appId);
+        });
+    });
+    describe('selectAppToMigrate', () => {
+        const mockApps = [
+            {
+                appId: 1,
+                appName: 'App 1',
+                isMigratable: true,
+                migrationComponents: [
+                    { id: '1', componentType: 'CARD', isSupported: true },
+                    { id: '2', componentType: 'FUNCTION', isSupported: false },
+                ],
+            },
+            createMockUnmigratableApp(2, 'App 2', projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE),
+        ];
+        beforeEach(() => {
+            mockedListPrompt.mockResolvedValue({ appId: 1 });
+            mockedConfirmPrompt.mockResolvedValue(true);
+        });
+        it('should throw an error when appId is provided but not found', async () => {
+            await expect((0, migrate_2.selectAppToMigrate)(mockApps, ACCOUNT_ID, 999)).rejects.toThrow(en_1.lib.migrate.errors.appWithAppIdNotFound(999));
+        });
+        it('should call listPrompt when appId is not provided', async () => {
+            await (0, migrate_2.selectAppToMigrate)(mockApps, ACCOUNT_ID);
+            expect(mockedListPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.chooseApp, expect.any(Object));
+        });
+        it('should return proceed: false and appIdToMigrate when user cancels', async () => {
+            mockedConfirmPrompt.mockResolvedValue(false);
+            const result = await (0, migrate_2.selectAppToMigrate)(mockApps, ACCOUNT_ID);
+            expect(result).toEqual({ proceed: false, appIdToMigrate: 1 });
+        });
+        it('should return proceed: true and appIdToMigrate when user confirms', async () => {
+            const result = await (0, migrate_2.selectAppToMigrate)(mockApps, ACCOUNT_ID);
+            expect(result).toEqual({ proceed: true, appIdToMigrate: 1 });
+        });
+    });
+    describe('handleMigrationSetup', () => {
+        const defaultOptions = {
+            name: PROJECT_NAME,
+            dest: PROJECT_DEST,
+            appId: APP_ID,
+            platformVersion: PLATFORM_VERSION,
+            unstable: false,
+        };
+        beforeEach(() => {
+            setupMockForHandleMigrationSetup();
+        });
+        function setupMockForHandleMigrationSetup() {
+            // @ts-expect-error
+            mockedListAppsForMigration.mockResolvedValue({
+                data: {
+                    migratableApps: [createMockMigratableApp(1, 'App 1')],
+                    unmigratableApps: [],
+                },
+            });
+            mockedListPrompt.mockResolvedValue({ appId: 1 });
+            mockedConfirmPrompt.mockResolvedValue(true);
+            mockedEnsureProjectExists.mockResolvedValue({ projectExists: false });
+        }
+        it('should return early when user cancels', async () => {
+            mockedConfirmPrompt.mockResolvedValueOnce(false);
+            const result = await (0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, defaultOptions);
+            expect(result).toEqual({});
+        });
+        it('should return project details when projectConfig is provided', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            // @ts-expect-error
+            mockedListAppsForMigration.mockResolvedValueOnce({
+                data: {
+                    migratableApps: [createMockMigratableApp(1, 'App 1', PROJECT_NAME)],
+                    unmigratableApps: [],
+                },
+            });
+            const result = await (0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, defaultOptions, projectConfig);
+            expect(result).toEqual({
+                appIdToMigrate: 1,
+                projectName: PROJECT_NAME,
+                projectDest: MOCK_PROJECT_DIR,
+            });
+        });
+        it('should prompt for project name when not provided', async () => {
+            const optionsWithoutName = { ...defaultOptions, name: undefined };
+            mockedInputPrompt.mockResolvedValue('New Project');
+            await (0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, optionsWithoutName);
+            expect(mockedInputPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.inputName, expect.any(Object));
+        });
+        it('should prompt for project destination when not provided', async () => {
+            const optionsWithoutDest = { ...defaultOptions, dest: undefined };
+            mockedInputPrompt.mockResolvedValue('/mock/new/dest');
+            await (0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, optionsWithoutDest);
+            expect(mockedInputPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.inputDest, expect.any(Object));
+        });
+        it('should throw an error when project already exists', async () => {
+            mockedEnsureProjectExists.mockResolvedValue({ projectExists: true });
+            await expect((0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, defaultOptions)).rejects.toThrow(en_1.lib.migrate.errors.project.alreadyExists(PROJECT_NAME));
+        });
+    });
+    describe('beginMigration', () => {
+        beforeEach(() => {
+            // @ts-expect-error
+            mockedInitializeMigration.mockResolvedValue({
+                data: { migrationId: MIGRATION_ID },
+            });
+            mockedPoll.mockResolvedValue({
+                status: Migration_1.MIGRATION_STATUS.INPUT_REQUIRED,
+                // @ts-expect-error
+                componentsRequiringUids: {},
+            });
+            mockedInputPrompt.mockResolvedValue('test-uid');
+        });
+        it('should initialize migration and return migrationId and uidMap', async () => {
+            const result = await (0, migrate_2.beginMigration)(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
+            expect(result).toEqual({
+                migrationId: MIGRATION_ID,
+                uidMap: {},
+            });
+        });
+        it('should prompt for UIDs when components require them', async () => {
+            const componentHint = 'test-card';
+            mockedPoll.mockResolvedValue({
+                status: Migration_1.MIGRATION_STATUS.INPUT_REQUIRED,
+                // @ts-expect-error
+                componentsRequiringUids: {
+                    '1': {
+                        componentType: 'CARD',
+                        componentHint,
+                    },
+                },
+            });
+            await (0, migrate_2.beginMigration)(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
+            expect(mockedInputPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.uidForComponent("card 'test-card' (ID: 1)"), {
+                defaultAnswer: componentHint,
+                validate: expect.any(Function),
+            });
+        });
+        it('should throw an error when migration fails', async () => {
+            mockedPoll.mockRejectedValue(new Error('Failed'));
+            await expect((0, migrate_2.beginMigration)(ACCOUNT_ID, APP_ID, PLATFORM_VERSION)).rejects.toThrow(/Migration Failed/);
+        });
+    });
+    describe('pollMigrationStatus', () => {
+        it('should call poll with checkMigrationStatusV2', async () => {
+            const mockStatus = {
+                id: MIGRATION_ID,
+                status: Migration_1.MIGRATION_STATUS.SUCCESS,
+                buildId: BUILD_ID,
+            };
+            mockedPoll.mockResolvedValue(mockStatus);
+            const result = await (0, migrate_2.pollMigrationStatus)(ACCOUNT_ID, MIGRATION_ID);
+            expect(mockedPoll).toHaveBeenCalledWith(expect.any(Function), expect.any(Object));
+            expect(result).toBe(mockStatus);
+        });
+    });
+    describe('finalizeMigration', () => {
+        const uidMap = { '1': 'test-uid' };
+        beforeEach(() => {
+            // @ts-expect-error
+            mockedContinueMigration.mockResolvedValue({
+                data: { migrationId: MIGRATION_ID },
+            });
+            mockedPoll.mockResolvedValue({
+                status: Migration_1.MIGRATION_STATUS.SUCCESS,
+                // @ts-expect-error
+                buildId: BUILD_ID,
+            });
+        });
+        it('should continue migration and return buildId', async () => {
+            const result = await (0, migrate_2.finalizeMigration)(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME);
+            expect(result).toBe(BUILD_ID);
+        });
+        it('should throw an error when migration fails', async () => {
+            mockedPoll.mockRejectedValue(new Error('Test error'));
+            await expect((0, migrate_2.finalizeMigration)(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME)).rejects.toThrow(/Migration Failed/);
+        });
+    });
+    describe('downloadProjectFiles', () => {
+        beforeEach(() => {
+            // @ts-expect-error
+            mockedDownloadProject.mockResolvedValue({
+                data: Buffer.from('mock-zip-data'),
+            });
+            mockedExtractZipArchive.mockResolvedValue(true);
+            mockedGetCwd.mockReturnValue(MOCK_CWD);
+            mockedSanitizeFileName.mockReturnValue(PROJECT_NAME);
+        });
+        it('should download and extract project files', async () => {
+            await (0, migrate_2.downloadProjectFiles)(ACCOUNT_ID, PROJECT_NAME, BUILD_ID, PROJECT_DEST);
+            expect(mockedDownloadProject).toHaveBeenCalledWith(ACCOUNT_ID, PROJECT_NAME, BUILD_ID);
+            expect(mockedExtractZipArchive).toHaveBeenCalledWith(expect.any(Buffer), PROJECT_NAME, expect.stringContaining(PROJECT_DEST), {
+                includesRootDir: true,
+                hideLogs: true,
+            });
+        });
+        it('should handle projectConfig correctly', async () => {
+            const projectConfig = {
+                projectConfig: { name: PROJECT_NAME, srcDir: 'src' },
+                projectDir: MOCK_PROJECT_DIR,
+            };
+            await (0, migrate_2.downloadProjectFiles)(ACCOUNT_ID, PROJECT_NAME, BUILD_ID, PROJECT_DEST, projectConfig);
+            expect(mockedFs.renameSync).toHaveBeenCalledWith(`${MOCK_PROJECT_DIR}/src`, `${MOCK_PROJECT_DIR}/archive`);
+            expect(mockedExtractZipArchive).toHaveBeenCalledWith(expect.any(Buffer), PROJECT_NAME, MOCK_PROJECT_DIR, {
+                includesRootDir: true,
+                hideLogs: true,
+            });
+        });
+        it('should throw an error when download fails', async () => {
+            const error = new Error('Download failed');
+            mockedDownloadProject.mockRejectedValue(error);
+            await expect((0, migrate_2.downloadProjectFiles)(ACCOUNT_ID, PROJECT_NAME, BUILD_ID, PROJECT_DEST)).rejects.toThrow(error);
+        });
+    });
+    describe('migrateApp2025_2', () => {
+        const options = {
+            name: PROJECT_NAME,
+            dest: PROJECT_DEST,
+            appId: APP_ID,
+            platformVersion: PLATFORM_VERSION,
+            unstable: false,
+        };
+        beforeEach(() => {
+            mockedHasFeature.mockResolvedValue(true);
+        });
+        it('should throw an error when account is not ungated for unified apps', async () => {
+            mockedHasFeature.mockResolvedValueOnce(false);
+            await expect((0, migrate_2.migrateApp2025_2)(ACCOUNT_ID, options)).rejects.toThrowError(/isn't enrolled in the required product beta to access this command./);
+        });
+        it('should throw an error when projectConfig is invalid', async () => {
+            const invalidProjectConfig = {
+                projectConfig: undefined,
+                projectDir: '/mock/project/dir',
+            };
+            await expect((0, migrate_2.migrateApp2025_2)(ACCOUNT_ID, options, invalidProjectConfig)).rejects.toThrow(/The project configuration file is invalid/);
+        });
+        it('should throw an error when project does not exist', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            mockedEnsureProjectExists.mockResolvedValueOnce({
+                projectExists: false,
+            });
+            await expect((0, migrate_2.migrateApp2025_2)(ACCOUNT_ID, options, projectConfig)).rejects.toThrow(/Migrations are only supported for existing projects/);
+        });
+    });
+    describe('logInvalidAccountError', () => {
+        it('should log the invalid account error message', () => {
+            (0, migrate_2.logInvalidAccountError)();
+            expect(mockedLogger.error).toHaveBeenCalledWith(en_1.lib.migrate.errors.invalidAccountTypeTitle);
+            expect(mockedLogger.log).toHaveBeenCalledWith(expect.stringContaining('Only public apps created in a developer account can be converted to a project component'));
+        });
+    });
+});

package/lib/app/__tests__/migrate_legacy.test.d.ts

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

package/lib/app/__tests__/migrate_legacy.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const appsDev_1 = require("@hubspot/local-dev-lib/api/appsDev");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const archive_1 = require("@hubspot/local-dev-lib/archive");
+const promptUtils_1 = require("../../prompts/promptUtils");
+const exitCodes_1 = require("../../enums/exitCodes");
+const accountTypes_1 = require("../../accountTypes");
+const selectPublicAppForMigrationPrompt_1 = require("../../prompts/selectPublicAppForMigrationPrompt");
+const projectNameAndDestPrompt_1 = require("../../prompts/projectNameAndDestPrompt");
+const ensureProjectExists_1 = require("../../projects/ensureProjectExists");
+const polling_1 = require("../../polling");
+const migrate_legacy_1 = require("../migrate_legacy");
+// Mock all external dependencies
+vi.mock('@hubspot/local-dev-lib/api/appsDev');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/path');
+vi.mock('@hubspot/local-dev-lib/urls');
+vi.mock('@hubspot/local-dev-lib/archive');
+vi.mock('../../prompts/promptUtils');
+vi.mock('../../errorHandlers');
+vi.mock('../../accountTypes');
+vi.mock('../../prompts/selectPublicAppForMigrationPrompt');
+vi.mock('../../prompts/projectNameAndDestPrompt');
+vi.mock('../../projects/ensureProjectExists');
+vi.mock('../../usageTracking');
+vi.mock('../../ui/SpinniesManager');
+vi.mock('../../process');
+vi.mock('../../polling');
+const isAppDeveloperAccount = accountTypes_1.isAppDeveloperAccount;
+const isUnifiedAccount = accountTypes_1.isUnifiedAccount;
+const selectPublicAppForMigrationPrompt = selectPublicAppForMigrationPrompt_1.selectPublicAppForMigrationPrompt;
+const projectNameAndDestPrompt = projectNameAndDestPrompt_1.projectNameAndDestPrompt;
+const ensureProjectExists = ensureProjectExists_1.ensureProjectExists;
+const poll = polling_1.poll;
+const fetchPublicAppMetadata = appsDev_1.fetchPublicAppMetadata;
+const migrateNonProjectApp_v2023_2 = projects_1.migrateApp;
+const downloadProject = projects_1.downloadProject;
+const promptUser = promptUtils_1.promptUser;
+describe('migrateApp2023_2', () => {
+    const mockDerivedAccountId = 123;
+    const mockOptions = {
+        _: [],
+        $0: 'test',
+        derivedAccountId: 123,
+        d: false,
+        debug: false,
+        platformVersion: '2023.2',
+        unstable: false,
+    };
+    const mockAccountConfig = {
+        accountId: 123,
+        name: 'Test Account',
+        env: 'prod',
+    };
+    const appId = 12345;
+    const projectName = 'test-project';
+    beforeEach(() => {
+        // @ts-expect-error function mismatch
+        vi.spyOn(process, 'exit').mockImplementation(() => { });
+        selectPublicAppForMigrationPrompt.mockResolvedValue({
+            appId,
+        });
+        isAppDeveloperAccount.mockReturnValue(true);
+        isUnifiedAccount.mockResolvedValue(false);
+        fetchPublicAppMetadata.mockResolvedValue({
+            // @ts-expect-error Mocking the return type
+            data: { preventProjectMigrations: false },
+        });
+        projectNameAndDestPrompt.mockResolvedValue({
+            name: projectName,
+            dest: '/test/dest',
+        });
+        promptUser.mockResolvedValue({
+            shouldCreateApp: true,
+        });
+        ensureProjectExists.mockResolvedValue({
+            projectExists: false,
+        });
+        migrateNonProjectApp_v2023_2.mockResolvedValue({
+            // @ts-expect-error Mocking the return type
+            data: { id: 'migration-id' },
+        });
+        poll.mockResolvedValue({
+            status: 'SUCCESS',
+            // @ts-expect-error
+            project: {
+                name: projectName,
+            },
+        });
+        downloadProject.mockResolvedValue({
+            // @ts-expect-error Mocking the return type
+            data: 'zipped-project-data',
+        });
+    });
+    it('should exit if account is not an app developer account and not unified', async () => {
+        isAppDeveloperAccount.mockReturnValue(false);
+        await (0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig);
+        expect(migrateNonProjectApp_v2023_2).not.toHaveBeenCalled();
+        expect(process.exit).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.SUCCESS);
+    });
+    it('should proceed with migration for valid app developer account', async () => {
+        await (0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig);
+        expect(selectPublicAppForMigrationPrompt).toHaveBeenCalled();
+        expect(fetchPublicAppMetadata).toHaveBeenCalledWith(appId, mockDerivedAccountId);
+        expect(projectNameAndDestPrompt).toHaveBeenCalled();
+        expect(ensureProjectExists).toHaveBeenCalled();
+        expect(migrateNonProjectApp_v2023_2).toHaveBeenCalled();
+        expect(poll).toHaveBeenCalled();
+        expect(downloadProject).toHaveBeenCalled();
+        expect(archive_1.extractZipArchive).toHaveBeenCalled();
+    });
+    it('should handle migration failure gracefully', async () => {
+        const errorMessage = 'Migration failed';
+        migrateNonProjectApp_v2023_2.mockRejectedValue(new Error(errorMessage));
+        await expect((0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig)).rejects.toThrow(errorMessage);
+    });
+    it('should handle non-migratable apps', async () => {
+        fetchPublicAppMetadata.mockResolvedValue({
+            data: {
+                preventProjectMigrations: true,
+                // @ts-expect-error
+                listingInfo: { someInfo: 'test' },
+            },
+        });
+        await (0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig);
+        expect(process.exit).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.ERROR);
+    });
+    it('should handle existing project error', async () => {
+        ensureProjectExists.mockResolvedValue({
+            projectExists: true,
+        });
+        await expect((0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig)).rejects.toThrow('A project with name test-project already exists');
+    });
+});

package/lib/buildAccount.d.ts

@@ -1,15 +1,9 @@
-import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { SandboxResponse } from '@hubspot/local-dev-lib/types/Sandbox';
 import { SandboxAccountType } from '../types/Sandboxes';
 export declare function saveAccountToConfig(accountId: number | undefined, accountName: string, env: Environment, personalAccessKey?: string, force?: boolean): Promise<string>;
-export declare function createDeveloperTestAccountV3(parentAccountId: number, testAccountConfig: DeveloperTestAccountConfig): Promise<{
-    accountName: string;
-    accountId?: number;
-    personalAccessKey?: string;
-}>;
-export declare function buildDeveloperTestAccount(testAccountName: string, parentAccountConfig: CLIAccount, env: Environment, portalLimit: number, useV3?: boolean): Promise<number>;
+export declare function buildDeveloperTestAccount(testAccountName: string, parentAccountConfig: CLIAccount, env: Environment, portalLimit: number): Promise<number>;
 type SandboxAccount = SandboxResponse & {
     name: string;
 };