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

Migrate JUnit 4 assertions to AssertJ

Browse Source 
Migrate all existing JUnit 4 `assert...` based assertions to AssertJ
and add a checkstyle rule to ensure they don't return.

See gh-23022
This commit is contained in:
Phillip Webb
2019-05-23 15:51:39 -07:00
parent 95a9d46a87
commit 9d74da006c
1636 changed files with 37861 additions and 40390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
spring-jms/src/test/java/org/springframework/jms/annotation/AbstractJmsAnnotationDrivenTests.java
View File

@@ -39,8 +39,7 @@ import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@@ -86,8 +85,8 @@ public abstract class AbstractJmsAnnotationDrivenTests {
context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
JmsListenerContainerTestFactory simpleFactory =
context.getBean("simpleFactory", JmsListenerContainerTestFactory.class);
assertEquals(1, defaultFactory.getListenerContainers().size());
assertEquals(1, simpleFactory.getListenerContainers().size());
assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(1);
}
/**
@@ -98,19 +97,19 @@ public abstract class AbstractJmsAnnotationDrivenTests {
public void testFullConfiguration(ApplicationContext context) {
JmsListenerContainerTestFactory simpleFactory =
context.getBean("simpleFactory", JmsListenerContainerTestFactory.class);
assertEquals(1, simpleFactory.getListenerContainers().size());
assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(1);
MethodJmsListenerEndpoint endpoint = (MethodJmsListenerEndpoint)
simpleFactory.getListenerContainers().get(0).getEndpoint();
assertEquals("listener1", endpoint.getId());
assertEquals("queueIn", endpoint.getDestination());
assertEquals("mySelector", endpoint.getSelector());
assertEquals("mySubscription", endpoint.getSubscription());
assertEquals("1-10", endpoint.getConcurrency());
assertThat(endpoint.getId()).isEqualTo("listener1");
assertThat(endpoint.getDestination()).isEqualTo("queueIn");
assertThat(endpoint.getSelector()).isEqualTo("mySelector");
assertThat(endpoint.getSubscription()).isEqualTo("mySubscription");
assertThat(endpoint.getConcurrency()).isEqualTo("1-10");
Method m = ReflectionUtils.findMethod(endpoint.getClass(), "getDefaultResponseDestination");
ReflectionUtils.makeAccessible(m);
Object destination = ReflectionUtils.invokeMethod(m, endpoint);
assertEquals("queueOut", destination);
assertThat(destination).isEqualTo("queueOut");
}
/**
@@ -123,23 +122,18 @@ public abstract class AbstractJmsAnnotationDrivenTests {
context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
JmsListenerContainerTestFactory customFactory =
context.getBean("customFactory", JmsListenerContainerTestFactory.class);
assertEquals(1, defaultFactory.getListenerContainers().size());
assertEquals(1, customFactory.getListenerContainers().size());
assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
assertThat(customFactory.getListenerContainers().size()).isEqualTo(1);
JmsListenerEndpoint endpoint = defaultFactory.getListenerContainers().get(0).getEndpoint();
assertEquals("Wrong endpoint type", SimpleJmsListenerEndpoint.class, endpoint.getClass());
assertEquals("Wrong listener set in custom endpoint", context.getBean("simpleMessageListener"),
((SimpleJmsListenerEndpoint) endpoint).getMessageListener());
assertThat(endpoint.getClass()).as("Wrong endpoint type").isEqualTo(SimpleJmsListenerEndpoint.class);
assertThat(((SimpleJmsListenerEndpoint) endpoint).getMessageListener()).as("Wrong listener set in custom endpoint").isEqualTo(context.getBean("simpleMessageListener"));
JmsListenerEndpointRegistry customRegistry =
context.getBean("customRegistry", JmsListenerEndpointRegistry.class);
assertEquals("Wrong number of containers in the registry", 2,
customRegistry.getListenerContainerIds().size());
assertEquals("Wrong number of containers in the registry", 2,
customRegistry.getListenerContainers().size());
assertNotNull("Container with custom id on the annotation should be found",
customRegistry.getListenerContainer("listenerId"));
assertNotNull("Container created with custom id should be found",
customRegistry.getListenerContainer("myCustomEndpointId"));
assertThat(customRegistry.getListenerContainerIds().size()).as("Wrong number of containers in the registry").isEqualTo(2);
assertThat(customRegistry.getListenerContainers().size()).as("Wrong number of containers in the registry").isEqualTo(2);
assertThat(customRegistry.getListenerContainer("listenerId")).as("Container with custom id on the annotation should be found").isNotNull();
assertThat(customRegistry.getListenerContainer("myCustomEndpointId")).as("Container created with custom id should be found").isNotNull();
}
/**
@@ -150,7 +144,7 @@ public abstract class AbstractJmsAnnotationDrivenTests {
public void testExplicitContainerFactoryConfiguration(ApplicationContext context) {
JmsListenerContainerTestFactory defaultFactory =
context.getBean("simpleFactory", JmsListenerContainerTestFactory.class);
assertEquals(1, defaultFactory.getListenerContainers().size());
assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
}
/**
@@ -160,7 +154,7 @@ public abstract class AbstractJmsAnnotationDrivenTests {
public void testDefaultContainerFactoryConfiguration(ApplicationContext context) {
JmsListenerContainerTestFactory defaultFactory =
context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
assertEquals(1, defaultFactory.getListenerContainers().size());
assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
}
/**
@@ -172,7 +166,7 @@ public abstract class AbstractJmsAnnotationDrivenTests {
public void testJmsHandlerMethodFactoryConfiguration(ApplicationContext context) throws JMSException {
JmsListenerContainerTestFactory simpleFactory =
context.getBean("defaultFactory", JmsListenerContainerTestFactory.class);
assertEquals(1, simpleFactory.getListenerContainers().size());
assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(1);
MethodJmsListenerEndpoint endpoint = (MethodJmsListenerEndpoint)
simpleFactory.getListenerContainers().get(0).getEndpoint();
@@ -189,19 +183,19 @@ public abstract class AbstractJmsAnnotationDrivenTests {
public void testJmsListenerRepeatable(ApplicationContext context) {
JmsListenerContainerTestFactory simpleFactory =
context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
assertEquals(2, simpleFactory.getListenerContainers().size());
assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(2);
MethodJmsListenerEndpoint first = (MethodJmsListenerEndpoint)
simpleFactory.getListenerContainer("first").getEndpoint();
assertEquals("first", first.getId());
assertEquals("myQueue", first.getDestination());
assertEquals(null, first.getConcurrency());
assertThat(first.getId()).isEqualTo("first");
assertThat(first.getDestination()).isEqualTo("myQueue");
assertThat(first.getConcurrency()).isEqualTo(null);
MethodJmsListenerEndpoint second = (MethodJmsListenerEndpoint)
simpleFactory.getListenerContainer("second").getEndpoint();
assertEquals("second", second.getId());
assertEquals("anotherQueue", second.getDestination());
assertEquals("2-10", second.getConcurrency());
assertThat(second.getId()).isEqualTo("second");
assertThat(second.getDestination()).isEqualTo("anotherQueue");
assertThat(second.getConcurrency()).isEqualTo("2-10");
}

37
spring-jms/src/test/java/org/springframework/jms/annotation/EnableJmsTests.java
View File

@@ -45,11 +45,8 @@ import org.springframework.messaging.handler.annotation.support.MessageHandlerMe
import org.springframework.messaging.handler.annotation.support.MethodArgumentNotValidException;
import org.springframework.stereotype.Component;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
/**
* @author Stephane Nicoll
@@ -111,8 +108,8 @@ public class EnableJmsTests extends AbstractJmsAnnotationDrivenTests {
JmsListenerContainerTestFactory factory =
context.getBean(JmsListenerContainerTestFactory.class);
MessageListenerTestContainer container = factory.getListenerContainers().get(0);
assertTrue(container.isAutoStartup());
assertTrue(container.isStarted());
assertThat(container.isAutoStartup()).isTrue();
assertThat(container.isStarted()).isTrue();
}
@Test
@@ -122,11 +119,11 @@ public class EnableJmsTests extends AbstractJmsAnnotationDrivenTests {
JmsListenerContainerTestFactory factory =
context.getBean(JmsListenerContainerTestFactory.class);
MessageListenerTestContainer container = factory.getListenerContainers().get(0);
assertFalse(container.isAutoStartup());
assertFalse(container.isStarted());
assertThat(container.isAutoStartup()).isFalse();
assertThat(container.isStarted()).isFalse();
JmsListenerEndpointRegistry registry = context.getBean(JmsListenerEndpointRegistry.class);
registry.start();
assertTrue(container.isStarted());
assertThat(container.isStarted()).isTrue();
}
@Override
@@ -162,19 +159,19 @@ public class EnableJmsTests extends AbstractJmsAnnotationDrivenTests {
EnableJmsDefaultContainerFactoryConfig.class, ComposedJmsListenersBean.class)) {
JmsListenerContainerTestFactory simpleFactory = context.getBean("jmsListenerContainerFactory",
JmsListenerContainerTestFactory.class);
assertEquals(2, simpleFactory.getListenerContainers().size());
assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(2);
MethodJmsListenerEndpoint first = (MethodJmsListenerEndpoint) simpleFactory.getListenerContainer(
"first").getEndpoint();
assertEquals("first", first.getId());
assertEquals("orderQueue", first.getDestination());
assertNull(first.getConcurrency());
assertThat(first.getId()).isEqualTo("first");
assertThat(first.getDestination()).isEqualTo("orderQueue");
assertThat(first.getConcurrency()).isNull();
MethodJmsListenerEndpoint second = (MethodJmsListenerEndpoint) simpleFactory.getListenerContainer(
"second").getEndpoint();
assertEquals("second", second.getId());
assertEquals("billingQueue", second.getDestination());
assertEquals("2-10", second.getConcurrency());
assertThat(second.getId()).isEqualTo("second");
assertThat(second.getDestination()).isEqualTo("billingQueue");
assertThat(second.getConcurrency()).isEqualTo("2-10");
}
}
@@ -193,14 +190,14 @@ public class EnableJmsTests extends AbstractJmsAnnotationDrivenTests {
EnableJmsDefaultContainerFactoryConfig.class, LazyBean.class);
JmsListenerContainerTestFactory defaultFactory =
context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
assertEquals(0, defaultFactory.getListenerContainers().size());
assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(0);
context.getBean(LazyBean.class); // trigger lazy resolution
assertEquals(1, defaultFactory.getListenerContainers().size());
assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
MessageListenerTestContainer container = defaultFactory.getListenerContainers().get(0);
assertTrue("Should have been started " + container, container.isStarted());
assertThat(container.isStarted()).as("Should have been started " + container).isTrue();
context.close(); // close and stop the listeners
assertTrue("Should have been stopped " + container, container.isStopped());
assertThat(container.isStopped()).as("Should have been stopped " + container).isTrue();
}

70
spring-jms/src/test/java/org/springframework/jms/annotation/JmsListenerAnnotationBeanPostProcessorTests.java
View File

@@ -45,10 +45,8 @@ import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
/**
@@ -63,25 +61,23 @@ public class JmsListenerAnnotationBeanPostProcessorTests {
Config.class, SimpleMessageListenerTestBean.class);
JmsListenerContainerTestFactory factory = context.getBean(JmsListenerContainerTestFactory.class);
assertEquals("One container should have been registered", 1, factory.getListenerContainers().size());
assertThat(factory.getListenerContainers().size()).as("One container should have been registered").isEqualTo(1);
MessageListenerTestContainer container = factory.getListenerContainers().get(0);
JmsListenerEndpoint endpoint = container.getEndpoint();
assertEquals("Wrong endpoint type", MethodJmsListenerEndpoint.class, endpoint.getClass());
assertThat(endpoint.getClass()).as("Wrong endpoint type").isEqualTo(MethodJmsListenerEndpoint.class);
MethodJmsListenerEndpoint methodEndpoint = (MethodJmsListenerEndpoint) endpoint;
assertEquals(SimpleMessageListenerTestBean.class, methodEndpoint.getBean().getClass());
assertEquals(SimpleMessageListenerTestBean.class.getMethod("handleIt", String.class),
methodEndpoint.getMethod());
assertEquals(SimpleMessageListenerTestBean.class.getMethod("handleIt", String.class),
methodEndpoint.getMostSpecificMethod());
assertThat(methodEndpoint.getBean().getClass()).isEqualTo(SimpleMessageListenerTestBean.class);
assertThat(methodEndpoint.getMethod()).isEqualTo(SimpleMessageListenerTestBean.class.getMethod("handleIt", String.class));
assertThat(methodEndpoint.getMostSpecificMethod()).isEqualTo(SimpleMessageListenerTestBean.class.getMethod("handleIt", String.class));
SimpleMessageListenerContainer listenerContainer = new SimpleMessageListenerContainer();
methodEndpoint.setupListenerContainer(listenerContainer);
assertNotNull(listenerContainer.getMessageListener());
assertThat(listenerContainer.getMessageListener()).isNotNull();
assertTrue("Should have been started " + container, container.isStarted());
assertThat(container.isStarted()).as("Should have been started " + container).isTrue();
context.close(); // Close and stop the listeners
assertTrue("Should have been stopped " + container, container.isStopped());
assertThat(container.isStopped()).as("Should have been stopped " + container).isTrue();
}
@Test
@@ -91,17 +87,15 @@ public class JmsListenerAnnotationBeanPostProcessorTests {
try {
JmsListenerContainerTestFactory factory = context.getBean(JmsListenerContainerTestFactory.class);
assertEquals("one container should have been registered", 1, factory.getListenerContainers().size());
assertThat(factory.getListenerContainers().size()).as("one container should have been registered").isEqualTo(1);
JmsListenerEndpoint endpoint = factory.getListenerContainers().get(0).getEndpoint();
assertEquals("Wrong endpoint type", MethodJmsListenerEndpoint.class, endpoint.getClass());
assertThat(endpoint.getClass()).as("Wrong endpoint type").isEqualTo(MethodJmsListenerEndpoint.class);
MethodJmsListenerEndpoint methodEndpoint = (MethodJmsListenerEndpoint) endpoint;
assertEquals(MetaAnnotationTestBean.class, methodEndpoint.getBean().getClass());
assertEquals(MetaAnnotationTestBean.class.getMethod("handleIt", String.class),
methodEndpoint.getMethod());
assertEquals(MetaAnnotationTestBean.class.getMethod("handleIt", String.class),
methodEndpoint.getMostSpecificMethod());
assertEquals("metaTestQueue", ((AbstractJmsListenerEndpoint) endpoint).getDestination());
assertThat(methodEndpoint.getBean().getClass()).isEqualTo(MetaAnnotationTestBean.class);
assertThat(methodEndpoint.getMethod()).isEqualTo(MetaAnnotationTestBean.class.getMethod("handleIt", String.class));
assertThat(methodEndpoint.getMostSpecificMethod()).isEqualTo(MetaAnnotationTestBean.class.getMethod("handleIt", String.class));
assertThat(((AbstractJmsListenerEndpoint) endpoint).getDestination()).isEqualTo("metaTestQueue");
}
finally {
context.close();
@@ -114,22 +108,21 @@ public class JmsListenerAnnotationBeanPostProcessorTests {
Config.class, ProxyConfig.class, InterfaceProxyTestBean.class);
try {
JmsListenerContainerTestFactory factory = context.getBean(JmsListenerContainerTestFactory.class);
assertEquals("one container should have been registered", 1, factory.getListenerContainers().size());
assertThat(factory.getListenerContainers().size()).as("one container should have been registered").isEqualTo(1);
JmsListenerEndpoint endpoint = factory.getListenerContainers().get(0).getEndpoint();
assertEquals("Wrong endpoint type", MethodJmsListenerEndpoint.class, endpoint.getClass());
assertThat(endpoint.getClass()).as("Wrong endpoint type").isEqualTo(MethodJmsListenerEndpoint.class);
MethodJmsListenerEndpoint methodEndpoint = (MethodJmsListenerEndpoint) endpoint;
assertTrue(AopUtils.isJdkDynamicProxy(methodEndpoint.getBean()));
assertTrue(methodEndpoint.getBean() instanceof SimpleService);
assertEquals(SimpleService.class.getMethod("handleIt", String.class, String.class),
methodEndpoint.getMethod());
assertEquals(InterfaceProxyTestBean.class.getMethod("handleIt", String.class, String.class),
methodEndpoint.getMostSpecificMethod());
assertThat(AopUtils.isJdkDynamicProxy(methodEndpoint.getBean())).isTrue();
boolean condition = methodEndpoint.getBean() instanceof SimpleService;
assertThat(condition).isTrue();
assertThat(methodEndpoint.getMethod()).isEqualTo(SimpleService.class.getMethod("handleIt", String.class, String.class));
assertThat(methodEndpoint.getMostSpecificMethod()).isEqualTo(InterfaceProxyTestBean.class.getMethod("handleIt", String.class, String.class));
Method method = ReflectionUtils.findMethod(endpoint.getClass(), "getDefaultResponseDestination");
ReflectionUtils.makeAccessible(method);
Object destination = ReflectionUtils.invokeMethod(method, endpoint);
assertEquals("SendTo annotation not found on proxy", "foobar", destination);
assertThat(destination).as("SendTo annotation not found on proxy").isEqualTo("foobar");
}
finally {
context.close();
@@ -142,22 +135,21 @@ public class JmsListenerAnnotationBeanPostProcessorTests {
Config.class, ProxyConfig.class, ClassProxyTestBean.class);
try {
JmsListenerContainerTestFactory factory = context.getBean(JmsListenerContainerTestFactory.class);
assertEquals("one container should have been registered", 1, factory.getListenerContainers().size());
assertThat(factory.getListenerContainers().size()).as("one container should have been registered").isEqualTo(1);
JmsListenerEndpoint endpoint = factory.getListenerContainers().get(0).getEndpoint();
assertEquals("Wrong endpoint type", MethodJmsListenerEndpoint.class, endpoint.getClass());
assertThat(endpoint.getClass()).as("Wrong endpoint type").isEqualTo(MethodJmsListenerEndpoint.class);
MethodJmsListenerEndpoint methodEndpoint = (MethodJmsListenerEndpoint) endpoint;
assertTrue(AopUtils.isCglibProxy(methodEndpoint.getBean()));
assertTrue(methodEndpoint.getBean() instanceof ClassProxyTestBean);
assertEquals(ClassProxyTestBean.class.getMethod("handleIt", String.class, String.class),
methodEndpoint.getMethod());
assertEquals(ClassProxyTestBean.class.getMethod("handleIt", String.class, String.class),
methodEndpoint.getMostSpecificMethod());
assertThat(AopUtils.isCglibProxy(methodEndpoint.getBean())).isTrue();
boolean condition = methodEndpoint.getBean() instanceof ClassProxyTestBean;
assertThat(condition).isTrue();
assertThat(methodEndpoint.getMethod()).isEqualTo(ClassProxyTestBean.class.getMethod("handleIt", String.class, String.class));
assertThat(methodEndpoint.getMostSpecificMethod()).isEqualTo(ClassProxyTestBean.class.getMethod("handleIt", String.class, String.class));
Method method = ReflectionUtils.findMethod(endpoint.getClass(), "getDefaultResponseDestination");
ReflectionUtils.makeAccessible(method);
Object destination = ReflectionUtils.invokeMethod(method, endpoint);
assertEquals("SendTo annotation not found on proxy", "foobar", destination);
assertThat(destination).as("SendTo annotation not found on proxy").isEqualTo("foobar");
}
finally {
context.close();

9
spring-jms/src/test/java/org/springframework/jms/config/JmsListenerContainerFactoryIntegrationTests.java
View File

@@ -41,8 +41,7 @@ import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
import org.springframework.util.ReflectionUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@@ -136,7 +135,7 @@ public class JmsListenerContainerFactoryIntegrationTests {
}
private void assertListenerMethodInvocation(String methodName) {
assertTrue("Method " + methodName + " should have been invoked", sample.invocations.get(methodName));
assertThat((boolean) sample.invocations.get(methodName)).as("Method " + methodName + " should have been invoked").isTrue();
}
private MethodJmsListenerEndpoint createMethodJmsEndpoint(DefaultMessageHandlerMethodFactory factory, Method method) {
@@ -169,8 +168,8 @@ public class JmsListenerContainerFactoryIntegrationTests {
public void handleIt(@Payload String msg, @Header("my-header") String myHeader) {
invocations.put("handleIt", true);
assertEquals("Unexpected payload message", "FOO-BAR", msg);
assertEquals("Unexpected header value", "my-value", myHeader);
assertThat(msg).as("Unexpected payload message").isEqualTo("FOO-BAR");
assertThat(myHeader).as("Unexpected header value").isEqualTo("my-value");
}
}

70
spring-jms/src/test/java/org/springframework/jms/config/JmsListenerContainerFactoryTests.java
View File

@@ -40,10 +40,8 @@ import org.springframework.jms.support.destination.DynamicDestinationResolver;
import org.springframework.util.backoff.BackOff;
import org.springframework.util.backoff.FixedBackOff;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.mockito.Mockito.mock;
/**
@@ -73,8 +71,8 @@ public class JmsListenerContainerFactoryTests {
SimpleMessageListenerContainer container = factory.createListenerContainer(endpoint);
assertDefaultJmsConfig(container);
assertEquals(messageListener, container.getMessageListener());
assertEquals("myQueue", container.getDestinationName());
assertThat(container.getMessageListener()).isEqualTo(messageListener);
assertThat(container.getDestinationName()).isEqualTo("myQueue");
}
@Test
@@ -92,13 +90,13 @@ public class JmsListenerContainerFactoryTests {
DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);
assertDefaultJmsConfig(container);
assertEquals(DefaultMessageListenerContainer.CACHE_CONSUMER, container.getCacheLevel());
assertEquals(3, container.getConcurrentConsumers());
assertEquals(10, container.getMaxConcurrentConsumers());
assertEquals(5, container.getMaxMessagesPerTask());
assertThat(container.getCacheLevel()).isEqualTo(DefaultMessageListenerContainer.CACHE_CONSUMER);
assertThat(container.getConcurrentConsumers()).isEqualTo(3);
assertThat(container.getMaxConcurrentConsumers()).isEqualTo(10);
assertThat(container.getMaxMessagesPerTask()).isEqualTo(5);
assertEquals(messageListener, container.getMessageListener());
assertEquals("myQueue", container.getDestinationName());
assertThat(container.getMessageListener()).isEqualTo(messageListener);
assertThat(container.getDestinationName()).isEqualTo("myQueue");
}
@Test
@@ -114,9 +112,9 @@ public class JmsListenerContainerFactoryTests {
JmsMessageEndpointManager container = factory.createListenerContainer(endpoint);
assertDefaultJcaConfig(container);
assertEquals(10, container.getActivationSpecConfig().getMaxConcurrency());
assertEquals(messageListener, container.getMessageListener());
assertEquals("myQueue", container.getActivationSpecConfig().getDestinationName());
assertThat(container.getActivationSpecConfig().getMaxConcurrency()).isEqualTo(10);
assertThat(container.getMessageListener()).isEqualTo(messageListener);
assertThat(container.getActivationSpecConfig().getDestinationName()).isEqualTo("myQueue");
}
@Test
@@ -144,7 +142,7 @@ public class JmsListenerContainerFactoryTests {
endpoint.setDestination("myQueue");
DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);
assertSame(backOff, new DirectFieldAccessor(container).getPropertyValue("backOff"));
assertThat(new DirectFieldAccessor(container).getPropertyValue("backOff")).isSameAs(backOff);
}
@Test
@@ -158,8 +156,8 @@ public class JmsListenerContainerFactoryTests {
endpoint.setDestination("myQueue");
endpoint.setConcurrency("4-6");
DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);
assertEquals(4, container.getConcurrentConsumers());
assertEquals(6, container.getMaxConcurrentConsumers());
assertThat(container.getConcurrentConsumers()).isEqualTo(4);
assertThat(container.getMaxConcurrentConsumers()).isEqualTo(6);
}
@@ -178,17 +176,17 @@ public class JmsListenerContainerFactoryTests {
}
private void assertDefaultJmsConfig(AbstractMessageListenerContainer container) {
assertEquals(this.connectionFactory, container.getConnectionFactory());
assertEquals(this.destinationResolver, container.getDestinationResolver());
assertEquals(this.messageConverter, container.getMessageConverter());
assertEquals(true, container.isSessionTransacted());
assertEquals(Session.DUPS_OK_ACKNOWLEDGE, container.getSessionAcknowledgeMode());
assertEquals(true, container.isPubSubDomain());
assertEquals(true, container.isReplyPubSubDomain());
assertEquals(new QosSettings(1, 7, 5000), container.getReplyQosSettings());
assertEquals(true, container.isSubscriptionDurable());
assertEquals("client-1234", container.getClientId());
assertEquals(false, container.isAutoStartup());
assertThat(container.getConnectionFactory()).isEqualTo(this.connectionFactory);
assertThat(container.getDestinationResolver()).isEqualTo(this.destinationResolver);
assertThat(container.getMessageConverter()).isEqualTo(this.messageConverter);
assertThat(container.isSessionTransacted()).isEqualTo(true);
assertThat(container.getSessionAcknowledgeMode()).isEqualTo(Session.DUPS_OK_ACKNOWLEDGE);
assertThat(container.isPubSubDomain()).isEqualTo(true);
assertThat(container.isReplyPubSubDomain()).isEqualTo(true);
assertThat(container.getReplyQosSettings()).isEqualTo(new QosSettings(1, 7, 5000));
assertThat(container.isSubscriptionDurable()).isEqualTo(true);
assertThat(container.getClientId()).isEqualTo("client-1234");
assertThat(container.isAutoStartup()).isEqualTo(false);
}
private void setDefaultJcaConfig(DefaultJcaListenerContainerFactory factory) {
@@ -203,15 +201,15 @@ public class JmsListenerContainerFactoryTests {
}
private void assertDefaultJcaConfig(JmsMessageEndpointManager container) {
assertEquals(this.messageConverter, container.getMessageConverter());
assertEquals(this.destinationResolver, container.getDestinationResolver());
assertThat(container.getMessageConverter()).isEqualTo(this.messageConverter);
assertThat(container.getDestinationResolver()).isEqualTo(this.destinationResolver);
JmsActivationSpecConfig config = container.getActivationSpecConfig();
assertNotNull(config);
assertEquals(Session.DUPS_OK_ACKNOWLEDGE, config.getAcknowledgeMode());
assertEquals(true, config.isPubSubDomain());
assertEquals(new QosSettings(1, 7, 5000), container.getReplyQosSettings());
assertEquals(true, config.isSubscriptionDurable());
assertEquals("client-1234", config.getClientId());
assertThat(config).isNotNull();
assertThat(config.getAcknowledgeMode()).isEqualTo(Session.DUPS_OK_ACKNOWLEDGE);
assertThat(config.isPubSubDomain()).isEqualTo(true);
assertThat(container.getReplyQosSettings()).isEqualTo(new QosSettings(1, 7, 5000));
assertThat(config.isSubscriptionDurable()).isEqualTo(true);
assertThat(config.getClientId()).isEqualTo("client-1234");
}
}

15
spring-jms/src/test/java/org/springframework/jms/config/JmsListenerEndpointRegistrarTests.java
View File

@@ -21,10 +21,9 @@ import org.junit.Test;
import org.springframework.beans.factory.support.StaticListableBeanFactory;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
/**
* @author Stephane Nicoll
@@ -73,9 +72,9 @@ public class JmsListenerEndpointRegistrarTests {
this.registrar.setContainerFactory(this.containerFactory);
this.registrar.registerEndpoint(endpoint, null);
this.registrar.afterPropertiesSet();
assertNotNull("Container not created", this.registry.getListenerContainer("some id"));
assertEquals(1, this.registry.getListenerContainers().size());
assertEquals("some id", this.registry.getListenerContainerIds().iterator().next());
assertThat(this.registry.getListenerContainer("some id")).as("Container not created").isNotNull();
assertThat(this.registry.getListenerContainers().size()).isEqualTo(1);
assertThat(this.registry.getListenerContainerIds().iterator().next()).isEqualTo("some id");
}
@Test
@@ -96,9 +95,9 @@ public class JmsListenerEndpointRegistrarTests {
this.registrar.setContainerFactory(this.containerFactory);
this.registrar.registerEndpoint(endpoint);
this.registrar.afterPropertiesSet();
assertNotNull("Container not created", this.registry.getListenerContainer("myEndpoint"));
assertEquals(1, this.registry.getListenerContainers().size());
assertEquals("myEndpoint", this.registry.getListenerContainerIds().iterator().next());
assertThat(this.registry.getListenerContainer("myEndpoint")).as("Container not created").isNotNull();
assertThat(this.registry.getListenerContainers().size()).isEqualTo(1);
assertThat(this.registry.getListenerContainerIds().iterator().next()).isEqualTo("myEndpoint");
}
}

26
spring-jms/src/test/java/org/springframework/jms/config/JmsListenerEndpointTests.java
View File

@@ -28,9 +28,9 @@ import org.springframework.jms.listener.adapter.MessageListenerAdapter;
import org.springframework.jms.listener.endpoint.JmsActivationSpecConfig;
import org.springframework.jms.listener.endpoint.JmsMessageEndpointManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
/**
@@ -50,12 +50,12 @@ public class JmsListenerEndpointTests {
endpoint.setMessageListener(messageListener);
endpoint.setupListenerContainer(container);
assertEquals("myQueue", container.getDestinationName());
assertEquals("foo = 'bar'", container.getMessageSelector());
assertEquals("mySubscription", container.getSubscriptionName());
assertEquals(5, container.getConcurrentConsumers());
assertEquals(10, container.getMaxConcurrentConsumers());
assertEquals(messageListener, container.getMessageListener());
assertThat(container.getDestinationName()).isEqualTo("myQueue");
assertThat(container.getMessageSelector()).isEqualTo("foo = 'bar'");
assertThat(container.getSubscriptionName()).isEqualTo("mySubscription");
assertThat(container.getConcurrentConsumers()).isEqualTo(5);
assertThat(container.getMaxConcurrentConsumers()).isEqualTo(10);
assertThat(container.getMessageListener()).isEqualTo(messageListener);
}
@Test
@@ -71,11 +71,11 @@ public class JmsListenerEndpointTests {
endpoint.setupListenerContainer(container);
JmsActivationSpecConfig config = container.getActivationSpecConfig();
assertEquals("myQueue", config.getDestinationName());
assertEquals("foo = 'bar'", config.getMessageSelector());
assertEquals("mySubscription", config.getSubscriptionName());
assertEquals(10, config.getMaxConcurrency());
assertEquals(messageListener, container.getMessageListener());
assertThat(config.getDestinationName()).isEqualTo("myQueue");
assertThat(config.getMessageSelector()).isEqualTo("foo = 'bar'");
assertThat(config.getSubscriptionName()).isEqualTo("mySubscription");
assertThat(config.getMaxConcurrency()).isEqualTo(10);
assertThat(container.getMessageListener()).isEqualTo(messageListener);
}
@Test
@@ -87,7 +87,7 @@ public class JmsListenerEndpointTests {
endpoint.setMessageListener(messageListener);
endpoint.setupListenerContainer(container);
assertEquals(10, new DirectFieldAccessor(container).getPropertyValue("concurrentConsumers"));
assertThat(new DirectFieldAccessor(container).getPropertyValue("concurrentConsumers")).isEqualTo(10);
}
@Test

180
spring-jms/src/test/java/org/springframework/jms/config/JmsNamespaceHandlerTests.java
View File

@@ -48,11 +48,7 @@ import org.springframework.util.ErrorHandler;
import org.springframework.util.backoff.BackOff;
import org.springframework.util.backoff.FixedBackOff;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -85,14 +81,14 @@ public class JmsNamespaceHandlerTests {
@Test
public void testBeansCreated() {
Map<String, ?> containers = context.getBeansOfType(DefaultMessageListenerContainer.class);
assertEquals("Context should contain 3 JMS listener containers", 3, containers.size());
assertThat(containers.size()).as("Context should contain 3 JMS listener containers").isEqualTo(3);
containers = context.getBeansOfType(GenericMessageEndpointManager.class);
assertEquals("Context should contain 3 JCA endpoint containers", 3, containers.size());
assertThat(containers.size()).as("Context should contain 3 JCA endpoint containers").isEqualTo(3);
Map<String, JmsListenerContainerFactory> containerFactories =
context.getBeansOfType(JmsListenerContainerFactory.class);
assertEquals("Context should contain 3 JmsListenerContainerFactory instances", 3, containerFactories.size());
assertThat(containerFactories.size()).as("Context should contain 3 JmsListenerContainerFactory instances").isEqualTo(3);
}
@Test
@@ -113,33 +109,28 @@ public class JmsNamespaceHandlerTests {
}
}
assertEquals("1 container should have the default connectionFactory", 1, defaultConnectionFactoryCount);
assertEquals("2 containers should have the explicit connectionFactory", 2, explicitConnectionFactoryCount);
assertThat(defaultConnectionFactoryCount).as("1 container should have the default connectionFactory").isEqualTo(1);
assertThat(explicitConnectionFactoryCount).as("2 containers should have the explicit connectionFactory").isEqualTo(2);
}
@Test
public void testJcaContainerConfiguration() throws Exception {
Map<String, JmsMessageEndpointManager> containers = context.getBeansOfType(JmsMessageEndpointManager.class);
assertTrue("listener3 not found", containers.containsKey("listener3"));
assertThat(containers.containsKey("listener3")).as("listener3 not found").isTrue();
JmsMessageEndpointManager listener3 = containers.get("listener3");
assertEquals("Wrong resource adapter",
context.getBean("testResourceAdapter"), listener3.getResourceAdapter());
assertEquals("Wrong activation spec factory", context.getBean("testActivationSpecFactory"),
new DirectFieldAccessor(listener3).getPropertyValue("activationSpecFactory"));
assertThat(listener3.getResourceAdapter()).as("Wrong resource adapter").isEqualTo(context.getBean("testResourceAdapter"));
assertThat(new DirectFieldAccessor(listener3).getPropertyValue("activationSpecFactory")).as("Wrong activation spec factory").isEqualTo(context.getBean("testActivationSpecFactory"));
Object endpointFactory = new DirectFieldAccessor(listener3).getPropertyValue("endpointFactory");
Object messageListener = new DirectFieldAccessor(endpointFactory).getPropertyValue("messageListener");
assertEquals("Wrong message listener", MessageListenerAdapter.class, messageListener.getClass());
assertThat(messageListener.getClass()).as("Wrong message listener").isEqualTo(MessageListenerAdapter.class);
MessageListenerAdapter adapter = (MessageListenerAdapter) messageListener;
DirectFieldAccessor adapterFieldAccessor = new DirectFieldAccessor(adapter);
assertEquals("Message converter not set properly", context.getBean("testMessageConverter"),
adapterFieldAccessor.getPropertyValue("messageConverter"));
assertEquals("Wrong delegate", context.getBean("testBean1"),
adapterFieldAccessor.getPropertyValue("delegate"));
assertEquals("Wrong method name", "setName",
adapterFieldAccessor.getPropertyValue("defaultListenerMethod"));
assertThat(adapterFieldAccessor.getPropertyValue("messageConverter")).as("Message converter not set properly").isEqualTo(context.getBean("testMessageConverter"));
assertThat(adapterFieldAccessor.getPropertyValue("delegate")).as("Wrong delegate").isEqualTo(context.getBean("testBean1"));
assertThat(adapterFieldAccessor.getPropertyValue("defaultListenerMethod")).as("Wrong method name").isEqualTo("setName");
}
@Test
@@ -147,24 +138,21 @@ public class JmsNamespaceHandlerTests {
Map<String, DefaultJmsListenerContainerFactory> containers =
context.getBeansOfType(DefaultJmsListenerContainerFactory.class);
DefaultJmsListenerContainerFactory factory = containers.get("testJmsFactory");
assertNotNull("No factory registered with testJmsFactory id", factory);
assertThat(factory).as("No factory registered with testJmsFactory id").isNotNull();
DefaultMessageListenerContainer container =
factory.createListenerContainer(createDummyEndpoint());
assertEquals("explicit connection factory not set",
context.getBean(EXPLICIT_CONNECTION_FACTORY), container.getConnectionFactory());
assertEquals("explicit destination resolver not set",
context.getBean("testDestinationResolver"), container.getDestinationResolver());
assertEquals("explicit message converter not set",
context.getBean("testMessageConverter"), container.getMessageConverter());
assertEquals("Wrong pub/sub", true, container.isPubSubDomain());
assertEquals("Wrong durable flag", true, container.isSubscriptionDurable());
assertEquals("wrong cache", DefaultMessageListenerContainer.CACHE_CONNECTION, container.getCacheLevel());
assertEquals("wrong concurrency", 3, container.getConcurrentConsumers());
assertEquals("wrong concurrency", 5, container.getMaxConcurrentConsumers());
assertEquals("wrong prefetch", 50, container.getMaxMessagesPerTask());
assertEquals("Wrong phase", 99, container.getPhase());
assertSame(context.getBean("testBackOff"), new DirectFieldAccessor(container).getPropertyValue("backOff"));
assertThat(container.getConnectionFactory()).as("explicit connection factory not set").isEqualTo(context.getBean(EXPLICIT_CONNECTION_FACTORY));
assertThat(container.getDestinationResolver()).as("explicit destination resolver not set").isEqualTo(context.getBean("testDestinationResolver"));
assertThat(container.getMessageConverter()).as("explicit message converter not set").isEqualTo(context.getBean("testMessageConverter"));
assertThat(container.isPubSubDomain()).as("Wrong pub/sub").isEqualTo(true);
assertThat(container.isSubscriptionDurable()).as("Wrong durable flag").isEqualTo(true);
assertThat(container.getCacheLevel()).as("wrong cache").isEqualTo(DefaultMessageListenerContainer.CACHE_CONNECTION);
assertThat(container.getConcurrentConsumers()).as("wrong concurrency").isEqualTo(3);
assertThat(container.getMaxConcurrentConsumers()).as("wrong concurrency").isEqualTo(5);
assertThat(container.getMaxMessagesPerTask()).as("wrong prefetch").isEqualTo(50);
assertThat(container.getPhase()).as("Wrong phase").isEqualTo(99);
assertThat(new DirectFieldAccessor(container).getPropertyValue("backOff")).isSameAs(context.getBean("testBackOff"));
}
@Test
@@ -172,18 +160,16 @@ public class JmsNamespaceHandlerTests {
Map<String, DefaultJcaListenerContainerFactory> containers =
context.getBeansOfType(DefaultJcaListenerContainerFactory.class);
DefaultJcaListenerContainerFactory factory = containers.get("testJcaFactory");
assertNotNull("No factory registered with testJcaFactory id", factory);
assertThat(factory).as("No factory registered with testJcaFactory id").isNotNull();
JmsMessageEndpointManager container =
factory.createListenerContainer(createDummyEndpoint());
assertEquals("explicit resource adapter not set",
context.getBean("testResourceAdapter"),container.getResourceAdapter());
assertEquals("explicit message converter not set",
context.getBean("testMessageConverter"), container.getActivationSpecConfig().getMessageConverter());
assertEquals("Wrong pub/sub", true, container.isPubSubDomain());
assertEquals("wrong concurrency", 5, container.getActivationSpecConfig().getMaxConcurrency());
assertEquals("Wrong prefetch", 50, container.getActivationSpecConfig().getPrefetchSize());
assertEquals("Wrong phase", 77, container.getPhase());
assertThat(container.getResourceAdapter()).as("explicit resource adapter not set").isEqualTo(context.getBean("testResourceAdapter"));
assertThat(container.getActivationSpecConfig().getMessageConverter()).as("explicit message converter not set").isEqualTo(context.getBean("testMessageConverter"));
assertThat(container.isPubSubDomain()).as("Wrong pub/sub").isEqualTo(true);
assertThat(container.getActivationSpecConfig().getMaxConcurrency()).as("wrong concurrency").isEqualTo(5);
assertThat(container.getActivationSpecConfig().getPrefetchSize()).as("Wrong prefetch").isEqualTo(50);
assertThat(container.getPhase()).as("Wrong phase").isEqualTo(77);
}
@Test
@@ -192,29 +178,29 @@ public class JmsNamespaceHandlerTests {
TestBean testBean2 = context.getBean("testBean2", TestBean.class);
TestMessageListener testBean3 = context.getBean("testBean3", TestMessageListener.class);
assertNull(testBean1.getName());
assertNull(testBean2.getName());
assertNull(testBean3.message);
assertThat(testBean1.getName()).isNull();
assertThat(testBean2.getName()).isNull();
assertThat(testBean3.message).isNull();
TextMessage message1 = mock(TextMessage.class);
given(message1.getText()).willReturn("Test1");
MessageListener listener1 = getListener("listener1");
listener1.onMessage(message1);
assertEquals("Test1", testBean1.getName());
assertThat(testBean1.getName()).isEqualTo("Test1");
TextMessage message2 = mock(TextMessage.class);
given(message2.getText()).willReturn("Test2");
MessageListener listener2 = getListener("listener2");
listener2.onMessage(message2);
assertEquals("Test2", testBean2.getName());
assertThat(testBean2.getName()).isEqualTo("Test2");
TextMessage message3 = mock(TextMessage.class);
MessageListener listener3 = getListener(DefaultMessageListenerContainer.class.getName() + "#0");
listener3.onMessage(message3);
assertSame(message3, testBean3.message);
assertThat(testBean3.message).isSameAs(message3);
}
@Test
@@ -224,9 +210,9 @@ public class JmsNamespaceHandlerTests {
BackOff backOff2 = getBackOff("listener2");
long recoveryInterval3 = getRecoveryInterval(DefaultMessageListenerContainer.class.getName() + "#0");
assertSame(testBackOff, backOff1);
assertSame(testBackOff, backOff2);
assertEquals(DefaultMessageListenerContainer.DEFAULT_RECOVERY_INTERVAL, recoveryInterval3);
assertThat(backOff1).isSameAs(testBackOff);
assertThat(backOff2).isSameAs(testBackOff);
assertThat(recoveryInterval3).isEqualTo(DefaultMessageListenerContainer.DEFAULT_RECOVERY_INTERVAL);
}
@Test
@@ -239,22 +225,20 @@ public class JmsNamespaceHandlerTests {
DefaultMessageListenerContainer listener2 = this.context
.getBean("listener2", DefaultMessageListenerContainer.class);
assertEquals("Wrong concurrency on listener using placeholder", 2, listener0.getConcurrentConsumers());
assertEquals("Wrong concurrency on listener using placeholder", 3, listener0.getMaxConcurrentConsumers());
assertEquals("Wrong concurrency on listener1", 3, listener1.getConcurrentConsumers());
assertEquals("Wrong max concurrency on listener1", 5, listener1.getMaxConcurrentConsumers());
assertEquals("Wrong custom concurrency on listener2", 5, listener2.getConcurrentConsumers());
assertEquals("Wrong custom max concurrency on listener2", 10, listener2.getMaxConcurrentConsumers());
assertThat(listener0.getConcurrentConsumers()).as("Wrong concurrency on listener using placeholder").isEqualTo(2);
assertThat(listener0.getMaxConcurrentConsumers()).as("Wrong concurrency on listener using placeholder").isEqualTo(3);
assertThat(listener1.getConcurrentConsumers()).as("Wrong concurrency on listener1").isEqualTo(3);
assertThat(listener1.getMaxConcurrentConsumers()).as("Wrong max concurrency on listener1").isEqualTo(5);
assertThat(listener2.getConcurrentConsumers()).as("Wrong custom concurrency on listener2").isEqualTo(5);
assertThat(listener2.getMaxConcurrentConsumers()).as("Wrong custom max concurrency on listener2").isEqualTo(10);
// JCA
JmsMessageEndpointManager listener3 = this.context
.getBean("listener3", JmsMessageEndpointManager.class);
JmsMessageEndpointManager listener4 = this.context
.getBean("listener4", JmsMessageEndpointManager.class);
assertEquals("Wrong concurrency on listener3", 5,
listener3.getActivationSpecConfig().getMaxConcurrency());
assertEquals("Wrong custom concurrency on listener4", 7,
listener4.getActivationSpecConfig().getMaxConcurrency());
assertThat(listener3.getActivationSpecConfig().getMaxConcurrency()).as("Wrong concurrency on listener3").isEqualTo(5);
assertThat(listener4.getActivationSpecConfig().getMaxConcurrency()).as("Wrong custom concurrency on listener4").isEqualTo(7);
}
@Test
@@ -264,20 +248,20 @@ public class JmsNamespaceHandlerTests {
.getBean("listener1", DefaultMessageListenerContainer.class);
DefaultMessageListenerContainer listener2 = this.context
.getBean("listener2", DefaultMessageListenerContainer.class);
assertEquals("Wrong destination type on listener1", true, listener1.isPubSubDomain());
assertEquals("Wrong destination type on listener2", true, listener2.isPubSubDomain());
assertEquals("Wrong response destination type on listener1", false, listener1.isReplyPubSubDomain());
assertEquals("Wrong response destination type on listener2", false, listener2.isReplyPubSubDomain());
assertThat(listener1.isPubSubDomain()).as("Wrong destination type on listener1").isEqualTo(true);
assertThat(listener2.isPubSubDomain()).as("Wrong destination type on listener2").isEqualTo(true);
assertThat(listener1.isReplyPubSubDomain()).as("Wrong response destination type on listener1").isEqualTo(false);
assertThat(listener2.isReplyPubSubDomain()).as("Wrong response destination type on listener2").isEqualTo(false);
// JCA
JmsMessageEndpointManager listener3 = this.context
.getBean("listener3", JmsMessageEndpointManager.class);
JmsMessageEndpointManager listener4 = this.context
.getBean("listener4", JmsMessageEndpointManager.class);
assertEquals("Wrong destination type on listener3", true, listener3.isPubSubDomain());
assertEquals("Wrong destination type on listener4", true, listener4.isPubSubDomain());
assertEquals("Wrong response destination type on listener3", false, listener3.isReplyPubSubDomain());
assertEquals("Wrong response destination type on listener4", false, listener4.isReplyPubSubDomain());
assertThat(listener3.isPubSubDomain()).as("Wrong destination type on listener3").isEqualTo(true);
assertThat(listener4.isPubSubDomain()).as("Wrong destination type on listener4").isEqualTo(true);
assertThat(listener3.isReplyPubSubDomain()).as("Wrong response destination type on listener3").isEqualTo(false);
assertThat(listener4.isReplyPubSubDomain()).as("Wrong response destination type on listener4").isEqualTo(false);
}
@Test
@@ -286,9 +270,9 @@ public class JmsNamespaceHandlerTests {
ErrorHandler errorHandler1 = getErrorHandler("listener1");
ErrorHandler errorHandler2 = getErrorHandler("listener2");
ErrorHandler defaultErrorHandler = getErrorHandler(DefaultMessageListenerContainer.class.getName() + "#0");
assertSame(expected, errorHandler1);
assertSame(expected, errorHandler2);
assertNull(defaultErrorHandler);
assertThat(errorHandler1).isSameAs(expected);
assertThat(errorHandler2).isSameAs(expected);
assertThat(defaultErrorHandler).isNull();
}
@Test
@@ -298,33 +282,25 @@ public class JmsNamespaceHandlerTests {
int phase3 = getPhase("listener3");
int phase4 = getPhase("listener4");
int defaultPhase = getPhase(DefaultMessageListenerContainer.class.getName() + "#0");
assertEquals(99, phase1);
assertEquals(99, phase2);
assertEquals(77, phase3);
assertEquals(77, phase4);
assertEquals(Integer.MAX_VALUE, defaultPhase);
assertThat(phase1).isEqualTo(99);
assertThat(phase2).isEqualTo(99);
assertThat(phase3).isEqualTo(77);
assertThat(phase4).isEqualTo(77);
assertThat(defaultPhase).isEqualTo(Integer.MAX_VALUE);
}
@Test
public void testComponentRegistration() {
assertTrue("Parser should have registered a component named 'listener1'",
context.containsComponentDefinition("listener1"));
assertTrue("Parser should have registered a component named 'listener2'",
context.containsComponentDefinition("listener2"));
assertTrue("Parser should have registered a component named 'listener3'",
context.containsComponentDefinition("listener3"));
assertTrue("Parser should have registered a component named '"
+ DefaultMessageListenerContainer.class.getName() + "#0'",
context.containsComponentDefinition(DefaultMessageListenerContainer.class.getName() + "#0"));
assertTrue("Parser should have registered a component named '"
+ JmsMessageEndpointManager.class.getName() + "#0'",
context.containsComponentDefinition(JmsMessageEndpointManager.class.getName() + "#0"));
assertTrue("Parser should have registered a component named 'testJmsFactory",
context.containsComponentDefinition("testJmsFactory"));
assertTrue("Parser should have registered a component named 'testJcaFactory",
context.containsComponentDefinition("testJcaFactory"));
assertTrue("Parser should have registered a component named 'testJcaFactory",
context.containsComponentDefinition("onlyJmsFactory"));
assertThat(context.containsComponentDefinition("listener1")).as("Parser should have registered a component named 'listener1'").isTrue();
assertThat(context.containsComponentDefinition("listener2")).as("Parser should have registered a component named 'listener2'").isTrue();
assertThat(context.containsComponentDefinition("listener3")).as("Parser should have registered a component named 'listener3'").isTrue();
assertThat(context.containsComponentDefinition(DefaultMessageListenerContainer.class.getName() + "#0")).as("Parser should have registered a component named '"
+ DefaultMessageListenerContainer.class.getName() + "#0'").isTrue();
assertThat(context.containsComponentDefinition(JmsMessageEndpointManager.class.getName() + "#0")).as("Parser should have registered a component named '"
+ JmsMessageEndpointManager.class.getName() + "#0'").isTrue();
assertThat(context.containsComponentDefinition("testJmsFactory")).as("Parser should have registered a component named 'testJmsFactory").isTrue();
assertThat(context.containsComponentDefinition("testJcaFactory")).as("Parser should have registered a component named 'testJcaFactory").isTrue();
assertThat(context.containsComponentDefinition("onlyJmsFactory")).as("Parser should have registered a component named 'testJcaFactory").isTrue();
}
@Test
@@ -332,7 +308,7 @@ public class JmsNamespaceHandlerTests {
Iterator<ComponentDefinition> iterator = context.getRegisteredComponents();
while (iterator.hasNext()) {
ComponentDefinition compDef = iterator.next();
assertNotNull("CompositeComponentDefinition '" + compDef.getName() + "' has no source attachment", compDef.getSource());
assertThat(compDef.getSource()).as("CompositeComponentDefinition '" + compDef.getName() + "' has no source attachment").isNotNull();
validateComponentDefinition(compDef);
}
}
@@ -341,7 +317,7 @@ public class JmsNamespaceHandlerTests {
private void validateComponentDefinition(ComponentDefinition compDef) {
BeanDefinition[] beanDefs = compDef.getBeanDefinitions();
for (BeanDefinition beanDef : beanDefs) {
assertNotNull("BeanDefinition has no source attachment", beanDef.getSource());
assertThat(beanDef.getSource()).as("BeanDefinition has no source attachment").isNotNull();
}
}
@@ -362,7 +338,7 @@ public class JmsNamespaceHandlerTests {
private long getRecoveryInterval(String containerBeanName) {
BackOff backOff = getBackOff(containerBeanName);
assertEquals(FixedBackOff.class, backOff.getClass());
assertThat(backOff.getClass()).isEqualTo(FixedBackOff.class);
return ((FixedBackOff)backOff).getInterval();
}

63
spring-jms/src/test/java/org/springframework/jms/config/MethodJmsListenerEndpointTests.java
View File

@@ -62,12 +62,9 @@ import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -111,7 +108,7 @@ public class MethodJmsListenerEndpointTests {
endpoint.setMethod(getTestMethod());
endpoint.setMessageHandlerMethodFactory(this.factory);
assertNotNull(endpoint.createMessageListener(this.container));
assertThat(endpoint.createMessageListener(this.container)).isNotNull();
}
@Test
@@ -124,8 +121,8 @@ public class MethodJmsListenerEndpointTests {
MessagingMessageListenerAdapter listener = createInstance(this.factory,
getListenerMethod("resolveObjectPayload", MyBean.class), this.container);
DirectFieldAccessor accessor = new DirectFieldAccessor(listener);
assertSame(messageConverter, accessor.getPropertyValue("messageConverter"));
assertSame(destinationResolver, accessor.getPropertyValue("destinationResolver"));
assertThat(accessor.getPropertyValue("messageConverter")).isSameAs(messageConverter);
assertThat(accessor.getPropertyValue("destinationResolver")).isSameAs(destinationResolver);
}
@Test
@@ -477,7 +474,7 @@ public class MethodJmsListenerEndpointTests {
private Method getListenerMethod(String methodName, Class<?>... parameterTypes) {
Method method = ReflectionUtils.findMethod(JmsEndpointSampleBean.class, methodName, parameterTypes);
assertNotNull("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes));
assertThat(("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes))).isNotNull();
return method;
}
@@ -490,7 +487,7 @@ public class MethodJmsListenerEndpointTests {
}
private void assertListenerMethodInvocation(JmsEndpointSampleBean bean, String methodName) {
assertTrue("Method " + methodName + " should have been invoked", bean.invocations.get(methodName));
assertThat((boolean) bean.invocations.get(methodName)).as("Method " + methodName + " should have been invoked").isTrue();
}
private void initializeFactory(DefaultMessageHandlerMethodFactory factory) {
@@ -526,66 +523,66 @@ public class MethodJmsListenerEndpointTests {
public void resolveMessageAndSession(javax.jms.Message message, Session session) {
this.invocations.put("resolveMessageAndSession", true);
assertNotNull("Message not injected", message);
assertNotNull("Session not injected", session);
assertThat(message).as("Message not injected").isNotNull();
assertThat(session).as("Session not injected").isNotNull();
}
public void resolveGenericMessage(Message<String> message) {
this.invocations.put("resolveGenericMessage", true);
assertNotNull("Generic message not injected", message);
assertEquals("Wrong message payload", "test", message.getPayload());
assertThat(message).as("Generic message not injected").isNotNull();
assertThat(message.getPayload()).as("Wrong message payload").isEqualTo("test");
}
public void resolveHeaderAndPayload(@Payload String content, @Header int myCounter) {
this.invocations.put("resolveHeaderAndPayload", true);
assertEquals("Wrong @Payload resolution", "my payload", content);
assertEquals("Wrong @Header resolution", 55, myCounter);
assertThat(content).as("Wrong @Payload resolution").isEqualTo("my payload");
assertThat(myCounter).as("Wrong @Header resolution").isEqualTo(55);
}
public void resolveCustomHeaderNameAndPayload(@Payload String content, @Header("myCounter") int counter) {
this.invocations.put("resolveCustomHeaderNameAndPayload", true);
assertEquals("Wrong @Payload resolution", "my payload", content);
assertEquals("Wrong @Header resolution", 24, counter);
assertThat(content).as("Wrong @Payload resolution").isEqualTo("my payload");
assertThat(counter).as("Wrong @Header resolution").isEqualTo(24);
}
public void resolveCustomHeaderNameAndPayloadWithHeaderNameSet(@Payload String content, @Header(name = "myCounter") int counter) {
this.invocations.put("resolveCustomHeaderNameAndPayloadWithHeaderNameSet", true);
assertEquals("Wrong @Payload resolution", "my payload", content);
assertEquals("Wrong @Header resolution", 24, counter);
assertThat(content).as("Wrong @Payload resolution").isEqualTo("my payload");
assertThat(counter).as("Wrong @Header resolution").isEqualTo(24);
}
public void resolveHeaders(String content, @Headers Map<String, Object> headers) {
this.invocations.put("resolveHeaders", true);
assertEquals("Wrong payload resolution", "my payload", content);
assertNotNull("headers not injected", headers);
assertEquals("Missing JMS message id header", "abcd-1234", headers.get(JmsHeaders.MESSAGE_ID));
assertEquals("Missing custom header", 1234, headers.get("customInt"));
assertThat(content).as("Wrong payload resolution").isEqualTo("my payload");
assertThat(headers).as("headers not injected").isNotNull();
assertThat(headers.get(JmsHeaders.MESSAGE_ID)).as("Missing JMS message id header").isEqualTo("abcd-1234");
assertThat(headers.get("customInt")).as("Missing custom header").isEqualTo(1234);
}
public void resolveMessageHeaders(MessageHeaders headers) {
this.invocations.put("resolveMessageHeaders", true);
assertNotNull("MessageHeaders not injected", headers);
assertEquals("Missing JMS message type header", "myMessageType", headers.get(JmsHeaders.TYPE));
assertEquals("Missing custom header", 4567L, (long) headers.get("customLong"), 0.0);
assertThat(headers).as("MessageHeaders not injected").isNotNull();
assertThat(headers.get(JmsHeaders.TYPE)).as("Missing JMS message type header").isEqualTo("myMessageType");
assertThat((long) headers.get("customLong")).as("Missing custom header").isEqualTo(4567);
}
public void resolveJmsMessageHeaderAccessor(JmsMessageHeaderAccessor headers) {
this.invocations.put("resolveJmsMessageHeaderAccessor", true);
assertNotNull("MessageHeaders not injected", headers);
assertEquals("Missing JMS message priority header", Integer.valueOf(9), headers.getPriority());
assertEquals("Missing custom header", true, headers.getHeader("customBoolean"));
assertThat(headers).as("MessageHeaders not injected").isNotNull();
assertThat(headers.getPriority()).as("Missing JMS message priority header").isEqualTo(Integer.valueOf(9));
assertThat(headers.getHeader("customBoolean")).as("Missing custom header").isEqualTo(true);
}
public void resolveObjectPayload(MyBean bean) {
this.invocations.put("resolveObjectPayload", true);
assertNotNull("Object payload not injected", bean);
assertEquals("Wrong content for payload", "myBean name", bean.name);
assertThat(bean).as("Object payload not injected").isNotNull();
assertThat(bean.name).as("Wrong content for payload").isEqualTo("myBean name");
}
public void resolveConvertedPayload(Integer counter) {
this.invocations.put("resolveConvertedPayload", true);
assertNotNull("Payload not injected", counter);
assertEquals("Wrong content for payload", Integer.valueOf(33), counter);
assertThat(counter).as("Payload not injected").isNotNull();
assertThat(counter).as("Wrong content for payload").isEqualTo(Integer.valueOf(33));
}
public String processAndReply(@Payload String content) {

4
spring-jms/src/test/java/org/springframework/jms/config/SimpleJmsListenerEndpointTests.java
View File

@@ -23,7 +23,7 @@ import org.junit.Test;
import org.springframework.jms.listener.SimpleMessageListenerContainer;
import org.springframework.jms.listener.adapter.MessageListenerAdapter;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Stephane Nicoll
@@ -38,7 +38,7 @@ public class SimpleJmsListenerEndpointTests {
SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
MessageListener messageListener = new MessageListenerAdapter();
endpoint.setMessageListener(messageListener);
assertSame(messageListener, endpoint.createMessageListener(container));
assertThat(endpoint.createMessageListener(container)).isSameAs(messageListener);
}
}

35
spring-jms/src/test/java/org/springframework/jms/connection/JmsTransactionManagerTests.java
View File

@@ -38,11 +38,8 @@ import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -56,8 +53,8 @@ public class JmsTransactionManagerTests {
@After
public void verifyTransactionSynchronizationManagerState() {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@@ -74,7 +71,7 @@ public class JmsTransactionManagerTests {
TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
JmsTemplate jt = new JmsTemplate(cf);
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
tm.commit(ts);
@@ -97,7 +94,7 @@ public class JmsTransactionManagerTests {
TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
JmsTemplate jt = new JmsTemplate(cf);
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
tm.rollback(ts);
@@ -120,7 +117,7 @@ public class JmsTransactionManagerTests {
TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
final JmsTemplate jt = new JmsTemplate(cf);
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
TransactionTemplate tt = new TransactionTemplate(tm);
@@ -128,7 +125,7 @@ public class JmsTransactionManagerTests {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
}
@@ -153,7 +150,7 @@ public class JmsTransactionManagerTests {
TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
final JmsTemplate jt = new JmsTemplate(cf);
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
TransactionTemplate tt = new TransactionTemplate(tm);
@@ -161,7 +158,7 @@ public class JmsTransactionManagerTests {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
status.setRollbackOnly();
@@ -190,7 +187,7 @@ public class JmsTransactionManagerTests {
TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
final JmsTemplate jt = new JmsTemplate(cf);
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
TransactionTemplate tt = new TransactionTemplate(tm);
@@ -199,13 +196,13 @@ public class JmsTransactionManagerTests {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
jt.execute((SessionCallback<Void>) sess -> {
assertNotSame(sess, session);
assertThat(session).isNotSameAs(sess);
return null;
});
}
});
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
tm.commit(ts);
@@ -230,7 +227,7 @@ public class JmsTransactionManagerTests {
TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
final JmsTemplate jt = new JmsTemplate(cf);
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
TransactionTemplate tt = new TransactionTemplate(tm);
@@ -239,13 +236,13 @@ public class JmsTransactionManagerTests {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
jt.execute((SessionCallback<Void>) sess -> {
assertNotSame(sess, session);
assertThat(session).isNotSameAs(sess);
return null;
});
}
});
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
tm.commit(ts);
@@ -300,7 +297,7 @@ public class JmsTransactionManagerTests {
JmsTemplate jt = new JmsTemplate(cf);
jt.execute((SessionCallback<Void>) sess -> {
assertSame(sess, session);
assertThat(session).isSameAs(sess);
return null;
});
tm.commit(ts);

48
spring-jms/src/test/java/org/springframework/jms/connection/SingleConnectionFactoryTests.java
View File

@@ -30,9 +30,7 @@ import javax.jms.TopicSession;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -285,7 +283,7 @@ public class SingleConnectionFactoryTests {
SingleConnectionFactory scf = new SingleConnectionFactory(cf);
scf.setExceptionListener(listener);
Connection con1 = scf.createConnection();
assertEquals(listener, con1.getExceptionListener());
assertThat(con1.getExceptionListener()).isEqualTo(listener);
con1.start();
con1.stop();
con1.close();
@@ -310,15 +308,15 @@ public class SingleConnectionFactoryTests {
SingleConnectionFactory scf = new SingleConnectionFactory(cf);
scf.setReconnectOnException(true);
Connection con1 = scf.createConnection();
assertNull(con1.getExceptionListener());
assertThat(con1.getExceptionListener()).isNull();
con1.start();
con.getExceptionListener().onException(new JMSException(""));
Connection con2 = scf.createConnection();
con2.start();
scf.destroy(); // should trigger actual close
assertEquals(2, con.getStartCount());
assertEquals(2, con.getCloseCount());
assertThat(con.getStartCount()).isEqualTo(2);
assertThat(con.getCloseCount()).isEqualTo(2);
}
@Test
@@ -332,16 +330,16 @@ public class SingleConnectionFactoryTests {
scf.setExceptionListener(listener);
scf.setReconnectOnException(true);
Connection con1 = scf.createConnection();
assertSame(listener, con1.getExceptionListener());
assertThat(con1.getExceptionListener()).isSameAs(listener);
con1.start();
con.getExceptionListener().onException(new JMSException(""));
Connection con2 = scf.createConnection();
con2.start();
scf.destroy(); // should trigger actual close
assertEquals(2, con.getStartCount());
assertEquals(2, con.getCloseCount());
assertEquals(1, listener.getCount());
assertThat(con.getStartCount()).isEqualTo(2);
assertThat(con.getCloseCount()).isEqualTo(2);
assertThat(listener.getCount()).isEqualTo(1);
}
@Test
@@ -364,10 +362,10 @@ public class SingleConnectionFactoryTests {
scf.setExceptionListener(listener0);
Connection con1 = scf.createConnection();
con1.setExceptionListener(listener1);
assertSame(listener1, con1.getExceptionListener());
assertThat(con1.getExceptionListener()).isSameAs(listener1);
Connection con2 = scf.createConnection();
con2.setExceptionListener(listener2);
assertSame(listener2, con2.getExceptionListener());
assertThat(con2.getExceptionListener()).isSameAs(listener2);
con.getExceptionListener().onException(new JMSException(""));
con2.close();
con.getExceptionListener().onException(new JMSException(""));
@@ -375,11 +373,11 @@ public class SingleConnectionFactoryTests {
con.getExceptionListener().onException(new JMSException(""));
scf.destroy(); // should trigger actual close
assertEquals(0, con.getStartCount());
assertEquals(1, con.getCloseCount());
assertEquals(3, listener0.getCount());
assertEquals(2, listener1.getCount());
assertEquals(1, listener2.getCount());
assertThat(con.getStartCount()).isEqualTo(0);
assertThat(con.getCloseCount()).isEqualTo(1);
assertThat(listener0.getCount()).isEqualTo(3);
assertThat(listener1.getCount()).isEqualTo(2);
assertThat(listener2.getCount()).isEqualTo(1);
}
@Test
@@ -397,11 +395,11 @@ public class SingleConnectionFactoryTests {
scf.setExceptionListener(listener0);
Connection con1 = scf.createConnection();
con1.setExceptionListener(listener1);
assertSame(listener1, con1.getExceptionListener());
assertThat(con1.getExceptionListener()).isSameAs(listener1);
con1.start();
Connection con2 = scf.createConnection();
con2.setExceptionListener(listener2);
assertSame(listener2, con2.getExceptionListener());
assertThat(con2.getExceptionListener()).isSameAs(listener2);
con.getExceptionListener().onException(new JMSException(""));
con2.close();
con1.getMetaData();
@@ -409,11 +407,11 @@ public class SingleConnectionFactoryTests {
con1.close();
scf.destroy(); // should trigger actual close
assertEquals(2, con.getStartCount());
assertEquals(2, con.getCloseCount());
assertEquals(2, listener0.getCount());
assertEquals(2, listener1.getCount());
assertEquals(1, listener2.getCount());
assertThat(con.getStartCount()).isEqualTo(2);
assertThat(con.getCloseCount()).isEqualTo(2);
assertThat(listener0.getCount()).isEqualTo(2);
assertThat(listener1.getCount()).isEqualTo(2);
assertThat(listener2.getCount()).isEqualTo(1);
}
@Test

53
spring-jms/src/test/java/org/springframework/jms/core/JmsMessagingTemplateTests.java
View File

@@ -48,12 +48,9 @@ import org.springframework.messaging.MessagingException;
import org.springframework.messaging.converter.GenericMessageConverter;
import org.springframework.messaging.support.MessageBuilder;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
@@ -87,7 +84,7 @@ public class JmsMessagingTemplateTests {
@Test
public void validateJmsTemplate() {
assertSame(this.jmsTemplate, this.messagingTemplate.getJmsTemplate());
assertThat(this.messagingTemplate.getJmsTemplate()).isSameAs(this.jmsTemplate);
}
@Test
@@ -125,10 +122,10 @@ public class JmsMessagingTemplateTests {
private void assertPayloadConverter(JmsMessagingTemplate messagingTemplate,
MessageConverter messageConverter) {
MessageConverter jmsMessageConverter = messagingTemplate.getJmsMessageConverter();
assertNotNull(jmsMessageConverter);
assertEquals(MessagingMessageConverter.class, jmsMessageConverter.getClass());
assertSame(messageConverter, new DirectFieldAccessor(jmsMessageConverter)
.getPropertyValue("payloadConverter"));
assertThat(jmsMessageConverter).isNotNull();
assertThat(jmsMessageConverter.getClass()).isEqualTo(MessagingMessageConverter.class);
assertThat(new DirectFieldAccessor(jmsMessageConverter)
.getPropertyValue("payloadConverter")).isSameAs(messageConverter);
}
@Test
@@ -199,7 +196,7 @@ public class JmsMessagingTemplateTests {
this.messagingTemplate.convertAndSend(destination, "my Payload");
verify(this.jmsTemplate).send(eq(destination), this.messageCreator.capture());
TextMessage textMessage = createTextMessage(this.messageCreator.getValue());
assertEquals("my Payload", textMessage.getText());
assertThat(textMessage.getText()).isEqualTo("my Payload");
}
@Test
@@ -207,7 +204,7 @@ public class JmsMessagingTemplateTests {
this.messagingTemplate.convertAndSend("myQueue", "my Payload");
verify(this.jmsTemplate).send(eq("myQueue"), this.messageCreator.capture());
TextMessage textMessage = createTextMessage(this.messageCreator.getValue());
assertEquals("my Payload", textMessage.getText());
assertThat(textMessage.getText()).isEqualTo("my Payload");
}
@Test
@@ -218,7 +215,7 @@ public class JmsMessagingTemplateTests {
this.messagingTemplate.convertAndSend("my Payload");
verify(this.jmsTemplate).send(eq(destination), this.messageCreator.capture());
TextMessage textMessage = createTextMessage(this.messageCreator.getValue());
assertEquals("my Payload", textMessage.getText());
assertThat(textMessage.getText()).isEqualTo("my Payload");
}
@Test
@@ -228,7 +225,7 @@ public class JmsMessagingTemplateTests {
this.messagingTemplate.convertAndSend("my Payload");
verify(this.jmsTemplate).send(eq("myQueue"), this.messageCreator.capture());
TextMessage textMessage = createTextMessage(this.messageCreator.getValue());
assertEquals("my Payload", textMessage.getText());
assertThat(textMessage.getText()).isEqualTo("my Payload");
}
@Test
@@ -333,7 +330,7 @@ public class JmsMessagingTemplateTests {
given(this.jmsTemplate.receive(destination)).willReturn(jmsMessage);
String payload = this.messagingTemplate.receiveAndConvert(destination, String.class);
assertEquals("my Payload", payload);
assertThat(payload).isEqualTo("my Payload");
verify(this.jmsTemplate).receive(destination);
}
@@ -343,7 +340,7 @@ public class JmsMessagingTemplateTests {
given(this.jmsTemplate.receive("myQueue")).willReturn(jmsMessage);
String payload = this.messagingTemplate.receiveAndConvert("myQueue", String.class);
assertEquals("my Payload", payload);
assertThat(payload).isEqualTo("my Payload");
verify(this.jmsTemplate).receive("myQueue");
}
@@ -355,7 +352,7 @@ public class JmsMessagingTemplateTests {
given(this.jmsTemplate.receive(destination)).willReturn(jmsMessage);
String payload = this.messagingTemplate.receiveAndConvert(String.class);
assertEquals("my Payload", payload);
assertThat(payload).isEqualTo("my Payload");
verify(this.jmsTemplate).receive(destination);
}
@@ -366,7 +363,7 @@ public class JmsMessagingTemplateTests {
given(this.jmsTemplate.receive("myQueue")).willReturn(jmsMessage);
String payload = this.messagingTemplate.receiveAndConvert(String.class);
assertEquals("my Payload", payload);
assertThat(payload).isEqualTo("my Payload");
verify(this.jmsTemplate).receive("myQueue");
}
@@ -378,7 +375,7 @@ public class JmsMessagingTemplateTests {
this.messagingTemplate.setMessageConverter(new GenericMessageConverter());
Integer payload = this.messagingTemplate.receiveAndConvert("myQueue", Integer.class);
assertEquals(Integer.valueOf(123), payload);
assertThat(payload).isEqualTo(Integer.valueOf(123));
verify(this.jmsTemplate).receive("myQueue");
}
@@ -395,7 +392,7 @@ public class JmsMessagingTemplateTests {
public void receiveAndConvertNoInput() {
given(this.jmsTemplate.receive("myQueue")).willReturn(null);
assertNull(this.messagingTemplate.receiveAndConvert("myQueue", String.class));
assertThat(this.messagingTemplate.receiveAndConvert("myQueue", String.class)).isNull();
}
@Test
@@ -462,7 +459,7 @@ public class JmsMessagingTemplateTests {
String reply = this.messagingTemplate.convertSendAndReceive(destination, "my Payload", String.class);
verify(this.jmsTemplate, times(1)).sendAndReceive(eq(destination), any());
assertEquals("My reply", reply);
assertThat(reply).isEqualTo("My reply");
}
@Test
@@ -472,7 +469,7 @@ public class JmsMessagingTemplateTests {
String reply = this.messagingTemplate.convertSendAndReceive("myQueue", "my Payload", String.class);
verify(this.jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), any());
assertEquals("My reply", reply);
assertThat(reply).isEqualTo("My reply");
}
@Test
@@ -484,7 +481,7 @@ public class JmsMessagingTemplateTests {
String reply = this.messagingTemplate.convertSendAndReceive("my Payload", String.class);
verify(this.jmsTemplate, times(1)).sendAndReceive(eq(destination), any());
assertEquals("My reply", reply);
assertThat(reply).isEqualTo("My reply");
}
@Test
@@ -495,7 +492,7 @@ public class JmsMessagingTemplateTests {
String reply = this.messagingTemplate.convertSendAndReceive("my Payload", String.class);
verify(this.jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), any());
assertEquals("My reply", reply);
assertThat(reply).isEqualTo("My reply");
}
@Test
@@ -634,8 +631,8 @@ public class JmsMessagingTemplateTests {
private void assertTextMessage(MessageCreator messageCreator) {
try {
TextMessage jmsMessage = createTextMessage(messageCreator);
assertEquals("Wrong body message", "Hello", jmsMessage.getText());
assertEquals("Invalid foo property", "bar", jmsMessage.getStringProperty("foo"));
assertThat(jmsMessage.getText()).as("Wrong body message").isEqualTo("Hello");
assertThat(jmsMessage.getStringProperty("foo")).as("Invalid foo property").isEqualTo("bar");
}
catch (JMSException e) {
throw new IllegalStateException("Wrong text message", e);
@@ -643,9 +640,9 @@ public class JmsMessagingTemplateTests {
}
private void assertTextMessage(Message<?> message) {
assertNotNull("message should not be null", message);
assertEquals("Wrong payload", "Hello", message.getPayload());
assertEquals("Invalid foo property", "bar", message.getHeaders().get("foo"));
assertThat(message).as("message should not be null").isNotNull();
assertThat(message.getPayload()).as("Wrong payload").isEqualTo("Hello");
assertThat(message.getHeaders().get("foo")).as("Invalid foo property").isEqualTo("bar");
}

20
spring-jms/src/test/java/org/springframework/jms/core/JmsTemplateTests.java
View File

@@ -60,10 +60,8 @@ import org.springframework.jndi.JndiTemplate;
import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willThrow;
import static org.mockito.Mockito.mock;
@@ -146,7 +144,7 @@ public class JmsTemplateTests {
PrintWriter out = new PrintWriter(sw);
springJmsEx.printStackTrace(out);
String trace = sw.toString();
assertTrue("inner jms exception not found", trace.indexOf("host not found") > 0);
assertThat(trace.indexOf("host not found") > 0).as("inner jms exception not found").isTrue();
}
@Test
@@ -236,8 +234,8 @@ public class JmsTemplateTests {
}
});
assertSame(this.session, ConnectionFactoryUtils.getTransactionalSession(scf, null, false));
assertSame(this.session, ConnectionFactoryUtils.getTransactionalSession(scf, scf.createConnection(), false));
assertThat(ConnectionFactoryUtils.getTransactionalSession(scf, null, false)).isSameAs(this.session);
assertThat(ConnectionFactoryUtils.getTransactionalSession(scf, scf.createConnection(), false)).isSameAs(this.session);
TransactionAwareConnectionFactoryProxy tacf = new TransactionAwareConnectionFactoryProxy(scf);
Connection tac = tacf.createConnection();
@@ -247,7 +245,7 @@ public class JmsTemplateTests {
tac.close();
List<TransactionSynchronization> synchs = TransactionSynchronizationManager.getSynchronizations();
assertEquals(1, synchs.size());
assertThat(synchs.size()).isEqualTo(1);
TransactionSynchronization synch = synchs.get(0);
synch.beforeCommit(false);
synch.beforeCompletion();
@@ -258,7 +256,7 @@ public class JmsTemplateTests {
TransactionSynchronizationManager.clearSynchronization();
scf.destroy();
}
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
verify(this.connection).start();
if (useTransactedTemplate()) {
@@ -619,10 +617,10 @@ public class JmsTemplateTests {
}
if (testConverter) {
assertEquals("Message text should be equal", "Hello World!", textFromMessage);
assertThat(textFromMessage).as("Message text should be equal").isEqualTo("Hello World!");
}
else {
assertEquals("Messages should refer to the same object", message, textMessage);
assertThat(textMessage).as("Messages should refer to the same object").isEqualTo(message);
}
verify(this.connection).start();
@@ -712,7 +710,7 @@ public class JmsTemplateTests {
// replyTO set on the request
verify(request).setJMSReplyTo(replyDestination);
assertSame("Reply message not received", reply, message);
assertThat(message).as("Reply message not received").isSameAs(reply);
verify(this.connection).start();
verify(this.connection).close();
verify(localSession).close();

12
spring-jms/src/test/java/org/springframework/jms/core/support/JmsGatewaySupportTests.java
View File

@@ -23,7 +23,7 @@ import org.junit.Test;
import org.springframework.jms.core.JmsTemplate;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@@ -44,9 +44,9 @@ public class JmsGatewaySupportTests {
};
gateway.setConnectionFactory(mockConnectionFactory);
gateway.afterPropertiesSet();
assertEquals("Correct ConnectionFactory", mockConnectionFactory, gateway.getConnectionFactory());
assertEquals("Correct JmsTemplate", mockConnectionFactory, gateway.getJmsTemplate().getConnectionFactory());
assertEquals("initGateway called", 1, test.size());
assertThat(gateway.getConnectionFactory()).as("Correct ConnectionFactory").isEqualTo(mockConnectionFactory);
assertThat(gateway.getJmsTemplate().getConnectionFactory()).as("Correct JmsTemplate").isEqualTo(mockConnectionFactory);
assertThat(test.size()).as("initGateway called").isEqualTo(1);
}
@Test
@@ -61,8 +61,8 @@ public class JmsGatewaySupportTests {
};
gateway.setJmsTemplate(template);
gateway.afterPropertiesSet();
assertEquals("Correct JmsTemplate", template, gateway.getJmsTemplate());
assertEquals("initGateway called", 1, test.size());
assertThat(gateway.getJmsTemplate()).as("Correct JmsTemplate").isEqualTo(template);
assertThat(test.size()).as("initGateway called").isEqualTo(1);
}
}

12
spring-jms/src/test/java/org/springframework/jms/listener/DefaultMessageListenerContainerTests.java
View File

@@ -30,7 +30,7 @@ import org.mockito.stubbing.Answer;
import org.springframework.util.backoff.BackOff;
import org.springframework.util.backoff.BackOffExecution;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -51,11 +51,11 @@ public class DefaultMessageListenerContainerTests {
DefaultMessageListenerContainer container = createContainer(createFailingContainerFactory());
container.setBackOff(backOff);
container.start();
assertEquals(true, container.isRunning());
assertThat(container.isRunning()).isEqualTo(true);
container.refreshConnectionUntilSuccessful();
assertEquals(false, container.isRunning());
assertThat(container.isRunning()).isEqualTo(false);
verify(backOff).start();
verify(execution).nextBackOff();
}
@@ -72,7 +72,7 @@ public class DefaultMessageListenerContainerTests {
container.start();
container.refreshConnectionUntilSuccessful();
assertEquals(false, container.isRunning());
assertThat(container.isRunning()).isEqualTo(false);
verify(backOff).start();
verify(execution, times(2)).nextBackOff();
}
@@ -89,7 +89,7 @@ public class DefaultMessageListenerContainerTests {
container.start();
container.refreshConnectionUntilSuccessful();
assertEquals(true, container.isRunning());
assertThat(container.isRunning()).isEqualTo(true);
verify(backOff).start();
verify(execution, times(1)).nextBackOff(); // only on attempt as the second one lead to a recovery
}
@@ -182,7 +182,7 @@ public class DefaultMessageListenerContainerTests {
public void waitForCompletion() throws InterruptedException {
this.countDownLatch.await(2, TimeUnit.SECONDS);
assertEquals("callback was not invoked", 0, this.countDownLatch.getCount());
assertThat(this.countDownLatch.getCount()).as("callback was not invoked").isEqualTo(0);
}
}

24
spring-jms/src/test/java/org/springframework/jms/listener/SimpleMessageListenerContainerTests.java
View File

@@ -35,12 +35,9 @@ import org.springframework.jms.StubQueue;
import org.springframework.lang.Nullable;
import org.springframework.util.ErrorHandler;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -65,7 +62,7 @@ public class SimpleMessageListenerContainerTests {
@Test
public void testSettingMessageListenerToANullType() {
this.container.setMessageListener(null);
assertNull(this.container.getMessageListener());
assertThat(this.container.getMessageListener()).isNull();
}
@Test
@@ -76,10 +73,9 @@ public class SimpleMessageListenerContainerTests {
@Test
public void testSessionTransactedModeReallyDoesDefaultToFalse() {
assertFalse("The [pubSubLocal] property of SimpleMessageListenerContainer " +
assertThat(this.container.isPubSubNoLocal()).as("The [pubSubLocal] property of SimpleMessageListenerContainer " +
"must default to false. Change this test (and the " +
"attendant Javadoc) if you have changed the default.",
this.container.isPubSubNoLocal());
"attendant Javadoc) if you have changed the default.").isFalse();
}
@Test
@@ -190,7 +186,7 @@ public class SimpleMessageListenerContainerTests {
public void onMessage(Message message, @Nullable Session sess) {
try {
// Check correct Session passed into SessionAwareMessageListener.
assertSame(sess, session);
assertThat(session).isSameAs(sess);
}
catch (Throwable ex) {
failure.add("MessageListener execution failed: " + ex);
@@ -238,9 +234,9 @@ public class SimpleMessageListenerContainerTests {
@Override
public void execute(Runnable task) {
listener.executorInvoked = true;
assertFalse(listener.listenerInvoked);
assertThat(listener.listenerInvoked).isFalse();
task.run();
assertTrue(listener.listenerInvoked);
assertThat(listener.listenerInvoked).isTrue();
}
});
this.container.afterPropertiesSet();
@@ -249,8 +245,8 @@ public class SimpleMessageListenerContainerTests {
final Message message = mock(Message.class);
messageConsumer.sendMessage(message);
assertTrue(listener.executorInvoked);
assertTrue(listener.listenerInvoked);
assertThat(listener.executorInvoked).isTrue();
assertThat(listener.listenerInvoked).isTrue();
verify(connection).setExceptionListener(this.container);
verify(connection).start();

6
spring-jms/src/test/java/org/springframework/jms/listener/adapter/JmsResponseTests.java
View File

@@ -24,8 +24,8 @@ import org.junit.Test;
import org.springframework.jms.support.destination.DestinationResolver;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertSame;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -38,7 +38,7 @@ public class JmsResponseTests {
public void destinationDoesNotUseDestinationResolver() throws JMSException {
Destination destination = mock(Destination.class);
Destination actual = JmsResponse.forDestination("foo", destination).resolveDestination(null, null);
assertSame(destination, actual);
assertThat(actual).isSameAs(destination);
}
@Test
@@ -50,7 +50,7 @@ public class JmsResponseTests {
given(destinationResolver.resolveDestinationName(session, "myQueue", false)).willReturn(destination);
JmsResponse<String> jmsResponse = JmsResponse.forQueue("foo", "myQueue");
Destination actual = jmsResponse.resolveDestination(destinationResolver, session);
assertSame(destination, actual);
assertThat(actual).isSameAs(destination);
}
@Test

30
spring-jms/src/test/java/org/springframework/jms/listener/adapter/MessageListenerAdapterTests.java
View File

@@ -37,12 +37,8 @@ import org.mockito.stubbing.Answer;
import org.springframework.jms.support.converter.MessageConversionException;
import org.springframework.jms.support.converter.SimpleMessageConverter;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willThrow;
@@ -151,7 +147,7 @@ public class MessageListenerAdapterTests {
StubMessageListenerAdapter adapter = new StubMessageListenerAdapter();
adapter.onMessage(textMessage);
assertTrue(adapter.wasCalled());
assertThat(adapter.wasCalled()).isTrue();
}
@Test
@@ -163,7 +159,7 @@ public class MessageListenerAdapterTests {
StubMessageListenerAdapter adapter = new StubMessageListenerAdapter();
adapter.setDefaultListenerMethod("walnutsRock");
adapter.onMessage(textMessage);
assertFalse(adapter.wasCalled());
assertThat(adapter.wasCalled()).isFalse();
}
@Test
@@ -177,13 +173,13 @@ public class MessageListenerAdapterTests {
MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) {
@Override
protected void handleListenerException(Throwable ex) {
assertNotNull("The Throwable passed to the handleListenerException(..) method must never be null.", ex);
assertTrue("The Throwable passed to the handleListenerException(..) method must be of type [ListenerExecutionFailedException].",
ex instanceof ListenerExecutionFailedException);
assertThat(ex).as("The Throwable passed to the handleListenerException(..) method must never be null.").isNotNull();
boolean condition = ex instanceof ListenerExecutionFailedException;
assertThat(condition).as("The Throwable passed to the handleListenerException(..) method must be of type [ListenerExecutionFailedException].").isTrue();
ListenerExecutionFailedException lefx = (ListenerExecutionFailedException) ex;
Throwable cause = lefx.getCause();
assertNotNull("The cause of a ListenerExecutionFailedException must be preserved.", cause);
assertSame(exception, cause);
assertThat(cause).as("The cause of a ListenerExecutionFailedException must be preserved.").isNotNull();
assertThat(cause).isSameAs(exception);
}
};
// we DON'T want the default SimpleMessageConversion happening...
@@ -194,21 +190,21 @@ public class MessageListenerAdapterTests {
@Test
public void testThatTheDefaultMessageConverterisIndeedTheSimpleMessageConverter() throws Exception {
MessageListenerAdapter adapter = new MessageListenerAdapter();
assertNotNull("The default [MessageConverter] must never be null.", adapter.getMessageConverter());
assertTrue("The default [MessageConverter] must be of the type [SimpleMessageConverter]",
adapter.getMessageConverter() instanceof SimpleMessageConverter);
assertThat(adapter.getMessageConverter()).as("The default [MessageConverter] must never be null.").isNotNull();
boolean condition = adapter.getMessageConverter() instanceof SimpleMessageConverter;
assertThat(condition).as("The default [MessageConverter] must be of the type [SimpleMessageConverter]").isTrue();
}
@Test
public void testThatWhenNoDelegateIsSuppliedTheDelegateIsAssumedToBeTheMessageListenerAdapterItself() throws Exception {
MessageListenerAdapter adapter = new MessageListenerAdapter();
assertSame(adapter, adapter.getDelegate());
assertThat(adapter.getDelegate()).isSameAs(adapter);
}
@Test
public void testThatTheDefaultMessageHandlingMethodNameIsTheConstantDefault() throws Exception {
MessageListenerAdapter adapter = new MessageListenerAdapter();
assertEquals(MessageListenerAdapter.ORIGINAL_DEFAULT_LISTENER_METHOD, adapter.getDefaultListenerMethod());
assertThat(adapter.getDefaultListenerMethod()).isEqualTo(MessageListenerAdapter.ORIGINAL_DEFAULT_LISTENER_METHOD);
}
@Test

22
spring-jms/src/test/java/org/springframework/jms/listener/adapter/MessagingMessageListenerAdapterTests.java
View File

@@ -48,8 +48,6 @@ import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -89,11 +87,11 @@ public class MessagingMessageListenerAdapterTests {
javax.jms.Message replyMessage = listener.buildMessage(session, result);
verify(session).createTextMessage("Response");
assertNotNull("reply should never be null", replyMessage);
assertEquals("Response", ((TextMessage) replyMessage).getText());
assertEquals("custom header not copied", "bar", replyMessage.getStringProperty("foo"));
assertEquals("type header not copied", "msg_type", replyMessage.getJMSType());
assertEquals("replyTo header not copied", replyTo, replyMessage.getJMSReplyTo());
assertThat(replyMessage).as("reply should never be null").isNotNull();
assertThat(((TextMessage) replyMessage).getText()).isEqualTo("Response");
assertThat(replyMessage.getStringProperty("foo")).as("custom header not copied").isEqualTo("bar");
assertThat(replyMessage.getJMSType()).as("type header not copied").isEqualTo("msg_type");
assertThat(replyMessage.getJMSReplyTo()).as("replyTo header not copied").isEqualTo(replyTo);
}
@Test
@@ -127,7 +125,7 @@ public class MessagingMessageListenerAdapterTests {
listener.setMessageConverter(messageConverter);
Message<?> message = listener.toMessagingMessage(jmsMessage);
verify(messageConverter, never()).fromMessage(jmsMessage);
assertEquals("FooBar", message.getPayload());
assertThat(message.getPayload()).isEqualTo("FooBar");
verify(messageConverter, times(1)).fromMessage(jmsMessage);
}
@@ -154,8 +152,8 @@ public class MessagingMessageListenerAdapterTests {
listener.setMessageConverter(messageConverter);
listener.onMessage(jmsMessage, session);
verify(messageConverter, times(1)).fromMessage(jmsMessage);
assertEquals(1, sample.simples.size());
assertEquals("FooBar", sample.simples.get(0).getPayload());
assertThat(sample.simples.size()).isEqualTo(1);
assertThat(sample.simples.get(0).getPayload()).isEqualTo("FooBar");
}
@Test
@@ -170,8 +168,8 @@ public class MessagingMessageListenerAdapterTests {
javax.jms.Message replyMessage = listener.buildMessage(session, result);
verify(messageConverter, times(1)).toMessage("Response", session);
assertNotNull("reply should never be null", replyMessage);
assertEquals("Response", ((TextMessage) replyMessage).getText());
assertThat(replyMessage).as("reply should never be null").isNotNull();
assertThat(((TextMessage) replyMessage).getText()).isEqualTo("Response");
}
@Test

15
spring-jms/src/test/java/org/springframework/jms/listener/endpoint/DefaultJmsActivationSpecFactoryTests.java
View File

@@ -25,8 +25,7 @@ import org.springframework.jca.StubResourceAdapter;
import org.springframework.jms.StubQueue;
import org.springframework.jms.support.destination.DestinationResolver;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -54,9 +53,9 @@ public class DefaultJmsActivationSpecFactoryTests {
StubActiveMQActivationSpec spec = (StubActiveMQActivationSpec) activationSpecFactory.createActivationSpec(
new StubActiveMQResourceAdapter(), activationSpecConfig);
assertEquals(5, spec.getMaxSessions());
assertEquals(3, spec.getMaxMessagesPerSessions());
assertTrue(spec.isUseRAManagedTransaction());
assertThat(spec.getMaxSessions()).isEqualTo(5);
assertThat(spec.getMaxMessagesPerSessions()).isEqualTo(3);
assertThat(spec.isUseRAManagedTransaction()).isTrue();
}
@Test
@@ -72,9 +71,9 @@ public class DefaultJmsActivationSpecFactoryTests {
StubWebSphereActivationSpecImpl spec = (StubWebSphereActivationSpecImpl) activationSpecFactory
.createActivationSpec(new StubWebSphereResourceAdapterImpl(), activationSpecConfig);
assertEquals(destination, spec.getDestination());
assertEquals(5, spec.getMaxConcurrency());
assertEquals(3, spec.getMaxBatchSize());
assertThat(spec.getDestination()).isEqualTo(destination);
assertThat(spec.getMaxConcurrency()).isEqualTo(5);
assertThat(spec.getMaxBatchSize()).isEqualTo(3);
}

28
spring-jms/src/test/java/org/springframework/jms/listener/endpoint/JmsMessageEndpointManagerTests.java
View File

@@ -20,10 +20,8 @@ import org.junit.Test;
import org.springframework.jms.support.QosSettings;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
/**
* @author Stephane Nicoll
@@ -36,8 +34,8 @@ public class JmsMessageEndpointManagerTests {
JmsActivationSpecConfig config = new JmsActivationSpecConfig();
config.setPubSubDomain(false);
endpoint.setActivationSpecConfig(config);
assertEquals(false, endpoint.isPubSubDomain());
assertEquals(false, endpoint.isReplyPubSubDomain());
assertThat(endpoint.isPubSubDomain()).isEqualTo(false);
assertThat(endpoint.isReplyPubSubDomain()).isEqualTo(false);
}
@Test
@@ -46,8 +44,8 @@ public class JmsMessageEndpointManagerTests {
JmsActivationSpecConfig config = new JmsActivationSpecConfig();
config.setPubSubDomain(true);
endpoint.setActivationSpecConfig(config);
assertEquals(true, endpoint.isPubSubDomain());
assertEquals(true, endpoint.isReplyPubSubDomain());
assertThat(endpoint.isPubSubDomain()).isEqualTo(true);
assertThat(endpoint.isReplyPubSubDomain()).isEqualTo(true);
}
@Test
@@ -57,8 +55,8 @@ public class JmsMessageEndpointManagerTests {
config.setPubSubDomain(true);
config.setReplyPubSubDomain(false);
endpoint.setActivationSpecConfig(config);
assertEquals(true, endpoint.isPubSubDomain());
assertEquals(false, endpoint.isReplyPubSubDomain());
assertThat(endpoint.isPubSubDomain()).isEqualTo(true);
assertThat(endpoint.isReplyPubSubDomain()).isEqualTo(false);
}
@Test
@@ -68,10 +66,10 @@ public class JmsMessageEndpointManagerTests {
QosSettings settings = new QosSettings(1, 3, 5);
config.setReplyQosSettings(settings);
endpoint.setActivationSpecConfig(config);
assertNotNull(endpoint.getReplyQosSettings());
assertEquals(1, endpoint.getReplyQosSettings().getDeliveryMode());
assertEquals(3, endpoint.getReplyQosSettings().getPriority());
assertEquals(5, endpoint.getReplyQosSettings().getTimeToLive());
assertThat(endpoint.getReplyQosSettings()).isNotNull();
assertThat(endpoint.getReplyQosSettings().getDeliveryMode()).isEqualTo(1);
assertThat(endpoint.getReplyQosSettings().getPriority()).isEqualTo(3);
assertThat(endpoint.getReplyQosSettings().getTimeToLive()).isEqualTo(5);
}
@Test
@@ -101,12 +99,12 @@ public class JmsMessageEndpointManagerTests {
@Test
public void getMessageConverterNoConfig() {
JmsMessageEndpointManager endpoint = new JmsMessageEndpointManager();
assertNull(endpoint.getMessageConverter());
assertThat(endpoint.getMessageConverter()).isNull();
}
@Test
public void getDestinationResolverNoConfig() {
JmsMessageEndpointManager endpoint = new JmsMessageEndpointManager();
assertNull(endpoint.getDestinationResolver());
assertThat(endpoint.getDestinationResolver()).isNull();
}
}

13
spring-jms/src/test/java/org/springframework/jms/remoting/JmsInvokerTests.java
View File

@@ -40,10 +40,9 @@ import org.springframework.remoting.RemoteTimeoutException;
import org.springframework.tests.sample.beans.ITestBean;
import org.springframework.tests.sample.beans.TestBean;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -122,7 +121,7 @@ public class JmsInvokerTests {
ResponseStoringProducer mockProducer = new ResponseStoringProducer();
given(mockExporterSession.createProducer(requestMessage.getJMSReplyTo())).willReturn(mockProducer);
exporter.onMessage(requestMessage, mockExporterSession);
assertTrue(mockProducer.closed);
assertThat(mockProducer.closed).isTrue();
return mockProducer.response;
}
};
@@ -139,12 +138,12 @@ public class JmsInvokerTests {
pfb.afterPropertiesSet();
ITestBean proxy = (ITestBean) pfb.getObject();
assertEquals("myname", proxy.getName());
assertEquals(99, proxy.getAge());
assertThat(proxy.getName()).isEqualTo("myname");
assertThat(proxy.getAge()).isEqualTo(99);
proxy.setAge(50);
assertEquals(50, proxy.getAge());
assertThat(proxy.getAge()).isEqualTo(50);
proxy.setStringArray(new String[] {"str1", "str2"});
assertTrue(Arrays.equals(new String[] {"str1", "str2"}, proxy.getStringArray()));
assertThat(Arrays.equals(new String[] {"str1", "str2"}, proxy.getStringArray())).isTrue();
assertThatIllegalStateException().isThrownBy(() ->
proxy.exceptional(new IllegalStateException()));
assertThatExceptionOfType(IllegalAccessException.class).isThrownBy(() ->

14
spring-jms/src/test/java/org/springframework/jms/support/JmsAccessorTests.java
View File

@@ -20,9 +20,8 @@ import javax.jms.Session;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
/**
* Unit tests for the {@link JmsAccessor} class.
@@ -42,20 +41,17 @@ public class JmsAccessorTests {
@Test
public void testSessionTransactedModeReallyDoesDefaultToFalse() throws Exception {
JmsAccessor accessor = new StubJmsAccessor();
assertFalse("The [sessionTransacted] property of JmsAccessor must default to " +
assertThat(accessor.isSessionTransacted()).as("The [sessionTransacted] property of JmsAccessor must default to " +
"false. Change this test (and the attendant Javadoc) if you have " +
"changed the default.",
accessor.isSessionTransacted());
"changed the default.").isFalse();
}
@Test
public void testAcknowledgeModeReallyDoesDefaultToAutoAcknowledge() throws Exception {
JmsAccessor accessor = new StubJmsAccessor();
assertEquals("The [sessionAcknowledgeMode] property of JmsAccessor must default to " +
assertThat(accessor.getSessionAcknowledgeMode()).as("The [sessionAcknowledgeMode] property of JmsAccessor must default to " +
"[Session.AUTO_ACKNOWLEDGE]. Change this test (and the attendant " +
"Javadoc) if you have changed the default.",
Session.AUTO_ACKNOWLEDGE,
accessor.getSessionAcknowledgeMode());
"Javadoc) if you have changed the default.").isEqualTo(Session.AUTO_ACKNOWLEDGE);
}
@Test

26
spring-jms/src/test/java/org/springframework/jms/support/JmsMessageHeaderAccessorTests.java
View File

@@ -26,8 +26,7 @@ import org.springframework.jms.StubTextMessage;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
*
@@ -57,19 +56,20 @@ public class JmsMessageHeaderAccessorTests {
Map<String, Object> mappedHeaders = new SimpleJmsHeaderMapper().toHeaders(jmsMessage);
Message<String> message = MessageBuilder.withPayload("test").copyHeaders(mappedHeaders).build();
JmsMessageHeaderAccessor headerAccessor = JmsMessageHeaderAccessor.wrap(message);
assertEquals("correlation-1234", headerAccessor.getCorrelationId());
assertEquals(destination, headerAccessor.getDestination());
assertEquals(Integer.valueOf(1), headerAccessor.getDeliveryMode());
assertEquals(1234L, headerAccessor.getExpiration(), 0.0);
assertEquals("abcd-1234", headerAccessor.getMessageId());
assertEquals(Integer.valueOf(9), headerAccessor.getPriority());
assertEquals(replyTo, headerAccessor.getReplyTo());
assertEquals(true, headerAccessor.getRedelivered());
assertEquals("type", headerAccessor.getType());
assertEquals(4567L, headerAccessor.getTimestamp(), 0.0);
assertThat(headerAccessor.getCorrelationId()).isEqualTo("correlation-1234");
assertThat(headerAccessor.getDestination()).isEqualTo(destination);
assertThat(headerAccessor.getDeliveryMode()).isEqualTo(Integer.valueOf(1));
assertThat(headerAccessor.getExpiration()).isEqualTo(1234);
assertThat(headerAccessor.getMessageId()).isEqualTo("abcd-1234");
assertThat(headerAccessor.getPriority()).isEqualTo(Integer.valueOf(9));
assertThat(headerAccessor.getReplyTo()).isEqualTo(replyTo);
assertThat(headerAccessor.getRedelivered()).isEqualTo(true);
assertThat(headerAccessor.getType()).isEqualTo("type");
assertThat(headerAccessor.getTimestamp()).isEqualTo(4567);
// Making sure replyChannel is not mixed with replyTo
assertNull(headerAccessor.getReplyChannel());
assertThat(headerAccessor.getReplyChannel()).isNull();
}
}

108
spring-jms/src/test/java/org/springframework/jms/support/SimpleJmsHeaderMapperTests.java
View File

@@ -29,11 +29,7 @@ import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.MessageBuilder;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
/**
*
@@ -56,8 +52,8 @@ public class SimpleJmsHeaderMapperTests {
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNotNull(jmsMessage.getJMSReplyTo());
assertSame(replyTo, jmsMessage.getJMSReplyTo());
assertThat(jmsMessage.getJMSReplyTo()).isNotNull();
assertThat(jmsMessage.getJMSReplyTo()).isSameAs(replyTo);
}
@Test
@@ -66,7 +62,7 @@ public class SimpleJmsHeaderMapperTests {
.setHeader(JmsHeaders.REPLY_TO, "not-a-destination").build();
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNull(jmsMessage.getJMSReplyTo());
assertThat(jmsMessage.getJMSReplyTo()).isNull();
}
@Test
@@ -76,8 +72,8 @@ public class SimpleJmsHeaderMapperTests {
.setHeader(JmsHeaders.CORRELATION_ID, jmsCorrelationId).build();
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNotNull(jmsMessage.getJMSCorrelationID());
assertEquals(jmsCorrelationId, jmsMessage.getJMSCorrelationID());
assertThat(jmsMessage.getJMSCorrelationID()).isNotNull();
assertThat(jmsMessage.getJMSCorrelationID()).isEqualTo(jmsCorrelationId);
}
@Test
@@ -86,7 +82,7 @@ public class SimpleJmsHeaderMapperTests {
.setHeader(JmsHeaders.CORRELATION_ID, 123).build();
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertEquals("123", jmsMessage.getJMSCorrelationID());
assertThat(jmsMessage.getJMSCorrelationID()).isEqualTo("123");
}
@Test
@@ -95,7 +91,7 @@ public class SimpleJmsHeaderMapperTests {
.setHeader(JmsHeaders.CORRELATION_ID, new Date()).build();
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNull(jmsMessage.getJMSCorrelationID());
assertThat(jmsMessage.getJMSCorrelationID()).isNull();
}
@Test
@@ -105,8 +101,8 @@ public class SimpleJmsHeaderMapperTests {
.setHeader(JmsHeaders.TYPE, jmsType).build();
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNotNull(jmsMessage.getJMSType());
assertEquals(jmsType, jmsMessage.getJMSType());
assertThat(jmsMessage.getJMSType()).isNotNull();
assertThat(jmsMessage.getJMSType()).isEqualTo(jmsType);
}
@Test
@@ -115,7 +111,7 @@ public class SimpleJmsHeaderMapperTests {
.setHeader(JmsHeaders.TYPE, 123).build();
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNull(jmsMessage.getJMSType());
assertThat(jmsMessage.getJMSType()).isNull();
}
@Test
@@ -131,13 +127,13 @@ public class SimpleJmsHeaderMapperTests {
.build();
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNull(jmsMessage.getJMSDestination());
assertEquals(DeliveryMode.PERSISTENT, jmsMessage.getJMSDeliveryMode());
assertEquals(0, jmsMessage.getJMSExpiration());
assertNull(jmsMessage.getJMSMessageID());
assertEquals(javax.jms.Message.DEFAULT_PRIORITY, jmsMessage.getJMSPriority());
assertFalse(jmsMessage.getJMSRedelivered());
assertEquals(0, jmsMessage.getJMSTimestamp());
assertThat(jmsMessage.getJMSDestination()).isNull();
assertThat(jmsMessage.getJMSDeliveryMode()).isEqualTo(DeliveryMode.PERSISTENT);
assertThat(jmsMessage.getJMSExpiration()).isEqualTo(0);
assertThat(jmsMessage.getJMSMessageID()).isNull();
assertThat(jmsMessage.getJMSPriority()).isEqualTo(javax.jms.Message.DEFAULT_PRIORITY);
assertThat(jmsMessage.getJMSRedelivered()).isFalse();
assertThat(jmsMessage.getJMSTimestamp()).isEqualTo(0);
}
@Test
@@ -148,8 +144,8 @@ public class SimpleJmsHeaderMapperTests {
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
Object value = jmsMessage.getObjectProperty(JmsHeaderMapper.CONTENT_TYPE_PROPERTY);
assertNotNull(value);
assertEquals("foo", value);
assertThat(value).isNotNull();
assertThat(value).isEqualTo("foo");
}
@Test
@@ -160,9 +156,9 @@ public class SimpleJmsHeaderMapperTests {
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
Object value = jmsMessage.getObjectProperty("foo");
assertNotNull(value);
assertEquals(Integer.class, value.getClass());
assertEquals(123, ((Integer) value).intValue());
assertThat(value).isNotNull();
assertThat(value.getClass()).isEqualTo(Integer.class);
assertThat(((Integer) value).intValue()).isEqualTo(123);
}
@Test
@@ -174,9 +170,9 @@ public class SimpleJmsHeaderMapperTests {
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
Object value = jmsMessage.getObjectProperty("custom_foo");
assertNotNull(value);
assertEquals(Integer.class, value.getClass());
assertEquals(123, ((Integer) value).intValue());
assertThat(value).isNotNull();
assertThat(value.getClass()).isEqualTo(Integer.class);
assertThat(((Integer) value).intValue()).isEqualTo(123);
}
@Test
@@ -188,7 +184,7 @@ public class SimpleJmsHeaderMapperTests {
javax.jms.Message jmsMessage = new StubTextMessage();
mapper.fromHeaders(message.getHeaders(), jmsMessage);
Object value = jmsMessage.getObjectProperty("destination");
assertNull(value);
assertThat(value).isNull();
}
@Test
@@ -433,11 +429,11 @@ public class SimpleJmsHeaderMapperTests {
};
mapper.fromHeaders(message.getHeaders(), jmsMessage);
Object foo = jmsMessage.getObjectProperty("foo");
assertNotNull(foo);
assertThat(foo).isNotNull();
Object bar = jmsMessage.getObjectProperty("bar");
assertNotNull(bar);
assertThat(bar).isNotNull();
Object bad = jmsMessage.getObjectProperty("bad");
assertNull(bad);
assertThat(bad).isNull();
}
@Test
@@ -458,11 +454,11 @@ public class SimpleJmsHeaderMapperTests {
};
mapper.fromHeaders(message.getHeaders(), jmsMessage);
Object foo = jmsMessage.getObjectProperty("foo");
assertNotNull(foo);
assertThat(foo).isNotNull();
Object bar = jmsMessage.getObjectProperty("bar");
assertNotNull(bar);
assertThat(bar).isNotNull();
Object bad = jmsMessage.getObjectProperty("bad");
assertNull(bad);
assertThat(bad).isNull();
}
@Test
@@ -478,9 +474,9 @@ public class SimpleJmsHeaderMapperTests {
}
};
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNull(jmsMessage.getJMSReplyTo());
assertNotNull(jmsMessage.getStringProperty("foo"));
assertEquals("bar", jmsMessage.getStringProperty("foo"));
assertThat(jmsMessage.getJMSReplyTo()).isNull();
assertThat(jmsMessage.getStringProperty("foo")).isNotNull();
assertThat(jmsMessage.getStringProperty("foo")).isEqualTo("bar");
}
@Test
@@ -496,9 +492,9 @@ public class SimpleJmsHeaderMapperTests {
}
};
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNull(jmsMessage.getJMSType());
assertNotNull(jmsMessage.getStringProperty("foo"));
assertEquals("bar", jmsMessage.getStringProperty("foo"));
assertThat(jmsMessage.getJMSType()).isNull();
assertThat(jmsMessage.getStringProperty("foo")).isNotNull();
assertThat(jmsMessage.getStringProperty("foo")).isEqualTo("bar");
}
@Test
@@ -514,9 +510,9 @@ public class SimpleJmsHeaderMapperTests {
}
};
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNull(jmsMessage.getJMSCorrelationID());
assertNotNull(jmsMessage.getStringProperty("foo"));
assertEquals("bar", jmsMessage.getStringProperty("foo"));
assertThat(jmsMessage.getJMSCorrelationID()).isNull();
assertThat(jmsMessage.getStringProperty("foo")).isNotNull();
assertThat(jmsMessage.getStringProperty("foo")).isEqualTo("bar");
}
@Test
@@ -532,9 +528,9 @@ public class SimpleJmsHeaderMapperTests {
}
};
mapper.fromHeaders(message.getHeaders(), jmsMessage);
assertNull(jmsMessage.getJMSCorrelationID());
assertNotNull(jmsMessage.getStringProperty("foo"));
assertEquals("bar", jmsMessage.getStringProperty("foo"));
assertThat(jmsMessage.getJMSCorrelationID()).isNull();
assertThat(jmsMessage.getStringProperty("foo")).isNotNull();
assertThat(jmsMessage.getStringProperty("foo")).isEqualTo("bar");
}
@@ -542,12 +538,12 @@ public class SimpleJmsHeaderMapperTests {
Map<String, Object> headers = mapper.toHeaders(jmsMessage);
Object headerValue = headers.get(headerId);
if (value == null) {
assertNull(headerValue);
assertThat(headerValue).isNull();
}
else {
assertNotNull(headerValue);
assertEquals(value.getClass(), headerValue.getClass());
assertEquals(value, headerValue);
assertThat(headerValue).isNotNull();
assertThat(headerValue.getClass()).isEqualTo(value.getClass());
assertThat(headerValue).isEqualTo(value);
}
}
@@ -555,9 +551,9 @@ public class SimpleJmsHeaderMapperTests {
throws JMSException {
jmsMessage.setStringProperty("foo", "bar");
Map<String, Object> headers = mapper.toHeaders(jmsMessage);
assertNull(headers.get(headerId));
assertNotNull(headers.get("foo"));
assertEquals("bar", headers.get("foo"));
assertThat(headers.get(headerId)).isNull();
assertThat(headers.get("foo")).isNotNull();
assertThat(headers.get("foo")).isEqualTo("bar");
}
private MessageBuilder<String> initBuilder() {

15
spring-jms/src/test/java/org/springframework/jms/support/SimpleMessageConverterTests.java
View File

@@ -35,9 +35,8 @@ import org.mockito.stubbing.Answer;
import org.springframework.jms.support.converter.MessageConversionException;
import org.springframework.jms.support.converter.SimpleMessageConverter;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -64,7 +63,7 @@ public class SimpleMessageConverterTests {
SimpleMessageConverter converter = new SimpleMessageConverter();
Message msg = converter.toMessage(content, session);
assertEquals(content, converter.fromMessage(msg));
assertThat(converter.fromMessage(msg)).isEqualTo(content);
}
@Test
@@ -86,7 +85,7 @@ public class SimpleMessageConverterTests {
SimpleMessageConverter converter = new SimpleMessageConverter();
Message msg = converter.toMessage(content, session);
assertEquals(content.length, ((byte[]) converter.fromMessage(msg)).length);
assertThat(((byte[]) converter.fromMessage(msg)).length).isEqualTo(content.length);
verify(message).writeBytes(content);
}
@@ -108,7 +107,7 @@ public class SimpleMessageConverterTests {
SimpleMessageConverter converter = new SimpleMessageConverter();
Message msg = converter.toMessage(content, session);
assertEquals(content, converter.fromMessage(msg));
assertThat(converter.fromMessage(msg)).isEqualTo(content);
verify(message).setObject("key1", "value1");
verify(message).setObject("key2", "value2");
@@ -126,7 +125,7 @@ public class SimpleMessageConverterTests {
SimpleMessageConverter converter = new SimpleMessageConverter();
Message msg = converter.toMessage(content, session);
assertEquals(content, converter.fromMessage(msg));
assertThat(converter.fromMessage(msg)).isEqualTo(content);
}
@Test
@@ -148,7 +147,7 @@ public class SimpleMessageConverterTests {
SimpleMessageConverter converter = new SimpleMessageConverter();
Message msg = converter.toMessage(message, session);
assertSame(message, msg);
assertThat(msg).isSameAs(message);
}
@Test
@@ -157,7 +156,7 @@ public class SimpleMessageConverterTests {
SimpleMessageConverter converter = new SimpleMessageConverter();
Object msg = converter.fromMessage(message);
assertSame(message, msg);
assertThat(msg).isSameAs(message);
}
@Test

12
spring-jms/src/test/java/org/springframework/jms/support/converter/MappingJackson2MessageConverterTests.java
View File

@@ -35,8 +35,8 @@ import org.mockito.stubbing.Answer;
import org.springframework.core.MethodParameter;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.BDDMockito.given;
@@ -98,7 +98,7 @@ public class MappingJackson2MessageConverterTests {
});
Object result = converter.fromMessage(bytesMessageMock);
assertEquals("Invalid result", result, unmarshalled);
assertThat(unmarshalled).as("Invalid result").isEqualTo(result);
}
@Test
@@ -136,7 +136,7 @@ public class MappingJackson2MessageConverterTests {
given(textMessageMock.getText()).willReturn(text);
MyBean result = (MyBean)converter.fromMessage(textMessageMock);
assertEquals("Invalid result", result, unmarshalled);
assertThat(unmarshalled).as("Invalid result").isEqualTo(result);
}
@Test
@@ -149,7 +149,7 @@ public class MappingJackson2MessageConverterTests {
given(textMessageMock.getText()).willReturn(text);
MyBean result = (MyBean)converter.fromMessage(textMessageMock);
assertEquals("Invalid result", result, unmarshalled);
assertThat(unmarshalled).as("Invalid result").isEqualTo(result);
}
@Test
@@ -162,7 +162,7 @@ public class MappingJackson2MessageConverterTests {
given(textMessageMock.getText()).willReturn(text);
Object result = converter.fromMessage(textMessageMock);
assertEquals("Invalid result", result, unmarshalled);
assertThat(unmarshalled).as("Invalid result").isEqualTo(result);
}
@Test
@@ -175,7 +175,7 @@ public class MappingJackson2MessageConverterTests {
given(textMessageMock.getText()).willReturn(text);
Object result = converter.fromMessage(textMessageMock);
assertEquals("Invalid result", result, unmarshalled);
assertThat(unmarshalled).as("Invalid result").isEqualTo(result);
}
@Test

6
spring-jms/src/test/java/org/springframework/jms/support/converter/MarshallingMessageConverterTests.java
View File

@@ -28,7 +28,7 @@ import org.junit.Test;
import org.springframework.oxm.Marshaller;
import org.springframework.oxm.Unmarshaller;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.BDDMockito.given;
@@ -80,7 +80,7 @@ public class MarshallingMessageConverterTests {
given(unmarshallerMock.unmarshal(isA(Source.class))).willReturn(unmarshalled);
Object result = converter.fromMessage(bytesMessageMock);
assertEquals("Invalid result", result, unmarshalled);
assertThat(unmarshalled).as("Invalid result").isEqualTo(result);
}
@Test
@@ -106,7 +106,7 @@ public class MarshallingMessageConverterTests {
given(unmarshallerMock.unmarshal(isA(Source.class))).willReturn(unmarshalled);
Object result = converter.fromMessage(textMessageMock);
assertEquals("Invalid result", result, unmarshalled);
assertThat(unmarshalled).as("Invalid result").isEqualTo(result);
}
}

4
spring-jms/src/test/java/org/springframework/jms/support/converter/MessagingMessageConverterTests.java
View File

@@ -28,8 +28,8 @@ import org.springframework.jms.StubTextMessage;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -65,7 +65,7 @@ public class MessagingMessageConverterTests {
this.converter.setPayloadConverter(new TestMessageConverter());
Message<?> msg = (Message<?>) this.converter.fromMessage(jmsMsg);
assertEquals(1224L, msg.getPayload());
assertThat(msg.getPayload()).isEqualTo(1224L);
}

7
spring-jms/src/test/java/org/springframework/jms/support/destination/DynamicDestinationResolverTests.java
View File

@@ -29,8 +29,7 @@ import org.junit.Test;
import org.springframework.jms.StubQueue;
import org.springframework.jms.StubTopic;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -77,8 +76,8 @@ public class DynamicDestinationResolverTests {
private static void testResolveDestination(Session session, Destination expectedDestination, boolean isPubSub) throws JMSException {
DynamicDestinationResolver resolver = new DynamicDestinationResolver();
Destination destination = resolver.resolveDestinationName(session, DESTINATION_NAME, isPubSub);
assertNotNull(destination);
assertSame(expectedDestination, destination);
assertThat(destination).isNotNull();
assertThat(destination).isSameAs(expectedDestination);
}
}

7
spring-jms/src/test/java/org/springframework/jms/support/destination/JmsDestinationAccessorTests.java
View File

@@ -20,8 +20,8 @@ import javax.jms.ConnectionFactory;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertFalse;
import static org.mockito.Mockito.mock;
/**
@@ -43,10 +43,9 @@ public class JmsDestinationAccessorTests {
@Test
public void testSessionTransactedModeReallyDoesDefaultToFalse() throws Exception {
JmsDestinationAccessor accessor = new StubJmsDestinationAccessor();
assertFalse("The [pubSubDomain] property of JmsDestinationAccessor must default to " +
assertThat(accessor.isPubSubDomain()).as("The [pubSubDomain] property of JmsDestinationAccessor must default to " +
"false (i.e. Queues are used by default). Change this test (and the " +
"attendant Javadoc) if you have changed the default.",
accessor.isPubSubDomain());
"attendant Javadoc) if you have changed the default.").isFalse();
}

25
spring-jms/src/test/java/org/springframework/jms/support/destination/JndiDestinationResolverTests.java
View File

@@ -26,9 +26,6 @@ import org.springframework.jms.StubTopic;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -50,8 +47,8 @@ public class JndiDestinationResolverTests {
JndiDestinationResolver resolver = new OneTimeLookupJndiDestinationResolver();
Destination destination = resolver.resolveDestinationName(session, DESTINATION_NAME, true);
assertNotNull(destination);
assertSame(DESTINATION, destination);
assertThat(destination).isNotNull();
assertThat(destination).isSameAs(DESTINATION);
}
@Test
@@ -63,14 +60,14 @@ public class JndiDestinationResolverTests {
= new CountingCannedJndiDestinationResolver();
resolver.setCache(false);
Destination destination = resolver.resolveDestinationName(session, DESTINATION_NAME, true);
assertNotNull(destination);
assertSame(DESTINATION, destination);
assertEquals(1, resolver.getCallCount());
assertThat(destination).isNotNull();
assertThat(destination).isSameAs(DESTINATION);
assertThat(resolver.getCallCount()).isEqualTo(1);
destination = resolver.resolveDestinationName(session, DESTINATION_NAME, true);
assertNotNull(destination);
assertSame(DESTINATION, destination);
assertEquals(2, resolver.getCallCount());
assertThat(destination).isNotNull();
assertThat(destination).isSameAs(DESTINATION);
assertThat(resolver.getCallCount()).isEqualTo(2);
}
@Test
@@ -91,8 +88,8 @@ public class JndiDestinationResolverTests {
resolver.setDynamicDestinationResolver(dynamicResolver);
Destination destination = resolver.resolveDestinationName(session, DESTINATION_NAME, true);
assertNotNull(destination);
assertSame(DESTINATION, destination);
assertThat(destination).isNotNull();
assertThat(destination).isSameAs(DESTINATION);
}
@Test
@@ -120,7 +117,7 @@ public class JndiDestinationResolverTests {
@Override
protected <T> T lookup(String jndiName, Class<T> requiredType) throws NamingException {
assertThat(called).as("delegating to lookup(..) not cache").isFalse();
assertEquals(DESTINATION_NAME, jndiName);
assertThat(jndiName).isEqualTo(DESTINATION_NAME);
called = true;
return requiredType.cast(DESTINATION);
}