fix(Elasticsearch): Use HTTP wait strategy

src/Testcontainers.Elasticsearch/ElasticsearchBuilder.cs

@@ -1,4 +1,4 @@
-namespace Testcontainers.Elasticsearch;
+namespace Testcontainers.Elasticsearch;
 
 /// <inheritdoc cref="ContainerBuilder{TBuilderEntity, TContainerEntity, TConfigurationEntity}" />
 [PublicAPI]
@@ -121,15 +121,51 @@ private ElasticsearchBuilder WithUsername(string username)
     /// <inheritdoc cref="IWaitUntil" />
     private sealed class WaitUntil : IWaitUntil
     {
-        private static readonly IEnumerable<string> Pattern = new[] { "\"message\":\"started", "\"message\": \"started\"" };
-
         /// <inheritdoc />
         public async Task<bool> UntilAsync(IContainer container)
         {
-            var (stdout, _) = await container.GetLogsAsync(since: container.StoppedTime, timestampsEnabled: false)
+            if (container is not ElasticsearchContainer elasticContainer) return false;
+            var containerCredentials = elasticContainer.GetCredentials();
+            var username = containerCredentials.UserName ?? DefaultUsername;
+            var password = containerCredentials.Password ?? DefaultPassword;
+            var base64Credentials = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}"));
+
+            using var httpMessageHandler = new HttpClientHandler();
+            httpMessageHandler.ServerCertificateCustomValidationCallback = (_, _, _, _) => true; // intentionally trusting the self‑signed test certificate
+
+            var httpWaitStrategy = new HttpWaitStrategy()
+                .UsingHttpMessageHandler(httpMessageHandler)
+                .UsingTls(elasticContainer.HttpsEnabled)
+                .ForPath("/_cluster/health")
+                .ForPort(ElasticsearchHttpsPort)
+                .ForStatusCode(HttpStatusCode.OK)
+                .WithHeader("Authorization", "Basic " + base64Credentials)
+                .ForResponseMessageMatching(async m =>
+                {
+                    var content = await m.Content.ReadAsStringAsync().ConfigureAwait(false);
+                    try
+                    {
+                        var response = JsonSerializer.Deserialize<ElasticHealthResponse>(content) ?? new ElasticHealthResponse();
+                        return string.Equals(ElasticHealthResponse.YellowStatus, response.Status, StringComparison.OrdinalIgnoreCase) ||
+                            string.Equals(ElasticHealthResponse.GreenStatus, response.Status, StringComparison.OrdinalIgnoreCase);
+                    }
+                    catch (JsonException)
+                    {
+                        return false;
+                    }
+                });
+
+            return await httpWaitStrategy.UntilAsync(container)
                 .ConfigureAwait(false);
+        }
+
+        private class ElasticHealthResponse
+        {
+            public const string YellowStatus = "yellow";
+            public const string GreenStatus = "green";
 
-            return Pattern.Any(stdout.Contains);
+            [JsonPropertyName("status")]
+            public string Status { get; set; } = "unknown";
         }
     }
 }

src/Testcontainers.Elasticsearch/ElasticsearchConfiguration.cs

@@ -68,4 +68,27 @@ public ElasticsearchConfiguration(ElasticsearchConfiguration oldValue, Elasticse
     /// Gets the Elasticsearch password.
     /// </summary>
     public string Password { get; }
+
+    /// <summary>
+    /// Returns <c>true</c> if https connection to container is enabled, based on configuration environment variables.
+    /// </summary>
+    public bool HttpsEnabled
+    {
+        get
+        {
+            var hasSecurityEnabled = Environments
+                .TryGetValue("xpack.security.enabled", out var securityEnabled);
+
+            var hasHttpSslEnabled = Environments
+                .TryGetValue("xpack.security.http.ssl.enabled", out var httpSslEnabled);
+
+            var httpsDisabled =
+                hasSecurityEnabled &&
+                hasHttpSslEnabled &&
+                "false".Equals(securityEnabled, StringComparison.OrdinalIgnoreCase) &&
+                "false".Equals(httpSslEnabled, StringComparison.OrdinalIgnoreCase);
+
+            return !httpsDisabled;
+        }
+    }
 }

