chore: Update remaining parts

Author: HofmeisterAn

Directory.Packages.props

@@ -41,8 +41,8 @@
         <PackageVersion Include="Confluent.SchemaRegistry" Version="2.8.0"/>
         <PackageVersion Include="Consul" Version="1.6.10.9"/>
         <PackageVersion Include="CouchbaseNetClient" Version="3.6.4"/>
-        <PackageVersion Include="Net.IBM.Data.Db2-lnx" Version="8.0.0.200"/>
-        <PackageVersion Include="Net.IBM.Data.Db2" Version="8.0.0.200"/>
+        <PackageVersion Include="Net.IBM.Data.Db2-lnx" Version="9.0.0.100"/>
+        <PackageVersion Include="Net.IBM.Data.Db2" Version="9.0.0.100"/>
         <PackageVersion Include="DotPulsar" Version="3.3.2"/>
         <PackageVersion Include="Elastic.Clients.Elasticsearch" Version="8.16.3"/>
         <PackageVersion Include="EventStore.Client.Grpc.Streams" Version="22.0.0"/>

Testcontainers.sln

@@ -218,6 +218,9 @@ EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Testcontainers.Xunit.Tests", "tests\Testcontainers.Xunit.Tests\Testcontainers.Xunit.Tests.csproj", "{E901DF14-6F05-4FC2-825A-3055FAD33561}"
 EndProject
 Global
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU

docs/modules/db2.md

@@ -1,41 +1,31 @@
 # IBM DB2
 
