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

Convert tests to AssertJ

Browse Source 
- initial automated conversion + polishing

- TODO: `...size()).isEqualTo(...` to `).hasSize(...` etc
This commit is contained in:
Gary Russell
2019-04-16 12:33:59 -04:00
committed by Artem Bilan
parent 529bb63d86
commit 7472f1b0b6
50 changed files with 985 additions and 1119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
spring-amqp/src/test/java/org/springframework/amqp/core/AddressTests.java
View File

@@ -16,9 +16,8 @@
package org.springframework.amqp.core;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Assert;
import org.junit.Test;
/**
@@ -33,55 +32,55 @@ public class AddressTests {
public void toStringCheck() {
Address address = new Address("my-exchange", "routing-key");
String replyToUri = "my-exchange/routing-key";
Assert.assertEquals(replyToUri, address.toString());
assertThat(address.toString()).isEqualTo(replyToUri);
}
@Test
public void parse() {
String replyToUri = "direct://my-exchange/routing-key";
Address address = new Address(replyToUri);
assertEquals("my-exchange", address.getExchangeName());
assertEquals("routing-key", address.getRoutingKey());
assertThat(address.getExchangeName()).isEqualTo("my-exchange");
assertThat(address.getRoutingKey()).isEqualTo("routing-key");
}
@Test
public void parseUnstructuredWithRoutingKeyOnly() {
Address address = new Address("my-routing-key");
assertEquals("my-routing-key", address.getRoutingKey());
assertEquals("/my-routing-key", address.toString());
assertThat(address.getRoutingKey()).isEqualTo("my-routing-key");
assertThat(address.toString()).isEqualTo("/my-routing-key");
address = new Address("/foo");
assertEquals("foo", address.getRoutingKey());
assertEquals("/foo", address.toString());
assertThat(address.getRoutingKey()).isEqualTo("foo");
assertThat(address.toString()).isEqualTo("/foo");
address = new Address("bar/baz");
assertEquals("bar", address.getExchangeName());
assertEquals("baz", address.getRoutingKey());
assertEquals("bar/baz", address.toString());
assertThat(address.getExchangeName()).isEqualTo("bar");
assertThat(address.getRoutingKey()).isEqualTo("baz");
assertThat(address.toString()).isEqualTo("bar/baz");
}
@Test
public void parseWithoutRoutingKey() {
Address address = new Address("fanout://my-exchange");
assertEquals("my-exchange", address.getExchangeName());
assertEquals("", address.getRoutingKey());
assertEquals("my-exchange/", address.toString());
assertThat(address.getExchangeName()).isEqualTo("my-exchange");
assertThat(address.getRoutingKey()).isEqualTo("");
assertThat(address.toString()).isEqualTo("my-exchange/");
}
@Test
public void parseWithDefaultExchangeAndRoutingKey() {
Address address = new Address("direct:///routing-key");
assertEquals("", address.getExchangeName());
assertEquals("routing-key", address.getRoutingKey());
assertEquals("/routing-key", address.toString());
assertThat(address.getExchangeName()).isEqualTo("");
assertThat(address.getRoutingKey()).isEqualTo("routing-key");
assertThat(address.toString()).isEqualTo("/routing-key");
}
@Test
public void testEmpty() {
Address address = new Address("/");
assertEquals("", address.getExchangeName());
assertEquals("", address.getRoutingKey());
assertEquals("/", address.toString());
assertThat(address.getExchangeName()).isEqualTo("");
assertThat(address.getRoutingKey()).isEqualTo("");
assertThat(address.toString()).isEqualTo("/");
}
@Test
@@ -91,16 +90,16 @@ public class AddressTests {
props.setReplyTo(replyTo);
Message message = new Message("foo".getBytes(), props);
Address address = message.getMessageProperties().getReplyToAddress();
assertEquals("", address.getExchangeName());
assertEquals(replyTo, address.getRoutingKey());
assertThat(address.getExchangeName()).isEqualTo("");
assertThat(address.getRoutingKey()).isEqualTo(replyTo);
address = props.getReplyToAddress();
assertEquals("", address.getExchangeName());
assertEquals(replyTo, address.getRoutingKey());
assertThat(address.getExchangeName()).isEqualTo("");
assertThat(address.getRoutingKey()).isEqualTo(replyTo);
}
@Test
public void testEquals() {
assertEquals(new Address("foo/bar"), new Address("foo/bar"));
assertThat(new Address("foo/bar")).isEqualTo(new Address("foo/bar"));
}
}

75
spring-amqp/src/test/java/org/springframework/amqp/core/BindingBuilderTests.java
View File

@@ -16,8 +16,7 @@
package org.springframework.amqp.core;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Collections;
@@ -41,11 +40,11 @@ public class BindingBuilderTests {
public void fanoutBinding() {
FanoutExchange fanoutExchange = new FanoutExchange("f");
Binding binding = BindingBuilder.bind(queue).to(fanoutExchange);
assertNotNull(binding);
assertEquals(fanoutExchange.getName(), binding.getExchange());
assertEquals("", binding.getRoutingKey());
assertEquals(Binding.DestinationType.QUEUE, binding.getDestinationType());
assertEquals(queue.getName(), binding.getDestination());
assertThat(binding).isNotNull();
assertThat(binding.getExchange()).isEqualTo(fanoutExchange.getName());
assertThat(binding.getRoutingKey()).isEqualTo("");
assertThat(binding.getDestinationType()).isEqualTo(Binding.DestinationType.QUEUE);
assertThat(binding.getDestination()).isEqualTo(queue.getName());
}
@Test
@@ -53,22 +52,22 @@ public class BindingBuilderTests {
DirectExchange directExchange = new DirectExchange("d");
String routingKey = "r";
Binding binding = BindingBuilder.bind(queue).to(directExchange).with(routingKey);
assertNotNull(binding);
assertEquals(directExchange.getName(), binding.getExchange());
assertEquals(Binding.DestinationType.QUEUE, binding.getDestinationType());
assertEquals(queue.getName(), binding.getDestination());
assertEquals(routingKey, binding.getRoutingKey());
assertThat(binding).isNotNull();
assertThat(binding.getExchange()).isEqualTo(directExchange.getName());
assertThat(binding.getDestinationType()).isEqualTo(Binding.DestinationType.QUEUE);
assertThat(binding.getDestination()).isEqualTo(queue.getName());
assertThat(binding.getRoutingKey()).isEqualTo(routingKey);
}
@Test
public void directBindingWithQueueName() {
DirectExchange directExchange = new DirectExchange("d");
Binding binding = BindingBuilder.bind(queue).to(directExchange).withQueueName();
assertNotNull(binding);
assertEquals(directExchange.getName(), binding.getExchange());
assertEquals(Binding.DestinationType.QUEUE, binding.getDestinationType());
assertEquals(queue.getName(), binding.getDestination());
assertEquals(queue.getName(), binding.getRoutingKey());
assertThat(binding).isNotNull();
assertThat(binding.getExchange()).isEqualTo(directExchange.getName());
assertThat(binding.getDestinationType()).isEqualTo(Binding.DestinationType.QUEUE);
assertThat(binding.getDestination()).isEqualTo(queue.getName());
assertThat(binding.getRoutingKey()).isEqualTo(queue.getName());
}
@Test
@@ -76,11 +75,11 @@ public class BindingBuilderTests {
TopicExchange topicExchange = new TopicExchange("t");
String routingKey = "r";
Binding binding = BindingBuilder.bind(queue).to(topicExchange).with(routingKey);
assertNotNull(binding);
assertEquals(topicExchange.getName(), binding.getExchange());
assertEquals(Binding.DestinationType.QUEUE, binding.getDestinationType());
assertEquals(queue.getName(), binding.getDestination());
assertEquals(routingKey, binding.getRoutingKey());
assertThat(binding).isNotNull();
assertThat(binding.getExchange()).isEqualTo(topicExchange.getName());
assertThat(binding.getDestinationType()).isEqualTo(Binding.DestinationType.QUEUE);
assertThat(binding.getDestination()).isEqualTo(queue.getName());
assertThat(binding.getRoutingKey()).isEqualTo(routingKey);
}
@Test
@@ -88,11 +87,11 @@ public class BindingBuilderTests {
HeadersExchange headersExchange = new HeadersExchange("h");
String headerKey = "headerKey";
Binding binding = BindingBuilder.bind(queue).to(headersExchange).where(headerKey).exists();
assertNotNull(binding);
assertEquals(headersExchange.getName(), binding.getExchange());
assertEquals(Binding.DestinationType.QUEUE, binding.getDestinationType());
assertEquals(queue.getName(), binding.getDestination());
assertEquals("", binding.getRoutingKey());
assertThat(binding).isNotNull();
assertThat(binding.getExchange()).isEqualTo(headersExchange.getName());
assertThat(binding.getDestinationType()).isEqualTo(Binding.DestinationType.QUEUE);
assertThat(binding.getDestination()).isEqualTo(queue.getName());
assertThat(binding.getRoutingKey()).isEqualTo("");
}
@Test
@@ -115,12 +114,12 @@ public class BindingBuilderTests {
to(customExchange).//
with(routingKey).//
and(Collections.<String, Object>singletonMap("k", argumentObject));
assertNotNull(binding);
assertEquals(argumentObject, binding.getArguments().get("k"));
assertEquals(customExchange.getName(), binding.getExchange());
assertEquals(Binding.DestinationType.QUEUE, binding.getDestinationType());
assertEquals(queue.getName(), binding.getDestination());
assertEquals(routingKey, binding.getRoutingKey());
assertThat(binding).isNotNull();
assertThat(binding.getArguments().get("k")).isEqualTo(argumentObject);
assertThat(binding.getExchange()).isEqualTo(customExchange.getName());
assertThat(binding.getDestinationType()).isEqualTo(Binding.DestinationType.QUEUE);
assertThat(binding.getDestination()).isEqualTo(queue.getName());
assertThat(binding.getRoutingKey()).isEqualTo(routingKey);
}
@Test
@@ -128,11 +127,11 @@ public class BindingBuilderTests {
DirectExchange directExchange = new DirectExchange("d");
FanoutExchange fanoutExchange = new FanoutExchange("f");
Binding binding = BindingBuilder.bind(directExchange).to(fanoutExchange);
assertNotNull(binding);
assertEquals(fanoutExchange.getName(), binding.getExchange());
assertEquals(Binding.DestinationType.EXCHANGE, binding.getDestinationType());
assertEquals(directExchange.getName(), binding.getDestination());
assertEquals("", binding.getRoutingKey());
assertThat(binding).isNotNull();
assertThat(binding.getExchange()).isEqualTo(fanoutExchange.getName());
assertThat(binding.getDestinationType()).isEqualTo(Binding.DestinationType.EXCHANGE);
assertThat(binding.getDestination()).isEqualTo(directExchange.getName());
assertThat(binding.getRoutingKey()).isEqualTo("");
}
}

20
spring-amqp/src/test/java/org/springframework/amqp/core/MessagePropertiesTests.java
View File

@@ -16,9 +16,7 @@
package org.springframework.amqp.core;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.HashSet;
import java.util.Set;
@@ -42,14 +40,14 @@ public class MessagePropertiesTests {
public void testReplyTo() {
MessageProperties properties = new MessageProperties();
properties.setReplyTo("foo/bar");
assertEquals("bar", properties.getReplyToAddress().getRoutingKey());
assertThat(properties.getReplyToAddress().getRoutingKey()).isEqualTo("bar");
}
@Test
public void testReplyToNullByDefault() {
MessageProperties properties = new MessageProperties();
assertEquals(null, properties.getReplyTo());
assertEquals(null, properties.getReplyToAddress());
assertThat(properties.getReplyTo()).isEqualTo(null);
assertThat(properties.getReplyToAddress()).isEqualTo(null);
}
@Test
@@ -57,30 +55,30 @@ public class MessagePropertiesTests {
MessageProperties properties = new MessageProperties();
Integer delay = 100;
properties.setDelay(delay);
assertEquals(delay, properties.getHeaders().get(MessageProperties.X_DELAY));
assertThat(properties.getHeaders().get(MessageProperties.X_DELAY)).isEqualTo(delay);
properties.setDelay(null);
assertFalse(properties.getHeaders().containsKey(MessageProperties.X_DELAY));
assertThat(properties.getHeaders().containsKey(MessageProperties.X_DELAY)).isFalse();
}
@Test
public void testContentLengthSet() {
MessageProperties properties = new MessageProperties();
properties.setContentLength(1L);
assertTrue(properties.isContentLengthSet());
assertThat(properties.isContentLengthSet()).isTrue();
}
@Test
public void tesNoNullPointerInEquals() {
MessageProperties mp = new MessageProperties();
MessageProperties mp2 = new MessageProperties();
assertTrue(mp.equals(mp2));
assertThat(mp.equals(mp2)).isTrue();
}
@Test
public void tesNoNullPointerInHashCode() {
Set<MessageProperties> messageList = new HashSet<>();
messageList.add(new MessageProperties());
assertEquals(1, messageList.size());
assertThat(messageList.size()).isEqualTo(1);
}
}

28
spring-amqp/src/test/java/org/springframework/amqp/core/MessageTests.java
View File

@@ -16,11 +16,7 @@
package org.springframework.amqp.core;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@@ -45,19 +41,19 @@ public class MessageTests {
@Test
public void toStringForEmptyMessageBody() {
Message message = new Message(new byte[0], new MessageProperties());
assertNotNull(message.toString());
assertThat(message.toString()).isNotNull();
}
@Test
public void toStringForNullMessageProperties() {
Message message = new Message(new byte[0], null);
assertNotNull(message.toString());
assertThat(message.toString()).isNotNull();
}
@Test
public void toStringForNonStringMessageBody() {
Message message = new Message(SerializationUtils.serialize(new Date()), null);
assertNotNull(message.toString());
assertThat(message.toString()).isNotNull();
}
@Test
@@ -65,7 +61,7 @@ public class MessageTests {
MessageProperties messageProperties = new MessageProperties();
messageProperties.setContentType(MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT);
Message message = new Message(SerializationUtils.serialize(new Date()), messageProperties);
assertNotNull(message.toString());
assertThat(message.toString()).isNotNull();
}
@Test
@@ -73,7 +69,7 @@ public class MessageTests {
MessageProperties messageProperties = new MessageProperties();
messageProperties.setContentType(MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT);
Message message = new Message("foo".getBytes(), messageProperties);
assertNotNull(message.toString());
assertThat(message.toString()).isNotNull();
}
@Test
@@ -89,20 +85,20 @@ public class MessageTests {
os.close();
ObjectInputStream is = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
Message out = (Message) is.readObject();
assertEquals(new String(message.getBody()), new String(out.getBody()));
assertEquals(message.toString(), out.toString());
assertThat(new String(out.getBody())).isEqualTo(new String(message.getBody()));
assertThat(out.toString()).isEqualTo(message.toString());
}
@Test
public void fooNotDeserialized() {
Message message = new SimpleMessageConverter().toMessage(new Foo(), new MessageProperties());
assertThat(message.toString(), not(containsString("aFoo")));
assertThat(message.toString()).doesNotContainPattern("aFoo");
Message listMessage = new SimpleMessageConverter().toMessage(Collections.singletonList(new Foo()),
new MessageProperties());
assertThat(listMessage.toString(), not(containsString("aFoo")));
assertThat(listMessage.toString()).doesNotContainPattern("aFoo");
Message.addWhiteListPatterns(Foo.class.getName());
assertThat(message.toString(), containsString("aFoo"));
assertThat(listMessage.toString(), containsString("aFoo"));
assertThat(message.toString()).contains("aFoo");
assertThat(listMessage.toString()).contains("aFoo");
}
@SuppressWarnings("serial")

26
spring-amqp/src/test/java/org/springframework/amqp/core/QueueBuilderTests.java
View File

@@ -16,11 +16,7 @@
package org.springframework.amqp.core;
import static org.hamcrest.Matchers.hasEntry;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.HashMap;
import java.util.Map;
@@ -39,30 +35,30 @@ public class QueueBuilderTests {
public void buildsDurableQueue() {
Queue queue = QueueBuilder.durable("name").build();
assertTrue(queue.isDurable());
assertEquals("name", queue.getName());
assertThat(queue.isDurable()).isTrue();
assertThat(queue.getName()).isEqualTo("name");
}
@Test
public void buildsNonDurableQueue() {
Queue queue = QueueBuilder.nonDurable("name").build();
assertFalse(queue.isDurable());
assertEquals("name", queue.getName());
assertThat(queue.isDurable()).isFalse();
assertThat(queue.getName()).isEqualTo("name");
}
@Test
public void buildsAutoDeleteQueue() {
Queue queue = QueueBuilder.durable("name").autoDelete().build();
assertTrue(queue.isAutoDelete());
assertThat(queue.isAutoDelete()).isTrue();
}
@Test
public void buildsExclusiveQueue() {
Queue queue = QueueBuilder.durable("name").exclusive().build();
assertTrue(queue.isExclusive());
assertThat(queue.isExclusive()).isTrue();
}
@Test
@@ -72,8 +68,8 @@ public class QueueBuilderTests {
.withArgument("key2", "value2")
.build();
assertThat(queue.getArguments(), hasEntry("key1", (Object) "value1"));
assertThat(queue.getArguments(), hasEntry("key2", (Object) "value2"));
assertThat(queue.getArguments()).containsEntry("key1", "value1");
assertThat(queue.getArguments()).containsEntry("key2", "value2");
}
@Test
@@ -84,8 +80,8 @@ public class QueueBuilderTests {
Queue queue = QueueBuilder.durable("name").withArguments(arguments).build();
assertThat(queue.getArguments(), hasEntry("key1", (Object) "value1"));
assertThat(queue.getArguments(), hasEntry("key2", (Object) "value2"));
assertThat(queue.getArguments()).containsEntry("key1", "value1");
assertThat(queue.getArguments()).containsEntry("key2", "value2");
}
}

11
spring-amqp/src/test/java/org/springframework/amqp/core/QueueNameTests.java
View File

@@ -16,9 +16,7 @@
package org.springframework.amqp.core;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.regex.Pattern;
@@ -34,12 +32,11 @@ public class QueueNameTests {
@Test
public void testAnonymous() {
AnonymousQueue q = new AnonymousQueue();
assertThat(q.getName(), startsWith("spring.gen-"));
assertThat(q.getName()).startsWith("spring.gen-");
q = new AnonymousQueue(new Base64UrlNamingStrategy("foo-"));
assertThat(q.getName(), startsWith("foo-"));
assertThat(q.getName()).startsWith("foo-");
q = new AnonymousQueue(UUIDNamingStrategy.DEFAULT);
assertTrue("Not a UUID: " + q.getName(),
Pattern.matches("[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}", q.getName()));
assertThat(Pattern.matches("[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}", q.getName())).as("Not a UUID: " + q.getName()).isTrue();
}
}

75
spring-amqp/src/test/java/org/springframework/amqp/core/builder/BuilderTests.java
View File

@@ -16,12 +16,7 @@
package org.springframework.amqp.core.builder;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
@@ -44,56 +39,56 @@ public class BuilderTests {
@Test
public void testQueueBuilder() {
Queue queue = QueueBuilder.durable("foo").autoDelete().exclusive().withArgument("foo", "bar").build();
assertThat(queue.getName(), equalTo("foo"));
assertTrue(queue.isAutoDelete());
assertTrue(queue.isExclusive());
assertTrue(queue.isDurable());
assertThat((String) queue.getArguments().get("foo"), equalTo("bar"));
assertThat(queue.getName()).isEqualTo("foo");
assertThat(queue.isAutoDelete()).isTrue();
assertThat(queue.isExclusive()).isTrue();
assertThat(queue.isDurable()).isTrue();
assertThat((String) queue.getArguments().get("foo")).isEqualTo("bar");
queue = QueueBuilder.nonDurable().build();
assertThat(queue.getName(), startsWith("spring.gen-"));
assertFalse(queue.isAutoDelete());
assertFalse(queue.isExclusive());
assertFalse(queue.isDurable());
assertThat(queue.getName()).startsWith("spring.gen-");
assertThat(queue.isAutoDelete()).isFalse();
assertThat(queue.isExclusive()).isFalse();
assertThat(queue.isDurable()).isFalse();
queue = QueueBuilder.durable().build();
assertThat(queue.getName(), startsWith("spring.gen-"));
assertFalse(queue.isAutoDelete());
assertFalse(queue.isExclusive());
assertTrue(queue.isDurable());
assertThat(queue.getName()).startsWith("spring.gen-");
assertThat(queue.isAutoDelete()).isFalse();
assertThat(queue.isExclusive()).isFalse();
assertThat(queue.isDurable()).isTrue();
}
@Test
public void testExchangeBuilder() {
Exchange exchange = ExchangeBuilder.directExchange("foo").autoDelete().delayed().internal()
.withArgument("foo", "bar").build();
assertThat(exchange, instanceOf(DirectExchange.class));
assertTrue(exchange.isAutoDelete());
assertTrue(exchange.isDurable());
assertTrue(exchange.isInternal());
assertTrue(exchange.isDelayed());
assertThat((String) exchange.getArguments().get("foo"), equalTo("bar"));
assertThat(exchange).isInstanceOf(DirectExchange.class);
assertThat(exchange.isAutoDelete()).isTrue();
assertThat(exchange.isDurable()).isTrue();
assertThat(exchange.isInternal()).isTrue();
assertThat(exchange.isDelayed()).isTrue();
assertThat((String) exchange.getArguments().get("foo")).isEqualTo("bar");
exchange = ExchangeBuilder.topicExchange("foo").durable(false).build();
assertThat(exchange, instanceOf(TopicExchange.class));
assertFalse(exchange.isAutoDelete());
assertFalse(exchange.isDurable());
assertFalse(exchange.isInternal());
assertFalse(exchange.isDelayed());
assertThat(exchange).isInstanceOf(TopicExchange.class);
assertThat(exchange.isAutoDelete()).isFalse();
assertThat(exchange.isDurable()).isFalse();
assertThat(exchange.isInternal()).isFalse();
assertThat(exchange.isDelayed()).isFalse();
exchange = ExchangeBuilder.fanoutExchange("foo").build();
assertThat(exchange, instanceOf(FanoutExchange.class));
assertFalse(exchange.isAutoDelete());
assertTrue(exchange.isDurable());
assertFalse(exchange.isInternal());
assertFalse(exchange.isDelayed());
assertThat(exchange).isInstanceOf(FanoutExchange.class);
assertThat(exchange.isAutoDelete()).isFalse();
assertThat(exchange.isDurable()).isTrue();
assertThat(exchange.isInternal()).isFalse();
assertThat(exchange.isDelayed()).isFalse();
exchange = ExchangeBuilder.headersExchange("foo").build();
assertThat(exchange, instanceOf(HeadersExchange.class));
assertFalse(exchange.isAutoDelete());
assertTrue(exchange.isDurable());
assertFalse(exchange.isInternal());
assertFalse(exchange.isDelayed());
assertThat(exchange).isInstanceOf(HeadersExchange.class);
assertThat(exchange.isAutoDelete()).isFalse();
assertThat(exchange.isDurable()).isTrue();
assertThat(exchange.isInternal()).isFalse();
assertThat(exchange.isDelayed()).isFalse();
}
}

145
spring-amqp/src/test/java/org/springframework/amqp/core/builder/MessageBuilderTests.java
View File

@@ -16,11 +16,7 @@
package org.springframework.amqp.core.builder;
import static org.junit.Assert.assertEquals;
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.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
import java.util.Collections;
@@ -54,28 +50,27 @@ public class MessageBuilderTests {
Message message1 = MessageBuilder.withBody(bytes)
.andProperties(properties)
.build();
assertSame(bytes, message1.getBody());
assertEquals("replyTo", message1.getMessageProperties().getReplyTo());
assertThat(message1.getBody()).isSameAs(bytes);
assertThat(message1.getMessageProperties().getReplyTo()).isEqualTo("replyTo");
Message message2 = MessageBuilder.fromMessage(message1)
.setReplyTo("foo")
.build();
assertSame(bytes, message2.getBody());
assertNotSame(message1.getMessageProperties(), message2.getMessageProperties());
assertEquals(message1.getMessageProperties(),
MessageBuilder.fromMessage(message2).setReplyTo("replyTo").build().getMessageProperties());
assertEquals("foo", message2.getMessageProperties().getReplyTo());
assertThat(message2.getBody()).isSameAs(bytes);
assertThat(message2.getMessageProperties()).isNotSameAs(message1.getMessageProperties());
assertThat(MessageBuilder.fromMessage(message2).setReplyTo("replyTo").build().getMessageProperties()).isEqualTo(message1.getMessageProperties());
assertThat(message2.getMessageProperties().getReplyTo()).isEqualTo("foo");
Message message3 = MessageBuilder.fromClonedMessage(message1)
.setReplyToIfAbsent("foo")
.build();
assertEquals("replyTo", message3.getMessageProperties().getReplyTo());
assertThat(message3.getMessageProperties().getReplyTo()).isEqualTo("replyTo");
Message message4 = MessageBuilder.fromClonedMessage(message1)
.setReplyTo(null)
.setReplyToIfAbsent("foo")
.build();
assertEquals("foo", message4.getMessageProperties().getReplyTo());
assertThat(message4.getMessageProperties().getReplyTo()).isEqualTo("foo");
}
@@ -90,30 +85,30 @@ public class MessageBuilderTests {
.setReplyToAddressIfAbsent(new Address("addressxxxx"))
.build())
.build();
assertNotSame(bytes, message1.getBody());
assertTrue(Arrays.equals(bytes, message1.getBody()));
assertEquals(replyTo.toString(), message1.getMessageProperties().getReplyToAddress().toString());
assertThat(message1.getBody()).isNotSameAs(bytes);
assertThat(Arrays.equals(bytes, message1.getBody())).isTrue();
assertThat(message1.getMessageProperties().getReplyToAddress().toString()).isEqualTo(replyTo.toString());
Address foo = new Address("foo");
Message message2 = MessageBuilder.fromClonedMessage(message1)
.setReplyToAddress(foo)
.build();
assertNotSame(message1.getBody(), message2.getBody());
assertTrue(Arrays.equals(bytes, message2.getBody()));
assertEquals(message1.getMessageProperties(), MessageBuilder.fromMessage(message2)
.setReplyToAddress(replyTo).build().getMessageProperties());
assertEquals(foo.toString(), message2.getMessageProperties().getReplyToAddress().toString());
assertThat(message2.getBody()).isNotSameAs(message1.getBody());
assertThat(Arrays.equals(bytes, message2.getBody())).isTrue();
assertThat(MessageBuilder.fromMessage(message2)
.setReplyToAddress(replyTo).build().getMessageProperties()).isEqualTo(message1.getMessageProperties());
assertThat(message2.getMessageProperties().getReplyToAddress().toString()).isEqualTo(foo.toString());
Message message3 = MessageBuilder.fromClonedMessage(message1)
.setReplyToAddressIfAbsent(foo)
.build();
assertEquals(replyTo.toString(), message3.getMessageProperties().getReplyToAddress().toString());
assertThat(message3.getMessageProperties().getReplyToAddress().toString()).isEqualTo(replyTo.toString());
Message message4 = MessageBuilder.fromClonedMessage(message1)
.setReplyToAddress(null)
.setReplyToAddressIfAbsent(foo)
.build();
assertEquals(foo.toString(), message4.getMessageProperties().getReplyToAddress().toString());
assertThat(message4.getMessageProperties().getReplyToAddress().toString()).isEqualTo(foo.toString());
}
@Test
@@ -123,12 +118,12 @@ public class MessageBuilderTests {
.andProperties(this.setAll(MessagePropertiesBuilder.newInstance())
.build())
.build();
assertTrue(Arrays.equals("oba".getBytes(), message1.getBody()));
assertThat(Arrays.equals("oba".getBytes(), message1.getBody())).isTrue();
Message message2 = MessageBuilder.fromClonedMessage(message1).build();
assertNotSame(message1.getBody(), message2.getBody());
assertTrue(Arrays.equals(message1.getBody(), message2.getBody()));
assertEquals(message1.getMessageProperties(), message2.getMessageProperties());
assertThat(message2.getBody()).isNotSameAs(message1.getBody());
assertThat(Arrays.equals(message1.getBody(), message2.getBody())).isTrue();
assertThat(message2.getMessageProperties()).isEqualTo(message1.getMessageProperties());
}
@Test
@@ -139,25 +134,25 @@ public class MessageBuilderTests {
.setReplyTo("replyTo")
.build())
.build();
assertSame(bytes, message1.getBody());
assertThat(message1.getBody()).isSameAs(bytes);
Message message2 = MessageBuilder.withBody("bar".getBytes())
.copyProperties(message1.getMessageProperties())
.build();
assertNotSame(message1.getMessageProperties(), message2.getMessageProperties());
assertEquals(message1.getMessageProperties(), message2.getMessageProperties());
assertThat(message2.getMessageProperties()).isNotSameAs(message1.getMessageProperties());
assertThat(message2.getMessageProperties()).isEqualTo(message1.getMessageProperties());
Message message3 = MessageBuilder.withBody("bar".getBytes())
.copyProperties(message1.getMessageProperties())
.removeHeader("foo")
.build();
assertEquals(2, message3.getMessageProperties().getHeaders().size());
assertThat(message3.getMessageProperties().getHeaders().size()).isEqualTo(2);
Message message4 = MessageBuilder.withBody("bar".getBytes())
.copyProperties(message1.getMessageProperties())
.removeHeaders()
.build();
assertEquals(0, message4.getMessageProperties().getHeaders().size());
assertThat(message4.getMessageProperties().getHeaders().size()).isEqualTo(0);
}
@Test
@@ -315,51 +310,51 @@ public class MessageBuilderTests {
}
private void assertLower(MessageProperties properties) {
assertEquals("appId", properties.getAppId());
assertEquals("clusterId", properties.getClusterId());
assertEquals("contentEncoding", properties.getContentEncoding());
assertEquals(MessageProperties.CONTENT_TYPE_TEXT_PLAIN, properties.getContentType());
assertEquals(1, properties.getContentLength());
assertEquals("correlationId", properties.getCorrelationId());
assertEquals(MessageDeliveryMode.NON_PERSISTENT, properties.getDeliveryMode());
assertEquals(2, properties.getDeliveryTag());
assertEquals("expiration", properties.getExpiration());
assertEquals("bar", properties.getHeaders().get("foo"));
assertEquals("fiz", properties.getHeaders().get("qux"));
assertEquals("fuz", properties.getHeaders().get("baz"));
assertEquals(Integer.valueOf(3), properties.getMessageCount());
assertEquals("messageId", properties.getMessageId());
assertEquals(Integer.valueOf(4), properties.getPriority());
assertEquals("receivedExchange", properties.getReceivedExchange());
assertEquals("receivedRoutingKey", properties.getReceivedRoutingKey());
assertTrue(properties.getRedelivered());
assertTrue(properties.getTimestamp().getTime() > 0);
assertEquals("type", properties.getType());
assertEquals("userId", properties.getUserId());
assertThat(properties.getAppId()).isEqualTo("appId");
assertThat(properties.getClusterId()).isEqualTo("clusterId");
assertThat(properties.getContentEncoding()).isEqualTo("contentEncoding");
assertThat(properties.getContentType()).isEqualTo(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
assertThat(properties.getContentLength()).isEqualTo(1);
assertThat(properties.getCorrelationId()).isEqualTo("correlationId");
assertThat(properties.getDeliveryMode()).isEqualTo(MessageDeliveryMode.NON_PERSISTENT);
assertThat(properties.getDeliveryTag()).isEqualTo(2);
assertThat(properties.getExpiration()).isEqualTo("expiration");
assertThat(properties.getHeaders().get("foo")).isEqualTo("bar");
assertThat(properties.getHeaders().get("qux")).isEqualTo("fiz");
assertThat(properties.getHeaders().get("baz")).isEqualTo("fuz");
assertThat(properties.getMessageCount()).isEqualTo(Integer.valueOf(3));
assertThat(properties.getMessageId()).isEqualTo("messageId");
assertThat(properties.getPriority()).isEqualTo(Integer.valueOf(4));
assertThat(properties.getReceivedExchange()).isEqualTo("receivedExchange");
assertThat(properties.getReceivedRoutingKey()).isEqualTo("receivedRoutingKey");
assertThat(properties.getRedelivered()).isTrue();
assertThat(properties.getTimestamp().getTime() > 0).isTrue();
assertThat(properties.getType()).isEqualTo("type");
assertThat(properties.getUserId()).isEqualTo("userId");
}
private void assertUpper(MessageProperties properties) {
assertEquals("APPID", properties.getAppId());
assertEquals("CLUSTERID", properties.getClusterId());
assertEquals("CONTENTENCODING", properties.getContentEncoding());
assertEquals(MessageProperties.CONTENT_TYPE_BYTES, properties.getContentType());
assertEquals(10, properties.getContentLength());
assertEquals("CORRELATIONID", properties.getCorrelationId());
assertEquals(MessageDeliveryMode.PERSISTENT, properties.getDeliveryMode());
assertEquals(20, properties.getDeliveryTag());
assertEquals("EXPIRATION", properties.getExpiration());
assertEquals("BAR", properties.getHeaders().get("foo"));
assertEquals("FIZ", properties.getHeaders().get("qux"));
assertEquals("FUZ", properties.getHeaders().get("baz"));
assertEquals(Integer.valueOf(30), properties.getMessageCount());
assertEquals("MESSAGEID", properties.getMessageId());
assertEquals(Integer.valueOf(40), properties.getPriority());
assertEquals("RECEIVEDEXCHANGE", properties.getReceivedExchange());
assertEquals("RECEIVEDROUTINGKEY", properties.getReceivedRoutingKey());
assertFalse(properties.getRedelivered());
assertTrue(properties.getTimestamp().getTime() == 0);
assertEquals("TYPE", properties.getType());
assertEquals("USERID", properties.getUserId());
assertThat(properties.getAppId()).isEqualTo("APPID");
assertThat(properties.getClusterId()).isEqualTo("CLUSTERID");
assertThat(properties.getContentEncoding()).isEqualTo("CONTENTENCODING");
assertThat(properties.getContentType()).isEqualTo(MessageProperties.CONTENT_TYPE_BYTES);
assertThat(properties.getContentLength()).isEqualTo(10);
assertThat(properties.getCorrelationId()).isEqualTo("CORRELATIONID");
assertThat(properties.getDeliveryMode()).isEqualTo(MessageDeliveryMode.PERSISTENT);
assertThat(properties.getDeliveryTag()).isEqualTo(20);
assertThat(properties.getExpiration()).isEqualTo("EXPIRATION");
assertThat(properties.getHeaders().get("foo")).isEqualTo("BAR");
assertThat(properties.getHeaders().get("qux")).isEqualTo("FIZ");
assertThat(properties.getHeaders().get("baz")).isEqualTo("FUZ");
assertThat(properties.getMessageCount()).isEqualTo(Integer.valueOf(30));
assertThat(properties.getMessageId()).isEqualTo("MESSAGEID");
assertThat(properties.getPriority()).isEqualTo(Integer.valueOf(40));
assertThat(properties.getReceivedExchange()).isEqualTo("RECEIVEDEXCHANGE");
assertThat(properties.getReceivedRoutingKey()).isEqualTo("RECEIVEDROUTINGKEY");
assertThat(properties.getRedelivered()).isFalse();
assertThat(properties.getTimestamp().getTime() == 0).isTrue();
assertThat(properties.getType()).isEqualTo("TYPE");
assertThat(properties.getUserId()).isEqualTo("USERID");
}
}

16
spring-amqp/src/test/java/org/springframework/amqp/remoting/RemotingTest.java
View File

@@ -16,11 +16,7 @@
package org.springframework.amqp.remoting;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.concurrent.atomic.AtomicBoolean;
@@ -104,7 +100,7 @@ public class RemotingTest {
@Test
public void testEcho() {
assertEquals("Echo Test", riggedProxy.simpleStringReturningTestMethod("Test"));
assertThat(riggedProxy.simpleStringReturningTestMethod("Test")).isEqualTo("Echo Test");
}
@Test
@@ -113,7 +109,7 @@ public class RemotingTest {
this.riggedProxy.simulatedTimeoutMethod("timeout");
}
catch (RemoteProxyFailureException e) {
assertThat(e.getMessage(), containsString("'simulatedTimeoutMethod' with arguments '[timeout]'"));
assertThat(e.getMessage()).contains("'simulatedTimeoutMethod' with arguments '[timeout]'");
}
}
@@ -131,7 +127,7 @@ public class RemotingTest {
@Test
public void testActuallyExceptionReturningMethod() {
SpecialException returnedException = riggedProxy.actuallyExceptionReturningMethod();
assertNotNull(returnedException);
assertThat(returnedException).isNotNull();
}
@Test
@@ -157,8 +153,8 @@ public class RemotingTest {
riggedProxy.simpleStringReturningTestMethod("Test");
}
catch (Exception e) {
assertThat(e, instanceOf(IllegalArgumentException.class));
assertThat(e.getMessage(), containsString("The message does not contain a RemoteInvocation payload"));
assertThat(e).isInstanceOf(IllegalArgumentException.class);
assertThat(e.getMessage()).contains("The message does not contain a RemoteInvocation payload");
}
this.serviceExporter.setMessageConverter(messageConverter);

45
spring-amqp/src/test/java/org/springframework/amqp/support/AmqpMessageHeaderAccessorTests.java
View File

@@ -16,8 +16,7 @@
package org.springframework.amqp.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Date;
import java.util.Map;
@@ -73,28 +72,28 @@ public class AmqpMessageHeaderAccessorTests {
Message<String> message = MessageBuilder.withPayload("test").copyHeaders(mappedHeaders).build();
AmqpMessageHeaderAccessor headerAccessor = AmqpMessageHeaderAccessor.wrap(message);
assertEquals("app-id-1234", headerAccessor.getAppId());
assertEquals("cluster-id-1234", headerAccessor.getClusterId());
assertEquals("UTF-16", headerAccessor.getContentEncoding());
assertEquals(Long.valueOf(200), headerAccessor.getContentLength());
assertEquals(MimeType.valueOf("text/plain"), headerAccessor.getContentType());
assertEquals(correlationId, headerAccessor.getCorrelationId());
assertEquals(MessageDeliveryMode.NON_PERSISTENT, headerAccessor.getReceivedDeliveryMode());
assertEquals(Long.valueOf(555), headerAccessor.getDeliveryTag());
assertEquals("expiration-1234", headerAccessor.getExpiration());
assertEquals(Integer.valueOf(42), headerAccessor.getMessageCount());
assertEquals("message-id-1234", headerAccessor.getMessageId());
assertEquals(Integer.valueOf(9), headerAccessor.getPriority());
assertEquals("received-exchange-1234", headerAccessor.getReceivedExchange());
assertEquals("received-routing-key-1234", headerAccessor.getReceivedRoutingKey());
assertEquals(true, headerAccessor.getRedelivered());
assertEquals("reply-to-1234", headerAccessor.getReplyTo());
assertEquals(Long.valueOf(timestamp.getTime()), headerAccessor.getTimestamp());
assertEquals("type-1234", headerAccessor.getType());
assertEquals("user-id-1234", headerAccessor.getReceivedUserId());
assertThat(headerAccessor.getAppId()).isEqualTo("app-id-1234");
assertThat(headerAccessor.getClusterId()).isEqualTo("cluster-id-1234");
assertThat(headerAccessor.getContentEncoding()).isEqualTo("UTF-16");
assertThat(headerAccessor.getContentLength()).isEqualTo(Long.valueOf(200));
assertThat(headerAccessor.getContentType()).isEqualTo(MimeType.valueOf("text/plain"));
assertThat(headerAccessor.getCorrelationId()).isEqualTo(correlationId);
assertThat(headerAccessor.getReceivedDeliveryMode()).isEqualTo(MessageDeliveryMode.NON_PERSISTENT);
assertThat(headerAccessor.getDeliveryTag()).isEqualTo(Long.valueOf(555));
assertThat(headerAccessor.getExpiration()).isEqualTo("expiration-1234");
assertThat(headerAccessor.getMessageCount()).isEqualTo(Integer.valueOf(42));
assertThat(headerAccessor.getMessageId()).isEqualTo("message-id-1234");
assertThat(headerAccessor.getPriority()).isEqualTo(Integer.valueOf(9));
assertThat(headerAccessor.getReceivedExchange()).isEqualTo("received-exchange-1234");
assertThat(headerAccessor.getReceivedRoutingKey()).isEqualTo("received-routing-key-1234");
assertThat(headerAccessor.getRedelivered()).isEqualTo(true);
assertThat(headerAccessor.getReplyTo()).isEqualTo("reply-to-1234");
assertThat(headerAccessor.getTimestamp()).isEqualTo(Long.valueOf(timestamp.getTime()));
assertThat(headerAccessor.getType()).isEqualTo("type-1234");
assertThat(headerAccessor.getReceivedUserId()).isEqualTo("user-id-1234");
// Making sure replyChannel is not mixed with replyTo
assertNull(headerAccessor.getReplyChannel());
assertThat(headerAccessor.getReplyChannel()).isNull();
}
@Test
@@ -102,7 +101,7 @@ public class AmqpMessageHeaderAccessorTests {
Message<?> message = MessageBuilder.withPayload("payload").
setHeader(AmqpMessageHeaderAccessor.PRIORITY, 90).build();
AmqpMessageHeaderAccessor accessor = new AmqpMessageHeaderAccessor(message);
assertEquals(Integer.valueOf(90), accessor.getPriority());
assertThat(accessor.getPriority()).isEqualTo(Integer.valueOf(90));
}
@Test

22
spring-amqp/src/test/java/org/springframework/amqp/support/MessagePostProcessorUtilsTests.java
View File

@@ -16,9 +16,7 @@
package org.springframework.amqp.support;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
import java.util.Collection;
@@ -52,19 +50,19 @@ public class MessagePostProcessorUtilsTests {
Collection<MessagePostProcessor> sorted = MessagePostProcessorUtils.sort(Arrays.<MessagePostProcessor>asList(pps));
Iterator<MessagePostProcessor> iterator = sorted.iterator();
MessagePostProcessor mpp = iterator.next();
assertThat(mpp, instanceOf(POMPP.class));
assertEquals(2, ((POMPP) mpp).getOrder());
assertThat(mpp).isInstanceOf(POMPP.class);
assertThat(((POMPP) mpp).getOrder()).isEqualTo(2);
mpp = iterator.next();
assertThat(mpp, instanceOf(POMPP.class));
assertEquals(6, ((POMPP) mpp).getOrder());
assertThat(mpp).isInstanceOf(POMPP.class);
assertThat(((POMPP) mpp).getOrder()).isEqualTo(6);
mpp = iterator.next();
assertThat(mpp, instanceOf(OMPP.class));
assertEquals(1, ((OMPP) mpp).getOrder());
assertThat(mpp).isInstanceOf(OMPP.class);
assertThat(((OMPP) mpp).getOrder()).isEqualTo(1);
mpp = iterator.next();
assertThat(mpp, instanceOf(OMPP.class));
assertEquals(3, ((OMPP) mpp).getOrder());
assertThat(mpp).isInstanceOf(OMPP.class);
assertThat(((OMPP) mpp).getOrder()).isEqualTo(3);
mpp = iterator.next();
assertThat(mpp, instanceOf(MPP.class));
assertThat(mpp).isInstanceOf(MPP.class);
}
class MPP implements MessagePostProcessor {

92
spring-amqp/src/test/java/org/springframework/amqp/support/SimpleAmqpHeaderMapperTests.java
View File

@@ -16,8 +16,8 @@
package org.springframework.amqp.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.util.Date;
import java.util.HashMap;
@@ -72,27 +72,27 @@ public class SimpleAmqpHeaderMapperTests {
Set<String> headerKeys = amqpProperties.getHeaders().keySet();
for (String headerKey : headerKeys) {
if (headerKey.startsWith(AmqpHeaders.PREFIX)) {
fail();
fail("No headers with 'amqp_' prefix expected");
}
}
assertEquals("test.appId", amqpProperties.getAppId());
assertEquals("test.clusterId", amqpProperties.getClusterId());
assertEquals("test.contentEncoding", amqpProperties.getContentEncoding());
assertEquals(99L, amqpProperties.getContentLength());
assertEquals("test.contentType", amqpProperties.getContentType());
assertEquals(testCorrelationId, amqpProperties.getCorrelationId());
assertEquals(MessageDeliveryMode.NON_PERSISTENT, amqpProperties.getDeliveryMode());
assertEquals(1234L, amqpProperties.getDeliveryTag());
assertEquals("test.expiration", amqpProperties.getExpiration());
assertEquals(Integer.valueOf(42), amqpProperties.getMessageCount());
assertEquals("test.messageId", amqpProperties.getMessageId());
assertEquals("test.receivedExchange", amqpProperties.getReceivedExchange());
assertEquals("test.receivedRoutingKey", amqpProperties.getReceivedRoutingKey());
assertEquals("test.replyTo", amqpProperties.getReplyTo());
assertEquals(testTimestamp, amqpProperties.getTimestamp());
assertEquals("test.type", amqpProperties.getType());
assertEquals("test.userId", amqpProperties.getUserId());
assertEquals(Integer.valueOf(1234), amqpProperties.getDelay());
assertThat(amqpProperties.getAppId()).isEqualTo("test.appId");
assertThat(amqpProperties.getClusterId()).isEqualTo("test.clusterId");
assertThat(amqpProperties.getContentEncoding()).isEqualTo("test.contentEncoding");
assertThat(amqpProperties.getContentLength()).isEqualTo(99L);
assertThat(amqpProperties.getContentType()).isEqualTo("test.contentType");
assertThat(amqpProperties.getCorrelationId()).isEqualTo(testCorrelationId);
assertThat(amqpProperties.getDeliveryMode()).isEqualTo(MessageDeliveryMode.NON_PERSISTENT);
assertThat(amqpProperties.getDeliveryTag()).isEqualTo(1234L);
assertThat(amqpProperties.getExpiration()).isEqualTo("test.expiration");
assertThat(amqpProperties.getMessageCount()).isEqualTo(Integer.valueOf(42));
assertThat(amqpProperties.getMessageId()).isEqualTo("test.messageId");
assertThat(amqpProperties.getReceivedExchange()).isEqualTo("test.receivedExchange");
assertThat(amqpProperties.getReceivedRoutingKey()).isEqualTo("test.receivedRoutingKey");
assertThat(amqpProperties.getReplyTo()).isEqualTo("test.replyTo");
assertThat(amqpProperties.getTimestamp()).isEqualTo(testTimestamp);
assertThat(amqpProperties.getType()).isEqualTo("test.type");
assertThat(amqpProperties.getUserId()).isEqualTo("test.userId");
assertThat(amqpProperties.getDelay()).isEqualTo(Integer.valueOf(1234));
}
@Test
@@ -106,7 +106,7 @@ public class SimpleAmqpHeaderMapperTests {
MessageProperties amqpProperties = new MessageProperties();
headerMapper.fromHeaders(messageHeaders, amqpProperties);
assertEquals("text/html", amqpProperties.getContentType());
assertThat(amqpProperties.getContentType()).isEqualTo("text/html");
}
@Test
@@ -140,28 +140,28 @@ public class SimpleAmqpHeaderMapperTests {
amqpProperties.setHeader(AmqpHeaders.SPRING_REPLY_CORRELATION, "test.correlation");
amqpProperties.setHeader(AmqpHeaders.SPRING_REPLY_TO_STACK, "test.replyTo2");
Map<String, Object> headerMap = headerMapper.toHeaders(amqpProperties);
assertEquals("test.appId", headerMap.get(AmqpHeaders.APP_ID));
assertEquals("test.clusterId", headerMap.get(AmqpHeaders.CLUSTER_ID));
assertEquals("test.contentEncoding", headerMap.get(AmqpHeaders.CONTENT_ENCODING));
assertEquals(99L, headerMap.get(AmqpHeaders.CONTENT_LENGTH));
assertEquals("test.contentType", headerMap.get(AmqpHeaders.CONTENT_TYPE));
assertEquals(testCorrelationId, headerMap.get(AmqpHeaders.CORRELATION_ID));
assertEquals(MessageDeliveryMode.NON_PERSISTENT, headerMap.get(AmqpHeaders.RECEIVED_DELIVERY_MODE));
assertEquals(1234L, headerMap.get(AmqpHeaders.DELIVERY_TAG));
assertEquals("test.expiration", headerMap.get(AmqpHeaders.EXPIRATION));
assertEquals(42, headerMap.get(AmqpHeaders.MESSAGE_COUNT));
assertEquals("test.messageId", headerMap.get(AmqpHeaders.MESSAGE_ID));
assertEquals(1234, headerMap.get(AmqpHeaders.RECEIVED_DELAY));
assertEquals("test.receivedExchange", headerMap.get(AmqpHeaders.RECEIVED_EXCHANGE));
assertEquals("test.receivedRoutingKey", headerMap.get(AmqpHeaders.RECEIVED_ROUTING_KEY));
assertEquals("test.replyTo", headerMap.get(AmqpHeaders.REPLY_TO));
assertEquals(testTimestamp, headerMap.get(AmqpHeaders.TIMESTAMP));
assertEquals("test.type", headerMap.get(AmqpHeaders.TYPE));
assertEquals("test.userId", headerMap.get(AmqpHeaders.RECEIVED_USER_ID));
assertEquals("test.correlation", headerMap.get(AmqpHeaders.SPRING_REPLY_CORRELATION));
assertEquals("test.replyTo2", headerMap.get(AmqpHeaders.SPRING_REPLY_TO_STACK));
assertEquals("consumer.tag", headerMap.get(AmqpHeaders.CONSUMER_TAG));
assertEquals("consumer.queue", headerMap.get(AmqpHeaders.CONSUMER_QUEUE));
assertThat(headerMap.get(AmqpHeaders.APP_ID)).isEqualTo("test.appId");
assertThat(headerMap.get(AmqpHeaders.CLUSTER_ID)).isEqualTo("test.clusterId");
assertThat(headerMap.get(AmqpHeaders.CONTENT_ENCODING)).isEqualTo("test.contentEncoding");
assertThat(headerMap.get(AmqpHeaders.CONTENT_LENGTH)).isEqualTo(99L);
assertThat(headerMap.get(AmqpHeaders.CONTENT_TYPE)).isEqualTo("test.contentType");
assertThat(headerMap.get(AmqpHeaders.CORRELATION_ID)).isEqualTo(testCorrelationId);
assertThat(headerMap.get(AmqpHeaders.RECEIVED_DELIVERY_MODE)).isEqualTo(MessageDeliveryMode.NON_PERSISTENT);
assertThat(headerMap.get(AmqpHeaders.DELIVERY_TAG)).isEqualTo(1234L);
assertThat(headerMap.get(AmqpHeaders.EXPIRATION)).isEqualTo("test.expiration");
assertThat(headerMap.get(AmqpHeaders.MESSAGE_COUNT)).isEqualTo(42);
assertThat(headerMap.get(AmqpHeaders.MESSAGE_ID)).isEqualTo("test.messageId");
assertThat(headerMap.get(AmqpHeaders.RECEIVED_DELAY)).isEqualTo(1234);
assertThat(headerMap.get(AmqpHeaders.RECEIVED_EXCHANGE)).isEqualTo("test.receivedExchange");
assertThat(headerMap.get(AmqpHeaders.RECEIVED_ROUTING_KEY)).isEqualTo("test.receivedRoutingKey");
assertThat(headerMap.get(AmqpHeaders.REPLY_TO)).isEqualTo("test.replyTo");
assertThat(headerMap.get(AmqpHeaders.TIMESTAMP)).isEqualTo(testTimestamp);
assertThat(headerMap.get(AmqpHeaders.TYPE)).isEqualTo("test.type");
assertThat(headerMap.get(AmqpHeaders.RECEIVED_USER_ID)).isEqualTo("test.userId");
assertThat(headerMap.get(AmqpHeaders.SPRING_REPLY_CORRELATION)).isEqualTo("test.correlation");
assertThat(headerMap.get(AmqpHeaders.SPRING_REPLY_TO_STACK)).isEqualTo("test.replyTo2");
assertThat(headerMap.get(AmqpHeaders.CONSUMER_TAG)).isEqualTo("consumer.tag");
assertThat(headerMap.get(AmqpHeaders.CONSUMER_QUEUE)).isEqualTo("consumer.queue");
}
@Test // INT-2090
@@ -174,9 +174,9 @@ public class SimpleAmqpHeaderMapperTests {
headerMap.put("__TypeId__", "java.lang.Integer");
MessageHeaders messageHeaders = new MessageHeaders(headerMap);
headerMapper.fromHeaders(messageHeaders, amqpProperties);
assertEquals("java.lang.String", amqpProperties.getHeaders().get("__TypeId__"));
assertThat(amqpProperties.getHeaders().get("__TypeId__")).isEqualTo("java.lang.String");
Object result = converter.fromMessage(new Message("123".getBytes(), amqpProperties));
assertEquals(String.class, result.getClass());
assertThat(result.getClass()).isEqualTo(String.class);
}
}

21
spring-amqp/src/test/java/org/springframework/amqp/support/converter/ContentTypeDelegatingMessageConverterTests.java
View File

@@ -16,11 +16,8 @@
package org.springframework.amqp.support.converter;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.io.Serializable;
@@ -49,16 +46,16 @@ public class ContentTypeDelegatingMessageConverterTests {
Foo foo = new Foo();
foo.setFoo("bar");
Message message = converter.toMessage(foo, props);
assertEquals(MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT, message.getMessageProperties().getContentType());
assertThat(message.getMessageProperties().getContentType()).isEqualTo(MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT);
Object converted = converter.fromMessage(message);
assertThat(converted, instanceOf(Foo.class));
assertThat(converted).isInstanceOf(Foo.class);
props.setContentType("foo/bar");
message = converter.toMessage(foo, props);
assertEquals(MessageProperties.CONTENT_TYPE_JSON, message.getMessageProperties().getContentType());
assertEquals("{\"foo\":\"bar\"}", new String(message.getBody()));
assertThat(message.getMessageProperties().getContentType()).isEqualTo(MessageProperties.CONTENT_TYPE_JSON);
assertThat(new String(message.getBody())).isEqualTo("{\"foo\":\"bar\"}");
converted = converter.fromMessage(message);
assertThat(converted, instanceOf(Foo.class));
assertThat(converted).isInstanceOf(Foo.class);
converter = new ContentTypeDelegatingMessageConverter(null); // no default
try {
@@ -66,8 +63,8 @@ public class ContentTypeDelegatingMessageConverterTests {
fail("Expected exception");
}
catch (Exception e) {
assertThat(e, instanceOf(MessageConversionException.class));
assertThat(e.getMessage(), containsString("No delegate converter"));
assertThat(e).isInstanceOf(MessageConversionException.class);
assertThat(e.getMessage()).contains("No delegate converter");
}
}

24
spring-amqp/src/test/java/org/springframework/amqp/support/converter/DefaultClassMapperTests.java
View File

@@ -16,11 +16,7 @@
package org.springframework.amqp.support.converter;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import java.util.HashMap;
@@ -54,8 +50,8 @@ public class DefaultClassMapperTests {
}
catch (MessageConversionException e) {
String classIdFieldName = classMapper.getClassIdFieldName();
assertThat(e.getMessage(), containsString("Could not resolve "
+ classIdFieldName + " in header"));
assertThat(e.getMessage()).contains("Could not resolve "
+ classIdFieldName + " in header");
}
}
@@ -67,7 +63,7 @@ public class DefaultClassMapperTests {
Class<String> clazz = (Class<String>) classMapper.toClass(props);
assertThat(clazz, equalTo(String.class));
assertThat(clazz).isEqualTo(String.class);
}
@Test
@@ -78,7 +74,7 @@ public class DefaultClassMapperTests {
@SuppressWarnings("rawtypes")
Class clazz = classMapper.toClass(props);
assertEquals(clazz, SimpleTrade.class);
assertThat(SimpleTrade.class).isEqualTo(clazz);
}
@@ -88,7 +84,7 @@ public class DefaultClassMapperTests {
Class<?> clazz = classMapper.toClass(props);
assertThat(clazz, equalTo(LinkedHashMap.class));
assertThat(clazz).isEqualTo(LinkedHashMap.class);
}
@Test
@@ -97,7 +93,7 @@ public class DefaultClassMapperTests {
String className = (String) props.getHeaders().get(
classMapper.getClassIdFieldName());
assertThat(className, equalTo(SimpleTrade.class.getName()));
assertThat(className).isEqualTo(SimpleTrade.class.getName());
}
@Test
@@ -109,7 +105,7 @@ public class DefaultClassMapperTests {
String className = (String) props.getHeaders().get(
classMapper.getClassIdFieldName());
assertThat(className, equalTo("daytrade"));
assertThat(className).isEqualTo("daytrade");
}
@Test
@@ -119,7 +115,7 @@ public class DefaultClassMapperTests {
String className = (String) props.getHeaders().get(
classMapper.getClassIdFieldName());
assertThat(className, equalTo("Hashtable"));
assertThat(className).isEqualTo("Hashtable");
}
@SuppressWarnings("unchecked")
@@ -129,7 +125,7 @@ public class DefaultClassMapperTests {
classMapper.setDefaultType(Foo.class);
Class<Foo> clazz = (Class<Foo>) classMapper.toClass(props);
assertSame(Foo.class, clazz);
assertThat(clazz).isSameAs(Foo.class);
classMapper.setDefaultType(LinkedHashMap.class);
}

57
spring-amqp/src/test/java/org/springframework/amqp/support/converter/DefaultJackson2JavaTypeMapperTests.java
View File

@@ -16,11 +16,8 @@
package org.springframework.amqp.support.converter;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.BDDMockito.given;
import java.util.ArrayList;
@@ -70,7 +67,7 @@ public class DefaultJackson2JavaTypeMapperTests {
@Test
public void getAnObjectWhenClassIdNotPresent() {
JavaType javaType = javaTypeMapper.toJavaType(properties);
assertEquals(Object.class, javaType.getRawClass());
assertThat(javaType.getRawClass()).isEqualTo(Object.class);
}
@Test
@@ -80,7 +77,7 @@ public class DefaultJackson2JavaTypeMapperTests {
JavaType javaType = javaTypeMapper.toJavaType(properties);
assertThat(javaType, equalTo(TypeFactory.defaultInstance().constructType(String.class)));
assertThat(javaType).isEqualTo(TypeFactory.defaultInstance().constructType(String.class));
}
@Test
@@ -90,7 +87,7 @@ public class DefaultJackson2JavaTypeMapperTests {
JavaType javaType = javaTypeMapper.toJavaType(properties);
assertEquals(javaType, TypeFactory.defaultInstance().constructType(SimpleTrade.class));
assertThat(TypeFactory.defaultInstance().constructType(SimpleTrade.class)).isEqualTo(javaType);
}
@Test
@@ -98,7 +95,7 @@ public class DefaultJackson2JavaTypeMapperTests {
javaTypeMapper.fromJavaType(TypeFactory.defaultInstance().constructType(SimpleTrade.class), properties);
String className = (String) properties.getHeaders().get(javaTypeMapper.getClassIdFieldName());
assertThat(className, equalTo(SimpleTrade.class.getName()));
assertThat(className).isEqualTo(SimpleTrade.class.getName());
}
@Test
@@ -108,7 +105,7 @@ public class DefaultJackson2JavaTypeMapperTests {
javaTypeMapper.fromJavaType(TypeFactory.defaultInstance().constructType(SimpleTrade.class), properties);
String className = (String) properties.getHeaders().get(javaTypeMapper.getClassIdFieldName());
assertThat(className, equalTo("daytrade"));
assertThat(className).isEqualTo("daytrade");
}
@Test
@@ -120,10 +117,10 @@ public class DefaultJackson2JavaTypeMapperTests {
}
catch (MessageConversionException e) {
String contentClassIdFieldName = javaTypeMapper.getContentClassIdFieldName();
assertThat(e.getMessage(), containsString("Could not resolve " + contentClassIdFieldName + " in header"));
assertThat(e.getMessage()).contains("Could not resolve " + contentClassIdFieldName + " in header");
return;
}
fail();
fail("Expected exception");
}
@Test
@@ -134,8 +131,7 @@ public class DefaultJackson2JavaTypeMapperTests {
JavaType javaType = javaTypeMapper.toJavaType(properties);
assertThat((CollectionType) javaType,
equalTo(TypeFactory.defaultInstance().constructCollectionType(ArrayList.class, String.class)));
assertThat((CollectionType) javaType).isEqualTo(TypeFactory.defaultInstance().constructCollectionType(ArrayList.class, String.class));
}
@Test
@@ -150,9 +146,8 @@ public class DefaultJackson2JavaTypeMapperTests {
JavaType javaType = javaTypeMapper.toJavaType(properties);
assertThat((CollectionType) javaType,
equalTo(TypeFactory.defaultInstance().constructCollectionType(containerClass,
TypeFactory.defaultInstance().constructType(SimpleTrade.class))));
assertThat((CollectionType) javaType).isEqualTo(TypeFactory.defaultInstance().constructCollectionType(containerClass,
TypeFactory.defaultInstance().constructType(SimpleTrade.class)));
}
@Test
@@ -164,8 +159,8 @@ public class DefaultJackson2JavaTypeMapperTests {
String className = (String) properties.getHeaders().get(javaTypeMapper.getClassIdFieldName());
String contentClassName = (String) properties.getHeaders().get(javaTypeMapper.getContentClassIdFieldName());
assertThat(className, equalTo(ArrayList.class.getName()));
assertThat(contentClassName, equalTo(SimpleTrade.class.getName()));
assertThat(className).isEqualTo(ArrayList.class.getName());
assertThat(contentClassName).isEqualTo(SimpleTrade.class.getName());
}
@Test
@@ -178,10 +173,10 @@ public class DefaultJackson2JavaTypeMapperTests {
}
catch (MessageConversionException e) {
String contentClassIdFieldName = javaTypeMapper.getContentClassIdFieldName();
assertThat(e.getMessage(), containsString("Could not resolve " + contentClassIdFieldName + " in header"));
assertThat(e.getMessage()).contains("Could not resolve " + contentClassIdFieldName + " in header");
return;
}
fail();
fail("Expected exception");
}
@Test
@@ -193,8 +188,7 @@ public class DefaultJackson2JavaTypeMapperTests {
JavaType javaType = javaTypeMapper.toJavaType(properties);
assertThat((MapType) javaType,
equalTo(TypeFactory.defaultInstance().constructMapType(HashMap.class, Integer.class, String.class)));
assertThat((MapType) javaType).isEqualTo(TypeFactory.defaultInstance().constructMapType(HashMap.class, Integer.class, String.class));
}
@Test
@@ -210,10 +204,9 @@ public class DefaultJackson2JavaTypeMapperTests {
JavaType javaType = javaTypeMapper.toJavaType(properties);
assertThat((MapType) javaType,
equalTo(TypeFactory.defaultInstance().constructMapType(mapClass,
TypeFactory.defaultInstance().constructType(SimpleTrade.class),
TypeFactory.defaultInstance().constructType(String.class))));
assertThat((MapType) javaType).isEqualTo(TypeFactory.defaultInstance().constructMapType(mapClass,
TypeFactory.defaultInstance().constructType(SimpleTrade.class),
TypeFactory.defaultInstance().constructType(String.class)));
}
@Test
@@ -227,9 +220,9 @@ public class DefaultJackson2JavaTypeMapperTests {
String contentClassName = (String) properties.getHeaders().get(javaTypeMapper.getContentClassIdFieldName());
String keyClassName = (String) properties.getHeaders().get(javaTypeMapper.getKeyClassIdFieldName());
assertThat(className, equalTo(HashMap.class.getName()));
assertThat(contentClassName, equalTo(String.class.getName()));
assertThat(keyClassName, equalTo(SimpleTrade.class.getName()));
assertThat(className).isEqualTo(HashMap.class.getName());
assertThat(contentClassName).isEqualTo(String.class.getName());
assertThat(keyClassName).isEqualTo(SimpleTrade.class.getName());
}
@Test
@@ -237,7 +230,7 @@ public class DefaultJackson2JavaTypeMapperTests {
javaTypeMapper.fromClass(SimpleTrade.class, properties);
String className = (String) properties.getHeaders().get(javaTypeMapper.getClassIdFieldName());
assertThat(className, equalTo(SimpleTrade.class.getName()));
assertThat(className).isEqualTo(SimpleTrade.class.getName());
}
@Test
@@ -247,7 +240,7 @@ public class DefaultJackson2JavaTypeMapperTests {
Class<?> clazz = javaTypeMapper.toClass(properties);
assertEquals(SimpleTrade.class, clazz);
assertThat(clazz).isEqualTo(SimpleTrade.class);
}
private Map<String, Class<?>> map(String string, Class<?> clazz) {

57
spring-amqp/src/test/java/org/springframework/amqp/support/converter/Jackson2JsonMessageConverterTests.java
View File

@@ -16,12 +16,7 @@
package org.springframework.amqp.support.converter;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.math.BigDecimal;
import java.util.Hashtable;
@@ -83,7 +78,7 @@ public class Jackson2JsonMessageConverterTests {
Message message = converter.toMessage(trade, new MessageProperties());
SimpleTrade marshalledTrade = (SimpleTrade) converter.fromMessage(message);
assertEquals(trade, marshalledTrade);
assertThat(marshalledTrade).isEqualTo(trade);
}
@Test
@@ -98,7 +93,7 @@ public class Jackson2JsonMessageConverterTests {
Message message = converter.toMessage(trade, new MessageProperties());
SimpleTrade marshalledTrade = (SimpleTrade) converter.fromMessage(message);
assertEquals(trade, marshalledTrade);
assertThat(marshalledTrade).isEqualTo(trade);
}
@Test
@@ -109,7 +104,7 @@ public class Jackson2JsonMessageConverterTests {
Message message = converter.toMessage(bar, new MessageProperties());
Bar marshalled = (Bar) converter.fromMessage(message);
assertEquals(bar, marshalled);
assertThat(marshalled).isEqualTo(bar);
}
@Test
@@ -122,8 +117,8 @@ public class Jackson2JsonMessageConverterTests {
Message message = converter.toMessage(hashtable, new MessageProperties());
Hashtable<String, String> marhsalledHashtable = (Hashtable<String, String>) converter.fromMessage(message);
assertEquals("VMW", marhsalledHashtable.get("TICKER"));
assertEquals("103.2", marhsalledHashtable.get("PRICE"));
assertThat(marhsalledHashtable.get("TICKER")).isEqualTo("VMW");
assertThat(marhsalledHashtable.get("PRICE")).isEqualTo("103.2");
}
@Test
@@ -135,7 +130,7 @@ public class Jackson2JsonMessageConverterTests {
((DefaultClassMapper) this.converter.getClassMapper()).setTrustedPackages(TRUSTED_PACKAGE);
SimpleTrade marshalledTrade = (SimpleTrade) converter.fromMessage(message);
assertEquals(trade, marshalledTrade);
assertThat(marshalledTrade).isEqualTo(trade);
}
@Test
@@ -147,21 +142,21 @@ public class Jackson2JsonMessageConverterTests {
Message message = converter.toMessage(trade, new MessageProperties());
SimpleTrade marshalledTrade = (SimpleTrade) converter.fromMessage(message);
assertEquals(trade, marshalledTrade);
assertThat(marshalledTrade).isEqualTo(trade);
}
@Test
public void testAmqp330StringArray() {
String[] testData = { "test" };
Message message = converter.toMessage(testData, new MessageProperties());
assertArrayEquals(testData, (Object[]) converter.fromMessage(message));
assertThat((Object[]) converter.fromMessage(message)).isEqualTo(testData);
}
@Test
public void testAmqp330ObjectArray() {
SimpleTrade[] testData = { trade };
Message message = converter.toMessage(testData, new MessageProperties());
assertArrayEquals(testData, (Object[]) converter.fromMessage(message));
assertThat((Object[]) converter.fromMessage(message)).isEqualTo(testData);
}
@Test
@@ -175,7 +170,7 @@ public class Jackson2JsonMessageConverterTests {
classMapper.setDefaultType(Foo.class);
converter.setClassMapper(classMapper);
Object foo = converter.fromMessage(message);
assertTrue(foo instanceof Foo);
assertThat(foo instanceof Foo).isTrue();
}
@Test
@@ -185,7 +180,7 @@ public class Jackson2JsonMessageConverterTests {
messageProperties.setContentType("application/json");
Message message = new Message(bytes, messageProperties);
Object foo = jsonConverterWithDefaultType.fromMessage(message);
assertTrue(foo instanceof Foo);
assertThat(foo instanceof Foo).isTrue();
}
@Test
@@ -194,7 +189,7 @@ public class Jackson2JsonMessageConverterTests {
MessageProperties messageProperties = new MessageProperties();
Message message = new Message(bytes, messageProperties);
Object foo = jsonConverterWithDefaultType.fromMessage(message);
assertEquals(new String(bytes), new String((byte[]) foo));
assertThat(new String((byte[]) foo)).isEqualTo(new String(bytes));
}
@Test
@@ -204,10 +199,10 @@ public class Jackson2JsonMessageConverterTests {
messageProperties.setContentType("application/json");
Message message = new Message(bytes, messageProperties);
Object foo = this.converter.fromMessage(message);
assertThat(foo, instanceOf(LinkedHashMap.class));
assertThat(foo).isInstanceOf(LinkedHashMap.class);
@SuppressWarnings("unchecked")
Map<String, Object> map = (Map<String, Object>) foo;
assertThat(map.get("name"), instanceOf(LinkedHashMap.class));
assertThat(map.get("name")).isInstanceOf(LinkedHashMap.class);
}
@Test
@@ -218,7 +213,7 @@ public class Jackson2JsonMessageConverterTests {
messageProperties.setInferredArgumentType(Foo.class);
Message message = new Message(bytes, messageProperties);
Object foo = this.converter.fromMessage(message);
assertThat(foo, instanceOf(Foo.class));
assertThat(foo).isInstanceOf(Foo.class);
}
@Test
@@ -229,8 +224,8 @@ public class Jackson2JsonMessageConverterTests {
messageProperties.setInferredArgumentType((new ParameterizedTypeReference<List<Foo>>() { }).getType());
Message message = new Message(bytes, messageProperties);
Object foo = this.converter.fromMessage(message);
assertThat(foo, instanceOf(List.class));
assertThat(((List<?>) foo).get(0), instanceOf(Foo.class));
assertThat(foo).isInstanceOf(List.class);
assertThat(((List<?>) foo).get(0)).isInstanceOf(Foo.class);
}
@Test
@@ -242,13 +237,13 @@ public class Jackson2JsonMessageConverterTests {
(new ParameterizedTypeReference<Map<String, List<Bar>>>() { }).getType());
Message message = new Message(bytes, messageProperties);
Object foo = this.converter.fromMessage(message);
assertThat(foo, instanceOf(LinkedHashMap.class));
assertThat(foo).isInstanceOf(LinkedHashMap.class);
@SuppressWarnings("unchecked")
Map<String, Object> map = (Map<String, Object>) foo;
assertThat(map.get("qux"), instanceOf(List.class));
assertThat(map.get("qux")).isInstanceOf(List.class);
Object row = ((List<?>) map.get("qux")).get(0);
assertThat(row, instanceOf(Bar.class));
assertThat(((Bar) row).getFoo(), equalTo(new Foo("bar")));
assertThat(row).isInstanceOf(Bar.class);
assertThat(((Bar) row).getFoo()).isEqualTo(new Foo("bar"));
}
@Test
@@ -260,13 +255,13 @@ public class Jackson2JsonMessageConverterTests {
(new ParameterizedTypeReference<Map<String, Map<String, Bar>>>() { }).getType());
Message message = new Message(bytes, messageProperties);
Object foo = this.converter.fromMessage(message);
assertThat(foo, instanceOf(LinkedHashMap.class));
assertThat(foo).isInstanceOf(LinkedHashMap.class);
@SuppressWarnings("unchecked")
Map<String, Object> map = (Map<String, Object>) foo;
assertThat(map.get("qux"), instanceOf(Map.class));
assertThat(map.get("qux")).isInstanceOf(Map.class);
Object value = ((Map<?, ?>) map.get("qux")).get("baz");
assertThat(value, instanceOf(Bar.class));
assertThat(((Bar) value).getFoo(), equalTo(new Foo("bar")));
assertThat(value).isInstanceOf(Bar.class);
assertThat(((Bar) value).getFoo()).isEqualTo(new Foo("bar"));
}
public static class Foo {

10
spring-amqp/src/test/java/org/springframework/amqp/support/converter/MarshallingMessageConverterTests.java
View File

@@ -16,7 +16,7 @@
package org.springframework.amqp.support.converter;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.IOException;
@@ -45,7 +45,7 @@ public class MarshallingMessageConverterTests {
converter.afterPropertiesSet();
Message message = converter.toMessage("marshal test", new MessageProperties());
String response = new String(message.getBody(), "UTF-8");
assertEquals("MARSHAL TEST", response);
assertThat(response).isEqualTo("MARSHAL TEST");
}
@Test
@@ -57,7 +57,7 @@ public class MarshallingMessageConverterTests {
Message message = converter.toMessage("marshal test", new MessageProperties());
assertEquals("application/xml", message.getMessageProperties().getContentType());
assertThat(message.getMessageProperties().getContentType()).isEqualTo("application/xml");
}
@Test
@@ -69,7 +69,7 @@ public class MarshallingMessageConverterTests {
Message message = converter.toMessage("marshal test", new MessageProperties());
assertEquals(defaultContentType, message.getMessageProperties().getContentType());
assertThat(message.getMessageProperties().getContentType()).isEqualTo(defaultContentType);
}
@Test
@@ -79,7 +79,7 @@ public class MarshallingMessageConverterTests {
converter.afterPropertiesSet();
Message message = new Message("UNMARSHAL TEST".getBytes(), new MessageProperties());
Object result = converter.fromMessage(message);
assertEquals("unmarshal test", result);
assertThat(result).isEqualTo("unmarshal test");
}

15
spring-amqp/src/test/java/org/springframework/amqp/support/converter/MessagingMessageConverterTests.java
View File

@@ -16,8 +16,7 @@
package org.springframework.amqp.support.converter;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Rule;
import org.junit.Test;
@@ -50,13 +49,13 @@ public class MessagingMessageConverterTests {
org.springframework.amqp.core.Message message = converter
.toMessage(MessageBuilder.withPayload("Hello World").build(), new MessageProperties());
assertEquals(MessageProperties.CONTENT_TYPE_TEXT_PLAIN, message.getMessageProperties().getContentType());
assertEquals("Hello World", new String(message.getBody()));
assertThat(message.getMessageProperties().getContentType()).isEqualTo(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
assertThat(new String(message.getBody())).isEqualTo("Hello World");
}
@Test
public void fromNull() {
assertNull(converter.fromMessage(null));
assertThat(converter.fromMessage(null)).isNull();
}
@Test
@@ -70,7 +69,7 @@ public class MessagingMessageConverterTests {
});
Message<?> msg = (Message<?>) converter.fromMessage(createTextMessage("1224"));
assertEquals(1224L, msg.getPayload());
assertThat(msg.getPayload()).isEqualTo(1224L);
}
@Test
@@ -84,8 +83,8 @@ public class MessagingMessageConverterTests {
}
});
Message<?> msg = (Message<?>) converter.fromMessage(createTextMessage("foo"));
assertEquals(message.getPayload(), msg.getPayload());
assertEquals(true, msg.getHeaders().get("inside"));
assertThat(msg.getPayload()).isEqualTo(message.getPayload());
assertThat(msg.getHeaders().get("inside")).isEqualTo(true);
}
public org.springframework.amqp.core.Message createTextMessage(String body) {

70
spring-amqp/src/test/java/org/springframework/amqp/support/converter/SerializerMessageConverterTests.java
View File

@@ -16,11 +16,8 @@
package org.springframework.amqp.support.converter;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -30,9 +27,7 @@ import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.mockito.Mockito;
import org.springframework.amqp.core.Message;
@@ -48,16 +43,13 @@ import org.springframework.core.serializer.Deserializer;
*/
public class SerializerMessageConverterTests extends WhiteListDeserializingMessageConverterTests {
@Rule
public ExpectedException exception = ExpectedException.none();
@Test
public void bytesAsDefaultMessageBodyType() throws Exception {
SerializerMessageConverter converter = new SerializerMessageConverter();
Message message = new Message("test".getBytes(), new MessageProperties());
Object result = converter.fromMessage(message);
assertEquals(byte[].class, result.getClass());
assertEquals("test", new String((byte[]) result, "UTF-8"));
assertThat(result.getClass()).isEqualTo(byte[].class);
assertThat(new String((byte[]) result, "UTF-8")).isEqualTo("test");
}
@Test
@@ -66,8 +58,8 @@ public class SerializerMessageConverterTests extends WhiteListDeserializingMessa
Message message = new Message("test".getBytes(), new MessageProperties());
message.getMessageProperties().setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
Object result = converter.fromMessage(message);
assertEquals(String.class, result.getClass());
assertEquals("test", result);
assertThat(result.getClass()).isEqualTo(String.class);
assertThat(result).isEqualTo("test");
}
@Test
@@ -76,12 +68,12 @@ public class SerializerMessageConverterTests extends WhiteListDeserializingMessa
Message message = new Message(new byte[] { 1, 2, 3 }, new MessageProperties());
message.getMessageProperties().setContentType(MessageProperties.CONTENT_TYPE_BYTES);
Object result = converter.fromMessage(message);
assertEquals(byte[].class, result.getClass());
assertThat(result.getClass()).isEqualTo(byte[].class);
byte[] resultBytes = (byte[]) result;
assertEquals(3, resultBytes.length);
assertEquals(1, resultBytes[0]);
assertEquals(2, resultBytes[1]);
assertEquals(3, resultBytes[2]);
assertThat(resultBytes.length).isEqualTo(3);
assertThat(resultBytes[0]).isEqualTo((byte) 1);
assertThat(resultBytes[1]).isEqualTo((byte) 2);
assertThat(resultBytes[2]).isEqualTo((byte) 3);
}
@Test
@@ -98,8 +90,8 @@ public class SerializerMessageConverterTests extends WhiteListDeserializingMessa
byte[] bytes = byteStream.toByteArray();
Message message = new Message(bytes, properties);
Object result = converter.fromMessage(message);
assertEquals(TestBean.class, result.getClass());
assertEquals(testBean, result);
assertThat(result.getClass()).isEqualTo(TestBean.class);
assertThat(result).isEqualTo(testBean);
}
@Test
@@ -116,8 +108,8 @@ public class SerializerMessageConverterTests extends WhiteListDeserializingMessa
byte[] bytes = byteStream.toByteArray();
Message message = new Message(bytes, properties);
Object result = converter.fromMessage(message);
assertEquals(TestBean.class, result.getClass());
assertEquals(testBean, result);
assertThat(result.getClass()).isEqualTo(TestBean.class);
assertThat(result).isEqualTo(testBean);
}
@Test
@@ -127,8 +119,8 @@ public class SerializerMessageConverterTests extends WhiteListDeserializingMessa
String contentType = message.getMessageProperties().getContentType();
String content = new String(message.getBody(),
message.getMessageProperties().getContentEncoding());
assertEquals("text/plain", contentType);
assertEquals("test", content);
assertThat(contentType).isEqualTo("text/plain");
assertThat(content).isEqualTo("test");
}
@Test
@@ -137,11 +129,11 @@ public class SerializerMessageConverterTests extends WhiteListDeserializingMessa
Message message = converter.toMessage(new byte[] { 1, 2, 3 }, new MessageProperties());
String contentType = message.getMessageProperties().getContentType();
byte[] body = message.getBody();
assertEquals("application/octet-stream", contentType);
assertEquals(3, body.length);
assertEquals(1, body[0]);
assertEquals(2, body[1]);
assertEquals(3, body[2]);
assertThat(contentType).isEqualTo("application/octet-stream");
assertThat(body.length).isEqualTo(3);
assertThat(body[0]).isEqualTo((byte) 1);
assertThat(body[1]).isEqualTo((byte) 2);
assertThat(body[2]).isEqualTo((byte) 3);
}
@Test
@@ -151,10 +143,10 @@ public class SerializerMessageConverterTests extends WhiteListDeserializingMessa
Message message = converter.toMessage(testBean, new MessageProperties());
String contentType = message.getMessageProperties().getContentType();
byte[] body = message.getBody();
assertEquals("application/x-java-serialized-object", contentType);
assertThat(contentType).isEqualTo("application/x-java-serialized-object");
ByteArrayInputStream bais = new ByteArrayInputStream(body);
Object deserializedObject = new ObjectInputStream(bais).readObject();
assertEquals(testBean, deserializedObject);
assertThat(deserializedObject).isEqualTo(testBean);
}
@SuppressWarnings("unchecked")
@@ -164,11 +156,11 @@ public class SerializerMessageConverterTests extends WhiteListDeserializingMessa
ClassLoader loader = mock(ClassLoader.class);
Deserializer<Object> deserializer = new DefaultDeserializer(loader);
converter.setDeserializer(deserializer);
assertSame(loader, TestUtils.getPropertyValue(converter, "defaultDeserializerClassLoader"));
assertTrue(TestUtils.getPropertyValue(converter, "usingDefaultDeserializer", Boolean.class));
assertThat(TestUtils.getPropertyValue(converter, "defaultDeserializerClassLoader")).isSameAs(loader);
assertThat(TestUtils.getPropertyValue(converter, "usingDefaultDeserializer", Boolean.class)).isTrue();
Deserializer<Object> mock = mock(Deserializer.class);
converter.setDeserializer(mock);
assertFalse(TestUtils.getPropertyValue(converter, "usingDefaultDeserializer", Boolean.class));
assertThat(TestUtils.getPropertyValue(converter, "usingDefaultDeserializer", Boolean.class)).isFalse();
TestBean testBean = new TestBean("foo");
Message message = converter.toMessage(testBean, new MessageProperties());
converter.fromMessage(message);
@@ -181,12 +173,12 @@ public class SerializerMessageConverterTests extends WhiteListDeserializingMessa
TestBean testBean = new TestBean("foo");
Message message = converter.toMessage(testBean, new MessageProperties());
String contentType = message.getMessageProperties().getContentType();
assertEquals("application/x-java-serialized-object", contentType);
assertThat(contentType).isEqualTo("application/x-java-serialized-object");
byte[] body = message.getBody();
body[10] = 'z';
this.exception.expect(MessageConversionException.class);
this.exception.expectCause(instanceOf(NestedIOException.class));
converter.fromMessage(message);
assertThatThrownBy(() -> converter.fromMessage(message))
.isExactlyInstanceOf(MessageConversionException.class)
.hasCauseExactlyInstanceOf(NestedIOException.class);
}
}

