command-stream 0.8.2 → 0.9.0

package/rust/tests/process_runner.rs

@@ -0,0 +1,286 @@
+//! Integration tests for ProcessRunner
+//!
+//! These tests mirror the JavaScript $.test.mjs tests
+
+use command_stream::{run, create, exec, ProcessRunner, RunOptions, StdinOption};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use tempfile::TempDir;
+
+// ============================================================================
+// Basic Command Execution Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_simple_echo() {
+    let result = run("echo hello").await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello"));
+}
+
+#[tokio::test]
+async fn test_echo_with_multiple_words() {
+    let result = run("echo hello world").await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello world"));
+}
+
+#[tokio::test]
+async fn test_command_with_arguments() {
+    let result = run("echo -n test").await.unwrap();
+    assert!(result.is_success());
+}
+
+#[tokio::test]
+async fn test_false_command_returns_nonzero() {
+    let result = run("false").await.unwrap();
+    assert!(!result.is_success());
+    assert_eq!(result.code, 1);
+}
+
+#[tokio::test]
+async fn test_true_command_returns_zero() {
+    let result = run("true").await.unwrap();
+    assert!(result.is_success());
+    assert_eq!(result.code, 0);
+}
+
+// ============================================================================
+// ProcessRunner Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_process_runner_basic() {
+    let mut runner = ProcessRunner::new(
+        "echo hello",
+        RunOptions {
+            mirror: false,
+            ..Default::default()
+        },
+    );
+
+    let result = runner.run().await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello"));
+}
+
+#[tokio::test]
+async fn test_process_runner_with_capture() {
+    let mut runner = ProcessRunner::new(
+        "echo captured",
+        RunOptions {
+            mirror: false,
+            capture: true,
+            ..Default::default()
+        },
+    );
+
+    let result = runner.run().await.unwrap();
+    assert!(result.stdout.contains("captured"));
+}
+
+#[tokio::test]
+async fn test_process_runner_is_finished() {
+    let mut runner = ProcessRunner::new("true", RunOptions::default());
+
+    assert!(!runner.is_finished());
+    let _ = runner.run().await;
+    assert!(runner.is_finished());
+}
+
+#[tokio::test]
+async fn test_process_runner_result() {
+    let mut runner = ProcessRunner::new("echo test", RunOptions::default());
+    let _ = runner.run().await;
+
+    let result = runner.result();
+    assert!(result.is_some());
+    assert!(result.unwrap().is_success());
+}
+
+// ============================================================================
+// Working Directory Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_custom_working_directory() {
+    let dir = TempDir::new().unwrap();
+    std::fs::write(dir.path().join("test.txt"), "content").unwrap();
+
+    let mut runner = ProcessRunner::new(
+        "ls",
+        RunOptions {
+            mirror: false,
+            cwd: Some(dir.path().to_path_buf()),
+            ..Default::default()
+        },
+    );
+
+    let result = runner.run().await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("test.txt"));
+}
+
+// ============================================================================
+// Environment Variables Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_custom_environment_variable() {
+    let mut env_vars = HashMap::new();
+    env_vars.insert("MY_TEST_VAR".to_string(), "test_value".to_string());
+
+    let mut runner = ProcessRunner::new(
+        "printenv MY_TEST_VAR",
+        RunOptions {
+            mirror: false,
+            env: Some(env_vars),
+            ..Default::default()
+        },
+    );
+
+    let result = runner.run().await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("test_value"));
+}
+
+// ============================================================================
+// Stdin Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_stdin_content() {
+    let mut runner = ProcessRunner::new(
+        "cat",
+        RunOptions {
+            mirror: false,
+            stdin: StdinOption::Content("hello from stdin".to_string()),
+            ..Default::default()
+        },
+    );
+
+    let result = runner.run().await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello from stdin"));
+}
+
+// ============================================================================
+// exec Function Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_exec_with_options() {
+    let result = exec(
+        "echo test",
+        RunOptions {
+            mirror: false,
+            ..Default::default()
+        },
+    )
+    .await
+    .unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("test"));
+}
+
+// ============================================================================
+// create Function Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_create_and_run() {
+    let mut runner = create("echo created", RunOptions::default());
+    let result = runner.run().await.unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("created"));
+}
+
+// ============================================================================
+// Virtual Command Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_virtual_echo() {
+    let result = run("echo virtual echo").await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("virtual echo"));
+}
+
+#[tokio::test]
+async fn test_virtual_pwd() {
+    let result = run("pwd").await.unwrap();
+    assert!(result.is_success());
+    assert!(!result.stdout.is_empty());
+}
+
+#[tokio::test]
+async fn test_virtual_true() {
+    let result = run("true").await.unwrap();
+    assert!(result.is_success());
+    assert_eq!(result.code, 0);
+}
+
+#[tokio::test]
+async fn test_virtual_false() {
+    let result = run("false").await.unwrap();
+    assert!(!result.is_success());
+    assert_eq!(result.code, 1);
+}
+
+#[tokio::test]
+async fn test_virtual_sleep() {
+    let start = std::time::Instant::now();
+    let result = run("sleep 0.05").await.unwrap();
+    let elapsed = start.elapsed();
+
+    assert!(result.is_success());
+    assert!(elapsed.as_millis() >= 40);
+}
+
+// ============================================================================
+// Stderr Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_stderr_capture() {
+    let result = run("cat nonexistent_file_12345").await.unwrap();
+    assert!(!result.is_success());
+    assert!(!result.stderr.is_empty());
+}
+
+// ============================================================================
+// Exit Code Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_exit_code_zero() {
+    let result = run("exit 0").await.unwrap();
+    assert_eq!(result.code, 0);
+}
+
+#[tokio::test]
+async fn test_exit_code_nonzero() {
+    let result = run("exit 42").await.unwrap();
+    assert_eq!(result.code, 42);
+}
+
+// ============================================================================
+// Kill/Cancel Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_kill_process() {
+    let mut runner = ProcessRunner::new(
+        "sleep 10",
+        RunOptions {
+            mirror: false,
+            ..Default::default()
+        },
+    );
+
+    runner.start().await.unwrap();
+    let kill_result = runner.kill();
+    assert!(kill_result.is_ok());
+}

