| /* |
| * Copyright 2018 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.protobuf.services; |
| |
| import static com.google.common.truth.Truth.assertWithMessage; |
| import static org.junit.Assert.assertEquals; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.verify; |
| |
| import io.grpc.InternalChannelz; |
| import io.grpc.Status; |
| import io.grpc.channelz.v1.GetChannelRequest; |
| import io.grpc.channelz.v1.GetChannelResponse; |
| import io.grpc.channelz.v1.GetServerRequest; |
| import io.grpc.channelz.v1.GetServerResponse; |
| import io.grpc.channelz.v1.GetServersRequest; |
| import io.grpc.channelz.v1.GetServersResponse; |
| import io.grpc.channelz.v1.GetSocketRequest; |
| import io.grpc.channelz.v1.GetSocketResponse; |
| import io.grpc.channelz.v1.GetSubchannelRequest; |
| import io.grpc.channelz.v1.GetSubchannelResponse; |
| import io.grpc.channelz.v1.GetTopChannelsRequest; |
| import io.grpc.channelz.v1.GetTopChannelsResponse; |
| import io.grpc.protobuf.services.ChannelzTestHelper.TestChannel; |
| import io.grpc.protobuf.services.ChannelzTestHelper.TestServer; |
| import io.grpc.protobuf.services.ChannelzTestHelper.TestSocket; |
| import io.grpc.stub.StreamObserver; |
| import java.util.concurrent.ExecutionException; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| import org.mockito.ArgumentCaptor; |
| |
| @RunWith(JUnit4.class) |
| public class ChannelzServiceTest { |
| // small value to force pagination |
| private static final int MAX_PAGE_SIZE = 1; |
| |
| private final InternalChannelz channelz = new InternalChannelz(); |
| private ChannelzService service = new ChannelzService(channelz, MAX_PAGE_SIZE); |
| |
| @Test |
| public void getTopChannels_empty() { |
| assertEquals( |
| GetTopChannelsResponse.newBuilder().setEnd(true).build(), |
| getTopChannelHelper(0)); |
| } |
| |
| @Test |
| public void getTopChannels_onePage() throws Exception { |
| TestChannel root = new TestChannel(); |
| channelz.addRootChannel(root); |
| |
| assertEquals( |
| GetTopChannelsResponse |
| .newBuilder() |
| .addChannel(ChannelzProtoUtil.toChannel(root)) |
| .setEnd(true) |
| .build(), |
| getTopChannelHelper(0)); |
| } |
| |
| @Test |
| public void getChannel() throws ExecutionException, InterruptedException { |
| TestChannel root = new TestChannel(); |
| assertChannelNotFound(root.getLogId().getId()); |
| |
| channelz.addRootChannel(root); |
| assertEquals( |
| GetChannelResponse |
| .newBuilder() |
| .setChannel(ChannelzProtoUtil.toChannel(root)) |
| .build(), |
| getChannelHelper(root.getLogId().getId())); |
| |
| channelz.removeRootChannel(root); |
| assertChannelNotFound(root.getLogId().getId()); |
| } |
| |
| @Test |
| public void getSubchannel() throws Exception { |
| TestChannel subchannel = new TestChannel(); |
| assertSubchannelNotFound(subchannel.getLogId().getId()); |
| |
| channelz.addSubchannel(subchannel); |
| assertEquals( |
| GetSubchannelResponse |
| .newBuilder() |
| .setSubchannel(ChannelzProtoUtil.toSubchannel(subchannel)) |
| .build(), |
| getSubchannelHelper(subchannel.getLogId().getId())); |
| |
| channelz.removeSubchannel(subchannel); |
| assertSubchannelNotFound(subchannel.getLogId().getId()); |
| } |
| |
| @Test |
| public void getServers_empty() { |
| assertEquals( |
| GetServersResponse.newBuilder().setEnd(true).build(), |
| getServersHelper(0)); |
| } |
| |
| @Test |
| public void getServers_onePage() throws Exception { |
| TestServer server = new TestServer(); |
| channelz.addServer(server); |
| |
| assertEquals( |
| GetServersResponse |
| .newBuilder() |
| .addServer(ChannelzProtoUtil.toServer(server)) |
| .setEnd(true) |
| .build(), |
| getServersHelper(0)); |
| } |
| |
| @Test |
| public void getServer() throws ExecutionException, InterruptedException { |
| TestServer server = new TestServer(); |
| assertServerNotFound(server.getLogId().getId()); |
| |
| channelz.addServer(server); |
| assertEquals( |
| GetServerResponse |
| .newBuilder() |
| .setServer(ChannelzProtoUtil.toServer(server)) |
| .build(), |
| getServerHelper(server.getLogId().getId())); |
| |
| channelz.removeServer(server); |
| assertServerNotFound(server.getLogId().getId()); |
| } |
| |
| |
| @Test |
| public void getSocket() throws Exception { |
| TestSocket socket = new TestSocket(); |
| assertSocketNotFound(socket.getLogId().getId()); |
| |
| channelz.addClientSocket(socket); |
| assertEquals( |
| GetSocketResponse |
| .newBuilder() |
| .setSocket(ChannelzProtoUtil.toSocket(socket)) |
| .build(), |
| getSocketHelper(socket.getLogId().getId())); |
| |
| channelz.removeClientSocket(socket); |
| assertSocketNotFound(socket.getLogId().getId()); |
| } |
| |
| private GetTopChannelsResponse getTopChannelHelper(long startId) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetTopChannelsResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<GetTopChannelsResponse> responseCaptor |
| = ArgumentCaptor.forClass(GetTopChannelsResponse.class); |
| service.getTopChannels( |
| GetTopChannelsRequest.newBuilder().setStartChannelId(startId).build(), |
| observer); |
| verify(observer).onNext(responseCaptor.capture()); |
| verify(observer).onCompleted(); |
| return responseCaptor.getValue(); |
| } |
| |
| private GetChannelResponse getChannelHelper(long id) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetChannelResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<GetChannelResponse> response |
| = ArgumentCaptor.forClass(GetChannelResponse.class); |
| service.getChannel(GetChannelRequest.newBuilder().setChannelId(id).build(), observer); |
| verify(observer).onNext(response.capture()); |
| verify(observer).onCompleted(); |
| return response.getValue(); |
| } |
| |
| private void assertChannelNotFound(long id) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetChannelResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class); |
| service.getChannel(GetChannelRequest.newBuilder().setChannelId(id).build(), observer); |
| verify(observer).onError(exceptionCaptor.capture()); |
| Status s = Status.fromThrowable(exceptionCaptor.getValue()); |
| assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.NOT_FOUND); |
| } |
| |
| private GetSubchannelResponse getSubchannelHelper(long id) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetSubchannelResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<GetSubchannelResponse> response |
| = ArgumentCaptor.forClass(GetSubchannelResponse.class); |
| service.getSubchannel(GetSubchannelRequest.newBuilder().setSubchannelId(id).build(), observer); |
| verify(observer).onNext(response.capture()); |
| verify(observer).onCompleted(); |
| return response.getValue(); |
| } |
| |
| private void assertSubchannelNotFound(long id) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetSubchannelResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class); |
| service.getSubchannel(GetSubchannelRequest.newBuilder().setSubchannelId(id).build(), observer); |
| verify(observer).onError(exceptionCaptor.capture()); |
| Status s = Status.fromThrowable(exceptionCaptor.getValue()); |
| assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.NOT_FOUND); |
| } |
| |
| private GetServersResponse getServersHelper(long startId) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetServersResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<GetServersResponse> responseCaptor |
| = ArgumentCaptor.forClass(GetServersResponse.class); |
| service.getServers( |
| GetServersRequest.newBuilder().setStartServerId(startId).build(), |
| observer); |
| verify(observer).onNext(responseCaptor.capture()); |
| verify(observer).onCompleted(); |
| return responseCaptor.getValue(); |
| } |
| |
| private void assertServerNotFound(long id) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetServerResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class); |
| service.getServer(GetServerRequest.newBuilder().setServerId(id).build(), observer); |
| verify(observer).onError(exceptionCaptor.capture()); |
| Status s = Status.fromThrowable(exceptionCaptor.getValue()); |
| assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.NOT_FOUND); |
| } |
| |
| private GetServerResponse getServerHelper(long id) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetServerResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<GetServerResponse> response = ArgumentCaptor.forClass(GetServerResponse.class); |
| service.getServer(GetServerRequest.newBuilder().setServerId(id).build(), observer); |
| verify(observer).onNext(response.capture()); |
| verify(observer).onCompleted(); |
| return response.getValue(); |
| } |
| |
| private void assertSocketNotFound(long id) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetSocketResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class); |
| service.getSocket(GetSocketRequest.newBuilder().setSocketId(id).build(), observer); |
| verify(observer).onError(exceptionCaptor.capture()); |
| Status s = Status.fromThrowable(exceptionCaptor.getValue()); |
| assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.NOT_FOUND); |
| } |
| |
| private GetSocketResponse getSocketHelper(long id) { |
| @SuppressWarnings("unchecked") |
| StreamObserver<GetSocketResponse> observer = mock(StreamObserver.class); |
| ArgumentCaptor<GetSocketResponse> response |
| = ArgumentCaptor.forClass(GetSocketResponse.class); |
| service.getSocket(GetSocketRequest.newBuilder().setSocketId(id).build(), observer); |
| verify(observer).onNext(response.capture()); |
| verify(observer).onCompleted(); |
| return response.getValue(); |
| } |
| } |