diff --git a/build.gradle b/build.gradle index 77cc97961a..c714415cbc 100644 --- a/build.gradle +++ b/build.gradle @@ -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" diff --git a/spring-integration-core/src/test/java/org/springframework/integration/dispatcher/BroadcastingDispatcherTests.java b/spring-integration-core/src/test/java/org/springframework/integration/dispatcher/BroadcastingDispatcherTests.java index 1dd8d47b8f..51e92c0e2e 100644 --- a/spring-integration-core/src/test/java/org/springframework/integration/dispatcher/BroadcastingDispatcherTests.java +++ b/spring-integration-core/src/test/java/org/springframework/integration/dispatcher/BroadcastingDispatcherTests.java @@ -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 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() { - public Object answer() throws Throwable { - ((Runnable) getCurrentArguments()[0]).run(); + Mockito.doAnswer(new Answer() { + + @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() { - 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() { + + @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); } - }; + } } diff --git a/spring-integration-core/src/test/java/org/springframework/integration/endpoint/PollingConsumerEndpointTests.java b/spring-integration-core/src/test/java/org/springframework/integration/endpoint/PollingConsumerEndpointTests.java index cdc0097462..ca913088b9 100644 --- a/spring-integration-core/src/test/java/org/springframework/integration/endpoint/PollingConsumerEndpointTests.java +++ b/spring-integration-core/src/test/java/org/springframework/integration/endpoint/PollingConsumerEndpointTests.java @@ -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); } diff --git a/spring-integration-core/src/test/java/org/springframework/integration/gateway/MessagingGatewayTests.java b/spring-integration-core/src/test/java/org/springframework/integration/gateway/MessagingGatewayTests.java index 11e17d244b..1026e34e98 100644 --- a/spring-integration-core/src/test/java/org/springframework/integration/gateway/MessagingGatewayTests.java +++ b/spring-integration-core/src/test/java/org/springframework/integration/gateway/MessagingGatewayTests.java @@ -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() { - public Boolean answer() throws Throwable { - assertEquals("test", ((Message) getCurrentArguments()[0]).getPayload()); + Mockito.doAnswer(new Answer() { + + @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() { - public Boolean answer() throws Throwable { - assertEquals("test", ((Message) getCurrentArguments()[0]).getPayload()); + Mockito.doAnswer(new Answer() { + + @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() { + + @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 headers = new HashMap(); + 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() { + + @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() { + + @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 headers = new HashMap(); + 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() { - 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; } } diff --git a/spring-integration-core/src/test/java/org/springframework/integration/handler/MessageHandlerChainTests.java b/spring-integration-core/src/test/java/org/springframework/integration/handler/MessageHandlerChainTests.java index 540d7185b3..cc8aded47c 100644 --- a/spring-integration-core/src/test/java/org/springframework/integration/handler/MessageHandlerChainTests.java +++ b/spring-integration-core/src/test/java/org/springframework/integration/handler/MessageHandlerChainTests.java @@ -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 message = MessageBuilder.withPayload("foo").build(); - private Message 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 handlers = new ArrayList(); 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 handlers = new ArrayList(); 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 handlers = new ArrayList(); handlers.add(producer1); handlers.add(producer2); @@ -113,15 +114,6 @@ public class MessageHandlerChainTests { @Test public void chainForwardsToReplyChannel() { Message 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 handlers = new ArrayList(); 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 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 handlers = new ArrayList(); @@ -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); diff --git a/spring-integration-mail/src/test/java/org/springframework/integration/mail/MailReceivingMessageSourceTests.java b/spring-integration-mail/src/test/java/org/springframework/integration/mail/MailReceivingMessageSourceTests.java index 2c6bc25440..b34c954401 100644 --- a/spring-integration-mail/src/test/java/org/springframework/integration/mail/MailReceivingMessageSourceTests.java +++ b/spring-integration-mail/src/test/java/org/springframework/integration/mail/MailReceivingMessageSourceTests.java @@ -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 }); diff --git a/spring-integration-mail/src/test/java/org/springframework/integration/mail/config/MailToStringTransformerParserTests.java b/spring-integration-mail/src/test/java/org/springframework/integration/mail/config/MailToStringTransformerParserTests.java index 689d571b1f..12ca13d885 100644 --- a/spring-integration-mail/src/test/java/org/springframework/integration/mail/config/MailToStringTransformerParserTests.java +++ b/spring-integration-mail/src/test/java/org/springframework/integration/mail/config/MailToStringTransformerParserTests.java @@ -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(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(mimeMessage)); Message result = output.receive(0); assertNotNull(result); assertEquals("FOO!!!", result.getPayload()); - EasyMock.verify(mimeMessage); + Mockito.verify(mimeMessage).getContent(); } @Test(expected = BeanDefinitionStoreException.class)