feat(Azurite): Add in-memory support

src/Testcontainers.Azurite/AzuriteBuilder.cs

@@ -4,7 +4,7 @@ namespace Testcontainers.Azurite;
 [PublicAPI]
 public sealed class AzuriteBuilder : ContainerBuilder<AzuriteBuilder, AzuriteContainer, AzuriteConfiguration>
 {
-    public const string AzuriteImage = "mcr.microsoft.com/azure-storage/azurite:3.24.0";
+    public const string AzuriteImage = "mcr.microsoft.com/azure-storage/azurite:3.28.0";
 
     public const ushort BlobPort = 10000;
 
@@ -40,13 +40,47 @@ private AzuriteBuilder(AzuriteConfiguration resourceConfiguration)
     /// <inheritdoc />
     protected override AzuriteConfiguration DockerResourceConfiguration { get; }
 
+    /// <summary>
+    /// Enables in-memory persistence.
+    /// </summary>
+    /// <param name="memoryLimit">An optional memory limit in megabytes.</param>
+    /// <returns>A configured instance of <see cref="AzuriteBuilder"/>.</returns>
+    public AzuriteBuilder WithInMemoryPersistence(int? memoryLimit = null)
+    {
+        var command = new List<string>
+        {
+            "azurite",
+            "--blobHost",
+            "0.0.0.0",
+            "--queueHost",
+            "0.0.0.0",
+            "--tableHost",
+            "0.0.0.0",
+            "--inMemoryPersistence"
+        };
+
+        if (memoryLimit.HasValue)
+        {
+            command.Add("--extentMemoryLimit");
+            command.Add(memoryLimit.ToString());
+        }
+
+        return Merge(DockerResourceConfiguration, new AzuriteConfiguration(inMemoryPersistence: true, extentMemoryLimit: memoryLimit))
+            .WithCommand(command.ToArray());
+    }
+
     /// <inheritdoc />
     public override AzuriteContainer Build()
     {
         Validate();
 
         var waitStrategy = Wait.ForUnixContainer();
 
+        if (DockerResourceConfiguration.InMemoryPersistence)
+        {
+            waitStrategy = waitStrategy.UntilMessageIsLogged("In-memory extent storage is enabled");
+        }
+
         if (_enabledServices.Contains(AzuriteService.Blob))
         {
             waitStrategy = waitStrategy.UntilMessageIsLogged("Blob service is successfully listening");

src/Testcontainers.Azurite/AzuriteConfiguration.cs

@@ -7,8 +7,12 @@ public sealed class AzuriteConfiguration : ContainerConfiguration
     /// <summary>
     /// Initializes a new instance of the <see cref="AzuriteConfiguration" /> class.
     /// </summary>
-    public AzuriteConfiguration()
+    /// <param name="inMemoryPersistence">Indicates whether in-memory persistence is enabled.</param>
+    /// <param name="extentMemoryLimit">Optional memory-limit when using in-memory persistence.</param>
+    public AzuriteConfiguration(bool inMemoryPersistence = false, int? extentMemoryLimit = null)
     {
+        InMemoryPersistence = inMemoryPersistence;
+        ExtentMemoryLimit = extentMemoryLimit;
     }
 
     /// <summary>
@@ -50,4 +54,14 @@ public AzuriteConfiguration(AzuriteConfiguration oldValue, AzuriteConfiguration
         : base(oldValue, newValue)
     {
     }
+
+    /// <summary>
+    /// Gets a value indicating whether in-memory persistence is enabled.
+    /// </summary>
+    public bool InMemoryPersistence { get; }
+
+    /// <summary>
+    /// Gets the memory limit to use when in-memory persistence is enabled.
+    /// </summary>
+    public int? ExtentMemoryLimit { get; }
 }

tests/Testcontainers.Azurite.Tests/AzuriteInMemoryContainerTest.cs

@@ -0,0 +1,80 @@
+namespace Testcontainers.Azurite;
+
+public abstract class AzuriteInMemoryContainerTest : IAsyncLifetime
+{
+    private readonly AzuriteContainer _azuriteContainer = new AzuriteBuilder()
+        .WithInMemoryPersistence()
+        .Build();
+
+    public Task InitializeAsync()
+    {
+        return _azuriteContainer.StartAsync();
+    }
+
+    public Task DisposeAsync()
+    {
+        return _azuriteContainer.DisposeAsync().AsTask();
+    }
+
+    private static bool HasError<TResponseEntity>(NullableResponse<TResponseEntity> response)
+    {
+        using (var rawResponse = response.GetRawResponse())
+        {
+            return rawResponse.IsError;
+        }
+    }
+
+    public sealed class BlobService : AzuriteInMemoryContainerTest
+    {
+        [Fact]
+        [Trait(nameof(DockerCli.DockerPlatform), nameof(DockerCli.DockerPlatform.Linux))]
+        public async Task EstablishesConnection()
+        {
+            // Give
+            var client = new BlobServiceClient(_azuriteContainer.GetConnectionString());
+
+            // When
+            var properties = await client.GetPropertiesAsync()
+                .ConfigureAwait(false);
+
+            // Then
+            Assert.False(HasError(properties));
+        }
+    }
+
+    public sealed class QueueService : AzuriteInMemoryContainerTest
+    {
+        [Fact]
+        [Trait(nameof(DockerCli.DockerPlatform), nameof(DockerCli.DockerPlatform.Linux))]
+        public async Task EstablishesConnection()
+        {
+            // Give
+            var client = new QueueServiceClient(_azuriteContainer.GetConnectionString());
+
+            // When
+            var properties = await client.GetPropertiesAsync()
+                .ConfigureAwait(false);
+
+            // Then
+            Assert.False(HasError(properties));
+        }
+    }
+
+    public sealed class TableService : AzuriteInMemoryContainerTest
+    {
+        [Fact]
+        [Trait(nameof(DockerCli.DockerPlatform), nameof(DockerCli.DockerPlatform.Linux))]
+        public async Task EstablishesConnection()
+        {
+            // Give
+            var client = new TableServiceClient(_azuriteContainer.GetConnectionString());
+
+            // When
+            var properties = await client.GetPropertiesAsync()
+                .ConfigureAwait(false);
+
+            // Then
+            Assert.False(HasError(properties));
+        }
+    }
+}