Added entrypoint and workdir, closes #22, #23.

Author: HofmeisterAn

README.md

@@ -9,13 +9,15 @@ Choose from existing pre-configured configurations [^1] and start containers wit
 
 ## Supported commands
 - `WithImage` specifies an `IMAGE[:TAG]` to derive the container from.
+- `WithName` set the container name e. g. `--name nginx`.
+- `WithWorkingDirectory` specifies and overrides the `WORKDIR` for the instruction sets.
+- `WithEntrypoint` specifies and overrides the `ENTRYPOINT` that will run as an executable.
 - `WithCommand` specifies and overrides the `[COMMAND]` instruction provided from the Dockerfile.
 - `WithEnvironment` set an environment variable in the container e. g. `-e "test=containers"`.
 - `WithLabel` applies metadata to a container e. g. `-l, --label dotnet.testcontainers=awesome`.
 - `WithExposedPort` exposes a port inside the container e. g. `--expose=80`.
 - `WithPortBinding` publishes a container port to the host e. g. `-p 80:80`.
 - `WithMount` mounts a volume into the container e. g. `-v, --volume .:/tmp`.
-- `WithName` set the container name e. g. `--name nginx`.
 
 ## Examples
 Pulls `nginx`, creates a new container with port binding `80:80` and hits the default site.

src/DotNet.Testcontainers/Clients/TestcontainersClient.cs

