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

Migrate tests to AssertJ

Browse Source 
Mostly thanks to IDEA's plugin: https://plugins.jetbrains.com/plugin/10345-assertions2assertj
There is still a lot of work to do when complex and composite matchers are used.

* Add `awaitility` dependency and deprecate `EventuallyMatcher` in favor
of `awaitility`
* Remove Hamcrest from dependencies and disable JUnit & Hamcrest
static imports to encourage to use only AssertJ
* Migrate JUnit assumptions in rules to AssertJ's assumptions
* Deprecate some custom matchers in favor of existing in Hamcrest
after upgrading the last to version `2.1`
* Replace `ExpectedException` rules with `assertThatThrownBy()`
* Mention `MessagePredicate` in the `testing.adoc`
This commit is contained in:
Artem Bilan
2019-02-20 12:28:44 -05:00
parent b62c2a8fb3
commit 622d42c71a
916 changed files with 19714 additions and 21769 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
spring-integration-stream/src/test/java/org/springframework/integration/stream/ByteStreamSourceTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2016 the original author or authors.
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,17 +16,19 @@
package org.springframework.integration.stream;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import java.io.ByteArrayInputStream;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.messaging.Message;
/**
* @author Mark Fisher
* @author Artem Bilan
*/
public class ByteStreamSourceTests {
@@ -35,14 +37,15 @@ public class ByteStreamSourceTests {
byte[] bytes = new byte[] {1, 2, 3};
ByteArrayInputStream stream = new ByteArrayInputStream(bytes);
ByteStreamReadingMessageSource source = new ByteStreamReadingMessageSource(stream);
source.setBeanFactory(mock(BeanFactory.class));
Message<?> message1 = source.receive();
byte[] payload = (byte[]) message1.getPayload();
assertEquals(3, payload.length);
assertEquals(1, payload[0]);
assertEquals(2, payload[1]);
assertEquals(3, payload[2]);
assertThat(payload.length).isEqualTo(3);
assertThat(payload[0]).isEqualTo((byte) 1);
assertThat(payload[1]).isEqualTo((byte) 2);
assertThat(payload[2]).isEqualTo((byte) 3);
Message<?> message2 = source.receive();
assertNull(message2);
assertThat(message2).isNull();
}
@Test
@@ -51,12 +54,13 @@ public class ByteStreamSourceTests {
ByteArrayInputStream stream = new ByteArrayInputStream(bytes);
ByteStreamReadingMessageSource source = new ByteStreamReadingMessageSource(stream);
source.setBytesPerMessage(4);
source.setBeanFactory(mock(BeanFactory.class));
Message<?> message1 = source.receive();
assertEquals(4, ((byte[]) message1.getPayload()).length);
assertThat(((byte[]) message1.getPayload()).length).isEqualTo(4);
Message<?> message2 = source.receive();
assertEquals(2, ((byte[]) message2.getPayload()).length);
assertThat(((byte[]) message2.getPayload()).length).isEqualTo(2);
Message<?> message3 = source.receive();
assertNull(message3);
assertThat(message3).isNull();
}
@Test
@@ -66,16 +70,17 @@ public class ByteStreamSourceTests {
ByteStreamReadingMessageSource source = new ByteStreamReadingMessageSource(stream);
source.setBytesPerMessage(4);
source.setShouldTruncate(false);
source.setBeanFactory(mock(BeanFactory.class));
Message<?> message1 = source.receive();
assertEquals(4, ((byte[]) message1.getPayload()).length);
assertThat(((byte[]) message1.getPayload()).length).isEqualTo(4);
Message<?> message2 = source.receive();
assertEquals(4, ((byte[]) message2.getPayload()).length);
assertEquals(4, ((byte[]) message2.getPayload())[0]);
assertEquals(5, ((byte[]) message2.getPayload())[1]);
assertEquals(0, ((byte[]) message2.getPayload())[2]);
assertEquals(0, ((byte[]) message2.getPayload())[3]);
assertThat(((byte[]) message2.getPayload()).length).isEqualTo(4);
assertThat(((byte[]) message2.getPayload())[0]).isEqualTo((byte) 4);
assertThat(((byte[]) message2.getPayload())[1]).isEqualTo((byte) 5);
assertThat(((byte[]) message2.getPayload())[2]).isEqualTo((byte) 0);
assertThat(((byte[]) message2.getPayload())[3]).isEqualTo((byte) 0);
Message<?> message3 = source.receive();
assertNull(message3);
assertThat(message3).isNull();
}
}

