[#203] #EXTEND 'assemblyName: DotNet.Testcontainers; function WaitForContainerWindows'

HofmeisterAn · HofmeisterAn · commit f7ff14cc583b · 2020-02-02T10:43:31.000+01:00
{Add UntilCommandIsCompleted and UntilPortIsAvailable for Windows container.}
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
@@ -3,7 +3,7 @@ name: $(date:yyyyMMdd)$(rev:.r)
 variables:
   DOTNET_CLI_TELEMETRY_OPTOUT: true
   DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
-  dotNetCoreVersion3: 3.1.100
+  dotNetCoreVersion3: 3.1.101
   dotNetCoreVersion2: 2.2.402
   cakeVersion: 0.36.0
 
@@ -39,7 +39,6 @@ jobs:
       testFilter: FullyQualifiedName~DotNet.Testcontainers
 
   # Run static code analysis and publish artifact.
-  # Until now, we do not cover Windows only tests.
   - ${{ if in(variables['Build.SourceBranch'], 'refs/heads/master', 'refs/heads/develop') }}:
     - template: azure/publish.yml
       parameters:
diff --git a/src/DotNet.Testcontainers.Tests/Unit/Containers/WaitUntilMessageIsLogged.cs b/src/DotNet.Testcontainers.Tests/Unit/Containers/WaitUntilMessageIsLogged.cs
@@ -0,0 +1,32 @@
+namespace DotNet.Testcontainers.Tests.Unit.Containers
+{
+  using System.IO;
+  using System.Linq;
+  using System.Threading.Tasks;
+  using DotNet.Testcontainers.Containers.WaitStrategies;
+  using Xunit;
+
+  public class WaitUntilMessageIsLogged
+  {
+    [Fact]
+    public async Task UntilMessageIsLogged()
+    {
+      // Given
+      const string expectedMessage = nameof(this.UntilMessageIsLogged);
+
+      // When
+      // Then
+      using (var memoryStream = new MemoryStream())
+      {
+        using (var streamWriter = new StreamWriter(memoryStream))
+        {
+          streamWriter.Write(expectedMessage);
+          streamWriter.Flush();
+
+          var wait = Wait.ForUnixContainer().UntilMessageIsLogged(memoryStream, expectedMessage);
+          await WaitStrategy.WaitUntil(() => wait.Build().Skip(1).First().Until(null, string.Empty));
+        }
+      }
+    }
+  }
+}
diff --git a/src/DotNet.Testcontainers.Tests/Unit/Containers/WaitUntilOperationIsSucceeded.cs b/src/DotNet.Testcontainers.Tests/Unit/Containers/WaitUntilOperationIsSucceeded.cs
@@ -1,13 +1,12 @@
 namespace DotNet.Testcontainers.Tests.Unit.Containers
 {
   using System;
+  using System.Linq;
   using System.Threading.Tasks;
-  using DotNet.Testcontainers.Clients;
-  using DotNet.Testcontainers.Containers.WaitStrategies.Common;
-  using Testcontainers.Containers.WaitStrategies;
+  using DotNet.Testcontainers.Containers.WaitStrategies;
   using Xunit;
 
-  public class WaitUntilOperationSucceededTest
+  public class WaitUntilOperationIsSucceeded
   {
     [Theory]
     [InlineData(1, 1)]
@@ -24,12 +23,13 @@ public async Task UntilMaxRepeats(int maxCallCount, int expectedCallsCount)
       // When
       await Assert.ThrowsAsync<TimeoutException>(async () =>
       {
-        var wait = new UntilOperationIsSucceeded(() =>
+        var wait = Wait.ForUnixContainer().UntilOperationIsSucceeded(() =>
         {
           callCounter += 1;
           return false;
         }, maxCallCount);
-        await WaitStrategy.WaitUntil(() => wait.Until(DockerApiEndpoint.Local, string.Empty));
+
+        await WaitStrategy.WaitUntil(() => wait.Build().Skip(1).First().Until(null, string.Empty));
       });
 
       // Then
@@ -51,8 +51,8 @@ public async Task UntilSomeRepeats(int maxCallCount, int expectedCallsCount)
       var callCounter = 0;
 
       // When
-      var wait = new UntilOperationIsSucceeded(() => ++callCounter >= expectedCallsCount, maxCallCount);
-      await WaitStrategy.WaitUntil(() => wait.Until(DockerApiEndpoint.Local, string.Empty));
+      var wait = Wait.ForUnixContainer().UntilOperationIsSucceeded(() => ++callCounter >= expectedCallsCount, maxCallCount);
+      await WaitStrategy.WaitUntil(() => wait.Build().Skip(1).First().Until(null, string.Empty));
 
       // Then
       Assert.Equal(expectedCallsCount, callCounter);
diff --git a/src/DotNet.Testcontainers.Tests/Unit/Containers/Windows/TestcontainersContainerTest.cs b/src/DotNet.Testcontainers.Tests/Unit/Containers/Windows/TestcontainersContainerTest.cs
@@ -19,12 +19,30 @@ public async Task IsWindowsEngineEnabled()
       }
 
       [IgnoreOnLinuxEngine]
-      public async Task SafeDisposable()
+      public async Task UntilCommandIsCompleted()
       {
-        // Given
         var testcontainersBuilder = new TestcontainersBuilder<TestcontainersContainer>()
-          .WithImage("mcr.microsoft.com/windows/nanoserver:1809")
-          .WithWaitStrategy(Wait.ForWindowsContainer());
+          .WithImage("mcr.microsoft.com/windows/servercore:1809")
+          .WithEntrypoint("PowerShell", "-Command", "Start-Sleep -Seconds 3600")
+          .WithWaitStrategy(Wait.ForWindowsContainer()
+            .UntilCommandIsCompleted("exit !(Test-Path -Path 'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe')"));
+
+        // When
+        // Then
+        await using (IDockerContainer testcontainer = testcontainersBuilder.Build())
+        {
+          await testcontainer.StartAsync();
+        }
+      }
+
+      [IgnoreOnLinuxEngine]
+      public async Task UntilPortIsAvailable()
+      {
+        var testcontainersBuilder = new TestcontainersBuilder<TestcontainersContainer>()
+          .WithImage("mcr.microsoft.com/windows/servercore:1809")
+          .WithEntrypoint("PowerShell", "-Command", "$tcpListener = [System.Net.Sockets.TcpListener]1337; $tcpListener.Start(); Start-Sleep -Seconds 3600")
+          .WithWaitStrategy(Wait.ForWindowsContainer()
+            .UntilPortIsAvailable(1337));
 
         // When
         // Then
diff --git a/src/DotNet.Testcontainers/Clients/DockerContainerOperations.cs b/src/DotNet.Testcontainers/Clients/DockerContainerOperations.cs
@@ -9,7 +9,6 @@ namespace DotNet.Testcontainers.Clients
   using Docker.DotNet.Models;
   using DotNet.Testcontainers.Containers.Configurations;
   using DotNet.Testcontainers.Containers.OutputConsumers;
-  using DotNet.Testcontainers.Containers.OutputConsumers.Common;
   using DotNet.Testcontainers.Internals.Mappers;
 
   internal sealed class DockerContainerOperations : DockerApiClient, IDockerContainerOperations
@@ -84,7 +83,7 @@ public Task RemoveAsync(string id, CancellationToken ct = default)
 
     public async Task AttachAsync(string id, IOutputConsumer outputConsumer, CancellationToken ct = default)
     {
-      if (outputConsumer is null || outputConsumer is DoNotConsumeStdoutOrStderr)
+      if (outputConsumer is null)
       {
         return;
       }
diff --git a/src/DotNet.Testcontainers/Containers/WaitStrategies/IWaitForContainerOS.cs b/src/DotNet.Testcontainers/Containers/WaitStrategies/IWaitForContainerOS.cs
@@ -23,8 +23,20 @@ public interface IWaitForContainerOS
     /// </summary>
     /// <param name="command">Command to be executed</param>
     /// <returns>A configured instance of <see cref="IWaitForContainerOS" />.</returns>
+    /// <remarks>Invokes the operating system command shell. Expects the exit code to be 0.</remarks>
     IWaitForContainerOS UntilCommandIsCompleted(string command);
 
+    /// <summary>
+    /// Waits until the command is completed successfully.
+    /// </summary>
+    /// <param name="command">Command to be executed</param>
+    /// <returns>A configured instance of <see cref="IWaitForContainerOS" />.</returns>
+    /// <remarks>
+    /// Does not invoke the operating system command shell.
+    /// Normal shell processing does not happen. Expects the exit code to be 0.
+    /// </remarks>
+    IWaitForContainerOS UntilCommandIsCompleted(params string[] command);
+
     /// <summary>
     /// Waits until the file exists.
     /// </summary>
diff --git a/src/DotNet.Testcontainers/Containers/WaitStrategies/Unix/UntilCommandIsCompleted.cs b/src/DotNet.Testcontainers/Containers/WaitStrategies/Unix/UntilCommandIsCompleted.cs
@@ -6,16 +6,20 @@ namespace DotNet.Testcontainers.Containers.WaitStrategies.Unix
 
   internal class UntilCommandIsCompleted : IWaitUntil
   {
-    private readonly string command;
+    private readonly string[] command;
 
-    public UntilCommandIsCompleted(string command)
+    public UntilCommandIsCompleted(string command) : this("/bin/sh", "-c", command)
+    {
+    }
+
+    public UntilCommandIsCompleted(params string[] command)
     {
       this.command = command;
     }
 
     public virtual async Task<bool> Until(Uri endpoint, string id)
     {
-      var exitCode = await new TestcontainersClient(endpoint).ExecAsync(id, new[] { "/bin/sh", "-c", this.command });
+      var exitCode = await new TestcontainersClient(endpoint).ExecAsync(id, this.command);
       return 0L.Equals(exitCode);
     }
   }
diff --git a/src/DotNet.Testcontainers/Containers/WaitStrategies/WaitForContainerOS.cs b/src/DotNet.Testcontainers/Containers/WaitStrategies/WaitForContainerOS.cs
@@ -12,6 +12,8 @@ internal abstract class WaitForContainerOS : IWaitForContainerOS
 
     public abstract IWaitForContainerOS UntilCommandIsCompleted(string command);
 
+    public abstract IWaitForContainerOS UntilCommandIsCompleted(params string[] command);
+
     public abstract IWaitForContainerOS UntilPortIsAvailable(int port);
 
     protected WaitForContainerOS()
diff --git a/src/DotNet.Testcontainers/Containers/WaitStrategies/WaitForContainerUnix.cs b/src/DotNet.Testcontainers/Containers/WaitStrategies/WaitForContainerUnix.cs
@@ -12,6 +12,13 @@ public override IWaitForContainerOS UntilCommandIsCompleted(string command)
       return this;
     }
 
+    /// <inheritdoc />
+    public override IWaitForContainerOS UntilCommandIsCompleted(params string[] command)
+    {
+      this.AddCustomWaitStrategy(new UntilCommandIsCompleted(command));
+      return this;
+    }
+
     /// <inheritdoc />
     public override IWaitForContainerOS UntilPortIsAvailable(int port)
     {
diff --git a/src/DotNet.Testcontainers/Containers/WaitStrategies/WaitForContainerWindows.cs b/src/DotNet.Testcontainers/Containers/WaitStrategies/WaitForContainerWindows.cs
@@ -12,6 +12,13 @@ public override IWaitForContainerOS UntilCommandIsCompleted(string command)
       return this;
     }
 
+    /// <inheritdoc />
+    public override IWaitForContainerOS UntilCommandIsCompleted(params string[] command)
+    {
+      this.AddCustomWaitStrategy(new UntilCommandIsCompleted(command));
+      return this;
+    }
+
     /// <inheritdoc />
     public override IWaitForContainerOS UntilPortIsAvailable(int port)
     {
diff --git a/src/DotNet.Testcontainers/Containers/WaitStrategies/Windows/UntilCommandIsCompleted.cs b/src/DotNet.Testcontainers/Containers/WaitStrategies/Windows/UntilCommandIsCompleted.cs
@@ -1,17 +1,13 @@
 namespace DotNet.Testcontainers.Containers.WaitStrategies.Windows
 {
-  using System;
-  using System.Threading.Tasks;
-
   internal class UntilCommandIsCompleted : Unix.UntilCommandIsCompleted
   {
-    public UntilCommandIsCompleted(string command) : base(command)
+    public UntilCommandIsCompleted(string command) : base("PowerShell", "-Command", command)
     {
     }
 
-    public override Task<bool> Until(Uri endpoint, string id)
+    public UntilCommandIsCompleted(params string[] command) : base(command)
     {
-      throw new NotImplementedException();
     }
   }
 }
diff --git a/src/DotNet.Testcontainers/Containers/WaitStrategies/Windows/UntilPortIsAvailable.cs b/src/DotNet.Testcontainers/Containers/WaitStrategies/Windows/UntilPortIsAvailable.cs
@@ -1,17 +1,10 @@
 namespace DotNet.Testcontainers.Containers.WaitStrategies.Windows
 {
-  using System;
-  using System.Threading.Tasks;
-
-  internal class UntilPortIsAvailable : Unix.UntilPortIsAvailable
+  internal class UntilPortIsAvailable : UntilCommandIsCompleted
   {
-    public UntilPortIsAvailable(int port) : base(port)
+    public UntilPortIsAvailable(int port) : base(
+      $"exit !(Test-NetConnection -ComputerName 'localhost' -Port {port}).TcpTestSucceeded")
     {
     }
-
-    public override Task<bool> Until(Uri endpoint, string id)
-    {
-      throw new NotImplementedException();
-    }
   }
 }
diff --git a/src/DotNet.Testcontainers/Images/Builders/ImageFromDockerfileBuilder.cs b/src/DotNet.Testcontainers/Images/Builders/ImageFromDockerfileBuilder.cs
@@ -5,6 +5,7 @@ namespace DotNet.Testcontainers.Images.Builders
   using DotNet.Testcontainers.Images.Configurations;
   using DotNet.Testcontainers.Internals;
 
+  /// <inheritdoc cref="IImageFromDockerfileBuilder" />
   public sealed class ImageFromDockerfileBuilder : IImageFromDockerfileBuilder
   {
     private readonly IImageFromDockerfileConfiguration configuration;
@@ -18,35 +19,41 @@ private ImageFromDockerfileBuilder(IImageFromDockerfileConfiguration configurati
       this.configuration = configuration;
     }
 
+    /// <inheritdoc />
     public IImageFromDockerfileBuilder WithName(string name)
     {
       return this.WithName(new DockerImage(name));
     }
 
+    /// <inheritdoc />
     public IImageFromDockerfileBuilder WithName(IDockerImage name)
     {
       return new ImageFromDockerfileBuilder(
         new ImageFromDockerfileConfiguration(name, this.configuration.Dockerfile, this.configuration.DockerfileDirectory, this.configuration.DeleteIfExists));
     }
 
+    /// <inheritdoc />
     public IImageFromDockerfileBuilder WithDockerfile(string dockerfile)
     {
       return new ImageFromDockerfileBuilder(
         new ImageFromDockerfileConfiguration(this.configuration.Image, dockerfile, this.configuration.DockerfileDirectory, this.configuration.DeleteIfExists));
     }
 
+    /// <inheritdoc />
     public IImageFromDockerfileBuilder WithDockerfileDirectory(string dockerfileDirectory)
     {
       return new ImageFromDockerfileBuilder(
         new ImageFromDockerfileConfiguration(this.configuration.Image, this.configuration.Dockerfile, dockerfileDirectory, this.configuration.DeleteIfExists));
     }
 
+    /// <inheritdoc />
     public IImageFromDockerfileBuilder WithDeleteIfExists(bool deleteIfExists)
     {
       return new ImageFromDockerfileBuilder(
         new ImageFromDockerfileConfiguration(this.configuration.Image, this.configuration.Dockerfile, this.configuration.DockerfileDirectory, deleteIfExists));
     }
 
+    /// <inheritdoc />
     public async Task<string> Build()
     {
       await new SynchronizationContextRemover();
diff --git a/src/DotNet.Testcontainers/Images/Configurations/ImageFromDockerfileConfiguration.cs b/src/DotNet.Testcontainers/Images/Configurations/ImageFromDockerfileConfiguration.cs
@@ -2,7 +2,7 @@ namespace DotNet.Testcontainers.Images.Configurations
 {
   using System;
 
-  /// <inheritdoc />
+  /// <inheritdoc cref="IImageFromDockerfileConfiguration" />
   internal sealed class ImageFromDockerfileConfiguration : IImageFromDockerfileConfiguration
   {
     public ImageFromDockerfileConfiguration() : this(CreateDockerImage())
diff --git a/src/DotNet.Testcontainers/Images/DockerImage.cs b/src/DotNet.Testcontainers/Images/DockerImage.cs
@@ -4,6 +4,7 @@ namespace DotNet.Testcontainers.Images
   using System.Linq;
   using DotNet.Testcontainers.Internals.Parsers;
 
+  /// <inheritdoc cref="IDockerImage" />
   public sealed class DockerImage : IDockerImage
   {
     private static readonly MatchImage[] MatchImages = { new MatchImageRegistry(), new MatchImageRepositoryTag(), new MatchImageRepositoryLatest(), new MatchImageTag(), new MatchImage() };
@@ -32,12 +33,16 @@ public DockerImage(string repository, string name, string tag)
       }
     }
 
+    /// <inheritdoc />
     public string Repository { get; }
 
+    /// <inheritdoc />
     public string Name { get; }
 
+    /// <inheritdoc />
     public string Tag { get; }
 
+    /// <inheritdoc />
     public string FullName => string.IsNullOrEmpty(this.Repository) ? $"{this.Name}:{this.Tag}" : $"{this.Repository}/{this.Name}:{this.Tag}";
   }
 }
diff --git a/src/DotNet.Testcontainers/Images/IDockerImage.cs b/src/DotNet.Testcontainers/Images/IDockerImage.cs
@@ -1,21 +1,27 @@
 namespace DotNet.Testcontainers.Images
 {
+  using System.Diagnostics.CodeAnalysis;
+
   public interface IDockerImage
   {
     /// <summary>Gets the Docker image repository name.</summary>
     /// <value>Returns the Docker image repository name.</value>
+    [NotNull]
     string Repository { get; }
 
     /// <summary>Gets the Docker image name.</summary>
     /// <value>Returns the Docker image name.</value>
+    [NotNull]
     string Name { get; }
 
     /// <summary>Gets the Docker image tag.</summary>
     /// <value>Returns the Docker image tag if present or "latest" instead.</value>
+    [NotNull]
     string Tag { get; }
 
     /// <summary>Gets or sets the full Docker image name. Splits the full Docker image name into its components and sets each properties.</summary>
     /// <value>Full Docker image name, like "foo/bar:1.0.0" or "bar:latest" based on the components values.</value>
+    [NotNull]
     string FullName { get; }
   }
 }
diff --git a/tools/packages.config b/tools/packages.config
@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Cake" version="0.36.0" />
+  <package id="Cake" version="0.37.0" />
 </packages>

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,6 @@ namespace DotNet.Testcontainers.Clients`
`9`	`9`	`using Docker.DotNet.Models;`
`10`	`10`	`using DotNet.Testcontainers.Containers.Configurations;`
`11`	`11`	`using DotNet.Testcontainers.Containers.OutputConsumers;`
`12`		`- using DotNet.Testcontainers.Containers.OutputConsumers.Common;`
`13`	`12`	`using DotNet.Testcontainers.Internals.Mappers;`
`14`	`13`
`15`	`14`	`internal sealed class DockerContainerOperations : DockerApiClient, IDockerContainerOperations`
`@@ -84,7 +83,7 @@ public Task RemoveAsync(string id, CancellationToken ct = default)`
`84`	`83`
`85`	`84`	`public async Task AttachAsync(string id, IOutputConsumer outputConsumer, CancellationToken ct = default)`
`86`	`85`	`{`
`87`		`- if (outputConsumer is null \|\| outputConsumer is DoNotConsumeStdoutOrStderr)`
	`86`	`+ if (outputConsumer is null)`
`88`	`87`	`{`
`89`	`88`	`return;`
`90`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,16 +6,20 @@ namespace DotNet.Testcontainers.Containers.WaitStrategies.Unix`
`6`	`6`
`7`	`7`	`internal class UntilCommandIsCompleted : IWaitUntil`
`8`	`8`	`{`
`9`		`- private readonly string command;`
	`9`	`+ private readonly string[] command;`
`10`	`10`
`11`		`- public UntilCommandIsCompleted(string command)`
	`11`	`+ public UntilCommandIsCompleted(string command) : this("/bin/sh", "-c", command)`
	`12`	`+ {`
	`13`	`+ }`
	`14`	`+`
	`15`	`+ public UntilCommandIsCompleted(params string[] command)`
`12`	`16`	`{`
`13`	`17`	`this.command = command;`
`14`	`18`	`}`
`15`	`19`
`16`	`20`	`public virtual async Task<bool> Until(Uri endpoint, string id)`
`17`	`21`	`{`
`18`		`- var exitCode = await new TestcontainersClient(endpoint).ExecAsync(id, new[] { "/bin/sh", "-c", this.command });`
	`22`	`+ var exitCode = await new TestcontainersClient(endpoint).ExecAsync(id, this.command);`
`19`	`23`	`return 0L.Equals(exitCode);`
`20`	`24`	`}`
`21`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,13 @@ public override IWaitForContainerOS UntilCommandIsCompleted(string command)`
`12`	`12`	`return this;`
`13`	`13`	`}`
`14`	`14`
	`15`	`+ /// <inheritdoc />`
	`16`	`+ public override IWaitForContainerOS UntilCommandIsCompleted(params string[] command)`
	`17`	`+ {`
	`18`	`+ this.AddCustomWaitStrategy(new UntilCommandIsCompleted(command));`
	`19`	`+ return this;`
	`20`	`+ }`
	`21`	`+`
`15`	`22`	`/// <inheritdoc />`
`16`	`23`	`public override IWaitForContainerOS UntilPortIsAvailable(int port)`
`17`	`24`	`{`