feat: support copying directories to container

testcontainers/Cargo.toml

@@ -53,5 +53,6 @@ properties-config = ["serde-java-properties"]
 anyhow = "1.0.86"
 pretty_env_logger = "0.5"
 reqwest = { version = "0.12.4", features = ["blocking"], default-features = false }
+temp-dir = "0.1.13"
 testimages.workspace = true
 tokio = { version = "1", features = ["macros"] }

testcontainers/src/core/client.rs

@@ -293,12 +293,9 @@ impl Client {
         copy_to_container: &CopyToContainer,
     ) -> Result<(), ClientError> {
         let container_id: String = container_id.into();
-        let target_directory = copy_to_container
-            .target_directory()
-            .map_err(ClientError::CopyToContaienrError)?;
 
         let options = UploadToContainerOptions {
-            path: target_directory,
+            path: "/".to_string(),
             no_overwrite_dir_non_dir: "false".into(),
         };
 

testcontainers/src/core/copy.rs

@@ -1,6 +1,6 @@
 use std::{
     io,
-    path::{self, Path, PathBuf},
+    path::{Path, PathBuf},
 };
 
 #[derive(Debug, Clone)]
@@ -31,75 +31,103 @@ impl CopyToContainer {
         }
     }
 
-    pub(crate) fn target_directory(&self) -> Result<String, CopyToContaienrError> {
-        path::Path::new(&self.target)
-            .parent()
-            .map(path::Path::display)
-            .map(|dir| dir.to_string())
-            .ok_or_else(|| CopyToContaienrError::PathNameError(self.target.clone()))
-    }
-
     pub(crate) async fn tar(&self) -> Result<bytes::Bytes, CopyToContaienrError> {
         self.source.tar(&self.target).await
     }
 }
 
+impl From<&Path> for CopyDataSource {
+    fn from(value: &Path) -> Self {
+        CopyDataSource::File(value.to_path_buf())
+    }
+}
+impl From<PathBuf> for CopyDataSource {
+    fn from(value: PathBuf) -> Self {
+        CopyDataSource::File(value)
+    }
+}
+impl From<Vec<u8>> for CopyDataSource {
+    fn from(value: Vec<u8>) -> Self {
+        CopyDataSource::Data(value)
+    }
+}
+
 impl CopyDataSource {
     pub(crate) async fn tar(
         &self,
         target_path: impl Into<String>,
     ) -> Result<bytes::Bytes, CopyToContaienrError> {
         let target_path: String = target_path.into();
-        let mut ar = tokio_tar::Builder::new(Vec::new());
-
-        match self {
-            CopyDataSource::File(file_path) => {
-                let f = &mut tokio::fs::File::open(file_path)
-                    .await
-                    .map_err(CopyToContaienrError::IoError)?;
-                ar.append_file(&target_path, f)
-                    .await
-                    .map_err(CopyToContaienrError::IoError)?;
-            }
-            CopyDataSource::Data(data) => {
-                let path = path::Path::new(&target_path);
-                let file_name = match path.file_name() {
-                    Some(v) => v,
-                    None => return Err(CopyToContaienrError::PathNameError(target_path)),
-                };
-
-                let mut header = tokio_tar::Header::new_gnu();
-                header.set_size(data.len() as u64);
-                header.set_mode(0o0644);
-                header.set_cksum();
-
-                ar.append_data(&mut header, file_name, data.as_slice())
-                    .await
-                    .map_err(CopyToContaienrError::IoError)?;
-            }
-        }
 
-        let bytes = ar
-            .into_inner()
-            .await
-            .map_err(CopyToContaienrError::IoError)?;
+        let bytes = match self {
+            CopyDataSource::File(source_file_path) => {
+                tar_file(source_file_path, &target_path).await?
+            }
+            CopyDataSource::Data(data) => tar_bytes(data, &target_path).await?,
+        };
 
         Ok(bytes::Bytes::copy_from_slice(bytes.as_slice()))
     }
 }
 