158
spring-integration-stream/src/test/java/org/springframework/integration/stream/ByteStreamWritingMessageHandlerTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2016 the original author or authors.
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,15 +16,11 @@
package org.springframework.integration.stream;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.After;
import org.junit.Before;
@@ -33,13 +29,13 @@ import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.integration.endpoint.PollingConsumer;
import org.springframework.integration.test.util.OnlyOnceTrigger;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
/**
* @author Mark Fisher
* @author Artem Bilan
*/
public class ByteStreamWritingMessageHandlerTests {
@@ -51,7 +47,7 @@ public class ByteStreamWritingMessageHandlerTests {
private PollingConsumer endpoint;
private final TestTrigger trigger = new TestTrigger();
private final OnlyOnceTrigger trigger = new OnlyOnceTrigger();
private ThreadPoolTaskScheduler scheduler;
@@ -78,51 +74,51 @@ public class ByteStreamWritingMessageHandlerTests {
@Test
public void singleByteArray() {
handler.handleMessage(new GenericMessage<byte[]>(new byte[] {1, 2, 3}));
handler.handleMessage(new GenericMessage<byte[]>(new byte[] { 1, 2, 3 }));
byte[] result = stream.toByteArray();
assertEquals(3, result.length);
assertEquals(1, result[0]);
assertEquals(2, result[1]);
assertEquals(3, result[2]);
assertThat(result.length).isEqualTo(3);
assertThat(result[0]).isEqualTo((byte) 1);
assertThat(result[1]).isEqualTo((byte) 2);
assertThat(result[2]).isEqualTo((byte) 3);
}
@Test
public void singleString() {
handler.handleMessage(new GenericMessage<String>("foo"));
byte[] result = stream.toByteArray();
assertEquals(3, result.length);
assertEquals("foo", new String(result));
assertThat(result.length).isEqualTo(3);
assertThat(new String(result)).isEqualTo("foo");
}
@Test
public void maxMessagesPerTaskSameAsMessageCount() {
endpoint.setTrigger(trigger);
endpoint.setMaxMessagesPerPoll(3);
channel.send(new GenericMessage<byte[]>(new byte[] {1, 2, 3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4, 5, 6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7, 8, 9}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 1, 2, 3 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 4, 5, 6 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 7, 8, 9 }), 0);
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result = stream.toByteArray();
assertEquals(9, result.length);
assertEquals(1, result[0]);
assertEquals(9, result[8]);
assertThat(result.length).isEqualTo(9);
assertThat(result[0]).isEqualTo((byte) 1);
assertThat(result[8]).isEqualTo((byte) 9);
}
@Test
public void maxMessagesPerTaskLessThanMessageCount() {
endpoint.setTrigger(trigger);
endpoint.setMaxMessagesPerPoll(2);
channel.send(new GenericMessage<byte[]>(new byte[] {1, 2, 3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4, 5, 6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7, 8, 9}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 1, 2, 3 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 4, 5, 6 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 7, 8, 9 }), 0);
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result = stream.toByteArray();
assertEquals(6, result.length);
assertEquals(1, result[0]);
assertThat(result.length).isEqualTo(6);
assertThat(result[0]).isEqualTo((byte) 1);
}
@Test
@@ -130,15 +126,15 @@ public class ByteStreamWritingMessageHandlerTests {
endpoint.setTrigger(trigger);
endpoint.setMaxMessagesPerPoll(5);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1, 2, 3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4, 5, 6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7, 8, 9}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 1, 2, 3 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 4, 5, 6 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 7, 8, 9 }), 0);
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result = stream.toByteArray();
assertEquals(9, result.length);
assertEquals(1, result[0]);
assertThat(result.length).isEqualTo(9);
assertThat(result[0]).isEqualTo((byte) 1);
}
@Test
@@ -146,23 +142,23 @@ public class ByteStreamWritingMessageHandlerTests {
endpoint.setTrigger(trigger);
endpoint.setMaxMessagesPerPoll(2);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1, 2, 3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4, 5, 6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7, 8, 9}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 1, 2, 3 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 4, 5, 6 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 7, 8, 9 }), 0);
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result1 = stream.toByteArray();
assertEquals(6, result1.length);
assertEquals(1, result1[0]);
assertThat(result1.length).isEqualTo(6);
assertThat(result1[0]).isEqualTo((byte) 1);
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result2 = stream.toByteArray();
assertEquals(9, result2.length);
assertEquals(1, result2[0]);
assertEquals(7, result2[6]);
assertThat(result2.length).isEqualTo(9);
assertThat(result2[0]).isEqualTo((byte) 1);
assertThat(result2[6]).isEqualTo((byte) 7);
}
@Test
@@ -170,22 +166,22 @@ public class ByteStreamWritingMessageHandlerTests {
endpoint.setTrigger(trigger);
endpoint.setMaxMessagesPerPoll(5);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1, 2, 3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4, 5, 6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7, 8, 9}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 1, 2, 3 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 4, 5, 6 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 7, 8, 9 }), 0);
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result1 = stream.toByteArray();
assertEquals(9, result1.length);
assertEquals(1, result1[0]);
assertThat(result1.length).isEqualTo(9);
assertThat(result1[0]).isEqualTo((byte) 1);
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result2 = stream.toByteArray();
assertEquals(9, result2.length);
assertEquals(1, result2[0]);
assertThat(result2.length).isEqualTo(9);
assertThat(result2[0]).isEqualTo((byte) 1);
}
@Test
@@ -193,22 +189,22 @@ public class ByteStreamWritingMessageHandlerTests {
endpoint.setMaxMessagesPerPoll(2);
endpoint.setTrigger(trigger);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1, 2, 3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4, 5, 6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7, 8, 9}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 1, 2, 3 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 4, 5, 6 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 7, 8, 9 }), 0);
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result1 = stream.toByteArray();
assertEquals(6, result1.length);
assertThat(result1.length).isEqualTo(6);
stream.reset();
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result2 = stream.toByteArray();
assertEquals(3, result2.length);
assertEquals(7, result2[0]);
assertThat(result2.length).isEqualTo(3);
assertThat(result2[0]).isEqualTo((byte) 7);
}
@Test
@@ -216,63 +212,25 @@ public class ByteStreamWritingMessageHandlerTests {
endpoint.setTrigger(trigger);
endpoint.setMaxMessagesPerPoll(2);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1, 2, 3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4, 5, 6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7, 8, 9}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 1, 2, 3 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 4, 5, 6 }), 0);
channel.send(new GenericMessage<byte[]>(new byte[] { 7, 8, 9 }), 0);
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result1 = stream.toByteArray();
assertEquals(6, result1.length);
stream.write(new byte[] {123});
assertThat(result1.length).isEqualTo(6);
stream.write(new byte[] { 123 });
stream.flush();
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result2 = stream.toByteArray();
assertEquals(10, result2.length);
assertEquals(1, result2[0]);
assertEquals(123, result2[6]);
assertEquals(7, result2[7]);
}
private static class TestTrigger implements Trigger {
private final AtomicBoolean hasRun = new AtomicBoolean();
private volatile CountDownLatch latch = new CountDownLatch(1);
TestTrigger() {
super();
}
@Override
public Date nextExecutionTime(TriggerContext triggerContext) {
if (!hasRun.getAndSet(true)) {
return new Date();
}
this.latch.countDown();
return null;
}
public void reset() {
this.latch = new CountDownLatch(1);
this.hasRun.set(false);
}
public void await() {
try {
this.latch.await(3000, TimeUnit.MILLISECONDS);
if (latch.getCount() != 0) {
throw new RuntimeException("test timeout");
}
}
catch (InterruptedException e) {
throw new RuntimeException("test latch.await() interrupted");
}
}
assertThat(result2.length).isEqualTo(10);
assertThat(result2[0]).isEqualTo((byte) 1);
assertThat(result2[6]).isEqualTo((byte) 123);
assertThat(result2[7]).isEqualTo((byte) 7);
}
}

