@hubspot/cli 8.0.11-experimental.0 → 8.0.11-experimental.1

package/lib/prompts/__tests__/projectAddPrompt.test.js

@@ -1,143 +0,0 @@
-import { Separator } from '@inquirer/prompts';
-import { projectAddPromptV2 } from '../projectAddPrompt.js';
-import { promptUser } from '../promptUtils.js';
-vi.mock('../promptUtils');
-const mockedPromptUser = vi.mocked(promptUser);
-describe('lib/prompts/projectAddPrompt', () => {
-    const mockComponentTemplate = {
-        label: 'Test Module',
-        path: 'test-module',
-        type: 'module',
-        supportedAuthTypes: ['oauth'],
-        supportedDistributions: ['private'],
-    };
-    const mockComponentTemplateWithCliSelector = {
-        label: 'Workflow Action Tool',
-        path: 'workflow-action-tool',
-        type: 'workflow-action',
-        cliSelector: 'workflow-action-tool',
-        supportedAuthTypes: ['oauth'],
-        supportedDistributions: ['private'],
-    };
-    describe('projectAddPromptV2()', () => {
-        beforeEach(() => {
-            // Mock returns empty result, logic will use selectedComponents when selectedFeatures provided
-            mockedPromptUser.mockResolvedValue({});
-        });
-        it('should select component based on cliSelector when provided', async () => {
-            const templateChoice = {
-                name: 'Workflow Action Tool',
-                value: mockComponentTemplateWithCliSelector,
-            };
-            const components = [templateChoice];
-            const selectedFeatures = ['workflow-action-tool'];
-            const result = await projectAddPromptV2(components, selectedFeatures);
-            expect(result.componentTemplate).toEqual([
-                mockComponentTemplateWithCliSelector,
-            ]);
-            expect(mockedPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    name: 'componentTemplate',
-                    when: false, // selectedFeatures provided, so skip prompt
-                }),
-            ]);
-        });
-        it('should select component based on type when cliSelector not provided', async () => {
-            const templateChoice = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const components = [templateChoice];
-            const selectedFeatures = ['module'];
-            const result = await projectAddPromptV2(components, selectedFeatures);
-            expect(result.componentTemplate).toEqual([mockComponentTemplate]);
-            expect(mockedPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    name: 'componentTemplate',
-                    when: false, // selectedFeatures provided and selectedComponents found
-                }),
-            ]);
-        });
-        it('should prefer cliSelector over type when both are available', async () => {
-            const templateChoice = {
-                name: 'Workflow Action Tool',
-                value: mockComponentTemplateWithCliSelector,
-            };
-            const components = [templateChoice];
-            const selectedFeatures = ['workflow-action-tool']; // matches cliSelector
-            const result = await projectAddPromptV2(components, selectedFeatures);
-            expect(result.componentTemplate).toEqual([
-                mockComponentTemplateWithCliSelector,
-            ]);
-        });
-        it('should not select component when neither cliSelector nor type matches', async () => {
-            const templateChoice = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const components = [templateChoice];
-            const selectedFeatures = ['non-matching-feature'];
-            mockedPromptUser.mockResolvedValue({ componentTemplate: [] });
-            const result = await projectAddPromptV2(components, selectedFeatures);
-            expect(result.componentTemplate).toEqual([]);
-        });
-        it('should throw error when selected feature component is disabled', async () => {
-            const disabledTemplateChoice = {
-                name: 'Disabled Component',
-                value: mockComponentTemplateWithCliSelector,
-                disabled: 'Component is disabled for testing',
-            };
-            const components = [disabledTemplateChoice];
-            const selectedFeatures = ['workflow-action-tool'];
-            await expect(projectAddPromptV2(components, selectedFeatures)).rejects.toThrow(/Cannot.*feature.*workflow-action/);
-        });
-        it('should handle multiple components with mixed cliSelector availability', async () => {
-            const choice1 = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const choice2 = {
-                name: 'Workflow Action Tool',
-                value: mockComponentTemplateWithCliSelector,
-            };
-            const components = [choice1, choice2];
-            const selectedFeatures = ['module', 'workflow-action-tool'];
-            const result = await projectAddPromptV2(components, selectedFeatures);
-            expect(result.componentTemplate).toEqual([
-                mockComponentTemplate,
-                mockComponentTemplateWithCliSelector,
-            ]);
-        });
-        it('should skip Separator instances when processing components', async () => {
-            const separator = new Separator();
-            const templateChoice = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const components = [separator, templateChoice];
-            const selectedFeatures = ['module'];
-            const result = await projectAddPromptV2(components, selectedFeatures);
-            expect(result.componentTemplate).toEqual([mockComponentTemplate]);
-        });
-        it('should prompt user when no selectedFeatures provided', async () => {
-            const templateChoice = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const components = [templateChoice];
-            const selectedFeatures = undefined;
-            mockedPromptUser.mockResolvedValue({
-                componentTemplate: [mockComponentTemplate],
-            });
-            const result = await projectAddPromptV2(components, selectedFeatures);
-            expect(mockedPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    name: 'componentTemplate',
-                    type: 'checkbox',
-                    choices: components,
-                }),
-            ]);
-            expect(result.componentTemplate).toEqual([mockComponentTemplate]);
-        });
-    });
-});

