Fix: Make external LocalStack detection more lenient

Accept LocalStack instances that respond with HTTP 200 even if services
aren't fully initialized yet. This prevents port conflicts when multiple
tests try to start LocalStack simultaneously - they'll detect and reuse
the existing container instead of trying to create new ones.

The service readiness check is handled by WaitForServicesAsync with the
proper 90s timeout for CI environments.

Author: NinjaRocks

tests/SourceFlow.Cloud.AWS.Tests/TestHelpers/LocalStackManager.cs

@@ -523,50 +523,38 @@ private async Task<bool> IsExternalLocalStackAvailableAsync(string endpoint)
                     return false;
                 }
 
-                // Parse JSON response to verify services are "available"
+                // If we get HTTP 200, LocalStack is running - accept it even if services aren't fully ready yet
+                // We'll wait for services to become ready in WaitForServicesAsync
                 var content = await response.Content.ReadAsStringAsync();
-                var healthData = JsonSerializer.Deserialize<LocalStackHealthResponse>(content);
 
-                if (healthData?.Services == null || healthData.Services.Count == 0)
+                try
                 {
-                    _logger.LogDebug("External LocalStack health check returned no services (attempt {Attempt}/{MaxAttempts})", 
-                        attempt, maxAttempts);
+                    var healthData = JsonSerializer.Deserialize<LocalStackHealthResponse>(content);
 
-                    if (attempt < maxAttempts)
+                    if (healthData?.Services != null && healthData.Services.Count > 0)
                     {
-                        await Task.Delay(retryDelay);
-                        continue;
+                        var serviceStatus = healthData.Services
+                            .Select(s => $"{s.Key}:{s.Value}")
+                            .ToList();
+                        
+                        _logger.LogInformation("Successfully detected external LocalStack instance at {Endpoint} with {ServiceCount} services: {Services} (response time: {ResponseTime}ms)", 
+                            endpoint, healthData.Services.Count, string.Join(", ", serviceStatus), responseTime.TotalMilliseconds);
                     }
-                    return false;
-                }
-                
-                // Check if all services are available or running
-                var availableServices = healthData.Services
-                    .Where(s => s.Value == "available" || s.Value == "running")
-                    .Select(s => s.Key)
-                    .ToList();
-                
-                var unavailableServices = healthData.Services
-                    .Where(s => s.Value != "available" && s.Value != "running")
-                    .Select(s => $"{s.Key}:{s.Value}")
-                    .ToList();
-                
-                if (unavailableServices.Any())
-                {
-                    _logger.LogDebug("External LocalStack has unavailable services: {UnavailableServices} (attempt {Attempt}/{MaxAttempts}, response time: {ResponseTime}ms)", 
-                        string.Join(", ", unavailableServices), attempt, maxAttempts, responseTime.TotalMilliseconds);
-                    
-                    if (attempt < maxAttempts)
+                    else
                     {
-                        await Task.Delay(retryDelay);
-                        continue;
+                        _logger.LogInformation("Successfully detected external LocalStack instance at {Endpoint} (services still initializing, response time: {ResponseTime}ms)", 
+                            endpoint, responseTime.TotalMilliseconds);
                     }
-                    return false;
+                }
+                catch (JsonException)
+                {
+                    // JSON parsing failed, but we got HTTP 200, so LocalStack is running
+                    _logger.LogInformation("Successfully detected external LocalStack instance at {Endpoint} (health endpoint responded, response time: {ResponseTime}ms)", 
+                        endpoint, responseTime.TotalMilliseconds);
                 }
 
                 var totalTime = DateTime.UtcNow - startTime;
-                _logger.LogInformation("Successfully detected external LocalStack instance at {Endpoint} with {ServiceCount} available services: {Services} (total time: {TotalTime}ms, response time: {ResponseTime}ms)", 
-                    endpoint, availableServices.Count, string.Join(", ", availableServices), totalTime.TotalMilliseconds, responseTime.TotalMilliseconds);
+                _logger.LogDebug("External LocalStack detection succeeded after {TotalTime}ms", totalTime.TotalMilliseconds);
 
                 return true;
             }