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

131
spring-integration-mail/src/test/java/org/springframework/integration/mail/ImapMailReceiverTests.java
View File

@@ -16,17 +16,7 @@
package org.springframework.integration.mail;
import static org.hamcrest.Matchers.emptyArray;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.not;
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.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.BDDMockito.given;
@@ -129,7 +119,7 @@ public class ImapMailReceiverTests {
while (n++ < 100 && (!this.imapIdleServer.isListening())) {
Thread.sleep(100);
}
assertTrue(n < 100);
assertThat(n < 100).isTrue();
}
@After
@@ -158,7 +148,7 @@ public class ImapMailReceiverTests {
ImapMailReceiver receiver =
new ImapMailReceiver("imap://user:pw@localhost:" + this.imapIdleServer.getPort() + "/INBOX");
testIdleWithServerGuts(receiver, false);
assertTrue(this.imapIdleServer.assertReceived("searchWithUserFlag"));
assertThat(this.imapIdleServer.assertReceived("searchWithUserFlag")).isTrue();
}
@Test
@@ -175,7 +165,7 @@ public class ImapMailReceiverTests {
new ImapMailReceiver("imap://user:pw@localhost:" + this.imapIdleServer.getPort() + "/INBOX");
receiver.setSimpleContent(true);
testIdleWithServerGuts(receiver, false, true);
assertTrue(this.imapIdleServer.assertReceived("searchWithUserFlag"));
assertThat(this.imapIdleServer.assertReceived("searchWithUserFlag")).isTrue();
}
@Test
@@ -217,46 +207,46 @@ public class ImapMailReceiverTests {
@SuppressWarnings("unchecked")
org.springframework.messaging.Message<MimeMessage> received =
(org.springframework.messaging.Message<MimeMessage>) channel.receive(10000);
assertNotNull(received);
assertNotNull(received.getPayload().getReceivedDate());
assertTrue(received.getPayload().getLineCount() > -1);
assertThat(received).isNotNull();
assertThat(received.getPayload().getReceivedDate()).isNotNull();
assertThat(received.getPayload().getLineCount() > -1).isTrue();
if (simple) {
assertThat(received.getPayload().getContent(),
equalTo(TestMailServer.MailServer.MailHandler.BODY + "\r\n"));
assertThat(received.getPayload().getContent())
.isEqualTo(TestMailServer.MailServer.MailHandler.BODY + "\r\n");
}
else {
assertThat(received.getPayload().getContent(),
equalTo(TestMailServer.MailServer.MailHandler.MESSAGE + "\r\n"));
assertThat(received.getPayload().getContent())
.isEqualTo(TestMailServer.MailServer.MailHandler.MESSAGE + "\r\n");
}
}
else {
org.springframework.messaging.Message<?> received = channel.receive(10000);
assertNotNull(received);
assertThat(received).isNotNull();
MessageHeaders headers = received.getHeaders();
assertNotNull(headers.get(MailHeaders.RAW_HEADERS));
assertThat(headers.get(MailHeaders.CONTENT_TYPE), equalTo("TEXT/PLAIN; charset=ISO-8859-1"));
assertThat(headers.get(MessageHeaders.CONTENT_TYPE), equalTo("TEXT/PLAIN; charset=ISO-8859-1"));
assertThat(headers.get(MailHeaders.FROM), equalTo("Bar <bar@baz>"));
assertThat(headers.get(MailHeaders.RAW_HEADERS)).isNotNull();
assertThat(headers.get(MailHeaders.CONTENT_TYPE)).isEqualTo("TEXT/PLAIN; charset=ISO-8859-1");
assertThat(headers.get(MessageHeaders.CONTENT_TYPE)).isEqualTo("TEXT/PLAIN; charset=ISO-8859-1");
assertThat(headers.get(MailHeaders.FROM)).isEqualTo("Bar <bar@baz>");
String[] toHeader = headers.get(MailHeaders.TO, String[].class);
assertThat(toHeader, not(emptyArray()));
assertThat(toHeader[0], equalTo("Foo <foo@bar>"));
assertThat(Arrays.toString(headers.get(MailHeaders.CC, String[].class)), equalTo("[a@b, c@d]"));
assertThat(Arrays.toString(headers.get(MailHeaders.BCC, String[].class)), equalTo("[e@f, g@h]"));
assertThat(headers.get(MailHeaders.SUBJECT), equalTo("Test Email"));
assertThat(toHeader).isNotEmpty();
assertThat(toHeader[0]).isEqualTo("Foo <foo@bar>");
assertThat(Arrays.toString(headers.get(MailHeaders.CC, String[].class))).isEqualTo("[a@b, c@d]");
assertThat(Arrays.toString(headers.get(MailHeaders.BCC, String[].class))).isEqualTo("[e@f, g@h]");
assertThat(headers.get(MailHeaders.SUBJECT)).isEqualTo("Test Email");
if (simple) {
assertThat(received.getPayload(), equalTo(TestMailServer.MailServer.MailHandler.BODY + "\r\n"));
assertThat(received.getPayload()).isEqualTo(TestMailServer.MailServer.MailHandler.BODY + "\r\n");
}
else {
assertThat(received.getPayload(), equalTo(TestMailServer.MailServer.MailHandler.MESSAGE + "\r\n"));
assertThat(received.getPayload()).isEqualTo(TestMailServer.MailServer.MailHandler.MESSAGE + "\r\n");
}
}
assertNotNull(channel.receive(20000)); // new message after idle
assertNull(channel.receive(100)); // no new message after second and third idle
assertThat(channel.receive(20000)).isNotNull(); // new message after idle
assertThat(channel.receive(100)).isNull(); // no new message after second and third idle
verify(logger).debug("Canceling IDLE");
adapter.stop();
taskScheduler.shutdown();
assertTrue(this.imapIdleServer.assertReceived("storeUserFlag"));
assertThat(this.imapIdleServer.assertReceived("storeUserFlag")).isTrue();
}
@Test
@@ -503,10 +493,10 @@ public class ImapMailReceiverTests {
adapter.start();
org.springframework.messaging.Message<?> replMessage = channel.receive(10000);
MessageHistory history = MessageHistory.read(replMessage);
assertNotNull(history);
assertThat(history).isNotNull();
Properties componentHistoryRecord = TestUtils.locateComponentInHistory(history, "simpleAdapter", 0);
assertNotNull(componentHistoryRecord);
assertEquals("mail:imap-idle-channel-adapter", componentHistoryRecord.get("type"));
assertThat(componentHistoryRecord).isNotNull();
assertThat(componentHistoryRecord.get("type")).isEqualTo("mail:imap-idle-channel-adapter");
adapter.stop();
}
@@ -559,8 +549,8 @@ public class ImapMailReceiverTests {
adapter.start();
org.springframework.messaging.Message<?> replMessage = errorChannel.receive(10000);
assertNotNull(replMessage);
assertEquals("Failed", ((Exception) replMessage.getPayload()).getCause().getMessage());
assertThat(replMessage).isNotNull();
assertThat(((Exception) replMessage.getPayload()).getCause().getMessage()).isEqualTo("Failed");
adapter.stop();
}
@@ -630,10 +620,10 @@ public class ImapMailReceiverTests {
* Idle takes 5 seconds; if all is well, we should receive the first message
* before then.
*/
assertNotNull(channel.receive(3000));
assertThat(channel.receive(3000)).isNotNull();
// We should not receive any more until the next idle elapses
assertNull(channel.receive(100));
assertNotNull(channel.receive(6000));
assertThat(channel.receive(100)).isNull();
assertThat(channel.receive(6000)).isNotNull();
adapter.stop();
}
@@ -690,9 +680,9 @@ public class ImapMailReceiverTests {
* Idle takes 5 seconds; since this server supports RECENT, we should
* not receive any early messages.
*/
assertNull(channel.receive(100));
assertNotNull(channel.receive(5000));
assertTrue(idles.await(5, TimeUnit.SECONDS));
assertThat(channel.receive(100)).isNull();
assertThat(channel.receive(5000)).isNotNull();
assertThat(idles.await(5, TimeUnit.SECONDS)).isTrue();
adapter.stop();
}
@@ -703,7 +693,7 @@ public class ImapMailReceiverTests {
final AtomicReference<ImapIdleExceptionEvent> theEvent = new AtomicReference<>();
final CountDownLatch latch = new CountDownLatch(1);
adapter.setApplicationEventPublisher(event -> {
assertNull("only one event expected", theEvent.get());
assertThat(theEvent.get()).as("only one event expected").isNull();
theEvent.set((ImapIdleExceptionEvent) event);
latch.countDown();
});
@@ -712,9 +702,9 @@ public class ImapMailReceiverTests {
adapter.setTaskScheduler(taskScheduler);
adapter.setReconnectDelay(1);
adapter.start();
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertThat(theEvent.get().toString(),
endsWith("cause=java.lang.IllegalStateException: Failure in 'idle' task. Will resubmit.]"));
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
assertThat(theEvent.get().toString())
.endsWith("cause=java.lang.IllegalStateException: Failure in 'idle' task. Will resubmit.]");
adapter.stop();
taskScheduler.destroy();
@@ -760,7 +750,7 @@ public class ImapMailReceiverTests {
}
}).start();
}
assertEquals(0, failed.get());
assertThat(failed.get()).isEqualTo(0);
}
@Test
@@ -769,10 +759,10 @@ public class ImapMailReceiverTests {
Folder folder = testAttachmentsGuts(receiver);
Message[] messages = (Message[]) receiver.receive();
Object content = messages[0].getContent();
assertEquals("bar", ((Multipart) content).getBodyPart(0).getContent().toString().trim());
assertEquals("foo", ((Multipart) content).getBodyPart(1).getContent().toString().trim());
assertThat(((Multipart) content).getBodyPart(0).getContent().toString().trim()).isEqualTo("bar");
assertThat(((Multipart) content).getBodyPart(1).getContent().toString().trim()).isEqualTo("foo");
assertSame(folder, messages[0].getFolder());
assertThat(messages[0].getFolder()).isSameAs(folder);
}
@Test
@@ -784,11 +774,10 @@ public class ImapMailReceiverTests {
.receive();
org.springframework.messaging.Message<?> received = messages[0];
Object content = received.getPayload();
assertThat(content, instanceOf(byte[].class));
assertThat(received.getHeaders().get(MailHeaders.CONTENT_TYPE),
equalTo("multipart/mixed;\r\n boundary=\"------------040903000701040401040200\""));
assertThat(received.getHeaders().get(MessageHeaders.CONTENT_TYPE),
equalTo("application/octet-stream"));
assertThat(content).isInstanceOf(byte[].class);
assertThat(received.getHeaders().get(MailHeaders.CONTENT_TYPE))
.isEqualTo("multipart/mixed;\r\n boundary=\"------------040903000701040401040200\"");
assertThat(received.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo("application/octet-stream");
}
@Test
@@ -800,9 +789,9 @@ public class ImapMailReceiverTests {
org.springframework.messaging.Message<?>[] messages =
(org.springframework.messaging.Message<?>[]) receiver.receive();
Object content = messages[0].getPayload();
assertThat(content, instanceOf(Multipart.class));
assertEquals("bar", ((Multipart) content).getBodyPart(0).getContent().toString().trim());
assertEquals("foo", ((Multipart) content).getBodyPart(1).getContent().toString().trim());
assertThat(content).isInstanceOf(Multipart.class);
assertThat(((Multipart) content).getBodyPart(0).getContent().toString().trim()).isEqualTo("bar");
assertThat(((Multipart) content).getBodyPart(1).getContent().toString().trim()).isEqualTo("foo");
}
private Folder testAttachmentsGuts(final ImapMailReceiver receiver) throws MessagingException, IOException {
@@ -833,11 +822,11 @@ public class ImapMailReceiverTests {
adapter.start();
ExecutorService exec = TestUtils.getPropertyValue(adapter, "sendingTaskExecutor", ExecutorService.class);
adapter.stop();
assertTrue(exec.isShutdown());
assertThat(exec.isShutdown()).isTrue();
adapter.start();
exec = TestUtils.getPropertyValue(adapter, "sendingTaskExecutor", ExecutorService.class);
adapter.stop();
assertTrue(exec.isShutdown());
assertThat(exec.isShutdown()).isTrue();
taskScheduler.shutdown();
}
@@ -881,12 +870,12 @@ public class ImapMailReceiverTests {
}
ImapMailReceiver receiver = new TestReceiver();
Message[] received = (Message[]) receiver.receive();
assertEquals(1, received.length);
assertSame(message1, received[0]);
assertThat(received.length).isEqualTo(1);
assertThat(received[0]).isSameAs(message1);
received = (Message[]) receiver.receive();
assertEquals(1, received.length);
assertSame(messages2, received);
assertSame(message2, received[0]);
assertThat(received.length).isEqualTo(1);
assertThat(received).isSameAs(messages2);
assertThat(received[0]).isSameAs(message2);
}
@Test
@@ -924,7 +913,7 @@ public class ImapMailReceiverTests {
latch.countDown();
});
adapter.start();
assertTrue(latch.await(60, TimeUnit.SECONDS));
assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
verify(store, atLeast(3)).connect();
adapter.stop();