package/lib/prompts/__tests__/projectsLogsPrompt.test.d.ts

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

package/lib/prompts/__tests__/projectsLogsPrompt.test.js

@@ -1,37 +0,0 @@
-import { projectLogsPrompt } from '../projectsLogsPrompt.js';
-import { promptUser } from '../promptUtils.js';
-import chalk from 'chalk';
-vi.mock('../promptUtils');
-describe('lib/prompts/projectsLogsPrompt', () => {
-    it('should return undefined functionName when functionChoices is undefined', async () => {
-        const actual = await projectLogsPrompt({ functionChoices: undefined });
-        expect(actual).toEqual({});
-        expect(promptUser).not.toHaveBeenCalled();
-    });
-    it('should return the functionName without prompting when there is only one functionChoice', async () => {
-        const functionChoice = 'this-is-the-only-function';
-        const { functionName } = await projectLogsPrompt({
-            functionChoices: [functionChoice],
-        });
-        expect(functionName).toEqual(functionChoice);
-        expect(promptUser).not.toHaveBeenCalled();
-    });
-    it('should prompt the user if there is more than one choice', async () => {
-        const functionChoices = ['choice 1', 'choice 2'];
-        const projectName = 'my cool project';
-        await projectLogsPrompt({
-            functionChoices,
-            projectName,
-        });
-        expect(promptUser).toHaveBeenCalledTimes(1);
-        expect(promptUser).toHaveBeenLastCalledWith(expect.arrayContaining([
-            expect.objectContaining({
-                name: 'functionName',
-                type: 'list',
-                message: `[--function] Select function in ${chalk.bold(projectName)} project`,
-                when: expect.any(Function),
-                choices: functionChoices,
-            }),
-        ]));
-    });
-});

package/lib/prompts/__tests__/selectProjectTemplatePrompt.test.d.ts

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

package/lib/prompts/__tests__/selectProjectTemplatePrompt.test.js

