command-stream 0.8.2 → 0.9.0

package/js/tests/text-method.test.mjs

@@ -0,0 +1,225 @@
+import { describe, test, expect } from 'bun:test';
+import './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+// Disable virtual commands to ensure we're testing system/built-in commands
+disableVirtualCommands();
+
+describe('.text() method for Bun.$ compatibility', () => {
+  test('sync execution should have .text() method', () => {
+    const result = $`echo "sync test"`.sync();
+
+    expect(typeof result.text).toBe('function');
+    expect(result.text).toBeInstanceOf(Function);
+  });
+
+  test('async execution should have .text() method', async () => {
+    const result = await $`echo "async test"`;
+
+    expect(typeof result.text).toBe('function');
+    expect(result.text).toBeInstanceOf(Function);
+  });
+
+  test('.text() should return stdout content (sync)', async () => {
+    const result = $`echo "hello world"`.sync();
+    const text = await result.text();
+
+    expect(text).toBe('hello world\n');
+  });
+
+  test('.text() should return stdout content (async)', async () => {
+    const result = await $`echo "hello async"`;
+    const text = await result.text();
+
+    expect(text).toBe('hello async\n');
+  });
+
+  test('.text() should handle empty output', async () => {
+    // Use a command that produces no output
+    const result = await $`true`;
+    const text = await result.text();
+
+    expect(text).toBe('');
+  });
+
+  test('.text() should handle multiline output', async () => {
+    // Use seq to generate multiline output
+    const result = await $`seq 1 3`;
+    const text = await result.text();
+
+    expect(text).toBe('1\n2\n3\n');
+  });
+
+  test('.text() should work with built-in commands', async () => {
+    const result = await $`seq 1 3`;
+    const text = await result.text();
+
+    expect(text).toBe('1\n2\n3\n');
+  });
+
+  test('.text() should work with cat built-in command', async () => {
+    // Create a test file first
+    await $`echo "test content" > temp-text-test.txt`;
+
+    const result = await $`cat temp-text-test.txt`;
+    const text = await result.text();
+
+    expect(text).toBe('test content\n');
+
+    // Clean up
+    await $`rm temp-text-test.txt`;
+  });
+
+  test('.text() should work with ls built-in command', async () => {
+    const result = await $`ls -1 js/tests/`;
+    const text = await result.text();
+
+    // Should contain at least this test file
+    expect(text).toContain('text-method.test.mjs');
+  });
+
+  test('.text() should work with pwd built-in command', async () => {
+    const result = await $`pwd`;
+    const text = await result.text();
+
+    // Should return a path ending with newline
+    expect(text.trim()).toBeTruthy();
+    expect(text.endsWith('\n')).toBe(true);
+  });
+
+  test('.text() should return empty string for commands with no stdout', async () => {
+    const result =
+      await $`mkdir -p temp-dir-for-text-test && rmdir temp-dir-for-text-test`;
+    const text = await result.text();
+
+    expect(text).toBe('');
+  });
+
+  test('.text() should work with piped commands (when supported)', async () => {
+    // Note: Pipeline with built-ins currently treats them as system commands
+    // This test checks the behavior - expecting an error about unsupported pipeline
+    try {
+      const result = await $`seq 1 3 | cat`;
+      // If this succeeds somehow, check the .text() method exists
+      if (result.text) {
+        const text = await result.text();
+        expect(typeof text).toBe('string');
+      }
+    } catch (error) {
+      // Expected for now - pipeline with system commands not supported
+      expect(error.message).toContain('not yet supported');
+    }
+  });
+
+  test('.text() should work with complex pipeline (when supported)', async () => {
+    // Create a temp file for sorting
+    await $`echo "3" > temp-sort-test.txt`;
+    await $`echo "1" >> temp-sort-test.txt`;
+    await $`echo "2" >> temp-sort-test.txt`;
+
+    try {
+      const result = await $`cat temp-sort-test.txt | sort`;
+      // If this succeeds somehow, check the .text() method exists
+      if (result.text) {
+        const text = await result.text();
+        expect(typeof text).toBe('string');
+      }
+    } catch (error) {
+      // Expected for now - pipeline with system commands not supported
+      expect(error.message).toContain('not yet supported');
+    }
+
+    // Clean up
+    await $`rm temp-sort-test.txt`;
+  });
+
+  test('.text() should handle commands with stderr but no stdout', async () => {
+    try {
+      const result = await $`cat nonexistent-file-text-test.txt`;
+      const text = await result.text();
+
+      expect(text).toBe('');
+    } catch (error) {
+      // Some shells might throw on error, that's fine
+      expect(error.result).toBeDefined();
+      if (error.result) {
+        const text = await error.result.text();
+        expect(text).toBe('');
+      }
+    }
+  });
+
+  test('.text() should be consistent with .stdout property', async () => {
+    const result = await $`echo "consistency test"`;
+    const text = await result.text();
+
+    expect(text).toBe(result.stdout);
+  });
+
+  test('.text() can be called multiple times', async () => {
+    const result = await $`echo "multiple calls"`;
+
+    const text1 = await result.text();
+    const text2 = await result.text();
+    const text3 = await result.text();
+
+    expect(text1).toBe('multiple calls\n');
+    expect(text2).toBe('multiple calls\n');
+    expect(text3).toBe('multiple calls\n');
+    expect(text1).toBe(text2);
+    expect(text2).toBe(text3);
+  });
+
+  test('.text() returns a Promise', () => {
+    const result = $`echo "promise test"`.sync();
+    const textPromise = result.text();
+
+    expect(textPromise).toBeInstanceOf(Promise);
+  });
+
+  test('.text() should work with binary-safe content', async () => {
+    const testContent = 'content with special chars: üñíçødé 🚀';
+    // Write content directly without shell quoting issues
+    await $`touch temp-unicode-test.txt`;
+    await $`echo ${testContent} > temp-unicode-test.txt`;
+
+    const result = await $`cat temp-unicode-test.txt`;
+    const text = await result.text();
+
+    expect(text).toContain('üñíçødé');
+    expect(text).toContain('🚀');
+
+    // Clean up
+    await $`rm temp-unicode-test.txt`;
+  });
+
+  test('.text() should work with .pipe() method results', async () => {
+    const result = await $`echo "pipe test"`.pipe($`cat`);
+    const text = await result.text();
+
+    expect(text).toBe('pipe test\n');
+  });
+
+  test('.text() method should be accessible', () => {
+    const result = $`echo "test"`.sync();
+    const keys = Object.keys(result);
+
+    // .text() method should be accessible
+    expect(result.text).toBeDefined();
+    expect(typeof result.text).toBe('function');
+
+    // Check if it's in the keys (implementation detail)
+    const hasTextKey = keys.includes('text');
+    expect(typeof hasTextKey).toBe('boolean'); // Just verify it's a boolean
+  });
+
+  test('.text() should handle very large output efficiently', async () => {
+    // Generate a reasonably large output
+    const result = await $`seq 1 1000`;
+    const text = await result.text();
+
+    expect(text).toContain('1\n');
+    expect(text).toContain('1000\n');
+    expect(text.split('\n')).toHaveLength(1001); // 1000 numbers + empty line at end
+  });
+});

