@hubspot/cli 7.6.0-beta.1 → 7.6.0-beta.11

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

@@ -0,0 +1,189 @@
+import { ProjectLogsManager } from '../ProjectLogsManager.js';
+import { getProjectConfig } from '../config.js';
+import { ensureProjectExists } from '../ensureProjectExists.js';
+import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
+const SUBCOMPONENT_TYPES = {
+    APP_ID: 'APP_ID',
+    PACKAGE_LOCK_FILE: 'PACKAGE_LOCK_FILE',
+    CRM_CARD_V2: 'CRM_CARD_V2',
+    CARD_V2: 'CARD_V2',
+    SERVERLESS_PKG: 'SERVERLESS_PKG',
+    SERVERLESS_ROUTE: 'SERVERLESS_ROUTE',
+    SERVERLESS_FUNCTION: 'SERVERLESS_FUNCTION',
+    APP_FUNCTION: 'APP_FUNCTION',
+    AUTOMATION_ACTION: 'AUTOMATION_ACTION',
+    REACT_EXTENSION: 'REACT_EXTENSION',
+};
+vi.mock('../../projects/config');
+vi.mock('../../projects/ensureProjectExists');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+describe('lib/projects/ProjectLogsManager', () => {
+    const accountId = 12345678;
+    const appId = 999999;
+    const projectName = 'super cool test project';
+    const projectConfig = { projectConfig: { name: projectName } };
+    const projectId = 987654321;
+    const projectDetails = {
+        project: {
+            id: projectId,
+            deployedBuild: {
+                subbuildStatuses: {},
+            },
+        },
+    };
+    const function1 = {
+        componentName: 'function1',
+        type: {
+            name: SUBCOMPONENT_TYPES.APP_FUNCTION,
+        },
+        deployOutput: {
+            appId,
+            appFunctionName: 'function1',
+        },
+    };
+    const functions = [
+        function1,
+        {
+            componentName: 'function2',
+            type: {
+                name: SUBCOMPONENT_TYPES.APP_FUNCTION,
+            },
+            deployOutput: {
+                appId,
+                appFunctionName: 'function2',
+            },
+        },
+    ];
+    beforeEach(() => {
+        ProjectLogsManager.reset();
+        getProjectConfig.mockResolvedValue(projectConfig);
+        ensureProjectExists.mockResolvedValue(projectDetails);
+        fetchProjectComponentsMetadata.mockResolvedValue({
+            data: {
+                topLevelComponentMetadata: [
+                    {
+                        type: {
+                            name: 'PRIVATE_APP',
+                        },
+                        deployOutput: {
+                            appId,
+                        },
+                        featureComponents: [
+                            ...functions,
+                            {
+                                type: {
+                                    name: 'NOT_AN_APP_FUNCTION',
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+    });
+    describe('init', () => {
+        it('should load the project config', async () => {
+            await ProjectLogsManager.init(accountId);
+            expect(getProjectConfig).toHaveBeenCalledTimes(1);
+        });
+        it('should throw an error if there is a problem with the config', async () => {
+            getProjectConfig.mockResolvedValue({});
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow('No project detected. Run this command again from a project directory.');
+            expect(getProjectConfig).toHaveBeenCalledTimes(1);
+        });
+        it('should ensure the project exists', async () => {
+            await ProjectLogsManager.init(accountId);
+            expect(ensureProjectExists).toHaveBeenCalledTimes(1);
+            expect(ensureProjectExists).toHaveBeenCalledWith(accountId, projectName, {
+                allowCreate: false,
+            });
+        });
+        it('should throw an error if there is data missing from the project details', async () => {
+            ensureProjectExists.mockResolvedValue({});
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There was an error fetching project details/);
+        });
+        it('should set all of the expected fields correctly', async () => {
+            await ProjectLogsManager.init(accountId);
+            expect(ProjectLogsManager.projectId).toEqual(projectId);
+            expect(ProjectLogsManager.projectName).toEqual(projectName);
+            expect(ProjectLogsManager.accountId).toEqual(accountId);
+            expect(ProjectLogsManager.functions).toEqual(functions);
+        });
+    });
+    describe('fetchFunctionDetails', () => {
+        it('should throw an error if the projectId is null when the method is called', async () => {
+            await expect(async () => ProjectLogsManager.fetchFunctionDetails()).rejects.toThrow('No project detected. Run this command again from a project directory.');
+        });
+        it('should fetch the component metadata', async () => {
+            ProjectLogsManager.projectId = projectId;
+            ProjectLogsManager.accountId = accountId;
+            await ProjectLogsManager.fetchFunctionDetails();
+            expect(fetchProjectComponentsMetadata).toHaveBeenCalledTimes(1);
+            expect(fetchProjectComponentsMetadata).toHaveBeenCalledWith(accountId, projectId);
+        });
+        it('should set the functions correctly', async () => {
+            ProjectLogsManager.projectId = projectId;
+            ProjectLogsManager.accountId = accountId;
+            await ProjectLogsManager.fetchFunctionDetails();
+            expect(ProjectLogsManager.functions).toEqual(functions);
+        });
+    });
+    describe('getFunctionNames', () => {
+        it('should return an empty array if functions is empty', async () => {
+            ProjectLogsManager.functions = [];
+            expect(ProjectLogsManager.getFunctionNames()).toEqual([]);
+        });
+        it('should return an array of the componentNames', async () => {
+            ProjectLogsManager.functions = functions;
+            expect(ProjectLogsManager.getFunctionNames()).toEqual([
+                'function1',
+                'function2',
+            ]);
+        });
+    });
+    describe('setFunction', () => {
+        it('should throw an error when functions is empty', async () => {
+            ProjectLogsManager.functions = [];
+            expect(() => ProjectLogsManager.setFunction('foo')).toThrow(`There aren't any functions in this project`);
+        });
+        it('should throw an error when the provided function is invalid', async () => {
+            ProjectLogsManager.functions = functions;
+            const badName = 'foo';
+            expect(() => ProjectLogsManager.setFunction(badName)).toThrow(`No function with name "${badName}"`);
+        });
+        it('should set the data correctly for public functions', async () => {
+            const functionToChoose = {
+                componentName: 'function1',
+                type: {
+                    name: SUBCOMPONENT_TYPES.APP_FUNCTION,
+                },
+                deployOutput: {
+                    appId: 123,
+                    appFunctionName: 'function1',
+                    endpoint: { path: 'yooooooo', methods: ['GET'] },
+                },
+            };
+            ProjectLogsManager.functions = [functionToChoose];
+            ProjectLogsManager.setFunction('function1');
+            expect(ProjectLogsManager.functionName).toEqual('function1');
+            expect(ProjectLogsManager.endpointName).toEqual('yooooooo');
+            expect(ProjectLogsManager.selectedFunction).toEqual(functionToChoose);
+            expect(ProjectLogsManager.isPublicFunction).toEqual(true);
+        });
+        it('should set the data correctly for public functions', async () => {
+            ProjectLogsManager.functions = functions;
+            ProjectLogsManager.setFunction('function1');
+            expect(ProjectLogsManager.selectedFunction).toEqual(function1);
+            expect(ProjectLogsManager.functionName).toEqual('function1');
+            expect(ProjectLogsManager.isPublicFunction).toEqual(false);
+        });
+    });
+    describe('reset', () => {
+        it('should reset all the values', async () => {
+            ProjectLogsManager.projectName = 'value';
+            expect(ProjectLogsManager.projectName).toBeDefined();
+            ProjectLogsManager.reset();
+            expect(ProjectLogsManager.projectName).toBeUndefined();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,23 @@
+import { useV3Api } from '../buildAndDeploy.js';
+describe('buildAndDeploy', () => {
+    describe('useV3Api', () => {
+        it('returns true if platform version is UNSTABLE', () => {
+            expect(useV3Api('UNSTABLE')).toBe(true);
+        });
+        it('returns true if platform version is equal to the minimum', () => {
+            expect(useV3Api('2025.2')).toBe(true);
+        });
+        it('returns true if platform version is greater than the minimum', () => {
+            expect(useV3Api('2026.2')).toBe(true);
+        });
+        it('returns false if platform version is less than the minimum', () => {
+            expect(useV3Api('2025.0')).toBe(false);
+        });
+        it('returns false if platform version is invalid', () => {
+            expect(useV3Api(null)).toBe(false);
+        });
+        it('returns false for an invalid platform version', () => {
+            expect(useV3Api('notplaformversion')).toBe(false);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,181 @@
+import fs from 'fs';
+import { handleComponentCollision } from '../components.js';
+vi.mock('fs');
+const mockedFs = vi.mocked(fs);
+describe('lib/projects/components', () => {
+    describe('handleComponentCollision()', () => {
+        const mockCollision = {
+            dest: '/dest/path',
+            src: '/src/path',
+            collisions: [],
+        };
+        beforeEach(() => {
+            vi.resetAllMocks();
+            // Mock Date.now to return consistent values for testing
+            vi.spyOn(Date, 'now').mockReturnValue(1234567890);
+        });
+        afterEach(() => {
+            vi.restoreAllMocks();
+        });
+        it('handles source file collisions by renaming them with timestamps', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: ['component.js', 'utils.ts'],
+            };
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            handleComponentCollision(collision);
+            expect(mockedFs.copyFileSync).toHaveBeenCalledTimes(2);
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', '/dest/path/component-1234567890.js');
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/utils.ts', '/dest/path/utils-1234567890.ts');
+        });
+        it('handles metafile collisions by renaming and updating references', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: ['component.module.meta.json', 'source.js'],
+            };
+            const mockMetaContent = JSON.stringify({
+                file: 'source.js',
+                label: 'Test Component',
+            });
+            mockedFs.readFileSync.mockReturnValue(mockMetaContent);
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            // Mock metafileExtension
+            Object.defineProperty(require('@hubspot/project-parsing-lib'), 'metafileExtension', {
+                value: '.module.meta.json',
+                writable: false,
+            });
+            handleComponentCollision(collision);
+            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/component.module.meta.json', 'utf-8');
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/component-1234567890.module.meta.json', expect.stringContaining('source-1234567890.js'));
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/source.js', '/dest/path/source-1234567890.js');
+        });
+        it('handles package.json collisions by merging dependencies', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: ['package.json'],
+            };
+            const existingPackageJson = {
+                name: 'existing-package',
+                dependencies: {
+                    existing: '1.0.0',
+                    shared: '1.0.0',
+                },
+                devDependencies: {
+                    'existing-dev': '1.0.0',
+                },
+            };
+            const newPackageJson = {
+                name: 'new-package',
+                dependencies: {
+                    new: '2.0.0',
+                    shared: '2.0.0',
+                },
+                devDependencies: {
+                    'new-dev': '2.0.0',
+                    'existing-dev': '2.0.0',
+                },
+            };
+            mockedFs.readFileSync
+                .mockReturnValueOnce(JSON.stringify(existingPackageJson))
+                .mockReturnValueOnce(JSON.stringify(newPackageJson));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            // Mock console.log to avoid output during tests
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            handleComponentCollision(collision);
+            const expectedMergedPackageJson = {
+                name: 'existing-package',
+                dependencies: {
+                    new: '2.0.0',
+                    shared: '1.0.0',
+                    existing: '1.0.0',
+                },
+                devDependencies: {
+                    'new-dev': '2.0.0',
+                    'existing-dev': '1.0.0',
+                },
+            };
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/package.json', JSON.stringify(expectedMergedPackageJson, null, 2));
+            consoleSpy.mockRestore();
+        });
+        it('handles mixed collision types (source files, metafiles, and package.json)', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: [
+                    'component.js',
+                    'component.module.meta.json',
+                    'package.json',
+                    'utils.ts',
+                ],
+            };
+            const mockMetaContent = JSON.stringify({
+                file: 'component.js',
+                label: 'Test Component',
+            });
+            const existingPackageJson = { name: 'existing' };
+            const newPackageJson = { name: 'new', dependencies: { test: '1.0.0' } };
+            mockedFs.readFileSync
+                .mockReturnValueOnce(mockMetaContent)
+                .mockReturnValueOnce(JSON.stringify(existingPackageJson))
+                .mockReturnValueOnce(JSON.stringify(newPackageJson));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            // Mock metafileExtension
+            Object.defineProperty(require('@hubspot/project-parsing-lib'), 'metafileExtension', {
+                value: '.module.meta.json',
+                writable: false,
+            });
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            handleComponentCollision(collision);
+            // Verify source files are copied with new names
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', '/dest/path/component-1234567890.js');
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/utils.ts', '/dest/path/utils-1234567890.ts');
+            // Verify metafile is updated and written with new name
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/component-1234567890.module.meta.json', expect.stringContaining('component-1234567890.js'));
+            // Verify package.json is merged
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/package.json', expect.stringContaining('"dependencies"'));
+            consoleSpy.mockRestore();
+        });
+        it('handles empty collisions array gracefully', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: [],
+            };
+            handleComponentCollision(collision);
+            expect(mockedFs.copyFileSync).not.toHaveBeenCalled();
+            expect(mockedFs.readFileSync).not.toHaveBeenCalled();
+            expect(mockedFs.writeFileSync).not.toHaveBeenCalled();
+        });
+        it('correctly categorizes different file types', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: [
+                    'regular.js',
+                    'nested/path/file.ts',
+                    'component.module.meta.json',
+                    'another.meta.json',
+                    'package.json',
+                    'nested/package.json',
+                ],
+            };
+            // Mock metafileExtension
+            Object.defineProperty(require('@hubspot/project-parsing-lib'), 'metafileExtension', {
+                value: '.meta.json',
+                writable: false,
+            });
+            const mockMetaContent = '{}';
+            mockedFs.readFileSync.mockReturnValue(mockMetaContent);
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            // Mock console.log for package.json handling
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            handleComponentCollision(collision);
+            // Should copy 2 source files
+            expect(mockedFs.copyFileSync).toHaveBeenCalledTimes(2);
+            // Should handle 2 metafiles
+            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/component.module.meta.json', 'utf-8');
+            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/another.meta.json', 'utf-8');
+            consoleSpy.mockRestore();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,118 @@
+import fs from 'fs-extra';
+import os from 'os';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { downloadProject } from '@hubspot/local-dev-lib/api/projects';
+import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
+import { isDeepEqual } from '@hubspot/local-dev-lib/isDeepEqual';
+import { translate } from '@hubspot/project-parsing-lib';
+import { isDeployedProjectUpToDateWithLocal } from '../localDev/helpers/project.js';
+// Mock all external dependencies
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/archive');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('@hubspot/local-dev-lib/isDeepEqual');
+vi.mock('fs-extra');
+vi.mock('os');
+vi.mock('../../utils/isDeepEqual.js');
+describe('isDeployedProjectUpToDateWithLocal', () => {
+    const mockProjectName = 'test-project';
+    const mockAccountId = 123456;
+    const mockBuildId = 789;
+    const mockProjectConfig = {
+        name: mockProjectName,
+        srcDir: 'src',
+        platformVersion: '1.0.0',
+    };
+    const mockLocalNode = {
+        uid: 'component1',
+        componentType: 'APP',
+        localDev: {
+            componentRoot: '/local/path',
+            componentConfigPath: '/local/path/config.json',
+            configUpdatedSinceLastUpload: false,
+        },
+        componentDeps: {},
+        metaFilePath: '/local/path',
+        config: { name: 'Component 1' },
+        files: [],
+    };
+    const mockLocalProjectNodes = {
+        component1: mockLocalNode,
+    };
+    const mockTempDir = '/tmp/test-temp-dir';
+    const mockZippedProject = Buffer.from('fake-zip-data');
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock fs.mkdtemp
+        fs.mkdtemp.mockResolvedValue(mockTempDir);
+        // Mock fs.pathExists
+        fs.pathExists.mockResolvedValue(true);
+        // Mock fs.remove
+        fs.remove.mockResolvedValue(undefined);
+        // Mock os.tmpdir
+        os.tmpdir.mockReturnValue('/tmp');
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('when projects are identical', () => {
+        it('should return true for identical projects', async () => {
+            // Mock downloadProject
+            downloadProject.mockResolvedValue({
+                data: mockZippedProject,
+            });
+            // Mock extractZipArchive
+            extractZipArchive.mockResolvedValue(undefined);
+            // Mock translate to return identical nodes
+            translate.mockResolvedValue({
+                intermediateNodesIndexedByUid: mockLocalProjectNodes,
+            });
+            // Mock isDeepEqual to return true for identical projects
+            isDeepEqual.mockReturnValue(true);
+            const result = await isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes);
+            expect(result).toBe(true);
+            expect(isDeepEqual).toHaveBeenCalledWith(mockLocalProjectNodes, mockLocalProjectNodes, ['localDev']);
+            expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
+        });
+    });
+    describe('when projects are different', () => {
+        it('should return false for different projects', async () => {
+            // Mock downloadProject
+            downloadProject.mockResolvedValue({
+                data: mockZippedProject,
+            });
+            // Mock extractZipArchive
+            extractZipArchive.mockResolvedValue(undefined);
+            // Mock translate to return different nodes
+            const differentDeployedNodes = {};
+            translate.mockResolvedValue({
+                intermediateNodesIndexedByUid: differentDeployedNodes,
+            });
+            // Mock isDeepEqual to return false for different projects
+            isDeepEqual.mockReturnValue(false);
+            const result = await isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes);
+            expect(result).toBe(false);
+            expect(isDeepEqual).toHaveBeenCalledWith(mockLocalProjectNodes, differentDeployedNodes, ['localDev']);
+        });
+    });
+    describe('error handling', () => {
+        it('should clean up temp directory even when errors occur', async () => {
+            // Mock downloadProject to throw an error after temp dir is created
+            downloadProject.mockRejectedValue(new Error('Download Error'));
+            await expect(isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes)).rejects.toThrow('Download Error');
+            expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
+        });
+        it('should handle translateForLocalDev errors', async () => {
+            // Mock downloadProject
+            downloadProject.mockResolvedValue({
+                data: mockZippedProject,
+            });
+            // Mock extractZipArchive
+            extractZipArchive.mockResolvedValue(undefined);
+            // Mock translate to throw an error
+            translate.mockRejectedValue(new Error('Translation Error'));
+            await expect(isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes)).rejects.toThrow('Translation Error');
+            expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,84 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { validateProjectConfig } from '../../projects/config.js';
+import { logger } from '@hubspot/local-dev-lib/logger';
+vi.mock('@hubspot/local-dev-lib/logger');
+describe('lib/projects', () => {
+    describe('validateProjectConfig()', () => {
+        let projectDir;
+        let exitMock;
+        beforeAll(() => {
+            projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'projects-'));
+            fs.mkdirSync(path.join(projectDir, 'src'));
+        });
+        beforeEach(() => {
+            // @ts-expect-error - Mocking process.exit
+            exitMock = vi
+                .spyOn(process, 'exit')
+                .mockImplementation(() => undefined);
+        });
+        afterEach(() => {
+            exitMock.mockRestore();
+        });
+        it('rejects undefined configuration', () => {
+            // @ts-ignore Testing invalid input
+            validateProjectConfig(null, projectDir);
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*Unable to locate a project configuration file. Try running again from a project directory, or run*/));
+        });
+        it('rejects configuration with missing name', () => {
+            // @ts-ignore Testing invalid input
+            validateProjectConfig({ srcDir: '.' }, projectDir);
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields*/));
+        });
+        it('rejects configuration with missing srcDir', () => {
+            // @ts-ignore Testing invalid input
+            validateProjectConfig({ name: 'hello' }, projectDir);
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields.*/));
+        });
+        describe('rejects configuration with srcDir outside project directory', () => {
+            it('for parent directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: '..', platformVersion: '' }, projectDir);
+                expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: ".."'));
+            });
+            it('for root directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: '/', platformVersion: '' }, projectDir);
+                expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: "/"'));
+            });
+            it('for complicated directory', () => {
+                const srcDir = './src/././../src/../../src';
+                validateProjectConfig({ name: 'hello', srcDir, platformVersion: '' }, projectDir);
+                expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining(`srcDir: "${srcDir}"`));
+            });
+        });
+        it('rejects configuration with srcDir that does not exist', () => {
+            validateProjectConfig({ name: 'hello', srcDir: 'foo', platformVersion: '' }, projectDir);
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*could not be found in.*/));
+        });
+        describe('accepts configuration with valid srcDir', () => {
+            it('for current directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: '.', platformVersion: '' }, projectDir);
+                expect(exitMock).not.toHaveBeenCalled();
+                expect(logger.error).not.toHaveBeenCalled();
+            });
+            it('for relative directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: './src', platformVersion: '' }, projectDir);
+                expect(exitMock).not.toHaveBeenCalled();
+                expect(logger.error).not.toHaveBeenCalled();
+            });
+            it('for implied relative directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: 'src', platformVersion: '' }, projectDir);
+                expect(exitMock).not.toHaveBeenCalled();
+                expect(logger.error).not.toHaveBeenCalled();
+            });
+        });
+    });
+});

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

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