@sfdc-webapps/cli 1.0.2

package/test/unit/new-app.spec.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { newAppOrFeatureCommand } from '../../src/commands/new-app-feature.js';
+import { ValidationError } from '../../src/utils/validation.js';
+import { rmSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+// Note: These tests run against the actual monorepo structure
+// They create real apps in packages/ directory and clean them up after
+describe('new-app command', () => {
+  let testAppNames: string[] = [];
+  let monorepoRoot: string;
+
+  beforeEach(() => {
+    // Track app names created during tests for cleanup
+    testAppNames = [];
+    monorepoRoot = process.cwd().includes('/packages/cli')
+      ? join(process.cwd(), '../..')
+      : process.cwd();
+  });
+
+  afterEach(() => {
+    // Clean up any test apps that were created
+    for (const appName of testAppNames) {
+      const appPath = join(monorepoRoot, 'packages', appName);
+      if (existsSync(appPath)) {
+        rmSync(appPath, { recursive: true, force: true });
+      }
+    }
+  });
+
+  describe('validation', () => {
+    it('should reject invalid app names', async () => {
+      await expect(newAppOrFeatureCommand('Invalid_Name', 'app')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('Invalid_Name', 'app')).rejects.toThrow(/invalid.*kebab-case/);
+    });
+
+    it('should reject empty app names', async () => {
+      await expect(newAppOrFeatureCommand('', 'app')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('', 'app')).rejects.toThrow(/cannot be empty/);
+    });
+
+    it('should reject reserved names', async () => {
+      await expect(newAppOrFeatureCommand('app', 'app')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('app', 'app')).rejects.toThrow(/reserved/);
+
+      await expect(newAppOrFeatureCommand('feature', 'app')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('feature', 'app')).rejects.toThrow(/reserved/);
+    });
+
+    it('should reject if app already exists', async () => {
+      // Use an existing app (navigation-menu) which should already exist
+      await expect(newAppOrFeatureCommand('vibe-coding-starter', 'app')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('vibe-coding-starter', 'app')).rejects.toThrow(/already exists/);
+    });
+
+    it('should reject names that are too long', async () => {
+      const tooLongName = 'a'.repeat(51);
+      await expect(newAppOrFeatureCommand(tooLongName, 'app')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand(tooLongName, 'app')).rejects.toThrow(/too long/);
+    });
+  });
+
+  describe('app creation', () => {
+    it('should create app directory with all required files', async () => {
+      const testName = `test-unit-${Date.now()}`;
+      testAppNames.push(`app-${testName}`);
+
+      await newAppOrFeatureCommand(testName, 'app');
+
+      const appPath = join(monorepoRoot, 'packages', `app-${testName}`);
+
+      // Check directory and files exist
+      expect(existsSync(appPath)).toBe(true);
+      expect(existsSync(join(appPath, 'package.json'))).toBe(true);
+      expect(existsSync(join(appPath, 'feature.ts'))).toBe(true);
+      expect(existsSync(join(appPath, 'tsconfig.app.json'))).toBe(true);
+      expect(existsSync(join(appPath, 'template'))).toBe(true);
+    });
+
+    it('should update package.json with correct name and scripts', async () => {
+      const testName = `test-pkgjson-${Date.now()}`;
+      testAppNames.push(`app-${testName}`);
+
+      await newAppOrFeatureCommand(testName, 'app');
+
+      const appPath = join(monorepoRoot, 'packages', `app-${testName}`);
+      const packageJson = JSON.parse(readFileSync(join(appPath, 'package.json'), 'utf-8'));
+
+      // Check name
+      expect(packageJson.name).toBe(`app-${testName}`);
+
+      // Check scripts are updated
+      expect(packageJson.scripts.dev).toContain(`app-${testName}`);
+      expect(packageJson.scripts.dev).not.toContain('base-reference-app');
+    });
+
+    // it('should update tsconfig.app.json include path', async () => {
+    //   const testName = `test-tsconfig-${Date.now()}`;
+    //   testFeatureNames.push(`feature-${testName}`);
+
+    //   await newFeatureCommand(testName);
+
+    //   const featurePath = join(monorepoRoot, 'packages', `feature-${testName}`);
+    //   const tsconfigContent = readFileSync(join(featurePath, 'tsconfig.app.json'), 'utf-8');
+
+    //   // Should contain the new path
+    //   expect(tsconfigContent).toContain(`template/digitalExperiences/webApplications/${testName}`);
+
+    //   // Should not contain base-feature
+    //   expect(tsconfigContent).not.toContain('base-feature');
+    // });
+
+    it('should auto-prefix app name with "app-"', async () => {
+      const testName = `autoprefix-${Date.now()}`;
+      testAppNames.push(`app-${testName}`);
+
+      await newAppOrFeatureCommand(testName, 'app');
+
+      const appPath = join(monorepoRoot, 'packages', `app-${testName}`);
+      expect(existsSync(appPath)).toBe(true);
+
+      const packageJson = JSON.parse(readFileSync(join(appPath, 'package.json'), 'utf-8'));
+      expect(packageJson.name).toBe(`app-${testName}`);
+    });
+
+    it('should not double-prefix if name already starts with "app-"', async () => {
+      const testName = `doubleprefix-${Date.now()}`;
+      testAppNames.push(`app-${testName}`);
+
+      await newAppOrFeatureCommand(`app-${testName}`, 'app');
+
+      const appPath = join(monorepoRoot, 'packages', `app-${testName}`);
+      expect(existsSync(appPath)).toBe(true);
+
+      // Should not create app-app-{testName}
+      const wrongPath = join(monorepoRoot, 'packages', `app-app-${testName}`);
+      expect(existsSync(wrongPath)).toBe(false);
+    });
+
+    it('should handle hyphenated app names', async () => {
+      const testName = `user-auth-${Date.now()}`;
+      testAppNames.push(`app-${testName}`);
+
+      await newAppOrFeatureCommand(testName, 'app');
+
+      const appPath = join(monorepoRoot, 'packages', `app-${testName}`);
+      expect(existsSync(appPath)).toBe(true);
+
+      const packageJson = JSON.parse(readFileSync(join(appPath, 'package.json'), 'utf-8'));
+      expect(packageJson.name).toBe(`app-${testName}`);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw ValidationError for duplicate app', async () => {
+      const testName = `duplicate-${Date.now()}`;
+      testAppNames.push(`app-${testName}`);
+
+      // Create first app
+      await newAppOrFeatureCommand(testName, 'app');
+
+      // Try to create again with same name
+      await expect(newAppOrFeatureCommand(testName, 'app')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand(testName, 'app')).rejects.toThrow(/already exists/);
+    });
+
+    it('should provide clear error messages', async () => {
+      try {
+        await newAppOrFeatureCommand('Invalid_Name', 'app');
+        expect.fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(ValidationError);
+        expect((err as Error).message).toContain('invalid');
+        expect((err as Error).message).toContain('Examples:');
+      }
+    });
+  });
+});

package/test/unit/new-feature.spec.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { newAppOrFeatureCommand } from '../../src/commands/new-app-feature.js';
+import { ValidationError } from '../../src/utils/validation.js';
+import { rmSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+// Note: These tests run against the actual monorepo structure
+// They create real features in packages/ directory and clean them up after
+describe('new-feature command', () => {
+  let testFeatureNames: string[] = [];
+  let monorepoRoot: string;
+
+  beforeEach(() => {
+    // Track feature names created during tests for cleanup
+    testFeatureNames = [];
+    monorepoRoot = process.cwd().includes('/packages/cli')
+      ? join(process.cwd(), '../..')
+      : process.cwd();
+  });
+
+  afterEach(() => {
+    // Clean up any test features that were created
+    for (const featureName of testFeatureNames) {
+      const featurePath = join(monorepoRoot, 'packages', featureName);
+      if (existsSync(featurePath)) {
+        rmSync(featurePath, { recursive: true, force: true });
+      }
+    }
+  });
+
+  describe('validation', () => {
+    it('should reject invalid feature names', async () => {
+      await expect(newAppOrFeatureCommand('Invalid_Name', 'feature')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('Invalid_Name', 'feature')).rejects.toThrow(/invalid.*kebab-case/);
+    });
+
+    it('should reject empty feature names', async () => {
+      await expect(newAppOrFeatureCommand('', 'feature')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('', 'feature')).rejects.toThrow(/cannot be empty/);
+    });
+
+    it('should reject reserved names', async () => {
+      await expect(newAppOrFeatureCommand('app', 'feature')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('app', 'feature')).rejects.toThrow(/reserved/);
+
+      await expect(newAppOrFeatureCommand('feature', 'feature')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('feature', 'feature')).rejects.toThrow(/reserved/);
+    });
+
+    it('should reject if feature already exists', async () => {
+      // Use an existing feature (navigation-menu) which should already exist
+      await expect(newAppOrFeatureCommand('navigation-menu', 'feature')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand('navigation-menu', 'feature')).rejects.toThrow(/already exists/);
+    });
+
+    it('should reject names that are too long', async () => {
+      const tooLongName = 'a'.repeat(51);
+      await expect(newAppOrFeatureCommand(tooLongName, 'feature')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand(tooLongName, 'feature')).rejects.toThrow(/too long/);
+    });
+  });
+
+  describe('feature creation', () => {
+    it('should create feature directory with all required files', async () => {
+      const testName = `test-unit-${Date.now()}`;
+      testFeatureNames.push(`feature-${testName}`);
+
+      await newAppOrFeatureCommand(testName, 'feature');
+
+      const featurePath = join(monorepoRoot, 'packages', `feature-${testName}`);
+
+      // Check directory and files exist
+      expect(existsSync(featurePath)).toBe(true);
+      expect(existsSync(join(featurePath, 'package.json'))).toBe(true);
+      expect(existsSync(join(featurePath, 'feature.ts'))).toBe(true);
+      expect(existsSync(join(featurePath, 'tsconfig.app.json'))).toBe(true);
+      expect(existsSync(join(featurePath, 'template'))).toBe(true);
+    });
+
+    it('should update package.json with correct name and scripts', async () => {
+      const testName = `test-pkgjson-${Date.now()}`;
+      testFeatureNames.push(`feature-${testName}`);
+
+      await newAppOrFeatureCommand(testName, 'feature');
+
+      const featurePath = join(monorepoRoot, 'packages', `feature-${testName}`);
+      const packageJson = JSON.parse(readFileSync(join(featurePath, 'package.json'), 'utf-8'));
+
+      // Check name
+      expect(packageJson.name).toBe(`feature-${testName}`);
+
+      // Check scripts are updated
+      expect(packageJson.scripts.dev).toContain(`feature-${testName}`);
+      expect(packageJson.scripts.dev).not.toContain('base-feature');
+    });
+
+    // it('should update tsconfig.app.json include path', async () => {
+    //   const testName = `test-tsconfig-${Date.now()}`;
+    //   testFeatureNames.push(`feature-${testName}`);
+
+    //   await newFeatureCommand(testName);
+
+    //   const featurePath = join(monorepoRoot, 'packages', `feature-${testName}`);
+    //   const tsconfigContent = readFileSync(join(featurePath, 'tsconfig.app.json'), 'utf-8');
+
+    //   // Should contain the new path
+    //   expect(tsconfigContent).toContain(`template/digitalExperiences/webApplications/${testName}`);
+
+    //   // Should not contain base-feature
+    //   expect(tsconfigContent).not.toContain('base-feature');
+    // });
+
+    it('should auto-prefix feature name with "feature-"', async () => {
+      const testName = `autoprefix-${Date.now()}`;
+      testFeatureNames.push(`feature-${testName}`);
+
+      await newAppOrFeatureCommand(testName, 'feature');
+
+      const featurePath = join(monorepoRoot, 'packages', `feature-${testName}`);
+      expect(existsSync(featurePath)).toBe(true);
+
+      const packageJson = JSON.parse(readFileSync(join(featurePath, 'package.json'), 'utf-8'));
+      expect(packageJson.name).toBe(`feature-${testName}`);
+    });
+
+    it('should not double-prefix if name already starts with "feature-"', async () => {
+      const testName = `doubleprefix-${Date.now()}`;
+      testFeatureNames.push(`feature-${testName}`);
+
+      await newAppOrFeatureCommand(`feature-${testName}`, 'feature');
+
+      const featurePath = join(monorepoRoot, 'packages', `feature-${testName}`);
+      expect(existsSync(featurePath)).toBe(true);
+
+      // Should not create feature-feature-{testName}
+      const wrongPath = join(monorepoRoot, 'packages', `feature-feature-${testName}`);
+      expect(existsSync(wrongPath)).toBe(false);
+    });
+
+    it('should handle hyphenated feature names', async () => {
+      const testName = `user-auth-${Date.now()}`;
+      testFeatureNames.push(`feature-${testName}`);
+
+      await newAppOrFeatureCommand(testName, 'feature');
+
+      const featurePath = join(monorepoRoot, 'packages', `feature-${testName}`);
+      expect(existsSync(featurePath)).toBe(true);
+
+      const packageJson = JSON.parse(readFileSync(join(featurePath, 'package.json'), 'utf-8'));
+      expect(packageJson.name).toBe(`feature-${testName}`);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw ValidationError for duplicate feature', async () => {
+      const testName = `duplicate-${Date.now()}`;
+      testFeatureNames.push(`feature-${testName}`);
+
+      // Create first feature
+      await newAppOrFeatureCommand(testName, 'feature');
+
+      // Try to create again with same name
+      await expect(newAppOrFeatureCommand(testName, 'feature')).rejects.toThrow(ValidationError);
+      await expect(newAppOrFeatureCommand(testName, 'feature')).rejects.toThrow(/already exists/);
+    });
+
+    it('should provide clear error messages', async () => {
+      try {
+        await newAppOrFeatureCommand('Invalid_Name', 'feature');
+        expect.fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(ValidationError);
+        expect((err as Error).message).toContain('invalid');
+        expect((err as Error).message).toContain('Examples:');
+      }
+    });
+  });
+});

package/test/unit/package-json-merger.spec.ts

@@ -0,0 +1,275 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PackageJsonMergeError } from '../../src/core/package-json-merger.js';
+
+// Mock dependencies at the top level
+vi.mock('fs');
+vi.mock('../../src/utils/validation.js');
+vi.mock('../../src/utils/logger.js');
+vi.mock('child_process');
+
+describe('package-json-merger', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+  });
+
+  describe('buildPackageSpecs', () => {
+    it('should build package specs from dependencies object', async () => {
+      const { buildPackageSpecs } = await import('../../src/core/package-json-merger.js');
+      const dependencies = {
+        'react': '^18.0.0',
+        'react-dom': '^18.0.0'
+      };
+
+      const result = buildPackageSpecs(dependencies);
+
+      expect(result).toEqual(['react@^18.0.0', 'react-dom@^18.0.0']);
+    });
+
+    it('should handle single dependency', async () => {
+      const { buildPackageSpecs } = await import('../../src/core/package-json-merger.js');
+      const dependencies = {
+        'lodash': '^4.17.21'
+      };
+
+      const result = buildPackageSpecs(dependencies);
+
+      expect(result).toEqual(['lodash@^4.17.21']);
+    });
+
+    it('should handle empty dependencies object', async () => {
+      const { buildPackageSpecs } = await import('../../src/core/package-json-merger.js');
+      const dependencies = {};
+
+      const result = buildPackageSpecs(dependencies);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle scoped packages', async () => {
+      const { buildPackageSpecs } = await import('../../src/core/package-json-merger.js');
+      const dependencies = {
+        '@types/node': '^20.0.0',
+        '@babel/core': '^7.22.0'
+      };
+
+      const result = buildPackageSpecs(dependencies);
+
+      expect(result).toEqual(['@types/node@^20.0.0', '@babel/core@^7.22.0']);
+    });
+  });
+
+  describe('buildInstallCommand', () => {
+    it('should build yarn command for regular dependencies', async () => {
+      const { buildInstallCommand } = await import('../../src/core/package-json-merger.js');
+      const packageSpecs = ['react@^18.0.0', 'react-dom@^18.0.0'];
+
+      const result = buildInstallCommand(packageSpecs, false);
+
+      expect(result).toBe('yarn react@^18.0.0 react-dom@^18.0.0');
+    });
+
+    it('should build yarn command for dev dependencies', async () => {
+      const { buildInstallCommand } = await import('../../src/core/package-json-merger.js');
+      const packageSpecs = ['typescript@^5.0.0', 'vitest@^1.0.0'];
+
+      const result = buildInstallCommand(packageSpecs, true);
+
+      expect(result).toBe('yarn --dev typescript@^5.0.0 vitest@^1.0.0');
+    });
+
+    it('should differentiate between dev and regular dependencies', async () => {
+      const { buildInstallCommand } = await import('../../src/core/package-json-merger.js');
+      const packageSpecs = ['example@1.0.0'];
+
+      const regularCmd = buildInstallCommand(packageSpecs, false);
+      const devCmd = buildInstallCommand(packageSpecs, true);
+
+      expect(regularCmd).not.toContain('--dev');
+      expect(devCmd).toContain('--dev');
+    });
+  });
+
+  describe('executeNpmInstall', () => {
+    it('should call execSync with correct parameters', async () => {
+      const { execSync } = await import('child_process');
+      const { executeNpmInstall } = await import('../../src/core/package-json-merger.js');
+
+      vi.mocked(execSync).mockImplementation(() => Buffer.from(''));
+
+      executeNpmInstall('yarn react@^18.0.0', '/path/to/dir');
+
+      expect(execSync).toHaveBeenCalledWith('yarn react@^18.0.0', {
+        cwd: '/path/to/dir',
+        stdio: 'inherit'
+      });
+    });
+  });
+
+  describe('mergePackageJson', () => {
+    it('should return empty array when no dependencies', async () => {
+      const fs = await import('fs');
+      const validation = await import('../../src/utils/validation.js');
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(validation.getWebApplicationPath).mockReturnValue('/app/path');
+
+      const { mergePackageJson } = await import('../../src/core/package-json-merger.js');
+
+      const result = await mergePackageJson('/target', {});
+
+      expect(result).toEqual([]);
+    });
+
+    it('should throw if package.json does not exist', async () => {
+      const fs = await import('fs');
+      const validation = await import('../../src/utils/validation.js');
+
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+      vi.mocked(validation.getWebApplicationPath).mockReturnValue('/app/path');
+
+      const { mergePackageJson } = await import('../../src/core/package-json-merger.js');
+
+      await expect(mergePackageJson('/target', { dependencies: { 'react': '1.0.0' } }))
+        .rejects.toThrow(/package.json not found/);
+
+      try {
+        await mergePackageJson('/target', { dependencies: { 'react': '1.0.0' } });
+      } catch (err) {
+        expect((err as Error).name).toBe('PackageJsonMergeError');
+      }
+    });
+
+    it('should install dependencies successfully', async () => {
+      const fs = await import('fs');
+      const validation = await import('../../src/utils/validation.js');
+      const childProcess = await import('child_process');
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(validation.getWebApplicationPath).mockReturnValue('/app/path');
+      vi.mocked(childProcess.execSync).mockImplementation(() => Buffer.from(''));
+
+      const { mergePackageJson } = await import('../../src/core/package-json-merger.js');
+
+      const result = await mergePackageJson('/target', {
+        dependencies: { 'react': '^18.0.0' }
+      });
+
+      expect(result).toContain('react@^18.0.0');
+      expect(childProcess.execSync).toHaveBeenCalledWith(
+        'yarn react@^18.0.0',
+        expect.objectContaining({ cwd: '/app/path' })
+      );
+    });
+
+    it('should install devDependencies successfully', async () => {
+      const fs = await import('fs');
+      const validation = await import('../../src/utils/validation.js');
+      const childProcess = await import('child_process');
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(validation.getWebApplicationPath).mockReturnValue('/app/path');
+      vi.mocked(childProcess.execSync).mockImplementation(() => Buffer.from(''));
+
+      const { mergePackageJson } = await import('../../src/core/package-json-merger.js');
+
+      const result = await mergePackageJson('/target', {
+        devDependencies: { 'typescript': '^5.0.0' }
+      });
+
+      expect(result).toContain('typescript@^5.0.0 (dev)');
+      expect(childProcess.execSync).toHaveBeenCalledWith(
+        'yarn --dev typescript@^5.0.0',
+        expect.objectContaining({ cwd: '/app/path' })
+      );
+    });
+
+    it('should handle both dependencies and devDependencies', async () => {
+      const fs = await import('fs');
+      const validation = await import('../../src/utils/validation.js');
+      const childProcess = await import('child_process');
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(validation.getWebApplicationPath).mockReturnValue('/app/path');
+      vi.mocked(childProcess.execSync).mockImplementation(() => Buffer.from(''));
+
+      const { mergePackageJson } = await import('../../src/core/package-json-merger.js');
+
+      const result = await mergePackageJson('/target', {
+        dependencies: { 'react': '^18.0.0' },
+        devDependencies: { 'typescript': '^5.0.0' }
+      });
+
+      expect(result).toContain('react@^18.0.0');
+      expect(result).toContain('typescript@^5.0.0 (dev)');
+      expect(childProcess.execSync).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw error if yarn fails', async () => {
+      const fs = await import('fs');
+      const validation = await import('../../src/utils/validation.js');
+      const childProcess = await import('child_process');
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(validation.getWebApplicationPath).mockReturnValue('/app/path');
+      vi.mocked(childProcess.execSync).mockImplementation(() => {
+        throw new Error('yarn failed');
+      });
+
+      const { mergePackageJson } = await import('../../src/core/package-json-merger.js');
+
+      await expect(mergePackageJson('/target', { dependencies: { 'react': '1.0.0' } }))
+        .rejects.toThrow(/Failed to install dependencies/);
+
+      try {
+        await mergePackageJson('/target', { dependencies: { 'react': '1.0.0' } });
+      } catch (err) {
+        expect((err as Error).name).toBe('PackageJsonMergeError');
+      }
+    });
+
+    it('should use provided webAppDirPath', async () => {
+      const fs = await import('fs');
+      const childProcess = await import('child_process');
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(childProcess.execSync).mockImplementation(() => Buffer.from(''));
+
+      const { mergePackageJson } = await import('../../src/core/package-json-merger.js');
+
+      await mergePackageJson('/target', { dependencies: { 'react': '1.0.0' } }, '/custom/path');
+
+      expect(childProcess.execSync).toHaveBeenCalledWith(
+        'yarn react@1.0.0',
+        expect.objectContaining({ cwd: '/custom/path' })
+      );
+    });
+
+    it('should handle empty dependencies object', async () => {
+      const fs = await import('fs');
+      const validation = await import('../../src/utils/validation.js');
+      const childProcess = await import('child_process');
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(validation.getWebApplicationPath).mockReturnValue('/app/path');
+      vi.mocked(childProcess.execSync).mockImplementation(() => Buffer.from(''));
+
+      const { mergePackageJson } = await import('../../src/core/package-json-merger.js');
+
+      const result = await mergePackageJson('/target', { dependencies: {} });
+
+      expect(result).toEqual([]);
+      expect(childProcess.execSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('PackageJsonMergeError', () => {
+    it('should be throwable with custom message', () => {
+      const error = new PackageJsonMergeError('Custom merge error');
+
+      expect(error.message).toBe('Custom merge error');
+      expect(error.name).toBe('PackageJsonMergeError');
+      expect(error).toBeInstanceOf(Error);
+    });
+  });
+});