sync from monorepo @ 2452e92e

crates/dirigent_tools/tests/common/mod.rs

@@ -0,0 +1,108 @@
+//! Common test utilities for dirigent_tools.
+//!
+//! This module provides shared test utilities used across all test files.
+
+use std::path::{Path, PathBuf};
+use tempfile::TempDir;
+
+/// Create a temporary directory for testing.
+///
+/// The directory is automatically cleaned up when the TempDir is dropped.
+pub fn create_temp_dir() -> TempDir {
+    tempfile::tempdir().expect("Failed to create temp directory")
+}
+
+/// Create a temporary directory with a specific prefix.
+pub fn create_temp_dir_with_prefix(prefix: &str) -> TempDir {
+    tempfile::Builder::new()
+        .prefix(prefix)
+        .tempdir()
+        .expect("Failed to create temp directory with prefix")
+}
+
+/// Create a file in a directory with given content.
+pub fn create_test_file(dir: &Path, filename: &str, content: &str) -> PathBuf {
+    let file_path = dir.join(filename);
+    std::fs::write(&file_path, content).expect("Failed to write test file");
+    file_path
+}
+
+/// Read a file and return its content.
+pub fn read_file_content(path: &Path) -> String {
+    std::fs::read_to_string(path).expect("Failed to read file")
+}
+
+/// Create a sandboxed test environment with configured allowed roots.
+pub struct SandboxedTestEnv {
+    // RAII: TempDir must be kept alive to prevent premature cleanup
+    pub _temp_dir: TempDir,
+    pub allowed_root: PathBuf,
+    pub blocked_dir: PathBuf,
+    pub outside_dir: TempDir,
+}
+
+impl SandboxedTestEnv {
+    /// Create a new sandboxed test environment.
+    pub fn new() -> Self {
+        let temp_dir = create_temp_dir();
+        let allowed_root = temp_dir.path().to_path_buf();
+        let blocked_dir = allowed_root.join("blocked");
+        let outside_dir = create_temp_dir_with_prefix("outside");
+
+        std::fs::create_dir_all(&blocked_dir).expect("Failed to create blocked directory");
+
+        Self {
+            _temp_dir: temp_dir,
+            allowed_root,
+            blocked_dir,
+            outside_dir,
+        }
+    }
+
+    /// Create a file inside the allowed root.
+    pub fn create_allowed_file(&self, filename: &str, content: &str) -> PathBuf {
+        create_test_file(&self.allowed_root, filename, content)
+    }
+
+    /// Create a file outside the allowed root.
+    pub fn create_outside_file(&self, filename: &str, content: &str) -> PathBuf {
+        create_test_file(self.outside_dir.path(), filename, content)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_temp_dir() {
+        let temp_dir = create_temp_dir();
+        assert!(temp_dir.path().exists());
+    }
+
+    #[test]
+    fn test_create_test_file() {
+        let temp_dir = create_temp_dir();
+        let file_path = create_test_file(temp_dir.path(), "test.txt", "Hello, world!");
+        assert!(file_path.exists());
+        assert_eq!(read_file_content(&file_path), "Hello, world!");
+    }
+
+    #[test]
+    fn test_sandboxed_test_env() {
+        let env = SandboxedTestEnv::new();
+        assert!(env.allowed_root.exists());
+        assert!(env.blocked_dir.exists());
+        assert!(env.outside_dir.path().exists());
+
+        let allowed_file = env.create_allowed_file("test.txt", "allowed");
+        let outside_file = env.create_outside_file("test.txt", "outside");
+
+        assert!(allowed_file.exists());
+        assert!(outside_file.exists());
+        assert_ne!(
+            allowed_file.parent().unwrap(),
+            outside_file.parent().unwrap()
+        );
+    }
+}