feat: Add WithTarget(string) to image builder

src/Testcontainers/Builders/IImageFromDockerfileBuilder`1.cs

@@ -53,6 +53,15 @@ public interface IImageFromDockerfileBuilder<out TBuilderEntity>
     [PublicAPI]
     TBuilderEntity WithDockerfileDirectory(CommonDirectoryPath commonDirectoryPath, string dockerfileDirectory);
 
+    /// <summary>
+    /// Sets the target build stage for the Docker image, allowing partial builds for
+    /// multi-stage Dockerfiles.
+    /// </summary>
+    /// <param name="target">The target build stage to use for the image build.</param>
+    /// <returns>A configured instance of <typeparamref name="TBuilderEntity" />.</returns>
+    [PublicAPI]
+    TBuilderEntity WithTarget(string target);
+
     /// <summary>
     /// Sets the image build policy.
     /// </summary>

src/Testcontainers/Builders/ImageFromDockerfileBuilder.cs

@@ -83,6 +83,12 @@ public ImageFromDockerfileBuilder WithDockerfileDirectory(CommonDirectoryPath co
       return Merge(DockerResourceConfiguration, new ImageFromDockerfileConfiguration(dockerfileDirectory: dockerfileDirectoryPath));
     }
 
+    /// <inheritdoc />
+    public ImageFromDockerfileBuilder WithTarget(string target)
+    {
+      return Merge(DockerResourceConfiguration, new ImageFromDockerfileConfiguration(target: target));
+    }
+
     /// <inheritdoc />
     public ImageFromDockerfileBuilder WithImageBuildPolicy(Func<ImageInspectResponse, bool> imageBuildPolicy)
     {

src/Testcontainers/Clients/DockerImageOperations.cs

@@ -98,6 +98,7 @@ await DeleteAsync(image, ct)
       var buildParameters = new ImageBuildParameters
       {
         Dockerfile = configuration.Dockerfile,
+        Target = configuration.Target,
         Tags = new List<string> { image.FullName },
         BuildArgs = configuration.BuildArguments.ToDictionary(item => item.Key, item => item.Value),
         Labels = configuration.Labels.ToDictionary(item => item.Key, item => item.Value),

src/Testcontainers/Clients/TraceProgress.cs

@@ -19,22 +19,22 @@ public void Report(JSONMessage value)
 
       if (!string.IsNullOrWhiteSpace(value.Status))
       {
-        _logger.LogDebug(value.Status);
+        _logger.LogDebug(value.Status.TrimEnd());
       }
 
       if (!string.IsNullOrWhiteSpace(value.Stream))
       {
-        _logger.LogDebug(value.Stream);
+        _logger.LogDebug(value.Stream.TrimEnd());
       }
 
       if (!string.IsNullOrWhiteSpace(value.ProgressMessage))
       {
-        _logger.LogDebug(value.ProgressMessage);
+        _logger.LogDebug(value.ProgressMessage.TrimEnd());
       }
 
       if (!string.IsNullOrWhiteSpace(value.ErrorMessage))
       {
-        _logger.LogError(value.ErrorMessage);
+        _logger.LogError(value.ErrorMessage.TrimEnd());
       }
 
 #pragma warning restore CA1848, CA2254

src/Testcontainers/Configurations/Images/IImageFromDockerfileConfiguration.cs

@@ -27,6 +27,11 @@ public interface IImageFromDockerfileConfiguration : IResourceConfiguration<Imag
     /// </summary>
     string DockerfileDirectory { get; }
 
+    /// <summary>
+    /// Gets the target.
+    /// </summary>
+    string Target { get; }
+
     /// <summary>
     /// Gets the image.
     /// </summary>

src/Testcontainers/Configurations/Images/ImageFromDockerfileConfiguration.cs

@@ -17,20 +17,23 @@ internal sealed class ImageFromDockerfileConfiguration : ResourceConfiguration<I
     /// </summary>
     /// <param name="dockerfile">The Dockerfile.</param>
     /// <param name="dockerfileDirectory">The Dockerfile directory.</param>
+    /// <param name="target">The target.</param>
     /// <param name="image">The image.</param>
     /// <param name="imageBuildPolicy">The image build policy.</param>
     /// <param name="buildArguments">A list of build arguments.</param>
     /// <param name="deleteIfExists">A value indicating whether Testcontainers removes an existing image or not.</param>
     public ImageFromDockerfileConfiguration(
       string dockerfile = null,
       string dockerfileDirectory = null,
+      string target = null,
       IImage image = null,
       Func<ImageInspectResponse, bool> imageBuildPolicy = null,
       IReadOnlyDictionary<string, string> buildArguments = null,
       bool? deleteIfExists = null)
     {
       Dockerfile = dockerfile;
       DockerfileDirectory = dockerfileDirectory;
+      Target = target;
       Image = image;
       ImageBuildPolicy = imageBuildPolicy;
       BuildArguments = buildArguments;
@@ -65,6 +68,7 @@ public ImageFromDockerfileConfiguration(IImageFromDockerfileConfiguration oldVal
     {
       Dockerfile = BuildConfiguration.Combine(oldValue.Dockerfile, newValue.Dockerfile);
       DockerfileDirectory = BuildConfiguration.Combine(oldValue.DockerfileDirectory, newValue.DockerfileDirectory);
+      Target = BuildConfiguration.Combine(oldValue.Target, newValue.Target);
       Image = BuildConfiguration.Combine(oldValue.Image, newValue.Image);
       ImageBuildPolicy = BuildConfiguration.Combine(oldValue.ImageBuildPolicy, newValue.ImageBuildPolicy);
       BuildArguments = BuildConfiguration.Combine(oldValue.BuildArguments, newValue.BuildArguments);
@@ -83,6 +87,10 @@ public ImageFromDockerfileConfiguration(IImageFromDockerfileConfiguration oldVal
     [JsonIgnore]
     public string DockerfileDirectory { get; }
 
+    /// <inheritdoc />
+    [JsonIgnore]
+    public string Target { get; }
+
     /// <inheritdoc />
     [JsonIgnore]
     public IImage Image { get; }

tests/Testcontainers.Tests/Assets/.dockerignore

@@ -4,4 +4,5 @@ credsStore
 healthWaitStrategy
 pullBaseImages
 scratch
+target
 **/*.md

tests/Testcontainers.Tests/Assets/target/Dockerfile

@@ -0,0 +1,3 @@
+FROM scratch AS base
+FROM base AS build
+FROM build AS final

tests/Testcontainers.Tests/Unit/Images/ImageFromDockerfileTest.cs

@@ -11,6 +11,7 @@ namespace DotNet.Testcontainers.Tests.Unit
   using DotNet.Testcontainers.Commons;
   using DotNet.Testcontainers.Images;
   using ICSharpCode.SharpZipLib.Tar;
+  using Microsoft.Extensions.Logging;
   using Microsoft.Extensions.Logging.Abstractions;
   using Xunit;
 
@@ -168,5 +169,42 @@ await imageFromDockerfileBuilder.CreateAsync(TestContext.Current.CancellationTok
       Assert.NotNull(imageFromDockerfileBuilder.FullName);
       Assert.Null(imageFromDockerfileBuilder.GetHostname());
     }
+
+    [Fact]
+    public async Task BuildTargetBuildsUpToExpectedTarget()
+    {
+      // Given
+      var logger = new TestLogger();
+
+      var imageFromDockerfileBuilder = new ImageFromDockerfileBuilder()
+        .WithDockerfileDirectory("Assets/target")
+        .WithTarget("build")
+        .WithLogger(logger)
+        .Build();
+
+      // When
+      await imageFromDockerfileBuilder.CreateAsync(TestContext.Current.CancellationToken)
+        .ConfigureAwait(true);
+
+      // Then
+      Assert.Contains(logger.Logs, line => line.Contains("FROM scratch AS base"));
+      Assert.Contains(logger.Logs, line => line.Contains("FROM base AS build"));
+      Assert.DoesNotContain(logger.Logs, line => line.Contains("FROM build AS final"));
+    }
+
+    private sealed class TestLogger : ILogger
+    {
+      public IList<string> Logs { get; }
+        = new List<string>();
+
+      public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        => Logs.Add(formatter(state, exception));
+
+      public bool IsEnabled(LogLevel logLevel)
+        => true;
+
+      public IDisposable BeginScope<TState>(TState state) where TState : notnull
+        => null;
+    }
   }
 }