command-stream 0.8.2 → 0.9.0

package/rust/tests/utils.rs

@@ -0,0 +1,282 @@
+//! Integration tests for utility functions
+//!
+//! These tests mirror the JavaScript utility tests
+
+use command_stream::utils::{AnsiConfig, AnsiUtils, CommandResult, VirtualUtils, quote};
+use std::path::PathBuf;
+
+// ============================================================================
+// CommandResult Tests
+// ============================================================================
+
+#[test]
+fn test_command_result_success() {
+    let result = CommandResult::success("hello");
+    assert!(result.is_success());
+    assert_eq!(result.stdout, "hello");
+    assert_eq!(result.stderr, "");
+    assert_eq!(result.code, 0);
+}
+
+#[test]
+fn test_command_result_success_empty() {
+    let result = CommandResult::success_empty();
+    assert!(result.is_success());
+    assert_eq!(result.stdout, "");
+    assert_eq!(result.stderr, "");
+    assert_eq!(result.code, 0);
+}
+
+#[test]
+fn test_command_result_error() {
+    let result = CommandResult::error("something went wrong");
+    assert!(!result.is_success());
+    assert_eq!(result.stdout, "");
+    assert_eq!(result.stderr, "something went wrong");
+    assert_eq!(result.code, 1);
+}
+
+#[test]
+fn test_command_result_error_with_code() {
+    let result = CommandResult::error_with_code("not found", 127);
+    assert!(!result.is_success());
+    assert_eq!(result.code, 127);
+}
+
+// ============================================================================
+// VirtualUtils Tests
+// ============================================================================
+
+#[test]
+fn test_missing_operand_error() {
+    let result = VirtualUtils::missing_operand_error("cat");
+    assert!(!result.is_success());
+    assert!(result.stderr.contains("cat"));
+    assert!(result.stderr.contains("missing operand"));
+}
+
+#[test]
+fn test_invalid_argument_error() {
+    let result = VirtualUtils::invalid_argument_error("test", "invalid option");
+    assert!(!result.is_success());
+    assert!(result.stderr.contains("test"));
+    assert!(result.stderr.contains("invalid option"));
+}
+
+#[test]
+fn test_validate_args_sufficient() {
+    let args = vec!["arg1".to_string()];
+    let error = VirtualUtils::validate_args(&args, 1, "cmd");
+    assert!(error.is_none());
+}
+
+#[test]
+fn test_validate_args_insufficient() {
+    let args = vec![];
+    let error = VirtualUtils::validate_args(&args, 1, "cmd");
+    assert!(error.is_some());
+}
+
+#[test]
+fn test_resolve_path_absolute() {
+    let path = VirtualUtils::resolve_path("/absolute/path", None);
+    assert_eq!(path, PathBuf::from("/absolute/path"));
+}
+
+#[test]
+fn test_resolve_path_relative_with_cwd() {
+    let cwd = PathBuf::from("/home/user");
+    let path = VirtualUtils::resolve_path("relative/path", Some(&cwd));
+    assert_eq!(path, PathBuf::from("/home/user/relative/path"));
+}
+
+#[test]
+fn test_resolve_path_relative_without_cwd() {
+    let path = VirtualUtils::resolve_path("relative/path", None);
+    // Should resolve relative to current directory
+    assert!(path.ends_with("relative/path"));
+}
+
+// ============================================================================
+// AnsiUtils Tests
+// ============================================================================
+
+#[test]
+fn test_strip_ansi_basic() {
+    let text = "\x1b[31mRed text\x1b[0m";
+    assert_eq!(AnsiUtils::strip_ansi(text), "Red text");
+}
+
+#[test]
+fn test_strip_ansi_multiple() {
+    let text = "\x1b[1m\x1b[31mBold Red\x1b[0m normal";
+    let result = AnsiUtils::strip_ansi(text);
+    assert_eq!(result, "Bold Red normal");
+}
+
+#[test]
+fn test_strip_ansi_no_sequences() {
+    let text = "plain text";
+    assert_eq!(AnsiUtils::strip_ansi(text), "plain text");
+}
+
+#[test]
+fn test_strip_ansi_color_codes() {
+    let text = "\x1b[32mGreen\x1b[0m and \x1b[34mBlue\x1b[0m";
+    assert_eq!(AnsiUtils::strip_ansi(text), "Green and Blue");
+}
+
+#[test]
+fn test_strip_control_chars_basic() {
+    let text = "Hello\x00World";
+    assert_eq!(AnsiUtils::strip_control_chars(text), "HelloWorld");
+}
+
+#[test]
+fn test_strip_control_chars_preserve_newline() {
+    let text = "Line1\nLine2";
+    assert_eq!(AnsiUtils::strip_control_chars(text), "Line1\nLine2");
+}
+
+#[test]
+fn test_strip_control_chars_preserve_tab() {
+    let text = "Col1\tCol2";
+    assert_eq!(AnsiUtils::strip_control_chars(text), "Col1\tCol2");
+}
+
+#[test]
+fn test_strip_control_chars_preserve_carriage_return() {
+    let text = "Line1\r\nLine2";
+    assert_eq!(AnsiUtils::strip_control_chars(text), "Line1\r\nLine2");
+}
+
+#[test]
+fn test_strip_all() {
+    let text = "\x1b[31mRed\x00text\x1b[0m\nNewline";
+    let result = AnsiUtils::strip_all(text);
+    assert_eq!(result, "Redtext\nNewline");
+}
+
+// ============================================================================
+// AnsiConfig Tests
+// ============================================================================
+
+#[test]
+fn test_ansi_config_default() {
+    let config = AnsiConfig::default();
+    assert!(config.preserve_ansi);
+    assert!(config.preserve_control_chars);
+}
+
+#[test]
+fn test_ansi_config_process_preserve_all() {
+    let config = AnsiConfig {
+        preserve_ansi: true,
+        preserve_control_chars: true,
+    };
+    let text = "\x1b[31mRed\x00text\x1b[0m";
+    let result = config.process_output(text);
+    assert_eq!(result, text);
+}
+
+#[test]
+fn test_ansi_config_process_strip_ansi_only() {
+    let config = AnsiConfig {
+        preserve_ansi: false,
+        preserve_control_chars: true,
+    };
+    let text = "\x1b[31mRed text\x1b[0m";
+    let result = config.process_output(text);
+    assert_eq!(result, "Red text");
+}
+
+#[test]
+fn test_ansi_config_process_strip_control_only() {
+    let config = AnsiConfig {
+        preserve_ansi: true,
+        preserve_control_chars: false,
+    };
+    let text = "Hello\x00World\nNewline";
+    let result = config.process_output(text);
+    assert_eq!(result, "HelloWorld\nNewline");
+}
+
+#[test]
+fn test_ansi_config_process_strip_all() {
+    let config = AnsiConfig {
+        preserve_ansi: false,
+        preserve_control_chars: false,
+    };
+    let text = "\x1b[31mRed\x00text\x1b[0m";
+    let result = config.process_output(text);
+    assert_eq!(result, "Redtext");
+}
+
+// ============================================================================
+// Quote Function Tests
+// ============================================================================
+
+#[test]
+fn test_quote_empty_string() {
+    assert_eq!(quote(""), "''");
+}
+
+#[test]
+fn test_quote_simple_string() {
+    assert_eq!(quote("hello"), "hello");
+}
+
+#[test]
+fn test_quote_path() {
+    assert_eq!(quote("/path/to/file"), "/path/to/file");
+}
+
+#[test]
+fn test_quote_with_spaces() {
+    assert_eq!(quote("hello world"), "'hello world'");
+}
+
+#[test]
+fn test_quote_with_single_quote() {
+    assert_eq!(quote("it's"), "'it'\\''s'");
+}
+
+#[test]
+fn test_quote_already_single_quoted() {
+    assert_eq!(quote("'hello'"), "'hello'");
+}
+
+#[test]
+fn test_quote_already_double_quoted() {
+    let result = quote("\"hello\"");
+    assert!(result.contains("hello"));
+}
+
+#[test]
+fn test_quote_safe_characters() {
+    // These should not need quoting
+    assert_eq!(quote("file.txt"), "file.txt");
+    assert_eq!(quote("path/to/file"), "path/to/file");
+    assert_eq!(quote("key=value"), "key=value");
+    assert_eq!(quote("user@host"), "user@host");
+}
+
+#[test]
+fn test_quote_special_characters() {
+    // These need quoting
+    let result = quote("hello$world");
+    assert!(result.starts_with("'") && result.ends_with("'"));
+
+    let result = quote("hello;world");
+    assert!(result.starts_with("'") && result.ends_with("'"));
+
+    let result = quote("hello|world");
+    assert!(result.starts_with("'") && result.ends_with("'"));
+}
+
+#[test]
+fn test_quote_newline() {
+    let result = quote("hello\nworld");
+    assert!(result.contains("hello"));
+    assert!(result.contains("world"));
+}

