| /* |
| * 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.alts.internal; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.fail; |
| |
| import com.google.protobuf.ByteString; |
| import io.grpc.stub.StreamObserver; |
| import java.io.IOException; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** Unit tests for {@link AltsHandshakerStub}. */ |
| @RunWith(JUnit4.class) |
| public class AltsHandshakerStubTest { |
| /** Mock status of handshaker service. */ |
| private static enum Status { |
| OK, |
| ERROR, |
| COMPLETE |
| } |
| |
| private AltsHandshakerStub stub; |
| private MockWriter writer; |
| |
| @Before |
| public void setUp() { |
| writer = new MockWriter(); |
| stub = new AltsHandshakerStub(writer); |
| writer.setReader(stub.getReaderForTest()); |
| } |
| |
| /** Send a message as in_bytes and expect same message as out_frames echo back. */ |
| private void sendSuccessfulMessage() throws Exception { |
| String message = "hello world"; |
| HandshakerReq.Builder req = |
| HandshakerReq.newBuilder() |
| .setNext( |
| NextHandshakeMessageReq.newBuilder() |
| .setInBytes(ByteString.copyFromUtf8(message)) |
| .build()); |
| HandshakerResp resp = stub.send(req.build()); |
| assertEquals(resp.getOutFrames().toStringUtf8(), message); |
| } |
| |
| /** Send a message and expect an IOException on error. */ |
| private void sendAndExpectError() throws InterruptedException { |
| try { |
| stub.send(HandshakerReq.newBuilder().build()); |
| fail("Exception expected"); |
| } catch (IOException ex) { |
| assertThat(ex).hasMessageThat().contains("Received a terminating error"); |
| } |
| } |
| |
| /** Send a message and expect an IOException on closing. */ |
| private void sendAndExpectComplete() throws InterruptedException { |
| try { |
| stub.send(HandshakerReq.newBuilder().build()); |
| fail("Exception expected"); |
| } catch (IOException ex) { |
| assertThat(ex).hasMessageThat().contains("Response stream closed"); |
| } |
| } |
| |
| /** Send a message and expect an IOException on unexpected message. */ |
| private void sendAndExpectUnexpectedMessage() throws InterruptedException { |
| try { |
| stub.send(HandshakerReq.newBuilder().build()); |
| fail("Exception expected"); |
| } catch (IOException ex) { |
| assertThat(ex).hasMessageThat().contains("Received an unexpected response"); |
| } |
| } |
| |
| @Test |
| public void sendSuccessfulMessageTest() throws Exception { |
| writer.setServiceStatus(Status.OK); |
| sendSuccessfulMessage(); |
| stub.close(); |
| } |
| |
| @Test |
| public void getServiceErrorTest() throws InterruptedException { |
| writer.setServiceStatus(Status.ERROR); |
| sendAndExpectError(); |
| stub.close(); |
| } |
| |
| @Test |
| public void getServiceCompleteTest() throws Exception { |
| writer.setServiceStatus(Status.COMPLETE); |
| sendAndExpectComplete(); |
| stub.close(); |
| } |
| |
| @Test |
| public void getUnexpectedMessageTest() throws Exception { |
| writer.setServiceStatus(Status.OK); |
| writer.sendUnexpectedResponse(); |
| sendAndExpectUnexpectedMessage(); |
| stub.close(); |
| } |
| |
| @Test |
| public void closeEarlyTest() throws InterruptedException { |
| stub.close(); |
| sendAndExpectComplete(); |
| } |
| |
| private static class MockWriter implements StreamObserver<HandshakerReq> { |
| private StreamObserver<HandshakerResp> reader; |
| private Status status = Status.OK; |
| |
| private void setReader(StreamObserver<HandshakerResp> reader) { |
| this.reader = reader; |
| } |
| |
| private void setServiceStatus(Status status) { |
| this.status = status; |
| } |
| |
| /** Send a handshaker response to reader. */ |
| private void sendUnexpectedResponse() { |
| reader.onNext(HandshakerResp.newBuilder().build()); |
| } |
| |
| /** Mock writer onNext. Will respond based on the server status. */ |
| @Override |
| public void onNext(final HandshakerReq req) { |
| switch (status) { |
| case OK: |
| HandshakerResp.Builder resp = HandshakerResp.newBuilder(); |
| reader.onNext(resp.setOutFrames(req.getNext().getInBytes()).build()); |
| break; |
| case ERROR: |
| reader.onError(new RuntimeException()); |
| break; |
| case COMPLETE: |
| reader.onCompleted(); |
| break; |
| default: |
| return; |
| } |
| } |
| |
| @Override |
| public void onError(Throwable t) {} |
| |
| /** Mock writer onComplete. */ |
| @Override |
| public void onCompleted() { |
| reader.onCompleted(); |
| } |
| } |
| } |