@sfdc-webapps/cli 1.0.2

package/test/unit/debounce.spec.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { debounce } from '../../src/utils/debounce.js';
+
+describe('debounce', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should delay function execution until after wait time', () => {
+    const mockFn = vi.fn();
+    const debouncedFn = debounce(mockFn, 100);
+
+    debouncedFn();
+    expect(mockFn).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(50);
+    expect(mockFn).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(50);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should reset timer if called again before wait time', () => {
+    const mockFn = vi.fn();
+    const debouncedFn = debounce(mockFn, 100);
+
+    debouncedFn();
+    vi.advanceTimersByTime(50);
+
+    // Call again - should reset timer
+    debouncedFn();
+    vi.advanceTimersByTime(50);
+    expect(mockFn).not.toHaveBeenCalled();
+
+    // Now complete the full wait time from second call
+    vi.advanceTimersByTime(50);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should only call function once even with multiple rapid calls', () => {
+    const mockFn = vi.fn();
+    const debouncedFn = debounce(mockFn, 100);
+
+    // Rapid fire calls
+    debouncedFn();
+    debouncedFn();
+    debouncedFn();
+    debouncedFn();
+
+    // Function should not be called yet
+    expect(mockFn).not.toHaveBeenCalled();
+
+    // Fast forward past debounce time
+    vi.advanceTimersByTime(100);
+
+    // Should only be called once
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should pass arguments to debounced function', () => {
+    const mockFn = vi.fn();
+    const debouncedFn = debounce(mockFn, 100);
+
+    debouncedFn('arg1', 'arg2', 'arg3');
+
+    vi.advanceTimersByTime(100);
+
+    expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2', 'arg3');
+  });
+
+  it('should use latest arguments when called multiple times', () => {
+    const mockFn = vi.fn();
+    const debouncedFn = debounce(mockFn, 100);
+
+    debouncedFn('first');
+    vi.advanceTimersByTime(50);
+    debouncedFn('second');
+    vi.advanceTimersByTime(50);
+    debouncedFn('third');
+
+    vi.advanceTimersByTime(100);
+
+    // Should be called with the last set of arguments
+    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledWith('third');
+  });
+
+  it('should allow multiple separate debounced executions', () => {
+    const mockFn = vi.fn();
+    const debouncedFn = debounce(mockFn, 100);
+
+    // First execution
+    debouncedFn('first');
+    vi.advanceTimersByTime(100);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenLastCalledWith('first');
+
+    // Second execution after debounce period
+    debouncedFn('second');
+    vi.advanceTimersByTime(100);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+    expect(mockFn).toHaveBeenLastCalledWith('second');
+  });
+
+  it('should handle different wait times', () => {
+    const mockFn = vi.fn();
+    const debouncedFn = debounce(mockFn, 500);
+
+    debouncedFn();
+    vi.advanceTimersByTime(499);
+    expect(mockFn).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(1);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should work with zero wait time', () => {
+    const mockFn = vi.fn();
+    const debouncedFn = debounce(mockFn, 0);
+
+    debouncedFn();
+    expect(mockFn).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(0);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should preserve function return type through generics', () => {
+    // Type test - this should compile without errors
+    const returnsNumber = (x: number): number => x * 2;
+    const debouncedReturnsNumber = debounce(returnsNumber, 100);
+
+    // Debounced function returns void (fire and forget)
+    const result: void = debouncedReturnsNumber(5);
+    expect(result).toBeUndefined();
+  });
+
+  it('should clear previous timeout before setting new one', () => {
+    const mockFn = vi.fn();
+    const debouncedFn = debounce(mockFn, 100);
+
+    debouncedFn();
+
+    vi.advanceTimersByTime(50);
+    debouncedFn(); // This should clear the first timeout and start a new one
+
+    // If the first timeout wasn't cleared, the function would be called after 50ms more
+    // But since it was cleared, it should only be called after 100ms more
+    vi.advanceTimersByTime(50);
+    expect(mockFn).not.toHaveBeenCalled(); // Not called yet because timer was reset
+
+    vi.advanceTimersByTime(50);
+    expect(mockFn).toHaveBeenCalledTimes(1); // Called after full 100ms from second call
+  });
+});

