Testcontainer for CosmosDB Emulator

Packages.props

@@ -27,6 +27,7 @@
     <PackageReference Update="Azure.Data.Tables" Version="12.6.1" />
     <PackageReference Update="Azure.Storage.Blobs" Version="12.13.0" />
     <PackageReference Update="Azure.Storage.Queues" Version="12.11.0" />
+    <PackageReference Update="Microsoft.Azure.Cosmos" Version="3.30.0" />
     <PackageReference Update="Confluent.Kafka" Version="1.8.2" />
     <PackageReference Update="CouchbaseNetClient" Version="3.2.9" />
     <PackageReference Update="Elastic.Clients.Elasticsearch" Version="8.0.0-beta.3" />

src/Testcontainers/Builders/TestcontainersBuilderCosmosDbExtension.cs

@@ -0,0 +1,29 @@
+namespace DotNet.Testcontainers.Builders
+{
+  using System.Linq;
+  using DotNet.Testcontainers.Configurations;
+  using DotNet.Testcontainers.Containers;
+  using JetBrains.Annotations;
+
+  [PublicAPI]
+  public static class TestcontainersBuilderCosmosDbExtension
+  {
+    public static ITestcontainersBuilder<CosmosDbTestcontainer> WithCosmosDb(
+      this ITestcontainersBuilder<CosmosDbTestcontainer> builder, CosmosDbTestcontainerConfiguration configuration)
+    {
+      builder = configuration.Environments.Aggregate(builder, (current, environment)
+        => current.WithEnvironment(environment.Key, environment.Value));
+
+      return builder.WithImage(configuration.Image)
+        .WithPortBinding(configuration.DefaultPort, true)
+        .WithExposedPort(configuration.DefaultPort)
+        .WithWaitStrategy(configuration.WaitStrategy)
+        .WithOutputConsumer(configuration.OutputConsumer)
+        .ConfigureContainer(testcontainer =>
+        {
+          testcontainer.ContainerPort = configuration.DefaultPort;
+          testcontainer.Password = configuration.Password;
+        });
+    }
+  }
+}

src/Testcontainers/Configurations/Modules/Databases/CosmosDbTestcontainerConfiguration.cs

@@ -0,0 +1,66 @@
+namespace DotNet.Testcontainers.Configurations
+{
+  using System;
+  using System.Globalization;
+  using System.IO;
+  using DotNet.Testcontainers.Builders;
+  using JetBrains.Annotations;
+
+  [PublicAPI]
+  public class CosmosDbTestcontainerConfiguration : TestcontainerDatabaseConfiguration
+  {
+    public const string DefaultCosmosDbApiImage =
+      "mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator";
+
+    private const int DefaultCosmosPort = 8081;
+
+    public CosmosDbTestcontainerConfiguration()
+      : this(DefaultCosmosDbApiImage)
+    {
+      this.OutputConsumer = Consume.RedirectStdoutAndStderrToStream(new MemoryStream(), new MemoryStream());
+    }
+
+    public CosmosDbTestcontainerConfiguration(string image)
+      : base(image, DefaultCosmosPort)
+    {
+      this.PartitionCount = 1;
+      this.IpAddressOverride = "127.0.0.1";
+    }
+
+    public override IOutputConsumer OutputConsumer { get; }
+
+    public override IWaitForContainerOS WaitStrategy => Wait.ForUnixContainer().UntilMessageIsLogged(this.OutputConsumer.Stdout, "Started|Shutting");
+
+    public override string Password
+    {
+      // Default key for the emulator
+      // See: https://docs.microsoft.com/en-us/azure/cosmos-db/local-emulator?tabs=ssl-netstd21#authenticate-requests
+      get => "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==";
+      set => throw new NotImplementedException();
+    }
+
+    public override string Database
+    {
+      get => this.Environments["AZURE_COSMOS_EMULATOR_DATABASE"];
+      set => this.Environments["AZURE_COSMOS_EMULATOR_DATABASE"] = value;
+    }
+
+    public int PartitionCount
+    {
+      get => int.Parse(this.Environments["AZURE_COSMOS_EMULATOR_PARTITION_COUNT"], CultureInfo.InvariantCulture);
+      set => this.Environments["AZURE_COSMOS_EMULATOR_PARTITION_COUNT"] = value.ToString(CultureInfo.InvariantCulture);
+    }
+
+    public bool EnableDataPersistence
+    {
+      get => this.Environments["AZURE_COSMOS_EMULATOR_ENABLE_DATA_PERSISTENCE"] == "true";
+      set => this.Environments["AZURE_COSMOS_EMULATOR_ENABLE_DATA_PERSISTENCE"] = value.ToString().ToLower(CultureInfo.InvariantCulture);
+    }
+
+    public string IpAddressOverride
+    {
+      get => this.Environments["AZURE_COSMOS_EMULATOR_IP_ADDRESS_OVERRIDE"];
+      set => this.Environments["AZURE_COSMOS_EMULATOR_IP_ADDRESS_OVERRIDE"] = value;
+    }
+  }
+}

src/Testcontainers/Containers/Modules/Databases/CosmosDbTestcontainer.cs

