How to use

withChannel

method

in

com.google.api.gax.grpc.GrpcCallContext

@Override
public GrpcCallContext withTransportChannel(TransportChannel inputChannel) {
 Preconditions.checkNotNull(inputChannel);
 if (!(inputChannel instanceof GrpcTransportChannel)) {
  throw new IllegalArgumentException(
    "Expected GrpcTransportChannel, got " + inputChannel.getClass().getName());
 }
 GrpcTransportChannel transportChannel = (GrpcTransportChannel) inputChannel;
 return withChannel(transportChannel.getChannel());
}

@Test
public void testAffinity() {
 MethodDescriptor<Color, Money> descriptor = FakeServiceGrpc.METHOD_RECOGNIZE;
 @SuppressWarnings("unchecked")
 ClientCall<Color, Money> clientCall0 = Mockito.mock(ClientCall.class);
 @SuppressWarnings("unchecked")
 ClientCall<Color, Money> clientCall1 = Mockito.mock(ClientCall.class);
 ManagedChannel channel0 = Mockito.mock(ManagedChannel.class);
 ManagedChannel channel1 = Mockito.mock(ManagedChannel.class);
 Mockito.when(channel0.newCall(Mockito.eq(descriptor), Mockito.<CallOptions>any()))
   .thenReturn(clientCall0);
 Mockito.when(channel1.newCall(Mockito.eq(descriptor), Mockito.<CallOptions>any()))
   .thenReturn(clientCall1);
 Channel pool = new ChannelPool(Arrays.asList(channel0, channel1));
 GrpcCallContext context = GrpcCallContext.createDefault().withChannel(pool);
 ClientCall<Color, Money> gotCallA =
   GrpcClientCalls.newCall(descriptor, context.withChannelAffinity(0));
 ClientCall<Color, Money> gotCallB =
   GrpcClientCalls.newCall(descriptor, context.withChannelAffinity(0));
 ClientCall<Color, Money> gotCallC =
   GrpcClientCalls.newCall(descriptor, context.withChannelAffinity(1));
 assertThat(gotCallA).isSameAs(gotCallB);
 assertThat(gotCallA).isNotSameAs(gotCallC);
}

@Override
public GrpcCallContext withTransportChannel(TransportChannel inputChannel) {
 Preconditions.checkNotNull(inputChannel);
 if (!(inputChannel instanceof GrpcTransportChannel)) {
  throw new IllegalArgumentException(
    "Expected GrpcTransportChannel, got " + inputChannel.getClass().getName());
 }
 GrpcTransportChannel transportChannel = (GrpcTransportChannel) inputChannel;
 return withChannel(transportChannel.getChannel());
}

  GrpcCallContext.createDefault().withChannel(mockChannel).withExtraHeaders(extraHeaders);
GrpcClientCalls.newCall(descriptor, context).start(mockListener, emptyHeaders);

@Test
public void testTimeoutToDeadlineConversion() {
 MethodDescriptor<Color, Money> descriptor = FakeServiceGrpc.METHOD_RECOGNIZE;
 @SuppressWarnings("unchecked")
 ClientCall<Color, Money> mockClientCall = Mockito.mock(ClientCall.class);
 @SuppressWarnings("unchecked")
 ClientCall.Listener<Money> mockListener = Mockito.mock(ClientCall.Listener.class);
 @SuppressWarnings("unchecked")
 Channel mockChannel = Mockito.mock(ManagedChannel.class);
 ArgumentCaptor<CallOptions> capturedCallOptions = ArgumentCaptor.forClass(CallOptions.class);
 Mockito.when(mockChannel.newCall(Mockito.eq(descriptor), capturedCallOptions.capture()))
   .thenReturn(mockClientCall);
 Duration timeout = Duration.ofSeconds(10);
 Deadline minExpectedDeadline = Deadline.after(timeout.getSeconds(), TimeUnit.SECONDS);
 GrpcCallContext context =
   GrpcCallContext.createDefault().withChannel(mockChannel).withTimeout(timeout);
 GrpcClientCalls.newCall(descriptor, context).start(mockListener, new Metadata());
 Deadline maxExpectedDeadline = Deadline.after(timeout.getSeconds(), TimeUnit.SECONDS);
 Truth.assertThat(capturedCallOptions.getValue().getDeadline()).isAtLeast(minExpectedDeadline);
 Truth.assertThat(capturedCallOptions.getValue().getDeadline()).isAtMost(maxExpectedDeadline);
}

@Test
public void testTimeoutAfterDeadline() {
 MethodDescriptor<Color, Money> descriptor = FakeServiceGrpc.METHOD_RECOGNIZE;
 @SuppressWarnings("unchecked")
 ClientCall<Color, Money> mockClientCall = Mockito.mock(ClientCall.class);
 @SuppressWarnings("unchecked")
 ClientCall.Listener<Money> mockListener = Mockito.mock(ClientCall.Listener.class);
 @SuppressWarnings("unchecked")
 Channel mockChannel = Mockito.mock(ManagedChannel.class);
 ArgumentCaptor<CallOptions> capturedCallOptions = ArgumentCaptor.forClass(CallOptions.class);
 Mockito.when(mockChannel.newCall(Mockito.eq(descriptor), capturedCallOptions.capture()))
   .thenReturn(mockClientCall);
 // Configure a timeout that occurs after the grpc deadline
 Deadline priorDeadline = Deadline.after(5, TimeUnit.SECONDS);
 Duration timeout = Duration.ofSeconds(10);
 GrpcCallContext context =
   GrpcCallContext.createDefault()
     .withChannel(mockChannel)
     .withCallOptions(CallOptions.DEFAULT.withDeadline(priorDeadline))
     .withTimeout(timeout);
 GrpcClientCalls.newCall(descriptor, context).start(mockListener, new Metadata());
 // Verify that the timeout is ignored
 Truth.assertThat(capturedCallOptions.getValue().getDeadline()).isEqualTo(priorDeadline);
}

.withChannel(mockChannel)
.withCallOptions(CallOptions.DEFAULT.withDeadline(subsequentDeadline))
.withTimeout(timeout);