70
spring-amqp/src/test/java/org/springframework/amqp/support/converter/SimpleMessageConverterTests.java
View File

@@ -16,22 +16,16 @@
package org.springframework.amqp.support.converter;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.fail;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
@@ -42,23 +36,20 @@ import org.springframework.amqp.core.MessageProperties;
*/
public class SimpleMessageConverterTests extends WhiteListDeserializingMessageConverterTests {
@Rule
public ExpectedException exception = ExpectedException.none();
@Test
public void bytesAsDefaultMessageBodyType() throws Exception {
SimpleMessageConverter converter = new SimpleMessageConverter();
Message message = new Message("test".getBytes(), new MessageProperties());
Object result = converter.fromMessage(message);
assertEquals(byte[].class, result.getClass());
assertEquals("test", new String((byte[]) result, "UTF-8"));
assertThat(result.getClass()).isEqualTo(byte[].class);
assertThat(new String((byte[]) result, "UTF-8")).isEqualTo("test");
}
@Test
public void noMessageIdByDefault() throws Exception {
SimpleMessageConverter converter = new SimpleMessageConverter();
Message message = converter.toMessage("foo", null);
assertNull(message.getMessageProperties().getMessageId());
assertThat(message.getMessageProperties().getMessageId()).isNull();
}
@Test
@@ -66,7 +57,7 @@ public class SimpleMessageConverterTests extends WhiteListDeserializingMessageCo
SimpleMessageConverter converter = new SimpleMessageConverter();
converter.setCreateMessageIds(true);
Message message = converter.toMessage("foo", null);
assertNotNull(message.getMessageProperties().getMessageId());
assertThat(message.getMessageProperties().getMessageId()).isNotNull();
}
@Test
@@ -75,8 +66,8 @@ public class SimpleMessageConverterTests extends WhiteListDeserializingMessageCo
Message message = new Message("test".getBytes(), new MessageProperties());
message.getMessageProperties().setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
Object result = converter.fromMessage(message);
assertEquals(String.class, result.getClass());
assertEquals("test", result);
assertThat(result.getClass()).isEqualTo(String.class);
assertThat(result).isEqualTo("test");
}
@Test
@@ -85,12 +76,12 @@ public class SimpleMessageConverterTests extends WhiteListDeserializingMessageCo
Message message = new Message(new byte[] { 1, 2, 3 }, new MessageProperties());
message.getMessageProperties().setContentType(MessageProperties.CONTENT_TYPE_BYTES);
Object result = converter.fromMessage(message);
assertEquals(byte[].class, result.getClass());
assertThat(result.getClass()).isEqualTo(byte[].class);
byte[] resultBytes = (byte[]) result;
assertEquals(3, resultBytes.length);
assertEquals(1, resultBytes[0]);
assertEquals(2, resultBytes[1]);
assertEquals(3, resultBytes[2]);
assertThat(resultBytes.length).isEqualTo(3);
assertThat(resultBytes[0]).isEqualTo((byte) 1);
assertThat(resultBytes[1]).isEqualTo((byte) 2);
assertThat(resultBytes[2]).isEqualTo((byte) 3);
}
@Test
@@ -107,8 +98,8 @@ public class SimpleMessageConverterTests extends WhiteListDeserializingMessageCo
byte[] bytes = byteStream.toByteArray();
Message message = new Message(bytes, properties);
Object result = converter.fromMessage(message);
assertEquals(TestBean.class, result.getClass());
assertEquals(testBean, result);
assertThat(result.getClass()).isEqualTo(TestBean.class);
assertThat(result).isEqualTo(testBean);
}
@Test
@@ -118,8 +109,8 @@ public class SimpleMessageConverterTests extends WhiteListDeserializingMessageCo
String contentType = message.getMessageProperties().getContentType();
String content = new String(message.getBody(),
message.getMessageProperties().getContentEncoding());
assertEquals("text/plain", contentType);
assertEquals("test", content);
assertThat(contentType).isEqualTo("text/plain");
assertThat(content).isEqualTo("test");
}
@Test
@@ -128,11 +119,11 @@ public class SimpleMessageConverterTests extends WhiteListDeserializingMessageCo
Message message = converter.toMessage(new byte[] { 1, 2, 3 }, new MessageProperties());
String contentType = message.getMessageProperties().getContentType();
byte[] body = message.getBody();
assertEquals("application/octet-stream", contentType);
assertEquals(3, body.length);
assertEquals(1, body[0]);
assertEquals(2, body[1]);
assertEquals(3, body[2]);
assertThat(contentType).isEqualTo("application/octet-stream");
assertThat(body.length).isEqualTo(3);
assertThat(body[0]).isEqualTo((byte) 1);
assertThat(body[1]).isEqualTo((byte) 2);
assertThat(body[2]).isEqualTo((byte) 3);
}
@Test
@@ -142,10 +133,10 @@ public class SimpleMessageConverterTests extends WhiteListDeserializingMessageCo
Message message = converter.toMessage(testBean, new MessageProperties());
String contentType = message.getMessageProperties().getContentType();
byte[] body = message.getBody();
assertEquals("application/x-java-serialized-object", contentType);
assertThat(contentType).isEqualTo("application/x-java-serialized-object");
ByteArrayInputStream bais = new ByteArrayInputStream(body);
Object deserializedObject = new ObjectInputStream(bais).readObject();
assertEquals(testBean, deserializedObject);
assertThat(deserializedObject).isEqualTo(testBean);
}
@Test
@@ -154,12 +145,12 @@ public class SimpleMessageConverterTests extends WhiteListDeserializingMessageCo
TestBean testBean = new TestBean("foo");
Message message = converter.toMessage(testBean, new MessageProperties());
String contentType = message.getMessageProperties().getContentType();
assertEquals("application/x-java-serialized-object", contentType);
assertThat(contentType).isEqualTo("application/x-java-serialized-object");
byte[] body = message.getBody();
body[10] = 'z';
this.exception.expect(MessageConversionException.class);
this.exception.expectCause(instanceOf(IllegalStateException.class));
converter.fromMessage(message);
assertThatThrownBy(() -> converter.fromMessage(message))
.isExactlyInstanceOf(MessageConversionException.class)
.hasCauseExactlyInstanceOf(IllegalStateException.class);
}
@Test
@@ -172,8 +163,7 @@ public class SimpleMessageConverterTests extends WhiteListDeserializingMessageCo
fail("Expected exception");
}
catch (IllegalArgumentException e) {
assertThat(e.getMessage(), containsString(
"SimpleMessageConverter only supports String, byte[] and Serializable payloads, received:"));
assertThat(e.getMessage()).contains("SimpleMessageConverter only supports String, byte[] and Serializable payloads, received:");
}
}

