Merge branch 'develop' into ssl-config-dotnet

Author: ozkanpakdil

docs/api/wait_strategies.md

@@ -7,7 +7,6 @@ _ = Wait.ForUnixContainer()
   .UntilInternalTcpPortIsAvailable(80)
   .UntilFileExists("/tmp/foo")
   .UntilFileExists("/tmp/bar")
-  .UntilOperationIsSucceeded(() => true, 1)
   .AddCustomWaitStrategy(new MyCustomWaitStrategy());
 ```
 
@@ -20,6 +19,17 @@ _ = Wait.ForUnixContainer()
 
 Besides configuring the wait strategy, cancelling a container start can always be done utilizing a [CancellationToken](create_docker_container.md#canceling-a-container-start).
 
+## Wait strategy modes
+
+Wait strategy modes define how Testcontainers for .NET handles container readiness checks. By default, wait strategies assume the container remains running throughout the startup. If a container exits unexpectedly during startup, Testcontainers for .NET will throw a `ContainerNotRunningException` containing the exit code and logs.
+
+Some containers are intended to stop after completing short-lived tasks like migrations or setup scripts. In these cases, the container exit is expected, not a failure. Use `WaitStrategyMode.OneShot` to treat a normal exit as successful rather than throwing an exception.
+
+```csharp
+_ = Wait.ForUnixContainer()
+  .UntilMessageIsLogged("Migration completed", o => o.WithMode(WaitStrategyMode.OneShot));
+```
+
 ## Wait until an HTTP(S) endpoint is available
 
 You can choose to wait for an HTTP(S) endpoint to return a particular HTTP response status code or to match a predicate. The default configuration tries to access the HTTP endpoint running inside the container. Chose `ForPort(ushort)` or `ForPath(string)` to adjust the endpoint or `UsingTls()` to switch to HTTPS. When using `UsingTls()` port 443 is used as a default. If your container exposes a different HTTPS port, make sure that the correct waiting port is configured accordingly.

docs/custom_configuration/index.md

@@ -81,13 +81,13 @@ Once configured, Testcontainers will rewrite Docker Hub image names by adding th
 For example, the image:
 
 ```
-testcontainers/helloworld:1.2.0
+testcontainers/helloworld:1.3.0
 ```
 
 will automatically become:
 
 ```
-registry.mycompany.com/mirror/testcontainers/helloworld:1.2.0
+registry.mycompany.com/mirror/testcontainers/helloworld:1.3.0
 ```
 
 ## Enable logging

docs/index.md

@@ -7,8 +7,8 @@ dotnet add package Testcontainers
 ```csharp title="Run the Hello World container"
 // Create a new instance of a container.
 var container = new ContainerBuilder()
-  // Set the image for the container to "testcontainers/helloworld:1.2.0".
-  .WithImage("testcontainers/helloworld:1.2.0")
+  // Set the image for the container to "testcontainers/helloworld:1.3.0".
+  .WithImage("testcontainers/helloworld:1.3.0")
   // Bind port 8080 of the container to a random port on the host.
   .WithPortBinding(8080, true)
   // Wait until the HTTP endpoint of the container is available.

src/Testcontainers.MongoDb/MongoDbBuilder.cs

@@ -65,7 +65,7 @@ public MongoDbBuilder WithPassword(string password)
     }
 
     /// <summary>
-    /// Initialize MongoDB as a single-node replica set.
+    /// Initializes MongoDB as a single-node replica set.
     /// </summary>
     /// <param name="replicaSetName">The replica set name.</param>
     /// <returns>A configured instance of <see cref="MongoDbBuilder" />.</returns>
@@ -97,7 +97,7 @@ public override MongoDbContainer Build()
         }
         else
         {
-            waitUntil = new WaitInitiateReplicaSet(DockerResourceConfiguration);
+            waitUntil = new WaitInitiateReplicaSet();
         }
 
         // If the user does not provide a custom waiting strategy, append the default MongoDb waiting strategy.
@@ -112,7 +112,8 @@ protected override MongoDbBuilder Init()
             .WithImage(MongoDbImage)
             .WithPortBinding(MongoDbPort, true)
             .WithUsername(DefaultUsername)
-            .WithPassword(DefaultPassword);
+            .WithPassword(DefaultPassword)
+            .WithStartupCallback(InitiateReplicaSetAsync);
     }
 
     /// <inheritdoc />
