@hubspot/cli 8.1.0-beta.0 → 8.1.0-experimental.0

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

@@ -1,187 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createModulePrompt } from '../createModulePrompt.js';
-import { promptUser } from '../promptUtils.js';
-vi.mock('../promptUtils.js');
-const mockPromptUser = vi.mocked(promptUser);
-describe('createModulePrompt', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    describe('when all parameters are provided', () => {
-        it('should return provided values without prompting', async () => {
-            const commandArgs = {
-                moduleLabel: 'My Module',
-                reactType: true,
-                contentTypes: 'LANDING_PAGE,SITE_PAGE',
-                global: false,
-                availableForNewContent: true,
-            };
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                moduleLabel: 'My Module',
-                reactType: true,
-                contentTypes: ['LANDING_PAGE', 'SITE_PAGE'],
-                global: false,
-                availableForNewContent: true,
-            });
-        });
-        it('should use default values when optional parameters not provided', async () => {
-            const commandArgs = {
-                moduleLabel: 'My Module',
-            };
-            mockPromptUser.mockResolvedValue({
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: true,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'reactType' }),
-                expect.objectContaining({ name: 'contentTypes' }),
-                expect.objectContaining({ name: 'global' }),
-                expect.objectContaining({ name: 'availableForNewContent' }),
-            ]);
-            expect(result).toEqual({
-                moduleLabel: 'My Module',
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: true,
-            });
-        });
-        it('should parse contentTypes string correctly', async () => {
-            const commandArgs = {
-                moduleLabel: 'Test Module',
-                contentTypes: 'BLOG_POST, EMAIL, LANDING_PAGE',
-            };
-            mockPromptUser.mockResolvedValue({
-                reactType: false,
-                global: false,
-                availableForNewContent: true,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(result.contentTypes).toEqual([
-                'BLOG_POST',
-                'EMAIL',
-                'LANDING_PAGE',
-            ]);
-        });
-    });
-    describe('when some parameters are missing', () => {
-        it('should only prompt for missing parameters', async () => {
-            const commandArgs = {
-                moduleLabel: 'My Module',
-                reactType: true,
-            };
-            mockPromptUser.mockResolvedValue({
-                contentTypes: ['SITE_PAGE'],
-                global: true,
-                availableForNewContent: false,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'contentTypes' }),
-                expect.objectContaining({ name: 'global' }),
-                expect.objectContaining({ name: 'availableForNewContent' }),
-            ]);
-            expect(result).toEqual({
-                moduleLabel: 'My Module',
-                reactType: true,
-                contentTypes: ['SITE_PAGE'],
-                global: true,
-                availableForNewContent: false,
-            });
-        });
-    });
-    describe('when no parameters are provided', () => {
-        it('should prompt for all parameters', async () => {
-            mockPromptUser.mockResolvedValue({
-                moduleLabel: 'Prompted Module',
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: true,
-            });
-            const result = await createModulePrompt();
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'moduleLabel' }),
-                expect.objectContaining({ name: 'reactType' }),
-                expect.objectContaining({ name: 'contentTypes' }),
-                expect.objectContaining({ name: 'global' }),
-                expect.objectContaining({ name: 'availableForNewContent' }),
-            ]);
-            expect(result).toEqual({
-                moduleLabel: 'Prompted Module',
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: true,
-            });
-        });
-    });
-    describe('parameter precedence', () => {
-        it('should prioritize command args over prompted values', async () => {
-            const commandArgs = {
-                moduleLabel: 'Args Module',
-                global: true,
-            };
-            mockPromptUser.mockResolvedValue({
-                reactType: false,
-                contentTypes: ['EMAIL'],
-                availableForNewContent: false,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(result).toEqual({
-                moduleLabel: 'Args Module', // from commandArgs
-                reactType: false, // from prompt
-                contentTypes: ['EMAIL'], // from prompt
-                global: true, // from commandArgs
-                availableForNewContent: false, // from prompt
-            });
-        });
-        it('should handle boolean false values correctly', async () => {
-            const commandArgs = {
-                moduleLabel: 'Test Module',
-                reactType: false,
-                contentTypes: 'ANY',
-                global: false,
-                availableForNewContent: false,
-            };
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                moduleLabel: 'Test Module',
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: false,
-            });
-        });
-        it('should handle mixed scenario with partial command args and prompting', async () => {
-            const commandArgs = {
-                moduleLabel: 'Partial Module',
-                contentTypes: 'BLOG_POST,BLOG_LISTING',
-            };
-            mockPromptUser.mockResolvedValue({
-                reactType: true,
-                global: false,
-                availableForNewContent: true,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'reactType' }),
-                expect.objectContaining({ name: 'global' }),
-                expect.objectContaining({ name: 'availableForNewContent' }),
-            ]);
-            expect(result).toEqual({
-                moduleLabel: 'Partial Module', // from commandArgs
-                reactType: true, // from prompt
-                contentTypes: ['BLOG_POST', 'BLOG_LISTING'], // from commandArgs (parsed)
-                global: false, // from prompt
-                availableForNewContent: true, // from prompt
-            });
-        });
-    });
-});

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

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

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