@@ -1,43 +1,16 @@
 namespace DotNet.Testcontainers.Clients
 {
   using System;
-  using System.Collections.Generic;
   using System.Threading.Tasks;
   using Docker.DotNet.Models;
   using DotNet.Testcontainers.Core.Mapper;
-  using DotNet.Testcontainers.Core.Mapper.Converters;
   using DotNet.Testcontainers.Core.Models;
   using DotNet.Testcontainers.Diagnostics;
 
   internal class TestcontainersClient : DockerApiClient, ITestcontainersClient
   {
     private static readonly Lazy<ITestcontainersClient> Testcontainers = new Lazy<ITestcontainersClient>(() => new TestcontainersClient());
 
-    private static readonly ConverterFactory ConverterFactory = new ConverterFactory();
-
-    private static readonly GenericConverter GenericConverter = new GenericConverter(ConverterFactory);
-
-    static TestcontainersClient()
-    {
-      ConverterFactory.Register<IReadOnlyCollection<string>, IList<string>>(
-        () => new ConvertList());
-
-      ConverterFactory.Register<IReadOnlyDictionary<string, string>, IList<string>>(
-        () => new ConvertList());
-
-      ConverterFactory.Register<IReadOnlyDictionary<string, string>, IDictionary<string, string>>(
-        () => new ConvertDictionary());
-
-      ConverterFactory.Register<IReadOnlyDictionary<string, string>, IDictionary<string, EmptyStruct>>(
-        () => new ConvertExposedPort(), "ExposedPorts");
-
-      ConverterFactory.Register<IReadOnlyDictionary<string, string>, IDictionary<string, IList<PortBinding>>>(
-        () => new ConvertPortBinding(), "PortBindings");
-
-      ConverterFactory.Register<IReadOnlyDictionary<string, string>, IList<Mount>>(
-        () => new ConvertMount(), "Mounts");
-    }
-
     internal static ITestcontainersClient Instance
     {
       get
@@ -83,8 +56,6 @@ public async Task<string> RunAsync(TestcontainersConfiguration configuration)
     {
       var image = configuration.Container.Image;
 
-      var name = configuration.Container.Name;
-
       var pullImageTask = MetaDataClientImages.Instance.ExistsWithNameAsync(image).ContinueWith(async imageExists =>
       {
         if (!await imageExists)
@@ -94,23 +65,25 @@ public async Task<string> RunAsync(TestcontainersConfiguration configuration)
         }
       });
 
-      var cmd = GenericConverter.Convert<IReadOnlyCollection<string>,
-        IList<string>>(configuration.Container.Command);
+      var name = configuration.Container.Name;
+
+      var workingDir = configuration.Container.WorkingDirectory;
+
+      var converter = new TestcontainersConfigurationConverter(configuration);
+
+      var entrypoint = converter.Entrypoint;
+
+      var cmd = converter.Command;
 
-      var env = GenericConverter.Convert<IReadOnlyDictionary<string, string>,
-        IList<string>>(configuration.Container.Environments);
+      var env = converter.Environments;
 
-      var labels = GenericConverter.Convert<IReadOnlyDictionary<string, string>,
-        IDictionary<string, string>>(configuration.Container.Labels);
+      var labels = converter.Labels;
 
-      var exposedPorts = GenericConverter.Convert<IReadOnlyDictionary<string, string>,
-        IDictionary<string, EmptyStruct>>(configuration.Container.ExposedPorts, "ExposedPorts");
+      var exposedPorts = converter.ExposedPorts;
 
-      var portBindings = GenericConverter.Convert<IReadOnlyDictionary<string, string>,
-        IDictionary<string, IList<PortBinding>>>(configuration.Host.PortBindings, "PortBindings");
+      var portBindings = converter.PortBindings;
 
-      var mounts = GenericConverter.Convert<IReadOnlyDictionary<string, string>,
-        IList<Mount>>(configuration.Host.Mounts, "Mounts");
+      var mounts = converter.Mounts;
 
       await pullImageTask;
 
@@ -124,6 +97,8 @@ public async Task<string> RunAsync(TestcontainersConfiguration configuration)
       {
         Image = image,
         Name = name,
+        WorkingDir = workingDir,
+        Entrypoint = entrypoint,
         Env = env,
         Labels = labels,
         Cmd = cmd,

src/DotNet.Testcontainers/Core/Builder/ITestcontainersBuilder.cs

@@ -27,7 +27,21 @@ public interface ITestcontainersBuilder
     ITestcontainersBuilder WithName(string name);
 
     /// <summary>
-    /// Adds a command to the Testcontainer to provide defaults for an executing.
+    /// Overrides the working directory of the Testcontainer for the instruction sets.
+    /// </summary>
+    /// <param name="workingDirectory">Working directory.</param>
+    /// <returns>A configured instance of <see cref="ITestcontainersBuilder"/>.</returns>
+    ITestcontainersBuilder WithWorkingDirectory(string workingDirectory);
+
+    /// <summary>
+    /// Overrides the entrypoint of the Testcontainer to configure an executable.
+    /// </summary>
+    /// <param name="entrypoint">Entrypoint executable.</param>
+    /// <returns>A configured instance of <see cref="ITestcontainersBuilder"/>.</returns>
+    ITestcontainersBuilder WithEntrypoint(params string[] entrypoint);
+
+    /// <summary>
+    /// Overrides the command of the Testcontainer to provide defaults for an executing.
     /// </summary>
     /// <param name="command">List of commands, "executable", "param1", "param2" or "param1", "param2".</param>
     /// <returns>A configured instance of <see cref="ITestcontainersBuilder"/>.</returns>

src/DotNet.Testcontainers/Core/Builder/TestcontainersBuilder.cs

@@ -14,6 +14,10 @@ public class TestcontainersBuilder : ITestcontainersBuilder
 
     private readonly string name;
 
+    private readonly string workingDirectory;
+
+    private readonly IReadOnlyCollection<string> entrypoint = new List<string>();
+
     private readonly IReadOnlyCollection<string> command = new List<string>();
 
     private readonly IReadOnlyDictionary<string, string> environments = new Dictionary<string, string>();
@@ -37,6 +41,8 @@ public TestcontainersBuilder()
     protected TestcontainersBuilder(
       IDockerImage image,
       string name,
+      string workingDirectory,
+      IReadOnlyCollection<string> entrypoint,
       IReadOnlyCollection<string> commands,
       IReadOnlyDictionary<string, string> environments,
       IReadOnlyDictionary<string, string> labels,
@@ -47,6 +53,8 @@ protected TestcontainersBuilder(
     {
       this.image = image;
       this.name = name;
+      this.workingDirectory = workingDirectory;
+      this.entrypoint = entrypoint;
       this.command = commands;
       this.environments = environments;
       this.labels = labels;
@@ -73,6 +81,16 @@ public ITestcontainersBuilder WithName(string name)
       return Build(this, name: name);
     }
 
+    public ITestcontainersBuilder WithWorkingDirectory(string workingDirectory)
+    {
+      return Build(this, workingDirectory: workingDirectory);
+    }
+
+    public ITestcontainersBuilder WithEntrypoint(params string[] entrypoint)
+    {
+      return Build(this, entrypoint: entrypoint);
+    }
+
     public ITestcontainersBuilder WithCommand(params string[] command)
     {
       return Build(this, command: new ReadOnlyCollection<string>(command));
@@ -133,6 +151,8 @@ public IDockerContainer Build()
       var configuration = default(TestcontainersConfiguration);
       configuration.Container.Image = this.image.Image;
       configuration.Container.Name = this.name;
+      configuration.Container.WorkingDirectory = this.workingDirectory;
+      configuration.Container.Entrypoint = this.entrypoint;
       configuration.Container.Command = this.command;
       configuration.Container.Environments = this.environments;
       configuration.Container.ExposedPorts = this.exposedPorts;
@@ -149,6 +169,8 @@ private static ITestcontainersBuilder Build(
       TestcontainersBuilder old,
       IDockerImage image = null,
       string name = null,
+      string workingDirectory = null,
+      IReadOnlyCollection<string> entrypoint = null,
       IReadOnlyCollection<string> command = null,
       IReadOnlyDictionary<string, string> environments = null,
       IReadOnlyDictionary<string, string> exposedPorts = null,
@@ -161,12 +183,15 @@ private static ITestcontainersBuilder Build(
       Merge(old.exposedPorts, ref exposedPorts);
       Merge(old.labels, ref labels);
       Merge(old.portBindings, ref portBindings);
+      Merge(old.entrypoint, ref entrypoint);
       Merge(old.command, ref command);
       Merge(old.mounts, ref mounts);
 
       return new TestcontainersBuilder(
         image ?? old.image,
         name ?? old.name,
+        workingDirectory ?? old.workingDirectory,
+        entrypoint,
         command,
         environments,
         labels,

src/DotNet.Testcontainers/Core/Containers/IDockerContainer.cs

@@ -24,11 +24,13 @@ public interface IDockerContainer : IDisposable
     /// <summary>
     /// Starts the Testcontainer. If the image does not exist, it will be downloaded automatically. Non-existing containers are created at first start.
     /// </summary>
+    /// <returns>A task that represents the asynchronous start operation of a Testcontainer.</returns>
     Task StartAsync();
 
     /// <summary>
     /// Stops the Testcontainer and removes the container automatically.
     /// </summary>
+    /// <returns>A task that represents the asynchronous stop operation of a Testcontainer.</returns>
     Task StopAsync();
   }
 }

src/DotNet.Testcontainers/Core/Mapper/BaseConverter.cs

@@ -0,0 +1,14 @@
+namespace DotNet.Testcontainers.Core.Mapper
+{
+  internal abstract class BaseConverter<TSource, TTarget>
+  {
+    private readonly string name;
+
+    protected BaseConverter(string name)
+    {
+      this.name = name;
+    }
+
+    public abstract TTarget Convert(TSource source);
+  }
+}

src/DotNet.Testcontainers/Core/Mapper/CollectionConverter.cs

@@ -0,0 +1,15 @@
+namespace DotNet.Testcontainers.Core.Mapper
+{
+  using System.Collections.Generic;
+
+  internal abstract class CollectionConverter<T> : BaseConverter<IReadOnlyCollection<string>, T>
+  {
+    protected CollectionConverter() : base(string.Empty)
+    {
+    }
+
+    protected CollectionConverter(string name) : base(name)
+    {
+    }
+  }
+}