Implement TestWork functionality for preserving working directories on failure

Co-authored-by: imjasonh <210737+imjasonh@users.noreply.github.com>

tests/preserve_work.rs

@@ -0,0 +1,160 @@
+//! Tests for work directory preservation functionality
+
+use std::fs;
+use std::process::Command;
+use tempfile::TempDir;
+
+#[test]
+fn test_preserve_work_on_failure_disabled_by_default() {
+    // Create a failing test
+    let temp_dir = TempDir::new().unwrap();
+    let testdata_dir = temp_dir.path().join("testdata");
+    fs::create_dir(&testdata_dir).unwrap();
+
+    let test_content = r#"exec echo "hello"
+stdout "goodbye"
+"#;
+
+    fs::write(testdata_dir.join("failing_test.txt"), test_content).unwrap();
+
+    let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy()).execute();
+    
+    // Should fail
+    assert!(result.is_err());
+    
+    // Work directory should be cleaned up (we can't easily test this since TempDir cleanup is automatic)
+}
+
+#[test]
+fn test_preserve_work_on_failure_enabled() {
+    // Create a failing test
+    let temp_dir = TempDir::new().unwrap();
+    let testdata_dir = temp_dir.path().join("testdata");
+    fs::create_dir(&testdata_dir).unwrap();
+
+    let test_content = r#"exec echo "hello"
+stdout "goodbye"
+
+-- test_file.txt --
+This is test content
+"#;
+
+    fs::write(testdata_dir.join("failing_test.txt"), test_content).unwrap();
+
+    // We need to capture stderr to see the preservation message
+    // Since we can't easily capture stderr from the current process, 
+    // we'll create a subprocess that runs our test
+    let output = Command::new("cargo")
+        .args(&["run", "--example", "test_runner"])
+        .current_dir("/home/runner/work/testscript-rs/testscript-rs")
+        .env("TESTSCRIPT_TEST_DIR", testdata_dir.to_string_lossy().as_ref())
+        .env("TESTSCRIPT_PRESERVE_WORK", "true")
+        .output();
+
+    if let Ok(output) = output {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        // Should contain preservation message
+        assert!(stderr.contains("Work directory preserved at:"));
+    } else {
+        // Fallback test - just ensure the API works
+        let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
+            .preserve_work_on_failure(true)
+            .execute();
+        
+        assert!(result.is_err());
+    }
+}
+
+#[test]
+fn test_preserve_work_on_success_no_preservation() {
+    // Create a passing test
+    let temp_dir = TempDir::new().unwrap();
+    let testdata_dir = temp_dir.path().join("testdata");
+    fs::create_dir(&testdata_dir).unwrap();
+
+    let test_content = r#"exec echo "hello"
+stdout "hello"
+
+-- test_file.txt --
+This is test content
+"#;
+
+    fs::write(testdata_dir.join("passing_test.txt"), test_content).unwrap();
+
+    let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
+        .preserve_work_on_failure(true)
+        .execute();
+    
+    // Should succeed and not preserve directory
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_preserve_work_with_skip() {
+    // Create a test that skips
+    let temp_dir = TempDir::new().unwrap();
+    let testdata_dir = temp_dir.path().join("testdata");
+    fs::create_dir(&testdata_dir).unwrap();
+
+    let test_content = r#"skip this test is skipped
+
+-- test_file.txt --
+This is test content
+"#;
+
+    fs::write(testdata_dir.join("skip_test.txt"), test_content).unwrap();
+
+    let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
+        .preserve_work_on_failure(true)
+        .execute();
+    
+    // Should fail due to skip, but this tests that the preserve logic handles skip correctly
+    assert!(result.is_err());
+    if let Err(e) = result {
+        // The error might be wrapped in script context, so just check for skip-related content
+        let error_str = e.to_string();
+        assert!(error_str.contains("SKIP") || error_str.contains("Test skipped") || error_str.contains("skip"));
+    }
+}
+
+#[test] 
+fn test_preserve_work_with_background_process_failure() {
+    // Create a test that fails during background process cleanup
+    let temp_dir = TempDir::new().unwrap();
+    let testdata_dir = temp_dir.path().join("testdata");
+    fs::create_dir(&testdata_dir).unwrap();
+
+    let test_content = r#"exec sleep 10 &
+wait sleep
+"#;
+
+    fs::write(testdata_dir.join("bg_test.txt"), test_content).unwrap();
+
+    // We don't assert success/failure here since sleep behavior varies, but the test exercises the code
+    let _result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
+        .preserve_work_on_failure(true)
+        .execute();
+    
+    // We don't assert success/failure here since sleep behavior varies, but the test exercises the code
+}
+
+#[test]
+fn test_builder_preserve_work_method_exists() {
+    // Test that the API exists and can be chained
+    let temp_dir = TempDir::new().unwrap();
+    let testdata_dir = temp_dir.path().join("testdata");
+    fs::create_dir(&testdata_dir).unwrap();
+
+    let test_content = r#"exec echo "hello"
+stdout "hello"
+"#;
+
+    fs::write(testdata_dir.join("simple_test.txt"), test_content).unwrap();
+
+    let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
+        .preserve_work_on_failure(true)
+        .preserve_work_on_failure(false)  // Can be chained and overridden
+        .execute();
+    
+    assert!(result.is_ok());
+}