19
spring-integration-mail/src/test/java/org/springframework/integration/mail/ImapMailSearchTermsTests.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,8 +16,7 @@
package org.springframework.integration.mail;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -75,11 +74,11 @@ public class ImapMailSearchTermsTests {
compileSearchTerms.setAccessible(true);
Flags flags = new Flags();
SearchTerm searchTerms = (SearchTerm) compileSearchTerms.invoke(receiver, flags);
assertTrue(searchTerms instanceof NotTerm);
assertThat(searchTerms instanceof NotTerm).isTrue();
NotTerm notTerm = (NotTerm) searchTerms;
Flags siFlags = new Flags();
siFlags.add(userFlag);
assertEquals(siFlags, ((FlagTerm) notTerm.getTerm()).getFlags());
assertThat(((FlagTerm) notTerm.getTerm()).getFlags()).isEqualTo(siFlags);
}
@Test
@@ -100,16 +99,16 @@ public class ImapMailSearchTermsTests {
Flags flags = new Flags();
flags.add(Flag.ANSWERED);
SearchTerm searchTerms = (SearchTerm) compileSearchTerms.invoke(receiver, flags);
assertTrue(searchTerms instanceof AndTerm);
assertThat(searchTerms instanceof AndTerm).isTrue();
AndTerm andTerm = (AndTerm) searchTerms;
SearchTerm[] terms = andTerm.getTerms();
assertEquals(2, terms.length);
assertThat(terms.length).isEqualTo(2);
NotTerm notTerm = (NotTerm) terms[0];
assertTrue(((FlagTerm) notTerm.getTerm()).getFlags().contains(Flag.ANSWERED));
assertThat(((FlagTerm) notTerm.getTerm()).getFlags().contains(Flag.ANSWERED)).isTrue();
notTerm = (NotTerm) terms[1];
Flags siFlags = new Flags();
siFlags.add(AbstractMailReceiver.DEFAULT_SI_USER_FLAG);
assertTrue(((FlagTerm) notTerm.getTerm()).getFlags().contains(siFlags));
assertThat(((FlagTerm) notTerm.getTerm()).getFlags().contains(siFlags)).isTrue();
}
@Test
@@ -129,7 +128,7 @@ public class ImapMailSearchTermsTests {
compileSearchTerms.setAccessible(true);
Flags flags = new Flags();
SearchTerm searchTerms = (SearchTerm) compileSearchTerms.invoke(receiver, flags);
assertTrue(searchTerms instanceof NotTerm);
assertThat(searchTerms instanceof NotTerm).isTrue();
}
}

15
spring-integration-mail/src/test/java/org/springframework/integration/mail/MailReceivingMessageSourceTests.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,8 +16,7 @@
package org.springframework.integration.mail;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.concurrent.ConcurrentLinkedQueue;
@@ -47,11 +46,11 @@ public class MailReceivingMessageSourceTests {
mailReceiver.messages.add(new javax.mail.Message[] { message4 });
MailReceivingMessageSource source = new MailReceivingMessageSource(mailReceiver);
assertEquals("Wrong message for number 1", message1, source.receive().getPayload());
assertEquals("Wrong message for number 2", message2, source.receive().getPayload());
assertEquals("Wrong message for number 3", message3, source.receive().getPayload());
assertEquals("Wrong message for number 4", message4, source.receive().getPayload());
assertNull("Expected null after exhausting all messages", source.receive());
assertThat(source.receive().getPayload()).as("Wrong message for number 1").isEqualTo(message1);
assertThat(source.receive().getPayload()).as("Wrong message for number 2").isEqualTo(message2);
assertThat(source.receive().getPayload()).as("Wrong message for number 3").isEqualTo(message3);
assertThat(source.receive().getPayload()).as("Wrong message for number 4").isEqualTo(message4);
assertThat(source.receive()).as("Expected null after exhausting all messages").isNull();
}

