testcontainersGH-1261 [Enhancement]: Support Neo4j Enterprise

- Added small QoL method to support Neo4j enterprise
- Added validation to throw when enterprise is requested without the correct license agreement environment variable
- Added tests for enterprise & configuration changes
- Changed existing test to use IAsyncDisposable instead of sync-over-async disposal

Author: Sossenbinder

src/Testcontainers.Neo4j/Neo4jBuilder.cs

@@ -1,3 +1,6 @@
+using System.Linq;
+using DotNet.Testcontainers;
+
 namespace Testcontainers.Neo4j;
 
 /// <inheritdoc cref="ContainerBuilder{TBuilderEntity, TContainerEntity, TConfigurationEntity}" />
@@ -6,10 +9,16 @@ public sealed class Neo4jBuilder : ContainerBuilder<Neo4jBuilder, Neo4jContainer
 {
     public const string Neo4jImage = "neo4j:5.4";
 
+    public const string Neo4jEnterpriseImage = "neo4j:5.4-enterprise";
+
     public const ushort Neo4jHttpPort = 7474;
 
     public const ushort Neo4jBoltPort = 7687;
 
+    private const string AcceptLicenseAgreementEnvVar = "NEO4J_ACCEPT_LICENSE_AGREEMENT";
+
+    private const string AcceptLicenseAgreementEnvVarValue = "yes";
+
     /// <summary>
     /// Initializes a new instance of the <see cref="Neo4jBuilder" /> class.
     /// </summary>
@@ -39,6 +48,26 @@ public override Neo4jContainer Build()
         return new Neo4jContainer(DockerResourceConfiguration);
     }
 
+    /// <inheritdoc />
+    protected override void Validate()
+    {
+        base.Validate();
+
+        if (IsEnterpriseImage())
+        {
+            const string message = $"The 'enterprise' image requires setting environment variable {AcceptLicenseAgreementEnvVar} to= '{AcceptLicenseAgreementEnvVarValue}'";
+            _ = Guard.Argument(DockerResourceConfiguration, "Enterprise License agreement")
+                .ThrowIf(
+                    argument => !argument.Value.Environments.TryGetValue(AcceptLicenseAgreementEnvVar, out var licenseAgreementValue) || licenseAgreementValue != AcceptLicenseAgreementEnvVarValue,
+                    argument => new ArgumentException(message, argument.Name));
+        }
+    }
+
+    private bool IsEnterpriseImage()
+    {
+        return DockerResourceConfiguration.Image.Tag?.Contains("enterprise") ?? false;
+    }
+
     /// <inheritdoc />
     protected override Neo4jBuilder Init()
     {
@@ -68,4 +97,10 @@ protected override Neo4jBuilder Merge(Neo4jConfiguration oldValue, Neo4jConfigur
     {
         return new Neo4jBuilder(new Neo4jConfiguration(oldValue, newValue));
     }
+
+    public Neo4jBuilder WithEnterpriseEdition()
+    {
+        return WithImage(Neo4jEnterpriseImage)
+            .WithEnvironment(AcceptLicenseAgreementEnvVar, AcceptLicenseAgreementEnvVarValue);
+    }
 }

tests/Testcontainers.Neo4j.Tests/Neo4jBuilderConfigurationTest.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace Testcontainers.Neo4j;
+
+public sealed class Neo4jBuilderConfigurationTest
+{
+    [Fact]
+    public void CreatingEnterpriseContainerWithoutLicenseAgreementShouldThrow()
+    {
+        Assert.Throws<ArgumentException>(() => new Neo4jBuilder()
+            .WithImage(Neo4jBuilder.Neo4jEnterpriseImage)
+            .Build());
+    }
+}

tests/Testcontainers.Neo4j.Tests/Neo4jContainerTest.cs

@@ -1,9 +1,19 @@
+using System;
+using JetBrains.Annotations;
+
 namespace Testcontainers.Neo4j;
 
-public sealed class Neo4jContainerTest : IAsyncLifetime
+public abstract class Neo4jContainerTest : IAsyncLifetime
 {
+    private const string Neo4jDatabase = "neo4j";
+    
     // # --8<-- [start:UseNeo4jContainer]
-    private readonly Neo4jContainer _neo4jContainer = new Neo4jBuilder().Build();
+    private readonly Neo4jContainer _neo4jContainer;
+
+    private Neo4jContainerTest(Neo4jContainer neo4jContainer)
+    {
+        _neo4jContainer = neo4jContainer;
+    }
 
     public Task InitializeAsync()
     {
@@ -17,18 +27,53 @@ public Task DisposeAsync()
 
     [Fact]
     [Trait(nameof(DockerCli.DockerPlatform), nameof(DockerCli.DockerPlatform.Linux))]
-    public void SessionReturnsDatabase()
+    public async Task SessionReturnsDatabase()
     {
         // Given
-        const string database = "neo4j";
-
-        using var driver = GraphDatabase.Driver(_neo4jContainer.GetConnectionString());
+        await using var driver = GraphDatabase.Driver(_neo4jContainer.GetConnectionString());
 
         // When
-        using var session = driver.AsyncSession(sessionConfigBuilder => sessionConfigBuilder.WithDatabase(database));
+        await using var session = driver.AsyncSession(sessionConfigBuilder => sessionConfigBuilder.WithDatabase(Neo4jDatabase));
 
         // Then
-        Assert.Equal(database, session.SessionConfig.Database);
+        Assert.Equal(Neo4jDatabase, session.SessionConfig.Database);
     }
     // # --8<-- [end:UseNeo4jContainer]
+    
+    [UsedImplicitly]
+    public sealed class Neo4jDefaultConfiguration : Neo4jContainerTest
+    {
+        public Neo4jDefaultConfiguration()
+            : base(new Neo4jBuilder().Build())
+        {
+        }
+    }
+    
+    [UsedImplicitly]
+    public sealed class Neo4jEnterpriseConfiguration : Neo4jContainerTest
+    {
+        public Neo4jEnterpriseConfiguration()
+            : base(new Neo4jBuilder()
+                .WithEnterpriseEdition()
+                .Build())
+        {
+        }
+
+        [Fact]
+        [Trait(nameof(DockerCli.DockerPlatform), nameof(DockerCli.DockerPlatform.Linux))]
+        public async Task DatabaseShouldReturnEnterpriseEdition()
+        {
+            // Given
+            await using var driver = GraphDatabase.Driver(_neo4jContainer.GetConnectionString());
+
+            // When
+            await using var session = driver.AsyncSession(sessionConfigBuilder => sessionConfigBuilder.WithDatabase(Neo4jDatabase));
+            var result = await session.RunAsync("CALL dbms.components() YIELD edition RETURN edition");
+            var record = await result.SingleAsync();
+            var edition = record["edition"].As<string>();
+            
+            // Then
+            Assert.Equal("enterprise", edition);
+        }
+    }
 }