@@ -1,160 +0,0 @@
-import { Separator } from '@inquirer/prompts';
-import { selectProjectTemplatePrompt } from '../selectProjectTemplatePrompt.js';
-import { promptUser } from '../promptUtils.js';
-vi.mock('../promptUtils');
-const mockedPromptUser = vi.mocked(promptUser);
-describe('lib/prompts/selectProjectTemplatePrompt', () => {
-    const mockComponentTemplate = {
-        label: 'Test Module',
-        path: 'test-module',
-        type: 'module',
-        supportedAuthTypes: ['oauth'],
-        supportedDistributions: ['private'],
-    };
-    const mockComponentTemplateWithCliSelector = {
-        label: 'Workflow Action Tool',
-        path: 'workflow-action-tool',
-        type: 'workflow-action',
-        cliSelector: 'workflow-action-tool',
-        supportedAuthTypes: ['oauth'],
-        supportedDistributions: ['private'],
-    };
-    beforeEach(() => {
-        mockedPromptUser.mockResolvedValue({});
-    });
-    describe('selectProjectTemplatePrompt with component templates', () => {
-        it('should select component based on cliSelector when provided', async () => {
-            const templateChoice = {
-                name: 'Workflow Action Tool',
-                value: mockComponentTemplateWithCliSelector,
-            };
-            const componentTemplates = [templateChoice];
-            const promptOptions = {
-                features: ['workflow-action-tool'],
-            };
-            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
-            expect(result.componentTemplates).toEqual([
-                mockComponentTemplateWithCliSelector,
-            ]);
-            expect(mockedPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'projectTemplate' }),
-                expect.objectContaining({ name: 'componentTemplates' }),
-            ]);
-        });
-        it('should select component based on type when cliSelector not provided', async () => {
-            const templateChoice = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const componentTemplates = [templateChoice];
-            const promptOptions = {
-                features: ['module'],
-            };
-            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
-            expect(result.componentTemplates).toEqual([mockComponentTemplate]);
-        });
-        it('should prefer cliSelector over type when both are available', async () => {
-            const templateChoice = {
-                name: 'Workflow Action Tool',
-                value: mockComponentTemplateWithCliSelector,
-            };
-            const componentTemplates = [templateChoice];
-            const promptOptions = {
-                features: ['workflow-action-tool'], // matches cliSelector, not type
-            };
-            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
-            expect(result.componentTemplates).toEqual([
-                mockComponentTemplateWithCliSelector,
-            ]);
-        });
-        it('should not select component when neither cliSelector nor type matches', async () => {
-            const templateChoice = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const componentTemplates = [templateChoice];
-            const promptOptions = {
-                features: ['non-matching-feature'],
-            };
-            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
-            expect(result.componentTemplates).toEqual([]);
-        });
-        it('should throw error when selected feature component is disabled', async () => {
-            const disabledTemplateChoice = {
-                name: 'Disabled Component',
-                value: mockComponentTemplateWithCliSelector,
-                disabled: 'Component is disabled for testing',
-            };
-            const componentTemplates = [disabledTemplateChoice];
-            const promptOptions = {
-                features: ['workflow-action-tool'],
-            };
-            await expect(selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates)).rejects.toThrow(/Cannot create project with template.*workflow-action/);
-        });
-        it('should handle multiple components with mixed cliSelector availability', async () => {
-            const choice1 = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const choice2 = {
-                name: 'Workflow Action Tool',
-                value: mockComponentTemplateWithCliSelector,
-            };
-            const componentTemplates = [choice1, choice2];
-            const promptOptions = {
-                features: ['module', 'workflow-action-tool'],
-            };
-            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
-            expect(result.componentTemplates).toEqual([
-                mockComponentTemplate,
-                mockComponentTemplateWithCliSelector,
-            ]);
-        });
-        it('should skip Separator instances when processing components', async () => {
-            const separator = new Separator();
-            const templateChoice = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const componentTemplates = [separator, templateChoice];
-            const promptOptions = {
-                features: ['module'],
-            };
-            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
-            expect(result.componentTemplates).toEqual([mockComponentTemplate]);
-        });
-        it('should prompt user when no features provided', async () => {
-            const templateChoice = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const componentTemplates = [templateChoice];
-            const promptOptions = {};
-            mockedPromptUser.mockResolvedValue({
-                componentTemplates: [mockComponentTemplate],
-            });
-            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
-            expect(mockedPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'projectTemplate' }),
-                expect.objectContaining({
-                    name: 'componentTemplates',
-                    type: 'checkbox',
-                    choices: componentTemplates,
-                }),
-            ]);
-            expect(result.componentTemplates).toEqual([mockComponentTemplate]);
-        });
-        it('should handle empty componentTemplates selection', async () => {
-            const templateChoice = {
-                name: 'Test Module',
-                value: mockComponentTemplate,
-            };
-            const componentTemplates = [templateChoice];
-            const promptOptions = {
-                features: ['non-matching-feature'],
-            };
-            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
-            expect(result.componentTemplates).toEqual([]);
-        });
-    });
-});

package/lib/theme/__tests__/migrate.test.d.ts

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

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