79
spring-integration-mail/src/test/java/org/springframework/integration/mail/MailSendingMessageHandlerContextTests.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,14 +16,8 @@
package org.springframework.integration.mail;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.io.DataInputStream;
@@ -84,12 +78,12 @@ public class MailSendingMessageHandlerContextTests {
public void stringMessagesWithConfiguration() {
this.handler.handleMessage(MailTestsHelper.createIntegrationMessage());
SimpleMailMessage mailMessage = MailTestsHelper.createSimpleMailMessage();
assertEquals("no mime message should have been sent",
0, this.mailSender.getSentMimeMessages().size());
assertEquals("only one simple message must be sent",
1, this.mailSender.getSentSimpleMailMessages().size());
assertEquals("message content different from expected",
mailMessage, this.mailSender.getSentSimpleMailMessages().get(0));
assertThat(this.mailSender.getSentMimeMessages().size()).as("no mime message should have been sent")
.isEqualTo(0);
assertThat(this.mailSender.getSentSimpleMailMessages().size()).as("only one simple message must be sent")
.isEqualTo(1);
assertThat(this.mailSender.getSentSimpleMailMessages().get(0)).as("message content different from expected")
.isEqualTo(mailMessage);
}
@Test
@@ -101,19 +95,19 @@ public class MailSendingMessageHandlerContextTests {
.setHeader(MailHeaders.TO, MailTestsHelper.TO)
.build();
this.handler.handleMessage(message);
assertEquals("no mime message should have been sent",
1, this.mailSender.getSentMimeMessages().size());
assertEquals("only one simple message must be sent",
0, this.mailSender.getSentSimpleMailMessages().size());
assertThat(this.mailSender.getSentMimeMessages().size()).as("no mime message should have been sent")
.isEqualTo(1);
assertThat(this.mailSender.getSentSimpleMailMessages().size()).as("only one simple message must be sent")
.isEqualTo(0);
byte[] buffer = new byte[1024];
MimeMessage mimeMessage = this.mailSender.getSentMimeMessages().get(0);
assertTrue("message must be multipart", mimeMessage.getContent() instanceof Multipart);
assertThat(mimeMessage.getContent() instanceof Multipart).as("message must be multipart").isTrue();
int size = new DataInputStream(((Multipart) mimeMessage.getContent()).getBodyPart(0).getInputStream()).read(buffer);
assertEquals("buffer size does not match", payload.length, size);
assertThat(size).as("buffer size does not match").isEqualTo(payload.length);
byte[] messageContent = new byte[size];
System.arraycopy(buffer, 0, messageContent, 0, payload.length);
assertArrayEquals("buffer content does not match", payload, messageContent);
assertEquals(mimeMessage.getRecipients(Message.RecipientType.TO).length, MailTestsHelper.TO.length);
assertThat(messageContent).as("buffer content does not match").isEqualTo(payload);
assertThat(MailTestsHelper.TO.length).isEqualTo(mimeMessage.getRecipients(Message.RecipientType.TO).length);
}
@Test(expected = MessageMappingException.class)
@@ -124,29 +118,34 @@ public class MailSendingMessageHandlerContextTests {
@Test //INT-2275
public void mailOutboundChannelAdapterWithinChain() {
assertNotNull(this.beanFactory.getBean("org.springframework.integration.handler.MessageHandlerChain#0$child.mail-outbound-channel-adapter-within-chain.handler"));
assertThat(this.beanFactory
.getBean("org.springframework.integration.handler.MessageHandlerChain#0$child" +
".mail-outbound-channel-adapter-within-chain.handler"))
.isNotNull();
this.sendMailOutboundChainChannel.send(MailTestsHelper.createIntegrationMessage());
SimpleMailMessage mailMessage = MailTestsHelper.createSimpleMailMessage();
assertEquals("no mime message should have been sent", 0, this.mailSender.getSentMimeMessages().size());
assertEquals("only one simple message must be sent", 1, this.mailSender.getSentSimpleMailMessages().size());
assertEquals("message content different from expected", mailMessage, this.mailSender.getSentSimpleMailMessages().get(0));
assertThat(this.mailSender.getSentMimeMessages().size()).as("no mime message should have been sent")
.isEqualTo(0);
assertThat(this.mailSender.getSentSimpleMailMessages().size()).as("only one simple message must be sent")
.isEqualTo(1);
assertThat(this.mailSender.getSentSimpleMailMessages().get(0)).as("message content different from expected")
.isEqualTo(mailMessage);
}
@Test
public void testOutboundChannelAdapterWithSimpleMailSender() {
this.simpleEmailChannel.send(MailTestsHelper.createIntegrationMessage());
assertEquals(1, this.simpleMailSender.getSentMessages().size());
assertEquals(MailTestsHelper.createSimpleMailMessage(), this.simpleMailSender.getSentMessages().get(0));
assertThat(this.simpleMailSender.getSentMessages().size()).isEqualTo(1);
assertThat(this.simpleMailSender.getSentMessages().get(0)).isEqualTo(MailTestsHelper.createSimpleMailMessage());
try {
this.simpleEmailChannel.send(new GenericMessage<byte[]>(new byte[0]));
fail("IllegalStateException expected");
}
catch (Exception e) {
assertThat(e, instanceOf(MessageHandlingException.class));
assertThat(e.getCause(), instanceOf(IllegalStateException.class));
assertThat(e.getMessage(),
containsString("this adapter requires a 'JavaMailSender' to send a 'MimeMailMessage'"));
assertThat(e).isInstanceOf(MessageHandlingException.class);
assertThat(e.getCause()).isInstanceOf(IllegalStateException.class);
assertThat(e.getMessage()).contains("this adapter requires a 'JavaMailSender' to send a 'MimeMailMessage'");
}
try {
@@ -157,10 +156,9 @@ public class MailSendingMessageHandlerContextTests {
fail("IllegalStateException expected");
}
catch (Exception e) {
assertThat(e, instanceOf(MessageHandlingException.class));
assertThat(e.getCause(), instanceOf(IllegalStateException.class));
assertThat(e.getMessage(),
containsString("this adapter requires a 'JavaMailSender' to send a 'MimeMailMessage'"));
assertThat(e).isInstanceOf(MessageHandlingException.class);
assertThat(e.getCause()).isInstanceOf(IllegalStateException.class);
assertThat(e.getMessage()).contains("this adapter requires a 'JavaMailSender' to send a 'MimeMailMessage'");
}
try {
@@ -168,10 +166,9 @@ public class MailSendingMessageHandlerContextTests {
fail("IllegalStateException expected");
}
catch (Exception e) {
assertThat(e, instanceOf(MessageHandlingException.class));
assertThat(e.getCause(), instanceOf(IllegalStateException.class));
assertThat(e.getMessage(),
containsString("this adapter requires a 'JavaMailSender' to send a 'MimeMailMessage'"));
assertThat(e).isInstanceOf(MessageHandlingException.class);
assertThat(e.getCause()).isInstanceOf(IllegalStateException.class);
assertThat(e.getMessage()).contains("this adapter requires a 'JavaMailSender' to send a 'MimeMailMessage'");
}
}

51
spring-integration-mail/src/test/java/org/springframework/integration/mail/MailSendingMessageHandlerTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2010 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.mail;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.DataInputStream;
@@ -61,12 +59,11 @@ public class MailSendingMessageHandlerTests {
public void textMessage() {
this.handler.handleMessage(MailTestsHelper.createIntegrationMessage());
SimpleMailMessage mailMessage = MailTestsHelper.createSimpleMailMessage();
assertEquals("no mime message should have been sent",
0, mailSender.getSentMimeMessages().size());
assertEquals("only one simple message must be sent",
1, mailSender.getSentSimpleMailMessages().size());
assertEquals("message content different from expected",
mailMessage, mailSender.getSentSimpleMailMessages().get(0));
assertThat(mailSender.getSentMimeMessages().size()).as("no mime message should have been sent").isEqualTo(0);
assertThat(mailSender.getSentSimpleMailMessages().size()).as("only one simple message must be sent")
.isEqualTo(1);
assertThat(mailSender.getSentSimpleMailMessages().get(0)).as("message content different from expected")
.isEqualTo(mailMessage);
}
@Test
@@ -80,45 +77,45 @@ public class MailSendingMessageHandlerTests {
this.handler.handleMessage(message);
byte[] buffer = new byte[1024];
MimeMessage mimeMessage = this.mailSender.getSentMimeMessages().get(0);
assertTrue("message must be multipart", mimeMessage.getContent() instanceof Multipart);
assertThat(mimeMessage.getContent() instanceof Multipart).as("message must be multipart").isTrue();
int size = new DataInputStream(((Multipart) mimeMessage.getContent()).getBodyPart(0).getInputStream()).read(buffer);
assertEquals("buffer size does not match", payload.length, size);
assertThat(size).as("buffer size does not match").isEqualTo(payload.length);
byte[] messageContent = new byte[size];
System.arraycopy(buffer, 0, messageContent, 0, payload.length);
assertArrayEquals("buffer content does not match", payload, messageContent);
assertEquals(mimeMessage.getRecipients(Message.RecipientType.TO).length, MailTestsHelper.TO.length);
assertThat(messageContent).as("buffer content does not match").isEqualTo(payload);
assertThat(MailTestsHelper.TO.length).isEqualTo(mimeMessage.getRecipients(Message.RecipientType.TO).length);
}
@Test
public void mailHeaders() {
this.handler.handleMessage(MailTestsHelper.createIntegrationMessage());
SimpleMailMessage mailMessage = MailTestsHelper.createSimpleMailMessage();
assertEquals("no mime message should have been sent",
0, mailSender.getSentMimeMessages().size());
assertEquals("only one simple message must be sent",
1, mailSender.getSentSimpleMailMessages().size());
assertEquals("message content different from expected",
mailMessage, mailSender.getSentSimpleMailMessages().get(0));
assertThat(mailSender.getSentMimeMessages().size()).as("no mime message should have been sent").isEqualTo(0);
assertThat(mailSender.getSentSimpleMailMessages().size()).as("only one simple message must be sent")
.isEqualTo(1);
assertThat(mailSender.getSentSimpleMailMessages().get(0)).as("message content different from expected")
.isEqualTo(mailMessage);
}
@Test
public void simpleMailMessage() {
SimpleMailMessage mailMessage = MailTestsHelper.createSimpleMailMessage();
String[] toHeaders = mailMessage.getTo();
this.handler.handleMessage(MessageBuilder.withPayload(mailMessage).build());
assertEquals("only one simple message must be sent",
1, mailSender.getSentSimpleMailMessages().size());
assertThat(mailSender.getSentSimpleMailMessages().size()).as("only one simple message must be sent")
.isEqualTo(1);
SimpleMailMessage sentMessage = mailSender.getSentSimpleMailMessages().get(0);
assertTrue(sentMessage.getTo().equals(toHeaders));
assertThat(sentMessage.getTo().equals(toHeaders)).isTrue();
}
@Test
public void simpleMailMessageOverrideWithHeaders() {
SimpleMailMessage mailMessage = MailTestsHelper.createSimpleMailMessage();
mailMessage.getTo();
this.handler.handleMessage(MessageBuilder.withPayload(mailMessage).setHeader(MailHeaders.TO, new String[]{"foo@bar.bam"}).build());
assertEquals("only one simple message must be sent",
1, mailSender.getSentSimpleMailMessages().size());
this.handler.handleMessage(MessageBuilder.withPayload(mailMessage).setHeader(MailHeaders.TO, new String[]{"foo" +
"@bar.bam"}).build());
assertThat(mailSender.getSentSimpleMailMessages().size()).as("only one simple message must be sent")
.isEqualTo(1);
SimpleMailMessage sentMessage = mailSender.getSentSimpleMailMessages().get(0);
assertTrue(sentMessage.getTo()[0].equals("foo@bar.bam"));
assertThat(sentMessage.getTo()[0].equals("foo@bar.bam")).isTrue();
}
}

24
spring-integration-mail/src/test/java/org/springframework/integration/mail/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.mail.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));
}
}