src/Testcontainers.Elasticsearch/ElasticsearchContainer.cs

@@ -16,6 +16,17 @@ public ElasticsearchContainer(ElasticsearchConfiguration configuration)
         _configuration = configuration;
     }
 
+    /// <summary>
+    /// Returns <c>true</c> if https connection to container is enabled.
+    /// </summary>
+    public bool HttpsEnabled => _configuration.HttpsEnabled;
+
+    /// <summary>
+    /// Gets the Elasticsearch credentials.
+    /// </summary>
+    /// <returns>The Elasticsearch credentials.</returns>
+    public NetworkCredential GetCredentials() => new(_configuration.Username, _configuration.Password);
+
     /// <summary>
     /// Gets the Elasticsearch connection string.
     /// </summary>
@@ -28,19 +39,7 @@ public ElasticsearchContainer(ElasticsearchConfiguration configuration)
     /// <returns>The Elasticsearch connection string.</returns>
     public string GetConnectionString()
     {
-        var hasSecurityEnabled = _configuration.Environments
-            .TryGetValue("xpack.security.enabled", out var securityEnabled);
-
-        var hasHttpSslEnabled = _configuration.Environments
-            .TryGetValue("xpack.security.http.ssl.enabled", out var httpSslEnabled);
-
-        var httpsDisabled =
-            hasSecurityEnabled &&
-            hasHttpSslEnabled &&
-            "false".Equals(securityEnabled, StringComparison.OrdinalIgnoreCase) &&
-            "false".Equals(httpSslEnabled, StringComparison.OrdinalIgnoreCase);
-
-        var scheme = httpsDisabled ? Uri.UriSchemeHttp : Uri.UriSchemeHttps;
+        var scheme = _configuration.HttpsEnabled ? Uri.UriSchemeHttps : Uri.UriSchemeHttp;
 
         var endpoint = new UriBuilder(scheme, Hostname, GetMappedPublicPort(ElasticsearchBuilder.ElasticsearchHttpsPort));
         endpoint.UserName = _configuration.Username;

src/Testcontainers.Elasticsearch/Usings.cs

@@ -1,7 +1,11 @@
 global using System;
 global using System.Collections.Generic;
 global using System.Linq;
+global using System.Net;
+global using System.Net.Http;
 global using System.Text;
+global using System.Text.Json;
+global using System.Text.Json.Serialization;
 global using System.Threading.Tasks;
 global using Docker.DotNet.Models;
 global using DotNet.Testcontainers;

tests/Testcontainers.Elasticsearch.Tests/ElasticsearchContainerTest.cs

@@ -1,9 +1,14 @@
 namespace Testcontainers.Elasticsearch;
 
-public sealed class ElasticsearchContainerTest : IAsyncLifetime
+public abstract class ElasticsearchContainerTest : IAsyncLifetime
 {
     // # --8<-- [start:UseElasticsearchContainer]
-    private readonly ElasticsearchContainer _elasticsearchContainer = new ElasticsearchBuilder().Build();
+    private readonly ElasticsearchContainer _elasticsearchContainer;
+
+    protected ElasticsearchContainerTest(ElasticsearchContainer container)
+    {
+        _elasticsearchContainer = container;
+    }
 
     public async ValueTask InitializeAsync()
     {
@@ -33,4 +38,18 @@ public void PingReturnsValidResponse()
         Assert.True(response.IsValidResponse);
     }
     // # --8<-- [end:UseElasticsearchContainer]
+
+    public sealed class DefaultConfiguration : ElasticsearchContainerTest
+    {
+        public DefaultConfiguration() : base(new ElasticsearchBuilder().Build())
+        {
+        }
+    }
+
+    public sealed class CustomCredentialsConfiguration : ElasticsearchContainerTest
+    {
+        public CustomCredentialsConfiguration() : base(new ElasticsearchBuilder().WithPassword("CustomCredentialsConfiguration").Build())
+        {
+        }
+    }
 }