feat: Support coping directories using WithResourceMapping(string, string) (#932)

Author: HofmeisterAn

docs/api/create_docker_container.md

@@ -29,7 +29,7 @@ _ = new ContainerBuilder()
   .WithEnvironment("ASPNETCORE_URLS", "https://+")
   .WithEnvironment("ASPNETCORE_Kestrel__Certificates__Default__Path", "/app/certificate.crt")
   .WithEnvironment("ASPNETCORE_Kestrel__Certificates__Default__Password", "password")
-  .WithResourceMapping("certificate.crt", "/app/certificate.crt");
+  .WithResourceMapping("certificate.crt", "/app/");
 ```
 
 `WithBindMount(string, string)` is another option to provide access to directories or files. It mounts a host directory or file into the container. Note, this does not follow our best practices. Host paths differ between environments and may not be available on every system or Docker setup, e.g. CI.

src/Testcontainers.WebDriver/WebDriverBuilder.cs

@@ -64,7 +64,7 @@ public WebDriverBuilder WithBrowser(WebDriverBrowser webDriverBrowser)
     /// <returns>A configured instance of <see cref="WebDriverBuilder" />.</returns>
     public WebDriverBuilder WithConfigurationFromTomlFile(string configTomlFilePath)
     {
-        return WithResourceMapping(configTomlFilePath, "/opt/bin/config.toml");
+        return WithResourceMapping(File.ReadAllBytes(configTomlFilePath), "/opt/bin/config.toml");
     }
 
     /// <summary>

src/Testcontainers/Builders/ContainerBuilder`3.cs

@@ -3,6 +3,7 @@ namespace DotNet.Testcontainers.Builders
   using System;
   using System.Collections.Generic;
   using System.Globalization;
+  using System.IO;
   using System.Linq;
   using System.Threading;
   using System.Threading.Tasks;
@@ -181,22 +182,47 @@ public TBuilderEntity WithPortBinding(string hostPort, string containerPort)
     }
 
     /// <inheritdoc />
-    public TBuilderEntity WithResourceMapping(string source, string destination)
+    public TBuilderEntity WithResourceMapping(IResourceMapping resourceMapping)
     {
-      return WithResourceMapping(new FileResourceMapping(source, destination));
+      var resourceMappings = new Dictionary<string, IResourceMapping> { { resourceMapping.Target, resourceMapping } };
+      return Clone(new ContainerConfiguration(resourceMappings: resourceMappings));
     }
 
     /// <inheritdoc />
-    public TBuilderEntity WithResourceMapping(byte[] resourceContent, string destination)
+    public TBuilderEntity WithResourceMapping(byte[] resourceContent, string filePath, UnixFileModes fileMode = Unix.FileMode644)
     {
-      return WithResourceMapping(new BinaryResourceMapping(resourceContent, destination));
+      return WithResourceMapping(new BinaryResourceMapping(resourceContent, filePath, fileMode));
     }
 
     /// <inheritdoc />