@@ -1,247 +0,0 @@
-import { getProjectThemeDetails, migrateThemes, } from '@hubspot/project-parsing-lib/themes';
-import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { confirmPrompt } from '../../prompts/promptUtils.js';
-import { writeProjectConfig, } from '../../projects/config.js';
-import { ensureProjectExists } from '../../projects/ensureProjectExists.js';
-import { fetchMigrationApps } from '../../app/migrate.js';
-import { getHasMigratableThemes, validateMigrationAppsAndThemes, handleThemesMigration, migrateThemesV2, } from '../migrate.js';
-import { lib } from '../../../lang/en.js';
-vi.mock('@hubspot/project-parsing-lib/themes');
-vi.mock('../../prompts/promptUtils');
-vi.mock('../../projects/config');
-vi.mock('../../projects/ensureProjectExists');
-vi.mock('../../app/migrate');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../../ui/SpinniesManager', () => ({
-    default: {
-        init: vi.fn(),
-        add: vi.fn(),
-        succeed: vi.fn(),
-        fail: vi.fn(),
-        remove: vi.fn(),
-    },
-}));
-const mockedGetProjectThemeDetails = getProjectThemeDetails;
-const mockedMigrateThemes = migrateThemes;
-const mockedConfirmPrompt = confirmPrompt;
-const mockedWriteProjectConfig = writeProjectConfig;
-const mockedEnsureProjectExists = ensureProjectExists;
-const mockedFetchMigrationApps = fetchMigrationApps;
-const mockedGetConfigAccountById = getConfigAccountById;
-const ACCOUNT_ID = 123;
-const PROJECT_NAME = 'Test Project';
-const PLATFORM_VERSION = '2025.2';
-const MOCK_PROJECT_DIR = '/mock/project/dir';
-const createLoadedProjectConfig = (name) => ({
-    projectConfig: { name, srcDir: 'src', platformVersion: '2024.1' },
-    projectDir: MOCK_PROJECT_DIR,
-});
-describe('lib/theme/migrate', () => {
-    beforeEach(() => {
-        // Mock account config for the test account ID
-        mockedGetConfigAccountById.mockReturnValue({
-            accountId: ACCOUNT_ID,
-            name: 'Test Account',
-            authType: 'personalaccesskey',
-            auth: {
-                tokenInfo: {
-                    accessToken: 'test-token',
-                },
-            },
-            env: 'prod',
-        });
-    });
-    describe('getHasMigratableThemes', () => {
-        it('should return false when no projectConfig is provided', async () => {
-            const result = await getHasMigratableThemes();
-            expect(result).toEqual({
-                hasMigratableThemes: false,
-                migratableThemesCount: 0,
-            });
-        });
-        it('should return false when projectConfig is missing required properties', async () => {
-            const invalidProjectConfig = {
-                projectConfig: { name: undefined, srcDir: 'src' },
-                projectDir: undefined,
-            };
-            const result = await getHasMigratableThemes(invalidProjectConfig);
-            expect(result).toEqual({
-                hasMigratableThemes: false,
-                migratableThemesCount: 0,
-            });
-        });
-        it('should return true when there are legacy themes', async () => {
-            mockedGetProjectThemeDetails.mockResolvedValue({
-                legacyThemeDetails: [
-                    {
-                        configFilepath: 'src/theme.json',
-                        themePath: 'src/theme',
-                        themeConfig: {
-                            secret_names: ['my-secret'],
-                        },
-                    },
-                ],
-                legacyReactThemeDetails: [],
-            });
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            const result = await getHasMigratableThemes(projectConfig);
-            expect(result).toEqual({
-                hasMigratableThemes: true,
-                migratableThemesCount: 1,
-            });
-        });
-        it('should return true when there are legacy React themes', async () => {
-            mockedGetProjectThemeDetails.mockResolvedValue({
-                legacyThemeDetails: [],
-                legacyReactThemeDetails: [
-                    {
-                        configFilepath: 'src/react-theme.json',
-                        themePath: 'src/react-theme',
-                        themeConfig: {
-                            secretNames: ['my-secret'],
-                        },
-                    },
-                ],
-            });
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            const result = await getHasMigratableThemes(projectConfig);
-            expect(result).toEqual({
-                hasMigratableThemes: true,
-                migratableThemesCount: 1,
-            });
-        });
-        it('should return true when there are both legacy and React themes', async () => {
-            mockedGetProjectThemeDetails.mockResolvedValue({
-                legacyThemeDetails: [
-                    {
-                        configFilepath: 'src/theme.json',
-                        themePath: 'src/theme',
-                        themeConfig: {
-                            secret_names: ['my-secret'],
-                        },
-                    },
-                ],
-                legacyReactThemeDetails: [
-                    {
-                        configFilepath: 'src/react-theme.json',
-                        themePath: 'src/react-theme',
-                        themeConfig: {
-                            secretNames: ['my-secret'],
-                        },
-                    },
-                ],
-            });
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            const result = await getHasMigratableThemes(projectConfig);
-            expect(result).toEqual({
-                hasMigratableThemes: true,
-                migratableThemesCount: 2,
-            });
-        });
-    });
-    describe('validateMigrationAppsAndThemes', () => {
-        it('should throw an error when apps and themes are both present', async () => {
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            await expect(validateMigrationAppsAndThemes(1, projectConfig)).rejects.toThrow(lib.migrate.errors.project.themesAndAppsNotAllowed);
-        });
-        it('should throw an error when no project config is provided', async () => {
-            await expect(validateMigrationAppsAndThemes(0)).rejects.toThrow(lib.migrate.errors.project.noProjectForThemesMigration);
-        });
-        it('should not throw an error when validation passes', async () => {
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            await expect(validateMigrationAppsAndThemes(0, projectConfig)).resolves.not.toThrow();
-        });
-    });
-    describe('handleThemesMigration', () => {
-        const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-        beforeEach(() => {
-            mockedMigrateThemes.mockResolvedValue({
-                migrated: true,
-                failureReason: undefined,
-                legacyThemeDetails: [],
-                legacyReactThemeDetails: [],
-            });
-            mockedWriteProjectConfig.mockReturnValue(true);
-        });
-        it('should throw an error when project config is invalid', async () => {
-            const invalidProjectConfig = {
-                projectConfig: { name: PROJECT_NAME, srcDir: undefined },
-                projectDir: undefined,
-            };
-            await expect(handleThemesMigration(invalidProjectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.invalidConfig);
-        });
-        it('should successfully migrate themes and update project config', async () => {
-            await handleThemesMigration(projectConfig, PLATFORM_VERSION);
-            expect(mockedMigrateThemes).toHaveBeenCalledWith(MOCK_PROJECT_DIR, `${MOCK_PROJECT_DIR}/src`);
-            expect(mockedWriteProjectConfig).toHaveBeenCalledWith(`${MOCK_PROJECT_DIR}/hsproject.json`, expect.objectContaining({
-                platformVersion: PLATFORM_VERSION,
-            }));
-        });
-        it('should throw an error when theme migration fails', async () => {
-            mockedMigrateThemes.mockResolvedValue({
-                migrated: false,
-                failureReason: 'Migration failed',
-                legacyThemeDetails: [],
-                legacyReactThemeDetails: [],
-            });
-            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow('Migration failed');
-        });
-        it('should throw an error when project config write fails', async () => {
-            mockedWriteProjectConfig.mockReturnValue(false);
-            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.failedToUpdateProjectConfig);
-        });
-        it('should throw an error when migrateThemes throws an exception', async () => {
-            mockedMigrateThemes.mockRejectedValue(new Error('Unexpected error'));
-            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.failedToMigrateThemes);
-        });
-    });
-    describe('migrateThemesV2', () => {
-        const options = {
-            platformVersion: PLATFORM_VERSION,
-        };
-        const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-        const themeCount = 2;
-        beforeEach(() => {
-            mockedEnsureProjectExists.mockResolvedValue({ projectExists: true });
-            mockedFetchMigrationApps.mockResolvedValue({
-                migratableApps: [],
-                unmigratableApps: [],
-            });
-            mockedConfirmPrompt.mockResolvedValue(true);
-            mockedMigrateThemes.mockResolvedValue({
-                migrated: true,
-                failureReason: undefined,
-                legacyThemeDetails: [],
-                legacyReactThemeDetails: [],
-            });
-            mockedWriteProjectConfig.mockReturnValue(true);
-        });
-        it('should throw an error when project config is invalid', async () => {
-            const invalidProjectConfig = {
-                projectConfig: undefined,
-                projectDir: MOCK_PROJECT_DIR,
-            };
-            await expect(migrateThemesV2(ACCOUNT_ID, options, themeCount, invalidProjectConfig)).rejects.toThrow(lib.migrate.errors.project.invalidConfig);
-        });
-        it('should throw an error when project does not exist', async () => {
-            mockedEnsureProjectExists.mockResolvedValue({ projectExists: false });
-            await expect(migrateThemesV2(ACCOUNT_ID, options, themeCount, projectConfig)).rejects.toThrow(lib.migrate.errors.project.doesNotExist(ACCOUNT_ID));
-        });
-        it('should proceed with migration when user confirms', async () => {
-            await migrateThemesV2(ACCOUNT_ID, options, themeCount, projectConfig);
-            expect(mockedFetchMigrationApps).toHaveBeenCalledWith(ACCOUNT_ID, PLATFORM_VERSION, { projectConfig });
-            expect(mockedConfirmPrompt).toHaveBeenCalledWith(lib.migrate.prompt.proceed, { defaultAnswer: false });
-            expect(mockedMigrateThemes).toHaveBeenCalledWith(MOCK_PROJECT_DIR, `${MOCK_PROJECT_DIR}/src`);
-        });
-        it('should exit without migrating when user cancels', async () => {
-            mockedConfirmPrompt.mockResolvedValue(false);
-            await migrateThemesV2(ACCOUNT_ID, options, themeCount, projectConfig);
-            expect(mockedMigrateThemes).not.toHaveBeenCalled();
-        });
-        it('should validate migration apps and themes', async () => {
-            await migrateThemesV2(ACCOUNT_ID, options, themeCount, projectConfig);
-            // The validation is called internally, so we verify it through the error handling
-            expect(mockedFetchMigrationApps).toHaveBeenCalled();
-        });
-    });
-});

package/lib/ui/__tests__/SpinniesManager.test.d.ts

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