-impl From<&Path> for CopyDataSource {
-    fn from(value: &Path) -> Self {
-        CopyDataSource::File(value.to_path_buf())
-    }
+async fn tar_file(
+    source_file_path: &Path,
+    target_path: &str,
+) -> Result<Vec<u8>, CopyToContaienrError> {
+    let target_path = make_path_relative(&target_path);
+    let meta = tokio::fs::metadata(source_file_path)
+        .await
+        .map_err(CopyToContaienrError::IoError)?;
+
+    let mut ar = tokio_tar::Builder::new(Vec::new());
+    if meta.is_dir() {
+        ar.append_dir_all(target_path, source_file_path)
+            .await
+            .map_err(CopyToContaienrError::IoError)?;
+    } else {
+        let f = &mut tokio::fs::File::open(source_file_path)
+            .await
+            .map_err(CopyToContaienrError::IoError)?;
+
+        ar.append_file(target_path, f)
+            .await
+            .map_err(CopyToContaienrError::IoError)?;
+    };
+
+    let res = ar
+        .into_inner()
+        .await
+        .map_err(CopyToContaienrError::IoError)?;
+
+    Ok(res)
 }
-impl From<PathBuf> for CopyDataSource {
-    fn from(value: PathBuf) -> Self {
-        CopyDataSource::File(value)
-    }
+
+async fn tar_bytes(data: &Vec<u8>, target_path: &str) -> Result<Vec<u8>, CopyToContaienrError> {
+    let relative_target_path = make_path_relative(&target_path);
+
+    let mut header = tokio_tar::Header::new_gnu();
+    header.set_size(data.len() as u64);
+    header.set_mode(0o0644);
+    header.set_cksum();
+
+    let mut ar = tokio_tar::Builder::new(Vec::new());
+    ar.append_data(&mut header, relative_target_path, data.as_slice())
+        .await
+        .map_err(CopyToContaienrError::IoError)?;
+
+    let res = ar
+        .into_inner()
+        .await
+        .map_err(CopyToContaienrError::IoError)?;
+
+    Ok(res)
 }
-impl From<Vec<u8>> for CopyDataSource {
-    fn from(value: Vec<u8>) -> Self {
-        CopyDataSource::Data(value)
+
+fn make_path_relative(path: &str) -> String {
+    // TODO support also absolute windows paths like "C:\temp\foo.txt"
+    if path.starts_with("/") {
+        path.trim_start_matches("/").to_string()
+    } else {
+        path.to_string()
     }
 }

testcontainers/tests/async_runner.rs

@@ -201,7 +201,7 @@ async fn async_run_with_log_consumer() -> anyhow::Result<()> {
 }
 
 #[tokio::test]
-async fn async_copy_files_to_container() -> anyhow::Result<()> {
+async fn async_copy_bytes_to_container() -> anyhow::Result<()> {
     let container = GenericImage::new("alpine", "latest")
         .with_wait_for(WaitFor::seconds(2))
         .with_copy_to("/tmp/somefile", "foobar".to_string().into_bytes())
@@ -216,3 +216,34 @@ async fn async_copy_files_to_container() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn async_copy_files_to_container() -> anyhow::Result<()> {
+    let temp_dir = temp_dir::TempDir::new()?;
+    let f1 = temp_dir.child("foo.txt");
+
+    let sub_dir = temp_dir.child("subdir");
+    std::fs::create_dir(&sub_dir)?;
+    let mut f2 = sub_dir.clone();
+    f2.push("bar.txt");
+
+    std::fs::write(&f1, "foofoofoo")?;
+    std::fs::write(&f2, "barbarbar")?;
+
+    let container = GenericImage::new("alpine", "latest")
+        .with_wait_for(WaitFor::seconds(2))
+        .with_copy_to("/tmp/somefile", f1)
+        .with_copy_to("/", temp_dir.path())
+        .with_cmd(vec!["cat", "/tmp/somefile", "&&", "cat", "/subdir/bar.txt"])
+        .start()
+        .await?;
+
+    let mut out = String::new();
+    container.stdout(false).read_to_string(&mut out).await?;
+
+    println!("{}", out);
+    assert!(out.contains("foofoofoo"));
+    assert!(out.contains("barbarbar"));
+
+    Ok(())
+}

testcontainers/tests/sync_runner.rs

@@ -225,7 +225,7 @@ fn sync_run_with_log_consumer() -> anyhow::Result<()> {
 }
 
 #[test]
-fn sync_copy_files_to_container() -> anyhow::Result<()> {
+fn sync_copy_bytes_to_container() -> anyhow::Result<()> {
     let _ = pretty_env_logger::try_init();
 
     let container = GenericImage::new("alpine", "latest")
@@ -241,3 +241,33 @@ fn sync_copy_files_to_container() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn sync_copy_files_to_container() -> anyhow::Result<()> {
+    let temp_dir = temp_dir::TempDir::new()?;
+    let f1 = temp_dir.child("foo.txt");
+
+    let sub_dir = temp_dir.child("subdir");
+    std::fs::create_dir(&sub_dir)?;
+    let mut f2 = sub_dir.clone();
+    f2.push("bar.txt");
+
+    std::fs::write(&f1, "foofoofoo")?;
+    std::fs::write(&f2, "barbarbar")?;
+
+    let container = GenericImage::new("alpine", "latest")
+        .with_wait_for(WaitFor::seconds(2))
+        .with_copy_to("/tmp/somefile", f1)
+        .with_copy_to("/", temp_dir.path())
+        .with_cmd(vec!["cat", "/tmp/somefile", "&&", "cat", "/subdir/bar.txt"])
+        .start()?;
+
+    let mut out = String::new();
+    container.stdout(false).read_to_string(&mut out)?;
+
+    println!("{}", out);
+    assert!(out.contains("foofoofoo"));
+    assert!(out.contains("barbarbar"));
+
+    Ok(())
+}