-    public TBuilderEntity WithResourceMapping(IResourceMapping resourceMapping)
+    public TBuilderEntity WithResourceMapping(string source, string target, UnixFileModes fileMode = Unix.FileMode644)
     {
-      var resourceMappings = new Dictionary<string, IResourceMapping> { { resourceMapping.Target, resourceMapping } };
-      return Clone(new ContainerConfiguration(resourceMappings: resourceMappings));
+      return WithResourceMapping(new FileResourceMapping(source, target, fileMode));
+    }
+
+    /// <inheritdoc />
+    public TBuilderEntity WithResourceMapping(DirectoryInfo source, string target, UnixFileModes fileMode = Unix.FileMode644)
+    {
+      return WithResourceMapping(source.FullName, target, fileMode);
+    }
+
+    /// <inheritdoc />
+    public TBuilderEntity WithResourceMapping(FileInfo source, string target, UnixFileModes fileMode = Unix.FileMode644)
+    {
+      return WithResourceMapping(source.FullName, target, fileMode);
+    }
+
+    /// <inheritdoc />
+    public TBuilderEntity WithResourceMapping(FileInfo source, FileInfo target, UnixFileModes fileMode = Unix.FileMode644)
+    {
+      using (var fileStream = File.Open(source.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+      {
+        using (var streamReader = new BinaryReader(fileStream))
+        {
+          var resourceContent = streamReader.ReadBytes((int)streamReader.BaseStream.Length);
+          return WithResourceMapping(new BinaryResourceMapping(resourceContent, target.ToString(), fileMode));
+        }
+      }
     }
 
     /// <inheritdoc />

src/Testcontainers/Builders/IContainerBuilder`2.cs

@@ -2,6 +2,7 @@ namespace DotNet.Testcontainers.Builders
 {
   using System;
   using System.Collections.Generic;
+  using System.IO;
   using System.Threading;
   using System.Threading.Tasks;
   using Docker.DotNet.Models;
@@ -200,29 +201,62 @@ public interface IContainerBuilder<out TBuilderEntity, out TContainerEntity> : I
     TBuilderEntity WithPortBinding(string hostPort, string containerPort);
 
     /// <summary>
-    /// Copies the source file to the created container before it starts.
+    /// Copies the byte array content of the resource mapping to the created container before it starts.
     /// </summary>
-    /// <param name="source">An absolute path or a name value within the host machine.</param>
-    /// <param name="destination">An absolute path as destination in the container.</param>
+    /// <param name="resourceMapping">The resource mapping.</param>
     /// <returns>A configured instance of <typeparamref name="TBuilderEntity" />.</returns>
     [PublicAPI]
-    TBuilderEntity WithResourceMapping(string source, string destination);
+    TBuilderEntity WithResourceMapping(IResourceMapping resourceMapping);
 
     /// <summary>
     /// Copies the byte array content to the created container before it starts.
     /// </summary>
     /// <param name="resourceContent">The byte array content of the resource mapping.</param>
-    /// <param name="destination">An absolute path as destination in the container.</param>
+    /// <param name="filePath">The target file path to copy the file to.</param>
+    /// <param name="fileMode">The POSIX file mode permission.</param>
     /// <returns>A configured instance of <typeparamref name="TBuilderEntity" />.</returns>
     [PublicAPI]
-    TBuilderEntity WithResourceMapping(byte[] resourceContent, string destination);
+    TBuilderEntity WithResourceMapping(byte[] resourceContent, string filePath, UnixFileModes fileMode = Unix.FileMode644);
 
     /// <summary>
-    /// Copies the byte array content of the resource mapping to the created container before it starts.
+    /// Copies a test host directory or file to the container before it starts.
     /// </summary>
-    /// <param name="resourceMapping">The resource mapping.</param>
+    /// <param name="source">The source directory or file to be copied.</param>
+    /// <param name="target">The target directory path to copy the files to.</param>
+    /// <param name="fileMode">The POSIX file mode permission.</param>
     /// <returns>A configured instance of <typeparamref name="TBuilderEntity" />.</returns>
-    TBuilderEntity WithResourceMapping(IResourceMapping resourceMapping);
+    [PublicAPI]
+    TBuilderEntity WithResourceMapping(string source, string target, UnixFileModes fileMode = Unix.FileMode644);
+
+    /// <summary>
+    /// Copies a test host directory or file to the container before it starts.
+    /// </summary>
+    /// <param name="source">The source directory to be copied.</param>
+    /// <param name="target">The target directory path to copy the files to.</param>
+    /// <param name="fileMode">The POSIX file mode permission.</param>
+    /// <returns>A configured instance of <typeparamref name="TBuilderEntity" />.</returns>
+    [PublicAPI]
+    TBuilderEntity WithResourceMapping(DirectoryInfo source, string target, UnixFileModes fileMode = Unix.FileMode644);
+
+    /// <summary>
+    /// Copies a test host directory or file to the container before it starts.
+    /// </summary>
+    /// <param name="source">The source file to be copied.</param>
+    /// <param name="target">The target directory path to copy the file to.</param>
+    /// <param name="fileMode">The POSIX file mode permission.</param>
+    /// <returns>A configured instance of <typeparamref name="TBuilderEntity" />.</returns>
+    [PublicAPI]
+    TBuilderEntity WithResourceMapping(FileInfo source, string target, UnixFileModes fileMode = Unix.FileMode644);
+
+    /// <summary>
+    /// Copies a test host file to the container before it starts.
+    /// </summary>
+    /// <param name="source">The source file to be copied.</param>
+    /// <param name="target">The target file path to copy the file to.</param>
+    /// <param name="fileMode">The POSIX file mode permission.</param>
+    /// <returns>A configured instance of <typeparamref name="TBuilderEntity" />.</returns>
+    [PublicAPI]
+    TBuilderEntity WithResourceMapping(FileInfo source, FileInfo target, UnixFileModes fileMode = Unix.FileMode644);
 
     /// <summary>
     /// Assigns the mount configuration to manage data in the container.

src/Testcontainers/Clients/TestcontainersClient.cs

@@ -165,6 +165,22 @@ public Task<ExecResult> ExecAsync(string id, IList<string> command, Cancellation
     /// <inheritdoc />
     public async Task CopyAsync(string id, IResourceMapping resourceMapping, CancellationToken ct = default)
     {
+      if (Directory.Exists(resourceMapping.Source))
+      {
+        await CopyAsync(id, new DirectoryInfo(resourceMapping.Source), resourceMapping.Target, resourceMapping.FileMode, ct)
+          .ConfigureAwait(false);
+
+        return;
+      }
+
+      if (File.Exists(resourceMapping.Source))
+      {
+        await CopyAsync(id, new FileInfo(resourceMapping.Source), resourceMapping.Target, resourceMapping.FileMode, ct)
+          .ConfigureAwait(false);
+
+        return;
+      }
+
       using (var tarOutputMemStream = new TarOutputMemoryStream())
       {
         await tarOutputMemStream.AddAsync(resourceMapping, ct)

src/Testcontainers/Configurations/Volumes/BinaryResourceMapping.cs

@@ -14,7 +14,7 @@ internal class BinaryResourceMapping : FileResourceMapping
     /// <param name="resourceContent">The byte array content to map in the container.</param>
     /// <param name="containerPath">The absolute path of a file to map in the container.</param>
     /// <param name="fileMode">The POSIX file mode permission.</param>
-    public BinaryResourceMapping(byte[] resourceContent, string containerPath, UnixFileModes fileMode = Unix.FileMode644)
+    public BinaryResourceMapping(byte[] resourceContent, string containerPath, UnixFileModes fileMode)
       : base(string.Empty, containerPath, fileMode)
     {
       _resourceContent = resourceContent;

src/Testcontainers/Configurations/Volumes/FileResourceMapping.cs

@@ -13,7 +13,7 @@ internal class FileResourceMapping : IResourceMapping
     /// <param name="hostPath">The absolute path of a file to map on the host system.</param>
     /// <param name="containerPath">The absolute path of a file to map in the container.</param>
     /// <param name="fileMode">The POSIX file mode permission.</param>
-    public FileResourceMapping(string hostPath, string containerPath, UnixFileModes fileMode = Unix.FileMode644)
+    public FileResourceMapping(string hostPath, string containerPath, UnixFileModes fileMode)
     {
       Type = MountType.Bind;
       Source = hostPath;

src/Testcontainers/Configurations/Volumes/IResourceMapping.cs

@@ -13,6 +13,9 @@ public interface IResourceMapping : IMount
     /// <summary>
     /// Gets the Unix file mode.
     /// </summary>
+    /// <remarks>
+    /// The <see cref="Unix" /> class provides access to common constant POSIX file mode permissions.
+    /// </remarks>
     UnixFileModes FileMode { get; }
 
     /// <summary>

tests/Testcontainers.Platform.Linux.Tests/TarOutputMemoryStreamTest.cs

@@ -85,20 +85,32 @@ public Task<byte[]> GetAllBytesAsync(CancellationToken ct = default)
         public async Task TestFileExistsInContainer()
         {
             // Given
-            var targetFilePath = string.Join("/", string.Empty, "tmp", Guid.NewGuid(), _testFile.Name);
+            var targetFilePath1 = string.Join("/", string.Empty, "tmp", Guid.NewGuid(), _testFile.Name);
+
+            var targetFilePath2 = string.Join("/", string.Empty, "tmp", Guid.NewGuid(), _testFile.Name);
 
             var targetDirectoryPath1 = string.Join("/", string.Empty, "tmp", Guid.NewGuid());
 
             var targetDirectoryPath2 = string.Join("/", string.Empty, "tmp", Guid.NewGuid());
 
+            var targetDirectoryPath3 = string.Join("/", string.Empty, "tmp", Guid.NewGuid());
+
+            var targetDirectoryPath4 = string.Join("/", string.Empty, "tmp", Guid.NewGuid());
+
             IList<string> targetFilePaths = new List<string>();
-            targetFilePaths.Add(targetFilePath);
+            targetFilePaths.Add(targetFilePath1);
+            targetFilePaths.Add(targetFilePath2);
             targetFilePaths.Add(string.Join("/", targetDirectoryPath1, _testFile.Name));
             targetFilePaths.Add(string.Join("/", targetDirectoryPath2, _testFile.Name));
+            targetFilePaths.Add(string.Join("/", targetDirectoryPath3, _testFile.Name));
+            targetFilePaths.Add(string.Join("/", targetDirectoryPath4, _testFile.Name));
 
             await using var container = new ContainerBuilder()
                 .WithImage(CommonImages.Alpine)
                 .WithEntrypoint(CommonCommands.SleepInfinity)
+                .WithResourceMapping(_testFile, new FileInfo(targetFilePath1))
+                .WithResourceMapping(_testFile, targetDirectoryPath1)
+                .WithResourceMapping(_testFile.Directory, targetDirectoryPath2)
                 .Build();
 
             // When
@@ -108,17 +120,17 @@ public async Task TestFileExistsInContainer()
             await container.StartAsync()
                 .ConfigureAwait(false);
 
-            await container.CopyAsync(fileContent, targetFilePath)
+            await container.CopyAsync(fileContent, targetFilePath2)
                 .ConfigureAwait(false);
 
-            await container.CopyAsync(_testFile, targetDirectoryPath1)
+            await container.CopyAsync(_testFile, targetDirectoryPath3)
                 .ConfigureAwait(false);
 
-            await container.CopyAsync(_testFile.Directory, targetDirectoryPath2)
+            await container.CopyAsync(_testFile.Directory, targetDirectoryPath4)
                 .ConfigureAwait(false);
 
             // Then
-            var execResults = await Task.WhenAll(targetFilePaths.Select(targetFilePath => container.ExecAsync(new[] { "test", "-f", targetFilePath })))
+            var execResults = await Task.WhenAll(targetFilePaths.Select(containerFilePath => container.ExecAsync(new[] { "test", "-f", containerFilePath })))
                 .ConfigureAwait(false);
 
             Assert.All(execResults, result => Assert.Equal(0, result.ExitCode));

tests/Testcontainers.Tests/Unit/Containers/Unix/CopyResourceMappingContainerTest.cs

@@ -1,6 +1,7 @@
 namespace DotNet.Testcontainers.Tests.Unit
 {
   using System;
+  using System.Collections.Generic;
   using System.IO;
   using System.Linq;
   using System.Text;
@@ -14,26 +15,34 @@ public sealed class CopyResourceMappingContainerTest : IAsyncLifetime, IDisposab
   {
     private const string ResourceMappingContent = "👋";
 
-    private readonly string _resourceMappingSourceFilePath = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
+    private readonly FileInfo _sourceFilePath = new FileInfo(Path.Combine(TestSession.TempDirectoryPath, Path.GetRandomFileName()));
 
-    private readonly string _resourceMappingFileDestinationFilePath = string.Join("/", string.Empty, "tmp", Path.GetRandomFileName());
+    private readonly string _bytesTargetFilePath;
 
-    private readonly string _resourceMappingBytesDestinationFilePath = string.Join("/", string.Empty, "tmp", Path.GetRandomFileName());
+    private readonly string _fileTargetFilePath;
 
     private readonly IContainer _container;
 
     public CopyResourceMappingContainerTest()
     {
+      var resourceContent = Encoding.Default.GetBytes(ResourceMappingContent);
+
+      using var fileStream = _sourceFilePath.Create();
+      fileStream.Write(resourceContent);
+
+      _bytesTargetFilePath = string.Join("/", string.Empty, "tmp", Guid.NewGuid(), _sourceFilePath.Name);
+
+      _fileTargetFilePath = string.Join("/", string.Empty, "tmp", Guid.NewGuid());
+
       _container = new ContainerBuilder()
         .WithImage(CommonImages.Alpine)
-        .WithResourceMapping(_resourceMappingSourceFilePath, _resourceMappingFileDestinationFilePath)
-        .WithResourceMapping(Encoding.Default.GetBytes(ResourceMappingContent), _resourceMappingBytesDestinationFilePath)
+        .WithResourceMapping(resourceContent, _bytesTargetFilePath)
+        .WithResourceMapping(_sourceFilePath, _fileTargetFilePath)
         .Build();
     }
 
     public Task InitializeAsync()
     {
-      File.WriteAllText(_resourceMappingSourceFilePath, ResourceMappingContent);
       return _container.StartAsync();
     }
 
@@ -44,25 +53,23 @@ public Task DisposeAsync()
 
     public void Dispose()
     {
-      if (File.Exists(_resourceMappingSourceFilePath))
-      {
-        File.Delete(_resourceMappingSourceFilePath);
-      }
+      _sourceFilePath.Delete();
     }
 
     [Fact]
     public async Task ReadExistingFile()
     {
       // Given
-      var resourceMappingBytes = await Task.WhenAll(new[] { _resourceMappingFileDestinationFilePath, _resourceMappingBytesDestinationFilePath }
-          .Select(resourceMappingFilePath => _container.ReadFileAsync(resourceMappingFilePath)))
-        .ConfigureAwait(false);
+      IList<string> targetFilePaths = new List<string>();
+      targetFilePaths.Add(_bytesTargetFilePath);
+      targetFilePaths.Add(string.Join("/", _fileTargetFilePath, _sourceFilePath.Name));
 
       // When
-      var resourceMappingContent = resourceMappingBytes.Select(Encoding.Default.GetString);
+      var resourceContents = await Task.WhenAll(targetFilePaths.Select(containerFilePath => _container.ReadFileAsync(containerFilePath)))
+        .ConfigureAwait(false);
 
       // Then
-      Assert.All(resourceMappingContent, item => Assert.Equal(ResourceMappingContent, item));
+      Assert.All(resourceContents.Select(Encoding.Default.GetString), resourceContent => Assert.Equal(ResourceMappingContent, resourceContent));
     }
   }
 }