package/js/tests/virtual.test.mjs

@@ -0,0 +1,364 @@
+import { test, expect, describe, beforeEach, afterEach } from 'bun:test';
+import { beforeTestCleanup, afterTestCleanup } from './test-cleanup.mjs';
+import { isWindows } from './test-helper.mjs';
+import {
+  $,
+  shell,
+  register,
+  unregister,
+  listCommands,
+  enableVirtualCommands,
+} from '../src/$.mjs';
+
+// Helper function to setup shell settings
+function setupShellSettings() {
+  shell.errexit(false);
+  shell.verbose(false);
+  shell.xtrace(false);
+  shell.pipefail(false);
+  shell.nounset(false);
+  enableVirtualCommands();
+}
+
+describe('Virtual Commands System', () => {
+  beforeEach(async () => {
+    await beforeTestCleanup();
+    setupShellSettings();
+  });
+
+  afterEach(async () => {
+    await afterTestCleanup();
+  });
+
+  describe('Registration API', () => {
+    test('should register and execute custom virtual command', async () => {
+      register('greet', async ({ args }) => {
+        const name = args[0] || 'World';
+        return { stdout: `Hello, ${name}!\n`, code: 0 };
+      });
+
+      const result = await $`greet Alice`;
+
+      expect(result.stdout).toBe('Hello, Alice!\n');
+      expect(result.code).toBe(0);
+
+      // Cleanup
+      unregister('greet');
+    });
+
+    test('should unregister commands', async () => {
+      register('temp', async () => ({ stdout: 'temp', code: 0 }));
+
+      // Verify it exists
+      expect(listCommands()).toContain('temp');
+
+      // Unregister
+      const removed = unregister('temp');
+      expect(removed).toBe(true);
+      expect(listCommands()).not.toContain('temp');
+
+      // Verify it falls back to system command
+      try {
+        await $`temp`; // Should fail since 'temp' is not a system command
+      } catch (error) {
+        expect(error.code).not.toBe(0);
+      }
+    });
+
+    test('should list registered commands', () => {
+      const initialCommands = listCommands();
+
+      register('test1', async () => ({ stdout: '', code: 0 }));
+      register('test2', async () => ({ stdout: '', code: 0 }));
+
+      const commands = listCommands();
+      expect(commands).toContain('test1');
+      expect(commands).toContain('test2');
+      expect(commands.length).toBe(initialCommands.length + 2);
+
+      // Cleanup
+      unregister('test1');
+      unregister('test2');
+    });
+  });
+
+  describe('Built-in Commands', () => {
+    // Skip on Windows - uses Unix path /tmp
+    test.skipIf(isWindows)('should execute virtual cd command', async () => {
+      const originalCwd = process.cwd();
+
+      try {
+        const result = await $`cd /tmp`;
+        expect(result.code).toBe(0);
+        expect(process.cwd()).not.toBe(originalCwd);
+        expect(process.cwd()).toMatch(/tmp/);
+      } finally {
+        process.chdir(originalCwd);
+      }
+    });
+
+    test('should execute virtual pwd command', async () => {
+      const result = await $`pwd`;
+      expect(result.code).toBe(0);
+      expect(result.stdout.trim()).toBe(process.cwd());
+    });
+
+    test('should execute virtual echo command', async () => {
+      const result = await $`echo Hello World`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('Hello World\n');
+    });
+
+    test('should execute echo with -n flag', async () => {
+      const result = await $`echo -n Hello`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('Hello');
+    });
+
+    test('should execute virtual sleep command', async () => {
+      const start = Date.now();
+      const result = await $`sleep 0.1`;
+      const elapsed = Date.now() - start;
+
+      expect(result.code).toBe(0);
+      expect(elapsed).toBeGreaterThan(90); // At least 90ms
+      expect(elapsed).toBeLessThan(200); // But not too long
+    });
+
+    test('should execute virtual true command', async () => {
+      const result = await $`true`;
+      expect(result.code).toBe(0);
+    });
+
+    test('should execute virtual false command', async () => {
+      const result = await $`false`;
+      expect(result.code).toBe(1);
+    });
+
+    test('should execute virtual which command', async () => {
+      const result = await $`which echo`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('echo: shell builtin\n');
+    });
+
+    test('should execute virtual exit command', async () => {
+      const result = await $`exit 0`;
+      expect(result.code).toBe(0);
+
+      const result2 = await $`exit 42`;
+      expect(result2.code).toBe(42);
+    });
+
+    test('should execute virtual env command', async () => {
+      const result = await $`env`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toContain('PATH=');
+    });
+
+    test('should execute virtual test command', async () => {
+      // Test directory
+      const result1 = await $`test -d .`;
+      expect(result1.code).toBe(0);
+
+      // Test file
+      const result2 = await $`test -f package.json`;
+      expect(result2.code).toBe(0);
+
+      // Test non-existent
+      const result3 = await $`test -f nonexistent-file-99999`;
+      expect(result3.code).toBe(1);
+    });
+  });
+
+  describe('Virtual vs System Commands', () => {
+    test('should prioritize virtual commands over system commands', async () => {
+      // Register a virtual 'ls' that overrides system ls
+      register('ls', async ({ args }) => ({
+        stdout: 'virtual ls output\n',
+        code: 0,
+      }));
+
+      const result = await $`ls`;
+      expect(result.stdout).toBe('virtual ls output\n');
+
+      // Cleanup - should fall back to system ls
+      unregister('ls');
+
+      const systemResult = await $`ls`;
+      expect(systemResult.stdout).not.toBe('virtual ls output\n');
+      expect(systemResult.code).toBe(0); // System ls should work
+    });
+
+    test('should fall back to system commands when virtual not found', async () => {
+      // This should use system echo (since we didn't override it... wait, we did!)
+      // Let's test with a command we definitely didn't override
+      const result = await $`date`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toContain('202'); // Should contain year
+    });
+  });
+
+  describe('Streaming Virtual Commands', () => {
+    test('should support async generator virtual commands', async () => {
+      register('count', async function* ({ args }) {
+        const max = parseInt(args[0] || 3);
+        for (let i = 1; i <= max; i++) {
+          yield `${i}\n`;
+          // Small delay to test streaming
+          await new Promise((r) => setTimeout(r, 10));
+        }
+      });
+
+      const chunks = [];
+      const cmd = $`count 3`;
+      for await (const chunk of cmd.stream()) {
+        chunks.push(chunk.data.toString());
+      }
+
+      expect(chunks.length).toBeGreaterThan(0);
+      const output = chunks.join('');
+
+      // Check if we got the numbers in order, regardless of newlines
+      expect(output).toContain('1');
+      expect(output).toContain('2');
+      expect(output).toContain('3');
+
+      // The output should be either "1\n2\n3\n" or "123" depending on buffering
+      const normalized = output.replace(/\n/g, '');
+      expect(normalized).toBe('123');
+
+      // Cleanup
+      unregister('count');
+    });
+
+    test('should handle events with streaming virtual commands', async () => {
+      register('stream-test', async function* ({ args }) {
+        yield 'chunk1\n';
+        yield 'chunk2\n';
+      });
+
+      const events = [];
+      const result = await new Promise((resolve) => {
+        const cmd = $`stream-test`;
+        cmd.on('stdout', () => events.push('stdout'));
+        cmd.on('data', (chunk) => events.push(`data-${chunk.type}`));
+        cmd.on('end', resolve);
+        cmd.then().catch(() => {}); // Start execution
+      });
+
+      expect(events.length).toBeGreaterThan(0);
+      expect(events).toContain('stdout');
+      expect(events).toContain('data-stdout');
+
+      // Cleanup
+      unregister('stream-test');
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should handle virtual command errors', async () => {
+      register('fail', async ({ args }) => {
+        throw new Error('Virtual command failed');
+      });
+
+      const result = await $`fail`;
+      expect(result.code).toBe(1);
+      expect(result.stderr).toContain('Virtual command failed');
+
+      // Cleanup
+      unregister('fail');
+    });
+
+    test('should respect errexit setting with virtual commands', async () => {
+      register('fail-code', async ({ args }) => ({
+        stdout: '',
+        stderr: 'Failed',
+        code: 42,
+      }));
+
+      shell.errexit(true);
+
+      try {
+        await $`fail-code`;
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error.code).toBe(42);
+      }
+
+      shell.errexit(false);
+      const result = await $`fail-code`;
+      expect(result.code).toBe(42);
+
+      // Cleanup
+      unregister('fail-code');
+    });
+  });
+
+  describe('Command Arguments and Stdin', () => {
+    test('should pass arguments correctly to virtual commands', async () => {
+      register('args-test', async ({ args }) => ({
+        stdout: `Args: [${args.join(', ')}]\n`,
+        code: 0,
+      }));
+
+      const result = await $`args-test one "two three" four`;
+      expect(result.stdout).toBe('Args: [one, two three, four]\n');
+
+      // Cleanup
+      unregister('args-test');
+    });
+
+    test('should pass stdin to virtual commands', async () => {
+      register('stdin-test', async ({ args, stdin }) => ({
+        stdout: `Received: ${stdin}\n`,
+        code: 0,
+      }));
+
+      const result = await $`echo "test input" | stdin-test`;
+      expect(result.stdout).toBe('Received: test input\n\n');
+
+      // Cleanup
+      unregister('stdin-test');
+    });
+  });
+
+  describe('Shell Settings Integration', () => {
+    test('should respect verbose setting for virtual commands', async () => {
+      register('verbose-test', async () => ({ stdout: 'output', code: 0 }));
+
+      const originalLog = console.log;
+      const logs = [];
+      console.log = (...args) => logs.push(args.join(' '));
+
+      try {
+        shell.verbose(true);
+        await $`verbose-test arg1 arg2`;
+
+        expect(logs.some((log) => log.includes('verbose-test arg1 arg2'))).toBe(
+          true
+        );
+      } finally {
+        console.log = originalLog;
+        unregister('verbose-test');
+      }
+    });
+
+    test('should respect xtrace setting for virtual commands', async () => {
+      register('trace-test', async () => ({ stdout: 'output', code: 0 }));
+
+      const originalLog = console.log;
+      const logs = [];
+      console.log = (...args) => logs.push(args.join(' '));
+
+      try {
+        shell.xtrace(true);
+        await $`trace-test`;
+
+        expect(logs.some((log) => log.startsWith('+ trace-test'))).toBe(true);
+      } finally {
+        console.log = originalLog;
+        unregister('trace-test');
+      }
+    });
+  });
+});