131
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/ImapIdleChannelAdapterParserTests.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,10 +16,7 @@
package org.springframework.integration.mail.config;
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.assertj.core.api.Assertions.assertThat;
import java.util.Properties;
@@ -67,139 +64,139 @@ public class ImapIdleChannelAdapterParserTests {
@Test
public void simpleAdapter() {
Object adapter = context.getBean("simpleAdapter");
assertEquals(ImapIdleChannelAdapter.class, adapter.getClass());
assertThat(adapter.getClass()).isEqualTo(ImapIdleChannelAdapter.class);
DirectFieldAccessor adapterAccessor = new DirectFieldAccessor(adapter);
Object channel = context.getBean("channel");
assertSame(channel, adapterAccessor.getPropertyValue("outputChannel"));
assertEquals(Boolean.FALSE, adapterAccessor.getPropertyValue("autoStartup"));
assertThat(adapterAccessor.getPropertyValue("outputChannel")).isSameAs(channel);
assertThat(adapterAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
Object receiver = adapterAccessor.getPropertyValue("mailReceiver");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Object url = receiverAccessor.getPropertyValue("url");
assertEquals(new URLName("imap:foo"), url);
assertThat(url).isEqualTo(new URLName("imap:foo"));
Properties properties = (Properties) receiverAccessor.getPropertyValue("javaMailProperties");
// mail.imap(s).peek properties
assertEquals(2, properties.size());
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("shouldDeleteMessages"));
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead"));
assertNull(adapterAccessor.getPropertyValue("errorChannel"));
assertNull(adapterAccessor.getPropertyValue("adviceChain"));
assertEquals(Boolean.FALSE, receiverAccessor.getPropertyValue("embeddedPartsAsBytes"));
assertNotNull(receiverAccessor.getPropertyValue("headerMapper"));
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("simpleContent"));
assertThat(properties.size()).isEqualTo(2);
assertThat(receiverAccessor.getPropertyValue("shouldDeleteMessages")).isEqualTo(Boolean.TRUE);
assertThat(receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead")).isEqualTo(Boolean.TRUE);
assertThat(adapterAccessor.getPropertyValue("errorChannel")).isNull();
assertThat(adapterAccessor.getPropertyValue("adviceChain")).isNull();
assertThat(receiverAccessor.getPropertyValue("embeddedPartsAsBytes")).isEqualTo(Boolean.FALSE);
assertThat(receiverAccessor.getPropertyValue("headerMapper")).isNotNull();
assertThat(receiverAccessor.getPropertyValue("simpleContent")).isEqualTo(Boolean.TRUE);
}
@Test
public void simpleAdapterWithErrorChannel() {
Object adapter = context.getBean("simpleAdapterWithErrorChannel");
assertEquals(ImapIdleChannelAdapter.class, adapter.getClass());
assertThat(adapter.getClass()).isEqualTo(ImapIdleChannelAdapter.class);
DirectFieldAccessor adapterAccessor = new DirectFieldAccessor(adapter);
Object channel = context.getBean("channel");
assertSame(channel, adapterAccessor.getPropertyValue("outputChannel"));
assertEquals(Boolean.FALSE, adapterAccessor.getPropertyValue("autoStartup"));
assertThat(adapterAccessor.getPropertyValue("outputChannel")).isSameAs(channel);
assertThat(adapterAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
Object receiver = adapterAccessor.getPropertyValue("mailReceiver");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Object url = receiverAccessor.getPropertyValue("url");
assertEquals(new URLName("imap:foo"), url);
assertThat(url).isEqualTo(new URLName("imap:foo"));
Properties properties = (Properties) receiverAccessor.getPropertyValue("javaMailProperties");
// mail.imap(s).peek properties
assertEquals(2, properties.size());
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("shouldDeleteMessages"));
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead"));
assertSame(context.getBean("errorChannel"), adapterAccessor.getPropertyValue("errorChannel"));
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("embeddedPartsAsBytes"));
assertNull(receiverAccessor.getPropertyValue("headerMapper"));
assertEquals(Boolean.FALSE, receiverAccessor.getPropertyValue("simpleContent"));
assertThat(properties.size()).isEqualTo(2);
assertThat(receiverAccessor.getPropertyValue("shouldDeleteMessages")).isEqualTo(Boolean.TRUE);
assertThat(receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead")).isEqualTo(Boolean.TRUE);
assertThat(adapterAccessor.getPropertyValue("errorChannel")).isSameAs(context.getBean("errorChannel"));
assertThat(receiverAccessor.getPropertyValue("embeddedPartsAsBytes")).isEqualTo(Boolean.TRUE);
assertThat(receiverAccessor.getPropertyValue("headerMapper")).isNull();
assertThat(receiverAccessor.getPropertyValue("simpleContent")).isEqualTo(Boolean.FALSE);
}
@Test
public void simpleAdapterWithMarkeMessagesAsRead() {
Object adapter = context.getBean("simpleAdapterMarkAsRead");
assertEquals(ImapIdleChannelAdapter.class, adapter.getClass());
assertThat(adapter.getClass()).isEqualTo(ImapIdleChannelAdapter.class);
DirectFieldAccessor adapterAccessor = new DirectFieldAccessor(adapter);
Object channel = context.getBean("channel");
assertSame(channel, adapterAccessor.getPropertyValue("outputChannel"));
assertEquals(Boolean.FALSE, adapterAccessor.getPropertyValue("autoStartup"));
assertThat(adapterAccessor.getPropertyValue("outputChannel")).isSameAs(channel);
assertThat(adapterAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
Object receiver = adapterAccessor.getPropertyValue("mailReceiver");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Object url = receiverAccessor.getPropertyValue("url");
assertEquals(new URLName("imap:foo"), url);
assertThat(url).isEqualTo(new URLName("imap:foo"));
Properties properties = (Properties) receiverAccessor.getPropertyValue("javaMailProperties");
// mail.imap(s).peek properties
assertEquals(2, properties.size());
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("shouldDeleteMessages"));
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead"));
assertEquals("flagged", receiverAccessor.getPropertyValue("userFlag"));
assertThat(properties.size()).isEqualTo(2);
assertThat(receiverAccessor.getPropertyValue("shouldDeleteMessages")).isEqualTo(Boolean.TRUE);
assertThat(receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead")).isEqualTo(Boolean.TRUE);
assertThat(receiverAccessor.getPropertyValue("userFlag")).isEqualTo("flagged");
}
@Test
public void simpleAdapterWithMarkeMessagesAsReadFalse() {
Object adapter = context.getBean("simpleAdapterMarkAsReadFalse");
assertEquals(ImapIdleChannelAdapter.class, adapter.getClass());
assertThat(adapter.getClass()).isEqualTo(ImapIdleChannelAdapter.class);
DirectFieldAccessor adapterAccessor = new DirectFieldAccessor(adapter);
Object channel = context.getBean("channel");
assertSame(channel, adapterAccessor.getPropertyValue("outputChannel"));
assertEquals(Boolean.FALSE, adapterAccessor.getPropertyValue("autoStartup"));
assertThat(adapterAccessor.getPropertyValue("outputChannel")).isSameAs(channel);
assertThat(adapterAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
Object receiver = adapterAccessor.getPropertyValue("mailReceiver");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Object url = receiverAccessor.getPropertyValue("url");
assertEquals(new URLName("imap:foo"), url);
assertThat(url).isEqualTo(new URLName("imap:foo"));
Properties properties = (Properties) receiverAccessor.getPropertyValue("javaMailProperties");
// mail.imap(s).peek properties
assertEquals(2, properties.size());
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("shouldDeleteMessages"));
assertEquals(Boolean.FALSE, receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead"));
assertThat(properties.size()).isEqualTo(2);
assertThat(receiverAccessor.getPropertyValue("shouldDeleteMessages")).isEqualTo(Boolean.TRUE);
assertThat(receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead")).isEqualTo(Boolean.FALSE);
}
@Test
public void customAdapter() {
Object adapter = context.getBean("customAdapter");
assertEquals(ImapIdleChannelAdapter.class, adapter.getClass());
assertThat(adapter.getClass()).isEqualTo(ImapIdleChannelAdapter.class);
DirectFieldAccessor adapterAccessor = new DirectFieldAccessor(adapter);
Object channel = context.getBean("channel");
assertSame(channel, adapterAccessor.getPropertyValue("outputChannel"));
assertEquals(Boolean.FALSE, adapterAccessor.getPropertyValue("autoStartup"));
assertThat(adapterAccessor.getPropertyValue("outputChannel")).isSameAs(channel);
assertThat(adapterAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
Object receiver = adapterAccessor.getPropertyValue("mailReceiver");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Object url = receiverAccessor.getPropertyValue("url");
assertEquals(new URLName("imap:foo"), url);
assertThat(url).isEqualTo(new URLName("imap:foo"));
Properties properties = (Properties) receiverAccessor.getPropertyValue("javaMailProperties");
assertEquals("bar", properties.getProperty("foo"));
assertEquals(Boolean.FALSE, receiverAccessor.getPropertyValue("shouldDeleteMessages"));
assertThat(properties.getProperty("foo")).isEqualTo("bar");
assertThat(receiverAccessor.getPropertyValue("shouldDeleteMessages")).isEqualTo(Boolean.FALSE);
SearchTermStrategy stStrategy = context.getBean("searchTermStrategy", SearchTermStrategy.class);
assertEquals(stStrategy, TestUtils.getPropertyValue(adapter, "mailReceiver.searchTermStrategy"));
assertThat(TestUtils.getPropertyValue(adapter, "mailReceiver.searchTermStrategy")).isEqualTo(stStrategy);
}
@Test
public void testAutoChannel() {
assertSame(autoChannel, TestUtils.getPropertyValue(autoChannelAdapter, "outputChannel"));
assertThat(TestUtils.getPropertyValue(autoChannelAdapter, "outputChannel")).isSameAs(autoChannel);
}
@Test
public void transactionalAdapter() {
Object adapter = context.getBean("transactionalAdapter");
assertEquals(ImapIdleChannelAdapter.class, adapter.getClass());
assertThat(adapter.getClass()).isEqualTo(ImapIdleChannelAdapter.class);
DirectFieldAccessor adapterAccessor = new DirectFieldAccessor(adapter);
Object channel = context.getBean("channel");
assertSame(channel, adapterAccessor.getPropertyValue("outputChannel"));
assertEquals(Boolean.FALSE, adapterAccessor.getPropertyValue("autoStartup"));
assertThat(adapterAccessor.getPropertyValue("outputChannel")).isSameAs(channel);
assertThat(adapterAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
Object receiver = adapterAccessor.getPropertyValue("mailReceiver");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Object url = receiverAccessor.getPropertyValue("url");
assertEquals(new URLName("imap:foo"), url);
assertThat(url).isEqualTo(new URLName("imap:foo"));
Properties properties = (Properties) receiverAccessor.getPropertyValue("javaMailProperties");
// mail.imap(s).peek properties
assertEquals(2, properties.size());
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("shouldDeleteMessages"));
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead"));
assertNull(adapterAccessor.getPropertyValue("errorChannel"));
assertEquals(context.getBean("executor"), adapterAccessor.getPropertyValue("sendingTaskExecutor"));
assertNotNull(adapterAccessor.getPropertyValue("adviceChain"));
assertThat(properties.size()).isEqualTo(2);
assertThat(receiverAccessor.getPropertyValue("shouldDeleteMessages")).isEqualTo(Boolean.TRUE);
assertThat(receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead")).isEqualTo(Boolean.TRUE);
assertThat(adapterAccessor.getPropertyValue("errorChannel")).isNull();
assertThat(adapterAccessor.getPropertyValue("sendingTaskExecutor")).isEqualTo(context.getBean("executor"));
assertThat(adapterAccessor.getPropertyValue("adviceChain")).isNotNull();
}
public static class TestSearchTermStrategy implements SearchTermStrategy {

9
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/ImapIdleIntegrationTests.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.mail.config;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
@@ -55,7 +54,7 @@ public class ImapIdleIntegrationTests {
new ClassPathXmlApplicationContext("imap-idle-mock-integration-config.xml", this.getClass());
PostTransactionProcessor processor = context.getBean("syncProcessor", PostTransactionProcessor.class);
ImapIdleChannelAdapter adapter = context.getBean("customAdapter", ImapIdleChannelAdapter.class);
assertNotNull(TestUtils.getPropertyValue(adapter, "applicationEventPublisher"));
assertThat(TestUtils.getPropertyValue(adapter, "applicationEventPublisher")).isNotNull();
ImapMailReceiver receiver = TestUtils.getPropertyValue(adapter, "mailReceiver", ImapMailReceiver.class);
// setup mock scenario
@@ -93,7 +92,7 @@ public class ImapIdleIntegrationTests {
adapter.start();
assertTrue(txProcessorLatch.await(10, TimeUnit.SECONDS));
assertThat(txProcessorLatch.await(10, TimeUnit.SECONDS)).isTrue();
adapter.stop();
context.close();

139
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/InboundChannelAdapterParserTests.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,13 +16,8 @@
package org.springframework.integration.mail.config;
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.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import javax.mail.Authenticator;
@@ -74,51 +69,51 @@ public class InboundChannelAdapterParserTests {
@Test
public void pop3ShouldDeleteTrue() {
AbstractMailReceiver receiver = this.getReceiver("pop3ShouldDeleteTrue");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Boolean value = (Boolean) receiverAccessor.getPropertyValue("shouldDeleteMessages");
assertTrue(value);
assertEquals(Boolean.FALSE, receiverAccessor.getPropertyValue("embeddedPartsAsBytes"));
assertNotNull(receiverAccessor.getPropertyValue("headerMapper"));
assertThat(value).isTrue();
assertThat(receiverAccessor.getPropertyValue("embeddedPartsAsBytes")).isEqualTo(Boolean.FALSE);
assertThat(receiverAccessor.getPropertyValue("headerMapper")).isNotNull();
}
@Test
public void imapShouldMarkMessagesAsRead() {
AbstractMailReceiver receiver = this.getReceiver("imapShouldMarkAsReadTrue");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Boolean value = (Boolean) receiverAccessor.getPropertyValue("shouldMarkMessagesAsRead");
assertTrue(value);
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("embeddedPartsAsBytes"));
assertNull(receiverAccessor.getPropertyValue("headerMapper"));
assertThat(value).isTrue();
assertThat(receiverAccessor.getPropertyValue("embeddedPartsAsBytes")).isEqualTo(Boolean.TRUE);
assertThat(receiverAccessor.getPropertyValue("headerMapper")).isNull();
}
@Test
public void pop3ShouldDeleteFalse() {
AbstractMailReceiver receiver = this.getReceiver("pop3ShouldDeleteFalse");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
Boolean value = (Boolean) new DirectFieldAccessor(receiver).getPropertyValue("shouldDeleteMessages");
assertFalse(value);
assertThat(value).isFalse();
}
@Test
public void imapShouldDeleteTrue() {
AbstractMailReceiver receiver = this.getReceiver("imapShouldDeleteTrue");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Boolean value = (Boolean) receiverAccessor.getPropertyValue("shouldDeleteMessages");
assertTrue(value);
assertEquals(Boolean.TRUE, receiverAccessor.getPropertyValue("simpleContent"));
assertThat(value).isTrue();
assertThat(receiverAccessor.getPropertyValue("simpleContent")).isEqualTo(Boolean.TRUE);
}
@Test
public void imapShouldDeleteFalse() {
AbstractMailReceiver receiver = this.getReceiver("imapShouldDeleteFalse");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Boolean value = (Boolean) receiverAccessor.getPropertyValue("shouldDeleteMessages");
assertFalse(value);
assertEquals(Boolean.FALSE, receiverAccessor.getPropertyValue("simpleContent"));
assertThat(value).isFalse();
assertThat(receiverAccessor.getPropertyValue("simpleContent")).isEqualTo(Boolean.FALSE);
}
@@ -127,34 +122,34 @@ public class InboundChannelAdapterParserTests {
@Test
public void pop3ShouldDeleteTrueProperty() {
AbstractMailReceiver receiver = this.getReceiver("pop3ShouldDeleteTrueProperty");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
Boolean value = (Boolean) new DirectFieldAccessor(receiver).getPropertyValue("shouldDeleteMessages");
assertTrue(value);
assertThat(value).isTrue();
}
@Test
public void pop3ShouldDeleteFalseProperty() {
AbstractMailReceiver receiver = this.getReceiver("pop3ShouldDeleteFalseProperty");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
Boolean value = (Boolean) new DirectFieldAccessor(receiver).getPropertyValue("shouldDeleteMessages");
assertFalse(value);
assertThat(value).isFalse();
}
@Test
public void imapShouldDeleteTrueProperty() {
AbstractMailReceiver receiver = this.getReceiver("imapShouldDeleteTrueProperty");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Boolean value = (Boolean) new DirectFieldAccessor(receiver).getPropertyValue("shouldDeleteMessages");
assertTrue(value);
assertNotNull(TestUtils.getPropertyValue(receiver, "evaluationContext.beanResolver"));
assertThat(value).isTrue();
assertThat(TestUtils.getPropertyValue(receiver, "evaluationContext.beanResolver")).isNotNull();
}
@Test
public void imapShouldDeleteFalseProperty() {
AbstractMailReceiver receiver = this.getReceiver("imapShouldDeleteFalseProperty");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Boolean value = (Boolean) new DirectFieldAccessor(receiver).getPropertyValue("shouldDeleteMessages");
assertFalse(value);
assertThat(value).isFalse();
}
@@ -163,28 +158,28 @@ public class InboundChannelAdapterParserTests {
@Test
public void pop3WithAuthenticator() {
AbstractMailReceiver receiver = this.getReceiver("pop3WithAuthenticator");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
Object authenticator = new DirectFieldAccessor(receiver).getPropertyValue("javaMailAuthenticator");
assertNotNull(authenticator);
assertEquals(context.getBean("testAuthenticator"), authenticator);
assertThat(authenticator).isNotNull();
assertThat(authenticator).isEqualTo(context.getBean("testAuthenticator"));
}
@Test
public void imapWithAuthenticator() {
AbstractMailReceiver receiver = this.getReceiver("imapWithAuthenticator");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Object authenticator = new DirectFieldAccessor(receiver).getPropertyValue("javaMailAuthenticator");
assertNotNull(authenticator);
assertEquals(context.getBean("testAuthenticator"), authenticator);
assertThat(authenticator).isNotNull();
assertThat(authenticator).isEqualTo(context.getBean("testAuthenticator"));
}
@Test
public void imapIdleWithAuthenticator() {
AbstractMailReceiver receiver = this.getReceiver("imapIdleWithAuthenticator");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Object authenticator = new DirectFieldAccessor(receiver).getPropertyValue("javaMailAuthenticator");
assertNotNull(authenticator);
assertEquals(context.getBean("testAuthenticator"), authenticator);
assertThat(authenticator).isNotNull();
assertThat(authenticator).isEqualTo(context.getBean("testAuthenticator"));
}
@@ -198,33 +193,33 @@ public class InboundChannelAdapterParserTests {
@Test
public void pop3WithMaxFetchSize() {
AbstractMailReceiver receiver = this.getReceiver("pop3WithMaxFetchSize");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
Object value = new DirectFieldAccessor(receiver).getPropertyValue("maxFetchSize");
assertEquals(11, value);
assertThat(value).isEqualTo(11);
}
@Test
public void pop3WithMaxFetchSizeFallsBackToPollerMax() {
AbstractMailReceiver receiver = this.getReceiver("pop3WithMaxFetchSizeFallsBackToPollerMax");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
Object value = new DirectFieldAccessor(receiver).getPropertyValue("maxFetchSize");
assertEquals(99, value);
assertThat(value).isEqualTo(99);
}
@Test
public void imapWithMaxFetchSize() {
AbstractMailReceiver receiver = this.getReceiver("imapWithMaxFetchSize");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Object value = new DirectFieldAccessor(receiver).getPropertyValue("maxFetchSize");
assertEquals(22, value);
assertThat(value).isEqualTo(22);
}
@Test
public void imapIdleWithMaxFetchSize() {
AbstractMailReceiver receiver = this.getReceiver("imapIdleWithMaxFetchSize");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Object value = new DirectFieldAccessor(receiver).getPropertyValue("maxFetchSize");
assertEquals(33, value);
assertThat(value).isEqualTo(33);
}
@@ -233,28 +228,28 @@ public class InboundChannelAdapterParserTests {
@Test
public void pop3WithSession() {
AbstractMailReceiver receiver = this.getReceiver("pop3WithSession");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
Object session = new DirectFieldAccessor(receiver).getPropertyValue("session");
assertNotNull(session);
assertEquals(context.getBean("testSession"), session);
assertThat(session).isNotNull();
assertThat(session).isEqualTo(context.getBean("testSession"));
}
@Test
public void imapWithSession() {
AbstractMailReceiver receiver = this.getReceiver("imapWithSession");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Object session = new DirectFieldAccessor(receiver).getPropertyValue("session");
assertNotNull(session);
assertEquals(context.getBean("testSession"), session);
assertThat(session).isNotNull();
assertThat(session).isEqualTo(context.getBean("testSession"));
}
@Test
public void imapIdleWithSession() {
AbstractMailReceiver receiver = this.getReceiver("imapIdleWithSession");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Object session = new DirectFieldAccessor(receiver).getPropertyValue("session");
assertNotNull(session);
assertEquals(context.getBean("testSession"), session);
assertThat(session).isNotNull();
assertThat(session).isEqualTo(context.getBean("testSession"));
}
@@ -263,25 +258,25 @@ public class InboundChannelAdapterParserTests {
@Test
public void pop3WithoutStoreUri() {
AbstractMailReceiver receiver = this.getReceiver("pop3WithoutStoreUri");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
Object url = new DirectFieldAccessor(receiver).getPropertyValue("url");
assertNull(url);
assertThat(url).isNull();
}
@Test
public void imapWithoutStoreUri() {
AbstractMailReceiver receiver = this.getReceiver("imapWithoutStoreUri");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Object url = new DirectFieldAccessor(receiver).getPropertyValue("url");
assertNull(url);
assertThat(url).isNull();
}
@Test
public void imapIdleWithoutStoreUri() {
AbstractMailReceiver receiver = this.getReceiver("imapIdleWithoutStoreUri");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
Object url = new DirectFieldAccessor(receiver).getPropertyValue("url");
assertNull(url);
assertThat(url).isNull();
}
@@ -296,7 +291,7 @@ public class InboundChannelAdapterParserTests {
fail("expected a parser error");
}
catch (BeanDefinitionStoreException e) {
assertEquals(SAXParseException.class, e.getCause().getClass());
assertThat(e.getCause().getClass()).isEqualTo(SAXParseException.class);
}
}
@@ -306,12 +301,12 @@ public class InboundChannelAdapterParserTests {
@Test
public void imapWithSearchTermStrategy() {
AbstractMailReceiver receiver = this.getReceiver("imapWithSearch");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Object sts = receiverAccessor.getPropertyValue("searchTermStrategy");
assertNotNull(sts);
assertSame(context.getBean(SearchTermStrategy.class), sts);
assertEquals("flagged", receiverAccessor.getPropertyValue("userFlag"));
assertThat(sts).isNotNull();
assertThat(sts).isSameAs(context.getBean(SearchTermStrategy.class));
assertThat(receiverAccessor.getPropertyValue("userFlag")).isEqualTo("flagged");
}
@Test
@@ -323,7 +318,7 @@ public class InboundChannelAdapterParserTests {
fail("expected a parser error");
}
catch (BeanCreationException e) {
assertTrue(e.getMessage().contains("searchTermStrategy is only allowed with imap"));
assertThat(e.getMessage().contains("searchTermStrategy is only allowed with imap")).isTrue();
}
}
@@ -339,7 +334,7 @@ public class InboundChannelAdapterParserTests {
@Test
public void testAutoChannel() {
assertSame(autoChannel, TestUtils.getPropertyValue(autoChannelAdapter, "outputChannel"));
assertThat(TestUtils.getPropertyValue(autoChannelAdapter, "outputChannel")).isSameAs(autoChannel);
}
}

32
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/MailHeaderEnricherTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2018 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.mail.config;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Map;
@@ -57,14 +57,14 @@ public class MailHeaderEnricherTests {
template.setDefaultDestination(this.literalValuesInput);
Message<?> result = template.sendAndReceive(new GenericMessage<>("test"));
Map<String, Object> headers = result.getHeaders();
assertEquals("test.to", headers.get(MailHeaders.TO));
assertEquals("test.cc", headers.get(MailHeaders.CC));
assertEquals("test.bcc", headers.get(MailHeaders.BCC));
assertEquals("test.from", headers.get(MailHeaders.FROM));
assertEquals("test.reply-to", headers.get(MailHeaders.REPLY_TO));
assertEquals("test.subject", headers.get(MailHeaders.SUBJECT));
assertEquals("foo.txt", headers.get(MailHeaders.ATTACHMENT_FILENAME));
assertEquals("1", headers.get(MailHeaders.MULTIPART_MODE));
assertThat(headers.get(MailHeaders.TO)).isEqualTo("test.to");
assertThat(headers.get(MailHeaders.CC)).isEqualTo("test.cc");
assertThat(headers.get(MailHeaders.BCC)).isEqualTo("test.bcc");
assertThat(headers.get(MailHeaders.FROM)).isEqualTo("test.from");
assertThat(headers.get(MailHeaders.REPLY_TO)).isEqualTo("test.reply-to");
assertThat(headers.get(MailHeaders.SUBJECT)).isEqualTo("test.subject");
assertThat(headers.get(MailHeaders.ATTACHMENT_FILENAME)).isEqualTo("foo.txt");
assertThat(headers.get(MailHeaders.MULTIPART_MODE)).isEqualTo("1");
}
@Test
@@ -73,12 +73,12 @@ public class MailHeaderEnricherTests {
template.setDefaultDestination(this.expressionsInput);
Message<?> result = template.sendAndReceive(new GenericMessage<>("foo"));
Map<String, Object> headers = result.getHeaders();
assertEquals("foo.to", headers.get(MailHeaders.TO));
assertEquals("foo.cc", headers.get(MailHeaders.CC));
assertEquals("foo.bcc", headers.get(MailHeaders.BCC));
assertEquals("foo.from", headers.get(MailHeaders.FROM));
assertEquals("foo.reply-to", headers.get(MailHeaders.REPLY_TO));
assertEquals("foo.subject", headers.get(MailHeaders.SUBJECT));
assertThat(headers.get(MailHeaders.TO)).isEqualTo("foo.to");
assertThat(headers.get(MailHeaders.CC)).isEqualTo("foo.cc");
assertThat(headers.get(MailHeaders.BCC)).isEqualTo("foo.bcc");
assertThat(headers.get(MailHeaders.FROM)).isEqualTo("foo.from");
assertThat(headers.get(MailHeaders.REPLY_TO)).isEqualTo("foo.reply-to");
assertThat(headers.get(MailHeaders.SUBJECT)).isEqualTo("foo.subject");
}
}

21
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/MailOutboundChannelAdapterParserTests.java
View File

@@ -16,8 +16,7 @@
package org.springframework.integration.mail.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Properties;
@@ -55,8 +54,8 @@ public class MailOutboundChannelAdapterParserTests {
new DirectFieldAccessor(adapter).getPropertyValue("handler");
DirectFieldAccessor fieldAccessor = new DirectFieldAccessor(handler);
MailSender mailSender = (MailSender) fieldAccessor.getPropertyValue("mailSender");
assertNotNull(mailSender);
assertEquals(23, fieldAccessor.getPropertyValue("order"));
assertThat(mailSender).isNotNull();
assertThat(fieldAccessor.getPropertyValue("order")).isEqualTo(23);
context.close();
}
@@ -68,7 +67,7 @@ public class MailOutboundChannelAdapterParserTests {
MessageHandler handler = (MessageHandler)
new DirectFieldAccessor(adapter).getPropertyValue("handler");
handler.handleMessage(new GenericMessage<>("foo"));
assertEquals(1, adviceCalled);
assertThat(adviceCalled).isEqualTo(1);
context.close();
}
@@ -81,7 +80,7 @@ public class MailOutboundChannelAdapterParserTests {
new DirectFieldAccessor(adapter).getPropertyValue("handler");
DirectFieldAccessor fieldAccessor = new DirectFieldAccessor(handler);
MailSender mailSender = (MailSender) fieldAccessor.getPropertyValue("mailSender");
assertNotNull(mailSender);
assertThat(mailSender).isNotNull();
context.close();
}
@@ -91,7 +90,7 @@ public class MailOutboundChannelAdapterParserTests {
"mailOutboundChannelAdapterParserTests.xml", this.getClass());
PollingConsumer pc = context.getBean("adapterWithPollableChannel", PollingConsumer.class);
QueueChannel pollableChannel = TestUtils.getPropertyValue(pc, "inputChannel", QueueChannel.class);
assertEquals("pollableChannel", pollableChannel.getComponentName());
assertThat(pollableChannel.getComponentName()).isEqualTo("pollableChannel");
context.close();
}
@@ -104,11 +103,11 @@ public class MailOutboundChannelAdapterParserTests {
new DirectFieldAccessor(adapter).getPropertyValue("handler");
DirectFieldAccessor fieldAccessor = new DirectFieldAccessor(handler);
MailSender mailSender = (MailSender) fieldAccessor.getPropertyValue("mailSender");
assertNotNull(mailSender);
assertThat(mailSender).isNotNull();
Properties javaMailProperties = (Properties) TestUtils.getPropertyValue(mailSender, "javaMailProperties");
assertEquals(9, javaMailProperties.size());
assertNotNull(javaMailProperties);
assertEquals("true", javaMailProperties.get("mail.smtps.auth"));
assertThat(javaMailProperties.size()).isEqualTo(9);
assertThat(javaMailProperties).isNotNull();
assertThat(javaMailProperties.get("mail.smtps.auth")).isEqualTo("true");
context.close();
}

16
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/MailToStringTransformerParserTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2018 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.mail.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 javax.mail.internet.MimeMessage;
@@ -52,8 +50,8 @@ class MailToStringTransformerParserTests {
Mockito.when(mimeMessage.getContent()).thenReturn("hello");
input.send(new GenericMessage<javax.mail.Message>(mimeMessage));
Message<?> result = output.receive(10_000);
assertNotNull(result);
assertEquals("hello", result.getPayload());
assertThat(result).isNotNull();
assertThat(result.getPayload()).isEqualTo("hello");
Mockito.verify(mimeMessage).getContent();
}
}
@@ -70,8 +68,8 @@ class MailToStringTransformerParserTests {
Mockito.when(mimeMessage.getContent()).thenReturn("foo");
input.send(new GenericMessage<javax.mail.Message>(mimeMessage));
Message<?> result = output.receive(0);
assertNotNull(result);
assertEquals("FOO!!!", result.getPayload());
assertThat(result).isNotNull();
assertThat(result.getPayload()).isEqualTo("FOO!!!");
Mockito.verify(mimeMessage).getContent();
}
}
@@ -83,7 +81,7 @@ class MailToStringTransformerParserTests {
.close();
}
catch (BeanDefinitionStoreException e) {
assertTrue(e.getMessage().contains("input-channel"));
assertThat(e.getMessage().contains("input-channel")).isTrue();
}
}

6
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/MessageWithContentTypeTests.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,7 +16,7 @@
package org.springframework.integration.mail.config;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -82,7 +82,7 @@ public class MessageWithContentTypeTests {
when(sender.createMimeMessage()).thenReturn(mMessage);
doAnswer(invocation -> {
MimeMessage mimeMessage = invocation.getArgument(0);
assertEquals("text/html", mimeMessage.getDataHandler().getContentType());
assertThat(mimeMessage.getDataHandler().getContentType()).isEqualTo("text/html");
return null;
}).when(sender).send(Mockito.any(MimeMessage.class));

32
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/PollingMailSourceParserTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2009 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.mail.config;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Properties;
@@ -50,39 +50,39 @@ public class PollingMailSourceParserTests {
@Test
public void imapAdapter() {
Object adapter = context.getBean("imapAdapter");
assertEquals(SourcePollingChannelAdapter.class, adapter.getClass());
assertThat(adapter.getClass()).isEqualTo(SourcePollingChannelAdapter.class);
DirectFieldAccessor adapterAccessor = new DirectFieldAccessor(adapter);
assertEquals(Boolean.FALSE, adapterAccessor.getPropertyValue("autoStartup"));
assertThat(adapterAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
Object channel = context.getBean("channel");
assertEquals(channel, adapterAccessor.getPropertyValue("outputChannel"));
assertThat(adapterAccessor.getPropertyValue("outputChannel")).isEqualTo(channel);
Object source = adapterAccessor.getPropertyValue("source");
assertEquals(MailReceivingMessageSource.class, source.getClass());
assertThat(source.getClass()).isEqualTo(MailReceivingMessageSource.class);
Object receiver = new DirectFieldAccessor(source).getPropertyValue("mailReceiver");
assertEquals(ImapMailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(ImapMailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Object url = receiverAccessor.getPropertyValue("url");
assertEquals(new URLName("imap:foo"), url);
assertThat(url).isEqualTo(new URLName("imap:foo"));
Properties properties = (Properties) receiverAccessor.getPropertyValue("javaMailProperties");
assertEquals("bar", properties.getProperty("foo"));
assertThat(properties.getProperty("foo")).isEqualTo("bar");
}
@Test
public void pop3Adapter() {
Object adapter = context.getBean("pop3Adapter");
assertEquals(SourcePollingChannelAdapter.class, adapter.getClass());
assertThat(adapter.getClass()).isEqualTo(SourcePollingChannelAdapter.class);
DirectFieldAccessor adapterAccessor = new DirectFieldAccessor(adapter);
assertEquals(Boolean.FALSE, adapterAccessor.getPropertyValue("autoStartup"));
assertThat(adapterAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
Object channel = context.getBean("channel");
assertEquals(channel, adapterAccessor.getPropertyValue("outputChannel"));
assertThat(adapterAccessor.getPropertyValue("outputChannel")).isEqualTo(channel);
Object source = adapterAccessor.getPropertyValue("source");
assertEquals(MailReceivingMessageSource.class, source.getClass());
assertThat(source.getClass()).isEqualTo(MailReceivingMessageSource.class);
Object receiver = new DirectFieldAccessor(source).getPropertyValue("mailReceiver");
assertEquals(Pop3MailReceiver.class, receiver.getClass());
assertThat(receiver.getClass()).isEqualTo(Pop3MailReceiver.class);
DirectFieldAccessor receiverAccessor = new DirectFieldAccessor(receiver);
Object url = receiverAccessor.getPropertyValue("url");
assertEquals(new URLName("pop3:bar"), url);
assertThat(url).isEqualTo(new URLName("pop3:bar"));
Properties properties = (Properties) receiverAccessor.getPropertyValue("javaMailProperties");
assertEquals("bar", properties.getProperty("foo"));
assertThat(properties.getProperty("foo")).isEqualTo("bar");
}
}

22
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/Pop3Tests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2016-2017 the original author or authors.
* Copyright 2016-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.mail.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.util.Arrays;
@@ -50,7 +48,7 @@ public class Pop3Tests {
while (n++ < 100 && (!pop3Server.isListening())) {
Thread.sleep(100);
}
assertTrue(n < 100);
assertThat(n < 100).isTrue();
}
@AfterClass
@@ -64,14 +62,14 @@ public class Pop3Tests {
receiver.setHeaderMapper(new DefaultMailHeaderMapper());
MailReceivingMessageSource source = new MailReceivingMessageSource(receiver);
Message<?> message = source.receive();
assertNotNull(message);
assertThat(message).isNotNull();
MessageHeaders headers = message.getHeaders();
assertEquals("Foo <foo@bar>", headers.get(MailHeaders.TO, String[].class)[0]);
assertEquals("[a@b, c@d]", Arrays.toString(headers.get(MailHeaders.CC, String[].class)));
assertEquals("[e@f, g@h]", Arrays.toString(headers.get(MailHeaders.BCC, String[].class)));
assertEquals("Bar <bar@baz>", headers.get(MailHeaders.FROM));
assertEquals("Test Email", headers.get(MailHeaders.SUBJECT));
assertEquals("foo\r\n\r\n", message.getPayload());
assertThat(headers.get(MailHeaders.TO, String[].class)[0]).isEqualTo("Foo <foo@bar>");
assertThat(Arrays.toString(headers.get(MailHeaders.CC, String[].class))).isEqualTo("[a@b, c@d]");
assertThat(Arrays.toString(headers.get(MailHeaders.BCC, String[].class))).isEqualTo("[e@f, g@h]");
assertThat(headers.get(MailHeaders.FROM)).isEqualTo("Bar <bar@baz>");
assertThat(headers.get(MailHeaders.SUBJECT)).isEqualTo("Test Email");
assertThat(message.getPayload()).isEqualTo("foo\r\n\r\n");
}
}

21
spring-integration-mail/src/test/java/org/springframework/integration/mail/config/SmtpTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2016 the original author or authors.
* Copyright 2016-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,10 +16,7 @@
package org.springframework.integration.mail.config;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.endsWith;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.AfterClass;
import org.junit.BeforeClass;
@@ -47,7 +44,7 @@ public class SmtpTests {
while (n++ < 100 && (!smtpServer.isListening())) {
Thread.sleep(100);
}
assertTrue(n < 100);
assertThat(n < 100).isTrue();
}
@AfterClass
@@ -75,13 +72,13 @@ public class SmtpTests {
Thread.sleep(100);
}
assertTrue(smtpServer.getMessages().size() > 0);
assertThat(smtpServer.getMessages().size() > 0).isTrue();
String message = smtpServer.getMessages().get(0);
assertThat(message, endsWith("foo\n"));
assertThat(message, containsString("foo@bar"));
assertThat(message, containsString("bar@baz"));
assertThat(message, containsString("user:user"));
assertThat(message, containsString("password:pw"));
assertThat(message).endsWith("foo\n");
assertThat(message).contains("foo@bar");
assertThat(message).contains("bar@baz");
assertThat(message).contains("user:user");
assertThat(message).contains("password:pw");
}

62
spring-integration-mail/src/test/java/org/springframework/integration/mail/dsl/MailTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2014-2018 the original author or authors.
* Copyright 2014-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,14 +16,7 @@
package org.springframework.integration.mail.dsl;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Properties;
@@ -95,7 +88,7 @@ public class MailTests {
|| !imapServer.isListening()) || !imapIdleServer.isListening()) {
Thread.sleep(100);
}
assertTrue(n < 100);
assertThat(n < 100).isTrue();
}
@AfterClass
@@ -127,11 +120,11 @@ public class MailTests {
@Test
public void testSmtp() throws Exception {
assertEquals("localhost", TestUtils.getPropertyValue(this.sendMailHandler, "mailSender.host"));
assertThat(TestUtils.getPropertyValue(this.sendMailHandler, "mailSender.host")).isEqualTo("localhost");
Properties javaMailProperties = TestUtils.getPropertyValue(this.sendMailHandler,
"mailSender.javaMailProperties", Properties.class);
assertEquals("false", javaMailProperties.getProperty("mail.debug"));
assertThat(javaMailProperties.getProperty("mail.debug")).isEqualTo("false");
this.sendMailChannel.send(MessageBuilder.withPayload("foo").build());
@@ -140,49 +133,50 @@ public class MailTests {
Thread.sleep(100);
}
assertTrue(smtpServer.getMessages().size() > 0);
assertThat(smtpServer.getMessages().size() > 0).isTrue();
String message = smtpServer.getMessages().get(0);
assertThat(message, endsWith("foo\n"));
assertThat(message, containsString("foo@bar"));
assertThat(message, containsString("bar@baz"));
assertThat(message, containsString("user:user"));
assertThat(message, containsString("password:pw"));
assertThat(message).endsWith("foo\n");
assertThat(message).contains("foo@bar");
assertThat(message).contains("bar@baz");
assertThat(message).contains("user:user");
assertThat(message).contains("password:pw");
}
@Test
public void testPop3() throws Exception {
Message<?> message = this.pop3Channel.receive(10000);
assertNotNull(message);
assertThat(message).isNotNull();
MessageHeaders headers = message.getHeaders();
assertEquals("Foo <foo@bar>", headers.get(MailHeaders.TO, String[].class)[0]);
assertEquals("Bar <bar@baz>", headers.get(MailHeaders.FROM));
assertEquals("Test Email", headers.get(MailHeaders.SUBJECT));
assertEquals("foo\r\n\r\n", message.getPayload());
assertThat(headers.get(MailHeaders.TO, String[].class)[0]).isEqualTo("Foo <foo@bar>");
assertThat(headers.get(MailHeaders.FROM)).isEqualTo("Bar <bar@baz>");
assertThat(headers.get(MailHeaders.SUBJECT)).isEqualTo("Test Email");
assertThat(message.getPayload()).isEqualTo("foo\r\n\r\n");
}
@Test
public void testImap() throws Exception {
Message<?> message = this.imapChannel.receive(10000);
assertNotNull(message);
assertThat(message).isNotNull();
MimeMessage mm = (MimeMessage) message.getPayload();
assertEquals("Foo <foo@bar>", mm.getRecipients(RecipientType.TO)[0].toString());
assertEquals("Bar <bar@baz>", mm.getFrom()[0].toString());
assertEquals("Test Email", mm.getSubject());
assertThat(mm.getContent(), equalTo(TestMailServer.MailServer.MailHandler.BODY + "\r\n"));
assertThat(mm.getRecipients(RecipientType.TO)[0].toString()).isEqualTo("Foo <foo@bar>");
assertThat(mm.getFrom()[0].toString()).isEqualTo("Bar <bar@baz>");
assertThat(mm.getSubject()).isEqualTo("Test Email");
assertThat(mm.getContent()).isEqualTo(TestMailServer.MailServer.MailHandler.BODY + "\r\n");
}
@Test
public void testImapIdle() {
Message<?> message = this.imapIdleChannel.receive(10000);
assertNotNull(message);
assertThat(message).isNotNull();
MessageHeaders headers = message.getHeaders();
assertEquals("Foo <foo@bar>", headers.get(MailHeaders.TO, String[].class)[0]);
assertEquals("Bar <bar@baz>", headers.get(MailHeaders.FROM));
assertEquals("Test Email", headers.get(MailHeaders.SUBJECT));
assertThat(message.getPayload(), equalTo(TestMailServer.MailServer.MailHandler.MESSAGE + "\r\n"));
assertThat(headers.get(MailHeaders.TO, String[].class)[0]).isEqualTo("Foo <foo@bar>");
assertThat(headers.get(MailHeaders.FROM)).isEqualTo("Bar <bar@baz>");
assertThat(headers.get(MailHeaders.SUBJECT)).isEqualTo("Test Email");
assertThat(message.getPayload()).isEqualTo(TestMailServer.MailServer.MailHandler.MESSAGE + "\r\n");
this.imapIdleAdapter.stop();
assertFalse(TestUtils.getPropertyValue(this.imapIdleAdapter, "shouldReconnectAutomatically", Boolean.class));
assertThat(TestUtils.getPropertyValue(this.imapIdleAdapter, "shouldReconnectAutomatically", Boolean.class))
.isFalse();
}
@Configuration