@@ -150,6 +151,38 @@ protected override MongoDbBuilder Merge(MongoDbConfiguration oldValue, MongoDbCo
         return new MongoDbBuilder(new MongoDbConfiguration(oldValue, newValue));
     }
 
+    /// <summary>
+    /// Initiates the MongoDB replica set.
+    /// </summary>
+    /// <param name="container">The container instance.</param>
+    /// <param name="configuration">The container configuration.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>Task that completes when the replica set initiation has been executed.</returns>
+    private static async Task InitiateReplicaSetAsync(MongoDbContainer container, MongoDbConfiguration configuration, CancellationToken ct)
+    {
+        if (string.IsNullOrEmpty(configuration.ReplicaSetName))
+        {
+            return;
+        }
+
+        // This is a simple workaround to use the default options, which can be configured
+        // with custom configurations as needed.
+        var options = new WaitStrategy();
+
+        var scriptContent = $"var r=rs.initiate({{_id:\"{configuration.ReplicaSetName}\",members:[{{_id:0,host:\"127.0.0.1:27017\"}}]}});quit(r.ok===1?0:1);";
+
+        var initiate = async () =>
+        {
+            var execResult = await container.ExecScriptAsync(scriptContent, ct)
+                .ConfigureAwait(false);
+
+            return 0L.Equals(execResult.ExitCode);
+        };
+
+        await WaitStrategy.WaitUntilAsync(initiate, options.Interval, options.Timeout, options.Retries, ct)
+            .ConfigureAwait(false);
+    }
+
     /// <inheritdoc cref="IWaitUntil" />
     private sealed class WaitIndicateReadiness : IWaitUntil
     {
@@ -182,16 +215,7 @@ public async Task<bool> UntilAsync(IContainer container)
     /// <inheritdoc cref="IWaitUntil" />
     private sealed class WaitInitiateReplicaSet : IWaitUntil
     {
-        private readonly string _scriptContent;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="WaitInitiateReplicaSet" /> class.
-        /// </summary>
-        /// <param name="configuration">The container configuration.</param>
-        public WaitInitiateReplicaSet(MongoDbConfiguration configuration)
-        {
-            _scriptContent = $"try{{rs.status()}}catch(e){{rs.initiate({{_id:'{configuration.ReplicaSetName}',members:[{{_id:0,host:'127.0.0.1:27017'}}]}});throw e;}}";
-        }
+        private const string ScriptContent = "var r=db.runCommand({hello:1}).isWritablePrimary;quit(r===true?0:1);";
 
         /// <inheritdoc />
         public Task<bool> UntilAsync(IContainer container)
@@ -200,9 +224,9 @@ public Task<bool> UntilAsync(IContainer container)
         }
 
         /// <inheritdoc cref="IWaitUntil.UntilAsync" />
-        private async Task<bool> UntilAsync(MongoDbContainer container)
+        private static async Task<bool> UntilAsync(MongoDbContainer container)
         {
-            var execResult = await container.ExecScriptAsync(_scriptContent)
+            var execResult = await container.ExecScriptAsync(ScriptContent)
                 .ConfigureAwait(false);
 
             return 0L.Equals(execResult.ExitCode);

src/Testcontainers.Papercut/PapercutBuilder.cs

@@ -4,11 +4,11 @@ namespace Testcontainers.Papercut;
 [PublicAPI]
 public sealed class PapercutBuilder : ContainerBuilder<PapercutBuilder, PapercutContainer, PapercutConfiguration>
 {
-    public const string PapercutImage = "changemakerstudiosus/papercut-smtp:latest";
+    public const string PapercutImage = "changemakerstudiosus/papercut-smtp:7.0";
 
-    public const ushort SmtpPort = 25;
+    public const ushort SmtpPort = 2525;
 
-    public const ushort HttpPort = 80;
+    public const ushort HttpPort = 8080;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PapercutBuilder" /> class.

src/Testcontainers/Configurations/Commons/DefaultJsonSerializerOptions.cs

@@ -0,0 +1,15 @@
+namespace DotNet.Testcontainers.Configurations
+{
+  using System.Text.Json;
+
+  internal static class DefaultJsonSerializerOptions
+  {
+    static DefaultJsonSerializerOptions()
+    {
+      Instance.Converters.Add(new JsonOrderedKeysConverter());
+    }
+
+    public static JsonSerializerOptions Instance { get; }
+      = new JsonSerializerOptions();
+  }
+}

src/Testcontainers/Configurations/Commons/JsonIgnoreRuntimeResourceLabels.cs

@@ -1,39 +1,24 @@
 namespace DotNet.Testcontainers.Configurations
 {
-  using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text.Json;
-  using System.Text.Json.Serialization;
   using DotNet.Testcontainers.Clients;
   using DotNet.Testcontainers.Containers;
 
-  internal sealed class JsonIgnoreRuntimeResourceLabels : JsonConverter<IReadOnlyDictionary<string, string>>
+  internal sealed class JsonIgnoreRuntimeResourceLabels : JsonOrderedKeysConverter
   {
-    private static readonly ISet<string> IgnoreLabels = new HashSet<string> { ResourceReaper.ResourceReaperSessionLabel, TestcontainersClient.TestcontainersVersionLabel, TestcontainersClient.TestcontainersSessionIdLabel };
-
-    public override bool CanConvert(Type typeToConvert)
-    {
-      return typeof(IEnumerable<KeyValuePair<string, string>>).IsAssignableFrom(typeToConvert);
-    }
-
-    public override IReadOnlyDictionary<string, string> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    private static readonly ISet<string> IgnoreLabels = new HashSet<string>
     {
-      return JsonSerializer.Deserialize<IReadOnlyDictionary<string, string>>(ref reader);
-    }
+      ResourceReaper.ResourceReaperSessionLabel,
+      TestcontainersClient.TestcontainersVersionLabel,
+      TestcontainersClient.TestcontainersSessionIdLabel,
+    };
 
     public override void Write(Utf8JsonWriter writer, IReadOnlyDictionary<string, string> value, JsonSerializerOptions options)
     {
       var labels = value.Where(label => !IgnoreLabels.Contains(label.Key)).ToDictionary(label => label.Key, label => label.Value);
-
-      writer.WriteStartObject();
-
-      foreach (var label in labels)
-      {
-        writer.WriteString(label.Key, label.Value);
-      }
-
-      writer.WriteEndObject();
+      base.Write(writer, labels, options);
     }
   }
 }

src/Testcontainers/Configurations/Commons/JsonOrderedKeysConverter.cs

@@ -0,0 +1,33 @@
+namespace DotNet.Testcontainers.Configurations
+{
+  using System;
+  using System.Collections.Generic;
+  using System.Linq;
+  using System.Text.Json;
+  using System.Text.Json.Serialization;
+
+  internal class JsonOrderedKeysConverter : JsonConverter<IReadOnlyDictionary<string, string>>
+  {
+    public override bool CanConvert(Type typeToConvert)
+    {
+      return typeof(IEnumerable<KeyValuePair<string, string>>).IsAssignableFrom(typeToConvert);
+    }
+
+    public override IReadOnlyDictionary<string, string> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+      return JsonSerializer.Deserialize<IReadOnlyDictionary<string, string>>(ref reader);
+    }
+
+    public override void Write(Utf8JsonWriter writer, IReadOnlyDictionary<string, string> value, JsonSerializerOptions options)
+    {
+      writer.WriteStartObject();
+
+      foreach (var item in value.OrderBy(item => item.Key))
+      {
+        writer.WriteString(item.Key, item.Value);
+      }
+
+      writer.WriteEndObject();
+    }
+  }
+}

src/Testcontainers/Configurations/Commons/ResourceConfiguration.cs

@@ -88,7 +88,7 @@ protected ResourceConfiguration(IResourceConfiguration<TCreateResourceEntity> ol
     /// <inheritdoc />
     public virtual string GetReuseHash()
     {
-      var jsonUtf8Bytes = JsonSerializer.SerializeToUtf8Bytes(this, GetType());
+      var jsonUtf8Bytes = JsonSerializer.SerializeToUtf8Bytes(this, GetType(), DefaultJsonSerializerOptions.Instance);
 
 #if NET6_0_OR_GREATER
       return Convert.ToBase64String(SHA1.HashData(jsonUtf8Bytes));

src/Testcontainers/Configurations/WaitStrategies/IWaitStrategy.cs

@@ -9,6 +9,13 @@ namespace DotNet.Testcontainers.Configurations
   [PublicAPI]
   public interface IWaitStrategy
   {
+    /// <summary>
+    /// Sets the wait strategy mode.
+    /// </summary>
+    /// <param name="mode">The wait strategy mode.</param>
+    /// <returns>The updated instance of the wait strategy.</returns>
+    IWaitStrategy WithMode(WaitStrategyMode mode);
+
     /// <summary>
     /// Sets the number of retries for the wait strategy.
     /// </summary>