@@ -1,102 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createTemplatePrompt } from '../createTemplatePrompt.js';
-import { promptUser } from '../promptUtils.js';
-vi.mock('../promptUtils.js');
-const mockPromptUser = vi.mocked(promptUser);
-describe('createTemplatePrompt', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    describe('when templateType is provided', () => {
-        it('should return provided templateType without prompting', async () => {
-            const commandArgs = {
-                templateType: 'page-template',
-            };
-            const result = await createTemplatePrompt(commandArgs);
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                templateType: 'page-template',
-            });
-        });
-        it('should work with different template types', async () => {
-            const testCases = [
-                'email-template',
-                'partial',
-                'global-partial',
-                'blog-listing-template',
-                'blog-post-template',
-                'search-template',
-                'section',
-            ];
-            for (const templateType of testCases) {
-                const commandArgs = { templateType };
-                const result = await createTemplatePrompt(commandArgs);
-                expect(mockPromptUser).not.toHaveBeenCalled();
-                expect(result).toEqual({ templateType });
-                vi.resetAllMocks();
-            }
-        });
-    });
-    describe('when templateType is not provided', () => {
-        it('should prompt for templateType', async () => {
-            mockPromptUser.mockResolvedValue({
-                templateType: 'page-template',
-            });
-            const result = await createTemplatePrompt();
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    name: 'templateType',
-                    type: 'list',
-                    choices: expect.any(Array),
-                }),
-            ]);
-            expect(result).toEqual({
-                templateType: 'page-template',
-            });
-        });
-        it('should prompt when commandArgs is empty', async () => {
-            mockPromptUser.mockResolvedValue({
-                templateType: 'email-template',
-            });
-            const result = await createTemplatePrompt({});
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'templateType' }),
-            ]);
-            expect(result).toEqual({
-                templateType: 'email-template',
-            });
-        });
-        it('should prompt when templateType is undefined', async () => {
-            const commandArgs = {
-                templateType: undefined,
-            };
-            mockPromptUser.mockResolvedValue({
-                templateType: 'partial',
-            });
-            const result = await createTemplatePrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'templateType' }),
-            ]);
-            expect(result).toEqual({
-                templateType: 'partial',
-            });
-        });
-    });
-    describe('integration scenarios', () => {
-        it('should handle mixed usage patterns', async () => {
-            // First call with templateType provided
-            let result = await createTemplatePrompt({
-                templateType: 'blog-post-template',
-            });
-            expect(result.templateType).toBe('blog-post-template');
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            // Second call without templateType
-            mockPromptUser.mockResolvedValue({
-                templateType: 'section',
-            });
-            result = await createTemplatePrompt();
-            expect(result.templateType).toBe('section');
-            expect(mockPromptUser).toHaveBeenCalledTimes(1);
-        });
-    });
-});

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

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

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

@@ -1,31 +0,0 @@
-import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { fetchProjects } from '@hubspot/local-dev-lib/api/projects';
-import { downloadProjectPrompt } from '../downloadProjectPrompt.js';
-vi.mock('../promptUtils', () => ({
-    promptUser: vi.fn().mockResolvedValue({ project: 'test-project' }),
-}));
-vi.mock('@hubspot/local-dev-lib/api/projects', () => ({
-    fetchProjects: vi.fn().mockResolvedValue({
-        data: { results: [] },
-    }),
-}));
-vi.mock('@hubspot/local-dev-lib/config', () => ({
-    getConfigAccountIfExists: vi
-        .fn()
-        .mockImplementation(() => ({ accountId: 123456789 })),
-    globalConfigFileExists: vi.fn().mockReturnValue(true),
-}));
-describe('lib/prompts/downloadProjectPrompt', () => {
-    it('should honor the account passed as an option', async () => {
-        const account = 'Prod';
-        await downloadProjectPrompt({ account });
-        expect(getConfigAccountIfExists).toHaveBeenCalledTimes(1);
-        expect(getConfigAccountIfExists).toHaveBeenCalledWith(account);
-    });
-    it('should fetch the projects for the correct accountId', async () => {
-        const account = 'Prod';
-        await downloadProjectPrompt({ account });
-        expect(fetchProjects).toHaveBeenCalledTimes(1);
-        expect(fetchProjects).toHaveBeenCalledWith(123456789);
-    });
-});

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

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

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([]);
-        });
-    });
-});