command-stream 0.9.0 → 0.9.2

package/rust/tests/pipeline.rs

@@ -0,0 +1,93 @@
+//! Tests for the Pipeline module
+
+use command_stream::{Pipeline, PipelineExt, ProcessRunner, RunOptions};
+
+#[tokio::test]
+async fn test_pipeline_simple() {
+    let result = Pipeline::new()
+        .add("echo hello world")
+        .run()
+        .await
+        .unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello world"));
+}
+
+#[tokio::test]
+async fn test_pipeline_two_commands() {
+    let result = Pipeline::new()
+        .add("echo 'hello\nworld\nhello again'")
+        .add("grep hello")
+        .run()
+        .await
+        .unwrap();
+
+    assert!(result.is_success());
+    // The grep should filter to only lines containing "hello"
+    assert!(result.stdout.contains("hello"));
+}
+
+#[tokio::test]
+async fn test_pipeline_with_stdin() {
+    let result = Pipeline::new()
+        .stdin("line1\nline2\nline3")
+        .add("cat")
+        .run()
+        .await
+        .unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("line1"));
+    assert!(result.stdout.contains("line2"));
+    assert!(result.stdout.contains("line3"));
+}
+
+#[tokio::test]
+async fn test_pipeline_three_commands() {
+    let result = Pipeline::new()
+        .add("echo 'apple\nbanana\napricot\nblueberry'")
+        .add("grep a")
+        .add("wc -l")
+        .run()
+        .await
+        .unwrap();
+
+    assert!(result.is_success());
+    // Should count lines containing 'a': apple, banana, apricot = 3 lines
+}
+
+#[tokio::test]
+async fn test_pipeline_empty() {
+    let result = Pipeline::new().run().await.unwrap();
+
+    // Empty pipeline should return error
+    assert!(!result.is_success());
+    assert!(result.stderr.contains("No commands"));
+}
+
+#[tokio::test]
+async fn test_pipeline_failure_propagation() {
+    let result = Pipeline::new()
+        .add("echo hello")
+        .add("false")  // This command always fails
+        .add("echo should not reach here")
+        .run()
+        .await
+        .unwrap();
+
+    // Pipeline should fail because 'false' returns non-zero
+    assert!(!result.is_success());
+}
+
+#[tokio::test]
+async fn test_pipeline_builder_pattern() {
+    // Test the fluent API
+    let pipeline = Pipeline::new()
+        .add("echo test")
+        .mirror_output(false)
+        .capture_output(true);
+
+    let result = pipeline.run().await.unwrap();
+    assert!(result.is_success());
+}

package/rust/tests/state.rs

@@ -0,0 +1,207 @@
+//! Integration tests for the state module
+
+use command_stream::state::{GlobalState, ShellSettings};
+
+#[test]
+fn test_shell_settings_default() {
+    let settings = ShellSettings::new();
+    assert!(!settings.errexit);
+    assert!(!settings.verbose);
+    assert!(!settings.xtrace);
+    assert!(!settings.pipefail);
+    assert!(!settings.nounset);
+    assert!(!settings.noglob);
+    assert!(!settings.allexport);
+}
+
+#[test]
+fn test_shell_settings_set_short_flags() {
+    let mut settings = ShellSettings::new();
+
+    settings.set("e", true);
+    assert!(settings.errexit);
+
+    settings.set("v", true);
+    assert!(settings.verbose);
+
+    settings.set("x", true);
+    assert!(settings.xtrace);
+
+    settings.set("u", true);
+    assert!(settings.nounset);
+
+    settings.set("f", true);
+    assert!(settings.noglob);
+
+    settings.set("a", true);
+    assert!(settings.allexport);
+}
+
+#[test]
+fn test_shell_settings_set_long_names() {
+    let mut settings = ShellSettings::new();
+
+    settings.set("errexit", true);
+    assert!(settings.errexit);
+
+    settings.set("verbose", true);
+    assert!(settings.verbose);
+
+    settings.set("xtrace", true);
+    assert!(settings.xtrace);
+
+    settings.set("nounset", true);
+    assert!(settings.nounset);
+
+    settings.set("pipefail", true);
+    assert!(settings.pipefail);
+}
+
+#[test]
+fn test_shell_settings_enable_disable() {
+    let mut settings = ShellSettings::new();
+
+    settings.enable("errexit");
+    assert!(settings.errexit);
+
+    settings.disable("errexit");
+    assert!(!settings.errexit);
+}
+
+#[test]
+fn test_shell_settings_reset() {
+    let mut settings = ShellSettings::new();
+
+    settings.enable("errexit");
+    settings.enable("verbose");
+    settings.enable("pipefail");
+
+    settings.reset();
+
+    assert!(!settings.errexit);
+    assert!(!settings.verbose);
+    assert!(!settings.pipefail);
+}
+
+#[tokio::test]
+async fn test_global_state_shell_settings() {
+    let state = GlobalState::new();
+
+    // Default settings
+    let settings = state.get_shell_settings().await;
+    assert!(!settings.errexit);
+
+    // Enable option
+    state.enable_shell_option("errexit").await;
+    let settings = state.get_shell_settings().await;
+    assert!(settings.errexit);
+
+    // Disable option
+    state.disable_shell_option("errexit").await;
+    let settings = state.get_shell_settings().await;
+    assert!(!settings.errexit);
+}
+
+#[tokio::test]
+async fn test_global_state_runner_registration() {
+    let state = GlobalState::new();
+
+    assert_eq!(state.active_runner_count().await, 0);
+
+    let id1 = state.register_runner().await;
+    assert_eq!(state.active_runner_count().await, 1);
+
+    let id2 = state.register_runner().await;
+    assert_eq!(state.active_runner_count().await, 2);
+
+    // IDs should be unique
+    assert!(id1 != id2);
+
+    state.unregister_runner(id1).await;
+    assert_eq!(state.active_runner_count().await, 1);
+
+    state.unregister_runner(id2).await;
+    assert_eq!(state.active_runner_count().await, 0);
+}
+
+#[tokio::test]
+async fn test_global_state_virtual_commands() {
+    let state = GlobalState::new();
+
+    // Enabled by default
+    assert!(state.are_virtual_commands_enabled());
+
+    state.disable_virtual_commands();
+    assert!(!state.are_virtual_commands_enabled());
+
+    state.enable_virtual_commands();
+    assert!(state.are_virtual_commands_enabled());
+}
+
+#[tokio::test]
+async fn test_global_state_signal_handlers() {
+    let state = GlobalState::new();
+
+    // Not installed by default
+    assert!(!state.are_signal_handlers_installed());
+
+    state.set_signal_handlers_installed(true);
+    assert!(state.are_signal_handlers_installed());
+
+    state.set_signal_handlers_installed(false);
+    assert!(!state.are_signal_handlers_installed());
+}
+
+#[tokio::test]
+async fn test_global_state_reset() {
+    let state = GlobalState::new();
+
+    // Modify state
+    state.enable_shell_option("errexit").await;
+    state.enable_shell_option("pipefail").await;
+    state.register_runner().await;
+    state.register_runner().await;
+    state.disable_virtual_commands();
+
+    // Reset
+    state.reset().await;
+
+    // Verify reset
+    let settings = state.get_shell_settings().await;
+    assert!(!settings.errexit);
+    assert!(!settings.pipefail);
+    assert_eq!(state.active_runner_count().await, 0);
+    assert!(state.are_virtual_commands_enabled());
+}
+
+#[tokio::test]
+async fn test_global_state_with_shell_settings() {
+    let state = GlobalState::new();
+
+    state
+        .with_shell_settings(|settings| {
+            settings.errexit = true;
+            settings.verbose = true;
+        })
+        .await;
+
+    let settings = state.get_shell_settings().await;
+    assert!(settings.errexit);
+    assert!(settings.verbose);
+}
+
+#[tokio::test]
+async fn test_global_state_initial_cwd() {
+    let state = GlobalState::new();
+
+    let cwd = state.get_initial_cwd().await;
+    // Should have an initial cwd
+    assert!(cwd.is_some());
+}
+
+#[test]
+fn test_global_state_default() {
+    let state = GlobalState::default();
+    assert!(state.are_virtual_commands_enabled());
+    assert!(!state.are_signal_handlers_installed());
+}

