/** * Checks send after stream is ready. */ @Test public void sendAfterStreamReady() throws Exception { when(mRequestObserver.isReady()).thenReturn(false); doAnswer((args) -> { mOnReadyHandler = args.getArgumentAt(0, Runnable.class); return null; }).when(mRequestObserver).setOnReadyHandler(any(Runnable.class)); mResponseObserver.beforeStart(mRequestObserver); EXECUTOR.submit(() -> { try { // notify ready after a short period of time Thread.sleep(SHORT_TIMEOUT); when(mRequestObserver.isReady()).thenReturn(true); mOnReadyHandler.run(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); WriteRequest request = WriteRequest.newBuilder().build(); mStream.send(request, TIMEOUT); verify(mRequestObserver).onNext(request); }
/** * Cancels the stream. */ public void cancel() { if (isOpen()) { mCanceled = true; mRequestObserver.cancel("Request is cancelled by user.", null); } }
@Override public void onNext(SimpleResponse value) { if (numResponses.incrementAndGet() < CAPPED_NUM_MESSAGES) { requestStream.request(1); } else { if (!clientClosed.get()) { for (int i = 0; i < TOTAL_NUM_MESSAGES; i++) { requestStream.onNext(SimpleRequest.getDefaultInstance()); } requestStream.onCompleted(); clientClosed.set(true); } requestStream.request(1); } }
@Override public void beforeStart(ClientCallStreamObserver<SimpleRequest> requestStream) { requestStream.setOnReadyHandler(() -> { if (numRequests.get() < TOTAL_NUM_MESSAGES) { numRequests.incrementAndGet(); requestStream.onNext(REQUEST); } }); } });
/** * Set up gRPC interface mocks. */ @Before public void before() { mClient = mock(BlockWorkerClient.class); mRequestObserver = mock(ClientCallStreamObserver.class); when(mClient.writeBlock(any(StreamObserver.class))).thenAnswer((args) -> { mResponseObserver = args.getArgumentAt(0, ClientResponseObserver.class); return mRequestObserver; }); when(mRequestObserver.isReady()).thenReturn(true); mStream = new GrpcBlockingStream<>(mClient::writeBlock, BUFFER_SIZE, TEST_MESSAGE); }
/** * Validates the read request sent. * * @param client the worker client * @param offset the offset * @param length the length */ private void validateReadRequestSent(final BlockWorkerClient client, long offset, long length, boolean closed, int chunkSize) throws TimeoutException, InterruptedException { ArgumentCaptor<ReadRequest> requestCaptor = ArgumentCaptor.forClass(ReadRequest.class); verify(mRequestObserver, atLeastOnce()).onNext(requestCaptor.capture()); ArgumentCaptor<StreamObserver> captor = ArgumentCaptor.forClass(StreamObserver.class); verify(mClient).readBlock(captor.capture()); ReadRequest readRequest = requestCaptor.getValue(); captor.getValue().onCompleted(); verify(mRequestObserver, closed ? atLeastOnce() : never()).onCompleted(); assertTrue(readRequest != null); assertEquals(BLOCK_ID, readRequest.getBlockId()); assertEquals(offset, readRequest.getOffset()); assertEquals(length, readRequest.getLength()); assertEquals(chunkSize, readRequest.getChunkSize()); }
@Override public void beforeStart(ClientCallStreamObserver<ReqT> rs) { rs.setOnReadyHandler(() -> { // called from grpc response thread if(rs.isReady()) { errCounter = 0; boolean notify = userReqStream.established(rs); if(notify) respStream.onEstablished(); } }); } // called from grpc response thread
/** * Checks send request is called on the request observer. */ @Test public void send() throws Exception { WriteRequest request = WriteRequest.newBuilder().build(); mStream.send(request, TIMEOUT); verify(mRequestObserver).onNext(request); }
/** * Closes the outbound stream. */ public void close() { if (isOpen()) { mClosed = true; mRequestObserver.onCompleted(); } }
@Override public void beforeStart(ClientCallStreamObserver<SimpleRequest> requestStream) { this.requestStream = requestStream; requestStream.disableAutoInboundFlowControl(); } });
markerCounter.decrementAndGet(); if (!completionMarkerFound.get()) { requestStream.request(1);
/** * Checks send fails after timeout waiting for stream to be ready. */ @Test public void sendFailsAfterTimeout() throws Exception { when(mRequestObserver.isReady()).thenReturn(false); mThrown.expect(DeadlineExceededException.class); mThrown.expectMessage(containsString(TEST_MESSAGE)); mStream.send(WriteRequest.newBuilder().build(), SHORT_TIMEOUT); }
try { ArgumentCaptor<WriteRequest> requestCaptor = ArgumentCaptor.forClass(WriteRequest.class); verify(mRequestObserver, atLeastOnce()).onNext(requestCaptor.capture()); ArgumentCaptor<StreamObserver> captor = ArgumentCaptor.forClass(StreamObserver.class); verify(mClient).writeBlock(captor.capture());
/** * Checks onCompleted is called on request observer upon close. */ @Test public void close() throws Exception { mStream.close(); Assert.assertTrue(mStream.isClosed()); Assert.assertFalse(mStream.isOpen()); verify(mRequestObserver).onCompleted(); }
@Override public void beforeStart(ClientCallStreamObserver<ReadRowsRequest> requestStream) { requestStream.disableAutoInboundFlowControl(); this.requestStream = requestStream; }
@Before public void before() throws Exception { mClientContext = ClientContext.create(mConf); mContext = PowerMockito.mock(FileSystemContext.class); mAddress = Mockito.mock(WorkerNetAddress.class); mClient = mock(BlockWorkerClient.class); mRequestObserver = mock(ClientCallStreamObserver.class); PowerMockito.when(mContext.getClientContext()).thenReturn(mClientContext); PowerMockito.when(mContext.getConf()).thenReturn(mConf); PowerMockito.when(mContext.acquireBlockWorkerClient(mAddress)).thenReturn(mClient); PowerMockito.doNothing().when(mContext).releaseBlockWorkerClient(mAddress, mClient); PowerMockito.when(mClient.writeBlock(any(StreamObserver.class))).thenReturn(mRequestObserver); PowerMockito.when(mRequestObserver.isReady()).thenReturn(true); }
/** * Checks cancel is called on request observer upon cancel. */ @Test public void cancel() throws Exception { mStream.cancel(); Assert.assertTrue(mStream.isCanceled()); Assert.assertFalse(mStream.isOpen()); verify(mRequestObserver).cancel(any(String.class), eq(null)); }
try { ArgumentCaptor<WriteRequest> requestCaptor = ArgumentCaptor.forClass(WriteRequest.class); verify(mRequestObserver, atLeastOnce()).onNext(requestCaptor.capture()); ArgumentCaptor<StreamObserver> captor = ArgumentCaptor.forClass(StreamObserver.class); verify(mClient).writeBlock(captor.capture());