Add real domain tests, make getAddressResolverGroup() default method, lazy resolver init

- Added tests for real domains (google.com, example.com) with network
  availability check via assumeTrue
- Made getAddressResolverGroup() a default method returning null in the
  interface to avoid breaking downstream implementations
- Lazily obtain group resolver only in branches that need DNS resolution
- Added fail() to unknownHost test for proper assertion
- Documented resolver group lifecycle ownership in builder Javadoc

Agent-Logs-Url: https://github.com/doom369/async-http-client/sessions/ef98f786-3665-4a5f-9005-60ebdba761b1

Co-authored-by: doom369 <1536494+doom369@users.noreply.github.com>

Author: Copilot

client/src/main/java/org/asynchttpclient/AsyncHttpClientConfig.java

@@ -393,7 +393,9 @@ default boolean isHttp2CleartextEnabled() {
      * @return the {@link AddressResolverGroup} or {@code null} to use per-request resolvers
      */
     @Nullable
-    AddressResolverGroup<InetSocketAddress> getAddressResolverGroup();
+    default AddressResolverGroup<InetSocketAddress> getAddressResolverGroup() {
+        return null;
+    }
 
     boolean isUseNativeTransport();
 

client/src/main/java/org/asynchttpclient/DefaultAsyncHttpClientConfig.java

@@ -1531,6 +1531,11 @@ public Builder setEventLoopGroup(EventLoopGroup eventLoopGroup) {
          * <p>
          * When set, this resolver group is used instead of the per-request {@link io.netty.resolver.NameResolver}.
          * Pass {@code null} (the default) to use per-request resolvers (legacy behavior).
+         * <p>
+         * <b>Lifecycle:</b> The client takes ownership of the provided resolver group and will
+         * {@linkplain AddressResolverGroup#close() close} it when the client is shut down.
+         * Do not pass a shared resolver group that is used by other clients unless you manage
+         * its lifecycle independently.
          *
          * @param addressResolverGroup the resolver group, or {@code null} to use per-request resolvers
          * @return the same builder instance

client/src/main/java/org/asynchttpclient/netty/request/NettyRequestSender.java

@@ -35,6 +35,7 @@
 import io.netty.handler.codec.http2.Http2StreamChannel;
 import io.netty.handler.codec.http2.Http2StreamChannelBootstrap;
 import io.netty.resolver.AddressResolver;
+import io.netty.resolver.AddressResolverGroup;
 import io.netty.util.ReferenceCountUtil;
 import io.netty.util.Timer;
 import io.netty.util.concurrent.Future;
@@ -73,6 +74,7 @@
 import org.asynchttpclient.resolver.RequestHostnameResolver;
 import org.asynchttpclient.uri.Uri;
 import org.asynchttpclient.ws.WebSocketUpgradeHandler;
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -371,15 +373,11 @@ private <T> Future<List<InetSocketAddress>> resolveAddresses(Request request, Pr
         Uri uri = request.getUri();
         final Promise<List<InetSocketAddress>> promise = ImmediateEventExecutor.INSTANCE.newPromise();
 
-        // Use the client's AddressResolverGroup when configured for non-blocking async DNS.
-        AddressResolver<InetSocketAddress> groupResolver = channelManager.getAddressResolverGroup() != null
-                ? channelManager.getAddressResolverGroup().getResolver(channelManager.getEventLoopGroup().next())
-                : null;
-
         if (proxy != null && !proxy.isIgnoredForHost(uri.getHost()) && proxy.getProxyType().isHttp()) {
             int port = ProxyType.HTTPS.equals(proxy.getProxyType()) || uri.isSecured() ? proxy.getSecuredPort() : proxy.getPort();
             InetSocketAddress unresolvedRemoteAddress = InetSocketAddress.createUnresolved(proxy.getHost(), port);
             scheduleRequestTimeout(future, unresolvedRemoteAddress);
+            AddressResolver<InetSocketAddress> groupResolver = getGroupResolver();
             if (groupResolver != null) {
                 return RequestHostnameResolver.INSTANCE.resolve(groupResolver, unresolvedRemoteAddress, asyncHandler);
             }
@@ -394,14 +392,21 @@ private <T> Future<List<InetSocketAddress>> resolveAddresses(Request request, Pr
                 // bypass resolution
                 InetSocketAddress inetSocketAddress = new InetSocketAddress(request.getAddress(), port);
                 return promise.setSuccess(singletonList(inetSocketAddress));
-            } else if (groupResolver != null) {
+            }
+            AddressResolver<InetSocketAddress> groupResolver = getGroupResolver();
+            if (groupResolver != null) {
                 return RequestHostnameResolver.INSTANCE.resolve(groupResolver, unresolvedRemoteAddress, asyncHandler);
             } else {
                 return RequestHostnameResolver.INSTANCE.resolve(request.getNameResolver(), unresolvedRemoteAddress, asyncHandler);
             }
         }
     }
 
+    private @Nullable AddressResolver<InetSocketAddress> getGroupResolver() {
+        AddressResolverGroup<InetSocketAddress> group = channelManager.getAddressResolverGroup();
+        return group != null ? group.getResolver(channelManager.getEventLoopGroup().next()) : null;
+    }
+
     private <T> NettyResponseFuture<T> newNettyResponseFuture(Request request, AsyncHandler<T> asyncHandler, NettyRequest nettyRequest, ProxyServer proxyServer) {
         NettyResponseFuture<T> future = new NettyResponseFuture<>(
                 request,

client/src/test/java/org/asynchttpclient/AddressResolverGroupTest.java

@@ -25,21 +25,37 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 
+import java.net.InetSocketAddress;
+import java.net.Socket;
 import java.util.Arrays;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
 
 import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.asynchttpclient.Dsl.asyncHttpClient;
 import static org.asynchttpclient.Dsl.config;
 import static org.asynchttpclient.Dsl.get;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 public class AddressResolverGroupTest extends HttpTest {
 
     private HttpServer server;
 
+    private static boolean isExternalNetworkAvailable() {
+        try (Socket socket = new Socket()) {
+            socket.connect(new InetSocketAddress("www.google.com", 443), 3000);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
     @BeforeEach
     public void start() throws Throwable {
         server = new HttpServer();
@@ -117,12 +133,47 @@ public void unknownHostWithDnsResolverGroupFails() throws Throwable {
         withClient(config().setAddressResolverGroup(resolverGroup)).run(client -> {
             try {
                 client.prepareGet("http://nonexistent.invalid/foo").execute().get(10, SECONDS);
+                fail("Request to nonexistent host should have thrown an exception");
             } catch (ExecutionException e) {
-                // DNS failures may surface as UnknownHostException or as a Netty
-                // DnsErrorCauseException (since MiscUtils.getCause unwraps the chain).
-                // Either way, the request must fail, never silently succeed.
                 assertNotNull(e.getCause(), "Should have a cause for the DNS failure");
             }
         });
     }
+
+    @RepeatedIfExceptionsTest(repeats = 5)
+    public void resolveRealDomainWithDnsResolverGroup() throws Throwable {
+        assumeTrue(isExternalNetworkAvailable(), "External network not available - skipping test");
+
+        DnsAddressResolverGroup resolverGroup = new DnsAddressResolverGroup(
+                NioDatagramChannel.class,
+                DnsServerAddressStreamProviders.platformDefault());
+
+        try (AsyncHttpClient client = asyncHttpClient(config().setAddressResolverGroup(resolverGroup))) {
+            Response response = client.prepareGet("https://www.google.com/").execute().get(20, TimeUnit.SECONDS);
+            assertNotNull(response);
+            assertTrue(response.getStatusCode() >= 200 && response.getStatusCode() < 400,
+                    "Expected successful HTTP status but got " + response.getStatusCode());
+        }
+    }
+
+    @RepeatedIfExceptionsTest(repeats = 5)
+    public void resolveMultipleRealDomainsWithDnsResolverGroup() throws Throwable {
+        assumeTrue(isExternalNetworkAvailable(), "External network not available - skipping test");
+
+        DnsAddressResolverGroup resolverGroup = new DnsAddressResolverGroup(
+                NioDatagramChannel.class,
+                DnsServerAddressStreamProviders.platformDefault());
+
+        try (AsyncHttpClient client = asyncHttpClient(config().setAddressResolverGroup(resolverGroup))) {
+            Response response1 = client.prepareGet("https://www.google.com/").execute().get(20, TimeUnit.SECONDS);
+            assertNotNull(response1);
+            assertTrue(response1.getStatusCode() >= 200 && response1.getStatusCode() < 400,
+                    "Expected successful HTTP status for google.com but got " + response1.getStatusCode());
+
+            Response response2 = client.prepareGet("https://www.example.com/").execute().get(20, TimeUnit.SECONDS);
+            assertNotNull(response2);
+            assertTrue(response2.getStatusCode() >= 200 && response2.getStatusCode() < 400,
+                    "Expected successful HTTP status for example.com but got " + response2.getStatusCode());
+        }
+    }
 }