Spring/spring-integration
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

INT-3253: Eliminate EasyMock Dependency

Browse Source 
JIRA: https://jira.springsource.org/browse/INT-3253

INT-3253 Polishing

Use the mockito test runner to initialize the mocks.
This commit is contained in:
Artem Bilan
2014-01-02 12:52:33 +02:00
committed by Gary Russell
parent f9e0bef434
commit 0be6ade8f8
7 changed files with 233 additions and 334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
build.gradle
View File

@@ -46,7 +46,6 @@ subprojects { subproject ->
commonsNetVersion = '3.0.1'
commonsIoVersion = '2.4'
derbyVersion = '10.10.1.1'
easymockVersion = '3.2'
groovyVersion = '2.1.0'
hamcrestVersion = '1.3'
jacksonVersion = '1.9.2'
@@ -98,7 +97,6 @@ subprojects { subproject ->
dependencies {
testCompile "junit:junit:$junitVersion"
testCompile "log4j:log4j:$log4jVersion"
testCompile "org.easymock:easymock:$easymockVersion"
testCompile "org.hamcrest:hamcrest-all:$hamcrestVersion"
testCompile "org.mockito:mockito-all:$mockitoVersion"
testCompile "org.springframework:spring-test:$springVersion"

177
spring-integration-core/src/test/java/org/springframework/integration/dispatcher/BroadcastingDispatcherTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2010 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,58 +16,52 @@
package org.springframework.integration.dispatcher;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.getCurrentArguments;
import static org.easymock.EasyMock.isA;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.easymock.IAnswer;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.springframework.core.task.TaskExecutor;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessagingException;
import org.springframework.messaging.MessageHandler;
import org.springframework.integration.IntegrationMessageHeaderAccessor;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessagingException;
import org.springframework.messaging.support.GenericMessage;
/**
* @author Mark Fisher
* @author Iwein Fuld
* @author Gary Russell
* @author Artem Bilan
*/
public class BroadcastingDispatcherTests {
private BroadcastingDispatcher dispatcher;
private TaskExecutor taskExecutorMock = createMock(TaskExecutor.class);
private TaskExecutor taskExecutorMock = Mockito.mock(TaskExecutor.class);
private Message<?> messageMock = createMock(Message.class);
private Message<?> messageMock = Mockito.mock(Message.class);
private MessageHandler targetMock1 = createMock(MessageHandler.class);
private MessageHandler targetMock1 = Mockito.mock(MessageHandler.class);
private MessageHandler targetMock2 = createMock(MessageHandler.class);
private MessageHandler targetMock2 = Mockito.mock(MessageHandler.class);
private MessageHandler targetMock3 = createMock(MessageHandler.class);
private Object[] globalMocks = new Object[] {
messageMock, taskExecutorMock, targetMock1, targetMock2, targetMock3 };
private MessageHandler targetMock3 = Mockito.mock(MessageHandler.class);
@Before
public void init() {
reset(globalMocks);
Mockito.reset(taskExecutorMock, messageMock, taskExecutorMock, targetMock1, targetMock2, targetMock3);
defaultTaskExecutorMock();
}
@@ -76,22 +70,16 @@ public class BroadcastingDispatcherTests {
public void singleTargetWithoutTaskExecutor() throws Exception {
dispatcher = new BroadcastingDispatcher();
dispatcher.addHandler(targetMock1);
targetMock1.handleMessage(messageMock);
expectLastCall();
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1).handleMessage(Mockito.eq(messageMock));
}
@Test
public void singleTargetWithTaskExecutor() throws Exception {
dispatcher = new BroadcastingDispatcher(taskExecutorMock);
dispatcher.addHandler(targetMock1);
targetMock1.handleMessage(messageMock);
expectLastCall();
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1).handleMessage(Mockito.eq(messageMock));
}
@Test
@@ -100,15 +88,10 @@ public class BroadcastingDispatcherTests {
dispatcher.addHandler(targetMock1);
dispatcher.addHandler(targetMock2);
dispatcher.addHandler(targetMock3);
targetMock1.handleMessage(messageMock);
expectLastCall();
targetMock2.handleMessage(messageMock);
expectLastCall();
targetMock3.handleMessage(messageMock);
expectLastCall();
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock2).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock3).handleMessage(Mockito.eq(messageMock));
}
@Test
@@ -117,79 +100,62 @@ public class BroadcastingDispatcherTests {
dispatcher.addHandler(targetMock1);
dispatcher.addHandler(targetMock2);
dispatcher.addHandler(targetMock3);
targetMock1.handleMessage(messageMock);
expectLastCall();
targetMock2.handleMessage(messageMock);
expectLastCall();
targetMock3.handleMessage(messageMock);
expectLastCall();
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock2).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock3).handleMessage(Mockito.eq(messageMock));
}
@Test
public void multipleTargetsPartialFailureFirst() {
dispatcher = new BroadcastingDispatcher(taskExecutorMock);
reset(taskExecutorMock);
dispatcher.addHandler(targetMock1);
dispatcher.addHandler(targetMock2);
dispatcher.addHandler(targetMock3);
partialFailingExecutorMock(false, true, true);
targetMock2.handleMessage(messageMock);
expectLastCall();
targetMock3.handleMessage(messageMock);
expectLastCall();
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1, Mockito.never()).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock2).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock3).handleMessage(Mockito.eq(messageMock));
}
@Test
public void multipleTargetsPartialFailureMiddle() {
dispatcher = new BroadcastingDispatcher(taskExecutorMock);
reset(taskExecutorMock);
dispatcher.addHandler(targetMock1);
dispatcher.addHandler(targetMock2);
dispatcher.addHandler(targetMock3);
partialFailingExecutorMock(true, false, true);
targetMock1.handleMessage(messageMock);
expectLastCall();
targetMock3.handleMessage(messageMock);
expectLastCall();
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock2, Mockito.never()).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock3).handleMessage(Mockito.eq(messageMock));
}
@Test
public void multipleTargetsPartialFailureLast() {
dispatcher = new BroadcastingDispatcher(taskExecutorMock);
reset(taskExecutorMock);
dispatcher.addHandler(targetMock1);
dispatcher.addHandler(targetMock2);
dispatcher.addHandler(targetMock3);
partialFailingExecutorMock(true, true, false);
targetMock1.handleMessage(messageMock);
expectLastCall();
targetMock2.handleMessage(messageMock);
expectLastCall();
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock2).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock3, Mockito.never()).handleMessage(Mockito.eq(messageMock));
}
@Test
public void multipleTargetsAllFail() {
dispatcher = new BroadcastingDispatcher(taskExecutorMock);
reset(taskExecutorMock);
dispatcher.addHandler(targetMock1);
dispatcher.addHandler(targetMock2);
dispatcher.addHandler(targetMock3);
partialFailingExecutorMock(false, false, false);
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1, Mockito.never()).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock2, Mockito.never()).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock3, Mockito.never()).handleMessage(Mockito.eq(messageMock));
}
@Test
@@ -198,11 +164,8 @@ public class BroadcastingDispatcherTests {
dispatcher.addHandler(targetMock1);
dispatcher.addHandler(targetMock1);
dispatcher.addHandler(targetMock1);
targetMock1.handleMessage(messageMock);
expectLastCall();
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1).handleMessage(Mockito.eq(messageMock));
}
@Test
@@ -212,13 +175,10 @@ public class BroadcastingDispatcherTests {
dispatcher.addHandler(targetMock2);
dispatcher.addHandler(targetMock3);
dispatcher.removeHandler(targetMock2);
targetMock1.handleMessage(messageMock);
expectLastCall();
targetMock3.handleMessage(messageMock);
expectLastCall();
replay(globalMocks);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock2, Mockito.never()).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock3).handleMessage(Mockito.eq(messageMock));
}
@Test
@@ -227,17 +187,12 @@ public class BroadcastingDispatcherTests {
dispatcher.addHandler(targetMock1);
dispatcher.addHandler(targetMock2);
dispatcher.addHandler(targetMock3);
targetMock1.handleMessage(messageMock);
expectLastCall().times(2);
targetMock2.handleMessage(messageMock);
expectLastCall();
targetMock3.handleMessage(messageMock);
expectLastCall().times(2);
replay(globalMocks);
dispatcher.dispatch(messageMock);
dispatcher.removeHandler(targetMock2);
dispatcher.dispatch(messageMock);
verify(globalMocks);
Mockito.verify(targetMock1, Mockito.times(2)).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock2).handleMessage(Mockito.eq(messageMock));
Mockito.verify(targetMock3, Mockito.times(2)).handleMessage(Mockito.eq(messageMock));
}
@Test
@@ -290,16 +245,13 @@ public class BroadcastingDispatcherTests {
public void testExceptionEnhancement() {
dispatcher = new BroadcastingDispatcher();
dispatcher.addHandler(targetMock1);
targetMock1.handleMessage(messageMock);
expectLastCall().andThrow(new MessagingException("Mock Exception"));
replay(globalMocks);
Mockito.doThrow(new MessagingException("Mock Exception")).when(targetMock1).handleMessage(Mockito.eq(messageMock));
try {
dispatcher.dispatch(messageMock);
fail("Expected Exception");
} catch (MessagingException e) {
assertEquals(messageMock, e.getFailedMessage());
}
verify(globalMocks);
}
/**
@@ -312,43 +264,42 @@ public class BroadcastingDispatcherTests {
dispatcher.addHandler(targetMock1);
targetMock1.handleMessage(messageMock);
Message<String> dontReplaceThisMessage = MessageBuilder.withPayload("x").build();
expectLastCall().andThrow(new MessagingException(dontReplaceThisMessage,
"Mock Exception"));
replay(globalMocks);
Mockito.doThrow(new MessagingException(dontReplaceThisMessage, "Mock Exception"))
.when(targetMock1).handleMessage(Mockito.eq(messageMock));
try {
dispatcher.dispatch(messageMock);
fail("Expected Exception");
} catch (MessagingException e) {
assertEquals(dontReplaceThisMessage, e.getFailedMessage());
}
verify(globalMocks);
}
private void defaultTaskExecutorMock() {
taskExecutorMock.execute(isA(Runnable.class));
expectLastCall().andAnswer(new IAnswer<Object>() {
public Object answer() throws Throwable {
((Runnable) getCurrentArguments()[0]).run();
Mockito.doAnswer(new Answer<Void>() {
@Override
public Void answer(InvocationOnMock invocation) throws Throwable {
((Runnable) invocation.getArguments()[0]).run();
return null;
}
}).anyTimes();
}).when(taskExecutorMock).execute(Mockito.any(Runnable.class));
}
/*
* runs the runnable based on the array of passes
*/
private void partialFailingExecutorMock(boolean... passes) {
taskExecutorMock.execute(isA(Runnable.class));
for (final boolean pass : passes) {
expectLastCall().andAnswer(new IAnswer<Object>() {
public Object answer() throws Throwable {
if (pass) {
((Runnable) getCurrentArguments()[0]).run();
}
return null;
private void partialFailingExecutorMock(final boolean... passes) {
final AtomicInteger count = new AtomicInteger();
Mockito.doAnswer(new Answer<Void>() {
@Override
public Void answer(InvocationOnMock invocation) throws Throwable {
if (passes[count.getAndIncrement()]) {
((Runnable) invocation.getArguments()[0]).run();
}
});
}
return null;
}
}).when(taskExecutorMock).execute(Mockito.any(Runnable.class));
}
@@ -363,6 +314,6 @@ public class BroadcastingDispatcherTests {
public void handleMessage(Message<?> message) {
this.messageList.add(message);
}
};
}
}

63
spring-integration-core/src/test/java/org/springframework/integration/endpoint/PollingConsumerEndpointTests.java
View File

@@ -16,12 +16,6 @@
package org.springframework.integration.endpoint;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
@@ -34,6 +28,8 @@ import java.util.concurrent.atomic.AtomicInteger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.messaging.Message;
import org.springframework.integration.MessageRejectedException;
@@ -66,7 +62,7 @@ public class PollingConsumerEndpointTests {
private TestErrorHandler errorHandler = new TestErrorHandler();
private PollableChannel channelMock = createMock(PollableChannel.class);
private PollableChannel channelMock = Mockito.mock(PollableChannel.class);
private ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
@@ -84,7 +80,7 @@ public class PollingConsumerEndpointTests {
endpoint.setReceiveTimeout(-1);
endpoint.afterPropertiesSet();
taskScheduler.afterPropertiesSet();
reset(channelMock);
Mockito.reset(channelMock);
}
@After
@@ -95,58 +91,32 @@ public class PollingConsumerEndpointTests {
@Test
public void singleMessage() {
expect(channelMock.receive()).andReturn(message);
expectLastCall();
replay(channelMock);
Mockito.when(channelMock.receive()).thenReturn(message);
endpoint.setMaxMessagesPerPoll(1);
endpoint.setTrigger(trigger);
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals(1, consumer.counter.get());
verify(channelMock);
}
@Test
public void multipleMessages() {
expect(channelMock.receive()).andReturn(message).times(5);
replay(channelMock);
Mockito.when(channelMock.receive()).thenReturn(message, message, message, message, message);
endpoint.setMaxMessagesPerPoll(5);
endpoint.setTrigger(trigger);
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals(5, consumer.counter.get());
verify(channelMock);
}
@Test
public void multipleMessagesWithMaxMessagesAndTrigger() {
expect(channelMock.receive()).andReturn(message).times(5);
replay(channelMock);
endpoint.setMaxMessagesPerPoll(5);
endpoint.setTrigger(trigger);
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals(5, consumer.counter.get());
verify(channelMock);
}
@Test
public void multipleMessages_underrun() {
expect(channelMock.receive()).andReturn(message).times(5);
expect(channelMock.receive()).andReturn(null);
replay(channelMock);
Mockito.when(channelMock.receive()).thenReturn(message, message, message, message, message, null);
endpoint.setMaxMessagesPerPoll(6);
endpoint.setTrigger(trigger);
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals(5, consumer.counter.get());
verify(channelMock);
}
@Test
@@ -160,26 +130,21 @@ public class PollingConsumerEndpointTests {
@Test(expected = MessageRejectedException.class)
public void rejectedMessage() throws Throwable {
expect(channelMock.receive()).andReturn(badMessage);
replay(channelMock);
Mockito.when(channelMock.receive()).thenReturn(badMessage);
endpoint.start();
trigger.await();
endpoint.stop();
verify(channelMock);
assertEquals(1, consumer.counter.get());
errorHandler.throwLastErrorIfAvailable();
}
@Test(expected = MessageRejectedException.class)
public void droppedMessage_onePerPoll() throws Throwable {
expect(channelMock.receive()).andReturn(badMessage).times(1);
replay(channelMock);
Mockito.when(channelMock.receive()).thenReturn(badMessage);
endpoint.setMaxMessagesPerPoll(10);
endpoint.setTrigger(trigger);
endpoint.start();
trigger.await();
endpoint.stop();
verify(channelMock);
assertEquals(1, consumer.counter.get());
errorHandler.throwLastErrorIfAvailable();
}
@@ -187,29 +152,23 @@ public class PollingConsumerEndpointTests {
@Test
public void blockingSourceTimedOut() {
// we don't need to await the timeout, returning null suffices
expect(channelMock.receive(1)).andReturn(null);
replay(channelMock);
Mockito.when(channelMock.receive()).thenReturn(null);
endpoint.setReceiveTimeout(1);
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals(0, consumer.counter.get());
verify(channelMock);
}
@Test
public void blockingSourceNotTimedOut() {
expect(channelMock.receive(1)).andReturn(message);
expectLastCall();
replay(channelMock);
Mockito.when(channelMock.receive(Mockito.eq(1L))).thenReturn(message);
endpoint.setReceiveTimeout(1);
endpoint.setMaxMessagesPerPoll(1);
endpoint.setTrigger(trigger);
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals(1, consumer.counter.get());
verify(channelMock);
}

213
spring-integration-core/src/test/java/org/springframework/integration/gateway/MessagingGatewayTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,26 +16,21 @@
package org.springframework.integration.gateway;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.eq;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.getCurrentArguments;
import static org.easymock.EasyMock.isA;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import org.easymock.IAnswer;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.MessagingException;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.channel.PublishSubscribeChannel;
import org.springframework.integration.handler.ServiceActivatingHandler;
@@ -45,6 +40,8 @@ import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageDeliveryException;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.MessagingException;
import org.springframework.messaging.PollableChannel;
/**
@@ -57,15 +54,12 @@ public class MessagingGatewayTests {
private volatile MessagingGatewaySupport messagingGateway;
private volatile MessageChannel requestChannel = createMock(MessageChannel.class);
private volatile MessageChannel requestChannel = Mockito.mock(MessageChannel.class);
private volatile PollableChannel replyChannel = createMock(PollableChannel.class);
private volatile PollableChannel replyChannel = Mockito.mock(PollableChannel.class);
@SuppressWarnings("rawtypes")
private volatile Message messageMock = createMock(Message.class);
private final Object[] allmocks = new Object[] { requestChannel, replyChannel, messageMock };
private volatile Message messageMock = Mockito.mock(Message.class);
@Before
public void initializeSample() {
@@ -76,7 +70,6 @@ public class MessagingGatewayTests {
this.messagingGateway.setBeanFactory(applicationContext);
this.messagingGateway.afterPropertiesSet();
this.messagingGateway.start();
reset(allmocks);
applicationContext.refresh();
}
@@ -85,158 +78,170 @@ public class MessagingGatewayTests {
@Test
public void sendMessage() {
expect(requestChannel.send(messageMock, 1000L)).andReturn(true);
replay(allmocks);
Mockito.when(requestChannel.send(messageMock, 1000L)).thenReturn(true);
this.messagingGateway.send(messageMock);
verify(allmocks);
Mockito.verify(requestChannel).send(messageMock, 1000L);
}
@Test(expected=MessageDeliveryException.class)
public void sendMessage_failure() {
expect(messageMock.getHeaders()).andReturn(new MessageHeaders(null));
expect(requestChannel.send(messageMock, 1000)).andReturn(false);
replay(allmocks);
Mockito.when(messageMock.getHeaders()).thenReturn(new MessageHeaders(null));
Mockito.when(requestChannel.send(messageMock, 1000L)).thenReturn(false);
this.messagingGateway.send(messageMock);
verify(allmocks);
}
@Test
public void sendObject() {
expect(requestChannel.send(isA(Message.class), eq(1000L))).andAnswer(new IAnswer<Boolean>() {
public Boolean answer() throws Throwable {
assertEquals("test", ((Message<?>) getCurrentArguments()[0]).getPayload());
Mockito.doAnswer(new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
assertEquals("test", ((Message<?>) invocation.getArguments()[0]).getPayload());
return true;
}
});
replay(allmocks);
}).when(requestChannel).send(Mockito.any(Message.class), Mockito.eq(1000L));
this.messagingGateway.send("test");
verify(allmocks);
Mockito.verify(requestChannel).send(Mockito.any(Message.class), Mockito.eq(1000L));
}
@Test(expected=MessageDeliveryException.class)
public void sendObject_failure() {
expect(requestChannel.send(isA(Message.class), eq(1000L))).andAnswer(new IAnswer<Boolean>() {
public Boolean answer() throws Throwable {
assertEquals("test", ((Message<?>) getCurrentArguments()[0]).getPayload());
Mockito.doAnswer(new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
assertEquals("test", ((Message<?>) invocation.getArguments()[0]).getPayload());
return false;
}
});
replay(allmocks);
}).when(requestChannel).send(Mockito.any(Message.class), Mockito.eq(1000L));
this.messagingGateway.send("test");
verify(allmocks);
}
@Test(expected = IllegalArgumentException.class)
public void sendMessage_null() {
replay(allmocks);
try {
this.messagingGateway.send(null);
}
finally {
verify(allmocks);
}
this.messagingGateway.send(null);
}
/* receive tests */
@Test
public void receiveMessage() {
expect(replyChannel.receive(1000)).andReturn(messageMock);
expect(messageMock.getPayload()).andReturn("test").anyTimes();
replay(allmocks);
Mockito.when(replyChannel.receive(1000L)).thenReturn(messageMock);
Mockito.when(messageMock.getPayload()).thenReturn("test");
assertEquals("test", this.messagingGateway.receive());
verify(allmocks);
Mockito.verify(replyChannel).receive(1000L);
}
@Test
public void receiveMessage_null() {
expect(replyChannel.receive(1000)).andReturn(null);
replay(allmocks);
Mockito.when(replyChannel.receive(1000L)).thenReturn(null);
assertNull(this.messagingGateway.receive());
verify(allmocks);
Mockito.verify(replyChannel).receive(1000L);
}
/* send and receive tests */
@Test
public void sendObjectAndReceiveObject() {
expect(replyChannel.receive(100)).andReturn(messageMock);
expect(requestChannel.send(isA(Message.class), eq(1000L))).andReturn(true);
replay(allmocks);
Mockito.when(replyChannel.receive(100L)).thenReturn(messageMock);
Mockito.when(messageMock.getPayload()).thenReturn("test");
Mockito.doAnswer(new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
Message<?> message = (Message<?>) invocation.getArguments()[0];
MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel();
replyChannel.send(message);
return true;
}
}).when(requestChannel).send(Mockito.any(Message.class), Mockito.anyLong());
// TODO: if timeout is 0, this will fail occasionally
this.messagingGateway.setReplyTimeout(100);
this.messagingGateway.sendAndReceive("test");
verify(allmocks);
Object test = this.messagingGateway.sendAndReceive("test");
assertEquals("test", test);
}
@Test
@Ignore
public void sendMessageAndReceiveObject() {
// setup local mocks
MessageHeaders messageHeadersMock = createMock(MessageHeaders.class);
//set expectations
expect(replyChannel.receive(0)).andReturn(messageMock);
expect(messageMock.getHeaders()).andReturn(messageHeadersMock);
expect(requestChannel.send(messageMock)).andReturn(true);
expect(messageHeadersMock.getId()).andReturn(UUID.randomUUID());
Map<String, Object> headers = new HashMap<String, Object>();
headers.put(MessageHeaders.ID, UUID.randomUUID());
MessageHeaders messageHeadersMock = new MessageHeaders(headers);
Mockito.when(replyChannel.receive(0)).thenReturn(messageMock);
Mockito.when(messageMock.getHeaders()).thenReturn(messageHeadersMock);
Mockito.when(messageMock.getPayload()).thenReturn("foo");
Mockito.doAnswer(new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
Message<?> message = (Message<?>) invocation.getArguments()[0];
MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel();
replyChannel.send(message);
return true;
}
}).when(requestChannel).send(Mockito.any(Message.class), Mockito.anyLong());
//play scenario
replay(allmocks);
replay(messageHeadersMock);
this.messagingGateway.setReplyTimeout(0);
this.messagingGateway.sendAndReceive(messageMock);
verify(allmocks);
verify(messageHeadersMock);
Object o = this.messagingGateway.sendAndReceive(messageMock);
assertEquals("foo", o);
}
@Test(expected = IllegalArgumentException.class)
public void sendNullAndReceiveObject() {
replay(allmocks);
try {
this.messagingGateway.sendAndReceive(null);
}
finally {
verify(allmocks);
}
this.messagingGateway.sendAndReceive(null);
}
@Test
public void sendObjectAndReceiveMessage() {
expect(replyChannel.receive(100)).andReturn(messageMock);
expect(requestChannel.send(isA(Message.class), eq(1000L))).andReturn(true);
replay(allmocks);
Mockito.when(messageMock.getPayload()).thenReturn("foo");
Mockito.when(replyChannel.receive(100L)).thenReturn(messageMock);
Mockito.doAnswer(new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
Message<?> message = (Message<?>) invocation.getArguments()[0];
MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel();
replyChannel.send(messageMock);
return true;
}
}).when(requestChannel).send(Mockito.any(Message.class), Mockito.anyLong());
// TODO: commenting the next line causes the test to hang
this.messagingGateway.setReplyTimeout(100);
this.messagingGateway.sendAndReceiveMessage("test");
verify(allmocks);
this.messagingGateway.setReplyTimeout(100L);
Message<?> receiveMessage = this.messagingGateway.sendAndReceiveMessage("test");
assertSame(messageMock, receiveMessage);
}
@Test
@Ignore
public void sendMessageAndReceiveMessage() {
// setup local mocks
MessageHeaders messageHeadersMock = createMock(MessageHeaders.class);
//set expectations
expect(replyChannel.receive(0)).andReturn(messageMock);
expect(messageMock.getHeaders()).andReturn(messageHeadersMock);
expect(messageHeadersMock.getReplyChannel()).andReturn(replyChannel);
expect(requestChannel.send(messageMock)).andReturn(true);
expect(messageHeadersMock.getId()).andReturn(UUID.randomUUID());
Map<String, Object> headers = new HashMap<String, Object>();
headers.put(MessageHeaders.ID, UUID.randomUUID());
headers.put(MessageHeaders.REPLY_CHANNEL, replyChannel);
MessageHeaders messageHeadersMock = new MessageHeaders(headers);
Mockito.when(replyChannel.receive(Mockito.anyLong())).thenReturn(messageMock);
Mockito.when(messageMock.getHeaders()).thenReturn(messageHeadersMock);
Mockito.when(messageMock.getPayload()).thenReturn("foo");
Mockito.doAnswer(new Answer<Boolean>() {
replay(allmocks);
this.messagingGateway.sendAndReceiveMessage(messageMock);
verify(allmocks);
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
Message<?> message = (Message<?>) invocation.getArguments()[0];
MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel();
replyChannel.send(messageMock);
return true;
}
}).when(requestChannel).send(Mockito.any(Message.class), Mockito.anyLong());
Message<?> receiveMessage = this.messagingGateway.sendAndReceiveMessage(messageMock);
assertSame(messageMock, receiveMessage);
}
@Test(expected = IllegalArgumentException.class)
public void sendNullAndReceiveMessage() {
replay(allmocks);
try {
this.messagingGateway.sendAndReceiveMessage(null);
}
finally {
verify(allmocks);
}
this.messagingGateway.sendAndReceiveMessage(null);
}
// should fail but it doesn't now
@@ -288,7 +293,6 @@ public class MessagingGatewayTests {
this.messagingGateway.send("hello");
}
public static class MyErrorService {
public Message<?> handleErrorMessage(Message<?> errorMessage){
return errorMessage;
@@ -297,7 +301,6 @@ public class MessagingGatewayTests {
public static class MyOneWayErrorService {
public void handleErrorMessage(Message<?> errorMessage){
return;
}
}

84
spring-integration-core/src/test/java/org/springframework/integration/handler/MessageHandlerChainTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2011 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,56 +16,64 @@
package org.springframework.integration.handler;
import static org.easymock.EasyMock.*;
import java.util.ArrayList;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.integration.context.IntegrationObjectSupport;
import org.springframework.messaging.MessageHandler;
import org.springframework.integration.core.MessageProducer;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
/**
* @author Mark Fisher
* @author Iwein Fuld
* @author Gary Russell
* @author Artem Bilan
*/
@RunWith(MockitoJUnitRunner.class)
public class MessageHandlerChainTests {
private MessageChannel outputChannel = createMock(MessageChannel.class);
private final Message<String> message = MessageBuilder.withPayload("foo").build();
private Message<String> message = MessageBuilder.withPayload("foo").build();
@Mock
private MessageChannel outputChannel;
private MessageHandler handler1 = createMock(MessageHandler.class);
@Mock
private MessageHandler handler1;
private MessageHandler handler2 = createMock(MessageHandler.class);
@Mock
private MessageHandler handler2;
private MessageHandler handler3 = createMock(MessageHandler.class);
@Mock
private MessageHandler handler3;
private ProducingHandlerStub producer1 = new ProducingHandlerStub(handler1);
private ProducingHandlerStub producer1;
private ProducingHandlerStub producer2 = new ProducingHandlerStub(handler2);
private ProducingHandlerStub producer2;
private ProducingHandlerStub producer3 = new ProducingHandlerStub(handler3);
private ProducingHandlerStub producer3;
private Object[] allMocks = new Object[] { outputChannel, handler1, handler2, handler3 };
@Before
public void setup() {
Mockito.when(outputChannel.send(Mockito.any(Message.class))).thenReturn(true);
Mockito.when(outputChannel.send(Mockito.any(Message.class), Mockito.anyLong())).thenReturn(true);
producer1 = new ProducingHandlerStub(handler1);
producer2 = new ProducingHandlerStub(handler2);
producer3 = new ProducingHandlerStub(handler3);
}
@Test
public void chainWithOutputChannel() {
handler1.handleMessage(message);
expectLastCall();
handler2.handleMessage(message);
expectLastCall();
handler3.handleMessage(message);
expectLastCall();
expect(outputChannel.send(eq(message), eq(-1L))).andReturn(true);
replay(allMocks);
List<MessageHandler> handlers = new ArrayList<MessageHandler>();
handlers.add(producer1);
handlers.add(producer2);
@@ -75,11 +83,11 @@ public class MessageHandlerChainTests {
chain.setHandlers(handlers);
chain.setOutputChannel(outputChannel);
chain.handleMessage(message);
Mockito.verify(outputChannel).send(Mockito.eq(message), Mockito.eq(-1L));
}
@Test(expected = IllegalArgumentException.class)
public void chainWithOutputChannelButLastHandlerDoesNotProduceReplies() {
replay(allMocks);
List<MessageHandler> handlers = new ArrayList<MessageHandler>();
handlers.add(producer1);
handlers.add(producer2);
@@ -93,13 +101,6 @@ public class MessageHandlerChainTests {
@Test
public void chainWithoutOutputChannelButLastHandlerDoesNotProduceReplies() {
handler1.handleMessage(message);
expectLastCall();
handler2.handleMessage(message);
expectLastCall();
handler3.handleMessage(message);
expectLastCall();
replay(allMocks);
List<MessageHandler> handlers = new ArrayList<MessageHandler>();
handlers.add(producer1);
handlers.add(producer2);
@@ -113,15 +114,6 @@ public class MessageHandlerChainTests {
@Test
public void chainForwardsToReplyChannel() {
Message<String> message = MessageBuilder.withPayload("test").setReplyChannel(outputChannel).build();
handler1.handleMessage(message);
expectLastCall();
handler2.handleMessage(message);
expectLastCall();
handler3.handleMessage(message);
expectLastCall();
//equality is lost when recreating the message
expect(outputChannel.send(isA(Message.class))).andReturn(true);
replay(allMocks);
List<MessageHandler> handlers = new ArrayList<MessageHandler>();
handlers.add(producer1);
handlers.add(producer2);
@@ -130,19 +122,12 @@ public class MessageHandlerChainTests {
chain.setBeanName("testChain");
chain.setHandlers(handlers);
chain.handleMessage(message);
Mockito.verify(outputChannel).send(Mockito.any(Message.class));
}
@Test
public void chainResolvesReplyChannelName() {
Message<String> message = MessageBuilder.withPayload("test").setReplyChannelName("testChannel").build();
handler1.handleMessage(message);
expectLastCall();
handler2.handleMessage(message);
expectLastCall();
handler3.handleMessage(message);
expectLastCall();
expect(outputChannel.send(eq(message))).andReturn(true);
replay(allMocks);
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
beanFactory.registerSingleton("testChannel", outputChannel);
List<MessageHandler> handlers = new ArrayList<MessageHandler>();
@@ -154,6 +139,7 @@ public class MessageHandlerChainTests {
chain.setHandlers(handlers);
chain.setBeanFactory(beanFactory);
chain.handleMessage(message);
Mockito.verify(outputChannel).send(Mockito.eq(message));
}
@Test(expected = IllegalArgumentException.class) // INT-1175
@@ -181,11 +167,13 @@ public class MessageHandlerChainTests {
this.messageHandler = handler;
}
@Override
public void setOutputChannel(MessageChannel channel) {
this.output = channel;
}
@Override
public void handleMessage(Message<?> message) {
messageHandler.handleMessage(message);
output.send(message);

11
spring-integration-mail/src/test/java/org/springframework/integration/mail/MailReceivingMessageSourceTests.java
View File

@@ -23,23 +23,24 @@ import java.util.concurrent.ConcurrentLinkedQueue;
import javax.mail.internet.MimeMessage;
import org.easymock.EasyMock;
import org.junit.Test;
import org.mockito.Mockito;
/**
* @author Jonas Partner
* @author Mark Fisher
* @author Gary Russell
* @author Artem Bilan
*/
public class MailReceivingMessageSourceTests {
@Test
public void testPolling() {
StubMailReceiver mailReceiver = new StubMailReceiver();
MimeMessage message1 = EasyMock.createMock(MimeMessage.class);
MimeMessage message2 = EasyMock.createMock(MimeMessage.class);
MimeMessage message3 = EasyMock.createMock(MimeMessage.class);
MimeMessage message4 = EasyMock.createMock(MimeMessage.class);
MimeMessage message1 = Mockito.mock(MimeMessage.class);
MimeMessage message2 = Mockito.mock(MimeMessage.class);
MimeMessage message3 = Mockito.mock(MimeMessage.class);
MimeMessage message4 = Mockito.mock(MimeMessage.class);
mailReceiver.messages.add(new javax.mail.Message[] { message1 });
mailReceiver.messages.add(new javax.mail.Message[] { message2, message3 });

17
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/MailToStringTransformerParserTests.java
View File

@@ -22,8 +22,8 @@ import static org.junit.Assert.assertTrue;
import javax.mail.internet.MimeMessage;
import org.easymock.EasyMock;
import org.junit.Test;
import org.mockito.Mockito;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.context.support.ClassPathXmlApplicationContext;
@@ -36,6 +36,7 @@ import org.springframework.messaging.support.GenericMessage;
/**
* @author Mark Fisher
* @author Artem Bilan
*/
public class MailToStringTransformerParserTests {
@@ -45,14 +46,13 @@ public class MailToStringTransformerParserTests {
"mailToStringTransformerParserTests.xml", this.getClass());
MessageChannel input = new BeanFactoryChannelResolver(context).resolveDestination("input");
PollableChannel output = (PollableChannel) new BeanFactoryChannelResolver(context).resolveDestination("output");
MimeMessage mimeMessage = EasyMock.createNiceMock(MimeMessage.class);
EasyMock.expect(mimeMessage.getContent()).andReturn("hello");
EasyMock.replay(mimeMessage);
MimeMessage mimeMessage = Mockito.mock(MimeMessage.class);
Mockito.when(mimeMessage.getContent()).thenReturn("hello");
input.send(new GenericMessage<javax.mail.Message>(mimeMessage));
Message<?> result = output.receive(0);
assertNotNull(result);
assertEquals("hello", result.getPayload());
EasyMock.verify(mimeMessage);
Mockito.verify(mimeMessage).getContent();
}
@Test
@@ -61,14 +61,13 @@ public class MailToStringTransformerParserTests {
"mailToStringTransformerWithinChain.xml", this.getClass());
MessageChannel input = new BeanFactoryChannelResolver(context).resolveDestination("input");
PollableChannel output = (PollableChannel) new BeanFactoryChannelResolver(context).resolveDestination("output");
MimeMessage mimeMessage = EasyMock.createNiceMock(MimeMessage.class);
EasyMock.expect(mimeMessage.getContent()).andReturn("foo");
EasyMock.replay(mimeMessage);
MimeMessage mimeMessage = Mockito.mock(MimeMessage.class);
Mockito.when(mimeMessage.getContent()).thenReturn("foo");
input.send(new GenericMessage<javax.mail.Message>(mimeMessage));
Message<?> result = output.receive(0);
assertNotNull(result);
assertEquals("FOO!!!", result.getPayload());
EasyMock.verify(mimeMessage);
Mockito.verify(mimeMessage).getContent();
}
@Test(expected = BeanDefinitionStoreException.class)