14
spring-amqp/src/test/java/org/springframework/amqp/support/converter/WhiteListDeserializingMessageConverterTests.java
View File

@@ -16,8 +16,8 @@
package org.springframework.amqp.support.converter;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.io.Serializable;
import java.util.Collections;
@@ -41,23 +41,23 @@ public class WhiteListDeserializingMessageConverterTests {
TestBean testBean = new TestBean("foo");
Message message = converter.toMessage(testBean, new MessageProperties());
Object fromMessage = converter.fromMessage(message);
assertEquals(testBean, fromMessage);
assertThat(fromMessage).isEqualTo(testBean);
converter.setWhiteListPatterns(Collections.singletonList("*"));
fromMessage = converter.fromMessage(message);
assertEquals(testBean, fromMessage);
assertThat(fromMessage).isEqualTo(testBean);
converter.setWhiteListPatterns(Collections.singletonList("org.springframework.amqp.*"));
fromMessage = converter.fromMessage(message);
assertEquals(testBean, fromMessage);
assertThat(fromMessage).isEqualTo(testBean);
converter.setWhiteListPatterns(Collections.singletonList("*$TestBean"));
fromMessage = converter.fromMessage(message);
assertEquals(testBean, fromMessage);
assertThat(fromMessage).isEqualTo(testBean);
try {
converter.setWhiteListPatterns(Collections.singletonList("foo.*"));
fromMessage = converter.fromMessage(message);
assertEquals(testBean, fromMessage);
assertThat(fromMessage).isEqualTo(testBean);
fail("Expected SecurityException");
}
catch (SecurityException e) {

26
spring-rabbit-junit/src/test/java/org/springframework/amqp/rabbit/junit/BrokerRunningTests.java
View File

@@ -16,7 +16,7 @@
package org.springframework.amqp.rabbit.junit;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.HashMap;
import java.util.Map;
@@ -44,12 +44,12 @@ public class BrokerRunningTests {
brokerRunning.setPort(1234);
brokerRunning.setUser("fiz");
assertEquals("http://baz:15672/api/", brokerRunning.getAdminUri());
assertThat(brokerRunning.getAdminUri()).isEqualTo("http://baz:15672/api/");
ConnectionFactory connectionFactory = brokerRunning.getConnectionFactory();
assertEquals("baz", connectionFactory.getHost());
assertEquals(1234, connectionFactory.getPort());
assertEquals("fiz", connectionFactory.getUsername());
assertEquals("qux", connectionFactory.getPassword());
assertThat(connectionFactory.getHost()).isEqualTo("baz");
assertThat(connectionFactory.getPort()).isEqualTo(1234);
assertThat(connectionFactory.getUsername()).isEqualTo("fiz");
assertThat(connectionFactory.getPassword()).isEqualTo("qux");
}
@Test
@@ -65,15 +65,15 @@ public class BrokerRunningTests {
BrokerRunning.setEnvironmentVariableOverrides(vars);
BrokerRunning brokerRunning = BrokerRunning.isBrokerAndManagementRunning();
assertEquals("https://foo/bar", brokerRunning.getAdminUri());
assertThat(brokerRunning.getAdminUri()).isEqualTo("https://foo/bar");
ConnectionFactory connectionFactory = brokerRunning.getConnectionFactory();
assertEquals("BAZ", connectionFactory.getHost());
assertEquals(2345, connectionFactory.getPort());
assertEquals("FIZ", connectionFactory.getUsername());
assertEquals("QUX", connectionFactory.getPassword());
assertThat(connectionFactory.getHost()).isEqualTo("BAZ");
assertThat(connectionFactory.getPort()).isEqualTo(2345);
assertThat(connectionFactory.getUsername()).isEqualTo("FIZ");
assertThat(connectionFactory.getPassword()).isEqualTo("QUX");
DirectFieldAccessor dfa = new DirectFieldAccessor(brokerRunning);
assertEquals("BAR", dfa.getPropertyValue("adminUser"));
assertEquals("FOO", dfa.getPropertyValue("adminPassword"));
assertThat(dfa.getPropertyValue("adminUser")).isEqualTo("BAR");
assertThat(dfa.getPropertyValue("adminPassword")).isEqualTo("FOO");
BrokerRunning.clearEnvironmentVariableOverrides();
}

7
spring-rabbit-junit/src/test/java/org/springframework/amqp/rabbit/junit/RabbitAvailableCTORInjectionTests.java
View File

@@ -16,8 +16,7 @@
package org.springframework.amqp.rabbit.junit;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
@@ -42,11 +41,11 @@ public class RabbitAvailableCTORInjectionTests {
@Test
public void test(ConnectionFactory cf) throws Exception {
assertSame(cf, this.connectionFactory);
assertThat(this.connectionFactory).isSameAs(cf);
Connection conn = this.connectionFactory.newConnection();
Channel channel = conn.createChannel();
DeclareOk declareOk = channel.queueDeclarePassive("rabbitAvailableTests.queue");
assertEquals(0, declareOk.getConsumerCount());
assertThat(declareOk.getConsumerCount()).isEqualTo(0);
channel.close();
conn.close();
}

4
spring-rabbit-junit/src/test/java/org/springframework/amqp/rabbit/junit/RabbitAvailableTests.java
View File

@@ -16,7 +16,7 @@
package org.springframework.amqp.rabbit.junit;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
@@ -38,7 +38,7 @@ public class RabbitAvailableTests {
Connection conn = connectionFactory.newConnection();
Channel channel = conn.createChannel();
DeclareOk declareOk = channel.queueDeclarePassive("rabbitAvailableTests.queue");
assertEquals(0, declareOk.getConsumerCount());
assertThat(declareOk.getConsumerCount()).isEqualTo(0);
channel.close();
conn.close();
}

20
spring-rabbit-test/src/test/java/org/springframework/amqp/rabbit/repeatable/AbstractRabbitAnnotationDrivenTests.java
View File

@@ -16,7 +16,7 @@
package org.springframework.amqp.rabbit.repeatable;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Rule;
import org.junit.Test;
@@ -51,27 +51,27 @@ public abstract class AbstractRabbitAnnotationDrivenTests {
public void testRabbitListenerRepeatable(ApplicationContext context) {
RabbitListenerContainerTestFactory simpleFactory =
context.getBean("rabbitListenerContainerFactory", RabbitListenerContainerTestFactory.class);
assertEquals(4, simpleFactory.getListenerContainers().size());
assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(4);
MethodRabbitListenerEndpoint first = (MethodRabbitListenerEndpoint)
simpleFactory.getListenerContainer("first").getEndpoint();
assertEquals("first", first.getId());
assertEquals("myQueue", first.getQueueNames().iterator().next());
assertThat(first.getId()).isEqualTo("first");
assertThat(first.getQueueNames().iterator().next()).isEqualTo("myQueue");
MethodRabbitListenerEndpoint second = (MethodRabbitListenerEndpoint)
simpleFactory.getListenerContainer("second").getEndpoint();
assertEquals("second", second.getId());
assertEquals("anotherQueue", second.getQueueNames().iterator().next());
assertThat(second.getId()).isEqualTo("second");
assertThat(second.getQueueNames().iterator().next()).isEqualTo("anotherQueue");
MethodRabbitListenerEndpoint third = (MethodRabbitListenerEndpoint)
simpleFactory.getListenerContainer("third").getEndpoint();
assertEquals("third", third.getId());
assertEquals("class1", third.getQueueNames().iterator().next());
assertThat(third.getId()).isEqualTo("third");
assertThat(third.getQueueNames().iterator().next()).isEqualTo("class1");
MethodRabbitListenerEndpoint fourth = (MethodRabbitListenerEndpoint)
simpleFactory.getListenerContainer("fourth").getEndpoint();
assertEquals("fourth", fourth.getId());
assertEquals("class2", fourth.getQueueNames().iterator().next());
assertThat(fourth.getId()).isEqualTo("fourth");
assertThat(fourth.getQueueNames().iterator().next()).isEqualTo("class2");
}
@Component

44
spring-rabbit-test/src/test/java/org/springframework/amqp/rabbit/test/ExampleRabbitListenerCaptureTest.java
View File

@@ -16,11 +16,7 @@
package org.springframework.amqp.rabbit.test;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.concurrent.TimeUnit;
@@ -78,12 +74,12 @@ public class ExampleRabbitListenerCaptureTest {
@Test
public void testTwoWay() throws Exception {
assertEquals("FOO", this.rabbitTemplate.convertSendAndReceive(this.queue1.getName(), "foo"));
assertThat(this.rabbitTemplate.convertSendAndReceive(this.queue1.getName(), "foo")).isEqualTo("FOO");
InvocationData invocationData = this.harness.getNextInvocationDataFor("foo", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat((String) invocationData.getArguments()[0], equalTo("foo"));
assertThat((String) invocationData.getResult(), equalTo("FOO"));
assertThat(invocationData).isNotNull();
assertThat((String) invocationData.getArguments()[0]).isEqualTo("foo");
assertThat((String) invocationData.getResult()).isEqualTo("FOO");
}
@Test
@@ -93,31 +89,31 @@ public class ExampleRabbitListenerCaptureTest {
this.rabbitTemplate.convertAndSend(this.queue2.getName(), "ex");
InvocationData invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat(invocationData).isNotNull();
Object[] args = invocationData.getArguments();
assertThat((String) args[0], equalTo("bar"));
assertThat((String) args[1], equalTo(queue2.getName()));
assertThat((String) args[0]).isEqualTo("bar");
assertThat((String) args[1]).isEqualTo(queue2.getName());
invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat(invocationData).isNotNull();
args = invocationData.getArguments();
assertThat((String) args[0], equalTo("baz"));
assertThat((String) args[1], equalTo(queue2.getName()));
assertThat((String) args[0]).isEqualTo("baz");
assertThat((String) args[1]).isEqualTo(queue2.getName());
invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat(invocationData).isNotNull();
args = invocationData.getArguments();
assertThat((String) args[0], equalTo("ex"));
assertThat((String) args[1], equalTo(queue2.getName()));
assertNotNull(invocationData.getThrowable());
assertEquals("ex", invocationData.getThrowable().getMessage());
assertThat((String) args[0]).isEqualTo("ex");
assertThat((String) args[1]).isEqualTo(queue2.getName());
assertThat(invocationData.getThrowable()).isNotNull();
assertThat(invocationData.getThrowable().getMessage()).isEqualTo("ex");
invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat(invocationData).isNotNull();
args = invocationData.getArguments();
assertThat((String) args[0], equalTo("ex"));
assertThat((String) args[1], equalTo(queue2.getName()));
assertNull(invocationData.getThrowable());
assertThat((String) args[0]).isEqualTo("ex");
assertThat((String) args[1]).isEqualTo(queue2.getName());
assertThat(invocationData.getThrowable()).isNull();
}
@Configuration

51
spring-rabbit-test/src/test/java/org/springframework/amqp/rabbit/test/ExampleRabbitListenerSpyAndCaptureTest.java
View File

@@ -16,12 +16,7 @@
package org.springframework.amqp.rabbit.test;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
@@ -79,22 +74,22 @@ public class ExampleRabbitListenerSpyAndCaptureTest {
@Test
public void testTwoWay() throws Exception {
assertEquals("FOO", this.rabbitTemplate.convertSendAndReceive(this.queue1.getName(), "foo"));
assertThat(this.rabbitTemplate.convertSendAndReceive(this.queue1.getName(), "foo")).isEqualTo("FOO");
Listener listener = this.harness.getSpy("foo");
assertNotNull(listener);
assertThat(listener).isNotNull();
verify(listener).foo("foo");
InvocationData invocationData = this.harness.getNextInvocationDataFor("foo", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat((String) invocationData.getArguments()[0], equalTo("foo"));
assertThat((String) invocationData.getResult(), equalTo("FOO"));
assertThat(invocationData).isNotNull();
assertThat((String) invocationData.getArguments()[0]).isEqualTo("foo");
assertThat((String) invocationData.getResult()).isEqualTo("FOO");
}
@Test
public void testOneWay() throws Exception {
Listener listener = this.harness.getSpy("bar");
assertNotNull(listener);
assertThat(listener).isNotNull();
LatchCountDownAndCallRealMethodAnswer answer = new LatchCountDownAndCallRealMethodAnswer(2);
doAnswer(answer).when(listener).foo(anyString(), anyString());
@@ -103,36 +98,36 @@ public class ExampleRabbitListenerSpyAndCaptureTest {
this.rabbitTemplate.convertAndSend(this.queue2.getName(), "baz");
this.rabbitTemplate.convertAndSend(this.queue2.getName(), "ex");
assertTrue(answer.getLatch().await(10, TimeUnit.SECONDS));
assertThat(answer.getLatch().await(10, TimeUnit.SECONDS)).isTrue();
verify(listener).foo("bar", this.queue2.getName());
verify(listener).foo("baz", this.queue2.getName());
InvocationData invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat(invocationData).isNotNull();
Object[] args = invocationData.getArguments();
assertThat((String) args[0], equalTo("bar"));
assertThat((String) args[1], equalTo(queue2.getName()));
assertThat((String) args[0]).isEqualTo("bar");
assertThat((String) args[1]).isEqualTo(queue2.getName());
invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat(invocationData).isNotNull();
args = invocationData.getArguments();
assertThat((String) args[0], equalTo("baz"));
assertThat((String) args[1], equalTo(queue2.getName()));
assertThat((String) args[0]).isEqualTo("baz");
assertThat((String) args[1]).isEqualTo(queue2.getName());
invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat(invocationData).isNotNull();
args = invocationData.getArguments();
assertThat((String) args[0], equalTo("ex"));
assertThat((String) args[1], equalTo(queue2.getName()));
assertNotNull(invocationData.getThrowable());
assertEquals("ex", invocationData.getThrowable().getMessage());
assertThat((String) args[0]).isEqualTo("ex");
assertThat((String) args[1]).isEqualTo(queue2.getName());
assertThat(invocationData.getThrowable()).isNotNull();
assertThat(invocationData.getThrowable().getMessage()).isEqualTo("ex");
invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
assertNotNull(invocationData);
assertThat(invocationData).isNotNull();
args = invocationData.getArguments();
assertThat((String) args[0], equalTo("ex"));
assertThat((String) args[1], equalTo(queue2.getName()));
assertNull(invocationData.getThrowable());
assertThat((String) args[0]).isEqualTo("ex");
assertThat((String) args[1]).isEqualTo(queue2.getName());
assertThat(invocationData.getThrowable()).isNull();
}
@Configuration

12
spring-rabbit-test/src/test/java/org/springframework/amqp/rabbit/test/ExampleRabbitListenerSpyTest.java
View File

@@ -16,9 +16,7 @@
package org.springframework.amqp.rabbit.test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
@@ -78,17 +76,17 @@ public class ExampleRabbitListenerSpyTest {
@Test
public void testTwoWay() {
assertEquals("FOO", this.rabbitTemplate.convertSendAndReceive(this.queue1.getName(), "foo"));
assertThat(this.rabbitTemplate.convertSendAndReceive(this.queue1.getName(), "foo")).isEqualTo("FOO");
Listener listener = this.harness.getSpy("foo");
assertNotNull(listener);
assertThat(listener).isNotNull();
verify(listener).foo("foo");
}
@Test
public void testOneWay() throws Exception {
Listener listener = this.harness.getSpy("bar");
assertNotNull(listener);
assertThat(listener).isNotNull();
LatchCountDownAndCallRealMethodAnswer answer = new LatchCountDownAndCallRealMethodAnswer(2);
doAnswer(answer).when(listener).foo(anyString(), anyString());
@@ -96,7 +94,7 @@ public class ExampleRabbitListenerSpyTest {
this.rabbitTemplate.convertAndSend(this.queue2.getName(), "bar");
this.rabbitTemplate.convertAndSend(this.queue2.getName(), "baz");
assertTrue(answer.getLatch().await(10, TimeUnit.SECONDS));
assertThat(answer.getLatch().await(10, TimeUnit.SECONDS)).isTrue();
verify(listener).foo("bar", this.queue2.getName());
verify(listener).foo("baz", this.queue2.getName());
}

17
spring-rabbit-test/src/test/java/org/springframework/amqp/rabbit/test/TestRabbitTemplateTests.java
View File

@@ -16,8 +16,7 @@
package org.springframework.amqp.rabbit.test;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willReturn;
@@ -60,20 +59,20 @@ public class TestRabbitTemplateTests {
@Test
public void testSimpleSends() {
this.template.convertAndSend("foo", "hello1");
assertThat(this.config.fooIn, equalTo("foo:hello1"));
assertThat(this.config.fooIn).isEqualTo("foo:hello1");
this.template.convertAndSend("bar", "hello2");
assertThat(this.config.barIn, equalTo("bar:hello2"));
assertThat(this.config.smlc1In, equalTo("smlc1:"));
assertThat(this.config.barIn).isEqualTo("bar:hello2");
assertThat(this.config.smlc1In).isEqualTo("smlc1:");
this.template.convertAndSend("foo", "hello3");
assertThat(this.config.fooIn, equalTo("foo:hello1"));
assertThat(this.config.fooIn).isEqualTo("foo:hello1");
this.template.convertAndSend("bar", "hello4");
assertThat(this.config.barIn, equalTo("bar:hello2"));
assertThat(this.config.smlc1In, equalTo("smlc1:hello3hello4"));
assertThat(this.config.barIn).isEqualTo("bar:hello2");
assertThat(this.config.smlc1In).isEqualTo("smlc1:hello3hello4");
}
@Test
public void testSendAndReceive() {
assertThat(this.template.convertSendAndReceive("baz", "hello"), equalTo("baz:hello"));
assertThat(this.template.convertSendAndReceive("baz", "hello")).isEqualTo("baz:hello");
}
@Configuration

8
spring-rabbit-test/src/test/java/org/springframework/amqp/rabbit/test/mockito/AnswerTests.java
View File

@@ -16,7 +16,7 @@
package org.springframework.amqp.rabbit.test.mockito;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.spy;
@@ -34,12 +34,12 @@ public class AnswerTests {
public void testLambda() {
Foo foo = spy(new Foo());
doAnswer(new LambdaAnswer<String>(true, (i, r) -> r + r)).when(foo).foo(anyString());
assertEquals("FOOFOO", foo.foo("foo"));
assertThat(foo.foo("foo")).isEqualTo("FOOFOO");
doAnswer(new LambdaAnswer<String>(true, (i, r) -> r + i.getArguments()[0])).when(foo).foo(anyString());
assertEquals("FOOfoo", foo.foo("foo"));
assertThat(foo.foo("foo")).isEqualTo("FOOfoo");
doAnswer(new LambdaAnswer<String>(false, (i, r) ->
"" + i.getArguments()[0] + i.getArguments()[0])).when(foo).foo(anyString());
assertEquals("foofoo", foo.foo("foo"));
assertThat(foo.foo("foo")).isEqualTo("foofoo");
}
private static class Foo {

41
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/connection/AbstractConnectionFactoryTests.java
View File

@@ -16,10 +16,7 @@
package org.springframework.amqp.rabbit.connection;
import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
@@ -87,40 +84,36 @@ public abstract class AbstractConnectionFactoryTests {
doReturn(true).when(logger).isInfoEnabled();
new DirectFieldAccessor(connectionFactory).setPropertyValue("logger", logger);
Connection con = connectionFactory.createConnection();
assertEquals(1, called.get());
assertThat(called.get()).isEqualTo(1);
ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
verify(logger, times(2)).info(captor.capture());
assertThat(captor.getAllValues().get(0),
containsString("Attempting to connect to: null:0"));
assertThat(captor.getValue(),
allOf(containsString("Created new connection: "), containsString("SimpleConnection")));
assertThat(captor.getAllValues().get(0)).contains("Attempting to connect to: null:0");
assertThat(captor.getValue()).contains("Created new connection: ").contains("SimpleConnection");
con.close();
assertEquals(1, called.get());
assertThat(called.get()).isEqualTo(1);
verify(mockConnection, never()).close(anyInt());
connectionFactory.createConnection();
assertEquals(1, called.get());
assertThat(called.get()).isEqualTo(1);
connectionFactory.destroy();
assertEquals(0, called.get());
assertThat(called.get()).isEqualTo(0);
verify(mockConnection, atLeastOnce()).close(anyInt());
verify(mockConnectionFactory, times(1)).newConnection(any(ExecutorService.class), anyString());
connectionFactory.setAddresses("foo:5672,bar:5672");
con = connectionFactory.createConnection();
assertEquals(1, called.get());
assertThat(called.get()).isEqualTo(1);
captor = ArgumentCaptor.forClass(String.class);
verify(logger, times(4)).info(captor.capture());
assertThat(captor.getAllValues().get(2),
containsString("Attempting to connect to: [foo:5672, bar:5672]"));
assertThat(captor.getValue(),
allOf(containsString("Created new connection: "), containsString("SimpleConnection")));
assertThat(captor.getAllValues().get(2)).contains("Attempting to connect to: [foo:5672, bar:5672]");
assertThat(captor.getValue()).contains("Created new connection: ").contains("SimpleConnection");
con.close();
connectionFactory.destroy();
assertEquals(0, called.get());
assertThat(called.get()).isEqualTo(0);
}
@Test
@@ -134,7 +127,7 @@ public abstract class AbstractConnectionFactoryTests {
final AtomicInteger called = new AtomicInteger(0);
AbstractConnectionFactory connectionFactory = createConnectionFactory(mockConnectionFactory);
Connection con = connectionFactory.createConnection();
assertEquals(0, called.get());
assertThat(called.get()).isEqualTo(0);
connectionFactory.setConnectionListeners(Collections.singletonList(new ConnectionListener() {
@@ -149,17 +142,17 @@ public abstract class AbstractConnectionFactoryTests {
}
}));
assertEquals(1, called.get());
assertThat(called.get()).isEqualTo(1);
con.close();
assertEquals(1, called.get());
assertThat(called.get()).isEqualTo(1);
verify(mockConnection, never()).close(anyInt());
connectionFactory.createConnection();
assertEquals(1, called.get());
assertThat(called.get()).isEqualTo(1);
connectionFactory.destroy();
assertEquals(0, called.get());
assertThat(called.get()).isEqualTo(0);
verify(mockConnection, atLeastOnce()).close(anyInt());
verify(mockConnectionFactory, times(1)).newConnection(any(ExecutorService.class), anyString());
@@ -214,7 +207,7 @@ public abstract class AbstractConnectionFactoryTests {
ThreadFactory connectionThreadFactory = new CustomizableThreadFactory("connection-thread-");
connectionFactory.setConnectionThreadFactory(connectionThreadFactory);
assertEquals(connectionThreadFactory, mockConnectionFactory.getThreadFactory());
assertThat(mockConnectionFactory.getThreadFactory()).isEqualTo(connectionThreadFactory);
}
}

426
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/connection/CachingConnectionFactoryTests.java
View File

@@ -16,13 +16,8 @@
package org.springframework.amqp.rabbit.connection;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
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.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.AdditionalMatchers.aryEq;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
@@ -121,8 +116,8 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
channel2.close(); // should be ignored
con2.close(); // should be ignored
assertSame(con, con2);
assertSame(channel, channel2);
assertThat(con2).isSameAs(con);
assertThat(channel2).isSameAs(channel);
verify(mockConnection, never()).close();
verify(mockChannel, never()).close();
}
@@ -154,14 +149,14 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
channel2.close(); // should be ignored
con2.close(); // should be ignored
assertSame(con, con2);
assertSame(channel, channel2);
assertThat(con2).isSameAs(con);
assertThat(channel2).isSameAs(channel);
verify(mockConnection, never()).close();
verify(mockChannel, never()).close();
assertNull(TestUtils.getPropertyValue(ccf, "connection.target"));
assertNotNull(TestUtils.getPropertyValue(ccf, "publisherConnectionFactory.connection.target"));
assertSame(con, TestUtils.getPropertyValue(ccf, "publisherConnectionFactory.connection"));
assertThat(TestUtils.getPropertyValue(ccf, "connection.target")).isNull();
assertThat(TestUtils.getPropertyValue(ccf, "publisherConnectionFactory.connection.target")).isNotNull();
assertThat(TestUtils.getPropertyValue(ccf, "publisherConnectionFactory.connection")).isSameAs(con);
}
@Test
@@ -191,7 +186,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
Channel channel2 = con.createChannel(false);
ChannelProxy txChannel = (ChannelProxy) con.createChannel(true);
assertTrue(txChannel.isTransactional());
assertThat(txChannel.isTransactional()).isTrue();
verify(mockTxChannel).txSelect();
txChannel.close();
@@ -206,9 +201,9 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
Channel ch2 = con.createChannel(false); // remove first entry in cache
// (channel2)
assertNotSame(ch1, ch2);
assertSame(ch1, channel1);
assertSame(ch2, channel2);
assertThat(ch2).isNotSameAs(ch1);
assertThat(channel1).isSameAs(ch1);
assertThat(channel2).isSameAs(ch2);
ch1.close();
ch2.close();
@@ -250,7 +245,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
// cache size is 1, but the other connection is not released yet so this
// creates a new one
Channel channel2 = con.createChannel(false);
assertNotSame(channel1, channel2);
assertThat(channel2).isNotSameAs(channel1);
// should be ignored, and added last into channel cache.
channel1.close();
@@ -262,9 +257,9 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
// create a new channel
Channel ch2 = con.createChannel(false);
assertNotSame(ch1, ch2);
assertSame(ch1, channel1);
assertNotSame(ch2, channel2);
assertThat(ch2).isNotSameAs(ch1);
assertThat(channel1).isSameAs(ch1);
assertThat(channel2).isNotSameAs(ch2);
ch1.close();
ch2.close();
@@ -315,7 +310,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
// remove first entry in cache (channel1)
Channel ch1 = con.createChannel(false);
assertSame(ch1, channel1);
assertThat(channel1).isSameAs(ch1);
ch1.close();
@@ -371,7 +366,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
// remove first entry in cache (channel1)
Channel ch1 = con.createChannel(false);
assertSame(ch1, channel1);
assertThat(channel1).isSameAs(ch1);
ch1.close();
@@ -417,7 +412,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
con1.close();
Connection con2 = ccf.createConnection();
assertSame(con1, con2);
assertThat(con2).isSameAs(con1);
final CountDownLatch latch2 = new CountDownLatch(1);
final CountDownLatch latch1 = new CountDownLatch(1);
@@ -429,11 +424,11 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
latch2.countDown();
});
assertTrue(latch1.await(10, TimeUnit.SECONDS));
assertThat(latch1.await(10, TimeUnit.SECONDS)).isTrue();
Thread.sleep(100);
con2.close();
assertTrue(latch2.await(10, TimeUnit.SECONDS));
assertSame(con2, connection.get());
assertThat(latch2.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(connection.get()).isSameAs(con2);
ccf.destroy();
}
@@ -488,15 +483,13 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
Connection con = ccf.createConnection();
Channel channel1 = con.createChannel(false);
assertEquals(1,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(1);
channel1.close();
con.close();
assertEquals(2,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(2);
when(mockConnection1.isOpen()).thenReturn(false);
when(mockChannel1.isOpen()).thenReturn(false);
@@ -517,15 +510,13 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
verify(mockConnection2, never()).close();
assertEquals(2,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(2);
ccf.destroy();
assertEquals(2,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(2);
}
@@ -569,9 +560,9 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
}
}).start();
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Channel channel2 = con.createChannel(false);
assertSame(channelOne.get(), channel2);
assertThat(channel2).isSameAs(channelOne.get());
channel2.close();
@@ -601,21 +592,18 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
Connection con = ccf.createConnection();
Channel channel1 = con.createChannel(false);
assertEquals(0,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(0);
channel1.close();
con.close();
assertEquals(1,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(1);
channel1 = con.createChannel(false);
RabbitUtils.setPhysicalCloseRequired(channel1, true);
assertEquals(0,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(0);
channel1.close();
RabbitUtils.setPhysicalCloseRequired(channel1, false);
@@ -623,15 +611,13 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
verify(mockChannel1).close();
verify(mockConnection1, never()).close();
assertEquals(1,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(1);
ccf.destroy();
assertEquals(1,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(1);
}
@@ -655,20 +641,17 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
Connection con = ccf.createConnection();
Channel channel1 = con.createChannel(false);
assertEquals(0,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(0);
channel1.close();
assertEquals(1,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(1);
channel1.close(); // double close of proxy
assertEquals(1,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(1);
con.close();
verify(mockChannel1, never()).close();
@@ -676,9 +659,8 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
ccf.destroy();
assertEquals(1,
((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits());
assertThat(((Semaphore) TestUtils.getPropertyValue(ccf, "checkoutPermits", Map.class).values().iterator().next())
.availablePermits()).isEqualTo(1);
}
@@ -707,15 +689,15 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
channel1.close(); // should be ignored, and add last into channel cache.
Channel channel2 = con.createChannel(false);
channel2.close(); // should be ignored, and add last into channel cache.
assertSame(channel1, channel2);
assertThat(channel2).isSameAs(channel1);
Channel ch1 = con.createChannel(false); // remove first entry in cache
// (channel1)
Channel ch2 = con.createChannel(false); // create new channel
assertNotSame(ch1, ch2);
assertSame(ch1, channel1);
assertNotSame(ch2, channel2);
assertThat(ch2).isNotSameAs(ch1);
assertThat(channel1).isSameAs(ch1);
assertThat(channel2).isNotSameAs(ch2);
ch1.close();
ch2.close();
@@ -759,14 +741,14 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
*/
Channel channel2 = con.createChannel(false);
channel2.close(); // should be ignored, and add last into channel cache.
assertNotSame(channel1, channel2);
assertThat(channel2).isNotSameAs(channel1);
Channel ch1 = con.createChannel(true); // remove first entry in cache (channel1)
Channel ch2 = con.createChannel(false); // create new channel
assertNotSame(ch1, ch2);
assertSame(ch1, channel1); // The non-transactional one
assertSame(ch2, channel2);
assertThat(ch2).isNotSameAs(ch1);
assertThat(channel1).isSameAs(ch1); // The non-transactional one
assertThat(channel2).isSameAs(ch2);
ch1.close();
ch2.close();
@@ -781,10 +763,10 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
@SuppressWarnings("unchecked")
List<Channel> notxlist = (List<Channel>) ReflectionTestUtils.getField(ccf, "cachedChannelsNonTransactional");
assertEquals(1, notxlist.size());
assertThat(notxlist.size()).isEqualTo(1);
@SuppressWarnings("unchecked")
List<Channel> txlist = (List<Channel>) ReflectionTestUtils.getField(ccf, "cachedChannelsTransactional");
assertEquals(1, txlist.size());
assertThat(txlist.size()).isEqualTo(1);
}
@@ -798,7 +780,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
Channel mockChannel2 = mock(Channel.class);
Channel mockChannel3 = mock(Channel.class);
assertNotSame(mockChannel1, mockChannel2);
assertThat(mockChannel2).isNotSameAs(mockChannel1);
when(mockConnectionFactory.newConnection(any(ExecutorService.class), anyString())).thenReturn(mockConnection1, mockConnection2);
when(mockConnection1.createChannel()).thenReturn(mockChannel1, mockChannel2);
@@ -829,14 +811,14 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
// remove first entry in cache (channel2)
Channel ch2 = con.createChannel(false);
assertSame(ch1, channel1);
assertSame(ch2, channel2);
assertThat(channel1).isSameAs(ch1);
assertThat(channel2).isSameAs(ch2);
Channel target1 = ((ChannelProxy) ch1).getTargetChannel();
Channel target2 = ((ChannelProxy) ch2).getTargetChannel();
// make sure mokito returned different mocks for the channel
assertNotSame(target1, target2);
assertThat(target2).isNotSameAs(target1);
ch1.close();
ch2.close();
@@ -854,12 +836,12 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
// After destroy we can get a new connection
Connection con1 = ccf.createConnection();
assertNotSame(conDelegate, targetDelegate(con1));
assertThat(targetDelegate(con1)).isNotSameAs(conDelegate);
// This will return a proxy that surpresses calls to close
Channel channel3 = con.createChannel(false);
assertNotSame(channel3, channel1);
assertNotSame(channel3, channel2);
assertThat(channel1).isNotSameAs(channel3);
assertThat(channel2).isNotSameAs(channel3);
}
@Test
@@ -887,7 +869,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
Connection con = connectionFactory.createConnection();
Channel channel = con.createChannel(false);
assertEquals(1, called.get());
assertThat(called.get()).isEqualTo(1);
channel.close();
con.close();
@@ -895,7 +877,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
connectionFactory.createConnection();
con.createChannel(false);
assertEquals(1, called.get());
assertThat(called.get()).isEqualTo(1);
connectionFactory.destroy();
verify(mockConnection, atLeastOnce()).close(anyInt());
@@ -941,7 +923,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
Connection con = connectionFactory.createConnection();
Channel channel = con.createChannel(false);
assertSame(con, created.get());
assertThat(created.get()).isSameAs(con);
channel.close();
con.close();
@@ -949,7 +931,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
Connection same = connectionFactory.createConnection();
channel = con.createChannel(false);
assertSame(con, same);
assertThat(same).isSameAs(con);
channel.close();
com.rabbitmq.client.Connection conDelegate = targetDelegate(con);
@@ -957,17 +939,17 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
when(mockChannel.isOpen()).thenReturn(false); // force a connection refresh
channel.basicCancel("foo");
channel.close();
assertEquals(1, timesClosed.get());
assertThat(timesClosed.get()).isEqualTo(1);
Connection notSame = connectionFactory.createConnection();
assertNotSame(conDelegate, targetDelegate(notSame));
assertSame(con, closed.get());
assertSame(notSame, created.get());
assertThat(targetDelegate(notSame)).isNotSameAs(conDelegate);
assertThat(closed.get()).isSameAs(con);
assertThat(created.get()).isSameAs(notSame);
connectionFactory.destroy();
verify(mockConnection2, atLeastOnce()).close(anyInt());
assertSame(notSame, closed.get());
assertEquals(2, timesClosed.get());
assertThat(closed.get()).isSameAs(notSame);
assertThat(timesClosed.get()).isEqualTo(2);
verify(mockConnectionFactory, times(2)).newConnection(any(ExecutorService.class), anyString());
}
@@ -1004,9 +986,9 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
ccf.afterPropertiesSet();
Set<?> allocatedConnections = TestUtils.getPropertyValue(ccf, "allocatedConnections", Set.class);
assertEquals(0, allocatedConnections.size());
assertThat(allocatedConnections.size()).isEqualTo(0);
BlockingQueue<?> idleConnections = TestUtils.getPropertyValue(ccf, "idleConnections", BlockingQueue.class);
assertEquals(0, idleConnections.size());
assertThat(idleConnections.size()).isEqualTo(0);
final AtomicReference<com.rabbitmq.client.Connection> createNotification =
new AtomicReference<com.rabbitmq.client.Connection>();
@@ -1016,23 +998,23 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
@Override
public void onCreate(Connection connection) {
assertNull(createNotification.get());
assertThat(createNotification.get()).isNull();
createNotification.set(targetDelegate(connection));
}
@Override
public void onClose(Connection connection) {
assertNull(closedNotification.get());
assertThat(closedNotification.get()).isNull();
closedNotification.set(targetDelegate(connection));
}
}));
Connection con1 = ccf.createConnection();
verifyConnectionIs(mockConnections.get(0), con1);
assertEquals(1, allocatedConnections.size());
assertEquals(0, idleConnections.size());
assertNotNull(createNotification.get());
assertSame(mockConnections.get(0), createNotification.getAndSet(null));
assertThat(allocatedConnections.size()).isEqualTo(1);
assertThat(idleConnections.size()).isEqualTo(0);
assertThat(createNotification.get()).isNotNull();
assertThat(createNotification.getAndSet(null)).isSameAs(mockConnections.get(0));
Channel channel1 = con1.createChannel(false);
verifyChannelIs(mockChannels.get(0), channel1);
@@ -1042,9 +1024,9 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
con1.close(); // should be ignored, and placed into connection cache.
verify(mockConnections.get(0), never()).close();
assertEquals(1, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertNull(closedNotification.get());
assertThat(allocatedConnections.size()).isEqualTo(1);
assertThat(idleConnections.size()).isEqualTo(1);
assertThat(closedNotification.get()).isNull();
/*
* will retrieve same connection that was just put into cache, and reuse single channel from cache as well
@@ -1057,9 +1039,9 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
verify(mockChannels.get(0), never()).close();
con2.close();
verify(mockConnections.get(0), never()).close();
assertEquals(1, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertNull(createNotification.get());
assertThat(allocatedConnections.size()).isEqualTo(1);
assertThat(idleConnections.size()).isEqualTo(1);
assertThat(createNotification.get()).isNull();
/*
* Now check for multiple connections/channels
@@ -1072,45 +1054,45 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
verifyChannelIs(mockChannels.get(0), channel1);
channel2 = con2.createChannel(false);
verifyChannelIs(mockChannels.get(1), channel2);
assertEquals(2, allocatedConnections.size());
assertEquals(0, idleConnections.size());
assertNotNull(createNotification.get());
assertSame(mockConnections.get(1), createNotification.getAndSet(null));
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(0);
assertThat(createNotification.get()).isNotNull();
assertThat(createNotification.getAndSet(null)).isSameAs(mockConnections.get(1));
// put mock1 in cache
channel1.close();
verify(mockChannels.get(1), never()).close();
con1.close();
verify(mockConnections.get(0), never()).close();
assertEquals(2, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertNull(closedNotification.get());
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(1);
assertThat(closedNotification.get()).isNull();
Connection con3 = ccf.createConnection();
assertNull(createNotification.get());
assertThat(createNotification.get()).isNull();
verifyConnectionIs(mockConnections.get(0), con3);
Channel channel3 = con3.createChannel(false);
verifyChannelIs(mockChannels.get(0), channel3);
assertEquals(2, allocatedConnections.size());
assertEquals(0, idleConnections.size());
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(0);
channel2.close();
con2.close();
assertEquals(2, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(1);
channel3.close();
con3.close();
assertEquals(2, allocatedConnections.size());
assertEquals(2, idleConnections.size());
assertEquals("1", ccf.getCacheProperties().get("openConnections"));
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(2);
assertThat(ccf.getCacheProperties().get("openConnections")).isEqualTo("1");
/*
* Cache size is 1; con3 (mock1) should have been a real close.
* con2 (mock2) should still be in the cache.
*/
verify(mockConnections.get(0)).close(30000);
assertNotNull(closedNotification.get());
assertSame(mockConnections.get(0), closedNotification.getAndSet(null));
assertThat(closedNotification.get()).isNotNull();
assertThat(closedNotification.getAndSet(null)).isSameAs(mockConnections.get(0));
verify(mockChannels.get(1), never()).close();
verify(mockConnections.get(1), never()).close(30000);
verify(mockChannels.get(1), never()).close();
@@ -1121,47 +1103,47 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
when(mockConnections.get(1).isOpen()).thenReturn(false);
when(mockChannels.get(1).isOpen()).thenReturn(false);
con3 = ccf.createConnection();
assertNotNull(closedNotification.get());
assertSame(mockConnections.get(1), closedNotification.getAndSet(null));
assertThat(closedNotification.get()).isNotNull();
assertThat(closedNotification.getAndSet(null)).isSameAs(mockConnections.get(1));
verifyConnectionIs(mockConnections.get(2), con3);
assertNotNull(createNotification.get());
assertSame(mockConnections.get(2), createNotification.getAndSet(null));
assertEquals(2, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertEquals("1", ccf.getCacheProperties().get("openConnections"));
assertThat(createNotification.get()).isNotNull();
assertThat(createNotification.getAndSet(null)).isSameAs(mockConnections.get(2));
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(1);
assertThat(ccf.getCacheProperties().get("openConnections")).isEqualTo("1");
channel3 = con3.createChannel(false);
verifyChannelIs(mockChannels.get(2), channel3);
channel3.close();
con3.close();
assertNull(closedNotification.get());
assertEquals(2, allocatedConnections.size());
assertEquals(2, idleConnections.size());
assertEquals("1", ccf.getCacheProperties().get("openConnections"));
assertThat(closedNotification.get()).isNull();
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(2);
assertThat(ccf.getCacheProperties().get("openConnections")).isEqualTo("1");
/*
* Now a closed cached connection when creating a channel
*/
con3 = ccf.createConnection();
verifyConnectionIs(mockConnections.get(2), con3);
assertNull(createNotification.get());
assertEquals(2, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertThat(createNotification.get()).isNull();
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(1);
when(mockConnections.get(2).isOpen()).thenReturn(false);
channel3 = con3.createChannel(false);
assertNotNull(closedNotification.getAndSet(null));
assertNotNull(createNotification.getAndSet(null));
assertThat(closedNotification.getAndSet(null)).isNotNull();
assertThat(createNotification.getAndSet(null)).isNotNull();
verifyChannelIs(mockChannels.get(3), channel3);
channel3.close();
con3.close();
assertNull(closedNotification.get());
assertEquals(2, allocatedConnections.size());
assertEquals(2, idleConnections.size());
assertEquals("1", ccf.getCacheProperties().get("openConnections"));
assertThat(closedNotification.get()).isNull();
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(2);
assertThat(ccf.getCacheProperties().get("openConnections")).isEqualTo("1");
// destroy
ccf.destroy();
assertNotNull(closedNotification.get());
assertThat(closedNotification.get()).isNotNull();
verify(mockConnections.get(3)).close(30000);
}
@@ -1200,9 +1182,9 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
ccf.afterPropertiesSet();
Set<?> allocatedConnections = TestUtils.getPropertyValue(ccf, "allocatedConnections", Set.class);
assertEquals(0, allocatedConnections.size());
assertThat(allocatedConnections.size()).isEqualTo(0);
BlockingQueue<?> idleConnections = TestUtils.getPropertyValue(ccf, "idleConnections", BlockingQueue.class);
assertEquals(0, idleConnections.size());
assertThat(idleConnections.size()).isEqualTo(0);
@SuppressWarnings("unchecked")
Map<?, List<?>> cachedChannels = TestUtils.getPropertyValue(ccf, "allocatedConnectionNonTransactionalChannels",
Map.class);
@@ -1215,23 +1197,23 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
@Override
public void onCreate(Connection connection) {
assertNull(createNotification.get());
assertThat(createNotification.get()).isNull();
createNotification.set(targetDelegate(connection));
}
@Override
public void onClose(Connection connection) {
assertNull(closedNotification.get());
assertThat(closedNotification.get()).isNull();
closedNotification.set(targetDelegate(connection));
}
}));
Connection con1 = ccf.createConnection();
verifyConnectionIs(mockConnections.get(0), con1);
assertEquals(1, allocatedConnections.size());
assertEquals(0, idleConnections.size());
assertNotNull(createNotification.get());
assertSame(mockConnections.get(0), createNotification.getAndSet(null));
assertThat(allocatedConnections.size()).isEqualTo(1);
assertThat(idleConnections.size()).isEqualTo(0);
assertThat(createNotification.get()).isNotNull();
assertThat(createNotification.getAndSet(null)).isSameAs(mockConnections.get(0));
Channel channel1 = con1.createChannel(false);
verifyChannelIs(mockChannels.get(0), channel1);
@@ -1241,10 +1223,10 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
con1.close(); // should be ignored, and placed into connection cache.
verify(mockConnections.get(0), never()).close();
assertEquals(1, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertEquals(1, cachedChannels.get(con1).size());
assertNull(closedNotification.get());
assertThat(allocatedConnections.size()).isEqualTo(1);
assertThat(idleConnections.size()).isEqualTo(1);
assertThat(cachedChannels.get(con1).size()).isEqualTo(1);
assertThat(closedNotification.get()).isNull();
/*
* will retrieve same connection that was just put into cache, and reuse single channel from cache as well
@@ -1257,9 +1239,9 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
verify(mockChannels.get(0), never()).close();
con2.close();
verify(mockConnections.get(0), never()).close();
assertEquals(1, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertNull(createNotification.get());
assertThat(allocatedConnections.size()).isEqualTo(1);
assertThat(idleConnections.size()).isEqualTo(1);
assertThat(createNotification.get()).isNull();
/*
* Now check for multiple connections/channels
@@ -1272,49 +1254,49 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
verifyChannelIs(mockChannels.get(0), channel1);
channel2 = con2.createChannel(false);
verifyChannelIs(mockChannels.get(1), channel2);
assertEquals(2, allocatedConnections.size());
assertEquals(0, idleConnections.size());
assertNotNull(createNotification.get());
assertSame(mockConnections.get(1), createNotification.getAndSet(null));
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(0);
assertThat(createNotification.get()).isNotNull();
assertThat(createNotification.getAndSet(null)).isSameAs(mockConnections.get(1));
// put mock1 in cache
channel1.close();
verify(mockChannels.get(1), never()).close();
con1.close();
verify(mockConnections.get(0), never()).close();
assertEquals(2, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertNull(closedNotification.get());
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(1);
assertThat(closedNotification.get()).isNull();
Connection con3 = ccf.createConnection();
assertNull(createNotification.get());
assertThat(createNotification.get()).isNull();
verifyConnectionIs(mockConnections.get(0), con3);
Channel channel3 = con3.createChannel(false);
verifyChannelIs(mockChannels.get(0), channel3);
assertEquals(2, allocatedConnections.size());
assertEquals(0, idleConnections.size());
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(0);
channel2.close();
con2.close();
assertEquals(2, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(1);
channel3.close();
con3.close();
assertEquals(2, allocatedConnections.size());
assertEquals(2, idleConnections.size());
assertEquals(1, cachedChannels.get(con1).size());
assertEquals(1, cachedChannels.get(con2).size());
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(2);
assertThat(cachedChannels.get(con1).size()).isEqualTo(1);
assertThat(cachedChannels.get(con2).size()).isEqualTo(1);
/*
* Cache size is 2; neither should have been a real close.
* con2 (mock2) and con1 should still be in the cache.
*/
verify(mockConnections.get(0), never()).close(30000);
assertNull(closedNotification.get());
assertThat(closedNotification.get()).isNull();
verify(mockChannels.get(1), never()).close();
verify(mockConnections.get(1), never()).close(30000);
verify(mockChannels.get(1), never()).close();
assertEquals(2, idleConnections.size());
assertThat(idleConnections.size()).isEqualTo(2);
Iterator<?> iterator = idleConnections.iterator();
verifyConnectionIs(mockConnections.get(1), iterator.next());
verifyConnectionIs(mockConnections.get(0), iterator.next());
@@ -1323,56 +1305,56 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
*/
when(mockConnections.get(1).isOpen()).thenReturn(false);
con3 = ccf.createConnection();
assertNotNull(closedNotification.get());
assertSame(mockConnections.get(1), closedNotification.getAndSet(null));
assertThat(closedNotification.get()).isNotNull();
assertThat(closedNotification.getAndSet(null)).isSameAs(mockConnections.get(1));
verifyConnectionIs(mockConnections.get(0), con3);
assertNull(createNotification.get());
assertEquals(2, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertThat(createNotification.get()).isNull();
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(1);
channel3 = con3.createChannel(false);
verifyChannelIs(mockChannels.get(0), channel3);
channel3.close();
con3.close();
assertNull(closedNotification.get());
assertEquals(2, allocatedConnections.size());
assertEquals(2, idleConnections.size());
assertThat(closedNotification.get()).isNull();
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(2);
/*
* Now a closed cached connection when creating a channel
*/
con3 = ccf.createConnection();
verifyConnectionIs(mockConnections.get(0), con3);
assertNull(createNotification.get());
assertEquals(2, allocatedConnections.size());
assertEquals(1, idleConnections.size());
assertThat(createNotification.get()).isNull();
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(1);
when(mockConnections.get(0).isOpen()).thenReturn(false);
channel3 = con3.createChannel(false);
assertNotNull(closedNotification.getAndSet(null));
assertNotNull(createNotification.getAndSet(null));
assertThat(closedNotification.getAndSet(null)).isNotNull();
assertThat(createNotification.getAndSet(null)).isNotNull();
verifyChannelIs(mockChannels.get(2), channel3);
channel3.close();
con3.close();
assertNull(closedNotification.get());
assertEquals(2, allocatedConnections.size());
assertEquals(2, idleConnections.size());
assertThat(closedNotification.get()).isNull();
assertThat(allocatedConnections.size()).isEqualTo(2);
assertThat(idleConnections.size()).isEqualTo(2);
Connection con4 = ccf.createConnection();
assertSame(con3, con4);
assertEquals(1, idleConnections.size());
assertThat(con4).isSameAs(con3);
assertThat(idleConnections.size()).isEqualTo(1);
Channel channelA = con4.createChannel(false);
Channel channelB = con4.createChannel(false);
Channel channelC = con4.createChannel(false);
channelA.close();
assertEquals(1, cachedChannels.get(con4).size());
assertThat(cachedChannels.get(con4).size()).isEqualTo(1);
channelB.close();
assertEquals(2, cachedChannels.get(con4).size());
assertThat(cachedChannels.get(con4).size()).isEqualTo(2);
channelC.close();
assertEquals(2, cachedChannels.get(con4).size());
assertThat(cachedChannels.get(con4).size()).isEqualTo(2);
// destroy
ccf.destroy();
assertNotNull(closedNotification.get());
assertThat(closedNotification.get()).isNotNull();
// physical wasn't invoked, because this mockConnection marked with 'false' for 'isOpen()'
verify(mockConnections.get(0)).close(30000);
verify(mockConnections.get(1)).close(30000);
@@ -1412,36 +1394,36 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
ccf.afterPropertiesSet();
Set<?> allocatedConnections = TestUtils.getPropertyValue(ccf, "allocatedConnections", Set.class);
assertEquals(0, allocatedConnections.size());
assertThat(allocatedConnections.size()).isEqualTo(0);
BlockingQueue<?> idleConnections = TestUtils.getPropertyValue(ccf, "idleConnections", BlockingQueue.class);
assertEquals(0, idleConnections.size());
assertThat(idleConnections.size()).isEqualTo(0);
Connection conn1 = ccf.createConnection();
Connection conn2 = ccf.createConnection();
Connection conn3 = ccf.createConnection();
assertEquals(3, allocatedConnections.size());
assertEquals(0, idleConnections.size());
assertThat(allocatedConnections.size()).isEqualTo(3);
assertThat(idleConnections.size()).isEqualTo(0);
conn1.close();
conn2.close();
conn3.close();
assertEquals(3, allocatedConnections.size());
assertEquals(3, idleConnections.size());
assertThat(allocatedConnections.size()).isEqualTo(3);
assertThat(idleConnections.size()).isEqualTo(3);
when(mockConnections.get(0).isOpen()).thenReturn(false);
when(mockConnections.get(1).isOpen()).thenReturn(false);
Connection conn4 = ccf.createConnection();
assertEquals(3, allocatedConnections.size());
assertEquals(2, idleConnections.size());
assertSame(conn3, conn4);
assertThat(allocatedConnections.size()).isEqualTo(3);
assertThat(idleConnections.size()).isEqualTo(2);
assertThat(conn4).isSameAs(conn3);
conn4.close();
assertEquals(3, allocatedConnections.size());
assertEquals(3, idleConnections.size());
assertEquals("1", ccf.getCacheProperties().get("openConnections"));
assertThat(allocatedConnections.size()).isEqualTo(3);
assertThat(idleConnections.size()).isEqualTo(3);
assertThat(ccf.getCacheProperties().get("openConnections")).isEqualTo("1");
ccf.destroy();
assertEquals(3, allocatedConnections.size());
assertEquals(3, idleConnections.size());
assertEquals("0", ccf.getCacheProperties().get("openConnections"));
assertThat(allocatedConnections.size()).isEqualTo(3);
assertThat(idleConnections.size()).isEqualTo(3);
assertThat(ccf.getCacheProperties().get("openConnections")).isEqualTo("0");
}
@Test
@@ -1483,7 +1465,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
RabbitUtils.setPhysicalCloseRequired(channel, false);
con.close(); // should be ignored
assertTrue(physicalCloseLatch.await(10, TimeUnit.SECONDS));
assertThat(physicalCloseLatch.await(10, TimeUnit.SECONDS)).isTrue();
}
finally {
executor.shutdownNow();
@@ -1491,7 +1473,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
}
private void verifyConnectionIs(com.rabbitmq.client.Connection mockConnection, Object con) {
assertSame(mockConnection, targetDelegate(con));
assertThat(targetDelegate(con)).isSameAs(mockConnection);
}
private com.rabbitmq.client.Connection targetDelegate(Object con) {
@@ -1501,7 +1483,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
private void verifyChannelIs(Channel mockChannel, Channel channel) {
ChannelProxy proxy = (ChannelProxy) channel;
assertSame(mockChannel, proxy.getTargetChannel());
assertThat(proxy.getTargetChannel()).isSameAs(mockChannel);
}
@Test
@@ -1593,7 +1575,7 @@ public class CachingConnectionFactoryTests extends AbstractConnectionFactoryTest
channel.close(); // physically closed, so remove from the cache.
channel.close(); // physically closed and removed from the cache before, so void "close".
Channel channel2 = con.createChannel(false);
assertNotSame(channel, channel2);
assertThat(channel2).isNotSameAs(channel);
}
@Test

4
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/connection/LocalizedQueueConnectionFactoryIntegrationTests.java
View File

@@ -16,7 +16,7 @@
package org.springframework.amqp.rabbit.connection;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.UUID;
@@ -71,7 +71,7 @@ public class LocalizedQueueConnectionFactoryIntegrationTests {
ConnectionFactory targetConnectionFactory = this.lqcf.getTargetConnectionFactory("[" + queue.getName() + "]");
RabbitTemplate template = new RabbitTemplate(targetConnectionFactory);
template.convertAndSend("", queue.getName(), "foo");
assertEquals("foo", template.receiveAndConvert(queue.getName()));
assertThat(template.receiveAndConvert(queue.getName())).isEqualTo("foo");
admin.deleteQueue(queue.getName());
}

30
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/connection/RoutingConnectionFactoryTests.java
View File

@@ -16,11 +16,7 @@
package org.springframework.amqp.rabbit.connection;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.BDDMockito.given;
@@ -114,7 +110,7 @@ public class RoutingConnectionFactoryTests {
}
executorService.shutdown();
assertTrue(executorService.awaitTermination(10, TimeUnit.SECONDS));
assertThat(executorService.awaitTermination(10, TimeUnit.SECONDS)).isTrue();
verify(connectionFactory1, times(2)).createConnection();
verify(connectionFactory2).createConnection();
@@ -132,17 +128,17 @@ public class RoutingConnectionFactoryTests {
};
//Make sure map is initialized and doesn't contain lookup key "1"
assertNull(routingFactory.getTargetConnectionFactory("1"));
assertThat(routingFactory.getTargetConnectionFactory("1")).isNull();
//Add one and make sure it's there
routingFactory.addTargetConnectionFactory("1", targetConnectionFactory);
assertEquals(targetConnectionFactory, routingFactory.getTargetConnectionFactory("1"));
assertNull(routingFactory.getTargetConnectionFactory("2"));
assertThat(routingFactory.getTargetConnectionFactory("1")).isEqualTo(targetConnectionFactory);
assertThat(routingFactory.getTargetConnectionFactory("2")).isNull();
//Remove it and make sure it's gone
ConnectionFactory removedConnectionFactory = routingFactory.removeTargetConnectionFactory("1");
assertEquals(targetConnectionFactory, removedConnectionFactory);
assertNull(routingFactory.getTargetConnectionFactory("1"));
assertThat(removedConnectionFactory).isEqualTo(targetConnectionFactory);
assertThat(routingFactory.getTargetConnectionFactory("1")).isNull();
}
@Test
@@ -234,10 +230,10 @@ public class RoutingConnectionFactoryTests {
container.setLookupKeyQualifier("xxx");
container.afterPropertiesSet();
container.start();
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
container.stop();
assertThat(connectionMakerKey1.get(), equalTo("xxx[foo]"));
assertThat(connectionMakerKey2.get(), equalTo("xxx[foo]"));
assertThat(connectionMakerKey1.get()).isEqualTo("xxx[foo]");
assertThat(connectionMakerKey2.get()).isEqualTo("xxx[foo]");
}
@Test
@@ -274,10 +270,10 @@ public class RoutingConnectionFactoryTests {
container.setShutdownTimeout(10);
container.afterPropertiesSet();
container.start();
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
container.stop();
assertThat(connectionMakerKey.get(), equalTo("xxx[foo]"));
assertThat(connectionMakerKey2.get(), equalTo("xxx[foo]"));
assertThat(connectionMakerKey.get()).isEqualTo("xxx[foo]");
assertThat(connectionMakerKey2.get()).isEqualTo("xxx[foo]");
}
}

13
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/core/RabbitGatewaySupportTests.java
View File

@@ -16,7 +16,7 @@
package org.springframework.amqp.rabbit.core;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import java.util.ArrayList;
@@ -45,10 +45,9 @@ public class RabbitGatewaySupportTests {
};
gateway.setConnectionFactory(mockConnectionFactory);
gateway.afterPropertiesSet();
assertEquals("Correct ConnectionFactory", mockConnectionFactory, gateway.getConnectionFactory());
assertEquals("Correct RabbitTemplate", mockConnectionFactory,
gateway.getRabbitOperations().getConnectionFactory());
assertEquals("initGatway called", test.size(), 1);
assertThat(gateway.getConnectionFactory()).as("Correct ConnectionFactory").isEqualTo(mockConnectionFactory);
assertThat(gateway.getRabbitOperations().getConnectionFactory()).as("Correct RabbitTemplate").isEqualTo(mockConnectionFactory);
assertThat(1).as("initGatway called").isEqualTo(test.size());
}
@Test
@@ -63,8 +62,8 @@ public class RabbitGatewaySupportTests {
};
gateway.setRabbitOperations(template);
gateway.afterPropertiesSet();
assertEquals("Correct RabbitTemplate", template, gateway.getRabbitOperations());
assertEquals("initGateway called", test.size(), 1);
assertThat(gateway.getRabbitOperations()).as("Correct RabbitTemplate").isEqualTo(template);
assertThat(1).as("initGateway called").isEqualTo(test.size());
}
}

37
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/core/RabbitTemplateDirectReplyToContainerIntegrationTests.java
View File

@@ -18,7 +18,6 @@ package org.springframework.amqp.rabbit.core;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.Assert.assertNotNull;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
@@ -47,54 +46,54 @@ public class RabbitTemplateDirectReplyToContainerIntegrationTests extends Rabbit
@Override
protected RabbitTemplate createSendAndReceiveRabbitTemplate(ConnectionFactory connectionFactory) {
RabbitTemplate template = super.createSendAndReceiveRabbitTemplate(connectionFactory);
template.setUseDirectReplyToContainer(true);
template.setBeanName(this.testName.getMethodName() + "SendReceiveRabbitTemplate");
return template;
RabbitTemplate rabbitTemplate = super.createSendAndReceiveRabbitTemplate(connectionFactory);
rabbitTemplate.setUseDirectReplyToContainer(true);
rabbitTemplate.setBeanName(this.testName.getMethodName() + "SendReceiveRabbitTemplate");
return rabbitTemplate;
}
@SuppressWarnings("unchecked")
@Test
public void channelReleasedOnTimeout() throws Exception {
final CachingConnectionFactory connectionFactory = new CachingConnectionFactory("localhost");
RabbitTemplate template = createSendAndReceiveRabbitTemplate(connectionFactory);
template.setReplyTimeout(1);
RabbitTemplate rabbitTemplate = createSendAndReceiveRabbitTemplate(connectionFactory);
rabbitTemplate.setReplyTimeout(1);
AtomicReference<Throwable> exception = new AtomicReference<>();
CountDownLatch latch = new CountDownLatch(1);
ErrorHandler replyErrorHandler = t -> {
exception.set(t);
latch.countDown();
};
template.setReplyErrorHandler(replyErrorHandler);
Object reply = template.convertSendAndReceive(ROUTE, "foo");
rabbitTemplate.setReplyErrorHandler(replyErrorHandler);
Object reply = rabbitTemplate.convertSendAndReceive(ROUTE, "foo");
assertThat(reply).isNull();
Object container = TestUtils.getPropertyValue(template, "directReplyToContainers", Map.class)
.get(template.isUsePublisherConnection()
Object container = TestUtils.getPropertyValue(rabbitTemplate, "directReplyToContainers", Map.class)
.get(rabbitTemplate.isUsePublisherConnection()
? connectionFactory.getPublisherConnectionFactory()
: connectionFactory);
assertThat(TestUtils.getPropertyValue(container, "inUseConsumerChannels", Map.class)).hasSize(0);
assertThat(TestUtils.getPropertyValue(container, "errorHandler")).isSameAs(replyErrorHandler);
Message replyMessage = new Message("foo".getBytes(), new MessageProperties());
assertThatThrownBy(() -> template.onMessage(replyMessage))
assertThatThrownBy(() -> rabbitTemplate.onMessage(replyMessage))
.isInstanceOf(AmqpRejectAndDontRequeueException.class)
.hasMessage("No correlation header in reply");
replyMessage.getMessageProperties().setCorrelationId("foo");
assertThatThrownBy(() -> template.onMessage(replyMessage))
assertThatThrownBy(() -> rabbitTemplate.onMessage(replyMessage))
.isInstanceOf(AmqpRejectAndDontRequeueException.class)
.hasMessage("Reply received after timeout");
ExecutorService executor = Executors.newFixedThreadPool(1);
// Set up a consumer to respond to our producer
executor.submit(() -> {
Message message = template.receive(ROUTE, 10_000);
assertNotNull("No message received", message);
template.send(message.getMessageProperties().getReplyTo(), replyMessage);
Message message = rabbitTemplate.receive(ROUTE, 10_000);
assertThat(message).as("No message received").isNotNull();
rabbitTemplate.send(message.getMessageProperties().getReplyTo(), replyMessage);
return message;
});
while (template.receive(ROUTE, 100) != null) {
while (rabbitTemplate.receive(ROUTE, 100) != null) {
// empty
}
reply = template.convertSendAndReceive(ROUTE, "foo");
reply = rabbitTemplate.convertSendAndReceive(ROUTE, "foo");
assertThat(reply).isNull();
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(exception.get()).isInstanceOf(ListenerExecutionFailedException.class);
@@ -103,7 +102,7 @@ public class RabbitTemplateDirectReplyToContainerIntegrationTests extends Rabbit
.isEqualTo(replyMessage.getBody());
assertThat(TestUtils.getPropertyValue(container, "inUseConsumerChannels", Map.class)).hasSize(0);
executor.shutdownNow();
template.stop();
rabbitTemplate.stop();
connectionFactory.destroy();
}

74
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/core/RabbitTemplateIntegrationTests.java
View File

@@ -16,6 +16,7 @@
package org.springframework.amqp.rabbit.core;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
@@ -221,21 +222,21 @@ public class RabbitTemplateIntegrationTests {
while (n++ < 100 && channel.isOpen()) {
Thread.sleep(100);
}
assertFalse(channel.isOpen());
assertThat(channel.isOpen()).isFalse();
try {
this.template.convertAndSend(ROUTE, "bar");
fail("Expected Exception");
}
catch (UncategorizedAmqpException e) {
if (e.getCause() instanceof IllegalStateException) {
assertThat(e.getCause().getMessage(), equalTo("Channel closed during transaction"));
assertThat(e.getCause().getMessage()).isEqualTo("Channel closed during transaction");
}
else {
fail("Expected IllegalStateException not" + e.getCause());
}
}
catch (AmqpConnectException e) {
assertThat(e.getCause(), instanceOf(AlreadyClosedException.class));
assertThat(e.getCause()).isInstanceOf(AlreadyClosedException.class);
}
}
finally {
@@ -250,23 +251,23 @@ public class RabbitTemplateIntegrationTests {
this.connectionFactory.destroy();
this.template.setUsePublisherConnection(true);
this.template.convertAndSend("dummy", "foo");
assertNull(TestUtils.getPropertyValue(this.connectionFactory, "connection.target"));
assertNotNull(TestUtils.getPropertyValue(
this.connectionFactory, "publisherConnectionFactory.connection.target"));
assertThat(TestUtils.getPropertyValue(this.connectionFactory, "connection.target")).isNull();
assertThat(TestUtils.getPropertyValue(
this.connectionFactory, "publisherConnectionFactory.connection.target")).isNotNull();
this.connectionFactory.destroy();
assertNull(TestUtils.getPropertyValue(this.connectionFactory, "connection.target"));
assertNull(TestUtils.getPropertyValue(
this.connectionFactory, "publisherConnectionFactory.connection.target"));
assertThat(TestUtils.getPropertyValue(this.connectionFactory, "connection.target")).isNull();
assertThat(TestUtils.getPropertyValue(
this.connectionFactory, "publisherConnectionFactory.connection.target")).isNull();
Channel channel = this.connectionFactory.createConnection().createChannel(true);
assertNotNull(TestUtils.getPropertyValue(this.connectionFactory, "connection.target"));
assertThat(TestUtils.getPropertyValue(this.connectionFactory, "connection.target")).isNotNull();
RabbitResourceHolder holder = new RabbitResourceHolder(channel, true);
TransactionSynchronizationManager.bindResource(this.connectionFactory, holder);
try {
this.template.setChannelTransacted(true);
this.template.convertAndSend("dummy", "foo");
assertNotNull(TestUtils.getPropertyValue(this.connectionFactory, "connection.target"));
assertNull(TestUtils.getPropertyValue(
this.connectionFactory, "publisherConnectionFactory.connection.target"));
assertThat(TestUtils.getPropertyValue(this.connectionFactory, "connection.target")).isNotNull();
assertThat(TestUtils.getPropertyValue(
this.connectionFactory, "publisherConnectionFactory.connection.target")).isNull();
}
finally {
TransactionSynchronizationManager.unbindResource(this.connectionFactory);
@@ -283,9 +284,9 @@ public class RabbitTemplateIntegrationTests {
Thread.sleep(100);
out = (String) this.template.receiveAndConvert(ROUTE);
}
assertNotNull(out);
assertEquals("nonblock", out);
assertNull(this.template.receive(ROUTE));
assertThat(out).isNotNull();
assertThat(out).isEqualTo("nonblock");
assertThat(this.template.receive(ROUTE)).isNull();
}
@Test(expected = ConsumerCancelledException.class)
@@ -376,22 +377,22 @@ public class RabbitTemplateIntegrationTests {
this.template.setUserIdExpressionString("@cf.username");
this.template.convertAndSend(ROUTE, "block");
Message received = this.template.receive(ROUTE, 10000);
assertNotNull(received);
assertEquals("block", new String(received.getBody()));
assertThat(received.getMessageProperties().getReceivedUserId(), equalTo("guest"));
assertThat(received).isNotNull();
assertThat(new String(received.getBody())).isEqualTo("block");
assertThat(received.getMessageProperties().getReceivedUserId()).isEqualTo("guest");
this.template.setReceiveTimeout(0);
assertNull(this.template.receive(ROUTE));
assertThat(this.template.receive(ROUTE)).isNull();
}
@Test
public void testReceiveBlockingNoTimeout() throws Exception {
this.template.convertAndSend(ROUTE, "blockNoTO");
String out = (String) this.template.receiveAndConvert(ROUTE, -1);
assertNotNull(out);
assertEquals("blockNoTO", out);
assertThat(out).isNotNull();
assertThat(out).isEqualTo("blockNoTO");
this.template.setReceiveTimeout(1); // test the no message after timeout path
try {
assertNull(this.template.receive(ROUTE));
assertThat(this.template.receive(ROUTE)).isNull();
}
catch (ConsumeOkNotReceivedException e) {
// we're expecting no result, this could happen, depending on timing.
@@ -401,14 +402,13 @@ public class RabbitTemplateIntegrationTests {
@Test
public void testReceiveTimeoutRequeue() {
try {
assertNull(this.template.receiveAndConvert(ROUTE, 10));
assertThat(this.template.receiveAndConvert(ROUTE, 10)).isNull();
}
catch (ConsumeOkNotReceivedException e) {
// empty - race for consumeOk
}
assertEquals(0,
TestUtils.getPropertyValue(this.connectionFactory, "cachedChannelsNonTransactional", List.class)
.size());
assertThat(TestUtils.getPropertyValue(this.connectionFactory, "cachedChannelsNonTransactional", List.class)
.size()).isEqualTo(0);
}
@Test
@@ -417,10 +417,10 @@ public class RabbitTemplateIntegrationTests {
this.template.setChannelTransacted(true);
this.template.setReceiveTimeout(10000);
String out = (String) this.template.receiveAndConvert(ROUTE);
assertNotNull(out);
assertEquals("blockTX", out);
assertThat(out).isNotNull();
assertThat(out).isEqualTo("blockTX");
this.template.setReceiveTimeout(0);
assertNull(this.template.receive(ROUTE));
assertThat(this.template.receive(ROUTE)).isNull();
}
@Test
@@ -435,11 +435,11 @@ public class RabbitTemplateIntegrationTests {
String out = (String) template.receiveAndConvert(ROUTE);
resourceHolder.commitAll();
resourceHolder.closeAll();
assertSame(resourceHolder, TransactionSynchronizationManager.unbindResource(template.getConnectionFactory()));
assertNotNull(out);
assertEquals("blockGTXNoTO", out);
assertThat(TransactionSynchronizationManager.unbindResource(template.getConnectionFactory())).isSameAs(resourceHolder);
assertThat(out).isNotNull();
assertThat(out).isEqualTo("blockGTXNoTO");
this.template.setReceiveTimeout(0);
assertNull(this.template.receive(ROUTE));
assertThat(this.template.receive(ROUTE)).isNull();
}
@Test
@@ -457,9 +457,9 @@ public class RabbitTemplateIntegrationTests {
// Now send the real message, and all should be well...
template.convertAndSend(ROUTE, "message");
String result = (String) template.receiveAndConvert(ROUTE);
assertEquals("message", result);
assertThat(result).isEqualTo("message");
result = (String) template.receiveAndConvert(ROUTE);
assertEquals(null, result);
assertThat(result).isEqualTo(null);
}
@Test
@@ -475,7 +475,7 @@ public class RabbitTemplateIntegrationTests {
return message;
});
template.setAfterReceivePostProcessors(message -> {
assertEquals(Arrays.asList(strings), message.getMessageProperties().getHeaders().get("strings"));
assertThat(message.getMessageProperties().getHeaders().get("strings")).isEqualTo(Arrays.asList(strings));
assertEquals(Arrays.asList(new String[] { "FooAsAString", "FooAsAString" }),
message.getMessageProperties().getHeaders().get("objects"));
assertArrayEquals("abc".getBytes(), (byte[]) message.getMessageProperties().getHeaders().get("bytes"));

17
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/core/RabbitTemplatePublisherCallbacksIntegrationTests2.java
View File

@@ -16,8 +16,7 @@
package org.springframework.amqp.rabbit.core;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
@@ -76,20 +75,22 @@ public class RabbitTemplatePublisherCallbacksIntegrationTests2 {
this.templateWithConfirmsEnabled.convertAndSend(ROUTE, "foo");
this.templateWithConfirmsEnabled.convertAndSend(ROUTE, "foo");
assertMessageCountEquals(2L);
assertEquals(Long.valueOf(1), this.templateWithConfirmsEnabled.execute(channel -> {
Long result = this.templateWithConfirmsEnabled.execute(channel -> {
final CountDownLatch latch = new CountDownLatch(2);
String consumerTag = channel.basicConsume(ROUTE, new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
byte[] body) {
public void handleDelivery(String ag, Envelope envelope, BasicProperties properties, byte[] body) {
latch.countDown();
}
});
long consumerCount = channel.consumerCount(ROUTE);
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
channel.basicCancel(consumerTag);
return consumerCount;
}));
});
assertThat(result).isEqualTo(1L);
assertMessageCountEquals(0L);
}
@@ -100,7 +101,7 @@ public class RabbitTemplatePublisherCallbacksIntegrationTests2 {
Thread.sleep(100);
messageCount = determineMessageCount();
}
assertEquals(wanted, messageCount);
assertThat(messageCount).isEqualTo(wanted);
}
private Long determineMessageCount() {

17
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/core/SimplePublisherConfirmsTests.java
View File

@@ -16,9 +16,7 @@
package org.springframework.amqp.rabbit.core;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
@@ -46,12 +44,13 @@ public class SimplePublisherConfirmsTests {
cf.setSimplePublisherConfirms(true);
RabbitTemplate template = new RabbitTemplate(cf);
template.setRoutingKey(QUEUE);
assertTrue(template.invoke(t -> {
Boolean invokeResult = template.invoke(t -> {
template.convertAndSend("foo");
template.convertAndSend("bar");
template.waitForConfirmsOrDie(10_000);
return true;
}));
});
assertThat(invokeResult).isTrue();
cf.destroy();
}
@@ -63,7 +62,7 @@ public class SimplePublisherConfirmsTests {
template.setRoutingKey(QUEUE);
AtomicReference<MessageProperties> finalProperties = new AtomicReference<>();
AtomicLong lastAck = new AtomicLong();
assertTrue(template.invoke(t -> {
Boolean invokeResult = template.invoke(t -> {
template.convertAndSend("foo");
template.convertAndSend("bar", m -> {
finalProperties.set(m.getMessageProperties());
@@ -73,8 +72,10 @@ public class SimplePublisherConfirmsTests {
return true;
}, (tag, multiple) -> {
lastAck.set(tag);
}, (tag, multiple) -> { }));
assertThat(lastAck.get(), equalTo(finalProperties.get().getPublishSequenceNumber()));
}, (tag, multiple) -> {
});
assertThat(invokeResult).isTrue();
assertThat(lastAck.get()).isEqualTo(finalProperties.get().getPublishSequenceNumber());
cf.destroy();
}

90
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/listener/ExternalTxManagerTests.java
View File

@@ -16,9 +16,7 @@
package org.springframework.amqp.rabbit.listener;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyLong;
@@ -143,12 +141,12 @@ public abstract class ExternalTxManagerTests {
container.setTransactionAttribute(transactionAttribute);
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -156,7 +154,7 @@ public abstract class ExternalTxManagerTests {
}
verify(mockConnection, times(1)).createChannel();
assertTrue(commitLatch.get().await(10, TimeUnit.SECONDS));
assertThat(commitLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel).basicAck(anyLong(), anyBoolean());
verify(onlyChannel).txCommit();
verify(onlyChannel).basicPublish(anyString(), anyString(), anyBoolean(),
@@ -165,9 +163,9 @@ public abstract class ExternalTxManagerTests {
// verify close() was never called on the channel
DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory);
List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsTransactional");
assertEquals(0, channels.size());
assertThat(channels.size()).isEqualTo(0);
assertTrue(transactionManager.committed);
assertThat(transactionManager.committed).isTrue();
transactionManager.committed = false;
transactionManager.latch = new CountDownLatch(1);
container.setMessageListener(m -> {
@@ -176,10 +174,10 @@ public abstract class ExternalTxManagerTests {
commitLatch.set(new CountDownLatch(1));
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(transactionManager.latch.await(10, TimeUnit.SECONDS));
assertTrue(commitLatch.get().await(10, TimeUnit.SECONDS));
assertTrue(transactionManager.rolledBack);
assertTrue(rollbackLatch.get().await(10, TimeUnit.SECONDS));
assertThat(transactionManager.latch.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(commitLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
assertThat(transactionManager.rolledBack).isTrue();
assertThat(rollbackLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel).basicReject(anyLong(), anyBoolean());
verify(onlyChannel, times(1)).txRollback();
@@ -191,9 +189,9 @@ public abstract class ExternalTxManagerTests {
commitLatch.set(new CountDownLatch(1));
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(transactionManager.latch.await(10, TimeUnit.SECONDS));
assertTrue(commitLatch.get().await(10, TimeUnit.SECONDS));
assertTrue(transactionManager.committed);
assertThat(transactionManager.latch.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(commitLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
assertThat(transactionManager.committed).isTrue();
verify(onlyChannel, times(2)).basicAck(anyLong(), anyBoolean());
verify(onlyChannel, times(3)).txCommit(); // previous + reject commit for above + this one
@@ -206,10 +204,10 @@ public abstract class ExternalTxManagerTests {
rollbackLatch.set(new CountDownLatch(1));
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(transactionManager.latch.await(10, TimeUnit.SECONDS));
assertTrue(transactionManager.rolledBack);
assertTrue(rollbackLatch.get().await(10, TimeUnit.SECONDS));
assertTrue(commitLatch.get().await(10, TimeUnit.SECONDS));
assertThat(transactionManager.latch.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(transactionManager.rolledBack).isTrue();
assertThat(rollbackLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
assertThat(commitLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel, times(2)).basicReject(anyLong(), anyBoolean());
verify(onlyChannel, times(2)).txRollback();
@@ -222,9 +220,9 @@ public abstract class ExternalTxManagerTests {
commitLatch.set(new CountDownLatch(1));
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(transactionManager.latch.await(10, TimeUnit.SECONDS));
assertTrue(commitLatch.get().await(10, TimeUnit.SECONDS));
assertTrue(transactionManager.committed);
assertThat(transactionManager.latch.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(commitLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
assertThat(transactionManager.committed).isTrue();
verify(onlyChannel, times(3)).basicAck(anyLong(), anyBoolean());
verify(onlyChannel, times(5)).txCommit();
@@ -314,12 +312,12 @@ public abstract class ExternalTxManagerTests {
container.setTransactionManager(new DummyTxManager());
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -327,9 +325,9 @@ public abstract class ExternalTxManagerTests {
}
verify(mockConnection, times(1)).createChannel();
assertTrue(rejectLatch.await(10, TimeUnit.SECONDS));
assertThat(rejectLatch.await(10, TimeUnit.SECONDS)).isTrue();
assertTrue(rollbackLatch.await(10, TimeUnit.SECONDS));
assertThat(rollbackLatch.await(10, TimeUnit.SECONDS)).isTrue();
if (propagation != TransactionDefinition.PROPAGATION_NEVER) {
verify(channel).basicReject(anyLong(), eq(expectRequeue));
}
@@ -403,12 +401,12 @@ public abstract class ExternalTxManagerTests {
container.setTransactionManager(new DummyTxManager());
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -417,8 +415,8 @@ public abstract class ExternalTxManagerTests {
verify(mockConnection, times(1)).createChannel();
assertTrue(ackLatch.await(10, TimeUnit.SECONDS));
assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
assertThat(ackLatch.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(commitLatch.await(10, TimeUnit.SECONDS)).isTrue();
verify(channel).basicAck(anyLong(), anyBoolean());
container.stop();
}
@@ -493,11 +491,11 @@ public abstract class ExternalTxManagerTests {
container.setTransactionManager(new DummyTxManager());
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(), new byte[] {0});
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -506,7 +504,7 @@ public abstract class ExternalTxManagerTests {
verify(listenerConnection, Mockito.times(1)).createChannel();
verify(templateConnection, Mockito.times(1)).createChannel();
assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
assertThat(commitLatch.await(10, TimeUnit.SECONDS)).isTrue();
verify(listenerChannel).txCommit();
verify(templateChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
Mockito.any(BasicProperties.class), Mockito.any(byte[].class));
@@ -515,7 +513,7 @@ public abstract class ExternalTxManagerTests {
// verify close() was never called on the channel
DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory);
List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsTransactional");
assertEquals(0, channels.size());
assertThat(channels.size()).isEqualTo(0);
container.stop();
@@ -575,11 +573,11 @@ public abstract class ExternalTxManagerTests {
container.setTransactionManager(new DummyTxManager());
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(), new byte[] {0});
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -587,7 +585,7 @@ public abstract class ExternalTxManagerTests {
}
verify(mockConnection, Mockito.times(1)).createChannel();
assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
assertThat(commitLatch.await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel).txCommit();
verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
Mockito.any(BasicProperties.class), Mockito.any(byte[].class));
@@ -597,7 +595,7 @@ public abstract class ExternalTxManagerTests {
container.stop();
assertSame(onlyChannel, exposed.get());
assertThat(exposed.get()).isSameAs(onlyChannel);
}
/**
@@ -656,11 +654,11 @@ public abstract class ExternalTxManagerTests {
container.setTransactionManager(new DummyTxManager());
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(), new byte[] {0});
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -668,7 +666,7 @@ public abstract class ExternalTxManagerTests {
}
verify(mockConnection, Mockito.times(1)).createChannel();
assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
assertThat(commitLatch.await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel).txCommit();
verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
Mockito.any(BasicProperties.class), Mockito.any(byte[].class));
@@ -678,7 +676,7 @@ public abstract class ExternalTxManagerTests {
container.stop();
assertSame(onlyChannel, exposed.get());
assertThat(exposed.get()).isSameAs(onlyChannel);
}
/**
@@ -735,11 +733,11 @@ public abstract class ExternalTxManagerTests {
container.setTransactionManager(new RabbitTransactionManager(cachingConnectionFactory));
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(), new byte[] {0});
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -747,7 +745,7 @@ public abstract class ExternalTxManagerTests {
}
verify(mockConnection, Mockito.times(1)).createChannel();
assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
assertThat(commitLatch.await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel).txCommit();
verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
Mockito.any(BasicProperties.class), Mockito.any(byte[].class));
@@ -755,7 +753,7 @@ public abstract class ExternalTxManagerTests {
// verify close() was never called on the channel
DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory);
List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsTransactional");
assertEquals(0, channels.size());
assertThat(channels.size()).isEqualTo(0);
container.stop();
}

24
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/listener/JavaConfigFixedReplyQueueTests.java
View File

@@ -16,14 +16,12 @@
package org.springframework.amqp.rabbit.listener;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.util.Arrays;
import java.util.UUID;
import org.hamcrest.Matchers;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -90,12 +88,12 @@ public class JavaConfigFixedReplyQueueTests {
*/
@Test
public void testReplyContainer() {
assertEquals("FOO", this.fixedReplyQRabbitTemplate.convertSendAndReceive("foo"));
assertThat(this.fixedReplyQRabbitTemplate.convertSendAndReceive("foo")).isEqualTo("FOO");
Message message = MessageBuilder.withBody("foo".getBytes())
.setContentType("text/plain")
.build();
Message reply = this.fixedReplyQRabbitTemplate.sendAndReceive(message);
assertEquals(this.replyExchange.getName(), reply.getMessageProperties().getReceivedExchange());
assertThat(reply.getMessageProperties().getReceivedExchange()).isEqualTo(this.replyExchange.getName());
}
@Test
@@ -105,9 +103,8 @@ public class JavaConfigFixedReplyQueueTests {
fail("expected exeption");
}
catch (IllegalStateException e) {
assertThat(e.getMessage(),
Matchers.containsString("RabbitTemplate is not configured as MessageListener - "
+ "cannot use a 'replyAddress'"));
assertThat(e.getMessage()).contains("RabbitTemplate is not configured as MessageListener - "
+ "cannot use a 'replyAddress'");
}
}
@@ -119,11 +116,10 @@ public class JavaConfigFixedReplyQueueTests {
}
catch (UncategorizedAmqpException e) {
Throwable t = e.getCause();
assertThat(t, Matchers.instanceOf(IllegalStateException.class));
assertThat(t.getMessage(),
Matchers.containsString("Listener expects us to be listening on '["
+ TestUtils.getPropertyValue(this.fixedReplyQRabbitTemplateWrongQueue, "replyAddress")
+ "]'; our queues: " + Arrays.asList(this.replyListenerContainerWrongQueue.getQueueNames())));
assertThat(t).isInstanceOf(IllegalStateException.class);
assertThat(t.getMessage()).contains("Listener expects us to be listening on '["
+ TestUtils.getPropertyValue(this.fixedReplyQRabbitTemplateWrongQueue, "replyAddress")
+ "]'; our queues: " + Arrays.asList(this.replyListenerContainerWrongQueue.getQueueNames()));
}
}

52
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/listener/LocallyTransactedTests.java
View File

@@ -16,9 +16,7 @@
package org.springframework.amqp.rabbit.listener;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyLong;
@@ -135,12 +133,12 @@ public abstract class LocallyTransactedTests {
container.setShutdownTimeout(100);
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -148,14 +146,14 @@ public abstract class LocallyTransactedTests {
}
verify(mockConnection, times(1)).createChannel();
assertTrue(commitLatch.get().await(10, TimeUnit.SECONDS));
assertThat(commitLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel).txCommit();
verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
Mockito.any(BasicProperties.class), Mockito.any(byte[].class));
DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory);
List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsTransactional");
assertEquals(0, channels.size());
assertThat(channels.size()).isEqualTo(0);
container.setMessageListener(m -> {
throw new RuntimeException();
@@ -163,8 +161,8 @@ public abstract class LocallyTransactedTests {
commitLatch.set(new CountDownLatch(1));
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(commitLatch.get().await(10, TimeUnit.SECONDS));
assertTrue(rollbackLatch.get().await(10, TimeUnit.SECONDS));
assertThat(commitLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
assertThat(rollbackLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel).basicNack(anyLong(), anyBoolean(), anyBoolean());
verify(onlyChannel, times(1)).txRollback();
@@ -177,8 +175,8 @@ public abstract class LocallyTransactedTests {
rollbackLatch.set(new CountDownLatch(1));
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(rollbackLatch.get().await(10, TimeUnit.SECONDS));
assertTrue(commitLatch.get().await(10, TimeUnit.SECONDS));
assertThat(rollbackLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
assertThat(commitLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel, times(2)).basicNack(anyLong(), anyBoolean(), anyBoolean());
verify(onlyChannel, times(2)).txRollback();
@@ -189,7 +187,7 @@ public abstract class LocallyTransactedTests {
commitLatch.set(new CountDownLatch(1));
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(commitLatch.get().await(10, TimeUnit.SECONDS));
assertThat(commitLatch.get().await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel, times(2)).basicAck(anyLong(), anyBoolean());
verify(onlyChannel, times(4)).txCommit();
@@ -244,12 +242,12 @@ public abstract class LocallyTransactedTests {
container.setShutdownTimeout(100);
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -257,7 +255,7 @@ public abstract class LocallyTransactedTests {
}
verify(mockConnection, times(1)).createChannel();
assertTrue(rollbackLatch.await(10, TimeUnit.SECONDS));
assertThat(rollbackLatch.await(10, TimeUnit.SECONDS)).isTrue();
container.stop();
}
@@ -333,12 +331,12 @@ public abstract class LocallyTransactedTests {
container.setShutdownTimeout(100);
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -346,7 +344,7 @@ public abstract class LocallyTransactedTests {
}
verify(mockConnection, times(2)).createChannel();
assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
assertThat(commitLatch.await(10, TimeUnit.SECONDS)).isTrue();
verify(channel1).txCommit();
verify(channel1, never()).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
Mockito.any(BasicProperties.class), Mockito.any(byte[].class));
@@ -356,7 +354,7 @@ public abstract class LocallyTransactedTests {
// verify close() was never called on the channel
DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory);
List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsNonTransactional");
assertEquals(1, channels.size());
assertThat(channels.size()).isEqualTo(1);
container.stop();
@@ -429,12 +427,12 @@ public abstract class LocallyTransactedTests {
container.setShutdownTimeout(100);
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
new byte[] { 0 });
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -442,7 +440,7 @@ public abstract class LocallyTransactedTests {
}
verify(mockConnection, Mockito.times(1)).createChannel();
assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
assertThat(commitLatch.await(10, TimeUnit.SECONDS)).isTrue();
verify(onlyChannel).txCommit();
verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
Mockito.any(BasicProperties.class), Mockito.any(byte[].class));
@@ -452,7 +450,7 @@ public abstract class LocallyTransactedTests {
container.stop();
assertSame(onlyChannel, exposed.get());
assertThat(exposed.get()).isSameAs(onlyChannel);
}
/**
@@ -518,11 +516,11 @@ public abstract class LocallyTransactedTests {
container.setShutdownTimeout(100);
container.afterPropertiesSet();
container.start();
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(), new byte[] {0});
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Exception e = tooManyChannels.get();
if (e != null) {
@@ -531,13 +529,13 @@ public abstract class LocallyTransactedTests {
// once for listener, once for exposed + 0 for template (used bound)
verify(mockConnection, Mockito.times(2)).createChannel();
assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
assertThat(commitLatch.await(10, TimeUnit.SECONDS)).isTrue();
verify(firstChannel).txCommit();
verify(secondChannel).txCommit();
verify(secondChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
Mockito.any(BasicProperties.class), Mockito.any(byte[].class));
assertSame(secondChannel, exposed.get());
assertThat(exposed.get()).isSameAs(secondChannel);
verify(firstChannel, Mockito.never()).close();
verify(secondChannel, Mockito.times(1)).close();

64
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/listener/MessageListenerContainerLifecycleIntegrationTests.java
View File

@@ -16,11 +16,8 @@
package org.springframework.amqp.rabbit.listener;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
@@ -212,7 +209,7 @@ public class MessageListenerContainerLifecycleIntegrationTests {
fail("expected exception");
}
catch (AmqpIllegalStateException e) {
assertTrue("Expected FatalListenerStartupException", e.getCause() instanceof FatalListenerStartupException);
assertThat(e.getCause() instanceof FatalListenerStartupException).as("Expected FatalListenerStartupException").isTrue();
}
finally {
((DisposableBean) template.getConnectionFactory()).destroy();
@@ -262,16 +259,16 @@ public class MessageListenerContainerLifecycleIntegrationTests {
boolean waited = latch.await(50, TimeUnit.MILLISECONDS);
logger.info("All messages received before stop: " + waited);
if (messageCount > 1) {
assertFalse("Expected not to receive all messages before stop", waited);
assertThat(waited).as("Expected not to receive all messages before stop").isFalse();
}
assertEquals(concurrentConsumers, container.getActiveConsumerCount());
assertThat(container.getActiveConsumerCount()).isEqualTo(concurrentConsumers);
container.stop();
int n = 0;
while (n++ < 100 && container.getActiveConsumerCount() > 0) {
Thread.sleep(100);
}
assertEquals(0, container.getActiveConsumerCount());
assertThat(container.getActiveConsumerCount()).isEqualTo(0);
if (!transactional) {
int messagesReceivedAfterStop = listener.getCount();
@@ -281,13 +278,12 @@ public class MessageListenerContainerLifecycleIntegrationTests {
logger.info("All messages received after stop: " + waited + " (" + messagesReceivedAfterStop + ")");
if (prefetchNoTx) {
assertFalse("Didn't expect to receive all messages after stop", waited);
assertThat(waited).as("Didn't expect to receive all messages after stop").isFalse();
}
else {
assertTrue("Expect to receive all messages after stop", waited);
assertThat(waited).as("Expect to receive all messages after stop").isTrue();
}
assertEquals("Unexpected additional messages received after stop", messagesReceivedAfterStop,
listener.getCount());
assertThat(listener.getCount()).as("Unexpected additional messages received after stop").isEqualTo(messagesReceivedAfterStop);
for (int i = 0; i < messageCount; i++) {
template.convertAndSend(queue.getName(), i + "bar");
@@ -307,18 +303,18 @@ public class MessageListenerContainerLifecycleIntegrationTests {
logger.debug("Waiting for messages with timeout = " + timeout + " (s)");
waited = latch.await(timeout, TimeUnit.SECONDS);
logger.info("All messages received after start: " + waited);
assertEquals(concurrentConsumers, container.getActiveConsumerCount());
assertThat(container.getActiveConsumerCount()).isEqualTo(concurrentConsumers);
if (transactional) {
assertTrue("Timed out waiting for message", waited);
assertThat(waited).as("Timed out waiting for message").isTrue();
}
else {
int count = listener.getCount();
assertTrue("Expected additional messages received after start: " + messagesReceivedBeforeStart + ">="
+ count, messagesReceivedBeforeStart < count);
assertNull("Messages still available", template.receive(queue.getName()));
assertThat(messagesReceivedBeforeStart < count).as("Expected additional messages received after start: " + messagesReceivedBeforeStart + ">="
+ count).isTrue();
assertThat(template.receive(queue.getName())).as("Messages still available").isNull();
}
assertEquals(concurrentConsumers, container.getActiveConsumerCount());
assertThat(container.getActiveConsumerCount()).isEqualTo(concurrentConsumers);
}
finally {
@@ -329,8 +325,8 @@ public class MessageListenerContainerLifecycleIntegrationTests {
while (n++ < 100 && container.getActiveConsumerCount() > 0) {
Thread.sleep(100);
}
assertEquals(0, container.getActiveConsumerCount());
assertNull(template.receiveAndConvert(queue.getName()));
assertThat(container.getActiveConsumerCount()).isEqualTo(0);
assertThat(template.receiveAndConvert(queue.getName())).isNull();
((DisposableBean) template.getConnectionFactory()).destroy();
}
@@ -381,7 +377,7 @@ public class MessageListenerContainerLifecycleIntegrationTests {
container.start();
// wait until the listener has the first message...
assertTrue(awaitStart1.await(10, TimeUnit.SECONDS));
assertThat(awaitStart1.await(10, TimeUnit.SECONDS)).isTrue();
// ... and the remaining 4 are queued...
@SuppressWarnings("unchecked")
Set<BlockingQueueConsumer> consumers = (Set<BlockingQueueConsumer>) TestUtils
@@ -402,26 +398,24 @@ public class MessageListenerContainerLifecycleIntegrationTests {
while (container.isActive() && n++ < 100) {
Thread.sleep(100);
}
assertTrue(n < 100);
assertThat(n < 100).isTrue();
awaitStop.countDown();
assertTrue("awaitConsumeFirst.count=" + awaitConsumeFirst.getCount(),
awaitConsumeFirst.await(10, TimeUnit.SECONDS));
assertThat(awaitConsumeFirst.await(10, TimeUnit.SECONDS)).as("awaitConsumeFirst.count=" + awaitConsumeFirst.getCount()).isTrue();
n = 0;
DirectFieldAccessor dfa = new DirectFieldAccessor(container);
while (dfa.getPropertyValue("consumers") != null && n++ < 100) {
Thread.sleep(100);
}
assertTrue(n < 100);
assertThat(n < 100).isTrue();
// make sure we stopped receiving after the prefetch was consumed
assertEquals(5, received.get());
assertEquals(1, awaitStart2.getCount());
assertThat(received.get()).isEqualTo(5);
assertThat(awaitStart2.getCount()).isEqualTo(1);
container.start();
assertTrue(awaitStart2.await(10, TimeUnit.SECONDS));
assertTrue("awaitConsumeSecond.count=" + awaitConsumeSecond.getCount(),
awaitConsumeSecond.await(10, TimeUnit.SECONDS));
assertThat(awaitStart2.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(awaitConsumeSecond.await(10, TimeUnit.SECONDS)).as("awaitConsumeSecond.count=" + awaitConsumeSecond.getCount()).isTrue();
container.stop();
((DisposableBean) template.getConnectionFactory()).destroy();
}
@@ -452,7 +446,7 @@ public class MessageListenerContainerLifecycleIntegrationTests {
try {
connectionFactory.destroy();
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
Mockito.verify(log).debug(
Mockito.contains("Consumer received Shutdown Signal, processing stopped"));
Mockito.verify(log, Mockito.never()).warn(Mockito.anyString(), Mockito.any(Throwable.class));
@@ -475,19 +469,19 @@ public class MessageListenerContainerLifecycleIntegrationTests {
CountDownLatch consumerLatch = applicationContext.getBean("consumerLatch", CountDownLatch.class);
SimpleMessageListenerContainer container = applicationContext.getBean(SimpleMessageListenerContainer.class);
assertTrue(consumerLatch.await(10, TimeUnit.SECONDS));
assertThat(consumerLatch.await(10, TimeUnit.SECONDS)).isTrue();
applicationContext.close();
@SuppressWarnings("rawtypes")
ActiveObjectCounter counter = TestUtils.getPropertyValue(container, "cancellationLock", ActiveObjectCounter.class);
assertTrue(counter.getCount() > 0);
assertThat(counter.getCount() > 0).isTrue();
int n = 0;
while (counter.getCount() > 0 && n++ < 10) {
Thread.sleep(500);
}
assertTrue(n < 10);
assertThat(n < 10).isTrue();
((DisposableBean) template.getConnectionFactory()).destroy();
}

7
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/listener/MessageListenerRecoveryRepeatIntegrationTests.java
View File

@@ -16,8 +16,7 @@
package org.springframework.amqp.rabbit.listener;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
@@ -138,9 +137,9 @@ public class MessageListenerRecoveryRepeatIntegrationTests {
int timeout = Math.min(4 + messageCount / (4 * concurrentConsumers), 30);
logger.debug("Waiting for messages with timeout = " + timeout + " (s)");
boolean waited = latch.await(timeout, TimeUnit.SECONDS);
assertTrue("Timed out waiting for message", waited);
assertThat(waited).as("Timed out waiting for message").isTrue();
assertNull(template.receiveAndConvert(queue.getName()));
assertThat(template.receiveAndConvert(queue.getName())).isNull();
}

16
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/listener/SimpleMessageListenerContainerLongTests.java
View File

@@ -16,10 +16,8 @@
package org.springframework.amqp.rabbit.listener;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.util.Set;
@@ -92,7 +90,7 @@ public class SimpleMessageListenerContainerLongTests {
container.setConcurrentConsumers(2);
container.setChannelTransacted(transacted);
container.afterPropertiesSet();
assertEquals(2, ReflectionTestUtils.getField(container, "concurrentConsumers"));
assertThat(ReflectionTestUtils.getField(container, "concurrentConsumers")).isEqualTo(2);
container.start();
waitForNConsumers(container, 2);
container.setConcurrentConsumers(1);
@@ -137,7 +135,7 @@ public class SimpleMessageListenerContainerLongTests {
while (n++ < 100 && container.getActiveConsumerCount() != 2) {
Thread.sleep(100);
}
assertEquals(2, container.getActiveConsumerCount());
assertThat(container.getActiveConsumerCount()).isEqualTo(2);
container.stop();
for (int i = 0; i < 20; i++) {
admin.deleteQueue("testAddQueuesAndStartInCycle" + i);
@@ -170,7 +168,7 @@ public class SimpleMessageListenerContainerLongTests {
waitForNConsumers(container, 5);
container.setConcurrentConsumers(4);
Set<?> consumers = (Set<?>) TestUtils.getPropertyValue(container, "consumers");
assertThat(consumers.size(), equalTo(5));
assertThat(consumers.size()).isEqualTo(5);
}
@Test
@@ -198,7 +196,7 @@ public class SimpleMessageListenerContainerLongTests {
waitForNConsumers(container, 3);
container.setConcurrentConsumers(1);
Set<?> consumers = (Set<?>) TestUtils.getPropertyValue(container, "consumers");
assertThat(consumers.size(), equalTo(3));
assertThat(consumers.size()).isEqualTo(3);
}
@Test
@@ -227,7 +225,7 @@ public class SimpleMessageListenerContainerLongTests {
container.setConcurrentConsumers(1);
container.setMaxConcurrentConsumers(1);
Set<?> consumers = (Set<?>) TestUtils.getPropertyValue(container, "consumers");
assertThat(consumers.size(), equalTo(1));
assertThat(consumers.size()).isEqualTo(1);
}
public void handleMessage(String foo) {

2
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/listener/StopStartIntegrationTests.java
View File

@@ -16,7 +16,7 @@
package org.springframework.amqp.rabbit.listener;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.fail;
import java.util.concurrent.atomic.AtomicInteger;

15
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/remoting/RemotingTests.java
View File

@@ -16,11 +16,8 @@
package org.springframework.amqp.rabbit.remoting;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
@@ -73,15 +70,15 @@ public class RemotingTests {
@Test
public void testEcho() {
String reply = client.echo("foo");
assertEquals("echo:foo", reply);
assertThat(reply).isEqualTo("echo:foo");
}
@Test
public void testNoAnswer() throws Exception {
latch = new CountDownLatch(1);
client.noAnswer("foo");
assertTrue(latch.await(5, TimeUnit.SECONDS));
assertEquals("received:foo", receivedMessage);
assertThat(latch.await(5, TimeUnit.SECONDS)).isTrue();
assertThat(receivedMessage).isEqualTo("received:foo");
}
@Test
@@ -91,7 +88,7 @@ public class RemotingTests {
fail("Exception expected");
}
catch (RemoteProxyFailureException e) {
assertThat(e.getMessage(), containsString(" - perhaps a timeout in the template?"));
assertThat(e.getMessage()).contains(" - perhaps a timeout in the template?");
}
}

15
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/retry/MissingIdRetryTests.java
View File

@@ -16,8 +16,7 @@
package org.springframework.amqp.rabbit.retry;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.atMost;
@@ -117,7 +116,7 @@ public class MissingIdRetryTests {
template.convertAndSend("retry.test.exchange", "retry.test.binding", "Hello, world!");
template.convertAndSend("retry.test.exchange", "retry.test.binding", "Hello, world!");
try {
assertTrue(latch.await(30, TimeUnit.SECONDS));
assertThat(latch.await(30, TimeUnit.SECONDS)).isTrue();
Map map = (Map) new DirectFieldAccessor(cache).getPropertyValue("map");
int n = 0;
while (n++ < 100 && map.size() != 0) {
@@ -125,7 +124,7 @@ public class MissingIdRetryTests {
}
verify(cache, never()).put(any(), any(RetryContext.class));
verify(cache, never()).remove(any());
assertEquals("Expected map.size() = 0, was: " + map.size(), 0, map.size());
assertThat(map.size()).as("Expected map.size() = 0, was: " + map.size()).isEqualTo(0);
}
finally {
container.stop();
@@ -166,7 +165,7 @@ public class MissingIdRetryTests {
template.send("retry.test.exchange", "retry.test.binding", message);
template.send("retry.test.exchange", "retry.test.binding", message);
try {
assertTrue(latch.await(30, TimeUnit.SECONDS));
assertThat(latch.await(30, TimeUnit.SECONDS)).isTrue();
Map map = (Map) new DirectFieldAccessor(cache).getPropertyValue("map");
int n = 0;
while (n++ < 100 && map.size() != 0) {
@@ -182,7 +181,7 @@ public class MissingIdRetryTests {
logger.debug("puts:" + putCaptor.getAllValues());
logger.debug("gets:" + putCaptor.getAllValues());
logger.debug("removes:" + removeCaptor.getAllValues());
assertEquals("Expected map.size() = 0, was: " + map.size(), 0, map.size());
assertThat(map.size()).as("Expected map.size() = 0, was: " + map.size()).isEqualTo(0);
}
finally {
container.stop();
@@ -231,7 +230,7 @@ public class MissingIdRetryTests {
messageProperties.setMessageId("bar");
template.send("retry.test.exchange", "retry.test.binding", message);
try {
assertTrue(latch.await(30, TimeUnit.SECONDS));
assertThat(latch.await(30, TimeUnit.SECONDS)).isTrue();
Map map = (Map) new DirectFieldAccessor(cache).getPropertyValue("map");
int n = 0;
while (n++ < 100 && map.size() != 0) {
@@ -247,7 +246,7 @@ public class MissingIdRetryTests {
logger.debug("puts:" + putCaptor.getAllValues());
logger.debug("gets:" + putCaptor.getAllValues());
logger.debug("removes:" + removeCaptor.getAllValues());
assertEquals("Expected map.size() = 0, was: " + map.size(), 0, map.size());
assertThat(map.size()).as("Expected map.size() = 0, was: " + map.size()).isEqualTo(0);
}
finally {
container.stop();

14
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/retry/RepublishMessageRecovererTest.java
View File

@@ -16,7 +16,7 @@
package org.springframework.amqp.rabbit.retry;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
import java.io.ByteArrayOutputStream;
@@ -92,7 +92,7 @@ public class RepublishMessageRecovererTest {
recoverer.recover(message, cause);
assertEquals(expectedHeaderValue, message.getMessageProperties().getHeaders().get("x-exception-stacktrace"));
assertThat(message.getMessageProperties().getHeaders().get("x-exception-stacktrace")).isEqualTo(expectedHeaderValue);
}
@Test
@@ -100,8 +100,7 @@ public class RepublishMessageRecovererTest {
recoverer = new RepublishMessageRecoverer(amqpTemplate);
recoverer.recover(message, cause);
assertEquals(cause.getCause().getMessage(),
message.getMessageProperties().getHeaders().get("x-exception-message"));
assertThat(message.getMessageProperties().getHeaders().get("x-exception-message")).isEqualTo(cause.getCause().getMessage());
}
@Test
@@ -111,8 +110,7 @@ public class RepublishMessageRecovererTest {
recoverer.recover(message, cause);
assertEquals("the.original.exchange",
message.getMessageProperties().getHeaders().get("x-original-exchange"));
assertThat(message.getMessageProperties().getHeaders().get("x-original-exchange")).isEqualTo("the.original.exchange");
}
@Test
@@ -130,7 +128,7 @@ public class RepublishMessageRecovererTest {
recoverer.recover(message, cause);
assertEquals(MessageDeliveryMode.PERSISTENT, message.getMessageProperties().getDeliveryMode());
assertThat(message.getMessageProperties().getDeliveryMode()).isEqualTo(MessageDeliveryMode.PERSISTENT);
}
@Test
@@ -141,7 +139,7 @@ public class RepublishMessageRecovererTest {
this.recoverer.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT);
recoverer.recover(this.message, this.cause);
assertEquals(MessageDeliveryMode.NON_PERSISTENT, this.message.getMessageProperties().getDeliveryMode());
assertThat(this.message.getMessageProperties().getDeliveryMode()).isEqualTo(MessageDeliveryMode.NON_PERSISTENT);
}
}

13
spring-rabbit/src/test/java/org/springframework/amqp/rabbit/test/RepeatProcessor.java
View File

@@ -16,7 +16,8 @@
package org.springframework.amqp.rabbit.test;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.util.ArrayList;
import java.util.List;
@@ -29,9 +30,7 @@ import java.util.concurrent.Future;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hamcrest.CoreMatchers;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.internal.runners.statements.RunAfters;
import org.junit.internal.runners.statements.RunBefores;
@@ -69,6 +68,7 @@ public class RepeatProcessor implements MethodRule {
this.concurrency = concurrency < 0 ? 0 : concurrency;
}
@Override
public Statement apply(final Statement base, FrameworkMethod method, final Object target) {
Repeat repeat = AnnotationUtils.findAnnotation(method.getMethod(), Repeat.class);
@@ -113,6 +113,7 @@ public class RepeatProcessor implements MethodRule {
for (int i = 0; i < repeats; i++) {
final int count = i;
results.add(completionService.submit(new Callable<Boolean>() {
@Override
public Boolean call() {
try {
base.evaluate();
@@ -126,7 +127,7 @@ public class RepeatProcessor implements MethodRule {
}
for (int i = 0; i < repeats; i++) {
Future<Boolean> future = completionService.take();
assertTrue("Null result from completer", future.get());
assertThat(future.get()).as("Null result from completer").isTrue();
}
}
finally {
@@ -151,7 +152,7 @@ public class RepeatProcessor implements MethodRule {
}, afters, target).evaluate();
}
catch (Throwable e) {
Assert.assertThat(e, CoreMatchers.not(CoreMatchers.anything()));
fail("Unexpected throwable " + e);
}
}
}
@@ -173,7 +174,7 @@ public class RepeatProcessor implements MethodRule {
}, befores, target).evaluate();
}
catch (Throwable e) {
Assert.assertThat(e, CoreMatchers.not(CoreMatchers.anything()));
fail("Unexpected throwable " + e);
}
initialized = true;
}