package/rust/tests/shell_parser.rs

@@ -0,0 +1,296 @@
+//! Integration tests for shell parser
+//!
+//! These tests mirror the JavaScript shell parser tests
+
+use command_stream::shell_parser::{needs_real_shell, parse_shell_command, tokenize, ParsedCommand, TokenType};
+
+// ============================================================================
+// Tokenizer Tests
+// ============================================================================
+
+#[test]
+fn test_tokenize_simple_command() {
+    let tokens = tokenize("echo hello world");
+    assert_eq!(tokens.len(), 4); // 3 words + EOF
+    assert!(matches!(tokens[0].token_type, TokenType::Word(_)));
+    assert!(matches!(tokens[1].token_type, TokenType::Word(_)));
+    assert!(matches!(tokens[2].token_type, TokenType::Word(_)));
+    assert!(matches!(tokens[3].token_type, TokenType::Eof));
+}
+
+#[test]
+fn test_tokenize_with_and_operator() {
+    let tokens = tokenize("cmd1 && cmd2");
+    assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::And)));
+}
+
+#[test]
+fn test_tokenize_with_or_operator() {
+    let tokens = tokenize("cmd1 || cmd2");
+    assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::Or)));
+}
+
+#[test]
+fn test_tokenize_with_pipe() {
+    let tokens = tokenize("ls | grep foo");
+    assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::Pipe)));
+}
+
+#[test]
+fn test_tokenize_with_semicolon() {
+    let tokens = tokenize("cmd1 ; cmd2");
+    assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::Semicolon)));
+}
+
+#[test]
+fn test_tokenize_with_parentheses() {
+    let tokens = tokenize("(echo hello)");
+    assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::LParen)));
+    assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::RParen)));
+}
+
+#[test]
+fn test_tokenize_with_redirect() {
+    let tokens = tokenize("echo hello > file.txt");
+    assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::RedirectOut)));
+}
+
+#[test]
+fn test_tokenize_with_append_redirect() {
+    let tokens = tokenize("echo hello >> file.txt");
+    assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::RedirectAppend)));
+}
+
+#[test]
+fn test_tokenize_with_input_redirect() {
+    let tokens = tokenize("cat < file.txt");
+    assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::RedirectIn)));
+}
+
+#[test]
+fn test_tokenize_single_quoted_string() {
+    let tokens = tokenize("echo 'hello world'");
+    assert_eq!(tokens.len(), 3); // echo + quoted string + EOF
+    if let TokenType::Word(w) = &tokens[1].token_type {
+        assert_eq!(w, "'hello world'");
+    } else {
+        panic!("Expected Word token");
+    }
+}
+
+#[test]
+fn test_tokenize_double_quoted_string() {
+    let tokens = tokenize("echo \"hello world\"");
+    assert_eq!(tokens.len(), 3); // echo + quoted string + EOF
+    if let TokenType::Word(w) = &tokens[1].token_type {
+        assert_eq!(w, "\"hello world\"");
+    } else {
+        panic!("Expected Word token");
+    }
+}
+
+#[test]
+fn test_tokenize_mixed_operators() {
+    let tokens = tokenize("cmd1 && cmd2 || cmd3 ; cmd4");
+    let ops: Vec<_> = tokens
+        .iter()
+        .filter(|t| matches!(t.token_type, TokenType::And | TokenType::Or | TokenType::Semicolon))
+        .collect();
+    assert_eq!(ops.len(), 3);
+}
+
+// ============================================================================
+// Parser Tests
+// ============================================================================
+
+#[test]
+fn test_parse_simple_command() {
+    let cmd = parse_shell_command("echo hello world").unwrap();
+    match cmd {
+        ParsedCommand::Simple { cmd, args, .. } => {
+            assert_eq!(cmd, "echo");
+            assert_eq!(args.len(), 2);
+            assert_eq!(args[0].value, "hello");
+            assert_eq!(args[1].value, "world");
+        }
+        _ => panic!("Expected Simple command"),
+    }
+}
+
+#[test]
+fn test_parse_command_with_quoted_args() {
+    let cmd = parse_shell_command("echo 'hello world'").unwrap();
+    match cmd {
+        ParsedCommand::Simple { cmd, args, .. } => {
+            assert_eq!(cmd, "echo");
+            assert_eq!(args.len(), 1);
+            assert_eq!(args[0].value, "hello world");
+            assert!(args[0].quoted);
+        }
+        _ => panic!("Expected Simple command"),
+    }
+}
+
+#[test]
+fn test_parse_pipeline() {
+    let cmd = parse_shell_command("ls | grep foo | wc -l").unwrap();
+    match cmd {
+        ParsedCommand::Pipeline { commands } => {
+            assert_eq!(commands.len(), 3);
+        }
+        _ => panic!("Expected Pipeline"),
+    }
+}
+
+#[test]
+fn test_parse_sequence_with_and() {
+    let cmd = parse_shell_command("cmd1 && cmd2").unwrap();
+    match cmd {
+        ParsedCommand::Sequence { commands, operators } => {
+            assert_eq!(commands.len(), 2);
+            assert_eq!(operators.len(), 1);
+            assert!(matches!(operators[0], TokenType::And));
+        }
+        _ => panic!("Expected Sequence"),
+    }
+}
+
+#[test]
+fn test_parse_sequence_with_or() {
+    let cmd = parse_shell_command("cmd1 || cmd2").unwrap();
+    match cmd {
+        ParsedCommand::Sequence { commands, operators } => {
+            assert_eq!(commands.len(), 2);
+            assert_eq!(operators.len(), 1);
+            assert!(matches!(operators[0], TokenType::Or));
+        }
+        _ => panic!("Expected Sequence"),
+    }
+}
+
+#[test]
+fn test_parse_sequence_mixed() {
+    let cmd = parse_shell_command("cmd1 && cmd2 || cmd3").unwrap();
+    match cmd {
+        ParsedCommand::Sequence { commands, operators } => {
+            assert_eq!(commands.len(), 3);
+            assert_eq!(operators.len(), 2);
+            assert!(matches!(operators[0], TokenType::And));
+            assert!(matches!(operators[1], TokenType::Or));
+        }
+        _ => panic!("Expected Sequence"),
+    }
+}
+
+#[test]
+fn test_parse_with_redirect_out() {
+    let cmd = parse_shell_command("echo hello > output.txt").unwrap();
+    match cmd {
+        ParsedCommand::Simple { cmd, args, redirects } => {
+            assert_eq!(cmd, "echo");
+            assert_eq!(args.len(), 1);
+            assert_eq!(redirects.len(), 1);
+            assert!(matches!(redirects[0].redirect_type, TokenType::RedirectOut));
+            assert_eq!(redirects[0].target, "output.txt");
+        }
+        _ => panic!("Expected Simple command with redirect"),
+    }
+}
+
+#[test]
+fn test_parse_with_redirect_append() {
+    let cmd = parse_shell_command("echo hello >> output.txt").unwrap();
+    match cmd {
+        ParsedCommand::Simple { redirects, .. } => {
+            assert_eq!(redirects.len(), 1);
+            assert!(matches!(redirects[0].redirect_type, TokenType::RedirectAppend));
+        }
+        _ => panic!("Expected Simple command with redirect"),
+    }
+}
+
+#[test]
+fn test_parse_subshell() {
+    let cmd = parse_shell_command("(echo hello)").unwrap();
+    match cmd {
+        ParsedCommand::Subshell { command } => {
+            match *command {
+                ParsedCommand::Simple { cmd, .. } => {
+                    assert_eq!(cmd, "echo");
+                }
+                _ => panic!("Expected Simple command inside subshell"),
+            }
+        }
+        _ => panic!("Expected Subshell"),
+    }
+}
+
+#[test]
+fn test_parse_subshell_with_sequence() {
+    let cmd = parse_shell_command("(echo hello) && echo world").unwrap();
+    match cmd {
+        ParsedCommand::Sequence { commands, .. } => {
+            assert_eq!(commands.len(), 2);
+            assert!(matches!(commands[0], ParsedCommand::Subshell { .. }));
+        }
+        _ => panic!("Expected Sequence with Subshell"),
+    }
+}
+
+#[test]
+fn test_parse_complex_pipeline_and_sequence() {
+    let cmd = parse_shell_command("ls | grep foo && cat file | wc").unwrap();
+    // This should be: (ls | grep foo) && (cat file | wc)
+    match cmd {
+        ParsedCommand::Sequence { commands, operators } => {
+            assert_eq!(commands.len(), 2);
+            assert_eq!(operators.len(), 1);
+            // Both commands should be pipelines
+        }
+        _ => panic!("Expected Sequence"),
+    }
+}
+
+// ============================================================================
+// needs_real_shell Tests
+// ============================================================================
+
+#[test]
+fn test_needs_real_shell_command_substitution() {
+    assert!(needs_real_shell("echo $(date)"));
+    assert!(needs_real_shell("echo `date`"));
+}
+
+#[test]
+fn test_needs_real_shell_variable_expansion() {
+    assert!(needs_real_shell("echo ${HOME}"));
+}
+
+#[test]
+fn test_needs_real_shell_glob_patterns() {
+    assert!(needs_real_shell("ls *.txt"));
+    assert!(needs_real_shell("ls file?.txt"));
+    assert!(needs_real_shell("ls [abc].txt"));
+}
+
+#[test]
+fn test_needs_real_shell_stderr_redirect() {
+    assert!(needs_real_shell("cmd 2>/dev/null"));
+}
+
+#[test]
+fn test_needs_real_shell_combined_redirect() {
+    assert!(needs_real_shell("cmd &>/dev/null"));
+}
+
+#[test]
+fn test_needs_real_shell_here_document() {
+    assert!(needs_real_shell("cat << EOF"));
+}
+
+#[test]
+fn test_needs_real_shell_simple_commands() {
+    assert!(!needs_real_shell("echo hello"));
+    assert!(!needs_real_shell("ls | grep foo"));
+    assert!(!needs_real_shell("cmd1 && cmd2"));
+}