public void send(ActorRef actor, Object msg) { actor.tell(msg, p.ref()); }
public void send(ActorRef actor, Object msg) { actor.tell(msg, p.ref()); }
public void send(ActorRef actor, Object msg) { actor.tell(msg, p.ref()); }
public void reply(Object msg) { p.lastMessage().sender().tell(msg, p.ref()); }
public void reply(Object msg) { p.lastMessage().sender().tell(msg, p.ref()); }
public void reply(Object msg) { p.lastMessage().sender().tell(msg, p.ref()); }
@Test public void testCloseAllSlicedMessageState() throws IOException { doReturn(1).when(mockInputStream).read(any(byte[].class)); final MessageSlicer slicer = newMessageSlicer("testCloseAllSlicedMessageState", 1); slice(slicer, IDENTIFIER, new BytesMessage(new byte[]{1, 2}), testProbe.ref(), testProbe.ref(), mockOnFailureCallback); slicer.close(); verify(mockFiledBackedStream).cleanup(); verifyNoMoreInteractions(mockOnFailureCallback); }
@Test public void testSliceWithInputStreamFailure() throws IOException { doReturn(0).when(mockInputStream).read(any(byte[].class)); try (MessageSlicer slicer = newMessageSlicer("testSliceWithInputStreamFailure", 2)) { final boolean wasSliced = slice(slicer, IDENTIFIER, new BytesMessage(new byte[]{}), testProbe.ref(), testProbe.ref(), mockOnFailureCallback); assertFalse(wasSliced); assertFailureCallback(IOException.class); verify(mockFiledBackedStream).cleanup(); } }
@Override protected TransmitQueue.Transmitting createQueue() { doReturn(false).when(mockMessageSlicer).slice(any()); backendInfo = new BackendInfo(probe.ref(), "test", 0L, ABIVersion.BORON, 3); return new TransmitQueue.Transmitting(new TransmitQueue.Halted(0), 0, backendInfo, now(), mockMessageSlicer); }
@Test public void testPoison() { final Consumer<Response<?, ?>> callback = mock(Consumer.class); final Request<?, ?> request = createRequest(replyToProbe.ref()); final ConnectionEntry entry = new ConnectionEntry(request, callback, 0L); connection.enqueueEntry(entry, 0L); connection.poison(new RuntimeRequestException("fail", new RuntimeException("fail"))); verify(callback, timeout(1000)).accept(isA(TransactionFailure.class)); }
@Test public void testPoison() { final Request<?, ?> request = new TransactionPurgeRequest(TRANSACTION_IDENTIFIER, 0L, probe.ref()); final Consumer<Response<?, ?>> callback = createConsumerMock(); final long now = Ticker.systemTicker().read(); queue.enqueueOrForward(new ConnectionEntry(request, callback, now), now); queue.poison(new RuntimeRequestException("fail", new RuntimeException("fail"))); verify(callback).accept(any(TransactionFailure.class)); Assert.assertTrue(queue.isEmpty()); }
@Test public void testCheckTimeout() { final Consumer<Response<?, ?>> callback = mock(Consumer.class); connection.sendRequest(createRequest(replyToProbe.ref()), callback); final long now = context.ticker().read(); final Optional<Long> timeout = connection.checkTimeout(now); Assert.assertTrue(timeout.isPresent()); }
@Override protected ConnectedClientConnection<BackendInfo> createConnection() { final BackendInfo backend = new BackendInfo(backendProbe.ref(), "test", 0L, ABIVersion.BORON, 10); final ConnectingClientConnection<BackendInfo> connectingConn = new ConnectingClientConnection<>(context, 0L, backend.getName()); return new ConnectedClientConnection<>(connectingConn, backend); }
@Test public void testFirstMessageSliceWithInvalidIndex() { try (MessageAssembler assembler = newMessageAssembler("testFirstMessageSliceWithInvalidIndex")) { final MessageSliceIdentifier identifier = new MessageSliceIdentifier(IDENTIFIER, 1); final MessageSlice messageSlice = new MessageSlice(identifier, new byte[0], 2, 3, 1, testProbe.ref()); assembler.handleMessage(messageSlice, testProbe.ref()); final MessageSliceReply reply = testProbe.expectMsgClass(MessageSliceReply.class); assertFailedMessageSliceReply(reply, IDENTIFIER, true); assertFalse("MessageAssembler should not have state for " + identifier, assembler.hasState(identifier)); } }
@Test public void testCheckTimeoutConnectionTimedout() { final Consumer<Response<?, ?>> callback = mock(Consumer.class); connection.sendRequest(createRequest(replyToProbe.ref()), callback); final long now = context.ticker().read() + ConnectedClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS; final Optional<Long> timeout = connection.checkTimeout(now); Assert.assertNull(timeout); }
@Before public void setUp() { MockitoAnnotations.initMocks(this); system = ActorSystem.apply(); backendProbe = new TestProbe(system); contextProbe = new TestProbe(system); context = new ClientActorContext(contextProbe.ref(), PERSISTENCE_ID, system, CLIENT_ID, AccessClientUtil.newMockClientActorConfig()); replyToProbe = new TestProbe(system); connection = createConnection(); }
@Test public void testPeek() { final Request<?, ?> request1 = new TransactionPurgeRequest(TRANSACTION_IDENTIFIER, 0L, probe.ref()); final Request<?, ?> request2 = new TransactionPurgeRequest(TRANSACTION_IDENTIFIER, 1L, probe.ref()); final Consumer<Response<?, ?>> callback = createConsumerMock(); final long now = Ticker.systemTicker().read(); final ConnectionEntry entry1 = new ConnectionEntry(request1, callback, now); final ConnectionEntry entry2 = new ConnectionEntry(request2, callback, now); queue.enqueueOrForward(entry1, now); queue.enqueueOrForward(entry2, now); Assert.assertEquals(entry1.getRequest(), queue.peek().getRequest()); }
@Test(expected = UnsupportedOperationException.class) @Override public void testTransmit() { final Request<?, ?> request = new TransactionPurgeRequest(TRANSACTION_IDENTIFIER, 0L, probe.ref()); final Consumer<Response<?, ?>> callback = createConsumerMock(); final long now = Ticker.systemTicker().read(); final ConnectionEntry entry = new ConnectionEntry(request, callback, now); queue.transmit(entry, now); }
@Test public void testMockingControl() { assertSame(CLIENT_ID, ctx.getIdentifier()); assertSame(PERSISTENCE_ID, ctx.persistenceId()); assertSame(probe.ref(), ctx.self()); }
@Test public void testIsEmpty() { Assert.assertTrue(queue.isEmpty()); final Request<?, ?> request = new TransactionPurgeRequest(TRANSACTION_IDENTIFIER, 0L, probe.ref()); final Consumer<Response<?, ?>> callback = createConsumerMock(); final long now = Ticker.systemTicker().read(); queue.enqueueOrForward(new ConnectionEntry(request, callback, now), now); Assert.assertFalse(queue.isEmpty()); }