27
spring-integration-stream/src/test/java/org/springframework/integration/stream/CharacterStreamSourceTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,11 +16,7 @@
package org.springframework.integration.stream;
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.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -49,10 +45,11 @@ public class CharacterStreamSourceTests {
public void testEndOfStream() {
StringReader reader = new StringReader("test");
CharacterStreamReadingMessageSource source = new CharacterStreamReadingMessageSource(reader);
source.setBeanFactory(mock(BeanFactory.class));
Message<?> message1 = source.receive();
assertEquals("test", message1.getPayload());
assertThat(message1.getPayload()).isEqualTo("test");
Message<?> message2 = source.receive();
assertNull(message2);
assertThat(message2).isNull();
}
@Test
@@ -61,10 +58,11 @@ public class CharacterStreamSourceTests {
CharacterStreamReadingMessageSource source = new CharacterStreamReadingMessageSource(reader, -1, true);
ApplicationEventPublisher publisher = mock(ApplicationEventPublisher.class);
source.setApplicationEventPublisher(publisher);
source.setBeanFactory(mock(BeanFactory.class));
Message<?> message1 = source.receive();
assertEquals("test", message1.getPayload());
assertThat(message1.getPayload()).isEqualTo("test");
Message<?> message2 = source.receive();
assertNull(message2);
assertThat(message2).isNull();
verify(publisher).publishEvent(any(StreamClosedEvent.class));
}
@@ -72,6 +70,7 @@ public class CharacterStreamSourceTests {
public void testEOFIntegrationTest() throws Exception {
StringReader reader = new StringReader("test");
CharacterStreamReadingMessageSource source = new CharacterStreamReadingMessageSource(reader, -1, true);
source.setBeanFactory(mock(BeanFactory.class));
SourcePollingChannelAdapter adapter = new SourcePollingChannelAdapter();
CountDownLatch latch = new CountDownLatch(2);
source.setApplicationEventPublisher(e -> {
@@ -93,10 +92,10 @@ public class CharacterStreamSourceTests {
adapter.afterPropertiesSet();
adapter.start();
Message<?> received = out.receive(10000);
assertNotNull(received);
assertEquals("test", received.getPayload());
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertFalse(adapter.isRunning());
assertThat(received).isNotNull();
assertThat(received.getPayload()).isEqualTo("test");
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(adapter.isRunning()).isFalse();
scheduler.shutdown();
}

24
spring-integration-stream/src/test/java/org/springframework/integration/stream/CharacterStreamWritingMessageHandlerTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
package org.springframework.integration.stream;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import java.io.StringWriter;
@@ -79,7 +79,7 @@ public class CharacterStreamWritingMessageHandlerTests {
@Test
public void singleString() {
handler.handleMessage(new GenericMessage<String>("foo"));
assertEquals("foo", writer.toString());
assertThat(writer.toString()).isEqualTo("foo");
}
@Test
@@ -91,12 +91,12 @@ public class CharacterStreamWritingMessageHandlerTests {
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foo", writer.toString());
assertThat(writer.toString()).isEqualTo("foo");
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foobar", writer.toString());
assertThat(writer.toString()).isEqualTo("foobar");
}
@Test
@@ -110,12 +110,12 @@ public class CharacterStreamWritingMessageHandlerTests {
trigger.await();
endpoint.stop();
String newLine = System.getProperty("line.separator");
assertEquals("foo" + newLine, writer.toString());
assertThat(writer.toString()).isEqualTo("foo" + newLine);
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foo" + newLine + "bar" + newLine, writer.toString());
assertThat(writer.toString()).isEqualTo("foo" + newLine + "bar" + newLine);
}
@Test
@@ -127,7 +127,7 @@ public class CharacterStreamWritingMessageHandlerTests {
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foobar", writer.toString());
assertThat(writer.toString()).isEqualTo("foobar");
}
@Test
@@ -142,7 +142,7 @@ public class CharacterStreamWritingMessageHandlerTests {
trigger.await();
endpoint.stop();
String newLine = System.getProperty("line.separator");
assertEquals("foo" + newLine + "bar" + newLine, writer.toString());
assertThat(writer.toString()).isEqualTo("foo" + newLine + "bar" + newLine);
}
@Test
@@ -154,7 +154,7 @@ public class CharacterStreamWritingMessageHandlerTests {
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foo", writer.toString());
assertThat(writer.toString()).isEqualTo("foo");
}
@Test
@@ -169,7 +169,7 @@ public class CharacterStreamWritingMessageHandlerTests {
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foobar", writer.toString());
assertThat(writer.toString()).isEqualTo("foobar");
}
@Test
@@ -186,7 +186,7 @@ public class CharacterStreamWritingMessageHandlerTests {
trigger.await();
endpoint.stop();
String newLine = System.getProperty("line.separator");
assertEquals("foo" + newLine + "bar" + newLine, writer.toString());
assertThat(writer.toString()).isEqualTo("foo" + newLine + "bar" + newLine);
}

48
spring-integration-stream/src/test/java/org/springframework/integration/stream/config/ConsoleInboundChannelAdapterParserTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2016 the original author or authors.
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,9 +16,7 @@
package org.springframework.integration.stream.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
@@ -59,24 +57,24 @@ public class ConsoleInboundChannelAdapterParserTests {
SourcePollingChannelAdapter adapter = context.getBean("adapterWithDefaultCharset.adapter",
SourcePollingChannelAdapter.class);
MessageSource<?> source = (MessageSource<?>) new DirectFieldAccessor(adapter).getPropertyValue("source");
assertTrue(source instanceof NamedComponent);
assertEquals("adapterWithDefaultCharset.adapter", adapter.getComponentName());
assertEquals("stream:stdin-channel-adapter(character)", adapter.getComponentType());
assertEquals("stream:stdin-channel-adapter(character)", ((NamedComponent) source).getComponentType());
assertThat(source instanceof NamedComponent).isTrue();
assertThat(adapter.getComponentName()).isEqualTo("adapterWithDefaultCharset.adapter");
assertThat(adapter.getComponentType()).isEqualTo("stream:stdin-channel-adapter(character)");
assertThat(((NamedComponent) source).getComponentType()).isEqualTo("stream:stdin-channel-adapter(character)");
DirectFieldAccessor sourceAccessor = new DirectFieldAccessor(source);
Reader bufferedReader = (Reader) sourceAccessor.getPropertyValue("reader");
assertEquals(BufferedReader.class, bufferedReader.getClass());
assertThat(bufferedReader.getClass()).isEqualTo(BufferedReader.class);
DirectFieldAccessor bufferedReaderAccessor = new DirectFieldAccessor(bufferedReader);
Reader reader = (Reader) bufferedReaderAccessor.getPropertyValue("in");
assertEquals(InputStreamReader.class, reader.getClass());
assertThat(reader.getClass()).isEqualTo(InputStreamReader.class);
Charset readerCharset = Charset.forName(((InputStreamReader) reader).getEncoding());
assertEquals(Charset.defaultCharset(), readerCharset);
assertThat(readerCharset).isEqualTo(Charset.defaultCharset());
Message<?> message = source.receive();
assertNotNull(message);
assertEquals("foo", message.getPayload());
assertThat(message).isNotNull();
assertThat(message.getPayload()).isEqualTo("foo");
adapter = context.getBean("pipedAdapterNoCharset.adapter", SourcePollingChannelAdapter.class);
source = adapter.getMessageSource();
assertTrue(TestUtils.getPropertyValue(source, "blockToDetectEOF", Boolean.class));
assertThat(TestUtils.getPropertyValue(source, "blockToDetectEOF", Boolean.class)).isTrue();
context.close();
}
@@ -89,26 +87,26 @@ public class ConsoleInboundChannelAdapterParserTests {
MessageSource<?> source = adapter.getMessageSource();
DirectFieldAccessor sourceAccessor = new DirectFieldAccessor(source);
Reader bufferedReader = (Reader) sourceAccessor.getPropertyValue("reader");
assertEquals(BufferedReader.class, bufferedReader.getClass());
assertEquals(false, sourceAccessor.getPropertyValue("blockToDetectEOF"));
assertThat(bufferedReader.getClass()).isEqualTo(BufferedReader.class);
assertThat(sourceAccessor.getPropertyValue("blockToDetectEOF")).isEqualTo(false);
DirectFieldAccessor bufferedReaderAccessor = new DirectFieldAccessor(bufferedReader);
Reader reader = (Reader) bufferedReaderAccessor.getPropertyValue("in");
assertEquals(InputStreamReader.class, reader.getClass());
assertThat(reader.getClass()).isEqualTo(InputStreamReader.class);
Charset readerCharset = Charset.forName(((InputStreamReader) reader).getEncoding());
assertEquals(Charset.forName("UTF-8"), readerCharset);
assertThat(readerCharset).isEqualTo(Charset.forName("UTF-8"));
Message<?> message = source.receive();
assertNotNull(message);
assertEquals("foo", message.getPayload());
assertThat(message).isNotNull();
assertThat(message.getPayload()).isEqualTo("foo");
adapter = context.getBean("pipedAdapterWithCharset.adapter", SourcePollingChannelAdapter.class);
source = adapter.getMessageSource();
assertTrue(TestUtils.getPropertyValue(source, "blockToDetectEOF", Boolean.class));
assertThat(TestUtils.getPropertyValue(source, "blockToDetectEOF", Boolean.class)).isTrue();
bufferedReader = (Reader) sourceAccessor.getPropertyValue("reader");
assertEquals(BufferedReader.class, bufferedReader.getClass());
assertThat(bufferedReader.getClass()).isEqualTo(BufferedReader.class);
bufferedReaderAccessor = new DirectFieldAccessor(bufferedReader);
reader = (Reader) bufferedReaderAccessor.getPropertyValue("in");
assertEquals(InputStreamReader.class, reader.getClass());
assertThat(reader.getClass()).isEqualTo(InputStreamReader.class);
readerCharset = Charset.forName(((InputStreamReader) reader).getEncoding());
assertEquals(Charset.forName("UTF-8"), readerCharset);
assertThat(readerCharset).isEqualTo(Charset.forName("UTF-8"));
context.close();
}
@@ -123,7 +121,7 @@ public class ConsoleInboundChannelAdapterParserTests {
beanCreationException = e;
}
Throwable rootCause = beanCreationException.getRootCause();
assertEquals(UnsupportedEncodingException.class, rootCause.getClass());
assertThat(rootCause.getClass()).isEqualTo(UnsupportedEncodingException.class);
}
}

49
spring-integration-stream/src/test/java/org/springframework/integration/stream/config/ConsoleOutboundChannelAdapterParserTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,8 +16,7 @@
package org.springframework.integration.stream.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@@ -85,12 +84,12 @@ public class ConsoleOutboundChannelAdapterParserTests {
public void stdoutAdapterWithDefaultCharset() throws IOException {
BufferedWriter bufferedWriter = TestUtils.getPropertyValue(this.stdoutAdapterWithDefaultCharsetHandler, "writer", BufferedWriter.class);
Writer writer = TestUtils.getPropertyValue(bufferedWriter, "out", Writer.class);
assertEquals(OutputStreamWriter.class, writer.getClass());
assertThat(writer.getClass()).isEqualTo(OutputStreamWriter.class);
Charset writerCharset = Charset.forName(((OutputStreamWriter) writer).getEncoding());
assertEquals(Charset.defaultCharset(), writerCharset);
assertThat(writerCharset).isEqualTo(Charset.defaultCharset());
Object lock = TestUtils.getPropertyValue(writer, "lock");
assertEquals(System.out, lock);
assertThat(lock).isEqualTo(System.out);
bufferedWriter = Mockito.spy(bufferedWriter);
@@ -100,19 +99,19 @@ public class ConsoleOutboundChannelAdapterParserTests {
this.stdoutAdapterWithDefaultCharsetHandler.handleMessage(new GenericMessage<String>("foo"));
verify(bufferedWriter, times(1)).write(eq("foo"));
assertEquals(23, TestUtils.getPropertyValue(this.stdoutAdapterWithDefaultCharsetHandler, "order"));
assertThat(TestUtils.getPropertyValue(this.stdoutAdapterWithDefaultCharsetHandler, "order")).isEqualTo(23);
}
@Test
public void stdoutAdapterWithProvidedCharset() throws IOException {
BufferedWriter bufferedWriter = TestUtils.getPropertyValue(this.stdoutAdapterWithProvidedCharsetHandler, "writer", BufferedWriter.class);
Writer writer = TestUtils.getPropertyValue(bufferedWriter, "out", Writer.class);
assertEquals(OutputStreamWriter.class, writer.getClass());
assertThat(writer.getClass()).isEqualTo(OutputStreamWriter.class);
Charset writerCharset = Charset.forName(((OutputStreamWriter) writer).getEncoding());
assertEquals(Charset.forName("UTF-8"), writerCharset);
assertThat(writerCharset).isEqualTo(Charset.forName("UTF-8"));
Object lock = TestUtils.getPropertyValue(writer, "lock");
assertEquals(System.out, lock);
assertThat(lock).isEqualTo(System.out);
bufferedWriter = Mockito.spy(bufferedWriter);
@@ -135,19 +134,19 @@ public class ConsoleOutboundChannelAdapterParserTests {
beanCreationException = e;
}
Throwable rootCause = beanCreationException.getRootCause();
assertEquals(UnsupportedEncodingException.class, rootCause.getClass());
assertThat(rootCause.getClass()).isEqualTo(UnsupportedEncodingException.class);
}
@Test
public void stderrAdapter() throws IOException {
BufferedWriter bufferedWriter = TestUtils.getPropertyValue(this.stderrAdapterHandler, "writer", BufferedWriter.class);
Writer writer = TestUtils.getPropertyValue(bufferedWriter, "out", Writer.class);
assertEquals(OutputStreamWriter.class, writer.getClass());
assertThat(writer.getClass()).isEqualTo(OutputStreamWriter.class);
Charset writerCharset = Charset.forName(((OutputStreamWriter) writer).getEncoding());
assertEquals(Charset.defaultCharset(), writerCharset);
assertThat(writerCharset).isEqualTo(Charset.defaultCharset());
Object lock = TestUtils.getPropertyValue(writer, "lock");
assertEquals(System.err, lock);
assertThat(lock).isEqualTo(System.err);
bufferedWriter = Mockito.spy(bufferedWriter);
@@ -159,19 +158,19 @@ public class ConsoleOutboundChannelAdapterParserTests {
verify(bufferedWriter, times(1)).write(eq("bar"));
assertEquals(34, TestUtils.getPropertyValue(this.stderrAdapterHandler, "order"));
assertThat(TestUtils.getPropertyValue(this.stderrAdapterHandler, "order")).isEqualTo(34);
}
@Test
public void stdoutAdatperWithAppendNewLine() throws IOException {
BufferedWriter bufferedWriter = TestUtils.getPropertyValue(this.newlineAdapterHandler, "writer", BufferedWriter.class);
Writer writer = TestUtils.getPropertyValue(bufferedWriter, "out", Writer.class);
assertEquals(OutputStreamWriter.class, writer.getClass());
assertThat(writer.getClass()).isEqualTo(OutputStreamWriter.class);
Charset writerCharset = Charset.forName(((OutputStreamWriter) writer).getEncoding());
assertEquals(Charset.defaultCharset(), writerCharset);
assertThat(writerCharset).isEqualTo(Charset.defaultCharset());
Object lock = TestUtils.getPropertyValue(writer, "lock");
assertEquals(System.out, lock);
assertThat(lock).isEqualTo(System.out);
bufferedWriter = Mockito.spy(bufferedWriter);
@@ -188,22 +187,22 @@ public class ConsoleOutboundChannelAdapterParserTests {
@Test //INT-2275
public void stdoutInsideNestedChain() throws IOException {
List<?> handlers = TestUtils.getPropertyValue(this.stdoutChainHandler, "handlers", List.class);
assertEquals(2, handlers.size());
assertThat(handlers.size()).isEqualTo(2);
Object chainHandler = handlers.get(1);
assertTrue(chainHandler instanceof MessageHandlerChain);
assertThat(chainHandler instanceof MessageHandlerChain).isTrue();
List<?> nestedChainHandlers = TestUtils.getPropertyValue(chainHandler, "handlers", List.class);
assertEquals(1, nestedChainHandlers.size());
assertThat(nestedChainHandlers.size()).isEqualTo(1);
Object stdoutHandler = nestedChainHandlers.get(0);
assertTrue(stdoutHandler instanceof CharacterStreamWritingMessageHandler);
assertThat(stdoutHandler instanceof CharacterStreamWritingMessageHandler).isTrue();
BufferedWriter bufferedWriter = TestUtils.getPropertyValue(stdoutHandler, "writer", BufferedWriter.class);
Writer writer = TestUtils.getPropertyValue(bufferedWriter, "out", Writer.class);
assertEquals(OutputStreamWriter.class, writer.getClass());
assertThat(writer.getClass()).isEqualTo(OutputStreamWriter.class);
Charset writerCharset = Charset.forName(((OutputStreamWriter) writer).getEncoding());
assertEquals(Charset.defaultCharset(), writerCharset);
assertThat(writerCharset).isEqualTo(Charset.defaultCharset());
Object lock = TestUtils.getPropertyValue(writer, "lock");
assertEquals(System.out, lock);
assertThat(lock).isEqualTo(System.out);
bufferedWriter = Mockito.spy(bufferedWriter);

24
spring-integration-stream/src/test/java/org/springframework/integration/stream/config/DefaultConfigurationTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,9 +16,7 @@
package org.springframework.integration.stream.config;
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;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -53,31 +51,31 @@ public class DefaultConfigurationTests {
@Test
public void verifyErrorChannel() {
Object errorChannel = context.getBean("errorChannel");
assertNotNull(errorChannel);
assertEquals(PublishSubscribeChannel.class, errorChannel.getClass());
assertThat(errorChannel).isNotNull();
assertThat(errorChannel.getClass()).isEqualTo(PublishSubscribeChannel.class);
}
@Test
public void verifyNullChannel() {
Object nullChannel = context.getBean("nullChannel");
assertNotNull(nullChannel);
assertEquals(NullChannel.class, nullChannel.getClass());
assertThat(nullChannel).isNotNull();
assertThat(nullChannel.getClass()).isEqualTo(NullChannel.class);
}
@Test
public void verifyTaskScheduler() {
Object taskScheduler = context.getBean(IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME);
assertEquals(ThreadPoolTaskScheduler.class, taskScheduler.getClass());
assertThat(taskScheduler.getClass()).isEqualTo(ThreadPoolTaskScheduler.class);
ErrorHandler errorHandler = TestUtils.getPropertyValue(taskScheduler, "errorHandler", ErrorHandler.class);
assertEquals(MessagePublishingErrorHandler.class, errorHandler.getClass());
assertThat(errorHandler.getClass()).isEqualTo(MessagePublishingErrorHandler.class);
MessageChannel defaultErrorChannel = TestUtils.getPropertyValue(errorHandler,
"messagingTemplate.defaultDestination", MessageChannel.class);
assertNull(defaultErrorChannel);
assertThat(defaultErrorChannel).isNull();
errorHandler.handleError(new Throwable());
defaultErrorChannel = TestUtils.getPropertyValue(errorHandler, "messagingTemplate.defaultDestination",
MessageChannel.class);
assertNotNull(defaultErrorChannel);
assertEquals(context.getBean(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME), defaultErrorChannel);
assertThat(defaultErrorChannel).isNotNull();
assertThat(defaultErrorChannel).isEqualTo(context.getBean(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME));
}
}