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

Migrate JUnit 4 assertions to AssertJ

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

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

59
spring-messaging/src/test/java/org/springframework/messaging/MessageHeadersTests.java
View File

@@ -27,13 +27,8 @@ import org.junit.Test;
import org.springframework.util.SerializationTestUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.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;
/**
* Test fixture for {@link MessageHeaders}.
@@ -47,7 +42,7 @@ public class MessageHeadersTests {
@Test
public void testTimestamp() {
MessageHeaders headers = new MessageHeaders(null);
assertNotNull(headers.getTimestamp());
assertThat(headers.getTimestamp()).isNotNull();
}
@Test
@@ -55,59 +50,59 @@ public class MessageHeadersTests {
MessageHeaders headers1 = new MessageHeaders(null);
Thread.sleep(50L);
MessageHeaders headers2 = new MessageHeaders(headers1);
assertNotSame(headers1.getTimestamp(), headers2.getTimestamp());
assertThat(headers2.getTimestamp()).isNotSameAs(headers1.getTimestamp());
}
@Test
public void testTimestampProvided() throws Exception {
MessageHeaders headers = new MessageHeaders(null, null, 10L);
assertEquals(10L, (long) headers.getTimestamp());
assertThat(headers.getTimestamp()).isEqualTo(10L);
}
@Test
public void testTimestampProvidedNullValue() throws Exception {
Map<String, Object> input = Collections.<String, Object>singletonMap(MessageHeaders.TIMESTAMP, 1L);
MessageHeaders headers = new MessageHeaders(input, null, null);
assertNotNull(headers.getTimestamp());
assertThat(headers.getTimestamp()).isNotNull();
}
@Test
public void testTimestampNone() throws Exception {
MessageHeaders headers = new MessageHeaders(null, null, -1L);
assertNull(headers.getTimestamp());
assertThat(headers.getTimestamp()).isNull();
}
@Test
public void testIdOverwritten() throws Exception {
MessageHeaders headers1 = new MessageHeaders(null);
MessageHeaders headers2 = new MessageHeaders(headers1);
assertNotSame(headers1.getId(), headers2.getId());
assertThat(headers2.getId()).isNotSameAs(headers1.getId());
}
@Test
public void testId() {
MessageHeaders headers = new MessageHeaders(null);
assertNotNull(headers.getId());
assertThat(headers.getId()).isNotNull();
}
@Test
public void testIdProvided() {
UUID id = new UUID(0L, 25L);
MessageHeaders headers = new MessageHeaders(null, id, null);
assertEquals(id, headers.getId());
assertThat(headers.getId()).isEqualTo(id);
}
@Test
public void testIdProvidedNullValue() {
Map<String, Object> input = Collections.<String, Object>singletonMap(MessageHeaders.ID, new UUID(0L, 25L));
MessageHeaders headers = new MessageHeaders(input, null, null);
assertNotNull(headers.getId());
assertThat(headers.getId()).isNotNull();
}
@Test
public void testIdNone() {
MessageHeaders headers = new MessageHeaders(null, MessageHeaders.ID_VALUE_NONE, null);
assertNull(headers.getId());
assertThat(headers.getId()).isNull();
}
@Test
@@ -116,7 +111,7 @@ public class MessageHeadersTests {
Map<String, Object> map = new HashMap<>();
map.put("test", value);
MessageHeaders headers = new MessageHeaders(map);
assertEquals(value, headers.get("test"));
assertThat(headers.get("test")).isEqualTo(value);
}
@Test
@@ -125,7 +120,7 @@ public class MessageHeadersTests {
Map<String, Object> map = new HashMap<>();
map.put("test", value);
MessageHeaders headers = new MessageHeaders(map);
assertEquals(value, headers.get("test", Integer.class));
assertThat(headers.get("test", Integer.class)).isEqualTo(value);
}
@Test
@@ -142,14 +137,14 @@ public class MessageHeadersTests {
public void testNullHeaderValue() {
Map<String, Object> map = new HashMap<>();
MessageHeaders headers = new MessageHeaders(map);
assertNull(headers.get("nosuchattribute"));
assertThat(headers.get("nosuchattribute")).isNull();
}
@Test
public void testNullHeaderValueWithTypedAccess() {
Map<String, Object> map = new HashMap<>();
MessageHeaders headers = new MessageHeaders(map);
assertNull(headers.get("nosuchattribute", String.class));
assertThat(headers.get("nosuchattribute", String.class)).isNull();
}
@Test
@@ -159,8 +154,8 @@ public class MessageHeadersTests {
map.put("key2", new Integer(123));
MessageHeaders headers = new MessageHeaders(map);
Set<String> keys = headers.keySet();
assertTrue(keys.contains("key1"));
assertTrue(keys.contains("key2"));
assertThat(keys.contains("key1")).isTrue();
assertThat(keys.contains("key2")).isTrue();
}
@Test
@@ -170,10 +165,10 @@ public class MessageHeadersTests {
map.put("age", 42);
MessageHeaders input = new MessageHeaders(map);
MessageHeaders output = (MessageHeaders) SerializationTestUtils.serializeAndDeserialize(input);
assertEquals("joe", output.get("name"));
assertEquals(42, output.get("age"));
assertEquals("joe", input.get("name"));
assertEquals(42, input.get("age"));
assertThat(output.get("name")).isEqualTo("joe");
assertThat(output.get("age")).isEqualTo(42);
assertThat(input.get("name")).isEqualTo("joe");
assertThat(input.get("age")).isEqualTo(42);
}
@Test
@@ -184,10 +179,10 @@ public class MessageHeadersTests {
map.put("address", address);
MessageHeaders input = new MessageHeaders(map);
MessageHeaders output = (MessageHeaders) SerializationTestUtils.serializeAndDeserialize(input);
assertEquals("joe", output.get("name"));
assertNull(output.get("address"));
assertEquals("joe", input.get("name"));
assertSame(address, input.get("address"));
assertThat(output.get("name")).isEqualTo("joe");
assertThat(output.get("address")).isNull();
assertThat(input.get("name")).isEqualTo("joe");
assertThat(input.get("address")).isSameAs(address);
}
@Test
@@ -200,8 +195,8 @@ public class MessageHeadersTests {
}
}
MessageHeaders headers = new MyMH();
assertEquals("00000000-0000-0000-0000-000000000001", headers.getId().toString());
assertEquals(1, headers.size());
assertThat(headers.getId().toString()).isEqualTo("00000000-0000-0000-0000-000000000001");
assertThat(headers.size()).isEqualTo(1);
}
}

11
spring-messaging/src/test/java/org/springframework/messaging/converter/DefaultContentTypeResolverTests.java
View File

@@ -27,10 +27,9 @@ import org.springframework.messaging.MessageHeaders;
import org.springframework.util.InvalidMimeTypeException;
import org.springframework.util.MimeTypeUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
/**
* Test fixture for {@link org.springframework.messaging.converter.DefaultContentTypeResolver}.
@@ -53,7 +52,7 @@ public class DefaultContentTypeResolverTests {
map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON);
MessageHeaders headers = new MessageHeaders(map);
assertEquals(MimeTypeUtils.APPLICATION_JSON, this.resolver.resolve(headers));
assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON);
}
@Test
@@ -62,7 +61,7 @@ public class DefaultContentTypeResolverTests {
map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON_VALUE);
MessageHeaders headers = new MessageHeaders(map);
assertEquals(MimeTypeUtils.APPLICATION_JSON, this.resolver.resolve(headers));
assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON);
}
@Test
@@ -87,7 +86,7 @@ public class DefaultContentTypeResolverTests {
public void resolveNoContentTypeHeader() {
MessageHeaders headers = new MessageHeaders(Collections.<String, Object>emptyMap());
assertNull(this.resolver.resolve(headers));
assertThat(this.resolver.resolve(headers)).isNull();
}
@Test
@@ -95,7 +94,7 @@ public class DefaultContentTypeResolverTests {
this.resolver.setDefaultMimeType(MimeTypeUtils.APPLICATION_JSON);
MessageHeaders headers = new MessageHeaders(Collections.<String, Object>emptyMap());
assertEquals(MimeTypeUtils.APPLICATION_JSON, this.resolver.resolve(headers));
assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON);
}
}

7
spring-messaging/src/test/java/org/springframework/messaging/converter/GenericMessageConverterTests.java
View File

@@ -26,9 +26,8 @@ import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
/**
*
@@ -42,13 +41,13 @@ public class GenericMessageConverterTests {
@Test
public void fromMessageWithConversion() {
Message<String> content = MessageBuilder.withPayload("33").build();
assertEquals(33, converter.fromMessage(content, Integer.class));
assertThat(converter.fromMessage(content, Integer.class)).isEqualTo(33);
}
@Test
public void fromMessageNoConverter() {
Message<Integer> content = MessageBuilder.withPayload(1234).build();
assertNull("No converter from integer to locale", converter.fromMessage(content, Locale.class));
assertThat(converter.fromMessage(content, Locale.class)).as("No converter from integer to locale").isNull();
}
@Test

85
spring-messaging/src/test/java/org/springframework/messaging/converter/MappingJackson2MessageConverterTests.java
View File

@@ -35,13 +35,7 @@ import org.springframework.util.MimeType;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.within;
/**
* Test fixture for {@link MappingJackson2MessageConverter}.
@@ -56,8 +50,8 @@ public class MappingJackson2MessageConverterTests {
MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
assertThat(converter.getSupportedMimeTypes())
.contains(new MimeType("application", "json"));
assertFalse(converter.getObjectMapper().getDeserializationConfig()
.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
assertThat(converter.getObjectMapper().getDeserializationConfig()
.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)).isFalse();
}
@Test // SPR-12724
@@ -65,8 +59,8 @@ public class MappingJackson2MessageConverterTests {
MimeType mimetype = new MimeType("application", "xml", StandardCharsets.UTF_8);
MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter(mimetype);
assertThat(converter.getSupportedMimeTypes()).contains(mimetype);
assertFalse(converter.getObjectMapper().getDeserializationConfig()
.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
assertThat(converter.getObjectMapper().getDeserializationConfig()
.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)).isFalse();
}
@Test // SPR-12724
@@ -75,8 +69,8 @@ public class MappingJackson2MessageConverterTests {
MimeType xmlMimetype = new MimeType("application", "xml", StandardCharsets.UTF_8);
MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter(jsonMimetype, xmlMimetype);
assertThat(converter.getSupportedMimeTypes()).contains(jsonMimetype, xmlMimetype);
assertFalse(converter.getObjectMapper().getDeserializationConfig()
.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
assertThat(converter.getObjectMapper().getDeserializationConfig()
.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)).isFalse();
}
@Test
@@ -92,12 +86,12 @@ public class MappingJackson2MessageConverterTests {
Message<?> message = MessageBuilder.withPayload(payload.getBytes(StandardCharsets.UTF_8)).build();
MyBean actual = (MyBean) converter.fromMessage(message, MyBean.class);
assertEquals("Foo", actual.getString());
assertEquals(42, actual.getNumber());
assertEquals(42F, actual.getFraction(), 0F);
assertArrayEquals(new String[]{"Foo", "Bar"}, actual.getArray());
assertTrue(actual.isBool());
assertArrayEquals(new byte[]{0x1, 0x2}, actual.getBytes());
assertThat(actual.getString()).isEqualTo("Foo");
assertThat(actual.getNumber()).isEqualTo(42);
assertThat(actual.getFraction()).isCloseTo(42F, within(0F));
assertThat(actual.getArray()).isEqualTo(new String[]{"Foo", "Bar"});
assertThat(actual.isBool()).isTrue();
assertThat(actual.getBytes()).isEqualTo(new byte[]{0x1, 0x2});
}
@Test
@@ -109,12 +103,12 @@ public class MappingJackson2MessageConverterTests {
@SuppressWarnings("unchecked")
HashMap<String, Object> actual = (HashMap<String, Object>) converter.fromMessage(message, HashMap.class);
assertEquals("Foo", actual.get("string"));
assertEquals(42, actual.get("number"));
assertEquals(42D, (Double) actual.get("fraction"), 0D);
assertEquals(Arrays.asList("Foo", "Bar"), actual.get("array"));
assertEquals(Boolean.TRUE, actual.get("bool"));
assertEquals("AQI=", actual.get("bytes"));
assertThat(actual.get("string")).isEqualTo("Foo");
assertThat(actual.get("number")).isEqualTo(42);
assertThat((Double) actual.get("fraction")).isCloseTo(42D, within(0D));
assertThat(actual.get("array")).isEqualTo(Arrays.asList("Foo", "Bar"));
assertThat(actual.get("bool")).isEqualTo(Boolean.TRUE);
assertThat(actual.get("bytes")).isEqualTo("AQI=");
}
@Test // gh-22386
@@ -122,7 +116,7 @@ public class MappingJackson2MessageConverterTests {
MyBean myBean = new MyBean();
MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
Message<?> message = MessageBuilder.withPayload(myBean).build();
assertSame(myBean, converter.fromMessage(message, MyBean.class));
assertThat(converter.fromMessage(message, MyBean.class)).isSameAs(myBean);
}
@Test
@@ -140,7 +134,7 @@ public class MappingJackson2MessageConverterTests {
String payload = "{\"string\":\"string\",\"unknownProperty\":\"value\"}";
Message<?> message = MessageBuilder.withPayload(payload.getBytes(StandardCharsets.UTF_8)).build();
MyBean myBean = (MyBean)converter.fromMessage(message, MyBean.class);
assertEquals("string", myBean.getString());
assertThat(myBean.getString()).isEqualTo("string");
}
@Test // SPR-16252
@@ -153,8 +147,8 @@ public class MappingJackson2MessageConverterTests {
MethodParameter param = new MethodParameter(method, 0);
Object actual = converter.fromMessage(message, List.class, param);
assertNotNull(actual);
assertEquals(Arrays.asList(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L), actual);
assertThat(actual).isNotNull();
assertThat(actual).isEqualTo(Arrays.asList(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L));
}
@Test // SPR-16486
@@ -167,8 +161,8 @@ public class MappingJackson2MessageConverterTests {
MethodParameter param = new MethodParameter(method, 0);
Object actual = converter.fromMessage(message, MyBean.class, param);
assertTrue(actual instanceof MyBean);
assertEquals("foo", ((MyBean) actual).getString());
assertThat(actual instanceof MyBean).isTrue();
assertThat(((MyBean) actual).getString()).isEqualTo("foo");
}
@Test
@@ -185,14 +179,13 @@ public class MappingJackson2MessageConverterTests {
Message<?> message = converter.toMessage(payload, null);
String actual = new String((byte[]) message.getPayload(), StandardCharsets.UTF_8);
assertTrue(actual.contains("\"string\":\"Foo\""));
assertTrue(actual.contains("\"number\":42"));
assertTrue(actual.contains("fraction\":42.0"));
assertTrue(actual.contains("\"array\":[\"Foo\",\"Bar\"]"));
assertTrue(actual.contains("\"bool\":true"));
assertTrue(actual.contains("\"bytes\":\"AQI=\""));
assertEquals("Invalid content-type", new MimeType("application", "json"),
message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class));
assertThat(actual.contains("\"string\":\"Foo\"")).isTrue();
assertThat(actual.contains("\"number\":42")).isTrue();
assertThat(actual.contains("fraction\":42.0")).isTrue();
assertThat(actual.contains("\"array\":[\"Foo\",\"Bar\"]")).isTrue();
assertThat(actual.contains("\"bool\":true")).isTrue();
assertThat(actual.contains("\"bytes\":\"AQI=\"")).isTrue();
assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class)).as("Invalid content-type").isEqualTo(new MimeType("application", "json"));
}
@Test
@@ -205,8 +198,8 @@ public class MappingJackson2MessageConverterTests {
String payload = "H\u00e9llo W\u00f6rld";
Message<?> message = converter.toMessage(payload, headers);
assertEquals("\"" + payload + "\"", new String((byte[]) message.getPayload(), StandardCharsets.UTF_16BE));
assertEquals(contentType, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
assertThat(new String((byte[]) message.getPayload(), StandardCharsets.UTF_16BE)).isEqualTo(("\"" + payload + "\""));
assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(contentType);
}
@Test
@@ -221,8 +214,8 @@ public class MappingJackson2MessageConverterTests {
String payload = "H\u00e9llo W\u00f6rld";
Message<?> message = converter.toMessage(payload, headers);
assertEquals("\"" + payload + "\"", message.getPayload());
assertEquals(contentType, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
assertThat(message.getPayload()).isEqualTo(("\"" + payload + "\""));
assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(contentType);
}
@Test
@@ -242,9 +235,9 @@ public class MappingJackson2MessageConverterTests {
method = getClass().getDeclaredMethod("jsonViewPayload", JacksonViewBean.class);
MethodParameter param = new MethodParameter(method, 0);
JacksonViewBean back = (JacksonViewBean) converter.fromMessage(message, JacksonViewBean.class, param);
assertNull(back.getWithView1());
assertEquals("with", back.getWithView2());
assertNull(back.getWithoutView());
assertThat(back.getWithView1()).isNull();
assertThat(back.getWithView2()).isEqualTo("with");
assertThat(back.getWithoutView()).isNull();
}

8
spring-messaging/src/test/java/org/springframework/messaging/converter/MarshallingMessageConverterTests.java
View File

@@ -31,8 +31,6 @@ import org.springframework.tests.XmlContent;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.xmlunit.diff.ComparisonType.XML_STANDALONE;
import static org.xmlunit.diff.DifferenceEvaluators.Default;
import static org.xmlunit.diff.DifferenceEvaluators.chain;
@@ -62,8 +60,8 @@ public class MarshallingMessageConverterTests {
Message<?> message = MessageBuilder.withPayload(payload.getBytes(StandardCharsets.UTF_8)).build();
MyBean actual = (MyBean) this.converter.fromMessage(message, MyBean.class);
assertNotNull(actual);
assertEquals("Foo", actual.getName());
assertThat(actual).isNotNull();
assertThat(actual.getName()).isEqualTo("Foo");
}
@Test
@@ -88,7 +86,7 @@ public class MarshallingMessageConverterTests {
payload.setName("Foo");
Message<?> message = this.converter.toMessage(payload, null);
assertNotNull(message);
assertThat(message).isNotNull();
String actual = new String((byte[]) message.getPayload(), StandardCharsets.UTF_8);
DifferenceEvaluator ev = chain(Default, downgradeDifferencesToEqual(XML_STANDALONE));

41
spring-messaging/src/test/java/org/springframework/messaging/converter/MessageConverterTests.java
View File

@@ -33,13 +33,8 @@ import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.MimeType;
import org.springframework.util.MimeTypeUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Unit tests for
@@ -56,8 +51,8 @@ public class MessageConverterTests {
public void supportsTargetClass() {
Message<String> message = MessageBuilder.withPayload("ABC").build();
assertEquals("success-from", this.converter.fromMessage(message, String.class));
assertNull(this.converter.fromMessage(message, Integer.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo("success-from");
assertThat(this.converter.fromMessage(message, Integer.class)).isNull();
}
@Test
@@ -65,7 +60,7 @@ public class MessageConverterTests {
Message<String> message = MessageBuilder.withPayload(
"ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
assertEquals("success-from", this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo("success-from");
}
@Test
@@ -73,13 +68,13 @@ public class MessageConverterTests {
Message<String> message = MessageBuilder.withPayload(
"ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON).build();
assertNull(this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isNull();
}
@Test
public void supportsMimeTypeNotSpecified() {
Message<String> message = MessageBuilder.withPayload("ABC").build();
assertEquals("success-from", this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo("success-from");
}
@Test
@@ -88,7 +83,7 @@ public class MessageConverterTests {
"ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON).build();
this.converter = new TestMessageConverter(Collections.<MimeType>emptyList());
assertEquals("success-from", this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo("success-from");
}
@Test
@@ -97,11 +92,11 @@ public class MessageConverterTests {
this.converter.setStrictContentTypeMatch(true);
Message<String> message = MessageBuilder.withPayload("ABC").build();
assertFalse(this.converter.canConvertFrom(message, String.class));
assertThat(this.converter.canConvertFrom(message, String.class)).isFalse();
message = MessageBuilder.withPayload("ABC")
.setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
assertTrue(this.converter.canConvertFrom(message, String.class));
assertThat(this.converter.canConvertFrom(message, String.class)).isTrue();
}
@@ -119,10 +114,10 @@ public class MessageConverterTests {
MessageHeaders headers = new MessageHeaders(map);
Message<?> message = this.converter.toMessage("ABC", headers);
assertNotNull(message.getHeaders().getId());
assertNotNull(message.getHeaders().getTimestamp());
assertEquals(MimeTypeUtils.TEXT_PLAIN, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
assertEquals("bar", message.getHeaders().get("foo"));
assertThat(message.getHeaders().getId()).isNotNull();
assertThat(message.getHeaders().getTimestamp()).isNotNull();
assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeTypeUtils.TEXT_PLAIN);
assertThat(message.getHeaders().get("foo")).isEqualTo("bar");
}
@Test
@@ -135,16 +130,16 @@ public class MessageConverterTests {
MessageHeaders headers = accessor.getMessageHeaders();
Message<?> message = this.converter.toMessage("ABC", headers);
assertSame(headers, message.getHeaders());
assertNull(message.getHeaders().getId());
assertNull(message.getHeaders().getTimestamp());
assertEquals(MimeTypeUtils.TEXT_PLAIN, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
assertThat(message.getHeaders()).isSameAs(headers);
assertThat(message.getHeaders().getId()).isNull();
assertThat(message.getHeaders().getTimestamp()).isNull();
assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeTypeUtils.TEXT_PLAIN);
}
@Test
public void toMessageContentTypeHeader() {
Message<?> message = this.converter.toMessage("ABC", null);
assertEquals(MimeTypeUtils.TEXT_PLAIN, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeTypeUtils.TEXT_PLAIN);
}

13
spring-messaging/src/test/java/org/springframework/messaging/converter/SimpleMessageConverterTests.java
View File

@@ -24,8 +24,7 @@ import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.MessageHeaderAccessor;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for
@@ -43,8 +42,8 @@ public class SimpleMessageConverterTests {
MessageHeaders headers = new MessageHeaders(Collections.<String, Object>singletonMap("foo", "bar"));
Message<?> message = this.converter.toMessage("payload", headers);
assertEquals("payload", message.getPayload());
assertEquals("bar", message.getHeaders().get("foo"));
assertThat(message.getPayload()).isEqualTo("payload");
assertThat(message.getHeaders().get("foo")).isEqualTo("bar");
}
@Test
@@ -56,8 +55,8 @@ public class SimpleMessageConverterTests {
Message<?> message = this.converter.toMessage("payload", headers);
assertEquals("payload", message.getPayload());
assertSame(headers, message.getHeaders());
assertEquals("bar", message.getHeaders().get("foo"));
assertThat(message.getPayload()).isEqualTo("payload");
assertThat(message.getHeaders()).isSameAs(headers);
assertThat(message.getHeaders().get("foo")).isEqualTo("bar");
}
}

19
spring-messaging/src/test/java/org/springframework/messaging/converter/StringMessageConverterTests.java
View File

@@ -28,8 +28,7 @@ import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.MimeType;
import org.springframework.util.MimeTypeUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Test fixture for {@link org.springframework.messaging.converter.StringMessageConverter}.
@@ -45,20 +44,20 @@ public class StringMessageConverterTests {
public void fromByteArrayMessage() {
Message<byte[]> message = MessageBuilder.withPayload(
"ABC".getBytes()).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
assertEquals("ABC", this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo("ABC");
}
@Test
public void fromStringMessage() {
Message<String> message = MessageBuilder.withPayload(
"ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
assertEquals("ABC", this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo("ABC");
}
@Test
public void fromMessageNoContentTypeHeader() {
Message<byte[]> message = MessageBuilder.withPayload("ABC".getBytes()).build();
assertEquals("ABC", this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo("ABC");
}
@Test
@@ -66,27 +65,27 @@ public class StringMessageConverterTests {
String payload = "H\u00e9llo W\u00f6rld";
Message<byte[]> message = MessageBuilder.withPayload(payload.getBytes(StandardCharsets.ISO_8859_1))
.setHeader(MessageHeaders.CONTENT_TYPE, new MimeType("text", "plain", StandardCharsets.ISO_8859_1)).build();
assertEquals(payload, this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo(payload);
}
@Test
public void fromMessageDefaultCharset() {
String payload = "H\u00e9llo W\u00f6rld";
Message<byte[]> message = MessageBuilder.withPayload(payload.getBytes(StandardCharsets.UTF_8)).build();
assertEquals(payload, this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo(payload);
}
@Test
public void fromMessageTargetClassNotSupported() {
Message<byte[]> message = MessageBuilder.withPayload("ABC".getBytes()).build();
assertNull(this.converter.fromMessage(message, Integer.class));
assertThat(this.converter.fromMessage(message, Integer.class)).isNull();
}
@Test
public void fromMessageByteArray() {
Message<byte[]> message = MessageBuilder.withPayload(
"ABC".getBytes()).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
assertEquals("ABC", this.converter.fromMessage(message, String.class));
assertThat(this.converter.fromMessage(message, String.class)).isEqualTo("ABC");
}
@Test
@@ -96,7 +95,7 @@ public class StringMessageConverterTests {
MessageHeaders headers = new MessageHeaders(map);
Message<?> message = this.converter.toMessage("ABC", headers);
assertEquals("ABC", new String(((byte[]) message.getPayload())));
assertThat(new String(((byte[]) message.getPayload()))).isEqualTo("ABC");
}
}

10
spring-messaging/src/test/java/org/springframework/messaging/core/CachingDestinationResolverTests.java
View File

@@ -18,8 +18,8 @@ package org.springframework.messaging.core;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -42,10 +42,10 @@ public class CachingDestinationResolverTests {
given(resolver.resolveDestination("abcd")).willReturn("dcba");
given(resolver.resolveDestination("1234")).willReturn("4321");
assertEquals("dcba", resolverProxy.resolveDestination("abcd"));
assertEquals("4321", resolverProxy.resolveDestination("1234"));
assertEquals("4321", resolverProxy.resolveDestination("1234"));
assertEquals("dcba", resolverProxy.resolveDestination("abcd"));
assertThat(resolverProxy.resolveDestination("abcd")).isEqualTo("dcba");
assertThat(resolverProxy.resolveDestination("1234")).isEqualTo("4321");
assertThat(resolverProxy.resolveDestination("1234")).isEqualTo("4321");
assertThat(resolverProxy.resolveDestination("abcd")).isEqualTo("dcba");
verify(resolver, times(1)).resolveDestination("abcd");
verify(resolver, times(1)).resolveDestination("1234");

90
spring-messaging/src/test/java/org/springframework/messaging/core/DestinationResolvingMessagingTemplateTests.java
View File

@@ -28,10 +28,8 @@ import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.support.ExecutorSubscribableChannel;
import org.springframework.messaging.support.GenericMessage;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
/**
* Unit tests for {@link AbstractDestinationResolvingMessagingTemplate}.
@@ -71,8 +69,8 @@ public class DestinationResolvingMessagingTemplateTests {
Message<?> message = new GenericMessage<Object>("payload");
this.template.send("myChannel", message);
assertSame(this.myChannel, this.template.messageChannel);
assertSame(message, this.template.message);
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
assertThat(this.template.message).isSameAs(message);
}
@Test
@@ -86,44 +84,44 @@ public class DestinationResolvingMessagingTemplateTests {
public void convertAndSendPayload() {
this.template.convertAndSend("myChannel", "payload");
assertSame(this.myChannel, this.template.messageChannel);
assertNotNull(this.template.message);
assertSame("payload", this.template.message.getPayload());
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getPayload()).isSameAs("payload");
}
@Test
public void convertAndSendPayloadAndHeaders() {
this.template.convertAndSend("myChannel", "payload", this.headers);
assertSame(this.myChannel, this.template.messageChannel);
assertNotNull(this.template.message);
assertEquals("value", this.template.message.getHeaders().get("key"));
assertEquals("payload", this.template.message.getPayload());
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getHeaders().get("key")).isEqualTo("value");
assertThat(this.template.message.getPayload()).isEqualTo("payload");
}
@Test
public void convertAndSendPayloadWithPostProcessor() {
this.template.convertAndSend("myChannel", "payload", this.postProcessor);
assertSame(this.myChannel, this.template.messageChannel);
assertNotNull(this.template.message);
assertEquals("payload", this.template.message.getPayload());
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getPayload()).isEqualTo("payload");
assertNotNull(this.postProcessor.getMessage());
assertSame(this.postProcessor.getMessage(), this.template.message);
assertThat(this.postProcessor.getMessage()).isNotNull();
assertThat(this.template.message).isSameAs(this.postProcessor.getMessage());
}
@Test
public void convertAndSendPayloadAndHeadersWithPostProcessor() {
this.template.convertAndSend("myChannel", "payload", this.headers, this.postProcessor);
assertSame(this.myChannel, this.template.messageChannel);
assertNotNull(this.template.message);
assertEquals("value", this.template.message.getHeaders().get("key"));
assertEquals("payload", this.template.message.getPayload());
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getHeaders().get("key")).isEqualTo("value");
assertThat(this.template.message.getPayload()).isEqualTo("payload");
assertNotNull(this.postProcessor.getMessage());
assertSame(this.postProcessor.getMessage(), this.template.message);
assertThat(this.postProcessor.getMessage()).isNotNull();
assertThat(this.template.message).isSameAs(this.postProcessor.getMessage());
}
@Test
@@ -132,8 +130,8 @@ public class DestinationResolvingMessagingTemplateTests {
this.template.setReceiveMessage(expected);
Message<?> actual = this.template.receive("myChannel");
assertSame(expected, actual);
assertSame(this.myChannel, this.template.messageChannel);
assertThat(actual).isSameAs(expected);
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
}
@Test
@@ -142,8 +140,8 @@ public class DestinationResolvingMessagingTemplateTests {
this.template.setReceiveMessage(expected);
String payload = this.template.receiveAndConvert("myChannel", String.class);
assertEquals("payload", payload);
assertSame(this.myChannel, this.template.messageChannel);
assertThat(payload).isEqualTo("payload");
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
}
@Test
@@ -153,9 +151,9 @@ public class DestinationResolvingMessagingTemplateTests {
this.template.setReceiveMessage(responseMessage);
Message<?> actual = this.template.sendAndReceive("myChannel", requestMessage);
assertEquals(requestMessage, this.template.message);
assertSame(responseMessage, actual);
assertSame(this.myChannel, this.template.messageChannel);
assertThat(this.template.message).isEqualTo(requestMessage);
assertThat(actual).isSameAs(responseMessage);
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
}
@Test
@@ -164,9 +162,9 @@ public class DestinationResolvingMessagingTemplateTests {
this.template.setReceiveMessage(responseMessage);
String actual = this.template.convertSendAndReceive("myChannel", "request", String.class);
assertEquals("request", this.template.message.getPayload());
assertSame("response", actual);
assertSame(this.myChannel, this.template.messageChannel);
assertThat(this.template.message.getPayload()).isEqualTo("request");
assertThat(actual).isSameAs("response");
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
}
@Test
@@ -175,10 +173,10 @@ public class DestinationResolvingMessagingTemplateTests {
this.template.setReceiveMessage(responseMessage);
String actual = this.template.convertSendAndReceive("myChannel", "request", this.headers, String.class);
assertEquals("value", this.template.message.getHeaders().get("key"));
assertEquals("request", this.template.message.getPayload());
assertSame("response", actual);
assertSame(this.myChannel, this.template.messageChannel);
assertThat(this.template.message.getHeaders().get("key")).isEqualTo("value");
assertThat(this.template.message.getPayload()).isEqualTo("request");
assertThat(actual).isSameAs("response");
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
}
@Test
@@ -187,10 +185,10 @@ public class DestinationResolvingMessagingTemplateTests {
this.template.setReceiveMessage(responseMessage);
String actual = this.template.convertSendAndReceive("myChannel", "request", String.class, this.postProcessor);
assertEquals("request", this.template.message.getPayload());
assertSame("request", this.postProcessor.getMessage().getPayload());
assertSame("response", actual);
assertSame(this.myChannel, this.template.messageChannel);
assertThat(this.template.message.getPayload()).isEqualTo("request");
assertThat(this.postProcessor.getMessage().getPayload()).isSameAs("request");
assertThat(actual).isSameAs("response");
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
}
@Test
@@ -200,11 +198,11 @@ public class DestinationResolvingMessagingTemplateTests {
String actual = this.template.convertSendAndReceive("myChannel", "request", this.headers,
String.class, this.postProcessor);
assertEquals("value", this.template.message.getHeaders().get("key"));
assertEquals("request", this.template.message.getPayload());
assertSame("request", this.postProcessor.getMessage().getPayload());
assertSame("response", actual);
assertSame(this.myChannel, this.template.messageChannel);
assertThat(this.template.message.getHeaders().get("key")).isEqualTo("value");
assertThat(this.template.message.getPayload()).isEqualTo("request");
assertThat(this.postProcessor.getMessage().getPayload()).isSameAs("request");
assertThat(actual).isSameAs("response");
assertThat(this.template.messageChannel).isSameAs(this.myChannel);
}

37
spring-messaging/src/test/java/org/springframework/messaging/core/GenericMessagingTemplateTests.java
View File

@@ -38,12 +38,7 @@ import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
@@ -90,9 +85,9 @@ public class GenericMessagingTemplateTests {
.build();
this.template.send(channel, message);
verify(channel).send(any(Message.class), eq(30_000L));
assertNotNull(sent.get());
assertFalse(sent.get().getHeaders().containsKey(GenericMessagingTemplate.DEFAULT_SEND_TIMEOUT_HEADER));
assertFalse(sent.get().getHeaders().containsKey(GenericMessagingTemplate.DEFAULT_RECEIVE_TIMEOUT_HEADER));
assertThat(sent.get()).isNotNull();
assertThat(sent.get().getHeaders().containsKey(GenericMessagingTemplate.DEFAULT_SEND_TIMEOUT_HEADER)).isFalse();
assertThat(sent.get().getHeaders().containsKey(GenericMessagingTemplate.DEFAULT_RECEIVE_TIMEOUT_HEADER)).isFalse();
}
@Test
@@ -109,9 +104,9 @@ public class GenericMessagingTemplateTests {
accessor.setHeader(GenericMessagingTemplate.DEFAULT_SEND_TIMEOUT_HEADER, 30_000L);
this.template.send(channel, message);
verify(channel).send(any(Message.class), eq(30_000L));
assertNotNull(sent.get());
assertFalse(sent.get().getHeaders().containsKey(GenericMessagingTemplate.DEFAULT_SEND_TIMEOUT_HEADER));
assertFalse(sent.get().getHeaders().containsKey(GenericMessagingTemplate.DEFAULT_RECEIVE_TIMEOUT_HEADER));
assertThat(sent.get()).isNotNull();
assertThat(sent.get().getHeaders().containsKey(GenericMessagingTemplate.DEFAULT_SEND_TIMEOUT_HEADER)).isFalse();
assertThat(sent.get().getHeaders().containsKey(GenericMessagingTemplate.DEFAULT_RECEIVE_TIMEOUT_HEADER)).isFalse();
}
@Test
@@ -126,7 +121,7 @@ public class GenericMessagingTemplateTests {
});
String actual = this.template.convertSendAndReceive(channel, "request", String.class);
assertEquals("response", actual);
assertThat(actual).isEqualTo("response");
}
@Test
@@ -145,8 +140,8 @@ public class GenericMessagingTemplateTests {
return true;
}).given(channel).send(any(Message.class), anyLong());
assertNull(this.template.convertSendAndReceive(channel, "request", String.class));
assertTrue(latch.await(10_000, TimeUnit.MILLISECONDS));
assertThat(this.template.convertSendAndReceive(channel, "request", String.class)).isNull();
assertThat(latch.await(10_000, TimeUnit.MILLISECONDS)).isTrue();
Throwable ex = failure.get();
if (ex != null) {
@@ -175,8 +170,8 @@ public class GenericMessagingTemplateTests {
.setHeader(GenericMessagingTemplate.DEFAULT_SEND_TIMEOUT_HEADER, 30_000L)
.setHeader(GenericMessagingTemplate.DEFAULT_RECEIVE_TIMEOUT_HEADER, 1L)
.build();
assertNull(this.template.sendAndReceive(channel, message));
assertTrue(latch.await(10_000, TimeUnit.MILLISECONDS));
assertThat(this.template.sendAndReceive(channel, message)).isNull();
assertThat(latch.await(10_000, TimeUnit.MILLISECONDS)).isTrue();
Throwable ex = failure.get();
if (ex != null) {
@@ -207,8 +202,8 @@ public class GenericMessagingTemplateTests {
.setHeader("sto", 30_000L)
.setHeader("rto", 1L)
.build();
assertNull(this.template.sendAndReceive(channel, message));
assertTrue(latch.await(10_000, TimeUnit.MILLISECONDS));
assertThat(this.template.sendAndReceive(channel, message)).isNull();
assertThat(latch.await(10_000, TimeUnit.MILLISECONDS)).isTrue();
Throwable ex = failure.get();
if (ex != null) {
@@ -254,8 +249,8 @@ public class GenericMessagingTemplateTests {
List<Message<byte[]>> messages = this.messageChannel.getMessages();
Message<byte[]> message = messages.get(0);
assertSame(headers, message.getHeaders());
assertFalse(accessor.isMutable());
assertThat(message.getHeaders()).isSameAs(headers);
assertThat(accessor.isMutable()).isFalse();
}

24
spring-messaging/src/test/java/org/springframework/messaging/core/MessageReceivingTemplateTests.java
View File

@@ -27,11 +27,9 @@ import org.springframework.messaging.converter.GenericMessageConverter;
import org.springframework.messaging.converter.MessageConversionException;
import org.springframework.messaging.support.GenericMessage;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Unit tests for receiving operations in {@link AbstractMessagingTemplate}.
@@ -56,8 +54,8 @@ public class MessageReceivingTemplateTests {
this.template.setReceiveMessage(expected);
Message<?> actual = this.template.receive();
assertEquals("home", this.template.destination);
assertSame(expected, actual);
assertThat(this.template.destination).isEqualTo("home");
assertThat(actual).isSameAs(expected);
}
@Test
@@ -72,8 +70,8 @@ public class MessageReceivingTemplateTests {
this.template.setReceiveMessage(expected);
Message<?> actual = this.template.receive("somewhere");
assertEquals("somewhere", this.template.destination);
assertSame(expected, actual);
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(actual).isSameAs(expected);
}
@Test
@@ -83,8 +81,8 @@ public class MessageReceivingTemplateTests {
this.template.setReceiveMessage(expected);
String payload = this.template.receiveAndConvert(String.class);
assertEquals("home", this.template.destination);
assertSame("payload", payload);
assertThat(this.template.destination).isEqualTo("home");
assertThat(payload).isSameAs("payload");
}
@Test
@@ -93,8 +91,8 @@ public class MessageReceivingTemplateTests {
this.template.setReceiveMessage(expected);
String payload = this.template.receiveAndConvert("somewhere", String.class);
assertEquals("somewhere", this.template.destination);
assertSame("payload", payload);
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(payload).isSameAs("payload");
}
@Test
@@ -118,8 +116,8 @@ public class MessageReceivingTemplateTests {
this.template.receiveAndConvert(Writer.class);
}
catch (MessageConversionException ex) {
assertTrue("Invalid exception message '" + ex.getMessage() + "'", ex.getMessage().contains("payload"));
assertSame(expected, ex.getFailedMessage());
assertThat(ex.getMessage().contains("payload")).as("Invalid exception message '" + ex.getMessage() + "'").isTrue();
assertThat(ex.getFailedMessage()).isSameAs(expected);
}
}

61
spring-messaging/src/test/java/org/springframework/messaging/core/MessageRequestReplyTemplateTests.java
View File

@@ -25,9 +25,8 @@ import org.junit.Test;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.GenericMessage;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
/**
* Unit tests for request and reply operations in {@link AbstractMessagingTemplate}.
@@ -61,9 +60,9 @@ public class MessageRequestReplyTemplateTests {
this.template.setReceiveMessage(responseMessage);
Message<?> actual = this.template.sendAndReceive(requestMessage);
assertEquals("home", this.template.destination);
assertSame(requestMessage, this.template.requestMessage);
assertSame(responseMessage, actual);
assertThat(this.template.destination).isEqualTo("home");
assertThat(this.template.requestMessage).isSameAs(requestMessage);
assertThat(actual).isSameAs(responseMessage);
}
@Test
@@ -79,9 +78,9 @@ public class MessageRequestReplyTemplateTests {
this.template.setReceiveMessage(responseMessage);
Message<?> actual = this.template.sendAndReceive("somewhere", requestMessage);
assertEquals("somewhere", this.template.destination);
assertSame(requestMessage, this.template.requestMessage);
assertSame(responseMessage, actual);
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.requestMessage).isSameAs(requestMessage);
assertThat(actual).isSameAs(responseMessage);
}
@Test
@@ -91,9 +90,9 @@ public class MessageRequestReplyTemplateTests {
this.template.setReceiveMessage(responseMessage);
String response = this.template.convertSendAndReceive("request", String.class);
assertEquals("home", this.template.destination);
assertSame("request", this.template.requestMessage.getPayload());
assertSame("response", response);
assertThat(this.template.destination).isEqualTo("home");
assertThat(this.template.requestMessage.getPayload()).isSameAs("request");
assertThat(response).isSameAs("response");
}
@Test
@@ -102,9 +101,9 @@ public class MessageRequestReplyTemplateTests {
this.template.setReceiveMessage(responseMessage);
String response = this.template.convertSendAndReceive("somewhere", "request", String.class);
assertEquals("somewhere", this.template.destination);
assertSame("request", this.template.requestMessage.getPayload());
assertSame("response", response);
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.requestMessage.getPayload()).isSameAs("request");
assertThat(response).isSameAs("response");
}
@Test
@@ -113,10 +112,10 @@ public class MessageRequestReplyTemplateTests {
this.template.setReceiveMessage(responseMessage);
String response = this.template.convertSendAndReceive("somewhere", "request", this.headers, String.class);
assertEquals("somewhere", this.template.destination);
assertEquals("value", this.template.requestMessage.getHeaders().get("key"));
assertSame("request", this.template.requestMessage.getPayload());
assertSame("response", response);
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.requestMessage.getHeaders().get("key")).isEqualTo("value");
assertThat(this.template.requestMessage.getPayload()).isSameAs("request");
assertThat(response).isSameAs("response");
}
@Test
@@ -126,10 +125,10 @@ public class MessageRequestReplyTemplateTests {
this.template.setReceiveMessage(responseMessage);
String response = this.template.convertSendAndReceive("request", String.class, this.postProcessor);
assertEquals("home", this.template.destination);
assertSame("request", this.template.requestMessage.getPayload());
assertSame("response", response);
assertSame(this.postProcessor.getMessage(), this.template.requestMessage);
assertThat(this.template.destination).isEqualTo("home");
assertThat(this.template.requestMessage.getPayload()).isSameAs("request");
assertThat(response).isSameAs("response");
assertThat(this.template.requestMessage).isSameAs(this.postProcessor.getMessage());
}
@Test
@@ -138,10 +137,10 @@ public class MessageRequestReplyTemplateTests {
this.template.setReceiveMessage(responseMessage);
String response = this.template.convertSendAndReceive("somewhere", "request", String.class, this.postProcessor);
assertEquals("somewhere", this.template.destination);
assertSame("request", this.template.requestMessage.getPayload());
assertSame("response", response);
assertSame(this.postProcessor.getMessage(), this.template.requestMessage);
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.requestMessage.getPayload()).isSameAs("request");
assertThat(response).isSameAs("response");
assertThat(this.template.requestMessage).isSameAs(this.postProcessor.getMessage());
}
@Test
@@ -151,11 +150,11 @@ public class MessageRequestReplyTemplateTests {
String response = this.template.convertSendAndReceive("somewhere", "request", this.headers,
String.class, this.postProcessor);
assertEquals("somewhere", this.template.destination);
assertEquals("value", this.template.requestMessage.getHeaders().get("key"));
assertSame("request", this.template.requestMessage.getPayload());
assertSame("response", response);
assertSame(this.postProcessor.getMessage(), this.template.requestMessage);
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.requestMessage.getHeaders().get("key")).isEqualTo("value");
assertThat(this.template.requestMessage.getPayload()).isSameAs("request");
assertThat(response).isSameAs("response");
assertThat(this.template.requestMessage).isSameAs(this.postProcessor.getMessage());
}

78
spring-messaging/src/test/java/org/springframework/messaging/core/MessageSendingTemplateTests.java
View File

@@ -36,11 +36,9 @@ import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.util.MimeType;
import org.springframework.util.MimeTypeUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
/**
* Unit tests for {@link AbstractMessageSendingTemplate}.
@@ -70,8 +68,8 @@ public class MessageSendingTemplateTests {
this.template.setDefaultDestination("home");
this.template.send(message);
assertEquals("home", this.template.destination);
assertSame(message, this.template.message);
assertThat(this.template.destination).isEqualTo("home");
assertThat(this.template.message).isSameAs(message);
}
@Test
@@ -79,8 +77,8 @@ public class MessageSendingTemplateTests {
Message<?> message = new GenericMessage<Object>("payload");
this.template.send("somewhere", message);
assertEquals("somewhere", this.template.destination);
assertSame(message, this.template.message);
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.message).isSameAs(message);
}
@Test
@@ -94,13 +92,13 @@ public class MessageSendingTemplateTests {
public void convertAndSend() {
this.template.convertAndSend("somewhere", "payload", headers, this.postProcessor);
assertEquals("somewhere", this.template.destination);
assertNotNull(this.template.message);
assertEquals("value", this.template.message.getHeaders().get("key"));
assertEquals("payload", this.template.message.getPayload());
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getHeaders().get("key")).isEqualTo("value");
assertThat(this.template.message.getPayload()).isEqualTo("payload");
assertNotNull(this.postProcessor.getMessage());
assertSame(this.template.message, this.postProcessor.getMessage());
assertThat(this.postProcessor.getMessage()).isNotNull();
assertThat(this.postProcessor.getMessage()).isSameAs(this.template.message);
}
@Test
@@ -108,30 +106,30 @@ public class MessageSendingTemplateTests {
this.template.setDefaultDestination("home");
this.template.convertAndSend("payload");
assertEquals("home", this.template.destination);
assertNotNull(this.template.message);
assertEquals("expected 'id' and 'timestamp' headers only", 2, this.template.message.getHeaders().size());
assertEquals("payload", this.template.message.getPayload());
assertThat(this.template.destination).isEqualTo("home");
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getHeaders().size()).as("expected 'id' and 'timestamp' headers only").isEqualTo(2);
assertThat(this.template.message.getPayload()).isEqualTo("payload");
}
@Test
public void convertAndSendPayloadToDestination() {
this.template.convertAndSend("somewhere", "payload");
assertEquals("somewhere", this.template.destination);
assertNotNull(this.template.message);
assertEquals("expected 'id' and 'timestamp' headers only", 2, this.template.message.getHeaders().size());
assertEquals("payload", this.template.message.getPayload());
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getHeaders().size()).as("expected 'id' and 'timestamp' headers only").isEqualTo(2);
assertThat(this.template.message.getPayload()).isEqualTo("payload");
}
@Test
public void convertAndSendPayloadAndHeadersToDestination() {
this.template.convertAndSend("somewhere", "payload", headers);
assertEquals("somewhere", this.template.destination);
assertNotNull(this.template.message);
assertEquals("value", this.template.message.getHeaders().get("key"));
assertEquals("payload", this.template.message.getPayload());
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getHeaders().get("key")).isEqualTo("value");
assertThat(this.template.message.getPayload()).isEqualTo("payload");
}
@Test
@@ -145,9 +143,9 @@ public class MessageSendingTemplateTests {
this.template.convertAndSend("somewhere", "payload", messageHeaders);
MessageHeaders actual = this.template.message.getHeaders();
assertSame(messageHeaders, actual);
assertEquals(new MimeType("text", "plain", StandardCharsets.UTF_8), actual.get(MessageHeaders.CONTENT_TYPE));
assertEquals("bar", actual.get("foo"));
assertThat(actual).isSameAs(messageHeaders);
assertThat(actual.get(MessageHeaders.CONTENT_TYPE)).isEqualTo(new MimeType("text", "plain", StandardCharsets.UTF_8));
assertThat(actual.get("foo")).isEqualTo("bar");
}
@Test
@@ -155,26 +153,26 @@ public class MessageSendingTemplateTests {
this.template.setDefaultDestination("home");
this.template.convertAndSend((Object) "payload", this.postProcessor);
assertEquals("home", this.template.destination);
assertNotNull(this.template.message);
assertEquals("expected 'id' and 'timestamp' headers only", 2, this.template.message.getHeaders().size());
assertEquals("payload", this.template.message.getPayload());
assertThat(this.template.destination).isEqualTo("home");
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getHeaders().size()).as("expected 'id' and 'timestamp' headers only").isEqualTo(2);
assertThat(this.template.message.getPayload()).isEqualTo("payload");
assertNotNull(this.postProcessor.getMessage());
assertSame(this.template.message, this.postProcessor.getMessage());
assertThat(this.postProcessor.getMessage()).isNotNull();
assertThat(this.postProcessor.getMessage()).isSameAs(this.template.message);
}
@Test
public void convertAndSendPayloadWithPostProcessorToDestination() {
this.template.convertAndSend("somewhere", "payload", this.postProcessor);
assertEquals("somewhere", this.template.destination);
assertNotNull(this.template.message);
assertEquals("expected 'id' and 'timestamp' headers only", 2, this.template.message.getHeaders().size());
assertEquals("payload", this.template.message.getPayload());
assertThat(this.template.destination).isEqualTo("somewhere");
assertThat(this.template.message).isNotNull();
assertThat(this.template.message.getHeaders().size()).as("expected 'id' and 'timestamp' headers only").isEqualTo(2);
assertThat(this.template.message.getPayload()).isEqualTo("payload");
assertNotNull(this.postProcessor.getMessage());
assertSame(this.template.message, this.postProcessor.getMessage());
assertThat(this.postProcessor.getMessage()).isNotNull();
assertThat(this.postProcessor.getMessage()).isSameAs(this.template.message);
}
@Test

32
spring-messaging/src/test/java/org/springframework/messaging/handler/DestinationPatternsMessageConditionTests.java
View File

@@ -22,8 +22,7 @@ import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.AntPathMatcher;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link DestinationPatternsMessageCondition}.
@@ -35,7 +34,7 @@ public class DestinationPatternsMessageConditionTests {
@Test
public void prependSlash() {
DestinationPatternsMessageCondition c = condition("foo");
assertEquals("/foo", c.getPatterns().iterator().next());
assertThat(c.getPatterns().iterator().next()).isEqualTo("/foo");
}
@Test
@@ -43,8 +42,7 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition c =
new DestinationPatternsMessageCondition(new String[] {"foo"}, new AntPathMatcher("."));
assertEquals("Pre-pending should be disabled when not using '/' as path separator",
"foo", c.getPatterns().iterator().next());
assertThat(c.getPatterns().iterator().next()).as("Pre-pending should be disabled when not using '/' as path separator").isEqualTo("foo");
}
// SPR-8255
@@ -52,7 +50,7 @@ public class DestinationPatternsMessageConditionTests {
@Test
public void prependNonEmptyPatternsOnly() {
DestinationPatternsMessageCondition c = condition("");
assertEquals("", c.getPatterns().iterator().next());
assertThat(c.getPatterns().iterator().next()).isEqualTo("");
}
@Test
@@ -60,7 +58,7 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition c1 = condition();
DestinationPatternsMessageCondition c2 = condition();
assertEquals(condition(""), c1.combine(c2));
assertThat(c1.combine(c2)).isEqualTo(condition(""));
}
@Test
@@ -68,12 +66,12 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition c1 = condition("/type1", "/type2");
DestinationPatternsMessageCondition c2 = condition();
assertEquals(condition("/type1", "/type2"), c1.combine(c2));
assertThat(c1.combine(c2)).isEqualTo(condition("/type1", "/type2"));
c1 = condition();
c2 = condition("/method1", "/method2");
assertEquals(condition("/method1", "/method2"), c1.combine(c2));
assertThat(c1.combine(c2)).isEqualTo(condition("/method1", "/method2"));
}
@Test
@@ -81,8 +79,8 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition c1 = condition("/t1", "/t2");
DestinationPatternsMessageCondition c2 = condition("/m1", "/m2");
assertEquals(new DestinationPatternsMessageCondition(
"/t1/m1", "/t1/m2", "/t2/m1", "/t2/m2"), c1.combine(c2));
assertThat(c1.combine(c2)).isEqualTo(new DestinationPatternsMessageCondition(
"/t1/m1", "/t1/m2", "/t2/m1", "/t2/m2"));
}
@Test
@@ -90,7 +88,7 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition condition = condition("/foo");
DestinationPatternsMessageCondition match = condition.getMatchingCondition(messageTo("/foo"));
assertNotNull(match);
assertThat(match).isNotNull();
}
@Test
@@ -98,7 +96,7 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition condition = condition("/foo/*");
DestinationPatternsMessageCondition match = condition.getMatchingCondition(messageTo("/foo/bar"));
assertNotNull(match);
assertThat(match).isNotNull();
}
@Test
@@ -107,7 +105,7 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition match = condition.getMatchingCondition(messageTo("/foo/bar"));
DestinationPatternsMessageCondition expected = condition("/foo/bar", "/foo/*", "/**");
assertEquals(expected, match);
assertThat(match).isEqualTo(expected);
}
@Test
@@ -115,7 +113,7 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition c1 = condition("/foo*");
DestinationPatternsMessageCondition c2 = condition("/foo*");
assertEquals(0, c1.compareTo(c2, messageTo("/foo")));
assertThat(c1.compareTo(c2, messageTo("/foo"))).isEqualTo(0);
}
@Test
@@ -123,7 +121,7 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition c1 = condition("/fo*");
DestinationPatternsMessageCondition c2 = condition("/foo");
assertEquals(1, c1.compareTo(c2, messageTo("/foo")));
assertThat(c1.compareTo(c2, messageTo("/foo"))).isEqualTo(1);
}
@Test
@@ -136,7 +134,7 @@ public class DestinationPatternsMessageConditionTests {
DestinationPatternsMessageCondition match1 = c1.getMatchingCondition(message);
DestinationPatternsMessageCondition match2 = c2.getMatchingCondition(message);
assertEquals(1, match1.compareTo(match2, message));
assertThat(match1.compareTo(match2, message)).isEqualTo(1);
}

12
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/reactive/DestinationVariableMethodArgumentResolverTests.java
View File

@@ -30,10 +30,8 @@ import org.springframework.messaging.handler.annotation.DestinationVariable;
import org.springframework.messaging.handler.invocation.ResolvableMethod;
import org.springframework.messaging.support.MessageBuilder;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.messaging.handler.annotation.MessagingPredicates.destinationVar;
/**
@@ -51,8 +49,8 @@ public class DestinationVariableMethodArgumentResolverTests {
@Test
public void supportsParameter() {
assertTrue(resolver.supportsParameter(this.resolvable.annot(destinationVar().noValue()).arg()));
assertFalse(resolver.supportsParameter(this.resolvable.annotNotPresent(DestinationVariable.class).arg()));
assertThat(resolver.supportsParameter(this.resolvable.annot(destinationVar().noValue()).arg())).isTrue();
assertThat(resolver.supportsParameter(this.resolvable.annotNotPresent(DestinationVariable.class).arg())).isFalse();
}
@Test
@@ -66,10 +64,10 @@ public class DestinationVariableMethodArgumentResolverTests {
DestinationVariableMethodArgumentResolver.DESTINATION_TEMPLATE_VARIABLES_HEADER, vars).build();
Object result = resolveArgument(this.resolvable.annot(destinationVar().noValue()).arg(), message);
assertEquals("bar", result);
assertThat(result).isEqualTo("bar");
result = resolveArgument(this.resolvable.annot(destinationVar("name")).arg(), message);
assertEquals("value", result);
assertThat(result).isEqualTo("value");
}
@Test

30
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/reactive/HeaderMethodArgumentResolverTests.java
View File

@@ -34,10 +34,8 @@ import org.springframework.messaging.handler.invocation.ResolvableMethod;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.NativeMessageHeaderAccessor;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.messaging.handler.annotation.MessagingPredicates.header;
import static org.springframework.messaging.handler.annotation.MessagingPredicates.headerPlain;
@@ -62,15 +60,15 @@ public class HeaderMethodArgumentResolverTests {
@Test
public void supportsParameter() {
assertTrue(this.resolver.supportsParameter(this.resolvable.annot(headerPlain()).arg()));
assertFalse(this.resolver.supportsParameter(this.resolvable.annotNotPresent(Header.class).arg()));
assertThat(this.resolver.supportsParameter(this.resolvable.annot(headerPlain()).arg())).isTrue();
assertThat(this.resolver.supportsParameter(this.resolvable.annotNotPresent(Header.class).arg())).isFalse();
}
@Test
public void resolveArgument() {
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeader("param1", "foo").build();
Object result = resolveArgument(this.resolvable.annot(headerPlain()).arg(), message);
assertEquals("foo", result);
assertThat(result).isEqualTo("foo");
}
@Test // SPR-11326
@@ -78,7 +76,7 @@ public class HeaderMethodArgumentResolverTests {
TestMessageHeaderAccessor headers = new TestMessageHeaderAccessor();
headers.setNativeHeader("param1", "foo");
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build();
assertEquals("foo", resolveArgument(this.resolvable.annot(headerPlain()).arg(), message));
assertThat(this.<Object>resolveArgument(this.resolvable.annot(headerPlain()).arg(), message)).isEqualTo("foo");
}
@Test
@@ -88,11 +86,11 @@ public class HeaderMethodArgumentResolverTests {
headers.setNativeHeader("param1", "native-foo");
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build();
assertEquals("foo", resolveArgument(
this.resolvable.annot(headerPlain()).arg(), message));
assertThat(this.<Object>resolveArgument(
this.resolvable.annot(headerPlain()).arg(), message)).isEqualTo("foo");
assertEquals("native-foo", resolveArgument(
this.resolvable.annot(header("nativeHeaders.param1")).arg(), message));
assertThat(this.<Object>resolveArgument(
this.resolvable.annot(header("nativeHeaders.param1")).arg(), message)).isEqualTo("native-foo");
}
@Test
@@ -106,7 +104,7 @@ public class HeaderMethodArgumentResolverTests {
public void resolveArgumentDefaultValue() {
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).build();
Object result = resolveArgument(this.resolvable.annot(header("name", "bar")).arg(), message);
assertEquals("bar", result);
assertThat(result).isEqualTo("bar");
}
@Test
@@ -116,7 +114,7 @@ public class HeaderMethodArgumentResolverTests {
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).build();
MethodParameter param = this.resolvable.annot(header("name", "#{systemProperties.systemProperty}")).arg();
Object result = resolveArgument(param, message);
assertEquals("sysbar", result);
assertThat(result).isEqualTo("sysbar");
}
finally {
System.clearProperty("systemProperty");
@@ -130,7 +128,7 @@ public class HeaderMethodArgumentResolverTests {
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeader("sysbar", "foo").build();
MethodParameter param = this.resolvable.annot(header("#{systemProperties.systemProperty}")).arg();
Object result = resolveArgument(param, message);
assertEquals("foo", result);
assertThat(result).isEqualTo("foo");
}
finally {
System.clearProperty("systemProperty");
@@ -142,7 +140,7 @@ public class HeaderMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("foo").setHeader("foo", "bar").build();
MethodParameter param = this.resolvable.annot(header("foo")).arg(Optional.class, String.class);
Object result = resolveArgument(param, message);
assertEquals(Optional.of("bar"), result);
assertThat(result).isEqualTo(Optional.of("bar"));
}
@Test
@@ -150,7 +148,7 @@ public class HeaderMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("foo").build();
MethodParameter param = this.resolvable.annot(header("foo")).arg(Optional.class, String.class);
Object result = resolveArgument(param, message);
assertEquals(Optional.empty(), result);
assertThat(result).isEqualTo(Optional.empty());
}
@SuppressWarnings({"unchecked", "ConstantConditions"})

24
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/reactive/HeadersMethodArgumentResolverTests.java
View File

@@ -31,10 +31,8 @@ import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.messaging.support.NativeMessageHeaderAccessor;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Test fixture for {@link HeadersMethodArgumentResolver} tests.
@@ -53,14 +51,14 @@ public class HeadersMethodArgumentResolverTests {
@Test
public void supportsParameter() {
assertTrue(this.resolver.supportsParameter(
this.resolvable.annotPresent(Headers.class).arg(Map.class, String.class, Object.class)));
assertThat(this.resolver.supportsParameter(
this.resolvable.annotPresent(Headers.class).arg(Map.class, String.class, Object.class))).isTrue();
assertTrue(this.resolver.supportsParameter(this.resolvable.arg(MessageHeaders.class)));
assertTrue(this.resolver.supportsParameter(this.resolvable.arg(MessageHeaderAccessor.class)));
assertTrue(this.resolver.supportsParameter(this.resolvable.arg(TestMessageHeaderAccessor.class)));
assertThat(this.resolver.supportsParameter(this.resolvable.arg(MessageHeaders.class))).isTrue();
assertThat(this.resolver.supportsParameter(this.resolvable.arg(MessageHeaderAccessor.class))).isTrue();
assertThat(this.resolver.supportsParameter(this.resolvable.arg(TestMessageHeaderAccessor.class))).isTrue();
assertFalse(this.resolver.supportsParameter(this.resolvable.annotPresent(Headers.class).arg(String.class)));
assertThat(this.resolver.supportsParameter(this.resolvable.annotPresent(Headers.class).arg(String.class))).isFalse();
}
@Test
@@ -68,7 +66,7 @@ public class HeadersMethodArgumentResolverTests {
public void resolveArgumentAnnotated() {
MethodParameter param = this.resolvable.annotPresent(Headers.class).arg(Map.class, String.class, Object.class);
Map<String, Object> headers = resolveArgument(param);
assertEquals("bar", headers.get("foo"));
assertThat(headers.get("foo")).isEqualTo("bar");
}
@Test
@@ -80,19 +78,19 @@ public class HeadersMethodArgumentResolverTests {
@Test
public void resolveArgumentMessageHeaders() {
MessageHeaders headers = resolveArgument(this.resolvable.arg(MessageHeaders.class));
assertEquals("bar", headers.get("foo"));
assertThat(headers.get("foo")).isEqualTo("bar");
}
@Test
public void resolveArgumentMessageHeaderAccessor() {
MessageHeaderAccessor headers = resolveArgument(this.resolvable.arg(MessageHeaderAccessor.class));
assertEquals("bar", headers.getHeader("foo"));
assertThat(headers.getHeader("foo")).isEqualTo("bar");
}
@Test
public void resolveArgumentMessageHeaderAccessorSubclass() {
TestMessageHeaderAccessor headers = resolveArgument(this.resolvable.arg(TestMessageHeaderAccessor.class));
assertEquals("bar", headers.getHeader("foo"));
assertThat(headers.getHeader("foo")).isEqualTo("bar");
}
@SuppressWarnings({"unchecked", "ConstantConditions"})

5
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/reactive/MessageMappingMessageHandlerTests.java
View File

@@ -51,7 +51,7 @@ import org.springframework.util.AntPathMatcher;
import org.springframework.util.SimpleRouteMatcher;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link MessageMappingMessageHandler}.
@@ -123,8 +123,7 @@ public class MessageMappingMessageHandlerTests {
new SimpleRouteMatcher(new AntPathMatcher()).parseRoute("string")));
StepVerifier.create(initMesssageHandler().handleMessage(message))
.expectErrorSatisfies(ex -> assertTrue("Actual: " + ex.getMessage(),
ex.getMessage().startsWith("Could not resolve method parameter at index 0")))
.expectErrorSatisfies(ex -> assertThat(ex.getMessage().startsWith("Could not resolve method parameter at index 0")).as("Actual: " + ex.getMessage()).isTrue())
.verify(Duration.ofSeconds(5));
}

27
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/reactive/PayloadMethodArgumentResolverTests.java
View File

@@ -47,10 +47,7 @@ import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
@@ -71,14 +68,14 @@ public class PayloadMethodArgumentResolverTests {
boolean useDefaultResolution = true;
PayloadMethodArgumentResolver resolver = createResolver(null, useDefaultResolution);
assertTrue(resolver.supportsParameter(this.testMethod.annotPresent(Payload.class).arg()));
assertTrue(resolver.supportsParameter(this.testMethod.annotNotPresent(Payload.class).arg(String.class)));
assertThat(resolver.supportsParameter(this.testMethod.annotPresent(Payload.class).arg())).isTrue();
assertThat(resolver.supportsParameter(this.testMethod.annotNotPresent(Payload.class).arg(String.class))).isTrue();
useDefaultResolution = false;
resolver = createResolver(null, useDefaultResolution);
assertTrue(resolver.supportsParameter(this.testMethod.annotPresent(Payload.class).arg()));
assertFalse(resolver.supportsParameter(this.testMethod.annotNotPresent(Payload.class).arg(String.class)));
assertThat(resolver.supportsParameter(this.testMethod.annotPresent(Payload.class).arg())).isTrue();
assertThat(resolver.supportsParameter(this.testMethod.annotNotPresent(Payload.class).arg(String.class))).isFalse();
}
@Test
@@ -88,8 +85,8 @@ public class PayloadMethodArgumentResolverTests {
StepVerifier.create(mono)
.consumeErrorWith(ex -> {
assertEquals(MethodArgumentResolutionException.class, ex.getClass());
assertTrue(ex.getMessage(), ex.getMessage().contains("Payload content is missing"));
assertThat(ex.getClass()).isEqualTo(MethodArgumentResolutionException.class);
assertThat(ex.getMessage().contains("Payload content is missing")).as(ex.getMessage()).isTrue();
})
.verify();
}
@@ -97,7 +94,7 @@ public class PayloadMethodArgumentResolverTests {
@Test
public void emptyBodyWhenNotRequired() {
MethodParameter param = this.testMethod.annotPresent(Payload.class).arg();
assertNull(resolveValue(param, Mono.empty(), null));
assertThat(this.<Object>resolveValue(param, Mono.empty(), null)).isNull();
}
@Test
@@ -107,7 +104,7 @@ public class PayloadMethodArgumentResolverTests {
Mono<Object> mono = resolveValue(param,
Mono.delay(Duration.ofMillis(10)).map(aLong -> toDataBuffer(body)), null);
assertEquals(body, mono.block());
assertThat(mono.block()).isEqualTo(body);
}
@Test
@@ -118,7 +115,7 @@ public class PayloadMethodArgumentResolverTests {
Flux<Object> flux = resolveValue(param,
Flux.fromIterable(body).delayElements(Duration.ofMillis(10)).map(this::toDataBuffer), null);
assertEquals(body, flux.collectList().block());
assertThat(flux.collectList().block()).isEqualTo(body);
}
@Test
@@ -127,7 +124,7 @@ public class PayloadMethodArgumentResolverTests {
MethodParameter param = this.testMethod.annotNotPresent(Payload.class).arg(String.class);
Object value = resolveValue(param, Mono.just(toDataBuffer(body)), null);
assertEquals(body, value);
assertThat(value).isEqualTo(body);
}
@Test
@@ -173,7 +170,7 @@ public class PayloadMethodArgumentResolverTests {
Object value = result.block(Duration.ofSeconds(5));
if (value != null) {
Class<?> expectedType = param.getParameterType();
assertTrue("Unexpected return value type: " + value, expectedType.isAssignableFrom(value.getClass()));
assertThat(expectedType.isAssignableFrom(value.getClass())).as("Unexpected return value type: " + value).isTrue();
}
return (T) value;
}

23
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/AnnotationExceptionHandlerMethodResolverTests.java
View File

@@ -27,9 +27,8 @@ import org.springframework.messaging.handler.annotation.MessageExceptionHandler;
import org.springframework.stereotype.Controller;
import org.springframework.util.ClassUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
/**
* Test fixture for {@link AnnotationExceptionHandlerMethodResolver} tests.
@@ -46,52 +45,52 @@ public class AnnotationExceptionHandlerMethodResolverTests {
@Test
public void resolveMethodFromAnnotation() {
IOException exception = new IOException();
assertEquals("handleIOException", this.resolver.resolveMethod(exception).getName());
assertThat(this.resolver.resolveMethod(exception).getName()).isEqualTo("handleIOException");
}
@Test
public void resolveMethodFromArgument() {
IllegalArgumentException exception = new IllegalArgumentException();
assertEquals("handleIllegalArgumentException", this.resolver.resolveMethod(exception).getName());
assertThat(this.resolver.resolveMethod(exception).getName()).isEqualTo("handleIllegalArgumentException");
}
@Test
public void resolveMethodFromArgumentWithErrorType() {
AssertionError exception = new AssertionError();
assertEquals("handleAssertionError", this.resolver.resolveMethod(new IllegalStateException(exception)).getName());
assertThat(this.resolver.resolveMethod(new IllegalStateException(exception)).getName()).isEqualTo("handleAssertionError");
}
@Test
public void resolveMethodExceptionSubType() {
IOException ioException = new FileNotFoundException();
assertEquals("handleIOException", this.resolver.resolveMethod(ioException).getName());
assertThat(this.resolver.resolveMethod(ioException).getName()).isEqualTo("handleIOException");
SocketException bindException = new BindException();
assertEquals("handleSocketException", this.resolver.resolveMethod(bindException).getName());
assertThat(this.resolver.resolveMethod(bindException).getName()).isEqualTo("handleSocketException");
}
@Test
public void resolveMethodBestMatch() {
SocketException exception = new SocketException();
assertEquals("handleSocketException", this.resolver.resolveMethod(exception).getName());
assertThat(this.resolver.resolveMethod(exception).getName()).isEqualTo("handleSocketException");
}
@Test
public void resolveMethodNoMatch() {
Exception exception = new Exception();
assertNull("1st lookup", this.resolver.resolveMethod(exception));
assertNull("2nd lookup from cache", this.resolver.resolveMethod(exception));
assertThat(this.resolver.resolveMethod(exception)).as("1st lookup").isNull();
assertThat(this.resolver.resolveMethod(exception)).as("2nd lookup from cache").isNull();
}
@Test
public void resolveMethodInherited() {
IOException exception = new IOException();
assertEquals("handleIOException", this.resolver.resolveMethod(exception).getName());
assertThat(this.resolver.resolveMethod(exception).getName()).isEqualTo("handleIOException");
}
@Test
public void resolveMethodAgainstCause() {
IllegalStateException exception = new IllegalStateException(new IOException());
assertEquals("handleIOException", this.resolver.resolveMethod(exception).getName());
assertThat(this.resolver.resolveMethod(exception).getName()).isEqualTo("handleIOException");
}
@Test

14
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/DefaultMessageHandlerMethodFactoryTests.java
View File

@@ -46,11 +46,8 @@ import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* @author Stephane Nicoll
@@ -87,8 +84,7 @@ public class DefaultMessageHandlerMethodFactoryTests {
public void customConversionServiceFailure() throws Exception {
DefaultMessageHandlerMethodFactory instance = createInstance();
GenericConversionService conversionService = new GenericConversionService();
assertFalse("conversion service should fail to convert payload",
conversionService.canConvert(Integer.class, String.class));
assertThat(conversionService.canConvert(Integer.class, String.class)).as("conversion service should fail to convert payload").isFalse();
instance.setConversionService(conversionService);
instance.afterPropertiesSet();
@@ -189,7 +185,7 @@ public class DefaultMessageHandlerMethodFactoryTests {
private void assertMethodInvocation(SampleBean bean, String methodName) {
assertTrue("Method " + methodName + " should have been invoked", bean.invocations.get(methodName));
assertThat((boolean) bean.invocations.get(methodName)).as("Method " + methodName + " should have been invoked").isTrue();
}
private InvocableHandlerMethod createInvocableHandlerMethod(
@@ -205,7 +201,7 @@ public class DefaultMessageHandlerMethodFactoryTests {
private Method getListenerMethod(String methodName, Class<?>... parameterTypes) {
Method method = ReflectionUtils.findMethod(SampleBean.class, methodName, parameterTypes);
assertNotNull("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes));
assertThat(("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes))).isNotNull();
return method;
}
@@ -224,7 +220,7 @@ public class DefaultMessageHandlerMethodFactoryTests {
public void customArgumentResolver(Locale locale) {
invocations.put("customArgumentResolver", true);
assertEquals("Wrong value for locale", Locale.getDefault(), locale);
assertThat(locale).as("Wrong value for locale").isEqualTo(Locale.getDefault());
}
}

12
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/DestinationVariableMethodArgumentResolverTests.java
View File

@@ -29,10 +29,8 @@ import org.springframework.messaging.handler.annotation.DestinationVariable;
import org.springframework.messaging.handler.invocation.ResolvableMethod;
import org.springframework.messaging.support.MessageBuilder;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.messaging.handler.annotation.MessagingPredicates.destinationVar;
/**
@@ -51,8 +49,8 @@ public class DestinationVariableMethodArgumentResolverTests {
@Test
public void supportsParameter() {
assertTrue(resolver.supportsParameter(this.resolvable.annot(destinationVar().noValue()).arg()));
assertFalse(resolver.supportsParameter(this.resolvable.annotNotPresent(DestinationVariable.class).arg()));
assertThat(resolver.supportsParameter(this.resolvable.annot(destinationVar().noValue()).arg())).isTrue();
assertThat(resolver.supportsParameter(this.resolvable.annotNotPresent(DestinationVariable.class).arg())).isFalse();
}
@Test
@@ -67,11 +65,11 @@ public class DestinationVariableMethodArgumentResolverTests {
MethodParameter param = this.resolvable.annot(destinationVar().noValue()).arg();
Object result = this.resolver.resolveArgument(param, message);
assertEquals("bar", result);
assertThat(result).isEqualTo("bar");
param = this.resolvable.annot(destinationVar("name")).arg();
result = this.resolver.resolveArgument(param, message);
assertEquals("value", result);
assertThat(result).isEqualTo("value");
}
@Test

30
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/HeaderMethodArgumentResolverTests.java
View File

@@ -33,10 +33,8 @@ import org.springframework.messaging.handler.invocation.ResolvableMethod;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.NativeMessageHeaderAccessor;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.messaging.handler.annotation.MessagingPredicates.header;
import static org.springframework.messaging.handler.annotation.MessagingPredicates.headerPlain;
@@ -64,15 +62,15 @@ public class HeaderMethodArgumentResolverTests {
@Test
public void supportsParameter() {
assertTrue(this.resolver.supportsParameter(this.resolvable.annot(headerPlain()).arg()));
assertFalse(this.resolver.supportsParameter(this.resolvable.annotNotPresent(Header.class).arg()));
assertThat(this.resolver.supportsParameter(this.resolvable.annot(headerPlain()).arg())).isTrue();
assertThat(this.resolver.supportsParameter(this.resolvable.annotNotPresent(Header.class).arg())).isFalse();
}
@Test
public void resolveArgument() throws Exception {
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeader("param1", "foo").build();
Object result = this.resolver.resolveArgument(this.resolvable.annot(headerPlain()).arg(), message);
assertEquals("foo", result);
assertThat(result).isEqualTo("foo");
}
@Test // SPR-11326
@@ -80,7 +78,7 @@ public class HeaderMethodArgumentResolverTests {
TestMessageHeaderAccessor headers = new TestMessageHeaderAccessor();
headers.setNativeHeader("param1", "foo");
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build();
assertEquals("foo", this.resolver.resolveArgument(this.resolvable.annot(headerPlain()).arg(), message));
assertThat(this.resolver.resolveArgument(this.resolvable.annot(headerPlain()).arg(), message)).isEqualTo("foo");
}
@Test
@@ -90,11 +88,11 @@ public class HeaderMethodArgumentResolverTests {
headers.setNativeHeader("param1", "native-foo");
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build();
assertEquals("foo", this.resolver.resolveArgument(
this.resolvable.annot(headerPlain()).arg(), message));
assertThat(this.resolver.resolveArgument(
this.resolvable.annot(headerPlain()).arg(), message)).isEqualTo("foo");
assertEquals("native-foo", this.resolver.resolveArgument(
this.resolvable.annot(header("nativeHeaders.param1")).arg(), message));
assertThat(this.resolver.resolveArgument(
this.resolvable.annot(header("nativeHeaders.param1")).arg(), message)).isEqualTo("native-foo");
}
@Test
@@ -108,7 +106,7 @@ public class HeaderMethodArgumentResolverTests {
public void resolveArgumentDefaultValue() throws Exception {
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).build();
Object result = this.resolver.resolveArgument(this.resolvable.annot(header("name", "bar")).arg(), message);
assertEquals("bar", result);
assertThat(result).isEqualTo("bar");
}
@Test
@@ -118,7 +116,7 @@ public class HeaderMethodArgumentResolverTests {
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).build();
MethodParameter param = this.resolvable.annot(header("name", "#{systemProperties.systemProperty}")).arg();
Object result = resolver.resolveArgument(param, message);
assertEquals("sysbar", result);
assertThat(result).isEqualTo("sysbar");
}
finally {
System.clearProperty("systemProperty");
@@ -132,7 +130,7 @@ public class HeaderMethodArgumentResolverTests {
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeader("sysbar", "foo").build();
MethodParameter param = this.resolvable.annot(header("#{systemProperties.systemProperty}")).arg();
Object result = resolver.resolveArgument(param, message);
assertEquals("foo", result);
assertThat(result).isEqualTo("foo");
}
finally {
System.clearProperty("systemProperty");
@@ -144,7 +142,7 @@ public class HeaderMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("foo").setHeader("foo", "bar").build();
MethodParameter param = this.resolvable.annot(header("foo")).arg(Optional.class, String.class);
Object result = resolver.resolveArgument(param, message);
assertEquals(Optional.of("bar"), result);
assertThat(result).isEqualTo(Optional.of("bar"));
}
@Test
@@ -152,7 +150,7 @@ public class HeaderMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("foo").build();
MethodParameter param = this.resolvable.annot(header("foo")).arg(Optional.class, String.class);
Object result = resolver.resolveArgument(param, message);
assertEquals(Optional.empty(), result);
assertThat(result).isEqualTo(Optional.empty());
}

36
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/HeadersMethodArgumentResolverTests.java
View File

@@ -30,10 +30,8 @@ import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.messaging.support.NativeMessageHeaderAccessor;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Test fixture for {@link HeadersMethodArgumentResolver} tests.
@@ -54,14 +52,14 @@ public class HeadersMethodArgumentResolverTests {
@Test
public void supportsParameter() {
assertTrue(this.resolver.supportsParameter(
this.resolvable.annotPresent(Headers.class).arg(Map.class, String.class, Object.class)));
assertThat(this.resolver.supportsParameter(
this.resolvable.annotPresent(Headers.class).arg(Map.class, String.class, Object.class))).isTrue();
assertTrue(this.resolver.supportsParameter(this.resolvable.arg(MessageHeaders.class)));
assertTrue(this.resolver.supportsParameter(this.resolvable.arg(MessageHeaderAccessor.class)));
assertTrue(this.resolver.supportsParameter(this.resolvable.arg(TestMessageHeaderAccessor.class)));
assertThat(this.resolver.supportsParameter(this.resolvable.arg(MessageHeaders.class))).isTrue();
assertThat(this.resolver.supportsParameter(this.resolvable.arg(MessageHeaderAccessor.class))).isTrue();
assertThat(this.resolver.supportsParameter(this.resolvable.arg(TestMessageHeaderAccessor.class))).isTrue();
assertFalse(this.resolver.supportsParameter(this.resolvable.annotPresent(Headers.class).arg(String.class)));
assertThat(this.resolver.supportsParameter(this.resolvable.annotPresent(Headers.class).arg(String.class))).isFalse();
}
@Test
@@ -69,10 +67,11 @@ public class HeadersMethodArgumentResolverTests {
MethodParameter param = this.resolvable.annotPresent(Headers.class).arg(Map.class, String.class, Object.class);
Object resolved = this.resolver.resolveArgument(param, this.message);
assertTrue(resolved instanceof Map);
boolean condition = resolved instanceof Map;
assertThat(condition).isTrue();
@SuppressWarnings("unchecked")
Map<String, Object> headers = (Map<String, Object>) resolved;
assertEquals("bar", headers.get("foo"));
assertThat(headers.get("foo")).isEqualTo("bar");
}
@Test
@@ -85,9 +84,10 @@ public class HeadersMethodArgumentResolverTests {
public void resolveArgumentMessageHeaders() throws Exception {
Object resolved = this.resolver.resolveArgument(this.resolvable.arg(MessageHeaders.class), this.message);
assertTrue(resolved instanceof MessageHeaders);
boolean condition = resolved instanceof MessageHeaders;
assertThat(condition).isTrue();
MessageHeaders headers = (MessageHeaders) resolved;
assertEquals("bar", headers.get("foo"));
assertThat(headers.get("foo")).isEqualTo("bar");
}
@Test
@@ -95,9 +95,10 @@ public class HeadersMethodArgumentResolverTests {
MethodParameter param = this.resolvable.arg(MessageHeaderAccessor.class);
Object resolved = this.resolver.resolveArgument(param, this.message);
assertTrue(resolved instanceof MessageHeaderAccessor);
boolean condition = resolved instanceof MessageHeaderAccessor;
assertThat(condition).isTrue();
MessageHeaderAccessor headers = (MessageHeaderAccessor) resolved;
assertEquals("bar", headers.getHeader("foo"));
assertThat(headers.getHeader("foo")).isEqualTo("bar");
}
@Test
@@ -105,9 +106,10 @@ public class HeadersMethodArgumentResolverTests {
MethodParameter param = this.resolvable.arg(TestMessageHeaderAccessor.class);
Object resolved = this.resolver.resolveArgument(param, this.message);
assertTrue(resolved instanceof TestMessageHeaderAccessor);
boolean condition = resolved instanceof TestMessageHeaderAccessor;
assertThat(condition).isTrue();
TestMessageHeaderAccessor headers = (TestMessageHeaderAccessor) resolved;
assertEquals("bar", headers.getHeader("foo"));
assertThat(headers.getHeader("foo")).isEqualTo("bar");
}

59
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/MessageMethodArgumentResolverTests.java
View File

@@ -31,11 +31,8 @@ import org.springframework.messaging.support.ErrorMessage;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.messaging.support.MessageBuilder;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -69,8 +66,8 @@ public class MessageMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("test").build();
MethodParameter parameter = new MethodParameter(this.method, 0);
assertTrue(this.resolver.supportsParameter(parameter));
assertSame(message, this.resolver.resolveArgument(parameter, message));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThat(this.resolver.resolveArgument(parameter, message)).isSameAs(message);
}
@Test
@@ -78,8 +75,8 @@ public class MessageMethodArgumentResolverTests {
Message<Integer> message = MessageBuilder.withPayload(123).build();
MethodParameter parameter = new MethodParameter(this.method, 1);
assertTrue(this.resolver.supportsParameter(parameter));
assertSame(message, this.resolver.resolveArgument(parameter, message));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThat(this.resolver.resolveArgument(parameter, message)).isSameAs(message);
}
@Test
@@ -87,8 +84,8 @@ public class MessageMethodArgumentResolverTests {
Message<Integer> message = MessageBuilder.withPayload(123).build();
MethodParameter parameter = new MethodParameter(this.method, 2);
assertTrue(this.resolver.supportsParameter(parameter));
assertSame(message, this.resolver.resolveArgument(parameter, message));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThat(this.resolver.resolveArgument(parameter, message)).isSameAs(message);
}
@Test
@@ -101,9 +98,9 @@ public class MessageMethodArgumentResolverTests {
@SuppressWarnings("unchecked")
Message<Integer> actual = (Message<Integer>) this.resolver.resolveArgument(parameter, message);
assertNotNull(actual);
assertSame(message.getHeaders(), actual.getHeaders());
assertEquals(new Integer(4), actual.getPayload());
assertThat(actual).isNotNull();
assertThat(actual.getHeaders()).isSameAs(message.getHeaders());
assertThat(actual.getPayload()).isEqualTo(new Integer(4));
}
@Test
@@ -111,7 +108,7 @@ public class MessageMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("test").build();
MethodParameter parameter = new MethodParameter(this.method, 1);
assertTrue(this.resolver.supportsParameter(parameter));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThatExceptionOfType(MessageConversionException.class).isThrownBy(() ->
this.resolver.resolveArgument(parameter, message))
.withMessageContaining(Integer.class.getName())
@@ -123,7 +120,7 @@ public class MessageMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("").build();
MethodParameter parameter = new MethodParameter(this.method, 1);
assertTrue(this.resolver.supportsParameter(parameter));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThatExceptionOfType(MessageConversionException.class).isThrownBy(() ->
this.resolver.resolveArgument(parameter, message))
.withMessageContaining("payload is empty")
@@ -136,8 +133,8 @@ public class MessageMethodArgumentResolverTests {
Message<Integer> message = MessageBuilder.withPayload(123).build();
MethodParameter parameter = new MethodParameter(this.method, 3);
assertTrue(this.resolver.supportsParameter(parameter));
assertSame(message, this.resolver.resolveArgument(parameter, message));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThat(this.resolver.resolveArgument(parameter, message)).isSameAs(message);
}
@Test
@@ -145,7 +142,7 @@ public class MessageMethodArgumentResolverTests {
Message<Locale> message = MessageBuilder.withPayload(Locale.getDefault()).build();
MethodParameter parameter = new MethodParameter(this.method, 3);
assertTrue(this.resolver.supportsParameter(parameter));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThatExceptionOfType(MessageConversionException.class).isThrownBy(() ->
this.resolver.resolveArgument(parameter, message))
.withMessageContaining(Number.class.getName())
@@ -157,8 +154,8 @@ public class MessageMethodArgumentResolverTests {
ErrorMessage message = new ErrorMessage(new UnsupportedOperationException());
MethodParameter parameter = new MethodParameter(this.method, 4);
assertTrue(this.resolver.supportsParameter(parameter));
assertSame(message, this.resolver.resolveArgument(parameter, message));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThat(this.resolver.resolveArgument(parameter, message)).isSameAs(message);
}
@Test
@@ -166,8 +163,8 @@ public class MessageMethodArgumentResolverTests {
ErrorMessage message = new ErrorMessage(new UnsupportedOperationException());
MethodParameter parameter = new MethodParameter(this.method, 0);
assertTrue(this.resolver.supportsParameter(parameter));
assertSame(message, this.resolver.resolveArgument(parameter, message));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThat(this.resolver.resolveArgument(parameter, message)).isSameAs(message);
}
@Test
@@ -176,7 +173,7 @@ public class MessageMethodArgumentResolverTests {
Message<? extends Throwable> message = new GenericMessage<Throwable>(ex);
MethodParameter parameter = new MethodParameter(this.method, 4);
assertTrue(this.resolver.supportsParameter(parameter));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThatExceptionOfType(MethodArgumentTypeMismatchException.class).isThrownBy(() ->
this.resolver.resolveArgument(parameter, message))
.withMessageContaining(ErrorMessage.class.getName())
@@ -190,8 +187,8 @@ public class MessageMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("test").build();
MethodParameter parameter = new MethodParameter(this.method, 0);
assertTrue(this.resolver.supportsParameter(parameter));
assertSame(message, this.resolver.resolveArgument(parameter, message));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThat(this.resolver.resolveArgument(parameter, message)).isSameAs(message);
}
@Test
@@ -201,7 +198,7 @@ public class MessageMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("test").build();
MethodParameter parameter = new MethodParameter(this.method, 1);
assertTrue(this.resolver.supportsParameter(parameter));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThatExceptionOfType(MessageConversionException.class).isThrownBy(() ->
this.resolver.resolveArgument(parameter, message))
.withMessageContaining(Integer.class.getName())
@@ -215,7 +212,7 @@ public class MessageMethodArgumentResolverTests {
Message<String> message = MessageBuilder.withPayload("").build();
MethodParameter parameter = new MethodParameter(this.method, 1);
assertTrue(this.resolver.supportsParameter(parameter));
assertThat(this.resolver.supportsParameter(parameter)).isTrue();
assertThatExceptionOfType(MessageConversionException.class).isThrownBy(() ->
this.resolver.resolveArgument(parameter, message))
.withMessageContaining("payload is empty")
@@ -231,10 +228,12 @@ public class MessageMethodArgumentResolverTests {
this.resolver = new MessageMethodArgumentResolver(new MappingJackson2MessageConverter());
Object actual = this.resolver.resolveArgument(parameter, inMessage);
assertTrue(actual instanceof Message);
boolean condition1 = actual instanceof Message;
assertThat(condition1).isTrue();
Message<?> outMessage = (Message<?>) actual;
assertTrue(outMessage.getPayload() instanceof Foo);
assertEquals("bar", ((Foo) outMessage.getPayload()).getFoo());
boolean condition = outMessage.getPayload() instanceof Foo;
assertThat(condition).isTrue();
assertThat(((Foo) outMessage.getPayload()).getFoo()).isEqualTo("bar");
}

26
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/PayloadMethodArgumentResolverTests.java
View File

@@ -38,12 +38,9 @@ import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
/**
* Test fixture for {@link PayloadMethodArgumentResolver}.
@@ -91,14 +88,14 @@ public class PayloadMethodArgumentResolverTests {
@Test
public void supportsParameter() {
assertTrue(this.resolver.supportsParameter(this.paramAnnotated));
assertTrue(this.resolver.supportsParameter(this.paramNotAnnotated));
assertThat(this.resolver.supportsParameter(this.paramAnnotated)).isTrue();
assertThat(this.resolver.supportsParameter(this.paramNotAnnotated)).isTrue();
PayloadMethodArgumentResolver strictResolver = new PayloadMethodArgumentResolver(
new StringMessageConverter(), testValidator(), false);
assertTrue(strictResolver.supportsParameter(this.paramAnnotated));
assertFalse(strictResolver.supportsParameter(this.paramNotAnnotated));
assertThat(strictResolver.supportsParameter(this.paramAnnotated)).isTrue();
assertThat(strictResolver.supportsParameter(this.paramNotAnnotated)).isFalse();
}
@Test
@@ -106,7 +103,7 @@ public class PayloadMethodArgumentResolverTests {
Message<?> message = MessageBuilder.withPayload("ABC".getBytes()).build();
Object actual = this.resolver.resolveArgument(paramAnnotated, message);
assertEquals("ABC", actual);
assertThat(actual).isEqualTo("ABC");
}
@Test
@@ -128,13 +125,13 @@ public class PayloadMethodArgumentResolverTests {
@Test
public void resolveNotRequired() throws Exception {
Message<?> emptyByteArrayMessage = MessageBuilder.withPayload(new byte[0]).build();
assertNull(this.resolver.resolveArgument(this.paramAnnotatedNotRequired, emptyByteArrayMessage));
assertThat(this.resolver.resolveArgument(this.paramAnnotatedNotRequired, emptyByteArrayMessage)).isNull();
Message<?> emptyStringMessage = MessageBuilder.withPayload("").build();
assertNull(this.resolver.resolveArgument(this.paramAnnotatedNotRequired, emptyStringMessage));
assertThat(this.resolver.resolveArgument(this.paramAnnotatedNotRequired, emptyStringMessage)).isNull();
Message<?> notEmptyMessage = MessageBuilder.withPayload("ABC".getBytes()).build();
assertEquals("ABC", this.resolver.resolveArgument(this.paramAnnotatedNotRequired, notEmptyMessage));
assertThat(this.resolver.resolveArgument(this.paramAnnotatedNotRequired, notEmptyMessage)).isEqualTo("ABC");
}
@Test
@@ -180,7 +177,7 @@ public class PayloadMethodArgumentResolverTests {
@Test
public void resolveNonAnnotatedParameter() throws Exception {
Message<?> notEmptyMessage = MessageBuilder.withPayload("ABC".getBytes()).build();
assertEquals("ABC", this.resolver.resolveArgument(this.paramNotAnnotated, notEmptyMessage));
assertThat(this.resolver.resolveArgument(this.paramNotAnnotated, notEmptyMessage)).isEqualTo("ABC");
Message<?> emptyStringMessage = MessageBuilder.withPayload("").build();
assertThatExceptionOfType(MethodArgumentNotValidException.class).isThrownBy(() ->
@@ -192,8 +189,7 @@ public class PayloadMethodArgumentResolverTests {
// See testValidator()
Message<?> message = MessageBuilder.withPayload("invalidValue".getBytes()).build();
assertThatExceptionOfType(MethodArgumentNotValidException.class).isThrownBy(() ->
assertEquals("invalidValue", this.resolver.resolveArgument(this.paramValidatedNotAnnotated, message)))
assertThatExceptionOfType(MethodArgumentNotValidException.class).isThrownBy(() -> assertThat(this.resolver.resolveArgument(this.paramValidatedNotAnnotated, message)).isEqualTo("invalidValue"))
.withMessageContaining("invalid value");
}

27
spring-messaging/src/test/java/org/springframework/messaging/handler/invocation/InvocableHandlerMethodTests.java
View File

@@ -24,11 +24,10 @@ import org.springframework.core.MethodParameter;
import org.springframework.lang.Nullable;
import org.springframework.messaging.Message;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.mock;
/**
@@ -50,11 +49,11 @@ public class InvocableHandlerMethodTests {
Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
Object value = invoke(new Handler(), method);
assertEquals(1, getStubResolver(0).getResolvedParameters().size());
assertEquals(1, getStubResolver(1).getResolvedParameters().size());
assertEquals("99-value", value);
assertEquals("intArg", getStubResolver(0).getResolvedParameters().get(0).getParameterName());
assertEquals("stringArg", getStubResolver(1).getResolvedParameters().get(0).getParameterName());
assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
assertThat(getStubResolver(1).getResolvedParameters().size()).isEqualTo(1);
assertThat(value).isEqualTo("99-value");
assertThat(getStubResolver(0).getResolvedParameters().get(0).getParameterName()).isEqualTo("intArg");
assertThat(getStubResolver(1).getResolvedParameters().get(0).getParameterName()).isEqualTo("stringArg");
}
@Test
@@ -64,9 +63,9 @@ public class InvocableHandlerMethodTests {
Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
Object value = invoke(new Handler(), method);
assertEquals(1, getStubResolver(0).getResolvedParameters().size());
assertEquals(1, getStubResolver(1).getResolvedParameters().size());
assertEquals("null-null", value);
assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
assertThat(getStubResolver(1).getResolvedParameters().size()).isEqualTo(1);
assertThat(value).isEqualTo("null-null");
}
@Test
@@ -82,9 +81,9 @@ public class InvocableHandlerMethodTests {
Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
Object value = invoke(new Handler(), method, 99, "value");
assertNotNull(value);
assertEquals(String.class, value.getClass());
assertEquals("99-value", value);
assertThat(value).isNotNull();
assertThat(value.getClass()).isEqualTo(String.class);
assertThat(value).isEqualTo("99-value");
}
@Test
@@ -94,7 +93,7 @@ public class InvocableHandlerMethodTests {
Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
Object value = invoke(new Handler(), method, 2, "value2");
assertEquals("2-value2", value);
assertThat(value).isEqualTo("2-value2");
}
@Test

16
spring-messaging/src/test/java/org/springframework/messaging/handler/invocation/MethodMessageHandlerTests.java
View File

@@ -42,8 +42,6 @@ import org.springframework.util.PathMatcher;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
/**
* Test fixture for
@@ -86,7 +84,7 @@ public class MethodMessageHandlerTests {
Map<String, HandlerMethod> handlerMethods = this.messageHandler.getHandlerMethods();
assertNotNull(handlerMethods);
assertThat(handlerMethods).isNotNull();
assertThat(handlerMethods).hasSize(3);
}
@@ -98,7 +96,7 @@ public class MethodMessageHandlerTests {
this.messageHandler.handleMessage(toDestination("/test/handlerPathMatchFoo"));
assertEquals("pathMatchWildcard", this.testController.method);
assertThat(this.testController.method).isEqualTo("pathMatchWildcard");
}
@Test
@@ -112,7 +110,7 @@ public class MethodMessageHandlerTests {
this.messageHandler.handleMessage(toDestination("/test/bestmatch/bar/path"));
assertEquals("bestMatch", this.testController.method);
assertThat(this.testController.method).isEqualTo("bestMatch");
}
@Test
@@ -120,8 +118,8 @@ public class MethodMessageHandlerTests {
this.messageHandler.handleMessage(toDestination("/test/handlerArgumentResolver"));
assertEquals("handlerArgumentResolver", this.testController.method);
assertNotNull(this.testController.arguments.get("message"));
assertThat(this.testController.method).isEqualTo("handlerArgumentResolver");
assertThat(this.testController.arguments.get("message")).isNotNull();
}
@Test
@@ -129,8 +127,8 @@ public class MethodMessageHandlerTests {
this.messageHandler.handleMessage(toDestination("/test/handlerThrowsExc"));
assertEquals("illegalStateException", this.testController.method);
assertNotNull(this.testController.arguments.get("exception"));
assertThat(this.testController.method).isEqualTo("illegalStateException");
assertThat(this.testController.arguments.get("exception")).isNotNull();
}
private Message<?> toDestination(String destination) {

43
spring-messaging/src/test/java/org/springframework/messaging/handler/invocation/reactive/InvocableHandlerMethodTests.java
View File

@@ -32,13 +32,10 @@ import org.springframework.messaging.Message;
import org.springframework.messaging.handler.invocation.MethodArgumentResolutionException;
import org.springframework.messaging.handler.invocation.ResolvableMethod;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.mockito.Mockito.mock;
/**
@@ -61,11 +58,11 @@ public class InvocableHandlerMethodTests {
Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
Object value = invokeAndBlock(new Handler(), method);
assertEquals(1, getStubResolver(0).getResolvedParameters().size());
assertEquals(1, getStubResolver(1).getResolvedParameters().size());
assertEquals("99-value", value);
assertEquals("intArg", getStubResolver(0).getResolvedParameters().get(0).getParameterName());
assertEquals("stringArg", getStubResolver(1).getResolvedParameters().get(0).getParameterName());
assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
assertThat(getStubResolver(1).getResolvedParameters().size()).isEqualTo(1);
assertThat(value).isEqualTo("99-value");
assertThat(getStubResolver(0).getResolvedParameters().get(0).getParameterName()).isEqualTo("intArg");
assertThat(getStubResolver(1).getResolvedParameters().get(0).getParameterName()).isEqualTo("stringArg");
}
@Test
@@ -75,9 +72,9 @@ public class InvocableHandlerMethodTests {
Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
Object value = invokeAndBlock(new Handler(), method);
assertEquals(1, getStubResolver(0).getResolvedParameters().size());
assertEquals(1, getStubResolver(1).getResolvedParameters().size());
assertEquals("null-null", value);
assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
assertThat(getStubResolver(1).getResolvedParameters().size()).isEqualTo(1);
assertThat(value).isEqualTo("null-null");
}
@Test
@@ -93,9 +90,9 @@ public class InvocableHandlerMethodTests {
Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
Object value = invokeAndBlock(new Handler(), method, 99, "value");
assertNotNull(value);
assertEquals(String.class, value.getClass());
assertEquals("99-value", value);
assertThat(value).isNotNull();
assertThat(value.getClass()).isEqualTo(String.class);
assertThat(value).isEqualTo("99-value");
}
@Test
@@ -105,7 +102,7 @@ public class InvocableHandlerMethodTests {
Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
Object value = invokeAndBlock(new Handler(), method, 2, "value2");
assertEquals("2-value2", value);
assertThat(value).isEqualTo("2-value2");
}
@Test
@@ -137,7 +134,7 @@ public class InvocableHandlerMethodTests {
Throwable expected = new Throwable("error");
Mono<Object> result = invoke(new Handler(), method, expected);
StepVerifier.create(result).expectErrorSatisfies(actual -> assertSame(expected, actual)).verify();
StepVerifier.create(result).expectErrorSatisfies(actual -> assertThat(actual).isSameAs(expected)).verify();
}
@Test
@@ -147,10 +144,10 @@ public class InvocableHandlerMethodTests {
Handler handler = new Handler();
Object value = invokeAndBlock(handler, method);
assertNull(value);
assertEquals(1, getStubResolver(0).getResolvedParameters().size());
assertEquals("5.25", handler.getResult());
assertEquals("amount", getStubResolver(0).getResolvedParameters().get(0).getParameterName());
assertThat(value).isNull();
assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
assertThat(handler.getResult()).isEqualTo("5.25");
assertThat(getStubResolver(0).getResolvedParameters().get(0).getParameterName()).isEqualTo("amount");
}
@Test
@@ -159,8 +156,8 @@ public class InvocableHandlerMethodTests {
Handler handler = new Handler();
Object value = invokeAndBlock(handler, method);
assertNull(value);
assertEquals("success", handler.getResult());
assertThat(value).isNull();
assertThat(handler.getResult()).isEqualTo("success");
}

3
spring-messaging/src/test/java/org/springframework/messaging/handler/invocation/reactive/MethodMessageHandlerTests.java
View File

@@ -48,7 +48,6 @@ import org.springframework.util.SimpleRouteMatcher;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
/**
* Unit tests for {@link AbstractMethodMessageHandler}.
@@ -68,7 +67,7 @@ public class MethodMessageHandlerTests {
TestMethodMessageHandler messageHandler = initMethodMessageHandler(TestController.class);
Map<String, HandlerMethod> mappings = messageHandler.getHandlerMethods();
assertEquals(5, mappings.keySet().size());
assertThat(mappings.keySet().size()).isEqualTo(5);
assertThat(mappings).containsOnlyKeys(
"/handleMessage", "/handleMessageWithArgument", "/handleMessageWithError",
"/handleMessageMatch1", "/handleMessageMatch2");

45
spring-messaging/src/test/java/org/springframework/messaging/rsocket/DefaultRSocketRequesterTests.java
View File

@@ -44,11 +44,8 @@ import org.springframework.messaging.rsocket.RSocketRequester.ResponseSpec;
import org.springframework.util.MimeTypeUtils;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Unit tests for {@link DefaultRSocketRequester}.
@@ -97,9 +94,9 @@ public class DefaultRSocketRequesterTests {
private void testSinglePayload(Function<RequestSpec, ResponseSpec> mapper, String expectedValue) {
mapper.apply(this.requester.route("toA")).send().block(Duration.ofSeconds(5));
assertEquals("fireAndForget", this.rsocket.getSavedMethodName());
assertEquals("toA", this.rsocket.getSavedPayload().getMetadataUtf8());
assertEquals(expectedValue, this.rsocket.getSavedPayload().getDataUtf8());
assertThat(this.rsocket.getSavedMethodName()).isEqualTo("fireAndForget");
assertThat(this.rsocket.getSavedPayload().getMetadataUtf8()).isEqualTo("toA");
assertThat(this.rsocket.getSavedPayload().getDataUtf8()).isEqualTo(expectedValue);
}
@Test
@@ -122,20 +119,18 @@ public class DefaultRSocketRequesterTests {
this.rsocket.reset();
mapper.apply(this.requester.route("toA")).retrieveFlux(String.class).blockLast(Duration.ofSeconds(5));
assertEquals("requestChannel", this.rsocket.getSavedMethodName());
assertThat(this.rsocket.getSavedMethodName()).isEqualTo("requestChannel");
List<Payload> payloads = this.rsocket.getSavedPayloadFlux().collectList().block(Duration.ofSeconds(5));
assertNotNull(payloads);
assertThat(payloads).isNotNull();
if (Arrays.equals(new String[] {""}, expectedValues)) {
assertEquals(1, payloads.size());
assertEquals("toA", payloads.get(0).getMetadataUtf8());
assertEquals("", payloads.get(0).getDataUtf8());
assertThat(payloads.size()).isEqualTo(1);
assertThat(payloads.get(0).getMetadataUtf8()).isEqualTo("toA");
assertThat(payloads.get(0).getDataUtf8()).isEqualTo("");
}
else {
assertArrayEquals(new String[] {"toA", "", ""},
payloads.stream().map(Payload::getMetadataUtf8).toArray(String[]::new));
assertArrayEquals(expectedValues,
payloads.stream().map(Payload::getDataUtf8).toArray(String[]::new));
assertThat(payloads.stream().map(Payload::getMetadataUtf8).toArray(String[]::new)).isEqualTo(new String[] {"toA", "", ""});
assertThat(payloads.stream().map(Payload::getDataUtf8).toArray(String[]::new)).isEqualTo(expectedValues);
}
}
@@ -144,9 +139,9 @@ public class DefaultRSocketRequesterTests {
String value = "bodyA";
this.requester.route("toA").data(value).send().block(Duration.ofSeconds(5));
assertEquals("fireAndForget", this.rsocket.getSavedMethodName());
assertEquals("toA", this.rsocket.getSavedPayload().getMetadataUtf8());
assertEquals("bodyA", this.rsocket.getSavedPayload().getDataUtf8());
assertThat(this.rsocket.getSavedMethodName()).isEqualTo("fireAndForget");
assertThat(this.rsocket.getSavedPayload().getMetadataUtf8()).isEqualTo("toA");
assertThat(this.rsocket.getSavedPayload().getDataUtf8()).isEqualTo("bodyA");
}
@Test
@@ -156,7 +151,7 @@ public class DefaultRSocketRequesterTests {
Mono<String> response = this.requester.route("").data("").retrieveMono(String.class);
StepVerifier.create(response).expectNext(value).expectComplete().verify(Duration.ofSeconds(5));
assertEquals("requestResponse", this.rsocket.getSavedMethodName());
assertThat(this.rsocket.getSavedMethodName()).isEqualTo("requestResponse");
}
@Test
@@ -166,8 +161,8 @@ public class DefaultRSocketRequesterTests {
this.rsocket.setPayloadMonoToReturn(mono);
this.requester.route("").data("").retrieveMono(Void.class).block(Duration.ofSeconds(5));
assertTrue(consumed.get());
assertEquals("requestResponse", this.rsocket.getSavedMethodName());
assertThat(consumed.get()).isTrue();
assertThat(this.rsocket.getSavedMethodName()).isEqualTo("requestResponse");
}
@Test
@@ -177,7 +172,7 @@ public class DefaultRSocketRequesterTests {
Flux<String> response = this.requester.route("").data("").retrieveFlux(String.class);
StepVerifier.create(response).expectNext(values).expectComplete().verify(Duration.ofSeconds(5));
assertEquals("requestStream", this.rsocket.getSavedMethodName());
assertThat(this.rsocket.getSavedMethodName()).isEqualTo("requestStream");
}
@Test
@@ -188,8 +183,8 @@ public class DefaultRSocketRequesterTests {
this.rsocket.setPayloadFluxToReturn(flux);
this.requester.route("").data("").retrieveFlux(Void.class).blockLast(Duration.ofSeconds(5));
assertTrue(consumed.get());
assertEquals("requestStream", this.rsocket.getSavedMethodName());
assertThat(consumed.get()).isTrue();
assertThat(this.rsocket.getSavedMethodName()).isEqualTo("requestStream");
}
@Test

4
spring-messaging/src/test/java/org/springframework/messaging/rsocket/RSocketBufferLeakTests.java
View File

@@ -61,7 +61,7 @@ import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Controller;
import org.springframework.util.ObjectUtils;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for scenarios that could lead to Payload and/or DataBuffer leaks.
@@ -348,7 +348,7 @@ public class RSocketBufferLeakTests {
while (true) {
try {
int count = info.getReferenceCount();
assertTrue("Leaked payload (refCnt=" + count + "): " + info, count == 0);
assertThat(count == 0).as("Leaked payload (refCnt=" + count + "): " + info).isTrue();
break;
}
catch (AssertionError ex) {

7
spring-messaging/src/test/java/org/springframework/messaging/rsocket/RSocketClientToServerIntegrationTests.java
View File

@@ -41,7 +41,7 @@ import org.springframework.messaging.handler.annotation.MessageExceptionHandler;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.stereotype.Controller;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Server-side handling of RSocket requests.
@@ -100,9 +100,8 @@ public class RSocketClientToServerIntegrationTests {
.thenCancel()
.verify(Duration.ofSeconds(5));
assertEquals(1, interceptor.getRSocketCount());
assertEquals("Fire and forget requests did not actually complete handling on the server side",
3, interceptor.getFireAndForgetCount(0));
assertThat(interceptor.getRSocketCount()).isEqualTo(1);
assertThat(interceptor.getFireAndForgetCount(0)).as("Fire and forget requests did not actually complete handling on the server side").isEqualTo(3);
}
@Test

12
spring-messaging/src/test/java/org/springframework/messaging/simp/SimpMessageHeaderAccessorTests.java
View File

@@ -20,7 +20,7 @@ import java.util.Collections;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for SimpMessageHeaderAccessor.
@@ -32,7 +32,7 @@ public class SimpMessageHeaderAccessorTests {
@Test
public void getShortLogMessage() {
assertEquals("MESSAGE session=null payload=p", SimpMessageHeaderAccessor.create().getShortLogMessage("p"));
assertThat(SimpMessageHeaderAccessor.create().getShortLogMessage("p")).isEqualTo("MESSAGE session=null payload=p");
}
@Test
@@ -44,8 +44,8 @@ public class SimpMessageHeaderAccessorTests {
accessor.setUser(new TestPrincipal("user"));
accessor.setSessionAttributes(Collections.<String, Object>singletonMap("key", "value"));
assertEquals("MESSAGE destination=/destination subscriptionId=subscription " +
"session=session user=user attributes[1] payload=p", accessor.getShortLogMessage("p"));
assertThat(accessor.getShortLogMessage("p")).isEqualTo(("MESSAGE destination=/destination subscriptionId=subscription " +
"session=session user=user attributes[1] payload=p"));
}
@Test
@@ -58,9 +58,9 @@ public class SimpMessageHeaderAccessorTests {
accessor.setSessionAttributes(Collections.<String, Object>singletonMap("key", "value"));
accessor.setNativeHeader("nativeKey", "nativeValue");
assertEquals("MESSAGE destination=/destination subscriptionId=subscription " +
assertThat(accessor.getDetailedLogMessage("p")).isEqualTo(("MESSAGE destination=/destination subscriptionId=subscription " +
"session=session user=user attributes={key=value} nativeHeaders=" +
"{nativeKey=[nativeValue]} payload=p", accessor.getDetailedLogMessage("p"));
"{nativeKey=[nativeValue]} payload=p"));
}
}

20
spring-messaging/src/test/java/org/springframework/messaging/simp/SimpMessageTypeMessageConditionTests.java
View File

@@ -21,9 +21,7 @@ import org.junit.Test;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for SimpMessageTypeMessageCondition.
@@ -38,13 +36,13 @@ public class SimpMessageTypeMessageConditionTests {
SimpMessageType subscribeType = SimpMessageType.SUBSCRIBE;
SimpMessageType actual = condition(messageType).combine(condition(subscribeType)).getMessageType();
assertEquals(subscribeType, actual);
assertThat(actual).isEqualTo(subscribeType);
actual = condition(messageType).combine(condition(messageType)).getMessageType();
assertEquals(messageType, actual);
assertThat(actual).isEqualTo(messageType);
actual = condition(subscribeType).combine(condition(subscribeType)).getMessageType();
assertEquals(subscribeType, actual);
assertThat(actual).isEqualTo(subscribeType);
}
@Test
@@ -53,8 +51,8 @@ public class SimpMessageTypeMessageConditionTests {
SimpMessageTypeMessageCondition condition = condition(SimpMessageType.MESSAGE);
SimpMessageTypeMessageCondition actual = condition.getMatchingCondition(message);
assertNotNull(actual);
assertEquals(SimpMessageType.MESSAGE, actual.getMessageType());
assertThat(actual).isNotNull();
assertThat(actual.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
}
@Test
@@ -62,14 +60,14 @@ public class SimpMessageTypeMessageConditionTests {
Message<?> message = message(null);
SimpMessageTypeMessageCondition condition = condition(SimpMessageType.MESSAGE);
assertNull(condition.getMatchingCondition(message));
assertThat(condition.getMatchingCondition(message)).isNull();
}
@Test
public void compareTo() {
Message<byte[]> message = message(null);
assertEquals(0, condition(SimpMessageType.MESSAGE).compareTo(condition(SimpMessageType.MESSAGE), message));
assertEquals(0, condition(SimpMessageType.MESSAGE).compareTo(condition(SimpMessageType.SUBSCRIBE), message));
assertThat(condition(SimpMessageType.MESSAGE).compareTo(condition(SimpMessageType.MESSAGE), message)).isEqualTo(0);
assertThat(condition(SimpMessageType.MESSAGE).compareTo(condition(SimpMessageType.SUBSCRIBE), message)).isEqualTo(0);
}
private Message<byte[]> message(SimpMessageType messageType) {

61
spring-messaging/src/test/java/org/springframework/messaging/simp/SimpMessagingTemplateTests.java
View File

@@ -35,12 +35,7 @@ import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.messaging.support.NativeMessageHeaderAccessor;
import org.springframework.util.LinkedMultiValueMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link org.springframework.messaging.simp.SimpMessagingTemplate}.
@@ -66,15 +61,15 @@ public class SimpMessagingTemplateTests {
this.messagingTemplate.convertAndSendToUser("joe", "/queue/foo", "data");
List<Message<byte[]>> messages = this.messageChannel.getMessages();
assertEquals(1, messages.size());
assertThat(messages.size()).isEqualTo(1);
Message<byte[]> message = messages.get(0);
SimpMessageHeaderAccessor headerAccessor =
MessageHeaderAccessor.getAccessor(message, SimpMessageHeaderAccessor.class);
assertNotNull(headerAccessor);
assertEquals(SimpMessageType.MESSAGE, headerAccessor.getMessageType());
assertEquals("/user/joe/queue/foo", headerAccessor.getDestination());
assertThat(headerAccessor).isNotNull();
assertThat(headerAccessor.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
assertThat(headerAccessor.getDestination()).isEqualTo("/user/joe/queue/foo");
}
@Test
@@ -82,13 +77,13 @@ public class SimpMessagingTemplateTests {
this.messagingTemplate.convertAndSendToUser("https://joe.openid.example.org/", "/queue/foo", "data");
List<Message<byte[]>> messages = this.messageChannel.getMessages();
assertEquals(1, messages.size());
assertThat(messages.size()).isEqualTo(1);
SimpMessageHeaderAccessor headerAccessor =
MessageHeaderAccessor.getAccessor(messages.get(0), SimpMessageHeaderAccessor.class);
assertNotNull(headerAccessor);
assertEquals("/user/https:%2F%2Fjoe.openid.example.org%2F/queue/foo", headerAccessor.getDestination());
assertThat(headerAccessor).isNotNull();
assertThat(headerAccessor.getDestination()).isEqualTo("/user/https:%2F%2Fjoe.openid.example.org%2F/queue/foo");
}
@Test
@@ -101,9 +96,9 @@ public class SimpMessagingTemplateTests {
SimpMessageHeaderAccessor headerAccessor =
MessageHeaderAccessor.getAccessor(messages.get(0), SimpMessageHeaderAccessor.class);
assertNotNull(headerAccessor);
assertNull(headerAccessor.toMap().get("key"));
assertEquals(Arrays.asList("value"), headerAccessor.getNativeHeader("key"));
assertThat(headerAccessor).isNotNull();
assertThat(headerAccessor.toMap().get("key")).isNull();
assertThat(headerAccessor.getNativeHeader("key")).isEqualTo(Arrays.asList("value"));
}
@Test
@@ -118,9 +113,9 @@ public class SimpMessagingTemplateTests {
SimpMessageHeaderAccessor headerAccessor =
MessageHeaderAccessor.getAccessor(messages.get(0), SimpMessageHeaderAccessor.class);
assertNotNull(headerAccessor);
assertEquals("value", headerAccessor.toMap().get("key"));
assertNull(headerAccessor.getNativeHeader("key"));
assertThat(headerAccessor).isNotNull();
assertThat(headerAccessor.toMap().get("key")).isEqualTo("value");
assertThat(headerAccessor.getNativeHeader("key")).isNull();
}
// SPR-11868
@@ -131,15 +126,15 @@ public class SimpMessagingTemplateTests {
this.messagingTemplate.convertAndSendToUser("joe", "/queue/foo", "data");
List<Message<byte[]>> messages = this.messageChannel.getMessages();
assertEquals(1, messages.size());
assertThat(messages.size()).isEqualTo(1);
Message<byte[]> message = messages.get(0);
SimpMessageHeaderAccessor headerAccessor =
MessageHeaderAccessor.getAccessor(message, SimpMessageHeaderAccessor.class);
assertNotNull(headerAccessor);
assertEquals(SimpMessageType.MESSAGE, headerAccessor.getMessageType());
assertEquals("/prefix/joe/queue/foo", headerAccessor.getDestination());
assertThat(headerAccessor).isNotNull();
assertThat(headerAccessor.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
assertThat(headerAccessor.getDestination()).isEqualTo("/prefix/joe/queue/foo");
}
@Test
@@ -155,22 +150,22 @@ public class SimpMessagingTemplateTests {
List<Message<byte[]>> messages = this.messageChannel.getMessages();
Message<byte[]> message = messages.get(0);
assertSame(headers, message.getHeaders());
assertFalse(accessor.isMutable());
assertThat(message.getHeaders()).isSameAs(headers);
assertThat(accessor.isMutable()).isFalse();
}
@Test
public void processHeadersToSend() {
Map<String, Object> map = this.messagingTemplate.processHeadersToSend(null);
assertNotNull(map);
assertTrue("Actual: " + map.getClass().toString(), MessageHeaders.class.isAssignableFrom(map.getClass()));
assertThat(map).isNotNull();
assertThat(MessageHeaders.class.isAssignableFrom(map.getClass())).as("Actual: " + map.getClass().toString()).isTrue();
SimpMessageHeaderAccessor headerAccessor =
MessageHeaderAccessor.getAccessor((MessageHeaders) map, SimpMessageHeaderAccessor.class);
assertTrue(headerAccessor.isMutable());
assertEquals(SimpMessageType.MESSAGE, headerAccessor.getMessageType());
assertThat(headerAccessor.isMutable()).isTrue();
assertThat(headerAccessor.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
}
@Test
@@ -187,8 +182,8 @@ public class SimpMessagingTemplateTests {
List<Message<byte[]>> messages = this.messageChannel.getMessages();
Message<byte[]> sentMessage = messages.get(0);
assertSame(message, sentMessage);
assertFalse(accessor.isMutable());
assertThat(sentMessage).isSameAs(message);
assertThat(accessor.isMutable()).isFalse();
}
@Test
@@ -203,8 +198,8 @@ public class SimpMessagingTemplateTests {
Message<byte[]> sentMessage = messages.get(0);
MessageHeaderAccessor sentAccessor = MessageHeaderAccessor.getAccessor(sentMessage, MessageHeaderAccessor.class);
assertEquals(StompHeaderAccessor.class, sentAccessor.getClass());
assertEquals("/queue/foo-user123", ((StompHeaderAccessor) sentAccessor).getDestination());
assertThat(sentAccessor.getClass()).isEqualTo(StompHeaderAccessor.class);
assertThat(((StompHeaderAccessor) sentAccessor).getDestination()).isEqualTo("/queue/foo-user123");
}
}

146
spring-messaging/src/test/java/org/springframework/messaging/simp/annotation/support/SendToMethodReturnValueHandlerTests.java
View File

@@ -54,11 +54,7 @@ import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.util.MimeType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
@@ -136,18 +132,18 @@ public class SendToMethodReturnValueHandlerTests {
@Test
public void supportsReturnType() throws Exception {
assertTrue(this.handler.supportsReturnType(this.sendToReturnType));
assertTrue(this.handler.supportsReturnType(this.sendToUserReturnType));
assertFalse(this.handler.supportsReturnType(this.noAnnotationsReturnType));
assertTrue(this.handlerAnnotationNotRequired.supportsReturnType(this.noAnnotationsReturnType));
assertThat(this.handler.supportsReturnType(this.sendToReturnType)).isTrue();
assertThat(this.handler.supportsReturnType(this.sendToUserReturnType)).isTrue();
assertThat(this.handler.supportsReturnType(this.noAnnotationsReturnType)).isFalse();
assertThat(this.handlerAnnotationNotRequired.supportsReturnType(this.noAnnotationsReturnType)).isTrue();
assertTrue(this.handler.supportsReturnType(this.defaultNoAnnotation));
assertTrue(this.handler.supportsReturnType(this.defaultEmptyAnnotation));
assertTrue(this.handler.supportsReturnType(this.defaultOverrideAnnotation));
assertThat(this.handler.supportsReturnType(this.defaultNoAnnotation)).isTrue();
assertThat(this.handler.supportsReturnType(this.defaultEmptyAnnotation)).isTrue();
assertThat(this.handler.supportsReturnType(this.defaultOverrideAnnotation)).isTrue();
assertTrue(this.handler.supportsReturnType(this.userDefaultNoAnnotation));
assertTrue(this.handler.supportsReturnType(this.userDefaultEmptyAnnotation));
assertTrue(this.handler.supportsReturnType(this.userDefaultOverrideAnnotation));
assertThat(this.handler.supportsReturnType(this.userDefaultNoAnnotation)).isTrue();
assertThat(this.handler.supportsReturnType(this.userDefaultEmptyAnnotation)).isTrue();
assertThat(this.handler.supportsReturnType(this.userDefaultOverrideAnnotation)).isTrue();
}
@Test
@@ -299,11 +295,11 @@ public class SendToMethodReturnValueHandlerTests {
int index, String destination) {
SimpMessageHeaderAccessor accessor = getCapturedAccessor(index);
assertEquals(sessionId, accessor.getSessionId());
assertEquals(destination, accessor.getDestination());
assertEquals(MIME_TYPE, accessor.getContentType());
assertNull("Subscription id should not be copied", accessor.getSubscriptionId());
assertEquals(methodParameter, accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER));
assertThat(accessor.getSessionId()).isEqualTo(sessionId);
assertThat(accessor.getDestination()).isEqualTo(destination);
assertThat(accessor.getContentType()).isEqualTo(MIME_TYPE);
assertThat(accessor.getSubscriptionId()).as("Subscription id should not be copied").isNull();
assertThat(accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER)).isEqualTo(methodParameter);
}
@Test
@@ -316,7 +312,7 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(1)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor accessor = getCapturedAccessor(0);
assertEquals("/topic/dest.foo.bar", accessor.getDestination());
assertThat(accessor.getDestination()).isEqualTo("/topic/dest.foo.bar");
}
@Test
@@ -334,12 +330,11 @@ public class SendToMethodReturnValueHandlerTests {
MessageHeaders headers = captor.getValue();
SimpMessageHeaderAccessor accessor =
MessageHeaderAccessor.getAccessor(headers, SimpMessageHeaderAccessor.class);
assertNotNull(accessor);
assertTrue(accessor.isMutable());
assertEquals("sess1", accessor.getSessionId());
assertNull("Subscription id should not be copied", accessor.getSubscriptionId());
assertEquals(this.noAnnotationsReturnType,
accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER));
assertThat(accessor).isNotNull();
assertThat(accessor.isMutable()).isTrue();
assertThat(accessor.getSessionId()).isEqualTo("sess1");
assertThat(accessor.getSubscriptionId()).as("Subscription id should not be copied").isNull();
assertThat(accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER)).isEqualTo(this.noAnnotationsReturnType);
}
@Test
@@ -354,14 +349,14 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(2)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor accessor = getCapturedAccessor(0);
assertNull(accessor.getSessionId());
assertNull(accessor.getSubscriptionId());
assertEquals("/user/" + user.getName() + "/dest1", accessor.getDestination());
assertThat(accessor.getSessionId()).isNull();
assertThat(accessor.getSubscriptionId()).isNull();
assertThat(accessor.getDestination()).isEqualTo(("/user/" + user.getName() + "/dest1"));
accessor = getCapturedAccessor(1);
assertNull(accessor.getSessionId());
assertNull(accessor.getSubscriptionId());
assertEquals("/user/" + user.getName() + "/dest2", accessor.getDestination());
assertThat(accessor.getSessionId()).isNull();
assertThat(accessor.getSubscriptionId()).isNull();
assertThat(accessor.getDestination()).isEqualTo(("/user/" + user.getName() + "/dest2"));
}
@Test
@@ -376,24 +371,24 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(4)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor accessor = getCapturedAccessor(0);
assertNull(accessor.getSessionId());
assertNull(accessor.getSubscriptionId());
assertEquals("/user/" + user.getName() + "/dest1", accessor.getDestination());
assertThat(accessor.getSessionId()).isNull();
assertThat(accessor.getSubscriptionId()).isNull();
assertThat(accessor.getDestination()).isEqualTo(("/user/" + user.getName() + "/dest1"));
accessor = getCapturedAccessor(1);
assertNull(accessor.getSessionId());
assertNull(accessor.getSubscriptionId());
assertEquals("/user/" + user.getName() + "/dest2", accessor.getDestination());
assertThat(accessor.getSessionId()).isNull();
assertThat(accessor.getSubscriptionId()).isNull();
assertThat(accessor.getDestination()).isEqualTo(("/user/" + user.getName() + "/dest2"));
accessor = getCapturedAccessor(2);
assertEquals("sess1", accessor.getSessionId());
assertNull(accessor.getSubscriptionId());
assertEquals("/dest1", accessor.getDestination());
assertThat(accessor.getSessionId()).isEqualTo("sess1");
assertThat(accessor.getSubscriptionId()).isNull();
assertThat(accessor.getDestination()).isEqualTo("/dest1");
accessor = getCapturedAccessor(3);
assertEquals("sess1", accessor.getSessionId());
assertNull(accessor.getSubscriptionId());
assertEquals("/dest2", accessor.getDestination());
assertThat(accessor.getSessionId()).isEqualTo("sess1");
assertThat(accessor.getSubscriptionId()).isNull();
assertThat(accessor.getDestination()).isEqualTo("/dest2");
}
@Test // SPR-12170
@@ -414,8 +409,8 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(1)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor actual = getCapturedAccessor(0);
assertEquals(sessionId, actual.getSessionId());
assertEquals("/topic/chat.message.filtered.roomA", actual.getDestination());
assertThat(actual.getSessionId()).isEqualTo(sessionId);
assertThat(actual.getDestination()).isEqualTo("/topic/chat.message.filtered.roomA");
}
@Test
@@ -430,20 +425,18 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(2)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor accessor = getCapturedAccessor(0);
assertEquals(sessionId, accessor.getSessionId());
assertEquals(MIME_TYPE, accessor.getContentType());
assertEquals("/user/" + user.getName() + "/dest1", accessor.getDestination());
assertNull("Subscription id should not be copied", accessor.getSubscriptionId());
assertEquals(this.sendToUserInSessionReturnType,
accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER));
assertThat(accessor.getSessionId()).isEqualTo(sessionId);
assertThat(accessor.getContentType()).isEqualTo(MIME_TYPE);
assertThat(accessor.getDestination()).isEqualTo(("/user/" + user.getName() + "/dest1"));
assertThat(accessor.getSubscriptionId()).as("Subscription id should not be copied").isNull();
assertThat(accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER)).isEqualTo(this.sendToUserInSessionReturnType);
accessor = getCapturedAccessor(1);
assertEquals(sessionId, accessor.getSessionId());
assertEquals("/user/" + user.getName() + "/dest2", accessor.getDestination());
assertEquals(MIME_TYPE, accessor.getContentType());
assertNull("Subscription id should not be copied", accessor.getSubscriptionId());
assertEquals(this.sendToUserInSessionReturnType,
accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER));
assertThat(accessor.getSessionId()).isEqualTo(sessionId);
assertThat(accessor.getDestination()).isEqualTo(("/user/" + user.getName() + "/dest2"));
assertThat(accessor.getContentType()).isEqualTo(MIME_TYPE);
assertThat(accessor.getSubscriptionId()).as("Subscription id should not be copied").isNull();
assertThat(accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER)).isEqualTo(this.sendToUserInSessionReturnType);
}
@Test
@@ -458,10 +451,10 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(2)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor accessor = getCapturedAccessor(0);
assertEquals("/user/Me myself and I/dest1", accessor.getDestination());
assertThat(accessor.getDestination()).isEqualTo("/user/Me myself and I/dest1");
accessor = getCapturedAccessor(1);
assertEquals("/user/Me myself and I/dest2", accessor.getDestination());
assertThat(accessor.getDestination()).isEqualTo("/user/Me myself and I/dest2");
}
@Test
@@ -476,9 +469,9 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(1)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor accessor = getCapturedAccessor(0);
assertNull(accessor.getSessionId());
assertNull(accessor.getSubscriptionId());
assertEquals("/user/" + user.getName() + "/queue/dest", accessor.getDestination());
assertThat(accessor.getSessionId()).isNull();
assertThat(accessor.getSubscriptionId()).isNull();
assertThat(accessor.getDestination()).isEqualTo(("/user/" + user.getName() + "/queue/dest"));
}
@Test
@@ -492,7 +485,7 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(1)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor accessor = getCapturedAccessor(0);
assertEquals("/user/" + user.getName() + "/queue/dest.foo.bar", accessor.getDestination());
assertThat(accessor.getDestination()).isEqualTo(("/user/" + user.getName() + "/queue/dest.foo.bar"));
}
@Test
@@ -507,12 +500,11 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(1)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor accessor = getCapturedAccessor(0);
assertEquals(sessionId, accessor.getSessionId());
assertEquals("/user/" + user.getName() + "/queue/dest", accessor.getDestination());
assertEquals(MIME_TYPE, accessor.getContentType());
assertNull("Subscription id should not be copied", accessor.getSubscriptionId());
assertEquals(this.sendToUserInSessionDefaultDestReturnType,
accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER));
assertThat(accessor.getSessionId()).isEqualTo(sessionId);
assertThat(accessor.getDestination()).isEqualTo(("/user/" + user.getName() + "/queue/dest"));
assertThat(accessor.getContentType()).isEqualTo(MIME_TYPE);
assertThat(accessor.getSubscriptionId()).as("Subscription id should not be copied").isNull();
assertThat(accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER)).isEqualTo(this.sendToUserInSessionDefaultDestReturnType);
}
@Test
@@ -526,12 +518,12 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel, times(2)).send(this.messageCaptor.capture());
SimpMessageHeaderAccessor accessor = getCapturedAccessor(0);
assertEquals("/user/sess1/dest1", accessor.getDestination());
assertEquals("sess1", accessor.getSessionId());
assertThat(accessor.getDestination()).isEqualTo("/user/sess1/dest1");
assertThat(accessor.getSessionId()).isEqualTo("sess1");
accessor = getCapturedAccessor(1);
assertEquals("/user/sess1/dest2", accessor.getDestination());
assertEquals("sess1", accessor.getSessionId());
assertThat(accessor.getDestination()).isEqualTo("/user/sess1/dest2");
assertThat(accessor.getSessionId()).isEqualTo("sess1");
}
@Test
@@ -544,10 +536,10 @@ public class SendToMethodReturnValueHandlerTests {
verify(this.messageChannel).send(this.messageCaptor.capture());
Message<?> message = this.messageCaptor.getValue();
assertNotNull(message);
assertThat(message).isNotNull();
String bytes = new String((byte[]) message.getPayload(), StandardCharsets.UTF_8);
assertEquals("{\"withView1\":\"with\"}", bytes);
assertThat(bytes).isEqualTo("{\"withView1\":\"with\"}");
}

92
spring-messaging/src/test/java/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandlerTests.java
View File

@@ -68,10 +68,6 @@ import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.never;
@@ -128,9 +124,9 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("headers", this.testController.method);
assertEquals("bar", this.testController.arguments.get("foo"));
assertEquals("bar", ((Map<String, Object>) this.testController.arguments.get("headers")).get("foo"));
assertThat(this.testController.method).isEqualTo("headers");
assertThat(this.testController.arguments.get("foo")).isEqualTo("bar");
assertThat(((Map<String, Object>) this.testController.arguments.get("headers")).get("foo")).isEqualTo("bar");
}
@Test
@@ -140,9 +136,9 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("optionalHeaders", this.testController.method);
assertEquals("bar", this.testController.arguments.get("foo1"));
assertEquals("bar", this.testController.arguments.get("foo2"));
assertThat(this.testController.method).isEqualTo("optionalHeaders");
assertThat(this.testController.arguments.get("foo1")).isEqualTo("bar");
assertThat(this.testController.arguments.get("foo2")).isEqualTo("bar");
}
@Test
@@ -151,9 +147,9 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("optionalHeaders", this.testController.method);
assertNull(this.testController.arguments.get("foo1"));
assertNull(this.testController.arguments.get("foo2"));
assertThat(this.testController.method).isEqualTo("optionalHeaders");
assertThat(this.testController.arguments.get("foo1")).isNull();
assertThat(this.testController.arguments.get("foo2")).isNull();
}
@Test
@@ -162,9 +158,9 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("messageMappingDestinationVariable", this.testController.method);
assertEquals("bar", this.testController.arguments.get("foo"));
assertEquals("value", this.testController.arguments.get("name"));
assertThat(this.testController.method).isEqualTo("messageMappingDestinationVariable");
assertThat(this.testController.arguments.get("foo")).isEqualTo("bar");
assertThat(this.testController.arguments.get("name")).isEqualTo("value");
}
@Test
@@ -173,9 +169,9 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("subscribeEventDestinationVariable", this.testController.method);
assertEquals("bar", this.testController.arguments.get("foo"));
assertEquals("value", this.testController.arguments.get("name"));
assertThat(this.testController.method).isEqualTo("subscribeEventDestinationVariable");
assertThat(this.testController.arguments.get("foo")).isEqualTo("bar");
assertThat(this.testController.arguments.get("name")).isEqualTo("value");
}
@Test
@@ -184,9 +180,9 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("simpleBinding", this.testController.method);
assertTrue("should be bound to type long", this.testController.arguments.get("id") instanceof Long);
assertEquals(12L, this.testController.arguments.get("id"));
assertThat(this.testController.method).isEqualTo("simpleBinding");
assertThat(this.testController.arguments.get("id") instanceof Long).as("should be bound to type long").isTrue();
assertThat(this.testController.arguments.get("id")).isEqualTo(12L);
}
@Test
@@ -195,7 +191,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("handleValidationException", this.testController.method);
assertThat(this.testController.method).isEqualTo("handleValidationException");
}
@Test
@@ -204,10 +200,10 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("handleExceptionWithHandlerMethodArg", this.testController.method);
assertThat(this.testController.method).isEqualTo("handleExceptionWithHandlerMethodArg");
HandlerMethod handlerMethod = (HandlerMethod) this.testController.arguments.get("handlerMethod");
assertNotNull(handlerMethod);
assertEquals("illegalState", handlerMethod.getMethod().getName());
assertThat(handlerMethod).isNotNull();
assertThat(handlerMethod.getMethod().getName()).isEqualTo("illegalState");
}
@Test
@@ -216,10 +212,10 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("handleExceptionWithHandlerMethodArg", this.testController.method);
assertThat(this.testController.method).isEqualTo("handleExceptionWithHandlerMethodArg");
HandlerMethod handlerMethod = (HandlerMethod) this.testController.arguments.get("handlerMethod");
assertNotNull(handlerMethod);
assertEquals("illegalStateCause", handlerMethod.getMethod().getName());
assertThat(handlerMethod).isNotNull();
assertThat(handlerMethod.getMethod().getName()).isEqualTo("illegalStateCause");
}
@Test
@@ -228,10 +224,10 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("handleErrorWithHandlerMethodArg", this.testController.method);
assertThat(this.testController.method).isEqualTo("handleErrorWithHandlerMethodArg");
HandlerMethod handlerMethod = (HandlerMethod) this.testController.arguments.get("handlerMethod");
assertNotNull(handlerMethod);
assertEquals("errorAsThrowable", handlerMethod.getMethod().getName());
assertThat(handlerMethod).isNotNull();
assertThat(handlerMethod.getMethod().getName()).isEqualTo("errorAsThrowable");
}
@Test
@@ -247,7 +243,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("scope", this.testController.method);
assertThat(this.testController.method).isEqualTo("scope");
}
@Test
@@ -262,12 +258,12 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("handleFoo", controller.method);
assertThat(controller.method).isEqualTo("handleFoo");
message = createMessage("/app2/pre.foo");
this.messageHandler.handleMessage(message);
assertEquals("handleFoo", controller.method);
assertThat(controller.method).isEqualTo("handleFoo");
}
@Test
@@ -284,10 +280,10 @@ public class SimpAnnotationMethodMessageHandlerTests {
Message<?> message = createMessage("/app1/listenable-future/success");
this.messageHandler.handleMessage(message);
assertNotNull(controller.future);
assertThat(controller.future).isNotNull();
controller.future.run();
verify(this.converter).toMessage(this.payloadCaptor.capture(), any(MessageHeaders.class));
assertEquals("foo", this.payloadCaptor.getValue());
assertThat(this.payloadCaptor.getValue()).isEqualTo("foo");
}
@Test
@@ -305,7 +301,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.handleMessage(message);
controller.future.run();
assertTrue(controller.exceptionCaught);
assertThat(controller.exceptionCaught).isTrue();
}
@Test
@@ -322,10 +318,10 @@ public class SimpAnnotationMethodMessageHandlerTests {
Message<?> message = createMessage("/app1/completable-future");
this.messageHandler.handleMessage(message);
assertNotNull(controller.future);
assertThat(controller.future).isNotNull();
controller.future.complete("foo");
verify(this.converter).toMessage(this.payloadCaptor.capture(), any(MessageHeaders.class));
assertEquals("foo", this.payloadCaptor.getValue());
assertThat(this.payloadCaptor.getValue()).isEqualTo("foo");
}
@Test
@@ -343,7 +339,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.handleMessage(message);
controller.future.completeExceptionally(new IllegalStateException());
assertTrue(controller.exceptionCaught);
assertThat(controller.exceptionCaught).isTrue();
}
@Test
@@ -360,10 +356,10 @@ public class SimpAnnotationMethodMessageHandlerTests {
Message<?> message = createMessage("/app1/mono");
this.messageHandler.handleMessage(message);
assertNotNull(controller.mono);
assertThat(controller.mono).isNotNull();
controller.mono.onNext("foo");
verify(this.converter).toMessage(this.payloadCaptor.capture(), any(MessageHeaders.class));
assertEquals("foo", this.payloadCaptor.getValue());
assertThat(this.payloadCaptor.getValue()).isEqualTo("foo");
}
@Test
@@ -381,7 +377,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.handleMessage(message);
controller.mono.onError(new IllegalStateException());
assertTrue(controller.exceptionCaught);
assertThat(controller.exceptionCaught).isTrue();
}
@Test
@@ -398,7 +394,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
Message<?> message = createMessage("/app1/flux");
this.messageHandler.handleMessage(message);
assertNotNull(controller.flux);
assertThat(controller.flux).isNotNull();
controller.flux.onNext("foo");
verify(this.converter, never()).toMessage(any(), any(MessageHeaders.class));
@@ -411,7 +407,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.registerHandler(this.testController);
this.messageHandler.handleMessage(message);
assertEquals("placeholder", this.testController.method);
assertThat(this.testController.method).isEqualTo("placeholder");
}
@@ -525,14 +521,14 @@ public class SimpAnnotationMethodMessageHandlerTests {
public void handleExceptionWithHandlerMethodArg(IllegalStateException ex, HandlerMethod handlerMethod) {
this.method = "handleExceptionWithHandlerMethodArg";
this.arguments.put("handlerMethod", handlerMethod);
assertEquals("my cause", ex.getMessage());
assertThat(ex.getMessage()).isEqualTo("my cause");
}
@MessageExceptionHandler
public void handleErrorWithHandlerMethodArg(Error ex, HandlerMethod handlerMethod) {
this.method = "handleErrorWithHandlerMethodArg";
this.arguments.put("handlerMethod", handlerMethod);
assertEquals("my cause", ex.getMessage());
assertThat(ex.getMessage()).isEqualTo("my cause");
}
@MessageMapping("/scope")

42
spring-messaging/src/test/java/org/springframework/messaging/simp/annotation/support/SubscriptionMethodReturnValueHandlerTests.java
View File

@@ -45,11 +45,7 @@ import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.util.MimeType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
@@ -113,9 +109,9 @@ public class SubscriptionMethodReturnValueHandlerTests {
@Test
public void supportsReturnType() throws Exception {
assertTrue(this.handler.supportsReturnType(this.subscribeEventReturnType));
assertFalse(this.handler.supportsReturnType(this.subscribeEventSendToReturnType));
assertFalse(this.handler.supportsReturnType(this.messageMappingReturnType));
assertThat(this.handler.supportsReturnType(this.subscribeEventReturnType)).isTrue();
assertThat(this.handler.supportsReturnType(this.subscribeEventSendToReturnType)).isFalse();
assertThat(this.handler.supportsReturnType(this.messageMappingReturnType)).isFalse();
}
@Test
@@ -130,18 +126,18 @@ public class SubscriptionMethodReturnValueHandlerTests {
this.handler.handleReturnValue(PAYLOAD, this.subscribeEventReturnType, inputMessage);
verify(this.messageChannel).send(this.messageCaptor.capture());
assertNotNull(this.messageCaptor.getValue());
assertThat(this.messageCaptor.getValue()).isNotNull();
Message<?> message = this.messageCaptor.getValue();
SimpMessageHeaderAccessor headerAccessor = SimpMessageHeaderAccessor.wrap(message);
assertNull("SimpMessageHeaderAccessor should have disabled id", headerAccessor.getId());
assertNull("SimpMessageHeaderAccessor should have disabled timestamp", headerAccessor.getTimestamp());
assertEquals(sessionId, headerAccessor.getSessionId());
assertEquals(subscriptionId, headerAccessor.getSubscriptionId());
assertEquals(destination, headerAccessor.getDestination());
assertEquals(MIME_TYPE, headerAccessor.getContentType());
assertEquals(this.subscribeEventReturnType, headerAccessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER));
assertThat(headerAccessor.getId()).as("SimpMessageHeaderAccessor should have disabled id").isNull();
assertThat(headerAccessor.getTimestamp()).as("SimpMessageHeaderAccessor should have disabled timestamp").isNull();
assertThat(headerAccessor.getSessionId()).isEqualTo(sessionId);
assertThat(headerAccessor.getSubscriptionId()).isEqualTo(subscriptionId);
assertThat(headerAccessor.getDestination()).isEqualTo(destination);
assertThat(headerAccessor.getContentType()).isEqualTo(MIME_TYPE);
assertThat(headerAccessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER)).isEqualTo(this.subscribeEventReturnType);
}
@Test
@@ -163,11 +159,11 @@ public class SubscriptionMethodReturnValueHandlerTests {
SimpMessageHeaderAccessor headerAccessor =
MessageHeaderAccessor.getAccessor(captor.getValue(), SimpMessageHeaderAccessor.class);
assertNotNull(headerAccessor);
assertTrue(headerAccessor.isMutable());
assertEquals(sessionId, headerAccessor.getSessionId());
assertEquals(subscriptionId, headerAccessor.getSubscriptionId());
assertEquals(this.subscribeEventReturnType, headerAccessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER));
assertThat(headerAccessor).isNotNull();
assertThat(headerAccessor.isMutable()).isTrue();
assertThat(headerAccessor.getSessionId()).isEqualTo(sessionId);
assertThat(headerAccessor.getSubscriptionId()).isEqualTo(subscriptionId);
assertThat(headerAccessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER)).isEqualTo(this.subscribeEventReturnType);
}
@Test
@@ -183,9 +179,9 @@ public class SubscriptionMethodReturnValueHandlerTests {
verify(this.messageChannel).send(this.messageCaptor.capture());
Message<?> message = this.messageCaptor.getValue();
assertNotNull(message);
assertThat(message).isNotNull();
assertEquals("{\"withView1\":\"with\"}", new String((byte[]) message.getPayload(), StandardCharsets.UTF_8));
assertThat(new String((byte[]) message.getPayload(), StandardCharsets.UTF_8)).isEqualTo("{\"withView1\":\"with\"}");
}

34
spring-messaging/src/test/java/org/springframework/messaging/simp/broker/BrokerMessageHandlerTests.java
View File

@@ -32,9 +32,7 @@ import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.SubscribableChannel;
import org.springframework.messaging.support.GenericMessage;
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 static org.mockito.Mockito.mock;
/**
@@ -56,44 +54,44 @@ public class BrokerMessageHandlerTests {
@Test
public void startShouldUpdateIsRunning() {
assertFalse(this.handler.isRunning());
assertThat(this.handler.isRunning()).isFalse();
this.handler.start();
assertTrue(this.handler.isRunning());
assertThat(this.handler.isRunning()).isTrue();
}
@Test
public void stopShouldUpdateIsRunning() {
this.handler.start();
assertTrue(this.handler.isRunning());
assertThat(this.handler.isRunning()).isTrue();
this.handler.stop();
assertFalse(this.handler.isRunning());
assertThat(this.handler.isRunning()).isFalse();
}
@Test
public void startAndStopShouldNotPublishBrokerAvailabilityEvents() {
this.handler.start();
this.handler.stop();
assertEquals(Collections.emptyList(), this.handler.availabilityEvents);
assertThat(this.handler.availabilityEvents).isEqualTo(Collections.emptyList());
}
@Test
public void handleMessageWhenBrokerNotRunning() {
this.handler.handleMessage(new GenericMessage<Object>("payload"));
assertEquals(Collections.emptyList(), this.handler.messages);
assertThat(this.handler.messages).isEqualTo(Collections.emptyList());
}
@Test
public void publishBrokerAvailableEvent() {
assertFalse(this.handler.isBrokerAvailable());
assertEquals(Collections.emptyList(), this.handler.availabilityEvents);
assertThat(this.handler.isBrokerAvailable()).isFalse();
assertThat(this.handler.availabilityEvents).isEqualTo(Collections.emptyList());
this.handler.publishBrokerAvailableEvent();
assertTrue(this.handler.isBrokerAvailable());
assertEquals(Arrays.asList(true), this.handler.availabilityEvents);
assertThat(this.handler.isBrokerAvailable()).isTrue();
assertThat(this.handler.availabilityEvents).isEqualTo(Arrays.asList(true));
}
@Test
@@ -102,19 +100,19 @@ public class BrokerMessageHandlerTests {
this.handler.publishBrokerAvailableEvent();
this.handler.publishBrokerAvailableEvent();
assertEquals(Arrays.asList(true), this.handler.availabilityEvents);
assertThat(this.handler.availabilityEvents).isEqualTo(Arrays.asList(true));
}
@Test
public void publishBrokerUnavailableEvent() {
this.handler.publishBrokerAvailableEvent();
assertTrue(this.handler.isBrokerAvailable());
assertThat(this.handler.isBrokerAvailable()).isTrue();
this.handler.publishBrokerUnavailableEvent();
assertFalse(this.handler.isBrokerAvailable());
assertThat(this.handler.isBrokerAvailable()).isFalse();
assertEquals(Arrays.asList(true, false), this.handler.availabilityEvents);
assertThat(this.handler.availabilityEvents).isEqualTo(Arrays.asList(true, false));
}
@Test
@@ -124,7 +122,7 @@ public class BrokerMessageHandlerTests {
this.handler.publishBrokerUnavailableEvent();
this.handler.publishBrokerUnavailableEvent();
assertEquals(Arrays.asList(true, false), this.handler.availabilityEvents);
assertThat(this.handler.availabilityEvents).isEqualTo(Arrays.asList(true, false));
}

171
spring-messaging/src/test/java/org/springframework/messaging/simp/broker/DefaultSubscriptionRegistryTests.java
View File

@@ -30,8 +30,7 @@ import org.springframework.messaging.simp.SimpMessageType;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.MultiValueMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Test fixture for
@@ -53,18 +52,18 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(null, subsId, dest));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertNotNull(actual);
assertEquals(0, actual.size());
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(0);
this.registry.registerSubscription(subscribeMessage(sessId, null, dest));
actual = this.registry.findSubscriptions(createMessage(dest));
assertNotNull(actual);
assertEquals(0, actual.size());
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(0);
this.registry.registerSubscription(subscribeMessage(sessId, subsId, null));
actual = this.registry.findSubscriptions(createMessage(dest));
assertNotNull(actual);
assertEquals(0, actual.size());
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(0);
}
@Test
@@ -76,9 +75,9 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sessId, subsId, dest));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertNotNull(actual);
assertEquals("Expected one element " + actual, 1, actual.size());
assertEquals(Collections.singletonList(subsId), actual.get(sessId));
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected one element " + actual).isEqualTo(1);
assertThat(actual.get(sessId)).isEqualTo(Collections.singletonList(subsId));
}
@Test
@@ -92,9 +91,9 @@ public class DefaultSubscriptionRegistryTests {
}
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertNotNull(actual);
assertEquals(1, actual.size());
assertEquals(subscriptionIds, sort(actual.get(sessId)));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(1);
assertThat(sort(actual.get(sessId))).isEqualTo(subscriptionIds);
}
@Test
@@ -110,11 +109,11 @@ public class DefaultSubscriptionRegistryTests {
}
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertNotNull(actual);
assertEquals(3, actual.size());
assertEquals(subscriptionIds, sort(actual.get(sessIds.get(0))));
assertEquals(subscriptionIds, sort(actual.get(sessIds.get(1))));
assertEquals(subscriptionIds, sort(actual.get(sessIds.get(2))));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(3);
assertThat(sort(actual.get(sessIds.get(0)))).isEqualTo(subscriptionIds);
assertThat(sort(actual.get(sessIds.get(1)))).isEqualTo(subscriptionIds);
assertThat(sort(actual.get(sessIds.get(2)))).isEqualTo(subscriptionIds);
}
@Test
@@ -126,9 +125,9 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sessId, subsId, destPattern));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertNotNull(actual);
assertEquals("Expected one element " + actual, 1, actual.size());
assertEquals(Collections.singletonList(subsId), actual.get(sessId));
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected one element " + actual).isEqualTo(1);
assertThat(actual.get(sessId)).isEqualTo(Collections.singletonList(subsId));
}
@Test // SPR-11657
@@ -147,56 +146,56 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sess1, subs1, "/topic/PRICE.STOCK.*.IBM"));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertNotNull(actual);
assertEquals(1, actual.size());
assertEquals(Arrays.asList(subs2, subs1), actual.get(sess1));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(1);
assertThat(actual.get(sess1)).isEqualTo(Arrays.asList(subs2, subs1));
this.registry.registerSubscription(subscribeMessage(sess2, subs1, destNasdaqIbm));
this.registry.registerSubscription(subscribeMessage(sess2, subs2, "/topic/PRICE.STOCK.NYSE.IBM"));
this.registry.registerSubscription(subscribeMessage(sess2, subs3, "/topic/PRICE.STOCK.NASDAQ.GOOG"));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertNotNull(actual);
assertEquals(2, actual.size());
assertEquals(Arrays.asList(subs2, subs1), actual.get(sess1));
assertEquals(Collections.singletonList(subs1), actual.get(sess2));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(2);
assertThat(actual.get(sess1)).isEqualTo(Arrays.asList(subs2, subs1));
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
this.registry.unregisterAllSubscriptions(sess1);
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertNotNull(actual);
assertEquals(1, actual.size());
assertEquals(Collections.singletonList(subs1), actual.get(sess2));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(1);
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
this.registry.registerSubscription(subscribeMessage(sess1, subs1, "/topic/PRICE.STOCK.*.IBM"));
this.registry.registerSubscription(subscribeMessage(sess1, subs2, destNasdaqIbm));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertNotNull(actual);
assertEquals(2, actual.size());
assertEquals(Arrays.asList(subs1, subs2), actual.get(sess1));
assertEquals(Collections.singletonList(subs1), actual.get(sess2));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(2);
assertThat(actual.get(sess1)).isEqualTo(Arrays.asList(subs1, subs2));
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
this.registry.unregisterSubscription(unsubscribeMessage(sess1, subs2));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertNotNull(actual);
assertEquals(2, actual.size());
assertEquals(Collections.singletonList(subs1), actual.get(sess1));
assertEquals(Collections.singletonList(subs1), actual.get(sess2));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(2);
assertThat(actual.get(sess1)).isEqualTo(Collections.singletonList(subs1));
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
this.registry.unregisterSubscription(unsubscribeMessage(sess1, subs1));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertNotNull(actual);
assertEquals(1, actual.size());
assertEquals(Collections.singletonList(subs1), actual.get(sess2));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(1);
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
this.registry.unregisterSubscription(unsubscribeMessage(sess2, subs1));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertNotNull(actual);
assertEquals(0, actual.size());
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(0);
}
@Test // SPR-11755
@@ -241,20 +240,20 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sessId, subsId, destPattern));
Message<?> message = createMessage("/topic/PRICE.STOCK.NASDAQ.IBM");
MultiValueMap<String, String> actual = this.registry.findSubscriptions(message);
assertNotNull(actual);
assertEquals("Expected one element " + actual, 1, actual.size());
assertEquals(Collections.singletonList(subsId), actual.get(sessId));
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected one element " + actual).isEqualTo(1);
assertThat(actual.get(sessId)).isEqualTo(Collections.singletonList(subsId));
message = createMessage("/topic/PRICE.STOCK.NASDAQ.MSFT");
actual = this.registry.findSubscriptions(message);
assertNotNull(actual);
assertEquals("Expected one element " + actual, 1, actual.size());
assertEquals(Collections.singletonList(subsId), actual.get(sessId));
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected one element " + actual).isEqualTo(1);
assertThat(actual.get(sessId)).isEqualTo(Collections.singletonList(subsId));
message = createMessage("/topic/PRICE.STOCK.NASDAQ.VMW");
actual = this.registry.findSubscriptions(message);
assertNotNull(actual);
assertEquals("Expected no elements " + actual, 0, actual.size());
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected no elements " + actual).isEqualTo(0);
}
@Test
@@ -274,15 +273,15 @@ public class DefaultSubscriptionRegistryTests {
Message<?> message = MessageBuilder.createMessage("", accessor.getMessageHeaders());
MultiValueMap<String, String> actual = this.registry.findSubscriptions(message);
assertNotNull(actual);
assertEquals(1, actual.size());
assertEquals(Collections.singletonList(subscriptionId), actual.get(sessionId));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(1);
assertThat(actual.get(sessionId)).isEqualTo(Collections.singletonList(subscriptionId));
// Then without
actual = this.registry.findSubscriptions(createMessage(destination));
assertNotNull(actual);
assertEquals(0, actual.size());
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(0);
}
@Test
@@ -301,9 +300,9 @@ public class DefaultSubscriptionRegistryTests {
Message<?> message = MessageBuilder.createMessage("", accessor.getMessageHeaders());
MultiValueMap<String, String> actual = this.registry.findSubscriptions(message);
assertNotNull(actual);
assertEquals(1, actual.size());
assertEquals(Collections.singletonList(subscriptionId), actual.get(sessionId));
assertThat(actual).isNotNull();
assertThat(actual.size()).isEqualTo(1);
assertThat(actual.get(sessionId)).isEqualTo(Collections.singletonList(subscriptionId));
}
@Test // SPR-11931
@@ -312,22 +311,22 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage("sess01", "subs02", "/foo"));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage("/foo"));
assertNotNull(actual);
assertEquals("Expected 1 element", 1, actual.size());
assertEquals(Arrays.asList("subs01", "subs02"), actual.get("sess01"));
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected 1 element").isEqualTo(1);
assertThat(actual.get("sess01")).isEqualTo(Arrays.asList("subs01", "subs02"));
this.registry.unregisterSubscription(unsubscribeMessage("sess01", "subs01"));
actual = this.registry.findSubscriptions(createMessage("/foo"));
assertNotNull(actual);
assertEquals("Expected 1 element", 1, actual.size());
assertEquals(Collections.singletonList("subs02"), actual.get("sess01"));
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected 1 element").isEqualTo(1);
assertThat(actual.get("sess01")).isEqualTo(Collections.singletonList("subs02"));
this.registry.unregisterSubscription(unsubscribeMessage("sess01", "subs02"));
actual = this.registry.findSubscriptions(createMessage("/foo"));
assertNotNull(actual);
assertEquals("Expected no element", 0, actual.size());
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected no element").isEqualTo(0);
}
@Test
@@ -347,10 +346,10 @@ public class DefaultSubscriptionRegistryTests {
this.registry.unregisterSubscription(unsubscribeMessage(sessIds.get(0), subscriptionIds.get(2)));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertNotNull(actual);
assertEquals("Expected two elements: " + actual, 2, actual.size());
assertEquals(subscriptionIds, sort(actual.get(sessIds.get(1))));
assertEquals(subscriptionIds, sort(actual.get(sessIds.get(2))));
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected two elements: " + actual).isEqualTo(2);
assertThat(sort(actual.get(sessIds.get(1)))).isEqualTo(subscriptionIds);
assertThat(sort(actual.get(sessIds.get(2)))).isEqualTo(subscriptionIds);
}
@Test
@@ -369,9 +368,9 @@ public class DefaultSubscriptionRegistryTests {
this.registry.unregisterAllSubscriptions(sessIds.get(1));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertNotNull(actual);
assertEquals("Expected one element: " + actual, 1, actual.size());
assertEquals(subscriptionIds, sort(actual.get(sessIds.get(2))));
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected one element: " + actual).isEqualTo(1);
assertThat(sort(actual.get(sessIds.get(2)))).isEqualTo(subscriptionIds);
}
@Test
@@ -383,8 +382,8 @@ public class DefaultSubscriptionRegistryTests {
@Test
public void findSubscriptionsNoMatches() {
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage("/foo"));
assertNotNull(actual);
assertEquals("Expected no elements " + actual, 0, actual.size());
assertThat(actual).isNotNull();
assertThat(actual.size()).as("Expected no elements " + actual).isEqualTo(0);
}
@Test // SPR-12665
@@ -393,8 +392,8 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage("sess2", "1", "/foo"));
MultiValueMap<String, String> subscriptions = this.registry.findSubscriptions(createMessage("/foo"));
assertNotNull(subscriptions);
assertEquals(2, subscriptions.size());
assertThat(subscriptions).isNotNull();
assertThat(subscriptions.size()).isEqualTo(2);
Iterator<Map.Entry<String, List<String>>> iterator = subscriptions.entrySet().iterator();
iterator.next();
@@ -411,8 +410,8 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage("sess1", "2", "/foo"));
MultiValueMap<String, String> allSubscriptions = this.registry.findSubscriptions(createMessage("/foo"));
assertNotNull(allSubscriptions);
assertEquals(1, allSubscriptions.size());
assertThat(allSubscriptions).isNotNull();
assertThat(allSubscriptions.size()).isEqualTo(1);
Iterator<String> iteratorValues = allSubscriptions.get("sess1").iterator();
iteratorValues.next();
@@ -429,14 +428,14 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage("sess1", "1", "/foo"));
this.registry.registerSubscription(subscribeMessage("sess1", "2", "/bar"));
assertEquals(1, this.registry.findSubscriptions(createMessage("/foo")).size());
assertEquals(1, this.registry.findSubscriptions(createMessage("/bar")).size());
assertThat(this.registry.findSubscriptions(createMessage("/foo")).size()).isEqualTo(1);
assertThat(this.registry.findSubscriptions(createMessage("/bar")).size()).isEqualTo(1);
this.registry.registerSubscription(subscribeMessage("sess2", "1", "/foo"));
this.registry.registerSubscription(subscribeMessage("sess2", "2", "/bar"));
assertEquals(2, this.registry.findSubscriptions(createMessage("/foo")).size());
assertEquals(2, this.registry.findSubscriptions(createMessage("/bar")).size());
assertThat(this.registry.findSubscriptions(createMessage("/foo")).size()).isEqualTo(2);
assertThat(this.registry.findSubscriptions(createMessage("/bar")).size()).isEqualTo(2);
}
private Message<?> createMessage(String destination) {

4
spring-messaging/src/test/java/org/springframework/messaging/simp/broker/OrderedMessageSenderTests.java
View File

@@ -33,7 +33,7 @@ import org.springframework.messaging.support.ExecutorSubscribableChannel;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link OrderedMessageSender}.
@@ -112,7 +112,7 @@ public class OrderedMessageSenderTests {
}
latch.await(10, TimeUnit.SECONDS);
assertEquals("Done", result.get());
assertThat(result.get()).isEqualTo("Done");
}
}

79
spring-messaging/src/test/java/org/springframework/messaging/simp/broker/SimpleBrokerMessageHandlerTests.java
View File

@@ -38,13 +38,8 @@ import org.springframework.messaging.simp.TestPrincipal;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.scheduling.TaskScheduler;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
@@ -107,12 +102,12 @@ public class SimpleBrokerMessageHandlerTests {
this.messageHandler.handleMessage(createMessage("/bar", "message2"));
verify(this.clientOutChannel, times(6)).send(this.messageCaptor.capture());
assertTrue(messageCaptured("sess1", "sub1", "/foo"));
assertTrue(messageCaptured("sess1", "sub2", "/foo"));
assertTrue(messageCaptured("sess2", "sub1", "/foo"));
assertTrue(messageCaptured("sess2", "sub2", "/foo"));
assertTrue(messageCaptured("sess1", "sub3", "/bar"));
assertTrue(messageCaptured("sess2", "sub3", "/bar"));
assertThat(messageCaptured("sess1", "sub1", "/foo")).isTrue();
assertThat(messageCaptured("sess1", "sub2", "/foo")).isTrue();
assertThat(messageCaptured("sess2", "sub1", "/foo")).isTrue();
assertThat(messageCaptured("sess2", "sub2", "/foo")).isTrue();
assertThat(messageCaptured("sess1", "sub3", "/bar")).isTrue();
assertThat(messageCaptured("sess2", "sub3", "/bar")).isTrue();
}
@Test
@@ -143,14 +138,14 @@ public class SimpleBrokerMessageHandlerTests {
verify(this.clientOutChannel, times(4)).send(this.messageCaptor.capture());
Message<?> captured = this.messageCaptor.getAllValues().get(2);
assertEquals(SimpMessageType.DISCONNECT_ACK, SimpMessageHeaderAccessor.getMessageType(captured.getHeaders()));
assertSame(message, captured.getHeaders().get(SimpMessageHeaderAccessor.DISCONNECT_MESSAGE_HEADER));
assertEquals(sess1, SimpMessageHeaderAccessor.getSessionId(captured.getHeaders()));
assertEquals("joe", SimpMessageHeaderAccessor.getUser(captured.getHeaders()).getName());
assertThat(SimpMessageHeaderAccessor.getMessageType(captured.getHeaders())).isEqualTo(SimpMessageType.DISCONNECT_ACK);
assertThat(captured.getHeaders().get(SimpMessageHeaderAccessor.DISCONNECT_MESSAGE_HEADER)).isSameAs(message);
assertThat(SimpMessageHeaderAccessor.getSessionId(captured.getHeaders())).isEqualTo(sess1);
assertThat(SimpMessageHeaderAccessor.getUser(captured.getHeaders()).getName()).isEqualTo("joe");
assertTrue(messageCaptured(sess2, "sub1", "/foo"));
assertTrue(messageCaptured(sess2, "sub2", "/foo"));
assertTrue(messageCaptured(sess2, "sub3", "/bar"));
assertThat(messageCaptured(sess2, "sub1", "/foo")).isTrue();
assertThat(messageCaptured(sess2, "sub2", "/foo")).isTrue();
assertThat(messageCaptured(sess2, "sub3", "/bar")).isTrue();
}
@Test
@@ -161,20 +156,19 @@ public class SimpleBrokerMessageHandlerTests {
Message<?> connectAckMessage = this.messageCaptor.getValue();
SimpMessageHeaderAccessor connectAckHeaders = SimpMessageHeaderAccessor.wrap(connectAckMessage);
assertEquals(connectMessage, connectAckHeaders.getHeader(SimpMessageHeaderAccessor.CONNECT_MESSAGE_HEADER));
assertEquals(id, connectAckHeaders.getSessionId());
assertEquals("joe", connectAckHeaders.getUser().getName());
assertArrayEquals(new long[] {10000, 10000},
SimpMessageHeaderAccessor.getHeartbeat(connectAckHeaders.getMessageHeaders()));
assertThat(connectAckHeaders.getHeader(SimpMessageHeaderAccessor.CONNECT_MESSAGE_HEADER)).isEqualTo(connectMessage);
assertThat(connectAckHeaders.getSessionId()).isEqualTo(id);
assertThat(connectAckHeaders.getUser().getName()).isEqualTo("joe");
assertThat(SimpMessageHeaderAccessor.getHeartbeat(connectAckHeaders.getMessageHeaders())).isEqualTo(new long[] {10000, 10000});
}
@Test
public void heartbeatValueWithAndWithoutTaskScheduler() {
assertNull(this.messageHandler.getHeartbeatValue());
assertThat(this.messageHandler.getHeartbeatValue()).isNull();
this.messageHandler.setTaskScheduler(this.taskScheduler);
assertNotNull(this.messageHandler.getHeartbeatValue());
assertArrayEquals(new long[] {10000, 10000}, this.messageHandler.getHeartbeatValue());
assertThat(this.messageHandler.getHeartbeatValue()).isNotNull();
assertThat(this.messageHandler.getHeartbeatValue()).isEqualTo(new long[] {10000, 10000});
}
@Test
@@ -222,7 +216,7 @@ public class SimpleBrokerMessageHandlerTests {
ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClass(Runnable.class);
verify(this.taskScheduler).scheduleWithFixedDelay(taskCaptor.capture(), eq(1L));
Runnable heartbeatTask = taskCaptor.getValue();
assertNotNull(heartbeatTask);
assertThat(heartbeatTask).isNotNull();
String id = "sess1";
TestPrincipal user = new TestPrincipal("joe");
@@ -234,14 +228,14 @@ public class SimpleBrokerMessageHandlerTests {
verify(this.clientOutChannel, atLeast(2)).send(this.messageCaptor.capture());
List<Message<?>> messages = this.messageCaptor.getAllValues();
assertEquals(2, messages.size());
assertThat(messages.size()).isEqualTo(2);
MessageHeaders headers = messages.get(0).getHeaders();
assertEquals(SimpMessageType.CONNECT_ACK, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
assertThat(headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.CONNECT_ACK);
headers = messages.get(1).getHeaders();
assertEquals(SimpMessageType.DISCONNECT_ACK, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
assertEquals(id, headers.get(SimpMessageHeaderAccessor.SESSION_ID_HEADER));
assertEquals(user, headers.get(SimpMessageHeaderAccessor.USER_HEADER));
assertThat(headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.DISCONNECT_ACK);
assertThat(headers.get(SimpMessageHeaderAccessor.SESSION_ID_HEADER)).isEqualTo(id);
assertThat(headers.get(SimpMessageHeaderAccessor.USER_HEADER)).isEqualTo(user);
}
@Test
@@ -253,7 +247,7 @@ public class SimpleBrokerMessageHandlerTests {
ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClass(Runnable.class);
verify(this.taskScheduler).scheduleWithFixedDelay(taskCaptor.capture(), eq(1L));
Runnable heartbeatTask = taskCaptor.getValue();
assertNotNull(heartbeatTask);
assertThat(heartbeatTask).isNotNull();
String id = "sess1";
TestPrincipal user = new TestPrincipal("joe");
@@ -265,14 +259,14 @@ public class SimpleBrokerMessageHandlerTests {
verify(this.clientOutChannel, times(2)).send(this.messageCaptor.capture());
List<Message<?>> messages = this.messageCaptor.getAllValues();
assertEquals(2, messages.size());
assertThat(messages.size()).isEqualTo(2);
MessageHeaders headers = messages.get(0).getHeaders();
assertEquals(SimpMessageType.CONNECT_ACK, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
assertThat(headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.CONNECT_ACK);
headers = messages.get(1).getHeaders();
assertEquals(SimpMessageType.HEARTBEAT, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
assertEquals(id, headers.get(SimpMessageHeaderAccessor.SESSION_ID_HEADER));
assertEquals(user, headers.get(SimpMessageHeaderAccessor.USER_HEADER));
assertThat(headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.HEARTBEAT);
assertThat(headers.get(SimpMessageHeaderAccessor.SESSION_ID_HEADER)).isEqualTo(id);
assertThat(headers.get(SimpMessageHeaderAccessor.USER_HEADER)).isEqualTo(user);
}
@Test
@@ -284,7 +278,7 @@ public class SimpleBrokerMessageHandlerTests {
ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClass(Runnable.class);
verify(this.taskScheduler).scheduleWithFixedDelay(taskCaptor.capture(), eq(1L));
Runnable heartbeatTask = taskCaptor.getValue();
assertNotNull(heartbeatTask);
assertThat(heartbeatTask).isNotNull();
String id = "sess1";
TestPrincipal user = new TestPrincipal("joe");
@@ -296,9 +290,8 @@ public class SimpleBrokerMessageHandlerTests {
verify(this.clientOutChannel, times(1)).send(this.messageCaptor.capture());
List<Message<?>> messages = this.messageCaptor.getAllValues();
assertEquals(1, messages.size());
assertEquals(SimpMessageType.CONNECT_ACK,
messages.get(0).getHeaders().get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
assertThat(messages.size()).isEqualTo(1);
assertThat(messages.get(0).getHeaders().get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.CONNECT_ACK);
}

154
spring-messaging/src/test/java/org/springframework/messaging/simp/config/MessageBrokerConfigurationTests.java
View File

@@ -77,12 +77,6 @@ import org.springframework.validation.Validator;
import org.springframework.validation.beanvalidation.OptionalValidatorFactoryBean;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
/**
@@ -101,10 +95,10 @@ public class MessageBrokerConfigurationTests {
TestChannel channel = context.getBean("clientInboundChannel", TestChannel.class);
Set<MessageHandler> handlers = channel.getSubscribers();
assertEquals(3, handlers.size());
assertTrue(handlers.contains(context.getBean(SimpAnnotationMethodMessageHandler.class)));
assertTrue(handlers.contains(context.getBean(UserDestinationMessageHandler.class)));
assertTrue(handlers.contains(context.getBean(SimpleBrokerMessageHandler.class)));
assertThat(handlers.size()).isEqualTo(3);
assertThat(handlers.contains(context.getBean(SimpAnnotationMethodMessageHandler.class))).isTrue();
assertThat(handlers.contains(context.getBean(UserDestinationMessageHandler.class))).isTrue();
assertThat(handlers.contains(context.getBean(SimpleBrokerMessageHandler.class))).isTrue();
}
@Test
@@ -114,10 +108,10 @@ public class MessageBrokerConfigurationTests {
TestChannel channel = context.getBean("clientInboundChannel", TestChannel.class);
Set<MessageHandler> handlers = channel.getSubscribers();
assertEquals(3, handlers.size());
assertTrue(handlers.contains(context.getBean(SimpAnnotationMethodMessageHandler.class)));
assertTrue(handlers.contains(context.getBean(UserDestinationMessageHandler.class)));
assertTrue(handlers.contains(context.getBean(StompBrokerRelayMessageHandler.class)));
assertThat(handlers.size()).isEqualTo(3);
assertThat(handlers.contains(context.getBean(SimpAnnotationMethodMessageHandler.class))).isTrue();
assertThat(handlers.contains(context.getBean(UserDestinationMessageHandler.class))).isTrue();
assertThat(handlers.contains(context.getBean(StompBrokerRelayMessageHandler.class))).isTrue();
}
@Test
@@ -126,13 +120,13 @@ public class MessageBrokerConfigurationTests {
AbstractSubscribableChannel channel = context.getBean(
"clientInboundChannel", AbstractSubscribableChannel.class);
assertEquals(3, channel.getInterceptors().size());
assertThat(channel.getInterceptors().size()).isEqualTo(3);
CustomThreadPoolTaskExecutor taskExecutor = context.getBean(
"clientInboundChannelExecutor", CustomThreadPoolTaskExecutor.class);
assertEquals(11, taskExecutor.getCorePoolSize());
assertEquals(12, taskExecutor.getMaxPoolSize());
assertEquals(13, taskExecutor.getKeepAliveSeconds());
assertThat(taskExecutor.getCorePoolSize()).isEqualTo(11);
assertThat(taskExecutor.getMaxPoolSize()).isEqualTo(12);
assertThat(taskExecutor.getKeepAliveSeconds()).isEqualTo(13);
}
@Test
@@ -155,9 +149,9 @@ public class MessageBrokerConfigurationTests {
message = channel.messages.get(0);
headers = StompHeaderAccessor.wrap(message);
assertEquals(SimpMessageType.MESSAGE, headers.getMessageType());
assertEquals("/foo", headers.getDestination());
assertEquals("bar", new String((byte[]) message.getPayload()));
assertThat(headers.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
assertThat(headers.getDestination()).isEqualTo("/foo");
assertThat(new String((byte[]) message.getPayload())).isEqualTo("bar");
}
@Test
@@ -188,9 +182,9 @@ public class MessageBrokerConfigurationTests {
message = outboundChannel.messages.get(1);
headers = StompHeaderAccessor.wrap(message);
assertEquals(SimpMessageType.MESSAGE, headers.getMessageType());
assertEquals("/foo", headers.getDestination());
assertEquals("bar", new String((byte[]) message.getPayload()));
assertThat(headers.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
assertThat(headers.getDestination()).isEqualTo("/foo");
assertThat(new String((byte[]) message.getPayload())).isEqualTo("bar");
}
@Test
@@ -200,18 +194,18 @@ public class MessageBrokerConfigurationTests {
AbstractSubscribableChannel channel = context.getBean(
"clientOutboundChannel", AbstractSubscribableChannel.class);
assertEquals(4, channel.getInterceptors().size());
assertThat(channel.getInterceptors().size()).isEqualTo(4);
ThreadPoolTaskExecutor taskExecutor = context.getBean(
"clientOutboundChannelExecutor", ThreadPoolTaskExecutor.class);
assertEquals(21, taskExecutor.getCorePoolSize());
assertEquals(22, taskExecutor.getMaxPoolSize());
assertEquals(23, taskExecutor.getKeepAliveSeconds());
assertThat(taskExecutor.getCorePoolSize()).isEqualTo(21);
assertThat(taskExecutor.getMaxPoolSize()).isEqualTo(22);
assertThat(taskExecutor.getKeepAliveSeconds()).isEqualTo(23);
SimpleBrokerMessageHandler broker =
context.getBean("simpleBrokerMessageHandler", SimpleBrokerMessageHandler.class);
assertTrue(broker.isPreservePublishOrder());
assertThat(broker.isPreservePublishOrder()).isTrue();
}
@Test
@@ -221,11 +215,11 @@ public class MessageBrokerConfigurationTests {
TestChannel channel = context.getBean("brokerChannel", TestChannel.class);
Set<MessageHandler> handlers = channel.getSubscribers();
assertEquals(2, handlers.size());
assertTrue(handlers.contains(context.getBean(UserDestinationMessageHandler.class)));
assertTrue(handlers.contains(context.getBean(SimpleBrokerMessageHandler.class)));
assertThat(handlers.size()).isEqualTo(2);
assertThat(handlers.contains(context.getBean(UserDestinationMessageHandler.class))).isTrue();
assertThat(handlers.contains(context.getBean(SimpleBrokerMessageHandler.class))).isTrue();
assertNull(channel.getExecutor());
assertThat((Object) channel.getExecutor()).isNull();
}
@Test
@@ -235,9 +229,9 @@ public class MessageBrokerConfigurationTests {
TestChannel channel = context.getBean("brokerChannel", TestChannel.class);
Set<MessageHandler> handlers = channel.getSubscribers();
assertEquals(2, handlers.size());
assertTrue(handlers.contains(context.getBean(UserDestinationMessageHandler.class)));
assertTrue(handlers.contains(context.getBean(StompBrokerRelayMessageHandler.class)));
assertThat(handlers.size()).isEqualTo(2);
assertThat(handlers.contains(context.getBean(UserDestinationMessageHandler.class))).isTrue();
assertThat(handlers.contains(context.getBean(StompBrokerRelayMessageHandler.class))).isTrue();
}
@Test
@@ -259,9 +253,9 @@ public class MessageBrokerConfigurationTests {
message = channel.messages.get(0);
headers = StompHeaderAccessor.wrap(message);
assertEquals(SimpMessageType.MESSAGE, headers.getMessageType());
assertEquals("/bar", headers.getDestination());
assertEquals("bar", new String((byte[]) message.getPayload()));
assertThat(headers.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
assertThat(headers.getDestination()).isEqualTo("/bar");
assertThat(new String((byte[]) message.getPayload())).isEqualTo("bar");
}
@Test
@@ -271,14 +265,14 @@ public class MessageBrokerConfigurationTests {
AbstractSubscribableChannel channel = context.getBean(
"brokerChannel", AbstractSubscribableChannel.class);
assertEquals(4, channel.getInterceptors().size());
assertThat(channel.getInterceptors().size()).isEqualTo(4);
ThreadPoolTaskExecutor taskExecutor = context.getBean(
"brokerChannelExecutor", ThreadPoolTaskExecutor.class);
assertEquals(31, taskExecutor.getCorePoolSize());
assertEquals(32, taskExecutor.getMaxPoolSize());
assertEquals(33, taskExecutor.getKeepAliveSeconds());
assertThat(taskExecutor.getCorePoolSize()).isEqualTo(31);
assertThat(taskExecutor.getMaxPoolSize()).isEqualTo(32);
assertThat(taskExecutor.getKeepAliveSeconds()).isEqualTo(33);
}
@Test
@@ -293,7 +287,7 @@ public class MessageBrokerConfigurationTests {
assertThat(converters.get(2)).isInstanceOf(MappingJackson2MessageConverter.class);
ContentTypeResolver resolver = ((MappingJackson2MessageConverter) converters.get(2)).getContentTypeResolver();
assertEquals(MimeTypeUtils.APPLICATION_JSON, ((DefaultContentTypeResolver) resolver).getDefaultMimeType());
assertThat(((DefaultContentTypeResolver) resolver).getDefaultMimeType()).isEqualTo(MimeTypeUtils.APPLICATION_JSON);
}
@Test
@@ -302,17 +296,17 @@ public class MessageBrokerConfigurationTests {
String name = "clientInboundChannelExecutor";
ThreadPoolTaskExecutor executor = context.getBean(name, ThreadPoolTaskExecutor.class);
assertEquals(Runtime.getRuntime().availableProcessors() * 2, executor.getCorePoolSize());
assertThat(executor.getCorePoolSize()).isEqualTo(Runtime.getRuntime().availableProcessors() * 2);
// No way to verify queue capacity
name = "clientOutboundChannelExecutor";
executor = context.getBean(name, ThreadPoolTaskExecutor.class);
assertEquals(Runtime.getRuntime().availableProcessors() * 2, executor.getCorePoolSize());
assertThat(executor.getCorePoolSize()).isEqualTo(Runtime.getRuntime().availableProcessors() * 2);
name = "brokerChannelExecutor";
executor = context.getBean(name, ThreadPoolTaskExecutor.class);
assertEquals(0, executor.getCorePoolSize());
assertEquals(1, executor.getMaxPoolSize());
assertThat(executor.getCorePoolSize()).isEqualTo(0);
assertThat(executor.getMaxPoolSize()).isEqualTo(1);
}
@Test
@@ -361,12 +355,12 @@ public class MessageBrokerConfigurationTests {
context.getBean(SimpAnnotationMethodMessageHandler.class);
List<HandlerMethodArgumentResolver> customResolvers = handler.getCustomArgumentResolvers();
assertEquals(1, customResolvers.size());
assertTrue(handler.getArgumentResolvers().contains(customResolvers.get(0)));
assertThat(customResolvers.size()).isEqualTo(1);
assertThat(handler.getArgumentResolvers().contains(customResolvers.get(0))).isTrue();
List<HandlerMethodReturnValueHandler> customHandlers = handler.getCustomReturnValueHandlers();
assertEquals(1, customHandlers.size());
assertTrue(handler.getReturnValueHandlers().contains(customHandlers.get(0)));
assertThat(customHandlers.size()).isEqualTo(1);
assertThat(handler.getReturnValueHandlers().contains(customHandlers.get(0))).isTrue();
}
@Test
@@ -388,7 +382,7 @@ public class MessageBrokerConfigurationTests {
}
};
assertSame(validator, config.simpValidator());
assertThat(config.simpValidator()).isSameAs(validator);
}
@Test
@@ -418,16 +412,16 @@ public class MessageBrokerConfigurationTests {
SimpleBrokerMessageHandler broker = context.getBean(SimpleBrokerMessageHandler.class);
DefaultSubscriptionRegistry registry = (DefaultSubscriptionRegistry) broker.getSubscriptionRegistry();
assertEquals("a.a", registry.getPathMatcher().combine("a", "a"));
assertThat(registry.getPathMatcher().combine("a", "a")).isEqualTo("a.a");
PathMatcher pathMatcher =
context.getBean(SimpAnnotationMethodMessageHandler.class).getPathMatcher();
assertEquals("a.a", pathMatcher.combine("a", "a"));
assertThat(pathMatcher.combine("a", "a")).isEqualTo("a.a");
DefaultUserDestinationResolver resolver = context.getBean(DefaultUserDestinationResolver.class);
assertNotNull(resolver);
assertEquals(false, resolver.isRemoveLeadingSlash());
assertThat(resolver).isNotNull();
assertThat(resolver.isRemoveLeadingSlash()).isEqualTo(false);
}
@Test
@@ -436,7 +430,7 @@ public class MessageBrokerConfigurationTests {
SimpleBrokerMessageHandler broker = context.getBean(SimpleBrokerMessageHandler.class);
DefaultSubscriptionRegistry registry = (DefaultSubscriptionRegistry) broker.getSubscriptionRegistry();
assertEquals(8192, registry.getCacheLimit());
assertThat(registry.getCacheLimit()).isEqualTo(8192);
}
@Test
@@ -444,8 +438,8 @@ public class MessageBrokerConfigurationTests {
ApplicationContext context = loadConfig(CustomConfig.class);
SimpUserRegistry registry = context.getBean(SimpUserRegistry.class);
assertTrue(registry instanceof TestUserRegistry);
assertEquals(99, ((TestUserRegistry) registry).getOrder());
assertThat(registry instanceof TestUserRegistry).isTrue();
assertThat(((TestUserRegistry) registry).getOrder()).isEqualTo(99);
}
@Test
@@ -453,19 +447,19 @@ public class MessageBrokerConfigurationTests {
ApplicationContext context = loadConfig(BrokerRelayConfig.class);
SimpUserRegistry userRegistry = context.getBean(SimpUserRegistry.class);
assertEquals(MultiServerUserRegistry.class, userRegistry.getClass());
assertThat(userRegistry.getClass()).isEqualTo(MultiServerUserRegistry.class);
UserDestinationMessageHandler handler1 = context.getBean(UserDestinationMessageHandler.class);
assertEquals("/topic/unresolved-user-destination", handler1.getBroadcastDestination());
assertThat(handler1.getBroadcastDestination()).isEqualTo("/topic/unresolved-user-destination");
UserRegistryMessageHandler handler2 = context.getBean(UserRegistryMessageHandler.class);
assertEquals("/topic/simp-user-registry", handler2.getBroadcastDestination());
assertThat(handler2.getBroadcastDestination()).isEqualTo("/topic/simp-user-registry");
StompBrokerRelayMessageHandler relay = context.getBean(StompBrokerRelayMessageHandler.class);
assertNotNull(relay.getSystemSubscriptions());
assertEquals(2, relay.getSystemSubscriptions().size());
assertSame(handler1, relay.getSystemSubscriptions().get("/topic/unresolved-user-destination"));
assertSame(handler2, relay.getSystemSubscriptions().get("/topic/simp-user-registry"));
assertThat(relay.getSystemSubscriptions()).isNotNull();
assertThat(relay.getSystemSubscriptions().size()).isEqualTo(2);
assertThat(relay.getSystemSubscriptions().get("/topic/unresolved-user-destination")).isSameAs(handler1);
assertThat(relay.getSystemSubscriptions().get("/topic/simp-user-registry")).isSameAs(handler2);
}
@Test
@@ -473,14 +467,14 @@ public class MessageBrokerConfigurationTests {
ApplicationContext context = loadConfig(SimpleBrokerConfig.class);
SimpUserRegistry registry = context.getBean(SimpUserRegistry.class);
assertNotNull(registry);
assertNotEquals(MultiServerUserRegistry.class, registry.getClass());
assertThat(registry).isNotNull();
assertThat(registry.getClass()).isNotEqualTo(MultiServerUserRegistry.class);
UserDestinationMessageHandler handler = context.getBean(UserDestinationMessageHandler.class);
assertNull(handler.getBroadcastDestination());
assertThat((Object) handler.getBroadcastDestination()).isNull();
Object nullBean = context.getBean("userRegistryMessageHandler");
assertTrue(nullBean.equals(null));
assertThat(nullBean.equals(null)).isTrue();
}
@Test // SPR-16275
@@ -519,13 +513,14 @@ public class MessageBrokerConfigurationTests {
message = MessageBuilder.createMessage("123".getBytes(), headers.getMessageHeaders());
inChannel.send(message);
assertEquals(2, outChannel.messages.size());
assertThat(outChannel.messages.size()).isEqualTo(2);
Message<?> outputMessage = outChannel.messages.remove(1);
headers = StompHeaderAccessor.wrap(outputMessage);
assertEquals(SimpMessageType.MESSAGE, headers.getMessageType());
assertEquals(expectLeadingSlash ? "/queue.q1-usersess1" : "queue.q1-usersess1", headers.getDestination());
assertEquals("123", new String((byte[]) outputMessage.getPayload()));
assertThat(headers.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
Object expecteds1 = expectLeadingSlash ? "/queue.q1-usersess1" : "queue.q1-usersess1";
assertThat(headers.getDestination()).isEqualTo(expecteds1);
assertThat(new String((byte[]) outputMessage.getPayload())).isEqualTo("123");
outChannel.messages.clear();
// 3. Send message via broker channel
@@ -535,13 +530,14 @@ public class MessageBrokerConfigurationTests {
accessor.setSessionId("sess1");
template.convertAndSendToUser("sess1", "queue.q1", "456".getBytes(), accessor.getMessageHeaders());
assertEquals(1, outChannel.messages.size());
assertThat(outChannel.messages.size()).isEqualTo(1);
outputMessage = outChannel.messages.remove(0);
headers = StompHeaderAccessor.wrap(outputMessage);
assertEquals(SimpMessageType.MESSAGE, headers.getMessageType());
assertEquals(expectLeadingSlash ? "/queue.q1-usersess1" : "queue.q1-usersess1", headers.getDestination());
assertEquals("456", new String((byte[]) outputMessage.getPayload()));
assertThat(headers.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
Object expecteds = expectLeadingSlash ? "/queue.q1-usersess1" : "queue.q1-usersess1";
assertThat(headers.getDestination()).isEqualTo(expecteds);
assertThat(new String((byte[]) outputMessage.getPayload())).isEqualTo("456");
}

19
spring-messaging/src/test/java/org/springframework/messaging/simp/config/StompBrokerRelayRegistrationTests.java
View File

@@ -24,8 +24,7 @@ import org.springframework.messaging.SubscribableChannel;
import org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler;
import org.springframework.util.StringUtils;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for
@@ -53,14 +52,14 @@ public class StompBrokerRelayRegistrationTests {
StompBrokerRelayMessageHandler handler = registration.getMessageHandler(new StubMessageChannel());
assertArrayEquals(prefixes, StringUtils.toStringArray(handler.getDestinationPrefixes()));
assertEquals("clientlogin", handler.getClientLogin());
assertEquals("clientpasscode", handler.getClientPasscode());
assertEquals("syslogin", handler.getSystemLogin());
assertEquals("syspasscode", handler.getSystemPasscode());
assertEquals(123, handler.getSystemHeartbeatReceiveInterval());
assertEquals(456, handler.getSystemHeartbeatSendInterval());
assertEquals("example.org", handler.getVirtualHost());
assertThat(StringUtils.toStringArray(handler.getDestinationPrefixes())).isEqualTo(prefixes);
assertThat(handler.getClientLogin()).isEqualTo("clientlogin");
assertThat(handler.getClientPasscode()).isEqualTo("clientpasscode");
assertThat(handler.getSystemLogin()).isEqualTo("syslogin");
assertThat(handler.getSystemPasscode()).isEqualTo("syspasscode");
assertThat(handler.getSystemHeartbeatReceiveInterval()).isEqualTo(123);
assertThat(handler.getSystemHeartbeatSendInterval()).isEqualTo(456);
assertThat(handler.getVirtualHost()).isEqualTo("example.org");
}
}

87
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/BufferingStompDecoderTests.java
View File

@@ -25,9 +25,8 @@ import org.junit.Test;
import org.springframework.messaging.Message;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
/**
* Unit tests for {@link BufferingStompDecoder}.
@@ -46,11 +45,11 @@ public class BufferingStompDecoderTests {
String chunk = "SEND\na:alpha\n\nMessage body\0";
List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk));
assertEquals(1, messages.size());
assertEquals("Message body", new String(messages.get(0).getPayload()));
assertThat(messages.size()).isEqualTo(1);
assertThat(new String(messages.get(0).getPayload())).isEqualTo("Message body");
assertEquals(0, stompDecoder.getBufferSize());
assertNull(stompDecoder.getExpectedContentLength());
assertThat(stompDecoder.getBufferSize()).isEqualTo(0);
assertThat(stompDecoder.getExpectedContentLength()).isNull();
}
@Test
@@ -60,14 +59,14 @@ public class BufferingStompDecoderTests {
String chunk2 = " body\0";
List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk1));
assertEquals(Collections.<Message<byte[]>>emptyList(), messages);
assertThat(messages).isEqualTo(Collections.<Message<byte[]>>emptyList());
messages = stompDecoder.decode(toByteBuffer(chunk2));
assertEquals(1, messages.size());
assertEquals("Message body", new String(messages.get(0).getPayload()));
assertThat(messages.size()).isEqualTo(1);
assertThat(new String(messages.get(0).getPayload())).isEqualTo("Message body");
assertEquals(0, stompDecoder.getBufferSize());
assertNull(stompDecoder.getExpectedContentLength());
assertThat(stompDecoder.getBufferSize()).isEqualTo(0);
assertThat(stompDecoder.getExpectedContentLength()).isNull();
}
@Test
@@ -76,12 +75,12 @@ public class BufferingStompDecoderTests {
String chunk = "SEND\na:alpha\n\nPayload1\0" + "SEND\na:alpha\n\nPayload2\0";
List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk));
assertEquals(2, messages.size());
assertEquals("Payload1", new String(messages.get(0).getPayload()));
assertEquals("Payload2", new String(messages.get(1).getPayload()));
assertThat(messages.size()).isEqualTo(2);
assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload1");
assertThat(new String(messages.get(1).getPayload())).isEqualTo("Payload2");
assertEquals(0, stompDecoder.getBufferSize());
assertNull(stompDecoder.getExpectedContentLength());
assertThat(stompDecoder.getBufferSize()).isEqualTo(0);
assertThat(stompDecoder.getExpectedContentLength()).isNull();
}
@Test
@@ -91,26 +90,26 @@ public class BufferingStompDecoderTests {
String chunk1 = "SEND\na:alpha\n\nPayload1\0SEND\ncontent-length:" + contentLength + "\n";
List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk1));
assertEquals(1, messages.size());
assertEquals("Payload1", new String(messages.get(0).getPayload()));
assertThat(messages.size()).isEqualTo(1);
assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload1");
assertEquals(23, stompDecoder.getBufferSize());
assertEquals(contentLength, (int) stompDecoder.getExpectedContentLength());
assertThat(stompDecoder.getBufferSize()).isEqualTo(23);
assertThat((int) stompDecoder.getExpectedContentLength()).isEqualTo(contentLength);
String chunk2 = "\nPayload2a";
messages = stompDecoder.decode(toByteBuffer(chunk2));
assertEquals(0, messages.size());
assertEquals(33, stompDecoder.getBufferSize());
assertEquals(contentLength, (int) stompDecoder.getExpectedContentLength());
assertThat(messages.size()).isEqualTo(0);
assertThat(stompDecoder.getBufferSize()).isEqualTo(33);
assertThat((int) stompDecoder.getExpectedContentLength()).isEqualTo(contentLength);
String chunk3 = "-Payload2b\0";
messages = stompDecoder.decode(toByteBuffer(chunk3));
assertEquals(1, messages.size());
assertEquals("Payload2a-Payload2b", new String(messages.get(0).getPayload()));
assertEquals(0, stompDecoder.getBufferSize());
assertNull(stompDecoder.getExpectedContentLength());
assertThat(messages.size()).isEqualTo(1);
assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload2a-Payload2b");
assertThat(stompDecoder.getBufferSize()).isEqualTo(0);
assertThat(stompDecoder.getExpectedContentLength()).isNull();
}
@Test
@@ -119,26 +118,26 @@ public class BufferingStompDecoderTests {
String chunk1 = "SEND\na:alpha\n\nPayload1\0SEND\na:alpha\n";
List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk1));
assertEquals(1, messages.size());
assertEquals("Payload1", new String(messages.get(0).getPayload()));
assertThat(messages.size()).isEqualTo(1);
assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload1");
assertEquals(13, stompDecoder.getBufferSize());
assertNull(stompDecoder.getExpectedContentLength());
assertThat(stompDecoder.getBufferSize()).isEqualTo(13);
assertThat(stompDecoder.getExpectedContentLength()).isNull();
String chunk2 = "\nPayload2a";
messages = stompDecoder.decode(toByteBuffer(chunk2));
assertEquals(0, messages.size());
assertEquals(23, stompDecoder.getBufferSize());
assertNull(stompDecoder.getExpectedContentLength());
assertThat(messages.size()).isEqualTo(0);
assertThat(stompDecoder.getBufferSize()).isEqualTo(23);
assertThat(stompDecoder.getExpectedContentLength()).isNull();
String chunk3 = "-Payload2b\0";
messages = stompDecoder.decode(toByteBuffer(chunk3));
assertEquals(1, messages.size());
assertEquals("Payload2a-Payload2b", new String(messages.get(0).getPayload()));
assertEquals(0, stompDecoder.getBufferSize());
assertNull(stompDecoder.getExpectedContentLength());
assertThat(messages.size()).isEqualTo(1);
assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload2a-Payload2b");
assertThat(stompDecoder.getBufferSize()).isEqualTo(0);
assertThat(stompDecoder.getExpectedContentLength()).isNull();
}
@Test
@@ -147,11 +146,11 @@ public class BufferingStompDecoderTests {
String chunk1 = "SEND\na:alpha\n\nPayload1\0SEND\ncontent-length:129\n";
List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk1));
assertEquals("We should have gotten the 1st message", 1, messages.size());
assertEquals("Payload1", new String(messages.get(0).getPayload()));
assertThat(messages.size()).as("We should have gotten the 1st message").isEqualTo(1);
assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload1");
assertEquals(24, stompDecoder.getBufferSize());
assertEquals(129, (int) stompDecoder.getExpectedContentLength());
assertThat(stompDecoder.getBufferSize()).isEqualTo(24);
assertThat((int) stompDecoder.getExpectedContentLength()).isEqualTo(129);
String chunk2 = "\nPayload2a";
assertThatExceptionOfType(StompConversionException.class).isThrownBy(() ->
@@ -172,7 +171,7 @@ public class BufferingStompDecoderTests {
String chunk = "MESSAG";
List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk));
assertEquals(0, messages.size());
assertThat(messages.size()).isEqualTo(0);
}
// SPR-13416
@@ -183,7 +182,7 @@ public class BufferingStompDecoderTests {
String chunk = "SEND\na:long\\";
List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk));
assertEquals(0, messages.size());
assertThat(messages.size()).isEqualTo(0);
}
@Test

135
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/DefaultStompSessionTests.java
View File

@@ -45,12 +45,6 @@ import org.springframework.util.concurrent.SettableListenableFuture;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.notNull;
@@ -99,31 +93,31 @@ public class DefaultStompSessionTests {
@Test
public void afterConnected() {
assertFalse(this.session.isConnected());
assertThat(this.session.isConnected()).isFalse();
this.connectHeaders.setHost("my-host");
this.connectHeaders.setHeartbeat(new long[] {11, 12});
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.CONNECT, accessor.getCommand());
assertEquals("my-host", accessor.getHost());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.CONNECT);
assertThat(accessor.getHost()).isEqualTo("my-host");
assertThat(accessor.getAcceptVersion()).containsExactly("1.1", "1.2");
assertArrayEquals(new long[] {11, 12}, accessor.getHeartbeat());
assertThat(accessor.getHeartbeat()).isEqualTo(new long[] {11, 12});
}
@Test // SPR-16844
public void afterConnectedWithSpecificVersion() {
assertFalse(this.session.isConnected());
assertThat(this.session.isConnected()).isFalse();
this.connectHeaders.setAcceptVersion(new String[] {"1.1"});
this.session.afterConnected(this.connection);
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.CONNECT, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.CONNECT);
assertThat(accessor.getAcceptVersion()).containsExactly("1.1");
}
@@ -138,7 +132,7 @@ public class DefaultStompSessionTests {
@Test
public void handleConnectedFrame() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
this.connectHeaders.setHeartbeat(new long[] {10000, 10000});
@@ -156,7 +150,7 @@ public class DefaultStompSessionTests {
@Test
public void heartbeatValues() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
this.connectHeaders.setHeartbeat(new long[] {10000, 10000});
@@ -168,11 +162,11 @@ public class DefaultStompSessionTests {
ArgumentCaptor<Long> writeInterval = ArgumentCaptor.forClass(Long.class);
verify(this.connection).onWriteInactivity(any(Runnable.class), writeInterval.capture());
assertEquals(20000, (long) writeInterval.getValue());
assertThat((long) writeInterval.getValue()).isEqualTo(20000);
ArgumentCaptor<Long> readInterval = ArgumentCaptor.forClass(Long.class);
verify(this.connection).onReadInactivity(any(Runnable.class), readInterval.capture());
assertEquals(60000, (long) readInterval.getValue());
assertThat((long) readInterval.getValue()).isEqualTo(60000);
}
@Test
@@ -211,8 +205,8 @@ public class DefaultStompSessionTests {
Runnable writeTask = writeTaskCaptor.getValue();
Runnable readTask = readTaskCaptor.getValue();
assertNotNull(writeTask);
assertNotNull(readTask);
assertThat(writeTask).isNotNull();
assertThat(readTask).isNotNull();
writeTask.run();
StompHeaderAccessor accessor = StompHeaderAccessor.createForHeartbeat();
@@ -306,7 +300,7 @@ public class DefaultStompSessionTests {
@Test
public void handleMessageFrameWithConversionException() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
StompFrameHandler frameHandler = mock(StompFrameHandler.class);
String destination = "/topic/foo";
@@ -353,7 +347,7 @@ public class DefaultStompSessionTests {
@Test
public void send() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
String destination = "/topic/foo";
String payload = "sample payload";
@@ -361,21 +355,22 @@ public class DefaultStompSessionTests {
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.SEND, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.SEND);
StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
assertEquals(stompHeaders.toString(), 2, stompHeaders.size());
assertThat(stompHeaders.size()).as(stompHeaders.toString()).isEqualTo(2);
assertEquals(destination, stompHeaders.getDestination());
assertEquals(new MimeType("text", "plain", StandardCharsets.UTF_8), stompHeaders.getContentType());
assertEquals(-1, stompHeaders.getContentLength()); // StompEncoder isn't involved
assertEquals(payload, new String(message.getPayload(), StandardCharsets.UTF_8));
assertThat(stompHeaders.getDestination()).isEqualTo(destination);
assertThat(stompHeaders.getContentType()).isEqualTo(new MimeType("text", "plain", StandardCharsets.UTF_8));
// StompEncoder isn't involved
assertThat(stompHeaders.getContentLength()).isEqualTo(-1);
assertThat(new String(message.getPayload(), StandardCharsets.UTF_8)).isEqualTo(payload);
}
@Test
public void sendWithReceipt() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
this.session.setTaskScheduler(mock(TaskScheduler.class));
this.session.setAutoReceipt(true);
@@ -383,7 +378,7 @@ public class DefaultStompSessionTests {
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertNotNull(accessor.getReceipt());
assertThat(accessor.getReceipt()).isNotNull();
StompHeaders stompHeaders = new StompHeaders();
stompHeaders.setDestination("/topic/foo");
@@ -392,13 +387,13 @@ public class DefaultStompSessionTests {
message = this.messageCaptor.getValue();
accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals("my-receipt", accessor.getReceipt());
assertThat(accessor.getReceipt()).isEqualTo("my-receipt");
}
@Test
public void sendWithConversionException() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
StompHeaders stompHeaders = new StompHeaders();
stompHeaders.setDestination("/topic/foo");
@@ -412,7 +407,7 @@ public class DefaultStompSessionTests {
@Test
public void sendWithExecutionException() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
IllegalStateException exception = new IllegalStateException("simulated exception");
SettableListenableFuture<Void> future = new SettableListenableFuture<>();
@@ -427,7 +422,7 @@ public class DefaultStompSessionTests {
@Test
public void subscribe() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
String destination = "/topic/foo";
StompFrameHandler frameHandler = mock(StompFrameHandler.class);
@@ -435,18 +430,18 @@ public class DefaultStompSessionTests {
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.SUBSCRIBE, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.SUBSCRIBE);
StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
assertEquals(stompHeaders.toString(), 2, stompHeaders.size());
assertEquals(destination, stompHeaders.getDestination());
assertEquals(subscription.getSubscriptionId(), stompHeaders.getId());
assertThat(stompHeaders.size()).as(stompHeaders.toString()).isEqualTo(2);
assertThat(stompHeaders.getDestination()).isEqualTo(destination);
assertThat(stompHeaders.getId()).isEqualTo(subscription.getSubscriptionId());
}
@Test
public void subscribeWithHeaders() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
String subscriptionId = "123";
String destination = "/topic/foo";
@@ -457,22 +452,22 @@ public class DefaultStompSessionTests {
StompFrameHandler frameHandler = mock(StompFrameHandler.class);
Subscription subscription = this.session.subscribe(stompHeaders, frameHandler);
assertEquals(subscriptionId, subscription.getSubscriptionId());
assertThat(subscription.getSubscriptionId()).isEqualTo(subscriptionId);
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.SUBSCRIBE, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.SUBSCRIBE);
stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
assertEquals(stompHeaders.toString(), 2, stompHeaders.size());
assertEquals(destination, stompHeaders.getDestination());
assertEquals(subscriptionId, stompHeaders.getId());
assertThat(stompHeaders.size()).as(stompHeaders.toString()).isEqualTo(2);
assertThat(stompHeaders.getDestination()).isEqualTo(destination);
assertThat(stompHeaders.getId()).isEqualTo(subscriptionId);
}
@Test
public void unsubscribe() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
String destination = "/topic/foo";
StompFrameHandler frameHandler = mock(StompFrameHandler.class);
@@ -481,17 +476,17 @@ public class DefaultStompSessionTests {
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.UNSUBSCRIBE, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.UNSUBSCRIBE);
StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
assertEquals(stompHeaders.toString(), 1, stompHeaders.size());
assertEquals(subscription.getSubscriptionId(), stompHeaders.getId());
assertThat(stompHeaders.size()).as(stompHeaders.toString()).isEqualTo(1);
assertThat(stompHeaders.getId()).isEqualTo(subscription.getSubscriptionId());
}
@Test // SPR-15131
public void unsubscribeWithCustomHeader() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
String headerName = "durable-subscription-name";
String headerValue = "123";
@@ -508,46 +503,46 @@ public class DefaultStompSessionTests {
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.UNSUBSCRIBE, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.UNSUBSCRIBE);
StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
assertEquals(stompHeaders.toString(), 2, stompHeaders.size());
assertEquals(subscription.getSubscriptionId(), stompHeaders.getId());
assertEquals(headerValue, stompHeaders.getFirst(headerName));
assertThat(stompHeaders.size()).as(stompHeaders.toString()).isEqualTo(2);
assertThat(stompHeaders.getId()).isEqualTo(subscription.getSubscriptionId());
assertThat(stompHeaders.getFirst(headerName)).isEqualTo(headerValue);
}
@Test
public void ack() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
String messageId = "123";
this.session.acknowledge(messageId, true);
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.ACK, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.ACK);
StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
assertEquals(stompHeaders.toString(), 1, stompHeaders.size());
assertEquals(messageId, stompHeaders.getId());
assertThat(stompHeaders.size()).as(stompHeaders.toString()).isEqualTo(1);
assertThat(stompHeaders.getId()).isEqualTo(messageId);
}
@Test
public void nack() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
String messageId = "123";
this.session.acknowledge(messageId, false);
Message<byte[]> message = this.messageCaptor.getValue();
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.NACK, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.NACK);
StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
assertEquals(stompHeaders.toString(), 1, stompHeaders.size());
assertEquals(messageId, stompHeaders.getId());
assertThat(stompHeaders.size()).as(stompHeaders.toString()).isEqualTo(1);
assertThat(stompHeaders.getId()).isEqualTo(messageId);
}
@Test
@@ -563,15 +558,15 @@ public class DefaultStompSessionTests {
Subscription subscription = this.session.subscribe(headers, mock(StompFrameHandler.class));
subscription.addReceiptTask(() -> received.set(true));
assertNull(received.get());
assertThat((Object) received.get()).isNull();
StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.RECEIPT);
accessor.setReceiptId("my-receipt");
accessor.setLeaveMutable(true);
this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders()));
assertNotNull(received.get());
assertTrue(received.get());
assertThat(received.get()).isNotNull();
assertThat(received.get()).isTrue();
}
@Test
@@ -593,8 +588,8 @@ public class DefaultStompSessionTests {
subscription.addReceiptTask(() -> received.set(true));
assertNotNull(received.get());
assertTrue(received.get());
assertThat(received.get()).isNotNull();
assertThat(received.get()).isTrue();
}
@Test
@@ -619,12 +614,12 @@ public class DefaultStompSessionTests {
ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClass(Runnable.class);
verify(taskScheduler).schedule(taskCaptor.capture(), (Date) notNull());
Runnable scheduledTask = taskCaptor.getValue();
assertNotNull(scheduledTask);
assertThat(scheduledTask).isNotNull();
assertNull(notReceived.get());
assertThat((Object) notReceived.get()).isNull();
scheduledTask.run();
assertTrue(notReceived.get());
assertThat(notReceived.get()).isTrue();
verify(future).cancel(true);
verifyNoMoreInteractions(future);
}
@@ -632,10 +627,10 @@ public class DefaultStompSessionTests {
@Test
public void disconnect() {
this.session.afterConnected(this.connection);
assertTrue(this.session.isConnected());
assertThat(this.session.isConnected()).isTrue();
this.session.disconnect();
assertFalse(this.session.isConnected());
assertThat(this.session.isConnected()).isFalse();
verifyNoMoreInteractions(this.sessionHandler);
}

9
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/ReactorNettyTcpStompClientTests.java
View File

@@ -41,7 +41,6 @@ import org.springframework.util.SocketUtils;
import org.springframework.util.concurrent.ListenableFuture;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertTrue;
/**
* Integration tests for {@link ReactorNettyTcpStompClient}.
@@ -110,18 +109,18 @@ public class ReactorNettyTcpStompClientTests {
ConsumingHandler consumingHandler2 = new ConsumingHandler(destination);
ListenableFuture<StompSession> consumerFuture2 = this.client.connect(consumingHandler2);
assertTrue(consumingHandler1.awaitForSubscriptions(5000));
assertTrue(consumingHandler2.awaitForSubscriptions(5000));
assertThat(consumingHandler1.awaitForSubscriptions(5000)).isTrue();
assertThat(consumingHandler2.awaitForSubscriptions(5000)).isTrue();
ProducingHandler producingHandler = new ProducingHandler();
producingHandler.addToSend(destination, "foo1");
producingHandler.addToSend(destination, "foo2");
ListenableFuture<StompSession> producerFuture = this.client.connect(producingHandler);
assertTrue(consumingHandler1.awaitForMessageCount(2, 5000));
assertThat(consumingHandler1.awaitForMessageCount(2, 5000)).isTrue();
assertThat(consumingHandler1.getReceived()).containsExactly("foo1", "foo2");
assertTrue(consumingHandler2.awaitForMessageCount(2, 5000));
assertThat(consumingHandler2.awaitForMessageCount(2, 5000)).isTrue();
assertThat(consumingHandler2.getReceived()).containsExactly("foo1", "foo2");
consumerFuture1.get().disconnect();

14
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompBrokerRelayMessageHandlerIntegrationTests.java
View File

@@ -49,10 +49,8 @@ import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.Assert;
import org.springframework.util.SocketUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Integration tests for {@link StompBrokerRelayMessageHandler} running against ActiveMQ.
@@ -140,7 +138,7 @@ public class StompBrokerRelayMessageHandlerIntegrationTests {
}
});
this.activeMQBroker.stop();
assertTrue("Broker did not stop", latch.await(5, TimeUnit.SECONDS));
assertThat(latch.await(5, TimeUnit.SECONDS)).as("Broker did not stop").isTrue();
logger.debug("Broker stopped");
}
@@ -263,8 +261,8 @@ public class StompBrokerRelayMessageHandlerIntegrationTests {
public void expectBrokerAvailabilityEvent(boolean isBrokerAvailable) throws InterruptedException {
BrokerAvailabilityEvent event = this.eventQueue.poll(20000, TimeUnit.MILLISECONDS);
assertNotNull("Times out waiting for BrokerAvailabilityEvent[" + isBrokerAvailable + "]", event);
assertEquals(isBrokerAvailable, event.isBrokerAvailable());
assertThat(event).as("Times out waiting for BrokerAvailabilityEvent[" + isBrokerAvailable + "]").isNotNull();
assertThat(event.isBrokerAvailable()).isEqualTo(isBrokerAvailable);
}
}
@@ -286,9 +284,9 @@ public class StompBrokerRelayMessageHandlerIntegrationTests {
new ArrayList<>(Arrays.<MessageExchange>asList(messageExchanges));
while (expectedMessages.size() > 0) {
Message<?> message = this.queue.poll(10000, TimeUnit.MILLISECONDS);
assertNotNull("Timed out waiting for messages, expected [" + expectedMessages + "]", message);
assertThat(message).as("Timed out waiting for messages, expected [" + expectedMessages + "]").isNotNull();
MessageExchange match = findMatch(expectedMessages, message);
assertNotNull("Unexpected message=" + message + ", expected [" + expectedMessages + "]", match);
assertThat(match).as("Unexpected message=" + message + ", expected [" + expectedMessages + "]").isNotNull();
expectedMessages.remove(match);
}
}

85
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompBrokerRelayMessageHandlerTests.java
View File

@@ -41,10 +41,7 @@ import org.springframework.messaging.tcp.TcpOperations;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureTask;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -90,17 +87,17 @@ public class StompBrokerRelayMessageHandlerTests {
this.brokerRelay.start();
this.brokerRelay.handleMessage(connectMessage("sess1", "joe"));
assertEquals(2, this.tcpClient.getSentMessages().size());
assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
StompHeaderAccessor headers1 = this.tcpClient.getSentHeaders(0);
assertEquals(StompCommand.CONNECT, headers1.getCommand());
assertEquals(StompBrokerRelayMessageHandler.SYSTEM_SESSION_ID, headers1.getSessionId());
assertEquals("ABC", headers1.getHost());
assertThat(headers1.getCommand()).isEqualTo(StompCommand.CONNECT);
assertThat(headers1.getSessionId()).isEqualTo(StompBrokerRelayMessageHandler.SYSTEM_SESSION_ID);
assertThat(headers1.getHost()).isEqualTo("ABC");
StompHeaderAccessor headers2 = this.tcpClient.getSentHeaders(1);
assertEquals(StompCommand.CONNECT, headers2.getCommand());
assertEquals("sess1", headers2.getSessionId());
assertEquals("ABC", headers2.getHost());
assertThat(headers2.getCommand()).isEqualTo(StompCommand.CONNECT);
assertThat(headers2.getSessionId()).isEqualTo("sess1");
assertThat(headers2.getHost()).isEqualTo("ABC");
}
@Test
@@ -114,17 +111,17 @@ public class StompBrokerRelayMessageHandlerTests {
this.brokerRelay.start();
this.brokerRelay.handleMessage(connectMessage("sess1", "joe"));
assertEquals(2, this.tcpClient.getSentMessages().size());
assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
StompHeaderAccessor headers1 = this.tcpClient.getSentHeaders(0);
assertEquals(StompCommand.CONNECT, headers1.getCommand());
assertEquals("syslogin", headers1.getLogin());
assertEquals("syspasscode", headers1.getPasscode());
assertThat(headers1.getCommand()).isEqualTo(StompCommand.CONNECT);
assertThat(headers1.getLogin()).isEqualTo("syslogin");
assertThat(headers1.getPasscode()).isEqualTo("syspasscode");
StompHeaderAccessor headers2 = this.tcpClient.getSentHeaders(1);
assertEquals(StompCommand.CONNECT, headers2.getCommand());
assertEquals("clientlogin", headers2.getLogin());
assertEquals("clientpasscode", headers2.getPasscode());
assertThat(headers2.getCommand()).isEqualTo(StompCommand.CONNECT);
assertThat(headers2.getLogin()).isEqualTo("clientlogin");
assertThat(headers2.getPasscode()).isEqualTo("clientpasscode");
}
@Test
@@ -137,10 +134,10 @@ public class StompBrokerRelayMessageHandlerTests {
headers.setDestination("/user/daisy/foo");
this.brokerRelay.handleMessage(MessageBuilder.createMessage(new byte[0], headers.getMessageHeaders()));
assertEquals(1, this.tcpClient.getSentMessages().size());
assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(1);
StompHeaderAccessor headers1 = this.tcpClient.getSentHeaders(0);
assertEquals(StompCommand.CONNECT, headers1.getCommand());
assertEquals(StompBrokerRelayMessageHandler.SYSTEM_SESSION_ID, headers1.getSessionId());
assertThat(headers1.getCommand()).isEqualTo(StompCommand.CONNECT);
assertThat(headers1.getSessionId()).isEqualTo(StompBrokerRelayMessageHandler.SYSTEM_SESSION_ID);
}
@Test
@@ -149,16 +146,16 @@ public class StompBrokerRelayMessageHandlerTests {
this.brokerRelay.start();
this.brokerRelay.handleMessage(connectMessage("sess1", "joe"));
assertEquals(2, this.tcpClient.getSentMessages().size());
assertEquals(StompCommand.CONNECT, this.tcpClient.getSentHeaders(0).getCommand());
assertEquals(StompCommand.CONNECT, this.tcpClient.getSentHeaders(1).getCommand());
assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
assertThat(this.tcpClient.getSentHeaders(0).getCommand()).isEqualTo(StompCommand.CONNECT);
assertThat(this.tcpClient.getSentHeaders(1).getCommand()).isEqualTo(StompCommand.CONNECT);
this.tcpClient.handleMessage(message(StompCommand.MESSAGE, null, null, null));
Message<byte[]> message = this.outboundChannel.getMessages().get(0);
StompHeaderAccessor accessor = StompHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals("sess1", accessor.getSessionId());
assertEquals("joe", accessor.getUser().getName());
assertThat(accessor.getSessionId()).isEqualTo("sess1");
assertThat(accessor.getUser().getName()).isEqualTo("joe");
}
// SPR-12820
@@ -172,31 +169,31 @@ public class StompBrokerRelayMessageHandlerTests {
Message<byte[]> message = this.outboundChannel.getMessages().get(0);
StompHeaderAccessor accessor = StompHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.ERROR, accessor.getCommand());
assertEquals("sess1", accessor.getSessionId());
assertEquals("joe", accessor.getUser().getName());
assertEquals("Broker not available.", accessor.getMessage());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.ERROR);
assertThat(accessor.getSessionId()).isEqualTo("sess1");
assertThat(accessor.getUser().getName()).isEqualTo("joe");
assertThat(accessor.getMessage()).isEqualTo("Broker not available.");
}
@Test
public void sendAfterBrokerUnavailable() throws Exception {
this.brokerRelay.start();
assertEquals(1, this.brokerRelay.getConnectionCount());
assertThat(this.brokerRelay.getConnectionCount()).isEqualTo(1);
this.brokerRelay.handleMessage(connectMessage("sess1", "joe"));
assertEquals(2, this.brokerRelay.getConnectionCount());
assertThat(this.brokerRelay.getConnectionCount()).isEqualTo(2);
this.brokerRelay.stopInternal();
this.brokerRelay.handleMessage(message(StompCommand.SEND, "sess1", "joe", "/foo"));
assertEquals(1, this.brokerRelay.getConnectionCount());
assertThat(this.brokerRelay.getConnectionCount()).isEqualTo(1);
Message<byte[]> message = this.outboundChannel.getMessages().get(0);
StompHeaderAccessor accessor = StompHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertEquals(StompCommand.ERROR, accessor.getCommand());
assertEquals("sess1", accessor.getSessionId());
assertEquals("joe", accessor.getUser().getName());
assertEquals("Broker not available.", accessor.getMessage());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.ERROR);
assertThat(accessor.getSessionId()).isEqualTo("sess1");
assertThat(accessor.getUser().getName()).isEqualTo("joe");
assertThat(accessor.getMessage()).isEqualTo("Broker not available.");
}
@Test
@@ -211,17 +208,17 @@ public class StompBrokerRelayMessageHandlerTests {
MessageHeaders headers = accessor.getMessageHeaders();
this.tcpClient.handleMessage(MessageBuilder.createMessage(new byte[0], headers));
assertEquals(2, this.tcpClient.getSentMessages().size());
assertEquals(StompCommand.CONNECT, this.tcpClient.getSentHeaders(0).getCommand());
assertEquals(StompCommand.SUBSCRIBE, this.tcpClient.getSentHeaders(1).getCommand());
assertEquals("/topic/foo", this.tcpClient.getSentHeaders(1).getDestination());
assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
assertThat(this.tcpClient.getSentHeaders(0).getCommand()).isEqualTo(StompCommand.CONNECT);
assertThat(this.tcpClient.getSentHeaders(1).getCommand()).isEqualTo(StompCommand.SUBSCRIBE);
assertThat(this.tcpClient.getSentHeaders(1).getDestination()).isEqualTo("/topic/foo");
Message<byte[]> message = message(StompCommand.MESSAGE, null, null, "/topic/foo");
this.tcpClient.handleMessage(message);
ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class);
verify(handler).handleMessage(captor.capture());
assertSame(message, captor.getValue());
assertThat(captor.getValue()).isSameAs(message);
}
private Message<byte[]> connectMessage(String sessionId, String user) {
@@ -282,10 +279,10 @@ public class StompBrokerRelayMessageHandlerTests {
}
public StompHeaderAccessor getSentHeaders(int index) {
assertTrue("Size: " + getSentMessages().size(), getSentMessages().size() > index);
assertThat(getSentMessages().size() > index).as("Size: " + getSentMessages().size()).isTrue();
Message<byte[]> message = getSentMessages().get(index);
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
assertNotNull(accessor);
assertThat(accessor).isNotNull();
return accessor;
}

21
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompClientSupportTests.java
View File

@@ -18,11 +18,8 @@ package org.springframework.messaging.simp.stomp;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Unit tests for {@link StompClientSupport}.
@@ -47,24 +44,24 @@ public class StompClientSupportTests {
@Test
public void defaultHeartbeatValue() throws Exception {
assertArrayEquals(new long[] {10000, 10000}, this.stompClient.getDefaultHeartbeat());
assertThat(this.stompClient.getDefaultHeartbeat()).isEqualTo(new long[] {10000, 10000});
}
@Test
public void isDefaultHeartbeatEnabled() throws Exception {
assertArrayEquals(new long[] {10000, 10000}, this.stompClient.getDefaultHeartbeat());
assertTrue(this.stompClient.isDefaultHeartbeatEnabled());
assertThat(this.stompClient.getDefaultHeartbeat()).isEqualTo(new long[] {10000, 10000});
assertThat(this.stompClient.isDefaultHeartbeatEnabled()).isTrue();
this.stompClient.setDefaultHeartbeat(new long[] {0, 0});
assertFalse(this.stompClient.isDefaultHeartbeatEnabled());
assertThat(this.stompClient.isDefaultHeartbeatEnabled()).isFalse();
}
@Test
public void processConnectHeadersDefault() throws Exception {
StompHeaders connectHeaders = this.stompClient.processConnectHeaders(null);
assertNotNull(connectHeaders);
assertArrayEquals(new long[] {10000, 10000}, connectHeaders.getHeartbeat());
assertThat(connectHeaders).isNotNull();
assertThat(connectHeaders.getHeartbeat()).isEqualTo(new long[] {10000, 10000});
}
@Test
@@ -74,8 +71,8 @@ public class StompClientSupportTests {
connectHeaders.setHeartbeat(new long[] {15000, 15000});
connectHeaders = this.stompClient.processConnectHeaders(connectHeaders);
assertNotNull(connectHeaders);
assertArrayEquals(new long[] {15000, 15000}, connectHeaders.getHeartbeat());
assertThat(connectHeaders).isNotNull();
assertThat(connectHeaders.getHeartbeat()).isEqualTo(new long[] {15000, 15000});
}
}

13
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompCommandTests.java
View File

@@ -25,8 +25,7 @@ import org.junit.Test;
import org.springframework.messaging.simp.SimpMessageType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Juergen Hoeller
@@ -66,35 +65,35 @@ public class StompCommandTests {
if (simp == null) {
simp = SimpMessageType.OTHER;
}
assertSame(simp, stompCommand.getMessageType());
assertThat(stompCommand.getMessageType()).isSameAs(simp);
}
}
@Test
public void requiresDestination() throws Exception {
for (StompCommand stompCommand : StompCommand.values()) {
assertEquals(destinationRequired.contains(stompCommand), stompCommand.requiresDestination());
assertThat(stompCommand.requiresDestination()).isEqualTo(destinationRequired.contains(stompCommand));
}
}
@Test
public void requiresSubscriptionId() throws Exception {
for (StompCommand stompCommand : StompCommand.values()) {
assertEquals(subscriptionIdRequired.contains(stompCommand), stompCommand.requiresSubscriptionId());
assertThat(stompCommand.requiresSubscriptionId()).isEqualTo(subscriptionIdRequired.contains(stompCommand));
}
}
@Test
public void requiresContentLength() throws Exception {
for (StompCommand stompCommand : StompCommand.values()) {
assertEquals(contentLengthRequired.contains(stompCommand), stompCommand.requiresContentLength());
assertThat(stompCommand.requiresContentLength()).isEqualTo(contentLengthRequired.contains(stompCommand));
}
}
@Test
public void isBodyAllowed() throws Exception {
for (StompCommand stompCommand : StompCommand.values()) {
assertEquals(bodyAllowed.contains(stompCommand), stompCommand.isBodyAllowed());
assertThat(stompCommand.isBodyAllowed()).isEqualTo(bodyAllowed.contains(stompCommand));
}
}

95
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompDecoderTests.java
View File

@@ -26,9 +26,8 @@ import org.springframework.messaging.Message;
import org.springframework.messaging.simp.SimpMessageType;
import org.springframework.util.InvalidMimeTypeException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
/**
* Test fixture for {@link StompDecoder}.
@@ -46,9 +45,9 @@ public class StompDecoderTests {
Message<byte[]> frame = decode("DISCONNECT\r\n\r\n\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
assertEquals(StompCommand.DISCONNECT, headers.getCommand());
assertEquals(0, headers.toNativeHeaderMap().size());
assertEquals(0, frame.getPayload().length);
assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
assertThat(headers.toNativeHeaderMap().size()).isEqualTo(0);
assertThat(frame.getPayload().length).isEqualTo(0);
}
@Test
@@ -56,9 +55,9 @@ public class StompDecoderTests {
Message<byte[]> frame = decode("DISCONNECT\n\n\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
assertEquals(StompCommand.DISCONNECT, headers.getCommand());
assertEquals(0, headers.toNativeHeaderMap().size());
assertEquals(0, frame.getPayload().length);
assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
assertThat(headers.toNativeHeaderMap().size()).isEqualTo(0);
assertThat(frame.getPayload().length).isEqualTo(0);
}
@Test
@@ -69,13 +68,13 @@ public class StompDecoderTests {
Message<byte[]> frame = decode("CONNECT\n" + accept + host + "\n\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
assertEquals(StompCommand.CONNECT, headers.getCommand());
assertThat(headers.getCommand()).isEqualTo(StompCommand.CONNECT);
assertEquals(2, headers.toNativeHeaderMap().size());
assertEquals("1.1", headers.getFirstNativeHeader("accept-version"));
assertEquals("github.org", headers.getHost());
assertThat(headers.toNativeHeaderMap().size()).isEqualTo(2);
assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
assertThat(headers.getHost()).isEqualTo("github.org");
assertEquals(0, frame.getPayload().length);
assertThat(frame.getPayload().length).isEqualTo(0);
}
@Test
@@ -83,13 +82,13 @@ public class StompDecoderTests {
Message<byte[]> frame = decode("SEND\ndestination:test\n\nThe body of the message\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
assertEquals(StompCommand.SEND, headers.getCommand());
assertThat(headers.getCommand()).isEqualTo(StompCommand.SEND);
assertEquals(headers.toNativeHeaderMap().toString(), 1, headers.toNativeHeaderMap().size());
assertEquals("test", headers.getDestination());
assertThat(headers.toNativeHeaderMap().size()).as(headers.toNativeHeaderMap().toString()).isEqualTo(1);
assertThat(headers.getDestination()).isEqualTo("test");
String bodyText = new String(frame.getPayload());
assertEquals("The body of the message", bodyText);
assertThat(bodyText).isEqualTo("The body of the message");
}
@Test
@@ -97,13 +96,13 @@ public class StompDecoderTests {
Message<byte[]> message = decode("SEND\ncontent-length:23\n\nThe body of the message\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(message);
assertEquals(StompCommand.SEND, headers.getCommand());
assertThat(headers.getCommand()).isEqualTo(StompCommand.SEND);
assertEquals(1, headers.toNativeHeaderMap().size());
assertEquals(Integer.valueOf(23), headers.getContentLength());
assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
assertThat(headers.getContentLength()).isEqualTo(Integer.valueOf(23));
String bodyText = new String(message.getPayload());
assertEquals("The body of the message", bodyText);
assertThat(bodyText).isEqualTo("The body of the message");
}
// SPR-11528
@@ -113,13 +112,13 @@ public class StompDecoderTests {
Message<byte[]> message = decode("SEND\ncontent-length:-1\n\nThe body of the message\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(message);
assertEquals(StompCommand.SEND, headers.getCommand());
assertThat(headers.getCommand()).isEqualTo(StompCommand.SEND);
assertEquals(1, headers.toNativeHeaderMap().size());
assertEquals(Integer.valueOf(-1), headers.getContentLength());
assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
assertThat(headers.getContentLength()).isEqualTo(Integer.valueOf(-1));
String bodyText = new String(message.getPayload());
assertEquals("The body of the message", bodyText);
assertThat(bodyText).isEqualTo("The body of the message");
}
@Test
@@ -127,13 +126,13 @@ public class StompDecoderTests {
Message<byte[]> frame = decode("SEND\ncontent-length:0\n\n\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
assertEquals(StompCommand.SEND, headers.getCommand());
assertThat(headers.getCommand()).isEqualTo(StompCommand.SEND);
assertEquals(1, headers.toNativeHeaderMap().size());
assertEquals(Integer.valueOf(0), headers.getContentLength());
assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
assertThat(headers.getContentLength()).isEqualTo(Integer.valueOf(0));
String bodyText = new String(frame.getPayload());
assertEquals("", bodyText);
assertThat(bodyText).isEqualTo("");
}
@Test
@@ -141,13 +140,13 @@ public class StompDecoderTests {
Message<byte[]> frame = decode("SEND\ncontent-length:23\n\nThe b\0dy \0f the message\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
assertEquals(StompCommand.SEND, headers.getCommand());
assertThat(headers.getCommand()).isEqualTo(StompCommand.SEND);
assertEquals(1, headers.toNativeHeaderMap().size());
assertEquals(Integer.valueOf(23), headers.getContentLength());
assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
assertThat(headers.getContentLength()).isEqualTo(Integer.valueOf(23));
String bodyText = new String(frame.getPayload());
assertEquals("The b\0dy \0f the message", bodyText);
assertThat(bodyText).isEqualTo("The b\0dy \0f the message");
}
@Test
@@ -155,10 +154,10 @@ public class StompDecoderTests {
Message<byte[]> frame = decode("DISCONNECT\na\\c\\r\\n\\\\b:alpha\\cbravo\\r\\n\\\\\n\n\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
assertEquals(StompCommand.DISCONNECT, headers.getCommand());
assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
assertEquals(1, headers.toNativeHeaderMap().size());
assertEquals("alpha:bravo\r\n\\", headers.getFirstNativeHeader("a:\r\n\\b"));
assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
assertThat(headers.getFirstNativeHeader("a:\r\n\\b")).isEqualTo("alpha:bravo\r\n\\");
}
@Test
@@ -175,9 +174,9 @@ public class StompDecoderTests {
final List<Message<byte[]>> messages = decoder.decode(buffer);
assertEquals(2, messages.size());
assertEquals(StompCommand.SEND, StompHeaderAccessor.wrap(messages.get(0)).getCommand());
assertEquals(StompCommand.DISCONNECT, StompHeaderAccessor.wrap(messages.get(1)).getCommand());
assertThat(messages.size()).isEqualTo(2);
assertThat(StompHeaderAccessor.wrap(messages.get(0)).getCommand()).isEqualTo(StompCommand.SEND);
assertThat(StompHeaderAccessor.wrap(messages.get(1)).getCommand()).isEqualTo(StompCommand.DISCONNECT);
}
// SPR-13111
@@ -190,13 +189,13 @@ public class StompDecoderTests {
Message<byte[]> frame = decode("CONNECT\n" + accept + valuelessKey + "\n\0");
StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
assertEquals(StompCommand.CONNECT, headers.getCommand());
assertThat(headers.getCommand()).isEqualTo(StompCommand.CONNECT);
assertEquals(2, headers.toNativeHeaderMap().size());
assertEquals("1.1", headers.getFirstNativeHeader("accept-version"));
assertEquals("", headers.getFirstNativeHeader("key"));
assertThat(headers.toNativeHeaderMap().size()).isEqualTo(2);
assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
assertThat(headers.getFirstNativeHeader("key")).isEqualTo("");
assertEquals(0, frame.getPayload().length);
assertThat(frame.getPayload().length).isEqualTo(0);
}
@Test
@@ -248,14 +247,14 @@ public class StompDecoderTests {
final List<Message<byte[]>> messages = decoder.decode(buffer);
assertEquals(1, messages.size());
assertEquals(SimpMessageType.HEARTBEAT, StompHeaderAccessor.wrap(messages.get(0)).getMessageType());
assertThat(messages.size()).isEqualTo(1);
assertThat(StompHeaderAccessor.wrap(messages.get(0)).getMessageType()).isEqualTo(SimpMessageType.HEARTBEAT);
}
private void assertIncompleteDecode(String partialFrame) {
ByteBuffer buffer = ByteBuffer.wrap(partialFrame.getBytes());
assertNull(decode(buffer));
assertEquals(0, buffer.position());
assertThat(decode(buffer)).isNull();
assertThat(buffer.position()).isEqualTo(0);
}
private Message<byte[]> decode(String stompFrame) {

19
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompEncoderTests.java
View File

@@ -21,8 +21,7 @@ import org.junit.Test;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Test fixture for {@link StompEncoder}.
@@ -40,7 +39,7 @@ public class StompEncoderTests {
StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.DISCONNECT);
Message<byte[]> frame = MessageBuilder.createMessage(new byte[0], headers.getMessageHeaders());
assertEquals("DISCONNECT\n\n\0", new String(encoder.encode(frame)));
assertThat(new String(encoder.encode(frame))).isEqualTo("DISCONNECT\n\n\0");
}
@Test
@@ -51,9 +50,8 @@ public class StompEncoderTests {
Message<byte[]> frame = MessageBuilder.createMessage(new byte[0], headers.getMessageHeaders());
String frameString = new String(encoder.encode(frame));
assertTrue(
"CONNECT\naccept-version:1.2\nhost:github.org\n\n\0".equals(frameString) ||
"CONNECT\nhost:github.org\naccept-version:1.2\n\n\0".equals(frameString));
assertThat("CONNECT\naccept-version:1.2\nhost:github.org\n\n\0".equals(frameString) ||
"CONNECT\nhost:github.org\naccept-version:1.2\n\n\0".equals(frameString)).isTrue();
}
@Test
@@ -62,8 +60,7 @@ public class StompEncoderTests {
headers.addNativeHeader("a:\r\n\\b", "alpha:bravo\r\n\\");
Message<byte[]> frame = MessageBuilder.createMessage(new byte[0], headers.getMessageHeaders());
assertEquals("DISCONNECT\na\\c\\r\\n\\\\b:alpha\\cbravo\\r\\n\\\\\n\n\0",
new String(encoder.encode(frame)));
assertThat(new String(encoder.encode(frame))).isEqualTo("DISCONNECT\na\\c\\r\\n\\\\b:alpha\\cbravo\\r\\n\\\\\n\n\0");
}
@Test
@@ -73,8 +70,7 @@ public class StompEncoderTests {
Message<byte[]> frame = MessageBuilder.createMessage(
"Message body".getBytes(), headers.getMessageHeaders());
assertEquals("SEND\na:alpha\ncontent-length:12\n\nMessage body\0",
new String(encoder.encode(frame)));
assertThat(new String(encoder.encode(frame))).isEqualTo("SEND\na:alpha\ncontent-length:12\n\nMessage body\0");
}
@Test
@@ -84,8 +80,7 @@ public class StompEncoderTests {
Message<byte[]> frame = MessageBuilder.createMessage(
"Message body".getBytes(), headers.getMessageHeaders());
assertEquals("SEND\ncontent-length:12\n\nMessage body\0",
new String(encoder.encode(frame)));
assertThat(new String(encoder.encode(frame))).isEqualTo("SEND\ncontent-length:12\n\nMessage body\0");
}
}

88
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompHeaderAccessorTests.java
View File

@@ -37,10 +37,6 @@ import org.springframework.util.MimeTypeUtils;
import org.springframework.util.MultiValueMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
/**
* Unit tests for {@link StompHeaderAccessor}.
@@ -53,10 +49,10 @@ public class StompHeaderAccessorTests {
@Test
public void createWithCommand() {
StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.CONNECTED);
assertEquals(StompCommand.CONNECTED, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.CONNECTED);
accessor = StompHeaderAccessor.create(StompCommand.CONNECTED, new LinkedMultiValueMap<>());
assertEquals(StompCommand.CONNECTED, accessor.getCommand());
assertThat(accessor.getCommand()).isEqualTo(StompCommand.CONNECTED);
}
@Test
@@ -67,10 +63,10 @@ public class StompHeaderAccessorTests {
StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.SUBSCRIBE, extHeaders);
assertEquals(StompCommand.SUBSCRIBE, headers.getCommand());
assertEquals(SimpMessageType.SUBSCRIBE, headers.getMessageType());
assertEquals("/d", headers.getDestination());
assertEquals("s1", headers.getSubscriptionId());
assertThat(headers.getCommand()).isEqualTo(StompCommand.SUBSCRIBE);
assertThat(headers.getMessageType()).isEqualTo(SimpMessageType.SUBSCRIBE);
assertThat(headers.getDestination()).isEqualTo("/d");
assertThat(headers.getSubscriptionId()).isEqualTo("s1");
}
@Test
@@ -80,9 +76,9 @@ public class StompHeaderAccessorTests {
StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.UNSUBSCRIBE, extHeaders);
assertEquals(StompCommand.UNSUBSCRIBE, headers.getCommand());
assertEquals(SimpMessageType.UNSUBSCRIBE, headers.getMessageType());
assertEquals("s1", headers.getSubscriptionId());
assertThat(headers.getCommand()).isEqualTo(StompCommand.UNSUBSCRIBE);
assertThat(headers.getMessageType()).isEqualTo(SimpMessageType.UNSUBSCRIBE);
assertThat(headers.getSubscriptionId()).isEqualTo("s1");
}
@Test
@@ -94,9 +90,9 @@ public class StompHeaderAccessorTests {
StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.MESSAGE, extHeaders);
assertEquals(StompCommand.MESSAGE, headers.getCommand());
assertEquals(SimpMessageType.MESSAGE, headers.getMessageType());
assertEquals("s1", headers.getSubscriptionId());
assertThat(headers.getCommand()).isEqualTo(StompCommand.MESSAGE);
assertThat(headers.getMessageType()).isEqualTo(SimpMessageType.MESSAGE);
assertThat(headers.getSubscriptionId()).isEqualTo("s1");
}
@Test
@@ -107,16 +103,16 @@ public class StompHeaderAccessorTests {
StompHeaderAccessor headerAccessor = StompHeaderAccessor.create(StompCommand.STOMP, extHeaders);
assertEquals(StompCommand.STOMP, headerAccessor.getCommand());
assertEquals(SimpMessageType.CONNECT, headerAccessor.getMessageType());
assertNotNull(headerAccessor.getHeader("stompCredentials"));
assertEquals("joe", headerAccessor.getLogin());
assertEquals("joe123", headerAccessor.getPasscode());
assertThat(headerAccessor.getCommand()).isEqualTo(StompCommand.STOMP);
assertThat(headerAccessor.getMessageType()).isEqualTo(SimpMessageType.CONNECT);
assertThat(headerAccessor.getHeader("stompCredentials")).isNotNull();
assertThat(headerAccessor.getLogin()).isEqualTo("joe");
assertThat(headerAccessor.getPasscode()).isEqualTo("joe123");
assertThat(headerAccessor.toString()).contains("passcode=[PROTECTED]");
Map<String, List<String>> output = headerAccessor.toNativeHeaderMap();
assertEquals("joe", output.get(StompHeaderAccessor.STOMP_LOGIN_HEADER).get(0));
assertEquals("PROTECTED", output.get(StompHeaderAccessor.STOMP_PASSCODE_HEADER).get(0));
assertThat(output.get(StompHeaderAccessor.STOMP_LOGIN_HEADER).get(0)).isEqualTo("joe");
assertThat(output.get(StompHeaderAccessor.STOMP_PASSCODE_HEADER).get(0)).isEqualTo("PROTECTED");
}
@Test
@@ -127,9 +123,9 @@ public class StompHeaderAccessorTests {
Map<String, List<String>> actual = headers.toNativeHeaderMap();
assertEquals(2, actual.size());
assertEquals("s1", actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0));
assertEquals("/d", actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0));
assertThat(actual.size()).isEqualTo(2);
assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0)).isEqualTo("s1");
assertThat(actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0)).isEqualTo("/d");
}
@Test
@@ -139,8 +135,8 @@ public class StompHeaderAccessorTests {
Map<String, List<String>> actual = headers.toNativeHeaderMap();
assertEquals(1, actual.size());
assertEquals("s1", actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0));
assertThat(actual.size()).isEqualTo(1);
assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0)).isEqualTo("s1");
}
@Test
@@ -153,11 +149,11 @@ public class StompHeaderAccessorTests {
Map<String, List<String>> actual = headers.toNativeHeaderMap();
assertEquals(actual.toString(), 4, actual.size());
assertEquals("s1", actual.get(StompHeaderAccessor.STOMP_SUBSCRIPTION_HEADER).get(0));
assertEquals("/d", actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0));
assertEquals("application/json", actual.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0));
assertNotNull("message-id was not created", actual.get(StompHeaderAccessor.STOMP_MESSAGE_ID_HEADER).get(0));
assertThat(actual.size()).as(actual.toString()).isEqualTo(4);
assertThat(actual.get(StompHeaderAccessor.STOMP_SUBSCRIPTION_HEADER).get(0)).isEqualTo("s1");
assertThat(actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0)).isEqualTo("/d");
assertThat(actual.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0)).isEqualTo("application/json");
assertThat(actual.get(StompHeaderAccessor.STOMP_MESSAGE_ID_HEADER).get(0)).as("message-id was not created").isNotNull();
}
@Test
@@ -169,7 +165,7 @@ public class StompHeaderAccessorTests {
StompHeaderAccessor stompHeaderAccessor = StompHeaderAccessor.wrap(message);
Map<String, List<String>> map = stompHeaderAccessor.toNativeHeaderMap();
assertEquals("application/atom+xml", map.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0));
assertThat(map.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0)).isEqualTo("application/atom+xml");
}
@Test
@@ -182,7 +178,7 @@ public class StompHeaderAccessorTests {
Message<byte[]> message = MessageBuilder.createMessage(new byte[0], headerAccessor.getMessageHeaders());
byte[] bytes = new StompEncoder().encode(message);
assertEquals("CONNECT\nlogin:joe\npasscode:joe123\n\n\0", new String(bytes, "UTF-8"));
assertThat(new String(bytes, "UTF-8")).isEqualTo("CONNECT\nlogin:joe\npasscode:joe123\n\n\0");
}
@Test
@@ -197,11 +193,11 @@ public class StompHeaderAccessorTests {
headers.setNativeHeader("accountId", accountId.toLowerCase());
Map<String, List<String>> actual = headers.toNativeHeaderMap();
assertEquals(3, actual.size());
assertThat(actual.size()).isEqualTo(3);
assertEquals("s1", actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0));
assertEquals("/d", actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0));
assertNotNull("abc123", actual.get("accountId").get(0));
assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0)).isEqualTo("s1");
assertThat(actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0)).isEqualTo("/d");
assertThat(actual.get("accountId").get(0)).as("abc123").isNotNull();
}
@Test
@@ -209,8 +205,8 @@ public class StompHeaderAccessorTests {
StompHeaderAccessor headerAccessor = StompHeaderAccessor.create(StompCommand.SEND);
MessageHeaders headers = headerAccessor.getMessageHeaders();
assertNull(headers.getId());
assertNull(headers.getTimestamp());
assertThat((Object) headers.getId()).isNull();
assertThat((Object) headers.getTimestamp()).isNull();
}
@Test
@@ -222,8 +218,8 @@ public class StompHeaderAccessorTests {
StompHeaderAccessor headerAccessor = StompHeaderAccessor.create(StompCommand.SEND);
headerInitializer.initHeaders(headerAccessor);
assertNotNull(headerAccessor.getMessageHeaders().getId());
assertNotNull(headerAccessor.getMessageHeaders().getTimestamp());
assertThat(headerAccessor.getMessageHeaders().getId()).isNotNull();
assertThat(headerAccessor.getMessageHeaders().getTimestamp()).isNotNull();
}
@Test
@@ -231,7 +227,7 @@ public class StompHeaderAccessorTests {
StompHeaderAccessor headerAccessor = StompHeaderAccessor.create(StompCommand.CONNECT);
Message<byte[]> message = MessageBuilder.createMessage(new byte[0], headerAccessor.getMessageHeaders());
assertSame(headerAccessor, MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class));
assertThat(MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class)).isSameAs(headerAccessor);
}
@Test
@@ -241,7 +237,7 @@ public class StompHeaderAccessorTests {
accessor.setContentType(MimeTypeUtils.APPLICATION_JSON);
accessor.setSessionId("123");
String actual = accessor.getShortLogMessage("payload".getBytes(StandardCharsets.UTF_8));
assertEquals("SEND /foo session=123 application/json payload=payload", actual);
assertThat(actual).isEqualTo("SEND /foo session=123 application/json payload=payload");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 80; i++) {
@@ -249,7 +245,7 @@ public class StompHeaderAccessorTests {
}
final String payload = sb.toString() + " > 80";
actual = accessor.getShortLogMessage(payload.getBytes(StandardCharsets.UTF_8));
assertEquals("SEND /foo session=123 application/json payload=" + sb + "...(truncated)", actual);
assertThat(actual).isEqualTo(("SEND /foo session=123 application/json payload=" + sb + "...(truncated)"));
}
}

85
spring-messaging/src/test/java/org/springframework/messaging/simp/user/DefaultUserDestinationResolverTests.java
View File

@@ -28,8 +28,7 @@ import org.springframework.messaging.simp.TestPrincipal;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.StringUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -65,11 +64,11 @@ public class DefaultUserDestinationResolverTests {
Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, user, "123", sourceDestination);
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(sourceDestination, actual.getSourceDestination());
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("/queue/foo-user123", actual.getTargetDestinations().iterator().next());
assertEquals(sourceDestination, actual.getSubscribeDestination());
assertEquals(user.getName(), actual.getUser());
assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user123");
assertThat(actual.getSubscribeDestination()).isEqualTo(sourceDestination);
assertThat(actual.getUser()).isEqualTo(user.getName());
}
@Test // SPR-14044
@@ -81,9 +80,9 @@ public class DefaultUserDestinationResolverTests {
Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, user, "123", destination);
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("jms.queue.call-user123", actual.getTargetDestinations().iterator().next());
assertEquals(destination, actual.getSubscribeDestination());
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("jms.queue.call-user123");
assertThat(actual.getSubscribeDestination()).isEqualTo(destination);
}
@Test // SPR-11325
@@ -97,8 +96,8 @@ public class DefaultUserDestinationResolverTests {
Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, user, "456", "/user/queue/foo");
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("/queue/foo-user456", actual.getTargetDestinations().iterator().next());
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user456");
}
@Test
@@ -107,11 +106,11 @@ public class DefaultUserDestinationResolverTests {
Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, null, "123", sourceDestination);
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(sourceDestination, actual.getSourceDestination());
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("/queue/foo-user" + "123", actual.getTargetDestinations().iterator().next());
assertEquals(sourceDestination, actual.getSubscribeDestination());
assertNull(actual.getUser());
assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo(("/queue/foo-user" + "123"));
assertThat(actual.getSubscribeDestination()).isEqualTo(sourceDestination);
assertThat(actual.getUser()).isNull();
}
@Test
@@ -120,8 +119,8 @@ public class DefaultUserDestinationResolverTests {
Message<?> message = createMessage(SimpMessageType.UNSUBSCRIBE, user, "123", "/user/queue/foo");
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("/queue/foo-user123", actual.getTargetDestinations().iterator().next());
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user123");
}
@Test
@@ -131,11 +130,11 @@ public class DefaultUserDestinationResolverTests {
Message<?> message = createMessage(SimpMessageType.MESSAGE, user, "123", sourceDestination);
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(sourceDestination, actual.getSourceDestination());
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("/queue/foo-user123", actual.getTargetDestinations().iterator().next());
assertEquals("/user/queue/foo", actual.getSubscribeDestination());
assertEquals(user.getName(), actual.getUser());
assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user123");
assertThat(actual.getSubscribeDestination()).isEqualTo("/user/queue/foo");
assertThat(actual.getUser()).isEqualTo(user.getName());
}
@Test // SPR-14044
@@ -147,9 +146,9 @@ public class DefaultUserDestinationResolverTests {
Message<?> message = createMessage(SimpMessageType.MESSAGE, user, "123", destination);
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("jms.queue.call-user123", actual.getTargetDestinations().iterator().next());
assertEquals("/user/jms.queue.call", actual.getSubscribeDestination());
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("jms.queue.call-user123");
assertThat(actual.getSubscribeDestination()).isEqualTo("/user/jms.queue.call");
}
@Test // SPR-12444
@@ -166,11 +165,11 @@ public class DefaultUserDestinationResolverTests {
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(sourceDestination, actual.getSourceDestination());
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("/queue/foo-user456", actual.getTargetDestinations().iterator().next());
assertEquals("/user/queue/foo", actual.getSubscribeDestination());
assertEquals(otherUser.getName(), actual.getUser());
assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user456");
assertThat(actual.getSubscribeDestination()).isEqualTo("/user/queue/foo");
assertThat(actual.getUser()).isEqualTo(otherUser.getName());
}
@Test
@@ -186,8 +185,8 @@ public class DefaultUserDestinationResolverTests {
Message<?> message = createMessage(SimpMessageType.MESSAGE, new TestPrincipal("joe"), null, destination);
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("/queue/foo-useropenid123", actual.getTargetDestinations().iterator().next());
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-useropenid123");
}
@Test
@@ -196,11 +195,11 @@ public class DefaultUserDestinationResolverTests {
Message<?> message = createMessage(SimpMessageType.MESSAGE, null, "123", sourceDestination);
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertEquals(sourceDestination, actual.getSourceDestination());
assertEquals(1, actual.getTargetDestinations().size());
assertEquals("/queue/foo-user123", actual.getTargetDestinations().iterator().next());
assertEquals("/user/queue/foo", actual.getSubscribeDestination());
assertNull(actual.getUser());
assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user123");
assertThat(actual.getSubscribeDestination()).isEqualTo("/user/queue/foo");
assertThat(actual.getUser()).isNull();
}
@Test
@@ -210,22 +209,22 @@ public class DefaultUserDestinationResolverTests {
TestPrincipal user = new TestPrincipal("joe");
Message<?> message = createMessage(SimpMessageType.MESSAGE, user, "123", null);
UserDestinationResult actual = this.resolver.resolveDestination(message);
assertNull(actual);
assertThat(actual).isNull();
// not a user destination
message = createMessage(SimpMessageType.MESSAGE, user, "123", "/queue/foo");
actual = this.resolver.resolveDestination(message);
assertNull(actual);
assertThat(actual).isNull();
// subscribe + not a user destination
message = createMessage(SimpMessageType.SUBSCRIBE, user, "123", "/queue/foo");
actual = this.resolver.resolveDestination(message);
assertNull(actual);
assertThat(actual).isNull();
// no match on message type
message = createMessage(SimpMessageType.CONNECT, user, "123", "user/joe/queue/foo");
actual = this.resolver.resolveDestination(message);
assertNull(actual);
assertThat(actual).isNull();
}
private Message<?> createMessage(SimpMessageType type, Principal user, String sessionId, String destination) {

56
spring-messaging/src/test/java/org/springframework/messaging/simp/user/MultiServerUserRegistryTests.java
View File

@@ -31,10 +31,6 @@ import org.springframework.messaging.converter.MappingJackson2MessageConverter;
import org.springframework.messaging.converter.MessageConverter;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -68,8 +64,8 @@ public class MultiServerUserRegistryTests {
given(this.localRegistry.getUserCount()).willReturn(1);
given(this.localRegistry.getUser("joe")).willReturn(user);
assertEquals(1, this.registry.getUserCount());
assertSame(user, this.registry.getUser("joe"));
assertThat(this.registry.getUserCount()).isEqualTo(1);
assertThat(this.registry.getUser("joe")).isSameAs(user);
}
@Test
@@ -87,20 +83,20 @@ public class MultiServerUserRegistryTests {
// Add remote registry
this.registry.addRemoteRegistryDto(message, this.converter, 20000);
assertEquals(1, this.registry.getUserCount());
assertThat(this.registry.getUserCount()).isEqualTo(1);
SimpUser user = this.registry.getUser("joe");
assertNotNull(user);
assertTrue(user.hasSessions());
assertEquals(1, user.getSessions().size());
assertThat(user).isNotNull();
assertThat(user.hasSessions()).isTrue();
assertThat(user.getSessions().size()).isEqualTo(1);
SimpSession session = user.getSession("remote-sess");
assertNotNull(session);
assertEquals("remote-sess", session.getId());
assertSame(user, session.getUser());
assertEquals(1, session.getSubscriptions().size());
assertThat(session).isNotNull();
assertThat(session.getId()).isEqualTo("remote-sess");
assertThat(session.getUser()).isSameAs(user);
assertThat(session.getSubscriptions().size()).isEqualTo(1);
SimpSubscription subscription = session.getSubscriptions().iterator().next();
assertEquals("remote-sub", subscription.getId());
assertSame(session, subscription.getSession());
assertEquals("/remote-dest", subscription.getDestination());
assertThat(subscription.getId()).isEqualTo("remote-sub");
assertThat(subscription.getSession()).isSameAs(session);
assertThat(subscription.getDestination()).isEqualTo("/remote-dest");
}
@Test
@@ -126,14 +122,14 @@ public class MultiServerUserRegistryTests {
// Add remote registry
this.registry.addRemoteRegistryDto(message, this.converter, 20000);
assertEquals(3, this.registry.getUserCount());
assertThat(this.registry.getUserCount()).isEqualTo(3);
Set<SimpSubscription> matches = this.registry.findSubscriptions(s -> s.getDestination().equals("/match"));
assertEquals(2, matches.size());
assertThat(matches.size()).isEqualTo(2);
Iterator<SimpSubscription> iterator = matches.iterator();
Set<String> sessionIds = new HashSet<>(2);
sessionIds.add(iterator.next().getSession().getId());
sessionIds.add(iterator.next().getSession().getId());
assertEquals(new HashSet<>(Arrays.asList("sess1", "sess2")), sessionIds);
assertThat(sessionIds).isEqualTo(new HashSet<>(Arrays.asList("sess1", "sess2")));
}
@Test // SPR-13800
@@ -157,19 +153,19 @@ public class MultiServerUserRegistryTests {
this.registry.addRemoteRegistryDto(message, this.converter, 20000);
assertEquals(1, this.registry.getUserCount());
assertThat(this.registry.getUserCount()).isEqualTo(1);
SimpUser user = this.registry.getUsers().iterator().next();
assertTrue(user.hasSessions());
assertEquals(2, user.getSessions().size());
assertThat(user.hasSessions()).isTrue();
assertThat(user.getSessions().size()).isEqualTo(2);
assertThat(user.getSessions()).containsExactlyInAnyOrder(localSession, remoteSession);
assertSame(localSession, user.getSession("sess123"));
assertEquals(remoteSession, user.getSession("sess456"));
assertThat(user.getSession("sess123")).isSameAs(localSession);
assertThat(user.getSession("sess456")).isEqualTo(remoteSession);
user = this.registry.getUser("joe");
assertEquals(2, user.getSessions().size());
assertThat(user.getSessions().size()).isEqualTo(2);
assertThat(user.getSessions()).containsExactlyInAnyOrder(localSession, remoteSession);
assertSame(localSession, user.getSession("sess123"));
assertEquals(remoteSession, user.getSession("sess456"));
assertThat(user.getSession("sess123")).isSameAs(localSession);
assertThat(user.getSession("sess456")).isEqualTo(remoteSession);
}
@Test
@@ -186,9 +182,9 @@ public class MultiServerUserRegistryTests {
this.registry.addRemoteRegistryDto(message, this.converter, -1);
assertEquals(1, this.registry.getUserCount());
assertThat(this.registry.getUserCount()).isEqualTo(1);
this.registry.purgeExpiredRegistries();
assertEquals(0, this.registry.getUserCount());
assertThat(this.registry.getUserCount()).isEqualTo(0);
}
}

26
spring-messaging/src/test/java/org/springframework/messaging/simp/user/UserDestinationMessageHandlerTests.java
View File

@@ -33,9 +33,7 @@ import org.springframework.messaging.simp.stomp.StompCommand;
import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
import org.springframework.messaging.support.MessageBuilder;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -74,7 +72,7 @@ public class UserDestinationMessageHandlerTests {
Mockito.verify(this.brokerChannel).send(captor.capture());
Message message = captor.getValue();
assertEquals("/queue/foo-user123", SimpMessageHeaderAccessor.getDestination(message.getHeaders()));
assertThat(SimpMessageHeaderAccessor.getDestination(message.getHeaders())).isEqualTo("/queue/foo-user123");
}
@Test
@@ -86,7 +84,7 @@ public class UserDestinationMessageHandlerTests {
Mockito.verify(this.brokerChannel).send(captor.capture());
Message message = captor.getValue();
assertEquals("/queue/foo-user123", SimpMessageHeaderAccessor.getDestination(message.getHeaders()));
assertThat(SimpMessageHeaderAccessor.getDestination(message.getHeaders())).isEqualTo("/queue/foo-user123");
}
@Test
@@ -101,8 +99,8 @@ public class UserDestinationMessageHandlerTests {
Mockito.verify(this.brokerChannel).send(captor.capture());
SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.wrap(captor.getValue());
assertEquals("/queue/foo-user123", accessor.getDestination());
assertEquals("/user/queue/foo", accessor.getFirstNativeHeader(ORIGINAL_DESTINATION));
assertThat(accessor.getDestination()).isEqualTo("/queue/foo-user123");
assertThat(accessor.getFirstNativeHeader(ORIGINAL_DESTINATION)).isEqualTo("/user/queue/foo");
}
@Test
@@ -116,8 +114,8 @@ public class UserDestinationMessageHandlerTests {
Message message = captor.getValue();
SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.wrap(message);
assertEquals("/topic/unresolved", accessor.getDestination());
assertEquals("/user/joe/queue/foo", accessor.getFirstNativeHeader(ORIGINAL_DESTINATION));
assertThat(accessor.getDestination()).isEqualTo("/topic/unresolved");
assertThat(accessor.getFirstNativeHeader(ORIGINAL_DESTINATION)).isEqualTo("/user/joe/queue/foo");
// Should ignore our own broadcast to brokerChannel
@@ -145,12 +143,12 @@ public class UserDestinationMessageHandlerTests {
ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class);
Mockito.verify(this.brokerChannel).send(captor.capture());
assertNotNull(captor.getValue());
assertThat(captor.getValue()).isNotNull();
SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.wrap(captor.getValue());
assertEquals("/queue/foo-user123", headers.getDestination());
assertEquals("/user/queue/foo", headers.getFirstNativeHeader(ORIGINAL_DESTINATION));
assertEquals("customHeaderValue", headers.getFirstNativeHeader("customHeader"));
assertArrayEquals(payload, (byte[]) captor.getValue().getPayload());
assertThat(headers.getDestination()).isEqualTo("/queue/foo-user123");
assertThat(headers.getFirstNativeHeader(ORIGINAL_DESTINATION)).isEqualTo("/user/queue/foo");
assertThat(headers.getFirstNativeHeader("customHeader")).isEqualTo("customHeaderValue");
assertThat((byte[]) captor.getValue().getPayload()).isEqualTo(payload);
}
@Test

25
spring-messaging/src/test/java/org/springframework/messaging/simp/user/UserRegistryMessageHandlerTests.java
View File

@@ -38,8 +38,7 @@ import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.messaging.simp.broker.BrokerAvailabilityEvent;
import org.springframework.scheduling.TaskScheduler;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
@@ -89,7 +88,7 @@ public class UserRegistryMessageHandlerTests {
@Test
public void brokerAvailableEvent() throws Exception {
Runnable runnable = getUserRegistryTask();
assertNotNull(runnable);
assertThat(runnable).isNotNull();
}
@SuppressWarnings("unchecked")
@@ -126,15 +125,15 @@ public class UserRegistryMessageHandlerTests {
verify(this.brokerChannel).send(captor.capture());
Message<?> message = captor.getValue();
assertNotNull(message);
assertThat(message).isNotNull();
MessageHeaders headers = message.getHeaders();
assertEquals("/topic/simp-user-registry", SimpMessageHeaderAccessor.getDestination(headers));
assertThat(SimpMessageHeaderAccessor.getDestination(headers)).isEqualTo("/topic/simp-user-registry");
MultiServerUserRegistry remoteRegistry = new MultiServerUserRegistry(mock(SimpUserRegistry.class));
remoteRegistry.addRemoteRegistryDto(message, this.converter, 20000);
assertEquals(2, remoteRegistry.getUserCount());
assertNotNull(remoteRegistry.getUser("joe"));
assertNotNull(remoteRegistry.getUser("jane"));
assertThat(remoteRegistry.getUserCount()).isEqualTo(2);
assertThat(remoteRegistry.getUser("joe")).isNotNull();
assertThat(remoteRegistry.getUser("jane")).isNotNull();
}
@Test
@@ -156,9 +155,9 @@ public class UserRegistryMessageHandlerTests {
this.handler.handleMessage(message);
assertEquals(2, remoteRegistry.getUserCount());
assertNotNull(this.multiServerRegistry.getUser("joe"));
assertNotNull(this.multiServerRegistry.getUser("jane"));
assertThat(remoteRegistry.getUserCount()).isEqualTo(2);
assertThat(this.multiServerRegistry.getUser("joe")).isNotNull();
assertThat(this.multiServerRegistry.getUser("jane")).isNotNull();
}
@Test
@@ -169,11 +168,11 @@ public class UserRegistryMessageHandlerTests {
given(this.localRegistry.getUserCount()).willReturn(1);
given(this.localRegistry.getUsers()).willReturn(Collections.singleton(simpUser));
assertEquals(1, this.multiServerRegistry.getUserCount());
assertThat(this.multiServerRegistry.getUserCount()).isEqualTo(1);
Message<?> message = this.converter.toMessage(this.multiServerRegistry.getLocalRegistryDto(), null);
this.multiServerRegistry.addRemoteRegistryDto(message, this.converter, 20000);
assertEquals(1, this.multiServerRegistry.getUserCount());
assertThat(this.multiServerRegistry.getUserCount()).isEqualTo(1);
}

62
spring-messaging/src/test/java/org/springframework/messaging/support/ChannelInterceptorTests.java
View File

@@ -29,11 +29,7 @@ import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessagingException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@@ -64,12 +60,12 @@ public class ChannelInterceptorTests {
this.channel.addInterceptor(interceptor);
this.channel.send(MessageBuilder.withPayload("test").build());
assertEquals(1, this.messageHandler.getMessages().size());
assertThat(this.messageHandler.getMessages().size()).isEqualTo(1);
Message<?> result = this.messageHandler.getMessages().get(0);
assertNotNull(result);
assertSame(expected, result);
assertTrue(interceptor.wasAfterCompletionInvoked());
assertThat(result).isNotNull();
assertThat(result).isSameAs(expected);
assertThat(interceptor.wasAfterCompletionInvoked()).isTrue();
}
@Test
@@ -81,11 +77,11 @@ public class ChannelInterceptorTests {
Message<?> message = MessageBuilder.withPayload("test").build();
this.channel.send(message);
assertEquals(1, interceptor1.getCounter().get());
assertEquals(1, interceptor2.getCounter().get());
assertEquals(0, this.messageHandler.getMessages().size());
assertTrue(interceptor1.wasAfterCompletionInvoked());
assertFalse(interceptor2.wasAfterCompletionInvoked());
assertThat(interceptor1.getCounter().get()).isEqualTo(1);
assertThat(interceptor2.getCounter().get()).isEqualTo(1);
assertThat(this.messageHandler.getMessages().size()).isEqualTo(0);
assertThat(interceptor1.wasAfterCompletionInvoked()).isTrue();
assertThat(interceptor2.wasAfterCompletionInvoked()).isFalse();
}
@Test
@@ -104,15 +100,15 @@ public class ChannelInterceptorTests {
completionInvoked.set(true);
}
private void assertInput(Message<?> message, MessageChannel channel, boolean sent) {
assertNotNull(message);
assertNotNull(channel);
assertSame(ChannelInterceptorTests.this.channel, channel);
assertTrue(sent);
assertThat(message).isNotNull();
assertThat(channel).isNotNull();
assertThat(channel).isSameAs(ChannelInterceptorTests.this.channel);
assertThat(sent).isTrue();
}
});
this.channel.send(MessageBuilder.withPayload("test").build());
assertTrue(preSendInvoked.get());
assertTrue(completionInvoked.get());
assertThat(preSendInvoked.get()).isTrue();
assertThat(completionInvoked.get()).isTrue();
}
@Test
@@ -137,15 +133,15 @@ public class ChannelInterceptorTests {
completionInvoked.set(true);
}
private void assertInput(Message<?> message, MessageChannel channel, boolean sent) {
assertNotNull(message);
assertNotNull(channel);
assertSame(testChannel, channel);
assertFalse(sent);
assertThat(message).isNotNull();
assertThat(channel).isNotNull();
assertThat(channel).isSameAs(testChannel);
assertThat(sent).isFalse();
}
});
testChannel.send(MessageBuilder.withPayload("test").build());
assertTrue(preSendInvoked.get());
assertTrue(completionInvoked.get());
assertThat(preSendInvoked.get()).isTrue();
assertThat(completionInvoked.get()).isTrue();
}
@Test
@@ -164,10 +160,10 @@ public class ChannelInterceptorTests {
testChannel.send(MessageBuilder.withPayload("test").build());
}
catch (Exception ex) {
assertEquals("Simulated exception", ex.getCause().getMessage());
assertThat(ex.getCause().getMessage()).isEqualTo("Simulated exception");
}
assertTrue(interceptor1.wasAfterCompletionInvoked());
assertTrue(interceptor2.wasAfterCompletionInvoked());
assertThat(interceptor1.wasAfterCompletionInvoked()).isTrue();
assertThat(interceptor2.wasAfterCompletionInvoked()).isTrue();
}
@Test
@@ -181,10 +177,10 @@ public class ChannelInterceptorTests {
this.channel.send(MessageBuilder.withPayload("test").build());
}
catch (Exception ex) {
assertEquals("Simulated exception", ex.getCause().getMessage());
assertThat(ex.getCause().getMessage()).isEqualTo("Simulated exception");
}
assertTrue(interceptor1.wasAfterCompletionInvoked());
assertFalse(interceptor2.wasAfterCompletionInvoked());
assertThat(interceptor1.wasAfterCompletionInvoked()).isTrue();
assertThat(interceptor2.wasAfterCompletionInvoked()).isFalse();
}
@@ -219,7 +215,7 @@ public class ChannelInterceptorTests {
@Override
public Message<?> preSend(Message<?> message, MessageChannel channel) {
assertNotNull(message);
assertThat(message).isNotNull();
counter.incrementAndGet();
return message;
}

30
spring-messaging/src/test/java/org/springframework/messaging/support/ExecutorSubscribableChannelTests.java
View File

@@ -33,10 +33,6 @@ import org.springframework.messaging.MessageHandler;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.willThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
@@ -85,8 +81,8 @@ public class ExecutorSubscribableChannelTests {
this.channel.subscribe(this.handler);
this.channel.send(this.message);
verify(this.handler).handleMessage(this.message);
assertEquals(1, interceptor.getCounter().get());
assertTrue(interceptor.wasAfterHandledInvoked());
assertThat(interceptor.getCounter().get()).isEqualTo(1);
assertThat(interceptor.wasAfterHandledInvoked()).isTrue();
}
@Test
@@ -101,8 +97,8 @@ public class ExecutorSubscribableChannelTests {
verify(this.handler, never()).handleMessage(this.message);
this.runnableCaptor.getValue().run();
verify(this.handler).handleMessage(this.message);
assertEquals(1, interceptor.getCounter().get());
assertTrue(interceptor.wasAfterHandledInvoked());
assertThat(interceptor.getCounter().get()).isEqualTo(1);
assertThat(interceptor.wasAfterHandledInvoked()).isTrue();
}
@Test
@@ -155,8 +151,8 @@ public class ExecutorSubscribableChannelTests {
this.channel.subscribe(this.handler);
this.channel.send(this.message);
verify(this.handler).handleMessage(expected);
assertEquals(1, interceptor.getCounter().get());
assertTrue(interceptor.wasAfterHandledInvoked());
assertThat(interceptor.getCounter().get()).isEqualTo(1);
assertThat(interceptor.wasAfterHandledInvoked()).isTrue();
}
@Test
@@ -168,9 +164,9 @@ public class ExecutorSubscribableChannelTests {
this.channel.subscribe(this.handler);
this.channel.send(this.message);
verifyNoMoreInteractions(this.handler);
assertEquals(1, interceptor1.getCounter().get());
assertEquals(1, interceptor2.getCounter().get());
assertTrue(interceptor1.wasAfterHandledInvoked());
assertThat(interceptor1.getCounter().get()).isEqualTo(1);
assertThat(interceptor2.getCounter().get()).isEqualTo(1);
assertThat(interceptor1.wasAfterHandledInvoked()).isTrue();
}
@Test
@@ -184,11 +180,11 @@ public class ExecutorSubscribableChannelTests {
this.channel.send(this.message);
}
catch (MessageDeliveryException actual) {
assertSame(expected, actual.getCause());
assertThat(actual.getCause()).isSameAs(expected);
}
verify(this.handler).handleMessage(this.message);
assertEquals(1, interceptor.getCounter().get());
assertTrue(interceptor.wasAfterHandledInvoked());
assertThat(interceptor.getCounter().get()).isEqualTo(1);
assertThat(interceptor.wasAfterHandledInvoked()).isTrue();
}
@@ -208,7 +204,7 @@ public class ExecutorSubscribableChannelTests {
@Override
public Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler) {
assertNotNull(message);
assertThat(message).isNotNull();
counter.incrementAndGet();
return message;
}

64
spring-messaging/src/test/java/org/springframework/messaging/support/MessageBuilderTests.java
View File

@@ -27,13 +27,9 @@ import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.util.IdGenerator;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
/**
* @author Mark Fisher
@@ -44,7 +40,7 @@ public class MessageBuilderTests {
@Test
public void testSimpleMessageCreation() {
Message<String> message = MessageBuilder.withPayload("foo").build();
assertEquals("foo", message.getPayload());
assertThat(message.getPayload()).isEqualTo("foo");
}
@Test
@@ -53,8 +49,8 @@ public class MessageBuilderTests {
.setHeader("foo", "bar")
.setHeader("count", 123)
.build();
assertEquals("bar", message.getHeaders().get("foo", String.class));
assertEquals(new Integer(123), message.getHeaders().get("count", Integer.class));
assertThat(message.getHeaders().get("foo", String.class)).isEqualTo("bar");
assertThat(message.getHeaders().get("count", Integer.class)).isEqualTo(new Integer(123));
}
@Test
@@ -68,12 +64,12 @@ public class MessageBuilderTests {
.setHeader("foo", "42")
.setHeaderIfAbsent("bar", "99")
.build();
assertEquals("test1", message1.getPayload());
assertEquals("test2", message2.getPayload());
assertEquals("1", message1.getHeaders().get("foo"));
assertEquals("42", message2.getHeaders().get("foo"));
assertEquals("2", message1.getHeaders().get("bar"));
assertEquals("2", message2.getHeaders().get("bar"));
assertThat(message1.getPayload()).isEqualTo("test1");
assertThat(message2.getPayload()).isEqualTo("test2");
assertThat(message1.getHeaders().get("foo")).isEqualTo("1");
assertThat(message2.getHeaders().get("foo")).isEqualTo("42");
assertThat(message1.getHeaders().get("bar")).isEqualTo("2");
assertThat(message2.getHeaders().get("bar")).isEqualTo("2");
}
@Test
@@ -98,8 +94,8 @@ public class MessageBuilderTests {
.setHeader("foo", 123)
.copyHeadersIfAbsent(message1.getHeaders())
.build();
assertEquals("test2", message2.getPayload());
assertEquals(123, message2.getHeaders().get("foo"));
assertThat(message2.getPayload()).isEqualTo("test2");
assertThat(message2.getHeaders().get("foo")).isEqualTo(123);
}
@Test
@@ -107,8 +103,8 @@ public class MessageBuilderTests {
Message<String> message1 = MessageBuilder.withPayload("test")
.setHeader("foo", "bar").build();
Message<String> message2 = MessageBuilder.fromMessage(message1).build();
assertEquals("test", message2.getPayload());
assertEquals("bar", message2.getHeaders().get("foo"));
assertThat(message2.getPayload()).isEqualTo("test");
assertThat(message2.getHeaders().get("foo")).isEqualTo("bar");
}
@Test
@@ -116,8 +112,8 @@ public class MessageBuilderTests {
Message<String> message1 = MessageBuilder.withPayload("test")
.setHeader("foo", "bar").build();
Message<String> message2 = MessageBuilder.fromMessage(message1).setHeader("another", 1).build();
assertEquals("bar", message2.getHeaders().get("foo"));
assertNotSame(message1.getHeaders().getId(), message2.getHeaders().getId());
assertThat(message2.getHeaders().get("foo")).isEqualTo("bar");
assertThat(message2.getHeaders().getId()).isNotSameAs(message1.getHeaders().getId());
}
@Test
@@ -127,7 +123,7 @@ public class MessageBuilderTests {
Message<Integer> message2 = MessageBuilder.fromMessage(message1)
.removeHeader("foo")
.build();
assertFalse(message2.getHeaders().containsKey("foo"));
assertThat(message2.getHeaders().containsKey("foo")).isFalse();
}
@Test
@@ -137,28 +133,28 @@ public class MessageBuilderTests {
Message<Integer> message2 = MessageBuilder.fromMessage(message1)
.setHeader("foo", null)
.build();
assertFalse(message2.getHeaders().containsKey("foo"));
assertThat(message2.getHeaders().containsKey("foo")).isFalse();
}
@Test
public void testNotModifiedSameMessage() throws Exception {
Message<?> original = MessageBuilder.withPayload("foo").build();
Message<?> result = MessageBuilder.fromMessage(original).build();
assertEquals(original, result);
assertThat(result).isEqualTo(original);
}
@Test
public void testContainsHeaderNotModifiedSameMessage() throws Exception {
Message<?> original = MessageBuilder.withPayload("foo").setHeader("bar", 42).build();
Message<?> result = MessageBuilder.fromMessage(original).build();
assertEquals(original, result);
assertThat(result).isEqualTo(original);
}
@Test
public void testSameHeaderValueAddedNotModifiedSameMessage() throws Exception {
Message<?> original = MessageBuilder.withPayload("foo").setHeader("bar", 42).build();
Message<?> result = MessageBuilder.fromMessage(original).setHeader("bar", 42).build();
assertEquals(original, result);
assertThat(result).isEqualTo(original);
}
@Test
@@ -173,7 +169,7 @@ public class MessageBuilderTests {
newHeaders.put("b", "xyz");
newHeaders.put("c", current);
Message<?> result = MessageBuilder.fromMessage(original).copyHeaders(newHeaders).build();
assertEquals(original, result);
assertThat(result).isEqualTo(original);
}
@Test
@@ -184,8 +180,8 @@ public class MessageBuilderTests {
Message<?> message = MessageBuilder.createMessage("payload", headers);
accessor.setHeader("foo", "bar");
assertEquals("bar", headers.get("foo"));
assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class));
assertThat(headers.get("foo")).isEqualTo("bar");
assertThat(MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)).isSameAs(accessor);
}
@Test
@@ -198,7 +194,7 @@ public class MessageBuilderTests {
accessor.setHeader("foo", "bar"))
.withMessageContaining("Already immutable");
assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class));
assertThat(MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)).isSameAs(accessor);
}
@Test
@@ -211,8 +207,8 @@ public class MessageBuilderTests {
}
});
Message<?> message = MessageBuilder.createMessage("foo", headerAccessor.getMessageHeaders());
assertNull(message.getHeaders().getId());
assertNull(message.getHeaders().getTimestamp());
assertThat(message.getHeaders().getId()).isNull();
assertThat(message.getHeaders().getTimestamp()).isNull();
}
@Test
@@ -229,8 +225,8 @@ public class MessageBuilderTests {
headerAccessor.setHeader("foo", "bar3");
Message<?> message3 = messageBuilder.build();
assertEquals("bar1", message1.getHeaders().get("foo"));
assertEquals("bar2", message2.getHeaders().get("foo"));
assertEquals("bar3", message3.getHeaders().get("foo"));
assertThat(message1.getHeaders().get("foo")).isEqualTo("bar1");
assertThat(message2.getHeaders().get("foo")).isEqualTo("bar2");
assertThat(message3.getHeaders().get("foo")).isEqualTo("bar3");
}
}

135
spring-messaging/src/test/java/org/springframework/messaging/support/MessageHeaderAccessorTests.java
View File

@@ -31,13 +31,6 @@ import org.springframework.util.SerializationTestUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Test fixture for {@link MessageHeaderAccessor}.
@@ -51,7 +44,7 @@ public class MessageHeaderAccessorTests {
@Test
public void newEmptyHeaders() {
MessageHeaderAccessor accessor = new MessageHeaderAccessor();
assertEquals(0, accessor.toMap().size());
assertThat(accessor.toMap().size()).isEqualTo(0);
}
@Test
@@ -64,9 +57,9 @@ public class MessageHeaderAccessorTests {
MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
MessageHeaders actual = accessor.getMessageHeaders();
assertEquals(3, actual.size());
assertEquals("bar", actual.get("foo"));
assertEquals("baz", actual.get("bar"));
assertThat(actual.size()).isEqualTo(3);
assertThat(actual.get("foo")).isEqualTo("bar");
assertThat(actual.get("bar")).isEqualTo("baz");
}
@Test
@@ -82,10 +75,10 @@ public class MessageHeaderAccessorTests {
accessor.setHeader("foo", "BAR");
MessageHeaders actual = accessor.getMessageHeaders();
assertEquals(3, actual.size());
assertNotEquals(message.getHeaders().getId(), actual.getId());
assertEquals("BAR", actual.get("foo"));
assertEquals("baz", actual.get("bar"));
assertThat(actual.size()).isEqualTo(3);
assertThat(actual.getId()).isNotEqualTo(message.getHeaders().getId());
assertThat(actual.get("foo")).isEqualTo("BAR");
assertThat(actual.get("bar")).isEqualTo("baz");
}
@Test
@@ -94,7 +87,7 @@ public class MessageHeaderAccessorTests {
MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
accessor.removeHeader("foo");
Map<String, Object> headers = accessor.toMap();
assertFalse(headers.containsKey("foo"));
assertThat(headers.containsKey("foo")).isFalse();
}
@Test
@@ -103,7 +96,7 @@ public class MessageHeaderAccessorTests {
MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
accessor.removeHeader("foo");
Map<String, Object> headers = accessor.toMap();
assertFalse(headers.containsKey("foo"));
assertThat(headers.containsKey("foo")).isFalse();
}
@Test
@@ -117,9 +110,9 @@ public class MessageHeaderAccessorTests {
accessor.removeHeaders("fo*");
MessageHeaders actual = accessor.getMessageHeaders();
assertEquals(2, actual.size());
assertNull(actual.get("foo"));
assertEquals("baz", actual.get("bar"));
assertThat(actual.size()).isEqualTo(2);
assertThat(actual.get("foo")).isNull();
assertThat(actual.get("bar")).isEqualTo("baz");
}
@Test
@@ -135,9 +128,9 @@ public class MessageHeaderAccessorTests {
accessor.copyHeaders(map2);
MessageHeaders actual = accessor.getMessageHeaders();
assertEquals(3, actual.size());
assertEquals("BAR", actual.get("foo"));
assertEquals("baz", actual.get("bar"));
assertThat(actual.size()).isEqualTo(3);
assertThat(actual.get("foo")).isEqualTo("BAR");
assertThat(actual.get("bar")).isEqualTo("baz");
}
@Test
@@ -153,9 +146,9 @@ public class MessageHeaderAccessorTests {
accessor.copyHeadersIfAbsent(map2);
MessageHeaders actual = accessor.getMessageHeaders();
assertEquals(3, actual.size());
assertEquals("bar", actual.get("foo"));
assertEquals("baz", actual.get("bar"));
assertThat(actual.size()).isEqualTo(3);
assertThat(actual.get("foo")).isEqualTo("bar");
assertThat(actual.get("bar")).isEqualTo("baz");
}
@Test
@@ -164,8 +157,8 @@ public class MessageHeaderAccessorTests {
headers.copyHeaders(null);
headers.copyHeadersIfAbsent(null);
assertEquals(1, headers.getMessageHeaders().size());
assertEquals(Collections.singleton("id"), headers.getMessageHeaders().keySet());
assertThat(headers.getMessageHeaders().size()).isEqualTo(1);
assertThat(headers.getMessageHeaders().keySet()).isEqualTo(Collections.singleton("id"));
}
@Test
@@ -181,13 +174,13 @@ public class MessageHeaderAccessorTests {
accessor.setHeader("foo", "bar3");
Map<String, Object> map3 = accessor.toMap();
assertEquals(1, map1.size());
assertEquals(1, map2.size());
assertEquals(1, map3.size());
assertThat(map1.size()).isEqualTo(1);
assertThat(map2.size()).isEqualTo(1);
assertThat(map3.size()).isEqualTo(1);
assertEquals("bar1", map1.get("foo"));
assertEquals("bar2", map2.get("foo"));
assertEquals("bar3", map3.get("foo"));
assertThat(map1.get("foo")).isEqualTo("bar1");
assertThat(map2.get("foo")).isEqualTo("bar2");
assertThat(map3.get("foo")).isEqualTo("bar3");
}
@Test
@@ -200,8 +193,8 @@ public class MessageHeaderAccessorTests {
accessor.setHeader("foo", "baz");
assertEquals("baz", headers.get("foo"));
assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class));
assertThat(headers.get("foo")).isEqualTo("baz");
assertThat(MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)).isSameAs(accessor);
}
@Test
@@ -219,15 +212,15 @@ public class MessageHeaderAccessorTests {
accessor.setHeader("foo", "baz"))
.withMessageContaining("Already immutable");
assertEquals("bar", headers.get("foo"));
assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class));
assertThat(headers.get("foo")).isEqualTo("bar");
assertThat(MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)).isSameAs(accessor);
}
@Test
public void getAccessor() {
MessageHeaderAccessor expected = new MessageHeaderAccessor();
Message<?> message = MessageBuilder.createMessage("payload", expected.getMessageHeaders());
assertSame(expected, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class));
assertThat(MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)).isSameAs(expected);
}
@Test
@@ -237,9 +230,9 @@ public class MessageHeaderAccessorTests {
Message<?> message = MessageBuilder.createMessage("payload", expected.getMessageHeaders());
MessageHeaderAccessor actual = MessageHeaderAccessor.getMutableAccessor(message);
assertNotNull(actual);
assertTrue(actual.isMutable());
assertSame(expected, actual);
assertThat(actual).isNotNull();
assertThat(actual.isMutable()).isTrue();
assertThat(actual).isSameAs(expected);
}
@Test
@@ -247,8 +240,8 @@ public class MessageHeaderAccessorTests {
Message<?> message = MessageBuilder.withPayload("payload").build();
MessageHeaderAccessor actual = MessageHeaderAccessor.getMutableAccessor(message);
assertNotNull(actual);
assertTrue(actual.isMutable());
assertThat(actual).isNotNull();
assertThat(actual.isMutable()).isTrue();
}
@Test
@@ -257,22 +250,22 @@ public class MessageHeaderAccessorTests {
Message<?> message = MessageBuilder.createMessage("payload", expected.getMessageHeaders());
MessageHeaderAccessor actual = MessageHeaderAccessor.getMutableAccessor(message);
assertNotNull(actual);
assertTrue(actual.isMutable());
assertEquals(TestMessageHeaderAccessor.class, actual.getClass());
assertThat(actual).isNotNull();
assertThat(actual.isMutable()).isTrue();
assertThat(actual.getClass()).isEqualTo(TestMessageHeaderAccessor.class);
}
@Test
public void timestampEnabled() {
MessageHeaderAccessor accessor = new MessageHeaderAccessor();
accessor.setEnableTimestamp(true);
assertNotNull(accessor.getMessageHeaders().getTimestamp());
assertThat(accessor.getMessageHeaders().getTimestamp()).isNotNull();
}
@Test
public void timestampDefaultBehavior() {
MessageHeaderAccessor accessor = new MessageHeaderAccessor();
assertNull(accessor.getMessageHeaders().getTimestamp());
assertThat((Object) accessor.getMessageHeaders().getTimestamp()).isNull();
}
@Test
@@ -280,13 +273,13 @@ public class MessageHeaderAccessorTests {
final UUID id = new UUID(0L, 23L);
MessageHeaderAccessor accessor = new MessageHeaderAccessor();
accessor.setIdGenerator(() -> id);
assertSame(id, accessor.getMessageHeaders().getId());
assertThat(accessor.getMessageHeaders().getId()).isSameAs(id);
}
@Test
public void idGeneratorDefaultBehavior() {
MessageHeaderAccessor accessor = new MessageHeaderAccessor();
assertNotNull(accessor.getMessageHeaders().getId());
assertThat(accessor.getMessageHeaders().getId()).isNotNull();
}
@@ -298,16 +291,16 @@ public class MessageHeaderAccessorTests {
accessor.setLeaveMutable(true);
MessageHeaders headers = accessor.getMessageHeaders();
assertNull(headers.getId());
assertNull(headers.getTimestamp());
assertThat((Object) headers.getId()).isNull();
assertThat((Object) headers.getTimestamp()).isNull();
final UUID id = new UUID(0L, 23L);
accessor.setIdGenerator(() -> id);
accessor.setEnableTimestamp(true);
accessor.setImmutable();
assertSame(id, accessor.getMessageHeaders().getId());
assertNotNull(headers.getTimestamp());
assertThat(accessor.getMessageHeaders().getId()).isSameAs(id);
assertThat(headers.getTimestamp()).isNotNull();
}
@Test
@@ -316,14 +309,14 @@ public class MessageHeaderAccessorTests {
accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
String expected = "headers={contentType=text/plain} payload=p";
assertEquals(expected, accessor.getShortLogMessage("p"));
assertEquals(expected, accessor.getShortLogMessage("p".getBytes(StandardCharsets.UTF_8)));
assertEquals(expected, accessor.getShortLogMessage(new Object() {
assertThat(accessor.getShortLogMessage("p")).isEqualTo(expected);
assertThat(accessor.getShortLogMessage("p".getBytes(StandardCharsets.UTF_8))).isEqualTo(expected);
assertThat(accessor.getShortLogMessage(new Object() {
@Override
public String toString() {
return "p";
}
}));
})).isEqualTo(expected);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 80; i++) {
@@ -332,10 +325,10 @@ public class MessageHeaderAccessorTests {
final String payload = sb.toString() + " > 80";
String actual = accessor.getShortLogMessage(payload);
assertEquals("headers={contentType=text/plain} payload=" + sb + "...(truncated)", actual);
assertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + "...(truncated)");
actual = accessor.getShortLogMessage(payload.getBytes(StandardCharsets.UTF_8));
assertEquals("headers={contentType=text/plain} payload=" + sb + "...(truncated)", actual);
assertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + "...(truncated)");
actual = accessor.getShortLogMessage(new Object() {
@Override
@@ -352,14 +345,14 @@ public class MessageHeaderAccessorTests {
accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
String expected = "headers={contentType=text/plain} payload=p";
assertEquals(expected, accessor.getDetailedLogMessage("p"));
assertEquals(expected, accessor.getDetailedLogMessage("p".getBytes(StandardCharsets.UTF_8)));
assertEquals(expected, accessor.getDetailedLogMessage(new Object() {
assertThat(accessor.getDetailedLogMessage("p")).isEqualTo(expected);
assertThat(accessor.getDetailedLogMessage("p".getBytes(StandardCharsets.UTF_8))).isEqualTo(expected);
assertThat(accessor.getDetailedLogMessage(new Object() {
@Override
public String toString() {
return "p";
}
}));
})).isEqualTo(expected);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 80; i++) {
@@ -368,10 +361,10 @@ public class MessageHeaderAccessorTests {
final String payload = sb.toString() + " > 80";
String actual = accessor.getDetailedLogMessage(payload);
assertEquals("headers={contentType=text/plain} payload=" + sb + " > 80", actual);
assertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + " > 80");
actual = accessor.getDetailedLogMessage(payload.getBytes(StandardCharsets.UTF_8));
assertEquals("headers={contentType=text/plain} payload=" + sb + " > 80", actual);
assertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + " > 80");
actual = accessor.getDetailedLogMessage(new Object() {
@Override
@@ -379,7 +372,7 @@ public class MessageHeaderAccessorTests {
return payload;
}
});
assertEquals("headers={contentType=text/plain} payload=" + sb + " > 80", actual);
assertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + " > 80");
}
@Test
@@ -392,9 +385,9 @@ public class MessageHeaderAccessorTests {
message = new GenericMessage<>(message.getPayload(), mutableAccessor.getMessageHeaders());
Message<?> output = (Message<?>) SerializationTestUtils.serializeAndDeserialize(message);
assertEquals("test", output.getPayload());
assertEquals("bar", output.getHeaders().get("foo"));
assertNotNull(output.getHeaders().get(MessageHeaders.CONTENT_TYPE));
assertThat(output.getPayload()).isEqualTo("test");
assertThat(output.getHeaders().get("foo")).isEqualTo("bar");
assertThat(output.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isNotNull();
}

57
spring-messaging/src/test/java/org/springframework/messaging/support/NativeMessageHeaderAccessorTests.java
View File

@@ -28,11 +28,8 @@ import org.springframework.messaging.Message;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
/**
* Test fixture for {@link NativeMessageHeaderAccessor}.
@@ -50,10 +47,10 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headerAccessor = new NativeMessageHeaderAccessor(inputNativeHeaders);
Map<String, Object> actual = headerAccessor.toMap();
assertEquals(actual.toString(), 1, actual.size());
assertNotNull(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS));
assertEquals(inputNativeHeaders, actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS));
assertNotSame(inputNativeHeaders, actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS));
assertThat(actual.size()).as(actual.toString()).isEqualTo(1);
assertThat(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isNotNull();
assertThat(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isEqualTo(inputNativeHeaders);
assertThat(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isNotSameAs(inputNativeHeaders);
}
@Test
@@ -70,11 +67,11 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headerAccessor = new NativeMessageHeaderAccessor(message);
Map<String, Object> actual = headerAccessor.toMap();
assertEquals(2, actual.size());
assertEquals("b", actual.get("a"));
assertNotNull(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS));
assertEquals(inputNativeHeaders, actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS));
assertNotSame(inputNativeHeaders, actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS));
assertThat(actual.size()).isEqualTo(2);
assertThat(actual.get("a")).isEqualTo("b");
assertThat(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isNotNull();
assertThat(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isEqualTo(inputNativeHeaders);
assertThat(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isNotSameAs(inputNativeHeaders);
}
@Test
@@ -82,10 +79,10 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headerAccessor = new NativeMessageHeaderAccessor((Message<?>) null);
Map<String, Object> actual = headerAccessor.toMap();
assertEquals(0, actual.size());
assertThat(actual.size()).isEqualTo(0);
Map<String, List<String>> actualNativeHeaders = headerAccessor.toNativeHeaderMap();
assertEquals(Collections.emptyMap(), actualNativeHeaders);
assertThat(actualNativeHeaders).isEqualTo(Collections.emptyMap());
}
@Test
@@ -107,16 +104,16 @@ public class NativeMessageHeaderAccessorTests {
Map<String, Object> actual = headerAccessor.toMap();
assertEquals(2, actual.size());
assertEquals("B", actual.get("a"));
assertThat(actual.size()).isEqualTo(2);
assertThat(actual.get("a")).isEqualTo("B");
@SuppressWarnings("unchecked")
Map<String, List<String>> actualNativeHeaders =
(Map<String, List<String>>) actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS);
assertNotNull(actualNativeHeaders);
assertEquals(Arrays.asList("BAR"), actualNativeHeaders.get("foo"));
assertEquals(Arrays.asList("baz"), actualNativeHeaders.get("bar"));
assertThat(actualNativeHeaders).isNotNull();
assertThat(actualNativeHeaders.get("foo")).isEqualTo(Arrays.asList("BAR"));
assertThat(actualNativeHeaders.get("bar")).isEqualTo(Arrays.asList("baz"));
}
@Test
@@ -127,7 +124,7 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headers = new NativeMessageHeaderAccessor(nativeHeaders);
headers.setNativeHeader("foo", "baz");
assertEquals(Arrays.asList("baz"), headers.getNativeHeader("foo"));
assertThat(headers.getNativeHeader("foo")).isEqualTo(Arrays.asList("baz"));
}
@Test
@@ -138,7 +135,7 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headers = new NativeMessageHeaderAccessor(nativeHeaders);
headers.setNativeHeader("foo", null);
assertNull(headers.getNativeHeader("foo"));
assertThat(headers.getNativeHeader("foo")).isNull();
}
@Test
@@ -146,7 +143,7 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headerAccessor = new NativeMessageHeaderAccessor();
headerAccessor.setNativeHeader("foo", "baz");
assertEquals(Arrays.asList("baz"), headerAccessor.getNativeHeader("foo"));
assertThat(headerAccessor.getNativeHeader("foo")).isEqualTo(Arrays.asList("baz"));
}
@Test
@@ -154,8 +151,8 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headerAccessor = new NativeMessageHeaderAccessor();
headerAccessor.setNativeHeader("foo", null);
assertNull(headerAccessor.getNativeHeader("foo"));
assertNull(headerAccessor.getMessageHeaders().get(NativeMessageHeaderAccessor.NATIVE_HEADERS));
assertThat(headerAccessor.getNativeHeader("foo")).isNull();
assertThat(headerAccessor.getMessageHeaders().get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isNull();
}
@Test
@@ -177,7 +174,7 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headers = new NativeMessageHeaderAccessor(nativeHeaders);
headers.addNativeHeader("foo", "baz");
assertEquals(Arrays.asList("bar", "baz"), headers.getNativeHeader("foo"));
assertThat(headers.getNativeHeader("foo")).isEqualTo(Arrays.asList("bar", "baz"));
}
@Test
@@ -188,7 +185,7 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headers = new NativeMessageHeaderAccessor(nativeHeaders);
headers.addNativeHeader("foo", null);
assertEquals(Arrays.asList("bar"), headers.getNativeHeader("foo"));
assertThat(headers.getNativeHeader("foo")).isEqualTo(Arrays.asList("bar"));
}
@Test
@@ -196,7 +193,7 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headerAccessor = new NativeMessageHeaderAccessor();
headerAccessor.addNativeHeader("foo", "bar");
assertEquals(Arrays.asList("bar"), headerAccessor.getNativeHeader("foo"));
assertThat(headerAccessor.getNativeHeader("foo")).isEqualTo(Arrays.asList("bar"));
}
@Test
@@ -204,8 +201,8 @@ public class NativeMessageHeaderAccessorTests {
NativeMessageHeaderAccessor headerAccessor = new NativeMessageHeaderAccessor();
headerAccessor.addNativeHeader("foo", null);
assertNull(headerAccessor.getNativeHeader("foo"));
assertNull(headerAccessor.getMessageHeaders().get(NativeMessageHeaderAccessor.NATIVE_HEADERS));
assertThat(headerAccessor.getNativeHeader("foo")).isNull();
assertThat(headerAccessor.getMessageHeaders().get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isNull();
}
@Test