ctrl-c-basic.test.mjs

import { describe, it, expect } from 'bun:test';
import './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
import { $ } from '../src/$.mjs';

describe('CTRL+C Basic Handling', () => {
  it('should be able to kill a long-running process', async () => {
    // Start a long-running process
    const runner = $`sleep 10`;
    
    // Start it without awaiting completion
    const promise = runner.start();
    
    // Give it time to start
    await new Promise(resolve => setTimeout(resolve, 100));
    
    // Kill it manually (simulating what CTRL+C would do)
    runner.kill();
    
    // The process should complete with a non-zero exit code
    const result = await promise;
    
    // Should have a non-zero exit code (143 for SIGTERM)
    expect(result.code).toBeGreaterThan(0);
    expect(result.code).toBe(143); // 128 + 15 (SIGTERM)
  });

  it('should spawn processes with detached flag on Unix', async () => {
    if (process.platform === 'win32') {
      // Skip on Windows
      return;
    }
    
    // Use /bin/sleep to get a real system process, not virtual command
    const runner = $`/bin/sleep 1`;
    
    // Start the process
    const promise = runner.start();
    
    // Give it a moment to spawn
    await new Promise(resolve => setTimeout(resolve, 50));
    
    // Check that the child process exists and has a PID
    expect(runner.child).toBeDefined();
    expect(runner.child.pid).toBeGreaterThan(0);
    
    // Kill and wait for completion
    runner.kill();
    
    try {
      await promise;
    } catch (error) {
      // Expected to error
    }
  });

  it('should handle CTRL+C character in raw mode', async () => {
    // Test that the _forwardTTYStdin method properly handles CTRL+C
    // This is a unit test of the specific functionality
    
    const runner = $`cat`; // Use cat to read stdin
    
    // Start the process
    const promise = runner.start();
    
    // Give it time to set up
    await new Promise(resolve => setTimeout(resolve, 100));
    
    // Kill the process
    runner.kill();
    
    // Should complete with an error
    let errorCode = null;
    try {
      await promise;
    } catch (error) {
      errorCode = error.code;
    }
    
    expect(errorCode).toBeDefined();
  });
});

describe('CTRL+C Virtual Commands', () => {
  it('should cancel virtual command with AbortController', async () => {
    const runner = $`sleep 5`; // Virtual sleep command
    
    const promise = runner.start();
    
    // Give virtual command time to start
    await new Promise(resolve => setTimeout(resolve, 100));
    
    // Kill the virtual command
    runner.kill();
    
    const result = await promise;
    
    // Virtual commands return SIGTERM exit code when cancelled
    expect(result.code).toBe(143);
  }, { timeout: 5000 });
  
  it('should cancel virtual async generator', async () => {
    // Test cancelling a streaming virtual command
    const runner = $`yes hello`;
    
    // Start streaming
    const streamPromise = (async () => {
      let chunks = 0;
      for await (const _chunk of runner.stream()) {
        chunks++;
        if (chunks >= 3) {
          break; // Break should trigger cancellation
        }
      }
      return chunks;
    })();
    
    const chunks = await streamPromise;
    expect(chunks).toBe(3);
    expect(runner.finished).toBe(true);
  }, { timeout: 5000 });
});

describe('CTRL+C Different stdin Modes', () => {
  it('should handle CTRL+C with string stdin', async () => {
    // Use a long-running command that will actually be killed
    const runner = $({ stdin: 'test input\n' })`sleep 10`;
    
    const promise = runner.start();
    await new Promise(resolve => setTimeout(resolve, 200));
    
    runner.kill();
    const result = await promise;
    
    expect(result.code).toBe(143);
  });
  
  it('should handle CTRL+C with Buffer stdin', async () => {
    // Use a long-running command that will actually be killed
    const runner = $({ stdin: Buffer.from('test input\n') })`sleep 10`;
    
    const promise = runner.start();
    await new Promise(resolve => setTimeout(resolve, 200));
    
    runner.kill();
    const result = await promise;
    
    expect(result.code).toBe(143);
  });
  
  it('should handle CTRL+C with ignore stdin', async () => {
    const runner = $({ stdin: 'ignore' })`sleep 5`;
    
    const promise = runner.start();
    await new Promise(resolve => setTimeout(resolve, 100));
    
    runner.kill();
    const result = await promise;
    
    expect(result.code).toBe(143);
  });
});

describe('CTRL+C Pipeline Interruption', () => {
  it('should interrupt simple pipeline', async () => {
    // Use a very simple approach that we know works
    const runner = $`sleep 10`;
    
    const promise = runner.start();
    await new Promise(resolve => setTimeout(resolve, 200));
    
    runner.kill();
    const result = await promise;
    
    // Should be interrupted with SIGTERM code
    expect(result.code).toBe(143);
  }, { timeout: 3000 });
});

describe('CTRL+C Process Groups', () => {
  it('should handle process group termination on Unix', async () => {
    if (process.platform === 'win32') return; // Skip on Windows
    
    // Use a command that spawns subprocesses
    const runner = $`sh -c 'sleep 10 & sleep 10 & wait'`;
    
    const promise = runner.start();
    await new Promise(resolve => setTimeout(resolve, 200));
    
    runner.kill();
    const result = await promise;
    
    expect(result.code).toBe(143);
  }, { timeout: 5000 });
});