import io.grpc.InternalChannelz;

import io.grpc.InternalChannelz.ChannelStats;

import io.grpc.InternalChannelz.ChannelTrace;

import io.grpc.InternalChannelz.ChannelTrace.Event.Severity;

import io.grpc.InternalConfigSelector;

import io.grpc.InternalInstrumented;

import io.grpc.LoadBalancer;

import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;

import io.grpc.internal.ManagedChannelImplBuilder.FixedPortProvider;

import io.grpc.internal.ManagedChannelImplBuilder.UnsupportedClientTransportFactoryBuilder;

import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;

import io.grpc.internal.ServiceConfigUtil.PolicySelection;

import io.grpc.internal.TestUtils.MockClientTransportInfo;

import io.grpc.stub.ClientCalls;

verifyNoMoreInteractions(mockLoadBalancer);

}

@Test

public void addressResolutionError_noPriorNameResolution_usesDefaultServiceConfig()

throws Exception {

Map<String, Object> rawServiceConfig =

parseConfig("{\"methodConfig\":[{"

+ "\"name\":[{\"service\":\"service\"}],"

+ "\"waitForReady\":true}]}");

ManagedChannelServiceConfig managedChannelServiceConfig =

createManagedChannelServiceConfig(rawServiceConfig, null);

FakeNameResolverFactory nameResolverFactory =

new FakeNameResolverFactory.Builder(expectedUri)

.setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))

.setResolvedAtStart(false)

.build();

nameResolverFactory.nextConfigOrError.set(

ConfigOrError.fromConfig(managedChannelServiceConfig));

channelBuilder.nameResolverFactory(nameResolverFactory);

Map<String, Object> defaultServiceConfig =

parseConfig("{\"methodConfig\":[{"

+ "\"name\":[{\"service\":\"service\"}],"

+ "\"waitForReady\":true}]}");

channelBuilder.defaultServiceConfig(defaultServiceConfig);

Status resolutionError = Status.UNAVAILABLE.withDescription("Resolution failed");

channelBuilder.maxTraceEvents(10);

createChannel();

FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0);

resolver.listener.onError(resolutionError);

InternalConfigSelector configSelector = channel.getConfigSelector();

ManagedChannelServiceConfig config =

(ManagedChannelServiceConfig) configSelector.selectConfig(null).getConfig();

MethodInfo methodConfig = config.getMethodConfig(method);

assertThat(methodConfig.waitForReady).isTrue();

timer.forwardNanos(1234);

assertThat(getStats(channel).channelTrace.events).contains(new ChannelTrace.Event.Builder()

.setDescription("Initial Name Resolution error, using default service config")

.setSeverity(Severity.CT_ERROR)

.setTimestampNanos(0)

.build());

// Check that "lastServiceConfig" variable has been set above: a config resolution with the same

// config simply gets ignored and not gets reassigned.

resolver.resolved();

timer.forwardNanos(1234);

assertThat(getStats(channel).channelTrace.events.stream().filter(

event -> event.description.equals("Service config changed")).count()).isEqualTo(0);

}

@Test

public void interceptor() throws Exception {

final AtomicLong atomic = new AtomicLong();

int size = getStats(channel).channelTrace.events.size();

assertThat(getStats(channel).channelTrace.events.get(size - 1))

.isNotEqualTo(new ChannelTrace.Event.Builder()

.setDescription("Using default service config")

.setDescription("timer.forwardNanos(1234);")

.setSeverity(ChannelTrace.Event.Severity.CT_INFO)

.setTimestampNanos(timer.getTicker().read())

.build());