@Test
public void testWithBadHandlers() throws Exception {
final MessageDispatchSender messageDispatchSender = new MessageDispatchSender();
final Message message = new SimpleMessage();
final CommunicationException communicationException = new CommunicationException("");
doThrow(communicationException).when(m_handler).handle(message);
messageDispatchSender.addFallback(m_handler);
try {
messageDispatchSender.send(message);
} catch (CommunicationException e) {
assertSame(communicationException, e);
}
messageDispatchSender.set(SimpleMessage.class, m_handler);
try {
messageDispatchSender.send(message);
} catch (CommunicationException e) {
assertSame(communicationException, e);
}
verify(m_handler, times(2)).handle(message);
verifyNoMoreInteractions(m_handler);
}
@Test
public void testShutdown() throws Exception {
final MessageDispatchSender messageDispatchSender = new MessageDispatchSender();
messageDispatchSender.shutdown();
messageDispatchSender.set(SimpleMessage.class, m_handler);
messageDispatchSender.shutdown();
verify(m_handler).shutdown();
messageDispatchSender.addFallback(m_handler2);
messageDispatchSender.addFallback(m_handler2);
messageDispatchSender.set(OtherMessage.class, m_responder);
final BlockingHandler<Message> blockingHandler2 =
new AbstractBlockingHandler<Message>() {
public Message blockingSend(Message message) throws CommunicationException {
return null;
}
};
messageDispatchSender.set(Message.class, blockingHandler2);
messageDispatchSender.shutdown();
verify(m_handler, times(2)).shutdown();
verify(m_handler2, times(2)).shutdown();
verify(m_responder).shutdown();
verifyNoMoreInteractions(m_handler, m_handler2, m_responder);
}
@Test
public void testSend() throws Exception {
final MessageDispatchSender messageDispatchSender = new MessageDispatchSender();
messageDispatchSender.send(new SimpleMessage());
messageDispatchSender.addFallback(m_fallBackHandler);
final Message m1 = new SimpleMessage();
final Message m2 = new SimpleMessage();
messageDispatchSender.send(m1);
messageDispatchSender.send(m2);
verify(m_fallBackHandler).handle(m1);
verify(m_fallBackHandler).handle(m2);
final Handler<Message> previousHandler =
messageDispatchSender.set(SimpleMessage.class, m_handler);
assertNull(previousHandler);
final Handler<Message> previousHandler2 =
messageDispatchSender.set(OtherMessage.class, m_handler2);
assertNull(previousHandler2);
messageDispatchSender.send(m1);
messageDispatchSender.send(m2);
verify(m_handler).handle(m1);
verify(m_handler).handle(m2);
final OtherMessage m3 = new OtherMessage();
messageDispatchSender.send(m3);
verify(m_handler2).handle(m3);
final CommunicationException e = new CommunicationException("");
doThrow(e).when(m_handler).handle(m1);
try {
messageDispatchSender.send(m1);
fail("Expected CommunicationException");
} catch (CommunicationException e2) {
assertSame(e, e2);
}
verify(m_handler, times(2)).handle(m1);
verifyNoMoreInteractions(m_handler, m_handler2, m_fallBackHandler);
}
@Test
public void testWithMessageRequiringResponse() throws Exception {
final MessageDispatchSender messageDispatchSender = new MessageDispatchSender();
final Message message = new SimpleMessage();
final MessageRequiringResponse messageRequiringResponse = new MessageRequiringResponse(message);
try {
messageDispatchSender.send(messageRequiringResponse);
fail("Expected CommunicationException");
} catch (CommunicationException e) {
}
messageRequiringResponse.setResponder(m_sender);
messageDispatchSender.send(messageRequiringResponse);
verify(m_sender).send(isA(NoResponseMessage.class));
// Now check a handler can send a response.
final Message responseMessage = new SimpleMessage();
messageDispatchSender.set(
SimpleMessage.class,
new MessageDispatchRegistry.AbstractBlockingHandler<SimpleMessage>() {
public Message blockingSend(SimpleMessage message) {
return responseMessage;
}
});
final MessageRequiringResponse messageRequiringResponse2 =
new MessageRequiringResponse(message);
messageRequiringResponse2.setResponder(m_sender);
messageDispatchSender.send(messageRequiringResponse2);
verify(m_sender).send(responseMessage);
// Finally, check that fallback handler can handle response.
final Message responseMessage2 = new SimpleMessage();
messageDispatchSender.addFallback(
new AbstractHandler<Message>() {
public void handle(Message message) throws CommunicationException {
if (message instanceof MessageRequiringResponse) {
final MessageRequiringResponse m = (MessageRequiringResponse) message;
m.sendResponse(responseMessage2);
}
}
});
final MessageRequiringResponse messageRequiringResponse3 =
new MessageRequiringResponse(new OtherMessage());
messageRequiringResponse3.setResponder(m_sender);
messageDispatchSender.send(messageRequiringResponse3);
verify(m_sender).send(responseMessage2);
verifyNoMoreInteractions(m_sender);
}
