xds: ring_hash requestHashHeader is not validated at config parse time; a -bin or invalid header name panics the channel #13151

/*
 * Copyright 2026 The gRPC Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.grpc.xds;

import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;

import com.google.common.collect.ImmutableList;
import io.grpc.CallOptions;
import io.grpc.EquivalentAddressGroup;
import io.grpc.ManagedChannel;
import io.grpc.NameResolver;
import io.grpc.NameResolver.ConfigOrError;
import io.grpc.NameResolverProvider;
import io.grpc.Status.Code;
import io.grpc.StatusOr;
import io.grpc.StatusRuntimeException;
import io.grpc.inprocess.InProcessChannelBuilder;
import io.grpc.inprocess.InProcessSocketAddress;
import io.grpc.internal.JsonParser;
import io.grpc.stub.ClientCalls;
import io.grpc.testing.TestMethodDescriptors;
import io.grpc.xds.RingHashLoadBalancer.RingHashConfig;
import java.io.IOException;
import java.net.SocketAddress;
import java.net.URI;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**
 * Tests that {@link RingHashLoadBalancerProvider} rejects an invalid requestHashHeader while
 * parsing the config, as required by gRFC A76.
 */
@RunWith(JUnit4.class)
public class RingHashRequestHashHeaderValidationTest {

  private static final String ENV_VAR_NAME =
      "GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY";

  private final RingHashLoadBalancerProvider provider = new RingHashLoadBalancerProvider();

  @Before
  public void setUp() {
    System.setProperty(ENV_VAR_NAME, "true");
  }

  @After
  public void tearDown() {
    System.clearProperty(ENV_VAR_NAME);
  }

  @Test
  public void requestHashHeader_binSuffixRejected() throws IOException {
    String lbConfig = "{\"requestHashHeader\": \"header-bin\"}";
    ConfigOrError configOrError =
        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
    assertThat(configOrError.getError()).isNotNull();
    assertThat(configOrError.getError().getCode()).isEqualTo(Code.UNAVAILABLE);
  }

  @Test
  public void requestHashHeader_invalidCharactersRejected() throws IOException {
    String lbConfig = "{\"requestHashHeader\": \"!invalid\"}";
    ConfigOrError configOrError =
        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
    assertThat(configOrError.getError()).isNotNull();
    assertThat(configOrError.getError().getCode()).isEqualTo(Code.UNAVAILABLE);
  }

  @Test
  public void requestHashHeader_mixedCaseAccepted() throws IOException {
    String lbConfig = "{\"requestHashHeader\": \"X-Foo\"}";
    ConfigOrError configOrError =
        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
    assertThat(configOrError.getError()).isNull();
    assertThat(((RingHashConfig) configOrError.getConfig()).requestHashHeader).isNotEmpty();
  }

  @Test
  public void invalidRequestHashHeaderFromResolver_doesNotPanicChannel() throws Exception {
    final Map<String, ?> serviceConfig = parseJsonObject(
        "{\"loadBalancingConfig\": [{\"ring_hash_experimental\": "
            + "{\"requestHashHeader\": \"header-bin\"}}]}");
    final String target = "fake:///ring-hash-test";
    NameResolverProvider resolverProvider = new NameResolverProvider() {
      @Override
      public NameResolver newNameResolver(URI targetUri, final NameResolver.Args args) {
        return new NameResolver() {
          @Override
          public String getServiceAuthority() {
            return "ring-hash-test";
          }

          @Override
          public void start(Listener2 listener) {
            listener.onResult(
                ResolutionResult.newBuilder()
                    .setAddressesOrError(StatusOr.fromValue(ImmutableList.of(
                        new EquivalentAddressGroup(
                            new InProcessSocketAddress("ring-hash-test")))))
                    .setServiceConfig(args.getServiceConfigParser()
                        .parseServiceConfig(serviceConfig))
                    .build());
          }

          @Override
          public void shutdown() {}
        };
      }

      @Override
      public String getDefaultScheme() {
        return "fake";
      }

      @Override
      protected boolean isAvailable() {
        return true;
      }

      @Override
      protected int priority() {
        return 5;
      }

      @Override
      public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
        return Collections.singleton(InProcessSocketAddress.class);
      }
    };

    ManagedChannel channel = InProcessChannelBuilder.forTarget(target)
        .nameResolverFactory(resolverProvider)
        .build();
    try {
      StatusRuntimeException e = assertThrows(StatusRuntimeException.class, () ->
          ClientCalls.blockingUnaryCall(
              channel,
              TestMethodDescriptors.voidMethod(),
              CallOptions.DEFAULT.withDeadlineAfter(5, TimeUnit.SECONDS),
              null));
      assertThat(e.getStatus().getDescription()).doesNotContain("Panic");
    } finally {
      channel.shutdownNow();
    }
  }

  @SuppressWarnings("unchecked")
  private static Map<String, ?> parseJsonObject(String json) throws IOException {
    return (Map<String, ?>) JsonParser.parse(json);
  }
}