package/rust/tests/stream.rs

@@ -0,0 +1,102 @@
+//! Tests for the streaming module
+
+use command_stream::{StreamingRunner, OutputChunk, AsyncIterator};
+
+#[tokio::test]
+async fn test_streaming_runner_basic() {
+    let runner = StreamingRunner::new("echo hello world");
+    let result = runner.collect().await.unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello world"));
+}
+
+#[tokio::test]
+async fn test_streaming_runner_with_stdin() {
+    let runner = StreamingRunner::new("cat")
+        .stdin("test input");
+    let result = runner.collect().await.unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("test input"));
+}
+
+#[tokio::test]
+async fn test_output_stream_chunks() {
+    let runner = StreamingRunner::new("echo chunk1 && echo chunk2");
+    let mut stream = runner.stream();
+
+    let mut stdout_chunks = Vec::new();
+    let mut exit_code = None;
+
+    while let Some(chunk) = stream.next().await {
+        match chunk {
+            OutputChunk::Stdout(data) => {
+                stdout_chunks.push(String::from_utf8_lossy(&data).to_string());
+            }
+            OutputChunk::Stderr(_) => {}
+            OutputChunk::Exit(code) => {
+                exit_code = Some(code);
+            }
+        }
+    }
+
+    assert!(exit_code.is_some());
+    assert_eq!(exit_code.unwrap(), 0);
+    let combined: String = stdout_chunks.join("");
+    assert!(combined.contains("chunk1"));
+    assert!(combined.contains("chunk2"));
+}
+
+#[tokio::test]
+async fn test_streaming_collect_stdout() {
+    let runner = StreamingRunner::new("echo stdout only");
+    let stream = runner.stream();
+
+    let stdout = stream.collect_stdout().await;
+    let stdout_str = String::from_utf8_lossy(&stdout);
+
+    assert!(stdout_str.contains("stdout only"));
+}
+
+#[tokio::test]
+async fn test_streaming_stderr() {
+    // Using sh -c to redirect to stderr
+    let runner = StreamingRunner::new("sh -c 'echo error message >&2'");
+    let result = runner.collect().await.unwrap();
+
+    assert!(result.stderr.contains("error message"));
+}
+
+#[tokio::test]
+async fn test_streaming_exit_code() {
+    let runner = StreamingRunner::new("exit 42");
+    let result = runner.collect().await.unwrap();
+
+    assert_eq!(result.code, 42);
+}
+
+#[tokio::test]
+async fn test_streaming_runner_cwd() {
+    let runner = StreamingRunner::new("pwd")
+        .cwd("/tmp");
+    let result = runner.collect().await.unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("/tmp"));
+}
+
+#[tokio::test]
+async fn test_streaming_runner_env() {
+    use std::collections::HashMap;
+
+    let mut env = HashMap::new();
+    env.insert("TEST_VAR".to_string(), "test_value".to_string());
+
+    let runner = StreamingRunner::new("sh -c 'echo $TEST_VAR'")
+        .env(env);
+    let result = runner.collect().await.unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("test_value"));
+}