Implement WorkdirRoot configuration feature

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

tests/workdir_root.rs

@@ -0,0 +1,181 @@
+//! Tests for workdir root configuration functionality
+
+use std::fs;
+use tempfile::TempDir;
+use testscript_rs::testscript;
+
+#[test]
+fn test_workdir_root_basic_functionality() {
+    // Create a temporary directory to use as our custom root
+    let custom_root = TempDir::new().unwrap();
+    let custom_root_path = custom_root.path();
+
+    // Create a test directory structure
+    let testdata_dir = TempDir::new().unwrap();
+    let testdata_path = testdata_dir.path().join("testdata");
+    fs::create_dir(&testdata_path).unwrap();
+
+    let test_content = r#"exec echo "hello from custom root"
+stdout "hello from custom root"
+
+-- test_file.txt --
+Test content in custom root
+"#;
+
+    fs::write(testdata_path.join("custom_root_test.txt"), test_content).unwrap();
+
+    // Run test with custom workdir root
+    let result = testscript::run(testdata_path.to_string_lossy())
+        .workdir_root(custom_root_path)
+        .execute();
+
+    assert!(result.is_ok(), "Test with custom workdir root failed: {:?}", result);
+
+    // Verify that temporary directories were created in our custom root
+    // (Note: the actual temp directories are cleaned up after the test runs,
+    // but we can verify the API works without errors)
+}
+
+#[test]
+fn test_workdir_root_nonexistent_directory() {
+    let testdata_dir = TempDir::new().unwrap();
+    let testdata_path = testdata_dir.path().join("testdata");
+    fs::create_dir(&testdata_path).unwrap();
+
+    let test_content = r#"exec echo "test"
+stdout "test"
+"#;
+
+    fs::write(testdata_path.join("simple_test.txt"), test_content).unwrap();
+
+    // Try to use a non-existent directory as workdir root
+    let nonexistent_path = "/this/path/does/not/exist";
+    let result = testscript::run(testdata_path.to_string_lossy())
+        .workdir_root(nonexistent_path)
+        .execute();
+
+    assert!(result.is_err(), "Expected error for non-existent workdir root");
+    let error_msg = format!("{:?}", result.unwrap_err());
+    assert!(error_msg.contains("does not exist"), "Error should mention directory doesn't exist");
+}
+
+#[test]
+fn test_workdir_root_not_a_directory() {
+    let temp_dir = TempDir::new().unwrap();
+    
+    // Create a file (not directory) to test the validation
+    let file_path = temp_dir.path().join("not_a_directory.txt");
+    fs::write(&file_path, "this is a file").unwrap();
+
+    let testdata_dir = TempDir::new().unwrap();
+    let testdata_path = testdata_dir.path().join("testdata");
+    fs::create_dir(&testdata_path).unwrap();
+
+    let test_content = r#"exec echo "test"
+stdout "test"
+"#;
+
+    fs::write(testdata_path.join("simple_test.txt"), test_content).unwrap();
+
+    // Try to use a file as workdir root
+    let result = testscript::run(testdata_path.to_string_lossy())
+        .workdir_root(&file_path)
+        .execute();
+
+    assert!(result.is_err(), "Expected error for file used as workdir root");
+    let error_msg = format!("{:?}", result.unwrap_err());
+    assert!(error_msg.contains("not a directory"), "Error should mention path is not a directory");
+}
+
+#[test]
+fn test_workdir_root_readonly_directory() {
+    // This test is tricky because creating a truly read-only directory
+    // that we can't write to requires platform-specific code and may fail
+    // in test environments. We'll skip this for now and rely on the validation
+    // in the actual tempfile::TempDir::new_in() call.
+}
+
+#[test]
+fn test_workdir_root_with_preserve_work() {
+    // Create a temporary directory to use as our custom root
+    let custom_root = TempDir::new().unwrap();
+    let custom_root_path = custom_root.path();
+
+    // Create a test directory structure
+    let testdata_dir = TempDir::new().unwrap();
+    let testdata_path = testdata_dir.path().join("testdata");
+    fs::create_dir(&testdata_path).unwrap();
+
+    let test_content = r#"exec echo "combined features test"
+stdout "combined features test"
+
+-- config.txt --
+Configuration file for testing
+"#;
+
+    fs::write(testdata_path.join("combined_test.txt"), test_content).unwrap();
+
+    // Test that workdir_root can be combined with other features
+    let result = testscript::run(testdata_path.to_string_lossy())
+        .workdir_root(custom_root_path)
+        .preserve_work_on_failure(true)
+        .execute();
+
+    assert!(result.is_ok(), "Combined features test failed: {:?}", result);
+}
+
+#[test]
+fn test_workdir_root_with_custom_command() {
+    // Create a temporary directory to use as our custom root
+    let custom_root = TempDir::new().unwrap();
+    let custom_root_path = custom_root.path();
+
+    // Create a test directory structure
+    let testdata_dir = TempDir::new().unwrap();
+    let testdata_path = testdata_dir.path().join("testdata");
+    fs::create_dir(&testdata_path).unwrap();
+
+    let test_content = r#"custom-echo hello world
+"#;
+
+    fs::write(testdata_path.join("custom_cmd_test.txt"), test_content).unwrap();
+
+    // Test that workdir_root works with custom commands
+    let result = testscript::run(testdata_path.to_string_lossy())
+        .workdir_root(custom_root_path)
+        .command("custom-echo", |_env, args| {
+            // Simple custom command that just validates args exist
+            if args.is_empty() {
+                return Err(testscript_rs::Error::Generic(
+                    "custom-echo requires arguments".to_string(),
+                ));
+            }
+            Ok(())
+        })
+        .execute();
+
+    assert!(result.is_ok(), "Custom command with workdir root failed: {:?}", result);
+}
+
+#[test]
+fn test_workdir_root_api_chaining() {
+    // Test that the API method exists and can be chained
+    let custom_root = TempDir::new().unwrap();
+    let testdata_dir = TempDir::new().unwrap();
+    let testdata_path = testdata_dir.path().join("testdata");
+    fs::create_dir(&testdata_path).unwrap();
+
+    let test_content = r#"exec echo "chaining test"
+stdout "chaining test"
+"#;
+
+    fs::write(testdata_path.join("chain_test.txt"), test_content).unwrap();
+
+    let result = testscript::run(testdata_path.to_string_lossy())
+        .workdir_root(custom_root.path())
+        .workdir_root(custom_root.path()) // Can be called multiple times
+        .preserve_work_on_failure(false)
+        .execute();
+
+    assert!(result.is_ok(), "API chaining test failed: {:?}", result);
+}