add test case for xDS server and others

Author: AgraVator

api/src/main/java/io/grpc/ForwardingChannelBuilder2.java

@@ -95,7 +95,7 @@ public T intercept(ClientInterceptor... interceptors) {
   }
 
   @Override
-  protected T interceptWithTarget(InterceptorFactory factory) {
+  public T interceptWithTarget(InterceptorFactory factory) {
     delegate().interceptWithTarget(factory);
     return thisT();
   }
@@ -258,7 +258,7 @@ public T disableServiceConfigLookUp() {
   }
 
   @Override
-  protected T addMetricSink(MetricSink metricSink) {
+  public T addMetricSink(MetricSink metricSink) {
     delegate().addMetricSink(metricSink);
     return thisT();
   }

api/src/main/java/io/grpc/ManagedChannelBuilder.java

@@ -160,17 +160,14 @@ public T offloadExecutor(Executor executor) {
   public abstract T intercept(ClientInterceptor... interceptors);
 
   /**
-   * Internal-only: Adds a factory that will construct an interceptor based on the channel's target.
+   * Adds a factory that will construct an interceptor based on the channel's target.
    * This can be used to work around nameResolverFactory() changing the target string.
    */
-  @Internal
-  protected T interceptWithTarget(InterceptorFactory factory) {
+  public T interceptWithTarget(InterceptorFactory factory) {
     throw new UnsupportedOperationException();
   }
 
-  /** Internal-only. */
-  @Internal
-  protected interface InterceptorFactory {
+  public interface InterceptorFactory {
     ClientInterceptor newInterceptor(String target);
   }
 
@@ -638,8 +635,7 @@ public T disableServiceConfigLookUp() {
    * @return this
    * @since 1.64.0
    */
-  @Internal
-  protected T addMetricSink(MetricSink metricSink) {
+  public T addMetricSink(MetricSink metricSink) {
     throw new UnsupportedOperationException();
   }
 

api/src/test/java/io/grpc/ChildChannelConfigurersTest.java

@@ -55,4 +55,4 @@ public void compose_ignoresNulls() {
 
     verify(builder).userAgent("agent1");
   }
-}
+}

core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java

@@ -404,7 +404,7 @@ public ManagedChannelImplBuilder intercept(ClientInterceptor... interceptors) {
   }
 
   @Override
-  protected ManagedChannelImplBuilder interceptWithTarget(InterceptorFactory factory) {
+  public ManagedChannelImplBuilder interceptWithTarget(InterceptorFactory factory) {
     // Add a placeholder instance to the interceptor list, and replace it with a real instance
     // during build().
     this.interceptors.add(new InterceptorFactoryWrapper(factory));
@@ -713,7 +713,7 @@ public ManagedChannelImplBuilder enableCheckAuthority() {
   }
 
   @Override
-  protected ManagedChannelImplBuilder addMetricSink(MetricSink metricSink) {
+  public ManagedChannelImplBuilder addMetricSink(MetricSink metricSink) {
     metricSinks.add(checkNotNull(metricSink, "metric sink"));
     return this;
   }

core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java

@@ -26,6 +26,7 @@
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -34,6 +35,7 @@
 import com.google.common.util.concurrent.MoreExecutors;
 import io.grpc.CallOptions;
 import io.grpc.Channel;
+import io.grpc.ChildChannelConfigurer;
 import io.grpc.ClientCall;
 import io.grpc.ClientInterceptor;
 import io.grpc.CompressorRegistry;
@@ -70,6 +72,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -762,6 +765,72 @@ public void setNameResolverExtArgs() {
     assertThat(builder.nameResolverCustomArgs.get(testKey)).isEqualTo(42);
   }
 
+  @Test
+  public void childChannelConfigurer_propagatesMetricsAndInterceptors_xdsTarget() {
+    // Setup Mocks
+    when(mockClientTransportFactory.getScheduledExecutorService())
+        .thenReturn(clock.getScheduledExecutorService());
+    when(mockClientTransportFactoryBuilder.buildClientTransportFactory())
+        .thenReturn(mockClientTransportFactory);
+    when(mockClientTransportFactory.getSupportedSocketAddressTypes())
+        .thenReturn(Collections.singleton(InetSocketAddress.class));
+
+    MetricSink mockMetricSink = mock(MetricSink.class);
+    ClientInterceptor mockInterceptor = mock(ClientInterceptor.class);
+
+    // Define the Configurer
+    ChildChannelConfigurer configurer = (builder) -> {
+      builder.addMetricSink(mockMetricSink);
+
+      // Assuming InternalInterceptorFactory is also accessible
+      builder.interceptWithTarget(target -> mockInterceptor);
+    };
+
+    // Mock NameResolver.Factory to capture Args
+    NameResolver.Factory mockNameResolverFactory = mock(NameResolver.Factory.class);
+    when(mockNameResolverFactory.getDefaultScheme()).thenReturn("xds");
+    NameResolver mockNameResolver = mock(NameResolver.class);
+    when(mockNameResolver.getServiceAuthority()).thenReturn("foo.authority");
+    ArgumentCaptor<NameResolver.Args> argsCaptor = ArgumentCaptor.forClass(NameResolver.Args.class);
+    when(mockNameResolverFactory.newNameResolver(any(),
+        argsCaptor.capture())).thenReturn(mockNameResolver);
+
+    // Use the configurer and the mock factory
+    NameResolverRegistry registry = new NameResolverRegistry();
+    registry.register(new NameResolverFactoryToProviderFacade(mockNameResolverFactory));
+
+    ManagedChannelBuilder<?> parentBuilder = new ManagedChannelImplBuilder(
+        "xds:///my-service-target",
+        mockClientTransportFactoryBuilder,
+        new FixedPortProvider(DUMMY_PORT))
+        .childChannelConfigurer(configurer)
+        .nameResolverRegistry(registry);
+
+    ManagedChannel channel = parentBuilder.build();
+    grpcCleanupRule.register(channel);
+
+    // Verify that newNameResolver was called
+    verify(mockNameResolverFactory).newNameResolver(any(), any());
+
+    // Extract the parent channel from Args
+    NameResolver.Args args = argsCaptor.getValue();
+    ManagedChannel parentChannelInArgs = args.getParentChannel();
+    assertNotNull("Parent channel should be present in NameResolver.Args",
+        parentChannelInArgs);
+
+    // Verify the configurer on the parent channel is the one we passed
+    assertThat(parentChannelInArgs.getChildChannelConfigurer()).isSameInstanceAs(configurer);
+
+    // Verify the configurer logically applies (by running it on a mock)
+    ManagedChannelBuilder<?> mockChildBuilder = mock(ManagedChannelBuilder.class);
+    // Stub addMetricSink to return the builder to avoid generic return type issues
+    doReturn(mockChildBuilder).when(mockChildBuilder).addMetricSink(any());
+
+    configurer.accept(mockChildBuilder);
+    verify(mockChildBuilder).addMetricSink(mockMetricSink);
+    verify(mockChildBuilder).interceptWithTarget(any());
+  }
+
   @Test
   public void metricSinks() {
     MetricSink mocksink = mock(MetricSink.class);

xds/src/test/java/io/grpc/xds/GrpcXdsTransportFactoryTest.java

@@ -17,15 +17,25 @@
 package io.grpc.xds;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import com.google.common.util.concurrent.SettableFuture;
 import io.envoyproxy.envoy.service.discovery.v3.AggregatedDiscoveryServiceGrpc;
 import io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest;
 import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
 import io.grpc.BindableService;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ChildChannelConfigurer;
+import io.grpc.ClientInterceptor;
 import io.grpc.Grpc;
 import io.grpc.InsecureChannelCredentials;
 import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
 import io.grpc.MethodDescriptor;
 import io.grpc.Server;
 import io.grpc.Status;
@@ -139,5 +149,74 @@ public void onStatusReceived(Status status) {
       endFuture.set(status);
     }
   }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void verifyConfigApplied_interceptor() {
+    // Create a mock Interceptor
+    final ClientInterceptor mockInterceptor = mock(ClientInterceptor.class);
+    when(mockInterceptor.interceptCall(any(MethodDescriptor.class),
+        any(CallOptions.class), any(Channel.class)))
+        .thenReturn(new io.grpc.NoopClientCall<>());
+
+    // Create Configurer that adds the interceptor
+    ChildChannelConfigurer configurer = (builder) -> builder.intercept(mockInterceptor);
+
+    // Mock Parent Channel
+    ManagedChannel mockParentChannel = mock(ManagedChannel.class);
+    when(mockParentChannel.getChildChannelConfigurer()).thenReturn(configurer);
+
+    // Create Factory
+    GrpcXdsTransportFactory factory = new GrpcXdsTransportFactory(
+        null,
+        mockParentChannel,
+        null);
+
+    // Create Transport
+    XdsTransportFactory.XdsTransport transport = factory.create(
+        Bootstrapper.ServerInfo.create("localhost:8080", InsecureChannelCredentials.create()));
+
+    // Create a Call to trigger interceptors
+    MethodDescriptor<Void, Void> method = MethodDescriptor.<Void, Void>newBuilder()
+        .setType(MethodDescriptor.MethodType.UNARY)
+        .setFullMethodName("service/method")
+        .setFullMethodName("service/method")
+        .setRequestMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .setResponseMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .build();
+
+    transport.createStreamingCall(method.getFullMethodName(), method.getRequestMarshaller(),
+        method.getResponseMarshaller());
+
+    // Verify interceptor was invoked
+    verify(mockInterceptor).interceptCall(any(MethodDescriptor.class),
+        any(CallOptions.class), any(Channel.class));
+
+    transport.shutdown();
+  }
+
+  @Test
+  public void useParentServerConfig() {
+    // 1. Mock Server and Configurer
+    Server mockServer = mock(Server.class);
+    ChildChannelConfigurer mockConfigurer = mock(ChildChannelConfigurer.class);
+    when(mockServer.getChildChannelConfigurer()).thenReturn(mockConfigurer);
+
+    // 2. Create Factory with Parent Server
+    GrpcXdsTransportFactory factory = new GrpcXdsTransportFactory(
+        null, // CallCredentials
+        null, // Parent Channel
+        mockServer);
+
+    // 3. Create Transport (triggers channel creation)
+    XdsTransportFactory.XdsTransport transport = factory.create(
+        Bootstrapper.ServerInfo.create("localhost:8080", InsecureChannelCredentials.create()));
+
+    // 4. Verify Configurer was accessed and applied
+    verify(mockServer).getChildChannelConfigurer();
+    verify(mockConfigurer).accept(any(ManagedChannelBuilder.class));
+
+    transport.shutdown();
+  }
 }
 

xds/src/test/java/io/grpc/xds/XdsNameResolverTest.java

@@ -27,7 +27,9 @@
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.mock;
@@ -68,6 +70,7 @@
 import io.grpc.NameResolver.ServiceConfigParser;
 import io.grpc.NoopClientCall;
 import io.grpc.NoopClientCall.NoopClientCallListener;
+import io.grpc.ProxyDetector;
 import io.grpc.Server;
 import io.grpc.Status;
 import io.grpc.Status.Code;
@@ -2951,4 +2954,64 @@ void deliverErrorStatus() {
       listener.onClose(Status.UNAVAILABLE, new Metadata());
     }
   }
+
+  @Test
+  public void start_passesParentChannelToClientPoolFactory() {
+    // Create a mock Parent Channel
+    ManagedChannel mockParentChannel = mock(ManagedChannel.class);
+
+    // Build NameResolver.Args containing the parent channel
+    NameResolver.Args args = NameResolver.Args.newBuilder()
+        .setDefaultPort(8080)
+        .setProxyDetector(mock(ProxyDetector.class))
+        .setSynchronizationContext(syncContext)
+        .setServiceConfigParser(serviceConfigParser)
+        .setChannelLogger(mock(ChannelLogger.class))
+        .setParentChannel(mockParentChannel)
+        .build();
+
+    // Mock the XdsClientPoolFactory
+    XdsClientPoolFactory mockPoolFactory = mock(XdsClientPoolFactory.class);
+    @SuppressWarnings("unchecked")
+    ObjectPool<XdsClient> mockObjectPool = mock(ObjectPool.class);
+    XdsClient mockXdsClient = mock(XdsClient.class);
+    when(mockObjectPool.getObject()).thenReturn(mockXdsClient);
+    when(mockXdsClient.getBootstrapInfo()).thenReturn(bootstrapInfo);
+
+    when(mockPoolFactory.getOrCreate(
+        anyString(),
+        any(BootstrapInfo.class),
+        any(MetricRecorder.class),
+        any(ManagedChannel.class),
+        any()))
+        .thenReturn(mockObjectPool);
+
+    XdsNameResolver resolver = new XdsNameResolver(
+        URI.create(AUTHORITY),
+        null, // targetAuthority (nullable)
+        AUTHORITY, // name
+        null, // overrideAuthority (nullable)
+        serviceConfigParser,
+        syncContext,
+        scheduler,
+        mockPoolFactory,
+        mockRandom,
+        FilterRegistry.getDefaultRegistry(),
+        rawBootstrap,
+        metricRecorder,
+        args);
+
+    // Start the resolver (this triggers the factory call)
+    resolver.start(mockListener);
+
+    // Ensure the factory's getOrCreate method was called with parent channel
+    verify(mockPoolFactory).getOrCreate(
+        eq(AUTHORITY),
+        any(BootstrapInfo.class),
+        eq(metricRecorder),
+        eq(mockParentChannel),
+        isNull());
+
+    resolver.shutdown();
+  }
 }