@sfdc-webapps/cli 1.0.2

package/test/e2e/apply-patches.spec.ts

@@ -0,0 +1,861 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { createTempDir, cleanupTempDir } from '../helpers/create-temp-dir.js';
+import { copyFixture, getFixturePath, getGoldPath } from '../helpers/fixtures.js';
+import { compareOrUpdate } from '../helpers/compare-directories.js';
+import { runApplyPatches } from '../helpers/cli-runner.js';
+
+describe('apply-patches E2E', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+  });
+
+  afterEach(() => {
+    cleanupTempDir(tempDir);
+  });
+
+  describe('Simple feature application', () => {
+    it('should apply a simple feature correctly', async () => {
+      // Setup: Copy base-app
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'simple-apply');
+      const featurePath = getFixturePath('basic-operations/feature-file-inherit-route-add');
+
+      // Execute: Apply patches via CLI
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+
+      // Assert: Command succeeded
+      expect(result.exitCode).toBe(0);
+
+      // Assert: Compare with gold files
+      const goldDir = getGoldPath('feature-file-inherit-route-add-apply');
+      const differences = compareOrUpdate(targetDir, goldDir);
+
+      expect(differences).toEqual([]);
+    });
+
+    it('should verify all expected files exist after simple apply', async () => {
+      // Setup
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'simple-apply-verify');
+      const featurePath = getFixturePath('basic-operations/feature-file-inherit-route-add');
+
+      // Execute
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Assert: Check that expected files exist (in feature-file-inherit-route-add nested structure)
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-inherit-route-add/src/about.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-inherit-route-add/src/routes.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-inherit-route-add/src/appLayout.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-inherit-route-add/src/home.tsx'))).toBe(true);
+    });
+  });
+
+  describe('File deletion', () => {
+    it('should delete files marked with __delete__', async () => {
+      // Setup: Copy base-app
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'delete-apply');
+      const featurePath = getFixturePath('basic-operations/feature-file-route-delete');
+
+      // Verify file exists before deletion (in base-app structure)
+      expect(existsSync(join(baseAppDir, 'digitalExperiences/webApplications/base-app/src/old-page.tsx'))).toBe(true);
+
+      // Execute
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Assert: File should be deleted (feature-file-route-delete becomes the target app name)
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-route-delete/src/old-page.tsx'))).toBe(false);
+
+      // Compare with gold files
+      const goldDir = getGoldPath('feature-file-route-delete-apply');
+      const differences = compareOrUpdate(targetDir, goldDir);
+      expect(differences).toEqual([]);
+    });
+
+    it('should clean up imports from deleted files', async () => {
+      // Setup
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'delete-apply-imports');
+      const featurePath = getFixturePath('basic-operations/feature-file-route-delete');
+
+      // Execute
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Assert: Check routes file doesn't have old-page import
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-route-delete/src/routes.tsx'), 'utf-8');
+
+      // Should not contain import or reference to old-page
+      expect(routesContent).not.toContain('old-page');
+      expect(routesContent).not.toContain('OldPage');
+    });
+  });
+
+  describe('Route deletion', () => {
+    it('should delete routes marked with __delete__ in path', async () => {
+      // Setup
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'route-delete-apply');
+      const featurePath = getFixturePath('basic-operations/feature-file-route-delete');
+
+      // Execute
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Assert: Check routes file doesn't have the old route
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-route-delete/src/routes.tsx'), 'utf-8');
+
+      // Should not contain path: 'old'
+      expect(routesContent).not.toMatch(/path:\s*['"]old['"]/);
+    });
+  });
+
+  describe('Dependency resolution', () => {
+    it('should apply features in dependency order', async () => {
+      // Setup: dep-chain-linear depends on feature-file-inherit-route-add
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'deps-apply');
+      const featurePath = getFixturePath('basic-operations/dep-chain-linear');
+
+      // Execute
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Assert: Both features should be applied
+      // From feature-file-inherit-route-add (dependency) and dep-chain-linear (main) - both write to dep-chain-linear path
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-chain-linear/src/about.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-chain-linear/src/contact.tsx'))).toBe(true);
+
+      // Routes should have both /about and /contact
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/dep-chain-linear/src/routes.tsx'), 'utf-8');
+      expect(routesContent).toContain('about');
+      expect(routesContent).toContain('contact');
+
+      // Compare with gold files
+      const goldDir = getGoldPath('dep-chain-linear-apply');
+      const differences = compareOrUpdate(targetDir, goldDir);
+      expect(differences).toEqual([]);
+    });
+  });
+
+  describe('Complex operations', () => {
+    it('should handle __inherit__, __prepend__, __append__', async () => {
+      // Setup
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'complex-apply');
+      const featurePath = getFixturePath('basic-operations/feature-file-prepend-append');
+
+      // Execute
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Assert: Check files exist (in feature-file-prepend-append path)
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-prepend-append/src/settings.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-prepend-append/src/appLayout.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-prepend-append/src/index.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-prepend-append/src/styles/global.css'))).toBe(true);
+
+      // Check prepend operation
+      const { readFileSync } = await import('fs');
+      const indexContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-prepend-append/src/index.tsx'), 'utf-8');
+      expect(indexContent).toContain('Feature complex initialized');
+
+      // Check append operation
+      const cssContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-prepend-append/src/styles/global.css'), 'utf-8');
+      expect(cssContent).toContain('--feature-color');
+      expect(cssContent).toContain('.feature-specific');
+
+      // Compare with gold files
+      const goldDir = getGoldPath('feature-file-prepend-append-apply');
+      const differences = compareOrUpdate(targetDir, goldDir);
+      expect(differences).toEqual([]);
+    });
+
+    it('should verify appLayout is inherited correctly', async () => {
+      // Setup
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'complex-apply-verify');
+      const featurePath = getFixturePath('basic-operations/feature-file-prepend-append');
+
+      // Execute
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Assert: appLayout should exist (inherited from base)
+      const { readFileSync } = await import('fs');
+      const appLayoutContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-prepend-append/src/appLayout.tsx'), 'utf-8');
+
+      // Should still have the base navigation structure
+      expect(appLayoutContent).toContain('routes[0].children?.map');
+      expect(appLayoutContent).toContain('Outlet');
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should fail gracefully when feature path does not exist', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'error-test');
+      const featurePath = getFixturePath('non-existent-feature');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+
+      expect(result.exitCode).not.toBe(0);
+    });
+
+    it('should fail when trying to delete non-existent file', async () => {
+      // Setup: Create a custom feature that tries to delete a file that doesn't exist
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'delete-error-test');
+
+      // Create a feature that tries to delete a non-existent file
+      const { mkdirSync, writeFileSync } = await import('fs');
+      const customFeature = join(tempDir, 'custom-feature');
+      mkdirSync(join(customFeature, 'template/digitalExperiences/webApplications/custom-feature/src'), { recursive: true });
+
+      // Write feature.ts
+      writeFileSync(
+        join(customFeature, 'feature.ts'),
+        `export default { templateDir: 'template' };`
+      );
+
+      // Write a delete marker for non-existent file
+      writeFileSync(
+        join(customFeature, 'template/digitalExperiences/webApplications/custom-feature/src/__delete__non-existent.tsx'),
+        '// This file does not exist in base app'
+      );
+
+      const result = await runApplyPatches(customFeature, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toMatch(/Cannot delete file that doesn't exist/);
+    });
+  });
+
+  describe('Idempotency', () => {
+    it('should handle applying patches multiple times idempotently', async () => {
+      // Setup: Copy base-app
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'idempotent-test');
+      const featurePath = getFixturePath('basic-operations/feature-file-inherit-route-add');
+
+      // First application
+      const result1 = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result1.exitCode).toBe(0);
+
+      // Verify it worked
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-inherit-route-add/src/about.tsx'))).toBe(true);
+
+      // Apply again (should be idempotent - not fail or corrupt files)
+      const result2 = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result2.exitCode).toBe(0);
+
+      // Should still work correctly
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-inherit-route-add/src/about.tsx'))).toBe(true);
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-inherit-route-add/src/routes.tsx'), 'utf-8');
+      expect(routesContent).toContain('about');
+    });
+  });
+
+  describe('Long dependency chains', () => {
+    it('should apply features in a long chain (A → B → C → D)', async () => {
+      // Setup: dep-chain-a depends on B, which depends on C, which depends on D
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'dep-chain-long-apply');
+      const featurePath = getFixturePath('dep-chain-long/dep-chain-a');
+
+      // Execute
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Assert: All 4 features should be applied
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-chain-a/src/page-a.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-chain-a/src/page-b.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-chain-a/src/page-c.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-chain-a/src/page-d.tsx'))).toBe(true);
+
+      // Routes should have all 4 pages
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/dep-chain-a/src/routes.tsx'), 'utf-8');
+      expect(routesContent).toContain('page-a');
+      expect(routesContent).toContain('page-b');
+      expect(routesContent).toContain('page-c');
+      expect(routesContent).toContain('page-d');
+
+      // Compare with gold files
+      const goldDir = getGoldPath('dep-chain-long-apply');
+      const differences = compareOrUpdate(targetDir, goldDir);
+      expect(differences).toEqual([]);
+    });
+  });
+
+  describe('Diamond dependencies', () => {
+    it('should apply shared dependency only once in diamond pattern', async () => {
+      // Setup: Both left and right depend on shared
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDirLeft = join(tempDir, 'dep-diamond-left-apply');
+      const targetDirRight = join(tempDir, 'dep-diamond-right-apply');
+
+      // Apply left feature (depends on shared)
+      const leftPath = getFixturePath('dep-diamond/dep-diamond-left');
+      const resultLeft = await runApplyPatches(leftPath, baseAppDir, targetDirLeft, {
+        skipDependencyChanges: true
+      });
+      expect(resultLeft.exitCode).toBe(0);
+
+      // Apply right feature (also depends on shared)
+      const rightPath = getFixturePath('dep-diamond/dep-diamond-right');
+      const resultRight = await runApplyPatches(rightPath, baseAppDir, targetDirRight, {
+        skipDependencyChanges: true
+      });
+      expect(resultRight.exitCode).toBe(0);
+
+      // Assert: Left should have shared and left-page
+      expect(existsSync(join(targetDirLeft, 'digitalExperiences/webApplications/dep-diamond-left/src/shared-utils.tsx'))).toBe(true);
+      expect(existsSync(join(targetDirLeft, 'digitalExperiences/webApplications/dep-diamond-left/src/left-page.tsx'))).toBe(true);
+
+      // Right should have shared and right-page
+      expect(existsSync(join(targetDirRight, 'digitalExperiences/webApplications/dep-diamond-right/src/shared-utils.tsx'))).toBe(true);
+      expect(existsSync(join(targetDirRight, 'digitalExperiences/webApplications/dep-diamond-right/src/right-page.tsx'))).toBe(true);
+
+      // Routes should have shared content in both
+      const { readFileSync } = await import('fs');
+      const routesLeft = readFileSync(join(targetDirLeft, 'digitalExperiences/webApplications/dep-diamond-left/src/routes.tsx'), 'utf-8');
+      const routesRight = readFileSync(join(targetDirRight, 'digitalExperiences/webApplications/dep-diamond-right/src/routes.tsx'), 'utf-8');
+
+      expect(routesLeft).toContain('shared');
+      expect(routesLeft).toContain('left');
+      expect(routesRight).toContain('shared');
+      expect(routesRight).toContain('right');
+    });
+  });
+
+  describe('Circular dependencies', () => {
+    it('should detect and reject circular dependencies', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'circular-error-test');
+      const featurePath = getFixturePath('dep-circular/dep-circular-a');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toMatch(/circular/i);
+    });
+  });
+
+  describe('Complex dependency graph', () => {
+    it('should resolve complex multi-branch dependencies correctly', async () => {
+      // Setup: Apply all 3 main features (auth, dashboard, profile)
+      // Each has different combinations of shared dependencies
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'dep-complex-graph-apply');
+
+      // Apply the parent dep-complex-graph feature which depends on all 3 main features
+      const complexGraphPath = getFixturePath('dep-complex-graph');
+      const result = await runApplyPatches(complexGraphPath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Assert: All features and shared dependencies should be present
+      // Shared dependencies
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/tools.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/types.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/components.tsx'))).toBe(true);
+
+      // Main features with enhanced route manipulation
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/login.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/signup.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/dashboard.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/analytics.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/reports.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/profile.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/profile-edit.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/admin-layout.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/admin-dashboard.tsx'))).toBe(true);
+
+      // Verify old route was deleted
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/old-page.tsx'))).toBe(false);
+
+      // Routes should have all new routes
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/dep-complex-graph/src/routes.tsx'), 'utf-8');
+      expect(routesContent).toContain('tools');
+      expect(routesContent).toContain('components');
+      expect(routesContent).toContain('login');
+      expect(routesContent).toContain('signup');
+      expect(routesContent).toContain('dashboard');
+      expect(routesContent).toContain('analytics');
+      expect(routesContent).toContain('reports');
+      expect(routesContent).toContain('profile/:id');
+      expect(routesContent).toContain('edit');
+      expect(routesContent).toContain('admin');
+      expect(routesContent).not.toContain('old');
+
+      // Compare with gold files
+      const goldDir = getGoldPath('dep-complex-graph-apply');
+      const differences = compareOrUpdate(targetDir, goldDir);
+      expect(differences).toEqual([]);
+    });
+  });
+
+  describe('Phase 2: Single feature tests', () => {
+    it('should apply prepend-only feature correctly', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'prepend-only-apply');
+      const featurePath = getFixturePath('single-operations/feature-file-prepend');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      const { readFileSync } = await import('fs');
+      const indexContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-prepend/src/index.tsx'), 'utf-8');
+      expect(indexContent).toContain('Feature prepend initialized');
+    });
+
+    it('should apply append-only feature correctly', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'append-only-apply');
+      const featurePath = getFixturePath('single-operations/feature-file-append');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      const { readFileSync } = await import('fs');
+      const cssContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-append/src/styles/global.css'), 'utf-8');
+      expect(cssContent).toContain('feature-append-specific');
+    });
+
+    it('should apply route-add feature correctly', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'route-add-apply');
+      const featurePath = getFixturePath('single-operations/feature-route-add');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-route-add/src/services.tsx'))).toBe(true);
+
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-route-add/src/routes.tsx'), 'utf-8');
+      expect(routesContent).toContain('services');
+    });
+
+    it('should apply inherit-only feature correctly', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'inherit-only-apply');
+      const featurePath = getFixturePath('single-operations/feature-file-inherit');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Verify inherited files exist
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-inherit/src/appLayout.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/feature-file-inherit/src/home.tsx'))).toBe(true);
+    });
+
+    it('should apply import-merge feature correctly', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'import-merge-apply');
+      const featurePath = getFixturePath('single-operations/feature-import-merge');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Verify route file has merged imports
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/feature-import-merge/src/routes.tsx'), 'utf-8');
+      expect(routesContent).toContain('settings');
+    });
+  });
+
+  describe('Phase 4: Composition tests', () => {
+    it('should handle multiple features appending to same file', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir1 = join(tempDir, 'append1');
+      const targetDir2 = join(tempDir, 'append2');
+      const targetDir3 = join(tempDir, 'append3');
+
+      // Apply three append features sequentially
+      const result1 = await runApplyPatches(getFixturePath('composition-append/composition-append-1'), baseAppDir, targetDir1, {
+        skipDependencyChanges: true
+      });
+      expect(result1.exitCode).toBe(0);
+
+      const result2 = await runApplyPatches(getFixturePath('composition-append/composition-append-2'), baseAppDir, targetDir2, {
+        skipDependencyChanges: true
+      });
+      expect(result2.exitCode).toBe(0);
+
+      const result3 = await runApplyPatches(getFixturePath('composition-append/composition-append-3'), baseAppDir, targetDir3, {
+        skipDependencyChanges: true
+      });
+      expect(result3.exitCode).toBe(0);
+
+      // Verify each append was applied
+      const { readFileSync } = await import('fs');
+      const css1 = readFileSync(join(targetDir1, 'digitalExperiences/webApplications/composition-append-1/src/styles/global.css'), 'utf-8');
+      const css2 = readFileSync(join(targetDir2, 'digitalExperiences/webApplications/composition-append-2/src/styles/global.css'), 'utf-8');
+      const css3 = readFileSync(join(targetDir3, 'digitalExperiences/webApplications/composition-append-3/src/styles/global.css'), 'utf-8');
+
+      expect(css1).toContain('composition-append-1');
+      expect(css2).toContain('composition-append-2');
+      expect(css3).toContain('composition-append-3');
+    });
+
+    it('should handle multiple features prepending to same file', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir1 = join(tempDir, 'prepend1');
+
+      const result = await runApplyPatches(getFixturePath('composition-prepend/composition-prepend-1'), baseAppDir, targetDir1, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      const { readFileSync } = await import('fs');
+      const indexContent = readFileSync(join(targetDir1, 'digitalExperiences/webApplications/composition-prepend-1/src/index.tsx'), 'utf-8');
+      expect(indexContent).toContain('composition-prepend-1');
+    });
+
+    it('should handle five features applied together', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, '5-features-apply');
+
+      // Apply all 5 features to test integration
+      const result1 = await runApplyPatches(getFixturePath('composition-5-features/5-features-navigation'), baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result1.exitCode).toBe(0);
+
+      const result2 = await runApplyPatches(getFixturePath('composition-5-features/5-features-footer'), baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result2.exitCode).toBe(0);
+
+      const result3 = await runApplyPatches(getFixturePath('composition-5-features/5-features-theme'), baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result3.exitCode).toBe(0);
+
+      const result4 = await runApplyPatches(getFixturePath('composition-5-features/5-features-analytics'), baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result4.exitCode).toBe(0);
+
+      const result5 = await runApplyPatches(getFixturePath('composition-5-features/5-features-about'), baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result5.exitCode).toBe(0);
+
+      // Verify at least some of the features were applied
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/5-features-about/src/about.tsx'))).toBe(true);
+    });
+
+    it('should handle inherit then modify pattern', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir1 = join(tempDir, 'inherit-layout');
+      const targetDir2 = join(tempDir, 'modify-layout');
+
+      // Apply inherit feature first
+      const result1 = await runApplyPatches(getFixturePath('composition-inherit-modify/composition-inherit-layout'), baseAppDir, targetDir1, {
+        skipDependencyChanges: true
+      });
+      expect(result1.exitCode).toBe(0);
+
+      // Apply modify feature
+      const result2 = await runApplyPatches(getFixturePath('composition-inherit-modify/composition-modify-layout'), baseAppDir, targetDir2, {
+        skipDependencyChanges: true
+      });
+      expect(result2.exitCode).toBe(0);
+
+      // Verify both applied correctly
+      const { readFileSync } = await import('fs');
+      const layout1 = readFileSync(join(targetDir1, 'digitalExperiences/webApplications/composition-inherit-layout/src/appLayout.tsx'), 'utf-8');
+      const layout2 = readFileSync(join(targetDir2, 'digitalExperiences/webApplications/composition-modify-layout/src/appLayout.tsx'), 'utf-8');
+
+      expect(layout1).toBeTruthy();
+      expect(layout2).toBeTruthy();
+    });
+
+    it('should handle multiple prepends in order (prepend-2 and prepend-3)', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir2 = join(tempDir, 'prepend2');
+      const targetDir3 = join(tempDir, 'prepend3');
+
+      const result2 = await runApplyPatches(getFixturePath('composition-prepend/composition-prepend-2'), baseAppDir, targetDir2, {
+        skipDependencyChanges: true
+      });
+      expect(result2.exitCode).toBe(0);
+
+      const result3 = await runApplyPatches(getFixturePath('composition-prepend/composition-prepend-3'), baseAppDir, targetDir3, {
+        skipDependencyChanges: true
+      });
+      expect(result3.exitCode).toBe(0);
+
+      const { readFileSync } = await import('fs');
+      const indexContent2 = readFileSync(join(targetDir2, 'digitalExperiences/webApplications/composition-prepend-2/src/index.tsx'), 'utf-8');
+      const indexContent3 = readFileSync(join(targetDir3, 'digitalExperiences/webApplications/composition-prepend-3/src/index.tsx'), 'utf-8');
+
+      expect(indexContent2).toContain('composition-prepend-2');
+      expect(indexContent3).toContain('composition-prepend-3');
+    });
+  });
+
+  describe('Phase 5: Real-world scenarios', () => {
+    it('should apply navigation menu feature', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'nav-menu-apply');
+      const featurePath = getFixturePath('scenarios/scenario-navigation-menu');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Verify navigation component exists
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/scenario-navigation-menu/src/components/NavigationMenu.tsx'))).toBe(true);
+
+      // Verify appLayout was modified
+      const { readFileSync } = await import('fs');
+      const appLayoutContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/scenario-navigation-menu/src/appLayout.tsx'), 'utf-8');
+      expect(appLayoutContent).toContain('NavigationMenu');
+    });
+
+    it('should apply authentication feature', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'auth-apply');
+      const featurePath = getFixturePath('scenarios/scenario-authentication');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Verify auth components exist
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/scenario-authentication/src/context/AuthContext.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/scenario-authentication/src/components/LoginForm.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/scenario-authentication/src/login.tsx'))).toBe(true);
+
+      // Verify routes include login
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/scenario-authentication/src/routes.tsx'), 'utf-8');
+      expect(routesContent).toContain('login');
+      expect(routesContent).toContain('Login');
+    });
+
+    it('should apply CRUD contacts feature', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'crud-apply');
+      const featurePath = getFixturePath('scenarios/scenario-crud-contacts');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Verify CRUD components exist
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/scenario-crud-contacts/src/components/ContactList.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/scenario-crud-contacts/src/components/ContactDetail.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/scenario-crud-contacts/src/components/ContactForm.tsx'))).toBe(true);
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/scenario-crud-contacts/src/utils/contactsApi.ts'))).toBe(true);
+
+      // Verify routes include contacts with nested routes
+      const { readFileSync } = await import('fs');
+      const routesContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/scenario-crud-contacts/src/routes.tsx'), 'utf-8');
+      expect(routesContent).toContain('contacts');
+      expect(routesContent).toContain(':id');
+      expect(routesContent).toContain('edit');
+
+      // Verify CSS was appended
+      const cssContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/scenario-crud-contacts/src/styles/global.css'), 'utf-8');
+      expect(cssContent).toContain('contact-list');
+      expect(cssContent).toContain('form-group');
+    });
+  });
+
+  describe('Phase 6: Edge cases', () => {
+    it('should handle empty feature with only dependencies', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'edge-empty-apply');
+      const featurePath = getFixturePath('edges/edge-empty-feature');
+
+      // Should succeed - empty features are valid "meta-features"
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Dependencies should be applied
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/edge-empty-feature/src/appLayout.tsx'))).toBe(true);
+    });
+
+    it('should reject conflicting prefixes', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'edge-conflict-apply');
+      const featurePath = getFixturePath('edges/edge-conflicting-prefixes');
+
+      // Should fail - can't have both __inherit__ and __delete__
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+
+      expect(result.exitCode).not.toBe(0);
+    });
+
+    it('should reject operations on missing base files', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'edge-missing-apply');
+      const featurePath = getFixturePath('edges/edge-missing-base-files');
+
+      // Should fail - can't prepend/append/inherit non-existent files
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+
+      expect(result.exitCode).not.toBe(0);
+    });
+
+    it('should detect package.json version conflicts', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'edge-pkg-conflict-apply');
+
+      // Apply first feature with react@18.0.0
+      const featurePathA = getFixturePath('edges/edge-package-json-conflicts-a');
+      const resultA = await runApplyPatches(featurePathA, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(resultA.exitCode).toBe(0);
+
+      // Try to apply second feature with react@18.2.0 - should conflict
+      const featurePathB = getFixturePath('edges/edge-package-json-conflicts-b');
+      const resultB = await runApplyPatches(featurePathB, targetDir, targetDir, {
+        skipDependencyChanges: true
+      });
+
+      expect(resultB.exitCode).not.toBe(0);
+      expect(resultB.stderr).toMatch(/conflict|version/i);
+    });
+
+    it('should reject invalid route operations', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'edge-invalid-routes-apply');
+      const featurePath = getFixturePath('edges/edge-invalid-routes');
+
+      // Should fail - trying to delete non-existent routes
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+
+      expect(result.exitCode).not.toBe(0);
+    });
+
+    it('should handle binary files correctly', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'edge-binary-apply');
+      const featurePath = getFixturePath('edges/edge-binary-files');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Binary file should be copied
+      const imagePath = join(targetDir, 'digitalExperiences/webApplications/edge-binary-files/src/assets/test-image.png');
+      expect(existsSync(imagePath)).toBe(true);
+
+      // Verify it's actually a binary file (not corrupted)
+      const { readFileSync } = await import('fs');
+      const imageBuffer = readFileSync(imagePath);
+      expect(imageBuffer.length).toBeGreaterThan(0);
+    });
+
+    it('should handle different line endings correctly', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'edge-line-endings-apply');
+      const featurePath = getFixturePath('edges/edge-line-endings');
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+      expect(result.exitCode).toBe(0);
+
+      // Prepend and append should work correctly regardless of line endings
+      const { readFileSync } = await import('fs');
+      const indexContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/edge-line-endings/src/index.tsx'), 'utf-8');
+      const cssContent = readFileSync(join(targetDir, 'digitalExperiences/webApplications/edge-line-endings/src/styles/global.css'), 'utf-8');
+
+      expect(indexContent).toContain('line-endings');
+      expect(cssContent).toContain('line-endings');
+    });
+
+    it('should handle many features with reasonable performance', async () => {
+      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
+      const targetDir = join(tempDir, 'edge-performance-apply');
+      const featurePath = getFixturePath('edges/edge-performance-many');
+
+      const startTime = Date.now();
+
+      const result = await runApplyPatches(featurePath, baseAppDir, targetDir, {
+        skipDependencyChanges: true
+      });
+
+      const duration = Date.now() - startTime;
+
+      expect(result.exitCode).toBe(0);
+
+      // Should complete in reasonable time (12 features should take less than 5 seconds)
+      expect(duration).toBeLessThan(5000);
+
+      // Verify at least some features were applied
+      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/edge-performance-many'))).toBe(true);
+    });
+  });
+
+});