feat: add Cloud Map (service discovery) support (#61)

Adds CloudMapConfig (ServiceKey CLOUDMAP, OperationCompletionDelaySeconds
setting), FlociBuilder.WithCloudMap, unit tests, and an integration test
round-trip (CreateHttpNamespace -> CreateService -> RegisterInstance ->
ListInstances) via AmazonServiceDiscoveryClient.

Author: hughesjs

src/Testcontainers.Floci/CloudMapConfig.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.Globalization;
+using JetBrains.Annotations;
+
+namespace Testcontainers.Floci;
+
+/// <summary>
+/// Configuration for Floci's Cloud Map (service discovery) emulation.
+/// </summary>
+/// <remarks>
+/// Apply via <see cref="FlociBuilder.WithCloudMap(CloudMapConfig)" />:
+/// <code>
+/// await using var floci = new FlociBuilder()
+///     .WithCloudMap(new CloudMapConfig { OperationCompletionDelaySeconds = 0 })
+///     .Build();
+/// </code>
+/// </remarks>
+[PublicAPI]
+public sealed record CloudMapConfig : FlociServiceConfig
+{
+    /// <summary>
+    /// Gets the delay in seconds before asynchronous operations transition from
+    /// <c>PENDING</c> to <c>SUCCESS</c>. Defaults to <c>0</c> (immediate).
+    /// </summary>
+    public int OperationCompletionDelaySeconds { get; init; } = 0;
+
+    /// <inheritdoc />
+    protected override string ServiceKey => "CLOUDMAP";
+
+    /// <inheritdoc />
+    protected override void AddSettings(IDictionary<string, string> env, string prefix)
+    {
+        env[prefix + "OPERATION_COMPLETION_DELAY_SECONDS"] = OperationCompletionDelaySeconds.ToString(CultureInfo.InvariantCulture);
+    }
+}

src/Testcontainers.Floci/FlociBuilder.cs

@@ -165,6 +165,13 @@ public FlociBuilder WithAvailabilityZone(string availabilityZone)
     /// <returns>A configured instance of <see cref="FlociBuilder" />.</returns>
     public FlociBuilder WithCloudTrail(CloudTrailConfig config) => WithServiceConfig(config);
 
+    /// <summary>
+    /// Configures Floci's Cloud Map (service discovery) emulation.
+    /// </summary>
+    /// <param name="config">The Cloud Map configuration.</param>
+    /// <returns>A configured instance of <see cref="FlociBuilder" />.</returns>
+    public FlociBuilder WithCloudMap(CloudMapConfig config) => WithServiceConfig(config);
+
     /// <summary>
     /// Configures Floci's Athena emulation.
     /// </summary>

tests/Testcontainers.Floci.IntegrationTests/CloudMapServiceTest.cs

@@ -0,0 +1,168 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Amazon.ServiceDiscovery;
+using Amazon.ServiceDiscovery.Model;
+using Testcontainers.Floci;
+using Xunit;
+
+namespace Testcontainers.Floci.Tests;
+
+public sealed class CloudMapServiceTest : IAsyncLifetime
+{
+    private readonly FlociContainer _floci = new FlociBuilder(TestImages.Floci)
+        .WithCloudMap(new CloudMapConfig())
+        .Build();
+
+    public Task InitializeAsync() => _floci.StartAsync();
+
+    public Task DisposeAsync() => _floci.DisposeAsync().AsTask();
+
+    private AmazonServiceDiscoveryClient CreateClient()
+    {
+        return new AmazonServiceDiscoveryClient(
+            _floci.AccessKey,
+            _floci.SecretKey,
+            new AmazonServiceDiscoveryConfig
+            {
+                ServiceURL = _floci.GetEndpoint(),
+                AuthenticationRegion = _floci.Region,
+            });
+    }
+
+    [Fact]
+    public async Task RegistersAndDiscoversInstance()
+    {
+        using var sd = CreateClient();
+
+        const string namespaceName = "test-namespace";
+        const string serviceName = "test-service";
+        const string instanceId = "inst-1";
+
+        string? namespaceId = null;
+        string? serviceId = null;
+
+        try
+        {
+            // Create an HTTP namespace — returns an OperationId because it's async.
+            var createNsResponse = await sd.CreateHttpNamespaceAsync(new CreateHttpNamespaceRequest
+            {
+                Name = namespaceName,
+            });
+
+            var namespaceOperationId = createNsResponse.OperationId;
+
+            // Poll until SUCCESS. With OperationCompletionDelaySeconds=0 this is immediate, but
+            // we loop a few times with a short back-off to handle any in-flight processing.
+            namespaceId = await PollOperationToSuccessAsync(sd, namespaceOperationId, "NAMESPACE");
+
+            // Create a service within the namespace.
+            var createSvcResponse = await sd.CreateServiceAsync(new CreateServiceRequest
+            {
+                Name = serviceName,
+                NamespaceId = namespaceId,
+            });
+
+            serviceId = createSvcResponse.Service.Id;
+
+            // Register an instance.
+            var registerResponse = await sd.RegisterInstanceAsync(new RegisterInstanceRequest
+            {
+                ServiceId = serviceId,
+                InstanceId = instanceId,
+                Attributes = new Dictionary<string, string>
+                {
+                    ["AWS_INSTANCE_IPV4"] = "10.0.0.1",
+                },
+            });
+
+            await PollOperationToSuccessAsync(sd, registerResponse.OperationId, target: null);
+
+            // List instances via the control-plane API and assert the registered one is present.
+            // (DiscoverInstancesAsync targets a separate data-plane endpoint that isn't reachable
+            // from the emulator's single ServiceURL; ListInstancesAsync uses the same endpoint.)
+            var listResponse = await sd.ListInstancesAsync(new ListInstancesRequest
+            {
+                ServiceId = serviceId,
+            });
+
+            Assert.Contains(listResponse.Instances, i => i.Id == instanceId);
+        }
+        finally
+        {
+            // Best-effort teardown — ignore failures so the test can report its own result.
+            try
+            {
+                if (serviceId != null)
+                {
+                    var deregResponse = await sd.DeregisterInstanceAsync(new DeregisterInstanceRequest
+                    {
+                        ServiceId = serviceId,
+                        InstanceId = instanceId,
+                    });
+                    await PollOperationToSuccessAsync(sd, deregResponse.OperationId, target: null);
+                }
+            }
+            catch { /* best-effort */ }
+
+            try
+            {
+                if (serviceId != null)
+                {
+                    await sd.DeleteServiceAsync(new DeleteServiceRequest { Id = serviceId });
+                }
+            }
+            catch { /* best-effort */ }
+
+            try
+            {
+                if (namespaceId != null)
+                {
+                    await sd.DeleteNamespaceAsync(new DeleteNamespaceRequest { Id = namespaceId });
+                }
+            }
+            catch { /* best-effort */ }
+        }
+    }
+
+    /// <summary>
+    /// Polls <see cref="AmazonServiceDiscoveryClient.GetOperationAsync" /> until the operation
+    /// reaches <see cref="OperationStatus.SUCCESS" /> and returns the value of
+    /// <paramref name="target" /> from <c>Operation.Targets</c> (or <see langword="null" /> when
+    /// no target value is needed).
+    /// </summary>
+    private static async Task<string?> PollOperationToSuccessAsync(
+        AmazonServiceDiscoveryClient client,
+        string operationId,
+        string? target)
+    {
+        for (var attempt = 0; attempt < 20; attempt++)
+        {
+            var response = await client.GetOperationAsync(new GetOperationRequest
+            {
+                OperationId = operationId,
+            });
+
+            if (response.Operation.Status == OperationStatus.SUCCESS)
+            {
+                if (target == null)
+                {
+                    return null;
+                }
+
+                response.Operation.Targets.TryGetValue(target, out var value);
+                return value;
+            }
+
+            if (response.Operation.Status == OperationStatus.FAIL)
+            {
+                throw new InvalidOperationException(
+                    $"Cloud Map operation {operationId} failed: {response.Operation.ErrorMessage}");
+            }
+
+            await Task.Delay(TimeSpan.FromMilliseconds(500));
+        }
+
+        throw new TimeoutException($"Cloud Map operation {operationId} did not reach SUCCESS within the polling limit.");
+    }
+}

tests/Testcontainers.Floci.IntegrationTests/Testcontainers.Floci.IntegrationTests.csproj

@@ -55,6 +55,7 @@
     <PackageReference Include="AWSSDK.S3" Version="4.0.24.3" />
     <PackageReference Include="AWSSDK.Scheduler" Version="4.0.3.5" />
     <PackageReference Include="AWSSDK.SecretsManager" Version="4.0.5.3" />
+    <PackageReference Include="AWSSDK.ServiceDiscovery" Version="4.0.3.6" />
     <PackageReference Include="AWSSDK.SimpleEmail" Version="4.0.3.3" />
     <PackageReference Include="AWSSDK.SimpleEmailV2" Version="4.0.14.4" />
     <PackageReference Include="AWSSDK.SimpleNotificationService" Version="4.0.3.3" />

tests/Testcontainers.Floci.Tests/CloudMapConfigTest.cs

@@ -0,0 +1,46 @@
+using Testcontainers.Floci;
+using Xunit;
+
+namespace Testcontainers.Floci.Tests;
+
+public sealed class CloudMapConfigTest
+{
+    [Fact]
+    public void DefaultsMatchUpstream()
+    {
+        var config = new CloudMapConfig();
+
+        Assert.True(config.Enabled);
+        Assert.Equal(0, config.OperationCompletionDelaySeconds);
+    }
+
+    [Fact]
+    public void DefaultConfigEmitsUpstreamDefaultEnvVars()
+    {
+        var env = new CloudMapConfig().BuildEnvironment();
+
+        Assert.Equal("true", env["FLOCI_SERVICES_CLOUDMAP_ENABLED"]);
+        Assert.Equal("0", env["FLOCI_SERVICES_CLOUDMAP_OPERATION_COMPLETION_DELAY_SECONDS"]);
+    }
+
+    [Fact]
+    public void CustomConfigEmitsCustomEnvVars()
+    {
+        var env = new CloudMapConfig
+        {
+            OperationCompletionDelaySeconds = 5,
+        }.BuildEnvironment();
+
+        Assert.Equal("true", env["FLOCI_SERVICES_CLOUDMAP_ENABLED"]);
+        Assert.Equal("5", env["FLOCI_SERVICES_CLOUDMAP_OPERATION_COMPLETION_DELAY_SECONDS"]);
+    }
+
+    [Fact]
+    public void DisabledConfigEmitsOnlyTheEnabledFlag()
+    {
+        var env = new CloudMapConfig { Enabled = false }.BuildEnvironment();
+
+        Assert.Equal("false", env["FLOCI_SERVICES_CLOUDMAP_ENABLED"]);
+        Assert.DoesNotContain("FLOCI_SERVICES_CLOUDMAP_OPERATION_COMPLETION_DELAY_SECONDS", env.Keys);
+    }
+}