-[IBM DB2](https://www.ibm.com/db2), is a relational database engine developed by IBM. The following example provides .NET developers with a starting point to use a IBM DB2 instance in the [xUnit][xunit] tests.
+[IBM DB2](https://www.ibm.com/db2) is a relational database engine developed by IBM.
 
-The following example (for windows) uses the following NuGet packages:
+Add the following dependency to your project file:
 
-```console title="Install the NuGet dependencies"
+```shell title="NuGet"
 dotnet add package Testcontainers.Db2
-dotnet add package Net.IBM.Data.Db2
-dotnet add package xunit
 ```
 
-Please note: For linux there are currently some hurdles and the package Net.IBM.Data.Db2-lnx has to be used with the following environment variables being set:
+!!! warning
 
-  - LD_LIBRARY_PATH
-  - PATH
-  - DB2_CLI_DRIVER_INSTALL_PATH
+    The Linux client dependency, [Net.IBM.Data.Db2-lnx](https://www.nuget.org/packages/Net.IBM.Data.Db2-lnx), requires additional configurations. We use the [Testcontainers.Db2.Tests.targets](tests/Testcontainers.Db2.Tests/Testcontainers.Db2.Tests.targets) file to configure the environment variables: `LD_LIBRARY_PATH`, `PATH`, `DB2_CLI_DRIVER_INSTALL_PATH`, at runtime.
 
-One way to achieve this within a test project is to extend the .csproj with a task that writes a .runsettings file. An example is given below:
-
-=== "Example"
-    ```xml
-    --8<-- "tests/Testcontainers.Db2.Tests/Testcontainers.Db2.Tests.csproj:RunSettingsGeneration"
-    ```
-
-IDEs and editors may also require the following packages to run tests: `xunit.runner.visualstudio` and `Microsoft.NET.Test.Sdk`.
-
-Copy and paste the following code into a new `.cs` test file within an existing test project.
+You can start an DB2 container instance from any .NET application. This example uses xUnit.net's `IAsyncLifetime` interface to manage the lifecycle of the container. The container is started in the `InitializeAsync` method before the test method runs, ensuring that the environment is ready for testing. After the test completes, the container is removed in the `DisposeAsync` method.
 
 === "Usage Example"
     ```csharp
     --8<-- "tests/Testcontainers.Db2.Tests/Db2ContainerTest.cs:UseDb2Container"
     ```
 
-To execute the tests, use the command `dotnet test` from a terminal.
+The test example uses the following NuGet dependencies:
 
-## A Note To Developers
+=== "Package References"
+    ```xml
+    --8<-- "tests/Testcontainers.Db2.Tests/Testcontainers.Db2.Tests.csproj:PackageReferences"
+    ```
 
-Once Testcontainers creates a server instance, developers may use the connection string with any of the popular data-access technologies found in the .NET Ecosystem. Some of these libraries include [Entity Framework Core](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore), [Dapper](https://www.nuget.org/packages/Dapper), and [NHibernate](https://www.nuget.org/packages/NHibernate). At which point, developers can execute database migrations and SQL scripts.
+To execute the tests, use the command `dotnet test` from a terminal.
 
-[xunit]: https://xunit.net/
+--8<-- "docs/modules/_call_out_test_projects.txt"

src/Testcontainers.Db2/Db2Builder.cs

@@ -14,9 +14,11 @@ public sealed class Db2Builder : ContainerBuilder<Db2Builder, Db2Container, Db2C
 
     public const string DefaultPassword = "db2inst1";
 
-    public const string DefaultLicenseAgreement = "accept";
+    private const string AcceptLicenseAgreementEnvVar = "LICENSE";
 
-    public const string DefaultInMemoryDatabasePath = "/home/db2inst1/data";
+    private const string AcceptLicenseAgreement = "accept";
+
+    private const string DeclineLicenseAgreement = "decline";
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Db2Builder" /> class.
@@ -40,6 +42,20 @@ private Db2Builder(Db2Configuration resourceConfiguration)
     /// <inheritdoc />
     protected override Db2Configuration DockerResourceConfiguration { get; }
 
+    /// <summary>
+    /// Accepts the license agreement.
+    /// </summary>
+    /// <remarks>
+    /// When <paramref name="acceptLicenseAgreement" /> is set to <c>true</c>, the Db2 <see href="www.ibm.com/terms/?id=L-SNMD-UVTL8R">license</see> is accepted.
+    /// </remarks>
+    /// <param name="acceptLicenseAgreement">A boolean value indicating whether the Db2 license agreement is accepted.</param>
+    /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
+    public Db2Builder WithAcceptLicenseAgreement(bool acceptLicenseAgreement)
+    {
+        var licenseAgreement = acceptLicenseAgreement ? AcceptLicenseAgreement : DeclineLicenseAgreement;
+        return WithEnvironment(AcceptLicenseAgreementEnvVar, licenseAgreement);
+    }
+
     /// <summary>
     /// Sets the Db2 database name.
     /// </summary>
@@ -59,7 +75,8 @@ public Db2Builder WithDatabase(string database)
     public Db2Builder WithUsername(string username)
     {
         return Merge(DockerResourceConfiguration, new Db2Configuration(username: username))
-            .WithEnvironment("DB2INSTANCE", username);
+            .WithEnvironment("DB2INSTANCE", username)
+            .WithTmpfsMount(string.Join("/", string.Empty, "home", username, "data"));
     }
 
     /// <summary>
@@ -73,53 +90,36 @@ public Db2Builder WithPassword(string password)
             .WithEnvironment("DB2INST1_PASSWORD", password);
     }
 
-    /// <summary>
-    /// Accepts the Db2 license agreement.
-    /// </summary>
-    /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
-    public Db2Builder WithLicenseAgreement()
-    {
-        return Merge(DockerResourceConfiguration, new Db2Configuration(licenseAgreement: DefaultLicenseAgreement))
-            .WithEnvironment("LICENSE", DefaultLicenseAgreement);
-    }
-
-    /// <summary>
-    /// Maps the database to memory.
-    /// </summary>
-    /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
-    public Db2Builder WithInMemoryDatabase()
-    {
-        return Merge(DockerResourceConfiguration, new Db2Configuration(inMemoryDatabasePath: DefaultInMemoryDatabasePath))
-            .WithTmpfsMount(DefaultInMemoryDatabasePath);
-    }
-
     /// <inheritdoc />
     public override Db2Container Build()
     {
         Validate();
         return new Db2Container(DockerResourceConfiguration);
     }
 
-  /// <inheritdoc />
+    /// <inheritdoc />
     protected override Db2Builder Init() => base.Init()
         .WithImage(Db2Image)
         .WithPortBinding(Db2Port, true)
         .WithDatabase(DefaultDatabase)
         .WithUsername(DefaultUsername)
         .WithPassword(DefaultPassword)
-        .WithLicenseAgreement()
-        .WithInMemoryDatabase()
         .WithPrivileged(true)
-        .WithWaitStrategy(Wait.ForUnixContainer()
-          .UntilMessageIsLogged("All databases are now active")
-          .UntilMessageIsLogged("Setup has completed.")
-          .AddCustomWaitStrategy(new WaitUntil(DockerResourceConfiguration)));
+        .WithWaitStrategy(Wait.ForUnixContainer().UntilMessageIsLogged("Setup has completed."));
 
     /// <inheritdoc />
     protected override void Validate()
     {
+        const string message = "The image '{0}' requires you to accept a license agreement.";
+
         base.Validate();
 
+        Predicate<Db2Configuration> licenseAgreementNotAccepted = value =>
+            !value.Environments.TryGetValue(AcceptLicenseAgreementEnvVar, out var licenseAgreementValue) || !AcceptLicenseAgreement.Equals(licenseAgreementValue, StringComparison.Ordinal);
+
+        _ = Guard.Argument(DockerResourceConfiguration, nameof(DockerResourceConfiguration.Image))
+            .ThrowIf(argument => licenseAgreementNotAccepted(argument.Value), argument => throw new ArgumentException(string.Format(message, DockerResourceConfiguration.Image.FullName), argument.Name));
+
         _ = Guard.Argument(DockerResourceConfiguration.Username, nameof(DockerResourceConfiguration.Username))
             .NotNull()
             .NotEmpty();
@@ -146,26 +146,4 @@ protected override Db2Builder Merge(Db2Configuration oldValue, Db2Configuration
     {
         return new Db2Builder(new Db2Configuration(oldValue, newValue));
     }
-
-    /// <inheritdoc cref="IWaitUntil" />
-    private sealed class WaitUntil : IWaitUntil
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="WaitUntil" /> class.
-        /// </summary>
-        /// <param name="configuration">The container configuration.</param>
-        public WaitUntil(Db2Configuration configuration)
-        {
-        }
-
-        /// <inheritdoc />
-        public async Task<bool> UntilAsync(IContainer container)
-        {
-            var db2Container = (Db2Container)container;
-
-            var execResult = await db2Container.ExecScriptAsync("SELECT 1 FROM SYSIBM.SYSDUMMY1").ConfigureAwait(false);
-
-            return 0L.Equals(execResult.ExitCode);
-        }
-    }
 }

src/Testcontainers.Db2/Db2Configuration.cs

@@ -4,37 +4,20 @@ namespace Testcontainers.Db2;
 [PublicAPI]
 public sealed class Db2Configuration : ContainerConfiguration
 {
-    private readonly bool _archiveLogs;
-    private readonly bool _autoConfig;
-    private readonly string _licenseAgreement;
-    private readonly string _inMemoryDatabasePath;
-
     /// <summary>
     /// Initializes a new instance of the <see cref="Db2Configuration" /> class.
     /// </summary>
     /// <param name="database">The Db2 database.</param>
     /// <param name="username">The Db2 username.</param>
     /// <param name="password">The Db2 password.</param>
-    /// <param name="archiveLogs">The Db2 archive logs setting.</param>
-    /// <param name="autoConfig">The Db2 auto config setting.</param>
-    /// <param name="licenseAgreement">The Db2 license agreement.</param>
-    /// <param name="inMemoryDatabasePath">The Db2 database path to map into memory (tmpfs).</param>
     public Db2Configuration(
         string database = null,
         string username = null,
-        string password = null,
-        bool archiveLogs = false,
-        bool autoConfig = false,
-        string licenseAgreement = null,
-        string inMemoryDatabasePath = null)
+        string password = null)
     {
         Database = database;
         Username = username;
         Password = password;
-        _archiveLogs = archiveLogs;
-        _autoConfig = autoConfig;
-        _licenseAgreement = licenseAgreement;
-        _inMemoryDatabasePath = inMemoryDatabasePath;
     }
 
     /// <summary>
@@ -78,10 +61,6 @@ public Db2Configuration(Db2Configuration oldValue, Db2Configuration newValue)
         Database = BuildConfiguration.Combine(oldValue.Database, newValue.Database);
         Username = BuildConfiguration.Combine(oldValue.Username, newValue.Username);
         Password = BuildConfiguration.Combine(oldValue.Password, newValue.Password);
-        _archiveLogs = BuildConfiguration.Combine(oldValue._archiveLogs, newValue._archiveLogs);
-        _autoConfig = BuildConfiguration.Combine(oldValue._autoConfig, newValue._autoConfig);
-        _licenseAgreement = BuildConfiguration.Combine(oldValue._licenseAgreement, newValue._licenseAgreement);
-        _inMemoryDatabasePath = BuildConfiguration.Combine(oldValue._inMemoryDatabasePath, newValue._inMemoryDatabasePath);
     }
 
     /// <summary>

src/Testcontainers.Db2/Db2Container.cs

@@ -4,37 +4,45 @@ namespace Testcontainers.Db2;
 [PublicAPI]
 public sealed class Db2Container : DockerContainer, IDatabaseContainer
 {
-    private static string Db2CommandPath = "/opt/ibm/db2/*/bin/db2";
-
     private readonly Db2Configuration _configuration;
 
-    private const char ConnectionStringDelimiter = ';';
-
     public Db2Container(Db2Configuration configuration) : base(configuration)
     {
         _configuration = configuration;
     }
 
-    public string GetConnectionString() => new StringBuilder()
-        .Append("Server=").Append(Hostname).Append(':').Append(GetMappedPublicPort(Db2Builder.Db2Port).ToString())
-        .Append(ConnectionStringDelimiter)
-        .Append("Database=").Append(_configuration.Database).Append(ConnectionStringDelimiter)
-        .Append("UID=").Append(_configuration.Username).Append(ConnectionStringDelimiter)
-        .Append("PWD=").Append(_configuration.Password).Append(ConnectionStringDelimiter)
-        .ToString();
+    /// <summary>
+    /// Gets the Db2 connection string.
+    /// </summary>
+    /// <returns>The Db2 connection string.</returns>
+    public string GetConnectionString()
+    {
+        var properties = new Dictionary<string, string>();
+        properties.Add("Server", Hostname + ":" + GetMappedPublicPort(Db2Builder.Db2Port));
+        properties.Add("Database", _configuration.Database);
+        properties.Add("UID", _configuration.Username);
+        properties.Add("PWD", _configuration.Password);
+        return string.Join(";", properties.Select(property => string.Join("=", property.Key, property.Value)));
+    }
 
-    public async Task<ExecResult> ExecScriptAsync(string scriptContent, CancellationToken cancellationToken = default)
+    /// <summary>
+    /// Executes the SQL script in the Db2 container.
+    /// </summary>
+    /// <param name="scriptContent">The content of the SQL script to execute.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>Task that completes when the SQL script has been executed.</returns>
+    public async Task<ExecResult> ExecScriptAsync(string scriptContent, CancellationToken ct = default)
     {
-        string[] command =
-        [
-            "su", "db2inst1", "-c", new StringBuilder()
-                .Append(Db2CommandPath).Append(" connect to ").Append(_configuration.Database)
-                .Append(" user ").Append(_configuration.Username).Append(" using ").Append(_configuration.Password)
-                .Append("; ")
-                .Append(Db2CommandPath).Append(' ').Append(scriptContent)
-                .ToString()
-        ];
-
-        return await ExecAsync(command).ConfigureAwait(false);
+        const string db2ShellCommandFormat = "su - {1} -c \"db2 connect to {0} && db2 -tvf '{2}'\"";
+
+        var scriptFilePath = string.Join("/", string.Empty, "tmp", Guid.NewGuid().ToString("D"), Path.GetRandomFileName());
+
+        var db2ShellCommand = string.Format(db2ShellCommandFormat, _configuration.Database, _configuration.Username, scriptFilePath);
+
+        await CopyAsync(Encoding.Default.GetBytes(scriptContent), scriptFilePath, Unix.FileMode644, ct)
+            .ConfigureAwait(false);
+
+        return await ExecAsync(new [] { "/bin/sh", "-c", db2ShellCommand}, ct)
+            .ConfigureAwait(false);
     }
 }

src/Testcontainers.Db2/Usings.cs

@@ -1,4 +1,6 @@
 global using System;
+global using System.Collections.Generic;
+global using System.IO;
 global using System.Linq;
 global using System.Text;
 global using System.Threading;

tests/Testcontainers.Db2.Tests/Db2ContainerTest.cs

@@ -3,15 +3,7 @@ namespace Testcontainers.Db2;
 public sealed class Db2ContainerTest : IAsyncLifetime
 {
     // # --8<-- [start:UseDb2Container]
-    private readonly Db2Container _db2Container = new Db2Builder()
-      .WithEnvironment("TO_CREATE_SAMPLEDB", "false")
-      .WithEnvironment("PERSISTENT_HOME", "true")
-      .WithEnvironment("REPODB", "false")
-      .WithEnvironment("BLU", "false")
-      .WithEnvironment("HADR_ENABLED", "false")
-      .WithEnvironment("ARCHIVE_LOGS", "false")
-      .WithEnvironment("AUTOCONFIG", "false")
-      .Build();
+    private readonly Db2Container _db2Container = new Db2Builder().WithAcceptLicenseAgreement(true).Build();
 
     public Task InitializeAsync()
     {
@@ -25,20 +17,14 @@ public Task DisposeAsync()
 
     [Fact]
     [Trait(nameof(DockerCli.DockerPlatform), nameof(DockerCli.DockerPlatform.Linux))]
-    public async Task ReadFromDb2Database()
+    public void ConnectionStateReturnsOpen()
     {
         // Given
         using DbConnection connection = new DB2Connection(_db2Container.GetConnectionString());
 
         // When
         connection.Open();
 
-        using DbCommand command = connection.CreateCommand();
-        command.CommandText = "SELECT 1 FROM SYSIBM.SYSDUMMY1;";
-
-        var actual = await command.ExecuteScalarAsync() as int?;
-        Assert.Equal(1, actual.GetValueOrDefault());
-
         // Then
         Assert.Equal(ConnectionState.Open, connection.State);
     }
@@ -51,7 +37,8 @@ public async Task ExecScriptReturnsSuccessful()
         const string scriptContent = "SELECT 1 FROM SYSIBM.SYSDUMMY1;";
 
         // When
-        var execResult = await _db2Container.ExecScriptAsync(scriptContent);
+        var execResult = await _db2Container.ExecScriptAsync(scriptContent)
+            .ConfigureAwait(true);
 
         // Then
         Assert.True(0L.Equals(execResult.ExitCode), execResult.Stderr);