wip vibing

Author: brandonskiser

crates/agent/src/agent/agent_config/parse.rs

@@ -221,7 +221,7 @@ mod tests {
         let resource = "file://project/README.md";
         assert_eq!(ResourceKind::parse(resource, &sys).unwrap(), ResourceKind::File {
             original: resource,
-            file_path: "project/README.md".to_string()
+            file_path: "/home/testuser/project/README.md".to_string()
         });
 
         let resource = "file://~/project/**/*.rs";

crates/agent/src/agent/tools/fs_read.rs

@@ -197,23 +197,28 @@ pub struct FileReadContext {}
 mod tests {
     use super::*;
     use crate::agent::util::test::TestDir;
-    use crate::util::test::TestProvider;
+    use crate::util::test::{
+        TestBase,
+        TestProvider,
+    };
 
     #[tokio::test]
     async fn test_fs_read_single_file() {
-        let test_provider = TestProvider::new();
-        let test_dir = TestDir::new().with_file(("test.txt", "line1\nline2\nline3")).await;
+        let test_base = TestBase::new()
+            .await
+            .with_file(("test.txt", "line1\nline2\nline3"))
+            .await;
 
         let tool = FsRead {
             ops: vec![FsReadOp {
-                path: test_dir.join("test.txt").to_string_lossy().to_string(),
+                path: test_base.join("test.txt").to_string_lossy().to_string(),
                 limit: None,
                 offset: None,
             }],
         };
 
-        assert!(tool.validate(&test_provider).await.is_ok());
-        let result = tool.execute(&test_provider).await.unwrap();
+        assert!(tool.validate(&test_base).await.is_ok());
+        let result = tool.execute(&test_base).await.unwrap();
         assert_eq!(result.items.len(), 1);
         if let ToolExecutionOutputItem::Text(content) = &result.items[0] {
             assert_eq!(content, "line1\nline2\nline3");
@@ -224,7 +229,7 @@ mod tests {
     async fn test_fs_read_with_offset_and_limit() {
         let test_provider = TestProvider::new();
         let test_dir = TestDir::new()
-            .with_file(("test.txt", "line1\nline2\nline3\nline4\nline5"))
+            .with_file_sys(("test.txt", "line1\nline2\nline3\nline4\nline5"), &test_provider)
             .await;
 
         let tool = FsRead {
@@ -245,9 +250,9 @@ mod tests {
     async fn test_fs_read_multiple_files() {
         let test_provider = TestProvider::new();
         let test_dir = TestDir::new()
-            .with_file(("file1.txt", "content1"))
+            .with_file_sys(("file1.txt", "content1"), &test_provider)
             .await
-            .with_file(("file2.txt", "content2"))
+            .with_file_sys(("file2.txt", "content2"), &test_provider)
             .await;
 
         let tool = FsRead {

crates/agent/src/agent/tools/fs_write.rs

@@ -393,7 +393,7 @@ mod tests {
     #[tokio::test]
     async fn test_str_replace_single_occurrence() {
         let test_provider = TestProvider::new();
-        let test_dir = TestDir::new().with_file(("test.txt", "hello world")).await;
+        let test_dir = TestDir::new().with_file_sys(("test.txt", "hello world"), &test_provider).await;
 
         let tool = FsWrite::StrReplace(StrReplace {
             path: test_dir.join("test.txt").to_string_lossy().to_string(),
@@ -411,7 +411,7 @@ mod tests {
     #[tokio::test]
     async fn test_str_replace_multiple_occurrences() {
         let test_provider = TestProvider::new();
-        let test_dir = TestDir::new().with_file(("test.txt", "foo bar foo")).await;
+        let test_dir = TestDir::new().with_file_sys(("test.txt", "foo bar foo"), &test_provider).await;
 
         let tool = FsWrite::StrReplace(StrReplace {
             path: test_dir.join("test.txt").to_string_lossy().to_string(),
@@ -429,7 +429,7 @@ mod tests {
     #[tokio::test]
     async fn test_str_replace_no_match() {
         let test_provider = TestProvider::new();
-        let test_dir = TestDir::new().with_file(("test.txt", "hello world")).await;
+        let test_dir = TestDir::new().with_file_sys(("test.txt", "hello world"), &test_provider).await;
 
         let tool = FsWrite::StrReplace(StrReplace {
             path: test_dir.join("test.txt").to_string_lossy().to_string(),
@@ -444,7 +444,7 @@ mod tests {
     #[tokio::test]
     async fn test_insert_at_line() {
         let test_provider = TestProvider::new();
-        let test_dir = TestDir::new().with_file(("test.txt", "line1\nline2\nline3")).await;
+        let test_dir = TestDir::new().with_file_sys(("test.txt", "line1\nline2\nline3"), &test_provider).await;
 
         let tool = FsWrite::Insert(Insert {
             path: test_dir.join("test.txt").to_string_lossy().to_string(),
@@ -461,7 +461,7 @@ mod tests {
     #[tokio::test]
     async fn test_insert_append() {
         let test_provider = TestProvider::new();
-        let test_dir = TestDir::new().with_file(("test.txt", "existing")).await;
+        let test_dir = TestDir::new().with_file_sys(("test.txt", "existing"), &test_provider).await;
 
         let tool = FsWrite::Insert(Insert {
             path: test_dir.join("test.txt").to_string_lossy().to_string(),

crates/agent/src/agent/tools/image_read.rs

@@ -230,6 +230,7 @@ pub fn is_supported_image_type(path: impl AsRef<Path>) -> bool {
 mod tests {
     use super::*;
     use crate::agent::util::test::TestDir;
+    use crate::util::test::TestProvider;
 
     // Create a minimal valid PNG for testing
     fn create_test_png() -> Vec<u8> {
@@ -254,7 +255,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_read_valid_image() {
-        let test_dir = TestDir::new().with_file(("test.png", create_test_png())).await;
+        let test_dir = TestDir::new()
+            .with_file_sys(("test.png", create_test_png()), &TestProvider::new())
+            .await;
 
         let tool = ImageRead {
             paths: vec![test_dir.join("test.png").to_string_lossy().to_string()],
@@ -271,10 +274,11 @@ mod tests {
 
     #[tokio::test]
     async fn test_read_multiple_images() {
+        let test_provider = TestProvider::new();
         let test_dir = TestDir::new()
-            .with_file(("image1.png", create_test_png()))
+            .with_file_sys(("image1.png", create_test_png()), &test_provider)
             .await
-            .with_file(("image2.png", create_test_png()))
+            .with_file_sys(("image2.png", create_test_png()), &test_provider)
             .await;
 
         let tool = ImageRead {
@@ -290,7 +294,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_validate_unsupported_format() {
-        let test_dir = TestDir::new().with_file(("test.txt", "not an image")).await;
+        let test_dir = TestDir::new()
+            .with_file_sys(("test.txt", "not an image"), &TestProvider::new())
+            .await;
 
         let tool = ImageRead {
             paths: vec![test_dir.join("test.txt").to_string_lossy().to_string()],

crates/agent/src/agent/tools/ls.rs

@@ -369,9 +369,9 @@ mod tests {
     async fn test_ls_basic_directory() {
         let test_provider = TestProvider::new();
         let test_dir = TestDir::new()
-            .with_file(("file1.txt", "content1"))
+            .with_file_sys(("file1.txt", "content1"), &test_provider)
             .await
-            .with_file(("file2.txt", "content2"))
+            .with_file_sys(("file2.txt", "content2"), &test_provider)
             .await;
 
         let tool = Ls {
@@ -394,9 +394,9 @@ mod tests {
     async fn test_ls_recursive() {
         let test_provider = TestProvider::new();
         let test_dir = TestDir::new()
-            .with_file(("root.txt", "root"))
+            .with_file_sys(("root.txt", "root"), &test_provider)
             .await
-            .with_file(("subdir/nested.txt", "nested"))
+            .with_file_sys(("subdir/nested.txt", "nested"), &test_provider)
             .await;
 
         let tool = Ls {
@@ -418,9 +418,9 @@ mod tests {
     async fn test_ls_with_ignore_patterns() {
         let test_provider = TestProvider::new();
         let test_dir = TestDir::new()
-            .with_file(("keep.txt", "keep"))
+            .with_file_sys(("keep.txt", "keep"), &test_provider)
             .await
-            .with_file(("ignore.log", "ignore"))
+            .with_file_sys(("ignore.log", "ignore"), &test_provider)
             .await;
 
         let tool = Ls {
@@ -452,7 +452,7 @@ mod tests {
     #[tokio::test]
     async fn test_ls_validate_file_not_directory() {
         let test_provider = TestProvider::new();
-        let test_dir = TestDir::new().with_file(("file.txt", "content")).await;
+        let test_dir = TestDir::new().with_file_sys(("file.txt", "content"), &test_provider).await;
 
         let tool = Ls {
             path: test_dir.join("file.txt").to_string_lossy().to_string(),

crates/agent/src/agent/util/mod.rs

@@ -202,7 +202,8 @@ mod tests {
     async fn test_read_file_with_max_limit() {
         // Test file with 30 bytes in length
         let test_file = "123456789\n".repeat(3);
-        let d = TestDir::new().with_file(("test.txt", &test_file)).await;
+        let test_provider = crate::util::test::TestProvider::new();
+        let d = TestDir::new().with_file_sys(("test.txt", &test_file), &test_provider).await;
 
         // Test not truncated
         let (content, bytes_truncated) = read_file_with_max_limit(d.join("test.txt"), 100, "...").await.unwrap();

crates/agent/src/agent/util/test.rs

@@ -14,6 +14,59 @@ use super::providers::{
     SystemProvider,
 };
 
+/// Test helper that wraps a temporary directory and test [SystemProvider].
+#[derive(Debug)]
+pub struct TestBase {
+    test_dir: TestDir,
+    provider: TestProvider,
+}
+
+impl TestBase {
+    /// Creates a new temporary directory with the following defaults configured:
+    /// - env vars: HOME=$tempdir_path/home/testuser
+    /// - cwd: $tempdir_path
+    /// - home: $tempdir_path/home/testuser
+    pub async fn new() -> Self {
+        let test_dir = TestDir::new();
+        let home_path = test_dir.path().join("home/testuser");
+        tokio::fs::create_dir_all(&home_path)
+            .await
+            .expect("failed to create test home directory");
+        let provider = TestProvider::new_with_base(home_path).with_cwd(test_dir.path());
+        Self { test_dir, provider }
+    }
+
+    /// Returns a resolved path using the generated temporary directory as the base.
+    pub fn join(&self, path: impl AsRef<Path>) -> PathBuf {
+        self.test_dir.path().join(path)
+    }
+
+    pub async fn with_file(mut self, file: impl TestFile) -> Self {
+        self.test_dir = self.test_dir.with_file_sys(file, &self.provider).await;
+        self
+    }
+}
+
+impl EnvProvider for TestBase {
+    fn var(&self, input: &str) -> Result<String, VarError> {
+        self.provider.var(input)
+    }
+}
+
+impl HomeProvider for TestBase {
+    fn home(&self) -> Option<PathBuf> {
+        self.provider.home()
+    }
+}
+
+impl CwdProvider for TestBase {
+    fn cwd(&self) -> Result<PathBuf, std::io::Error> {
+        self.provider.cwd()
+    }
+}
+
+impl SystemProvider for TestBase {}
+
 #[derive(Debug)]
 pub struct TestDir {
     temp_dir: tempfile::TempDir,