package/test/unit/dependency-resolver.spec.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  resolveDependencies,
+  CircularDependencyError,
+  DependencyResolutionError,
+  type ResolvedFeature
+} from '../../src/core/dependency-resolver.js';
+import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('dependency-resolver', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    // Create a temporary directory for test fixtures
+    tempDir = join(tmpdir(), `dep-resolver-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    // Clean up
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  /**
+   * Helper to create a feature directory with feature.ts
+   */
+  function createFeature(name: string, dependencies: string[] = []): string {
+    const featureDir = join(tempDir, name);
+    mkdirSync(featureDir, { recursive: true });
+
+    const patchesContent = `
+const feature = {
+  dependencies: ${JSON.stringify(dependencies)}
+};
+
+export default feature;
+`;
+
+    writeFileSync(join(featureDir, 'feature.ts'), patchesContent);
+    return featureDir;
+  }
+
+  describe('resolveDependencies', () => {
+    it('should resolve a feature with no dependencies', async () => {
+      const featurePath = createFeature('feature-a');
+
+      const result = await resolveDependencies(featurePath);
+
+      expect(result.orderedFeatures).toHaveLength(1);
+      expect(result.orderedFeatures[0].featurePath).toBe(featurePath);
+      expect(result.orderedFeatures[0].config.dependencies).toEqual([]);
+    });
+
+    it('should resolve a simple dependency chain', async () => {
+      // Create features: B depends on A
+      const featureA = createFeature('feature-a');
+      const featureB = createFeature('feature-b', [featureA]);
+
+      const result = await resolveDependencies(featureB);
+
+      expect(result.orderedFeatures).toHaveLength(2);
+      // A should come before B (dependencies first)
+      expect(result.orderedFeatures[0].featurePath).toBe(featureA);
+      expect(result.orderedFeatures[1].featurePath).toBe(featureB);
+    });
+
+    it('should resolve a nested dependency chain', async () => {
+      // Create features: C depends on B, B depends on A
+      const featureA = createFeature('feature-a');
+      const featureB = createFeature('feature-b', [featureA]);
+      const featureC = createFeature('feature-c', [featureB]);
+
+      const result = await resolveDependencies(featureC);
+
+      expect(result.orderedFeatures).toHaveLength(3);
+      // Order should be A, B, C
+      expect(result.orderedFeatures[0].featurePath).toBe(featureA);
+      expect(result.orderedFeatures[1].featurePath).toBe(featureB);
+      expect(result.orderedFeatures[2].featurePath).toBe(featureC);
+    });
+
+    it('should handle diamond dependencies (apply common dependency once)', async () => {
+      // Create diamond: D depends on [B, C], both B and C depend on A
+      const featureA = createFeature('feature-a');
+      const featureB = createFeature('feature-b', [featureA]);
+      const featureC = createFeature('feature-c', [featureA]);
+      const featureD = createFeature('feature-d', [featureB, featureC]);
+
+      const result = await resolveDependencies(featureD);
+
+      // A should only appear once
+      expect(result.orderedFeatures).toHaveLength(4);
+
+      // A must come first
+      expect(result.orderedFeatures[0].featurePath).toBe(featureA);
+
+      // B and C must come after A but before D
+      const bIndex = result.orderedFeatures.findIndex(f => f.featurePath === featureB);
+      const cIndex = result.orderedFeatures.findIndex(f => f.featurePath === featureC);
+      expect(bIndex).toBeGreaterThan(0);
+      expect(cIndex).toBeGreaterThan(0);
+
+      // D must come last
+      expect(result.orderedFeatures[3].featurePath).toBe(featureD);
+    });
+
+    it('should detect direct circular dependencies', async () => {
+      // Create circular dependency: A depends on B, B depends on A
+      const featureA = createFeature('feature-a-circular');
+      const featureB = createFeature('feature-b-circular', [featureA]);
+
+      // Update A to depend on B (creating cycle)
+      const patchesContent = `
+const feature = {
+  dependencies: ['${featureB}']
+};
+
+export default feature;
+`;
+      writeFileSync(join(featureA, 'feature.ts'), patchesContent);
+
+      await expect(resolveDependencies(featureB)).rejects.toThrow(CircularDependencyError);
+
+      try {
+        await resolveDependencies(featureB);
+      } catch (err) {
+        expect(err).toBeInstanceOf(CircularDependencyError);
+        const error = err as CircularDependencyError;
+        expect(error.message).toContain('Circular dependency detected');
+        expect(error.cycle).toBeDefined();
+        expect(error.cycle.length).toBeGreaterThan(1);
+      }
+    });
+
+    it('should detect indirect circular dependencies', async () => {
+      // Create circular dependency: A → B → C → A
+      const featureA = createFeature('feature-a-indirect');
+      const featureB = createFeature('feature-b-indirect', [featureA]);
+      const featureC = createFeature('feature-c-indirect', [featureB]);
+
+      // Update A to depend on C (creating cycle)
+      const patchesContent = `
+const feature = {
+  dependencies: ['${featureC}']
+};
+
+export default feature;
+`;
+      writeFileSync(join(featureA, 'feature.ts'), patchesContent);
+
+      await expect(resolveDependencies(featureC)).rejects.toThrow(CircularDependencyError);
+    });
+
+    it('should throw DependencyResolutionError for non-existent dependency', async () => {
+      const featureA = createFeature('feature-a', ['/non-existent/path']);
+
+      await expect(resolveDependencies(featureA)).rejects.toThrow(DependencyResolutionError);
+
+      try {
+        await resolveDependencies(featureA);
+      } catch (err) {
+        expect(err).toBeInstanceOf(DependencyResolutionError);
+        expect((err as Error).message).toContain('Failed to resolve dependencies');
+      }
+    });
+
+    it('should throw error for feature path without feature.ts', async () => {
+      const featurePath = join(tempDir, 'no-feature');
+      mkdirSync(featurePath, { recursive: true });
+      // Don't create feature.ts
+
+      await expect(resolveDependencies(featurePath)).rejects.toThrow();
+    });
+
+    it('should handle multiple features depending on the same dependency', async () => {
+      // Create: D and E both depend on A, F depends on [D, E]
+      const featureA = createFeature('feature-shared');
+      const featureD = createFeature('feature-d', [featureA]);
+      const featureE = createFeature('feature-e', [featureA]);
+      const featureF = createFeature('feature-f', [featureD, featureE]);
+
+      const result = await resolveDependencies(featureF);
+
+      // A should only appear once, even though D and E both depend on it
+      const aCount = result.orderedFeatures.filter(f => f.featurePath === featureA).length;
+      expect(aCount).toBe(1);
+
+      // A must come first
+      expect(result.orderedFeatures[0].featurePath).toBe(featureA);
+
+      // F must come last
+      expect(result.orderedFeatures[result.orderedFeatures.length - 1].featurePath).toBe(featureF);
+    });
+
+    it('should return dependency graph for debugging', async () => {
+      const featureA = createFeature('feature-a-graph');
+      const featureB = createFeature('feature-b-graph', [featureA]);
+
+      const result = await resolveDependencies(featureB);
+
+      expect(result.dependencyGraph).toBeDefined();
+      expect(result.dependencyGraph.size).toBe(2);
+
+      // Verify graph structure
+      const normalizedA = result.orderedFeatures[0].featureDir;
+      const normalizedB = result.orderedFeatures[1].featureDir;
+
+      expect(result.dependencyGraph.get(normalizedB)).toContain(featureA);
+      expect(result.dependencyGraph.get(normalizedA)).toEqual([]);
+    });
+
+    it('should handle relative and absolute paths consistently', async () => {
+      const featureA = createFeature('feature-abs');
+      const featureB = createFeature('feature-rel', [featureA]);
+
+      const result = await resolveDependencies(featureB);
+
+      expect(result.orderedFeatures).toHaveLength(2);
+      // Both should be resolved regardless of path format
+      expect(result.orderedFeatures[0].featurePath).toBe(featureA);
+      expect(result.orderedFeatures[1].featurePath).toBe(featureB);
+    });
+
+    it('should preserve feature configuration in resolved features', async () => {
+      const featureA = createFeature('feature-config');
+
+      const result = await resolveDependencies(featureA);
+
+      expect(result.orderedFeatures[0].config).toBeDefined();
+      expect(result.orderedFeatures[0].config.dependencies).toEqual([]);
+      expect(result.orderedFeatures[0].featureDir).toBe(featureA);
+    });
+  });
+
+  describe('CircularDependencyError', () => {
+    it('should format cycle information in error message', () => {
+      const cycle = ['feature-a', 'feature-b', 'feature-c', 'feature-a'];
+      const error = new CircularDependencyError(cycle);
+
+      expect(error.message).toContain('Circular dependency detected');
+      expect(error.message).toContain('feature-a → feature-b → feature-c → feature-a');
+      expect(error.cycle).toEqual(cycle);
+      expect(error.name).toBe('CircularDependencyError');
+    });
+  });
+
+  describe('DependencyResolutionError', () => {
+    it('should be throwable with custom message', () => {
+      const error = new DependencyResolutionError('Custom error message');
+
+      expect(error.message).toBe('Custom error message');
+      expect(error.name).toBe('DependencyResolutionError');
+      expect(error).toBeInstanceOf(Error);
+    });
+  });
+});

package/test/unit/file-operations.spec.ts

@@ -0,0 +1,264 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync, statSync } from 'fs';
+import { join } from 'path';
+import { createTempDir, cleanupTempDir } from '../helpers/create-temp-dir.js';
+import { deleteFile, prependToFile, appendToFile } from '../../src/core/file-operations.js';
+
+describe('file-operations', () => {
+  let testDir: string;
+  let sourceFile: string;
+  let targetFile: string;
+
+  beforeEach(() => {
+    testDir = createTempDir();
+    sourceFile = join(testDir, 'source.ts');
+    targetFile = join(testDir, 'target.ts');
+  });
+
+  afterEach(() => {
+    cleanupTempDir(testDir);
+  });
+
+  /**
+   * Helper function that simulates the upsert logic with content checking
+   */
+  function upsertWithContentCheck(sourcePath: string, targetPath: string): 'added' | 'updated' | 'skipped' {
+    const sourceContent = readFileSync(sourcePath, 'utf-8');
+
+    const fileExists = existsSync(targetPath);
+    if (fileExists) {
+      const existingContent = readFileSync(targetPath, 'utf-8');
+      if (existingContent === sourceContent) {
+        return 'skipped';
+      }
+    }
+
+    writeFileSync(targetPath, sourceContent, 'utf-8');
+    return fileExists ? 'updated' : 'added';
+  }
+
+  describe('Content checking', () => {
+    it('should add file on initial write', async () => {
+      writeFileSync(sourceFile, 'export const foo = "bar";\n');
+      const result = upsertWithContentCheck(sourceFile, targetFile);
+
+      expect(result).toBe('added');
+      expect(existsSync(targetFile)).toBe(true);
+    });
+
+    it('should skip write when content is unchanged', async () => {
+      writeFileSync(sourceFile, 'export const foo = "bar";\n');
+      upsertWithContentCheck(sourceFile, targetFile);
+
+      const firstStat = statSync(targetFile);
+      const firstMtime = firstStat.mtimeMs;
+
+      // Wait to ensure timestamp would differ if file is written
+      await new Promise(resolve => setTimeout(resolve, 20));
+
+      // Write same content (should skip)
+      const result = upsertWithContentCheck(sourceFile, targetFile);
+
+      expect(result).toBe('skipped');
+
+      const secondStat = statSync(targetFile);
+      const secondMtime = secondStat.mtimeMs;
+
+      expect(firstMtime).toBe(secondMtime);
+    });
+
+    it('should update file when content changes', async () => {
+      writeFileSync(sourceFile, 'export const foo = "bar";\n');
+      upsertWithContentCheck(sourceFile, targetFile);
+
+      const secondStat = statSync(targetFile);
+      const secondMtime = secondStat.mtimeMs;
+
+      await new Promise(resolve => setTimeout(resolve, 20));
+
+      // Write different content (should update)
+      writeFileSync(sourceFile, 'export const foo = "baz";\n');
+      const result = upsertWithContentCheck(sourceFile, targetFile);
+
+      expect(result).toBe('updated');
+
+      const thirdStat = statSync(targetFile);
+      const thirdMtime = thirdStat.mtimeMs;
+
+      expect(thirdMtime).not.toBe(secondMtime);
+
+      const finalContent = readFileSync(targetFile, 'utf-8');
+      expect(finalContent).toBe('export const foo = "baz";\n');
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('should delete existing file', async () => {
+      const testFile = join(testDir, 'delete-me.txt');
+      writeFileSync(testFile, 'content to delete');
+
+      expect(existsSync(testFile)).toBe(true);
+
+      await deleteFile(testFile, 'delete-me.txt');
+
+      expect(existsSync(testFile)).toBe(false);
+    });
+
+    it('should not error when deleting non-existent file', async () => {
+      const testFile = join(testDir, 'does-not-exist.txt');
+
+      // Should not throw
+      await expect(deleteFile(testFile, 'does-not-exist.txt')).resolves.toBeUndefined();
+    });
+
+    it('should delete directory recursively', async () => {
+      const testSubDir = join(testDir, 'subdir');
+      mkdirSync(testSubDir, { recursive: true });
+      writeFileSync(join(testSubDir, 'file1.txt'), 'file1');
+      writeFileSync(join(testSubDir, 'file2.txt'), 'file2');
+
+      expect(existsSync(testSubDir)).toBe(true);
+
+      await deleteFile(testSubDir, 'subdir');
+
+      expect(existsSync(testSubDir)).toBe(false);
+    });
+  });
+
+  describe('prependToFile', () => {
+    it('should prepend content to text file', async () => {
+      const featureFile = join(testDir, 'feature.txt');
+      const targetFile1 = join(testDir, 'target1.txt');
+
+      writeFileSync(featureFile, 'PREPENDED CONTENT');
+      writeFileSync(targetFile1, 'ORIGINAL CONTENT');
+
+      await prependToFile(featureFile, targetFile1, 'target1.txt');
+
+      const result = readFileSync(targetFile1, 'utf-8');
+      expect(result).toBe('PREPENDED CONTENT\nORIGINAL CONTENT');
+    });
+
+    it('should prepend to TypeScript file and fix __inherit__ imports', async () => {
+      const featureTsFile = join(testDir, 'feature.tsx');
+      const targetTsFile = join(testDir, 'target.tsx');
+
+      writeFileSync(featureTsFile, "import { x } from './__inherit__routes';\n");
+      writeFileSync(targetTsFile, 'const y = 1;');
+
+      await prependToFile(featureTsFile, targetTsFile, 'target.tsx');
+
+      const result = readFileSync(targetTsFile, 'utf-8');
+      expect(result).toBe("import { x } from './routes';\n\nconst y = 1;");
+    });
+
+    it('should modify content when prepending (even if prefix exists)', async () => {
+      const featureFile3 = join(testDir, 'feature3.txt');
+      const targetFile3 = join(testDir, 'target3.txt');
+
+      writeFileSync(featureFile3, 'PREFIX');
+      // Target already has the exact result of prepending PREFIX
+      writeFileSync(targetFile3, 'PREFIX\nORIGINAL');
+
+      await new Promise(resolve => setTimeout(resolve, 20));
+
+      // This should NOT skip because prepending PREFIX to "PREFIX\nORIGINAL"
+      // results in "PREFIX\nPREFIX\nORIGINAL" which is different
+      await prependToFile(featureFile3, targetFile3, 'target3.txt');
+
+      const result = readFileSync(targetFile3, 'utf-8');
+      expect(result).toBe('PREFIX\nPREFIX\nORIGINAL');
+    });
+
+    it('should error if feature file does not exist', async () => {
+      await expect(
+        prependToFile(join(testDir, 'nonexistent.txt'), targetFile, 'target.txt')
+      ).rejects.toThrow(/Feature file not found/);
+    });
+
+    it('should error if target file does not exist', async () => {
+      const featureFile = join(testDir, 'feature.txt');
+      writeFileSync(featureFile, 'content');
+
+      await expect(
+        prependToFile(featureFile, join(testDir, 'nonexistent-target.txt'), 'target.txt')
+      ).rejects.toThrow(/Target file not found/);
+    });
+  });
+
+  describe('appendToFile', () => {
+    it('should append content to text file', async () => {
+      const featureFile = join(testDir, 'feature-append.txt');
+      const targetFile1 = join(testDir, 'target-append1.txt');
+
+      writeFileSync(featureFile, 'APPENDED CONTENT');
+      writeFileSync(targetFile1, 'ORIGINAL CONTENT');
+
+      await appendToFile(featureFile, targetFile1, 'target-append1.txt');
+
+      const result = readFileSync(targetFile1, 'utf-8');
+      expect(result).toBe('ORIGINAL CONTENT\nAPPENDED CONTENT');
+    });
+
+    it('should append to CSS file', async () => {
+      const featureCssFile = join(testDir, 'feature.css');
+      const targetCssFile = join(testDir, 'target.css');
+
+      const baseCSS = '@import "tailwindcss";\n\nbody { margin: 0; }';
+      const appendCSS = ':root { --color: blue; }';
+
+      writeFileSync(targetCssFile, baseCSS);
+      writeFileSync(featureCssFile, appendCSS);
+
+      await appendToFile(featureCssFile, targetCssFile, 'target.css');
+
+      const result = readFileSync(targetCssFile, 'utf-8');
+      expect(result).toBe(`${baseCSS}\n${appendCSS}`);
+    });
+
+    it('should append to TypeScript file and fix __inherit__ imports', async () => {
+      const featureTsFile = join(testDir, 'feature-append.tsx');
+      const targetTsFile = join(testDir, 'target-append.tsx');
+
+      writeFileSync(targetTsFile, 'const y = 1;');
+      writeFileSync(featureTsFile, "import { x } from './__inherit__routes';");
+
+      await appendToFile(featureTsFile, targetTsFile, 'target-append.tsx');
+
+      const result = readFileSync(targetTsFile, 'utf-8');
+      expect(result).toBe("const y = 1;\nimport { x } from './routes';");
+    });
+
+    it('should modify content when appending (even if suffix exists)', async () => {
+      const featureFile4 = join(testDir, 'feature4.txt');
+      const targetFile4 = join(testDir, 'target4.txt');
+
+      writeFileSync(featureFile4, 'SUFFIX');
+      writeFileSync(targetFile4, 'ORIGINAL\nSUFFIX');
+
+      await new Promise(resolve => setTimeout(resolve, 20));
+
+      // This should NOT skip because appending SUFFIX to "ORIGINAL\nSUFFIX"
+      // results in "ORIGINAL\nSUFFIX\nSUFFIX" which is different
+      await appendToFile(featureFile4, targetFile4, 'target4.txt');
+
+      const result = readFileSync(targetFile4, 'utf-8');
+      expect(result).toBe('ORIGINAL\nSUFFIX\nSUFFIX');
+    });
+
+    it('should error if feature file does not exist', async () => {
+      await expect(
+        appendToFile(join(testDir, 'nonexistent.txt'), targetFile, 'target.txt')
+      ).rejects.toThrow(/Feature file not found/);
+    });
+
+    it('should error if target file does not exist', async () => {
+      const featureFile = join(testDir, 'feature.txt');
+      writeFileSync(featureFile, 'content');
+
+      await expect(
+        appendToFile(featureFile, join(testDir, 'nonexistent-target.txt'), 'target.txt')
+      ).rejects.toThrow(/Target file not found/);
+    });
+  });
+});