@@ -0,0 +1,53 @@
+namespace DotNet.Testcontainers.Containers
+{
+  using System;
+  using System.Linq;
+  using System.Net;
+  using System.Net.Http;
+  using System.Net.Sockets;
+  using System.Threading;
+  using System.Threading.Tasks;
+  using DotNet.Testcontainers.Configurations;
+  using Microsoft.Extensions.Logging;
+
+  public sealed class CosmosDbTestcontainer : TestcontainerDatabase
+  {
+    internal CosmosDbTestcontainer(ITestcontainersConfiguration configuration, ILogger logger)
+      : base(configuration, logger)
+    {
+    }
+
+    public HttpMessageHandler HttpMessageHandler => new UrlRewriter(this.Hostname, this.Port, new HttpClientHandler { ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true, });
+
+    public HttpClient HttpClient
+    {
+      get
+      {
+        return new HttpClient(this.HttpMessageHandler);
+      }
+    }
+
+    public override string ConnectionString =>
+      $"AccountEndpoint=https://{this.Hostname}:{this.Port};AccountKey={this.Password}";
+
+    private class UrlRewriter : DelegatingHandler
+    {
+      private readonly string host;
+      private readonly int portNumber;
+
+      internal UrlRewriter(string host, int portNumber, HttpMessageHandler innerHandler)
+        : base(innerHandler)
+      {
+        this.host = host;
+        this.portNumber = portNumber;
+      }
+
+      protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+      {
+        request.RequestUri = new Uri($"https://{this.host}:{this.portNumber}{request.RequestUri?.PathAndQuery}");
+        var response = await base.SendAsync(request, cancellationToken);
+        return response;
+      }
+    }
+  }
+}

tests/Testcontainers.Tests/Fixtures/Containers/Unix/Modules/Databases/CosmosDbFixture.cs

@@ -0,0 +1,58 @@
+namespace DotNet.Testcontainers.Tests.Fixtures
+{
+  using System;
+  using System.Data.Common;
+  using System.IO;
+  using System.Threading;
+  using System.Threading.Tasks;
+  using DotNet.Testcontainers.Builders;
+  using DotNet.Testcontainers.Configurations;
+  using DotNet.Testcontainers.Containers;
+
+  public class CosmosDbFixture : DatabaseFixture<CosmosDbTestcontainer, DbConnection>
+  {
+    public CosmosDbFixture()
+      : this(new CosmosDbTestcontainerConfiguration())
+    {
+    }
+
+    private CosmosDbFixture(CosmosDbTestcontainerConfiguration configuration)
+    {
+      this.Configuration = configuration;
+      this.Container = new TestcontainersBuilder<CosmosDbTestcontainer>()
+        .WithCosmosDb(configuration)
+        .Build();
+    }
+
+    public CosmosDbTestcontainerConfiguration Configuration { get; set; }
+
+    public override async Task InitializeAsync()
+    {
+      // workaround for broken cosmosdb emulator
+      var maxWait = TimeSpan.FromSeconds(5 * 1000);
+      var cancellationTokenSource = new CancellationTokenSource();
+      var containerTask = this.Container.StartAsync(cancellationTokenSource.Token);
+      var task = await Task.WhenAny(new[] { containerTask, Task.Delay(maxWait) });
+      if (task != containerTask)
+      {
+        cancellationTokenSource.Cancel();
+      }
+    }
+
+    public override async Task DisposeAsync()
+    {
+      if (this.Connection != null && this.Connection.State != System.Data.ConnectionState.Closed)
+      {
+        this.Connection.Dispose();
+      }
+
+      await this.Container.DisposeAsync()
+        .ConfigureAwait(false);
+    }
+
+    public override void Dispose()
+    {
+      this.Configuration.Dispose();
+    }
+  }
+}

tests/Testcontainers.Tests/Testcontainers.Tests.csproj

@@ -24,6 +24,7 @@
     <PackageReference Include="Azure.Data.Tables" />
     <PackageReference Include="Azure.Storage.Blobs" />
     <PackageReference Include="Azure.Storage.Queues" />
+    <PackageReference Include="Microsoft.Azure.Cosmos" />
     <PackageReference Include="Confluent.Kafka" />
     <PackageReference Include="CouchbaseNetClient" />
     <PackageReference Include="Elastic.Clients.Elasticsearch" />

tests/Testcontainers.Tests/Unit/Containers/Unix/Modules/Databases/CosmosDbTestcontainerTest.cs

@@ -0,0 +1,42 @@
+namespace DotNet.Testcontainers.Tests.Unit
+{
+  using System.Net;
+  using System.Threading.Tasks;
+  using DotNet.Testcontainers.Tests.Fixtures;
+  using Microsoft.Azure.Cosmos;
+  using Xunit;
+
+  public static class CosmosDbTestcontainerTest
+  {
+    [Collection(nameof(Testcontainers))]
+    public sealed class ConnectionTests : IClassFixture<CosmosDbFixture>
+    {
+      private readonly CosmosDbFixture fixture;
+
+      public ConnectionTests(CosmosDbFixture fixture)
+      {
+        this.fixture = fixture;
+      }
+
+      private CosmosClientOptions Options => new CosmosClientOptions { HttpClientFactory = () => this.fixture.Container.HttpClient, ConnectionMode = ConnectionMode.Gateway, };
+
+      [Fact(Skip = "Waiting for a working cosmosdb emulator")]
+      public async Task ShouldEstablishConnection()
+      {
+        var client = new CosmosClient(this.fixture.Container.ConnectionString, this.Options);
+
+        var accountProperties = await client.ReadAccountAsync();
+        Assert.Equal("localhost", accountProperties.Id);
+      }
+
+      [Fact(Skip = "Waiting for a working cosmosdb emulator")]
+      public async Task CreateDatabaseTest()
+      {
+        var client = new CosmosClient(this.fixture.Container.ConnectionString, this.Options);
+
+        var db = await client.CreateDatabaseIfNotExistsAsync("test-db");
+        Assert.Equal(HttpStatusCode.Created, db.StatusCode);
+      }
+    }
+  }
+}