package/rust/tests/virtual_commands.rs

@@ -0,0 +1,199 @@
+//! Integration tests for virtual command system
+//!
+//! These tests mirror the JavaScript tests in js/tests/virtual.test.mjs
+
+use command_stream::commands::{
+    are_virtual_commands_enabled, disable_virtual_commands, enable_virtual_commands,
+    CommandContext, VirtualCommandRegistry,
+};
+use command_stream::{run, ProcessRunner, RunOptions};
+
+// ============================================================================
+// Virtual Commands Enable/Disable Tests
+// ============================================================================
+
+#[test]
+fn test_virtual_commands_default_enabled() {
+    assert!(are_virtual_commands_enabled());
+}
+
+#[test]
+fn test_disable_virtual_commands() {
+    enable_virtual_commands(); // Ensure enabled first
+    disable_virtual_commands();
+    assert!(!are_virtual_commands_enabled());
+    enable_virtual_commands(); // Restore
+}
+
+#[test]
+fn test_enable_virtual_commands() {
+    disable_virtual_commands();
+    enable_virtual_commands();
+    assert!(are_virtual_commands_enabled());
+}
+
+// ============================================================================
+// Virtual Command Registry Tests
+// ============================================================================
+
+#[test]
+fn test_registry_new() {
+    let registry = VirtualCommandRegistry::new();
+    assert!(registry.list().is_empty());
+}
+
+#[test]
+fn test_registry_contains() {
+    let registry = VirtualCommandRegistry::new();
+    assert!(!registry.contains("nonexistent"));
+}
+
+// ============================================================================
+// CommandContext Tests
+// ============================================================================
+
+#[test]
+fn test_command_context_new() {
+    let ctx = CommandContext::new(vec!["arg1".to_string(), "arg2".to_string()]);
+    assert_eq!(ctx.args.len(), 2);
+    assert_eq!(ctx.args[0], "arg1");
+    assert_eq!(ctx.args[1], "arg2");
+}
+
+#[test]
+fn test_command_context_get_cwd() {
+    let ctx = CommandContext::new(vec![]);
+    let cwd = ctx.get_cwd();
+    assert!(cwd.exists());
+}
+
+#[test]
+fn test_command_context_with_cwd() {
+    let ctx = CommandContext {
+        args: vec![],
+        stdin: None,
+        cwd: Some(std::path::PathBuf::from("/tmp")),
+        env: None,
+        output_tx: None,
+        is_cancelled: None,
+    };
+    assert_eq!(ctx.get_cwd(), std::path::PathBuf::from("/tmp"));
+}
+
+#[test]
+fn test_command_context_is_cancelled_default() {
+    let ctx = CommandContext::new(vec![]);
+    assert!(!ctx.is_cancelled());
+}
+
+#[test]
+fn test_command_context_is_cancelled_with_fn() {
+    let ctx = CommandContext {
+        args: vec![],
+        stdin: None,
+        cwd: None,
+        env: None,
+        output_tx: None,
+        is_cancelled: Some(Box::new(|| true)),
+    };
+    assert!(ctx.is_cancelled());
+}
+
+// ============================================================================
+// Built-in Command Execution Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_execute_virtual_echo() {
+    enable_virtual_commands();
+    let result = run("echo Hello World").await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("Hello World"));
+}
+
+#[tokio::test]
+async fn test_execute_virtual_pwd() {
+    enable_virtual_commands();
+    let result = run("pwd").await.unwrap();
+    assert!(result.is_success());
+    assert!(!result.stdout.is_empty());
+}
+
+#[tokio::test]
+async fn test_execute_virtual_true() {
+    enable_virtual_commands();
+    let result = run("true").await.unwrap();
+    assert!(result.is_success());
+    assert_eq!(result.code, 0);
+}
+
+#[tokio::test]
+async fn test_execute_virtual_false() {
+    enable_virtual_commands();
+    let result = run("false").await.unwrap();
+    assert!(!result.is_success());
+    assert_eq!(result.code, 1);
+}
+
+#[tokio::test]
+async fn test_execute_virtual_exit() {
+    enable_virtual_commands();
+
+    let result = run("exit 0").await.unwrap();
+    assert_eq!(result.code, 0);
+
+    let result = run("exit 42").await.unwrap();
+    assert_eq!(result.code, 42);
+}
+
+#[tokio::test]
+async fn test_execute_virtual_which() {
+    enable_virtual_commands();
+    let result = run("which echo").await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("shell builtin"));
+}
+
+#[tokio::test]
+async fn test_execute_virtual_sleep() {
+    enable_virtual_commands();
+    let start = std::time::Instant::now();
+    let result = run("sleep 0.1").await.unwrap();
+    let elapsed = start.elapsed();
+
+    assert!(result.is_success());
+    assert!(elapsed.as_millis() >= 90);
+    assert!(elapsed.as_millis() < 300);
+}
+
+#[tokio::test]
+async fn test_execute_echo_with_n_flag() {
+    enable_virtual_commands();
+    let result = run("echo -n Hello").await.unwrap();
+    assert!(result.is_success());
+    assert_eq!(result.stdout.trim(), "Hello");
+    // -n flag should not add newline
+    assert!(!result.stdout.ends_with("\n\n"));
+}
+
+// ============================================================================
+// Process Runner with Virtual Commands Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_process_runner_virtual_echo() {
+    enable_virtual_commands();
+    let mut runner = ProcessRunner::new("echo test virtual", RunOptions::default());
+    let result = runner.run().await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("test virtual"));
+}
+
+#[tokio::test]
+async fn test_process_runner_virtual_pwd() {
+    enable_virtual_commands();
+    let mut runner = ProcessRunner::new("pwd", RunOptions::default());
+    let result = runner.run().await.unwrap();
+    assert!(result.is_success());
+    assert!(!result.stdout.is_empty());
+}