Polish JavaMailSenderTests

spring-context-support/src/main/java/org/springframework/mail/javamail/JavaMailSenderImpl.java

@@ -200,7 +200,7 @@ public class JavaMailSenderImpl implements JavaMailSender {
 	 * Set the mail server port.
 	 * <p>Default is {@link #DEFAULT_PORT}, letting JavaMail use the default
 	 * SMTP port (25).
-	*/
+	 */
 	public void setPort(int port) {
 		this.port = port;
 	}

spring-context-support/src/test/java/org/springframework/mail/javamail/JavaMailSenderTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2022 the original author or authors.
+ * Copyright 2002-2023 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,18 @@
 
 package org.springframework.mail.javamail;
 
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.GregorianCalendar;
 import java.util.List;
 import java.util.Properties;
+import java.util.stream.Stream;
 
 import jakarta.activation.FileTypeMap;
 import jakarta.mail.Address;
 import jakarta.mail.Message;
+import jakarta.mail.Message.RecipientType;
 import jakarta.mail.MessagingException;
 import jakarta.mail.NoSuchProviderException;
 import jakarta.mail.Session;
@@ -44,18 +45,22 @@ import org.springframework.util.ObjectUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.entry;
 
 /**
  * @author Juergen Hoeller
  * @author Stephane Nicoll
+ * @author Sam Brannen
  * @since 09.10.2004
  */
-public class JavaMailSenderTests {
+class JavaMailSenderTests {
+
+	private final MockJavaMailSender sender = new MockJavaMailSender();
+
 
 	@Test
-	public void javaMailSenderWithSimpleMessage() throws MessagingException, IOException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithSimpleMessage() throws Exception {
 		sender.setHost("host");
 		sender.setPort(30);
 		sender.setUsername("username");
@@ -81,30 +86,19 @@ public class JavaMailSenderTests {
 
 		assertThat(sender.transport.getSentMessages()).hasSize(1);
 		MimeMessage sentMessage = sender.transport.getSentMessage(0);
-		List<Address> froms = Arrays.asList(sentMessage.getFrom());
-		assertThat(froms).hasSize(1);
-		assertThat(((InternetAddress) froms.get(0)).getAddress()).isEqualTo("me@mail.org");
-		List<Address> replyTos = Arrays.asList(sentMessage.getReplyTo());
-		assertThat(((InternetAddress) replyTos.get(0)).getAddress()).isEqualTo("reply@mail.org");
-		List<Address> tos = Arrays.asList(sentMessage.getRecipients(Message.RecipientType.TO));
-		assertThat(tos).hasSize(1);
-		assertThat(((InternetAddress) tos.get(0)).getAddress()).isEqualTo("you@mail.org");
-		List<Address> ccs = Arrays.asList(sentMessage.getRecipients(Message.RecipientType.CC));
-		assertThat(ccs).hasSize(2);
-		assertThat(((InternetAddress) ccs.get(0)).getAddress()).isEqualTo("he@mail.org");
-		assertThat(((InternetAddress) ccs.get(1)).getAddress()).isEqualTo("she@mail.org");
-		List<Address> bccs = Arrays.asList(sentMessage.getRecipients(Message.RecipientType.BCC));
-		assertThat(bccs).hasSize(2);
-		assertThat(((InternetAddress) bccs.get(0)).getAddress()).isEqualTo("us@mail.org");
-		assertThat(((InternetAddress) bccs.get(1)).getAddress()).isEqualTo("them@mail.org");
+		assertThat(addresses(sentMessage.getFrom())).containsExactly("me@mail.org");
+		assertThat(addresses(sentMessage.getReplyTo())).containsExactly("reply@mail.org");
+		assertThat(addresses(sentMessage.getRecipients(RecipientType.TO))).containsExactly("you@mail.org");
+		assertThat(addresses(sentMessage.getRecipients(RecipientType.CC))).containsExactly("he@mail.org", "she@mail.org");
+		assertThat(addresses(sentMessage.getRecipients(RecipientType.BCC))).containsExactly("us@mail.org", "them@mail.org");
+
 		assertThat(sentMessage.getSentDate().getTime()).isEqualTo(sentDate.getTime());
 		assertThat(sentMessage.getSubject()).isEqualTo("my subject");
 		assertThat(sentMessage.getContent()).isEqualTo("my text");
 	}
 
 	@Test
-	public void javaMailSenderWithSimpleMessages() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithSimpleMessages() throws Exception {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
@@ -122,59 +116,49 @@ public class JavaMailSenderTests {
 
 		assertThat(sender.transport.getSentMessages()).hasSize(2);
 		MimeMessage sentMessage1 = sender.transport.getSentMessage(0);
-		List<Address> tos1 = Arrays.asList(sentMessage1.getRecipients(Message.RecipientType.TO));
-		assertThat(tos1).hasSize(1);
-		assertThat(((InternetAddress) tos1.get(0)).getAddress()).isEqualTo("he@mail.org");
 		MimeMessage sentMessage2 = sender.transport.getSentMessage(1);
-		List<Address> tos2 = Arrays.asList(sentMessage2.getRecipients(Message.RecipientType.TO));
-		assertThat(tos2).hasSize(1);
-		assertThat(((InternetAddress) tos2.get(0)).getAddress()).isEqualTo("she@mail.org");
+		assertThat(addresses(sentMessage1.getRecipients(RecipientType.TO))).containsExactly("he@mail.org");
+		assertThat(addresses(sentMessage2.getRecipients(RecipientType.TO))).containsExactly("she@mail.org");
 	}
 
 	@Test
-	public void javaMailSenderWithMimeMessage() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithMimeMessage() throws Exception {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
 
 		MimeMessage mimeMessage = sender.createMimeMessage();
-		mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress("you@mail.org"));
+		mimeMessage.setRecipient(RecipientType.TO, new InternetAddress("you@mail.org"));
 		sender.send(mimeMessage);
 
 		assertThat(sender.transport.getConnectedHost()).isEqualTo("host");
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages()).hasSize(1);
-		assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage);
+		assertThat(sender.transport.getSentMessages()).containsExactly(mimeMessage);
 	}
 
 	@Test
-	public void javaMailSenderWithMimeMessages() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithMimeMessages() throws Exception {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
 
 		MimeMessage mimeMessage1 = sender.createMimeMessage();
-		mimeMessage1.setRecipient(Message.RecipientType.TO, new InternetAddress("he@mail.org"));
+		mimeMessage1.setRecipient(RecipientType.TO, new InternetAddress("he@mail.org"));
 		MimeMessage mimeMessage2 = sender.createMimeMessage();
-		mimeMessage2.setRecipient(Message.RecipientType.TO, new InternetAddress("she@mail.org"));
+		mimeMessage2.setRecipient(RecipientType.TO, new InternetAddress("she@mail.org"));
 		sender.send(mimeMessage1, mimeMessage2);
 
 		assertThat(sender.transport.getConnectedHost()).isEqualTo("host");
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages()).hasSize(2);
-		assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage1);
-		assertThat(sender.transport.getSentMessage(1)).isEqualTo(mimeMessage2);
+		assertThat(sender.transport.getSentMessages()).containsExactly(mimeMessage1, mimeMessage2);
 	}
 
 	@Test
-	public void javaMailSenderWithMimeMessagePreparator() {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithMimeMessagePreparator() {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
@@ -182,7 +166,7 @@ public class JavaMailSenderTests {
 		final List<Message> messages = new ArrayList<>();
 
 		MimeMessagePreparator preparator = mimeMessage -> {
-			mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress("you@mail.org"));
+			mimeMessage.setRecipient(RecipientType.TO, new InternetAddress("you@mail.org"));
 			messages.add(mimeMessage);
 		};
 		sender.send(preparator);
@@ -191,13 +175,11 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages()).hasSize(1);
-		assertThat(sender.transport.getSentMessage(0)).isEqualTo(messages.get(0));
+		assertThat(sender.transport.getSentMessages()).containsExactly(messages.get(0));
 	}
 
 	@Test
-	public void javaMailSenderWithMimeMessagePreparators() {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithMimeMessagePreparators() {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
@@ -205,11 +187,11 @@ public class JavaMailSenderTests {
 		final List<Message> messages = new ArrayList<>();
 
 		MimeMessagePreparator preparator1 = mimeMessage -> {
-			mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress("he@mail.org"));
+			mimeMessage.setRecipient(RecipientType.TO, new InternetAddress("he@mail.org"));
 			messages.add(mimeMessage);
 		};
 		MimeMessagePreparator preparator2 = mimeMessage -> {
-			mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress("she@mail.org"));
+			mimeMessage.setRecipient(RecipientType.TO, new InternetAddress("she@mail.org"));
 			messages.add(mimeMessage);
 		};
 		sender.send(preparator1, preparator2);
@@ -218,22 +200,19 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages()).hasSize(2);
-		assertThat(sender.transport.getSentMessage(0)).isEqualTo(messages.get(0));
-		assertThat(sender.transport.getSentMessage(1)).isEqualTo(messages.get(1));
+		assertThat(messages).hasSize(2);
+		assertThat(sender.transport.getSentMessages()).containsExactlyElementsOf(messages);
 	}
 
 	@Test
-	public void javaMailSenderWithMimeMessageHelper() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithMimeMessageHelper() throws Exception {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
 
 		MimeMessageHelper message = new MimeMessageHelper(sender.createMimeMessage());
 		assertThat(message.getEncoding()).isNull();
-		boolean condition = message.getFileTypeMap() instanceof ConfigurableMimeFileTypeMap;
-		assertThat(condition).isTrue();
+		assertThat(message.getFileTypeMap()).isInstanceOf(ConfigurableMimeFileTypeMap.class);
 
 		message.setTo("you@mail.org");
 		sender.send(message.getMimeMessage());
@@ -242,13 +221,11 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages()).hasSize(1);
-		assertThat(sender.transport.getSentMessage(0)).isEqualTo(message.getMimeMessage());
+		assertThat(sender.transport.getSentMessages()).containsExactly(message.getMimeMessage());
 	}
 
 	@Test
-	public void javaMailSenderWithMimeMessageHelperAndSpecificEncoding() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithMimeMessageHelperAndSpecificEncoding() throws Exception {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
@@ -266,13 +243,11 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages()).hasSize(1);
-		assertThat(sender.transport.getSentMessage(0)).isEqualTo(message.getMimeMessage());
+		assertThat(sender.transport.getSentMessages()).containsExactly(message.getMimeMessage());
 	}
 
 	@Test
-	public void javaMailSenderWithMimeMessageHelperAndDefaultEncoding() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithMimeMessageHelperAndDefaultEncoding() throws Exception {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
@@ -291,41 +266,29 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages()).hasSize(1);
-		assertThat(sender.transport.getSentMessage(0)).isEqualTo(message.getMimeMessage());
+		assertThat(sender.transport.getSentMessages()).containsExactly(message.getMimeMessage());
 	}
 
 	@Test
-	public void javaMailSenderWithParseExceptionOnSimpleMessage() {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithParseExceptionOnSimpleMessage() {
 		SimpleMailMessage simpleMessage = new SimpleMailMessage();
 		simpleMessage.setFrom("");
-		try {
-			sender.send(simpleMessage);
-		}
-		catch (MailParseException ex) {
-			// expected
-			boolean condition = ex.getCause() instanceof AddressException;
-			assertThat(condition).isTrue();
-		}
+
+		assertThatExceptionOfType(MailParseException.class)
+			.isThrownBy(() -> sender.send(simpleMessage))
+			.withCauseInstanceOf(AddressException.class);
 	}
 
 	@Test
-	public void javaMailSenderWithParseExceptionOnMimeMessagePreparator() {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void javaMailSenderWithParseExceptionOnMimeMessagePreparator() {
 		MimeMessagePreparator preparator = mimeMessage -> mimeMessage.setFrom(new InternetAddress(""));
-		try {
-			sender.send(preparator);
-		}
-		catch (MailParseException ex) {
-			// expected
-			boolean condition = ex.getCause() instanceof AddressException;
-			assertThat(condition).isTrue();
-		}
+		assertThatExceptionOfType(MailParseException.class)
+			.isThrownBy(() -> sender.send(preparator))
+			.withCauseInstanceOf(AddressException.class);
 	}
 
 	@Test
-	public void javaMailSenderWithCustomSession() throws MessagingException {
+	void javaMailSenderWithCustomSession() throws Exception {
 		final Session session = Session.getInstance(new Properties());
 		MockJavaMailSender sender = new MockJavaMailSender() {
 			@Override
@@ -341,7 +304,7 @@ public class JavaMailSenderTests {
 
 		MimeMessage mimeMessage = sender.createMimeMessage();
 		mimeMessage.setSubject("custom");
-		mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress("you@mail.org"));
+		mimeMessage.setRecipient(RecipientType.TO, new InternetAddress("you@mail.org"));
 		mimeMessage.setSentDate(new GregorianCalendar(2005, 3, 1).getTime());
 		sender.send(mimeMessage);
 
@@ -349,12 +312,11 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages()).hasSize(1);
-		assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage);
+		assertThat(sender.transport.getSentMessages()).containsExactly(mimeMessage);
 	}
 
 	@Test
-	public void javaMailProperties() throws MessagingException {
+	void javaMailProperties() throws Exception {
 		Properties props = new Properties();
 		props.setProperty("bogusKey", "bogusValue");
 		MockJavaMailSender sender = new MockJavaMailSender() {
@@ -370,44 +332,40 @@ public class JavaMailSenderTests {
 		sender.setPassword("password");
 
 		MimeMessage mimeMessage = sender.createMimeMessage();
-		mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress("you@mail.org"));
+		mimeMessage.setRecipient(RecipientType.TO, new InternetAddress("you@mail.org"));
 		sender.send(mimeMessage);
 
 		assertThat(sender.transport.getConnectedHost()).isEqualTo("host");
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages()).hasSize(1);
-		assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage);
+		assertThat(sender.transport.getSentMessages()).containsExactly(mimeMessage);
 	}
 
 	@Test
-	public void failedMailServerConnect() {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void failedMailServerConnect() {
 		sender.setHost(null);
 		sender.setUsername("username");
 		sender.setPassword("password");
 		SimpleMailMessage simpleMessage1 = new SimpleMailMessage();
-		assertThatExceptionOfType(MailSendException.class).isThrownBy(() ->
-				sender.send(simpleMessage1))
-			.satisfies(ex ->  assertThat(ex.getFailedMessages()).containsExactly(entry(simpleMessage1, (Exception) ex.getCause())));
+		assertThatExceptionOfType(MailSendException.class)
+			.isThrownBy(() -> sender.send(simpleMessage1))
+			.satisfies(ex -> assertThat(ex.getFailedMessages()).containsExactly(entry(simpleMessage1, (Exception) ex.getCause())));
 	}
 
 	@Test
-	public void failedMailServerClose() {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void failedMailServerClose() {
 		sender.setHost("");
 		sender.setUsername("username");
 		sender.setPassword("password");
 		SimpleMailMessage simpleMessage1 = new SimpleMailMessage();
-		assertThatExceptionOfType(MailSendException.class).isThrownBy(() ->
-				sender.send(simpleMessage1))
+		assertThatExceptionOfType(MailSendException.class)
+			.isThrownBy(() -> sender.send(simpleMessage1))
 			.satisfies(ex -> assertThat(ex.getFailedMessages()).isEmpty());
 	}
 
 	@Test
-	public void failedSimpleMessage() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void failedSimpleMessage() throws Exception {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
@@ -422,68 +380,60 @@ public class JavaMailSenderTests {
 			sender.send(simpleMessage1, simpleMessage2);
 		}
 		catch (MailSendException ex) {
-			ex.printStackTrace();
 			assertThat(sender.transport.getConnectedHost()).isEqualTo("host");
 			assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 			assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 			assertThat(sender.transport.isCloseCalled()).isTrue();
 			assertThat(sender.transport.getSentMessages()).hasSize(1);
 			assertThat(sender.transport.getSentMessage(0).getAllRecipients()[0]).isEqualTo(new InternetAddress("she@mail.org"));
-			assertThat(ex.getFailedMessages()).hasSize(1);
-			assertThat(ex.getFailedMessages().keySet().iterator().next()).isEqualTo(simpleMessage1);
-			Object subEx = ex.getFailedMessages().values().iterator().next();
-			boolean condition = subEx instanceof MessagingException;
-			assertThat(condition).isTrue();
-			assertThat(((MessagingException) subEx).getMessage()).isEqualTo("failed");
+			assertThat(ex.getFailedMessages().keySet()).containsExactly(simpleMessage1);
+			Exception subEx = ex.getFailedMessages().values().iterator().next();
+			assertThat(subEx).isInstanceOf(MessagingException.class).hasMessage("failed");
 		}
 	}
 
 	@Test
-	public void failedMimeMessage() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void failedMimeMessage() throws Exception {
 		sender.setHost("host");
 		sender.setUsername("username");
 		sender.setPassword("password");
 
 		MimeMessage mimeMessage1 = sender.createMimeMessage();
-		mimeMessage1.setRecipient(Message.RecipientType.TO, new InternetAddress("he@mail.org"));
+		mimeMessage1.setRecipient(RecipientType.TO, new InternetAddress("he@mail.org"));
 		mimeMessage1.setSubject("fail");
 		MimeMessage mimeMessage2 = sender.createMimeMessage();
-		mimeMessage2.setRecipient(Message.RecipientType.TO, new InternetAddress("she@mail.org"));
+		mimeMessage2.setRecipient(RecipientType.TO, new InternetAddress("she@mail.org"));
 
 		try {
 			sender.send(mimeMessage1, mimeMessage2);
 		}
 		catch (MailSendException ex) {
-			ex.printStackTrace();
 			assertThat(sender.transport.getConnectedHost()).isEqualTo("host");
 			assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 			assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 			assertThat(sender.transport.isCloseCalled()).isTrue();
-			assertThat(sender.transport.getSentMessages()).hasSize(1);
-			assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage2);
-			assertThat(ex.getFailedMessages()).hasSize(1);
-			assertThat(ex.getFailedMessages().keySet().iterator().next()).isEqualTo(mimeMessage1);
-			Object subEx = ex.getFailedMessages().values().iterator().next();
-			boolean condition = subEx instanceof MessagingException;
-			assertThat(condition).isTrue();
-			assertThat(((MessagingException) subEx).getMessage()).isEqualTo("failed");
+			assertThat(sender.transport.getSentMessages()).containsExactly(mimeMessage2);
+			assertThat(ex.getFailedMessages().keySet()).containsExactly(mimeMessage1);
+			Exception subEx = ex.getFailedMessages().values().iterator().next();
+			assertThat(subEx).isInstanceOf(MessagingException.class).hasMessage("failed");
 		}
 	}
 
 	@Test
-	public void testConnection() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void testConnection() {
 		sender.setHost("host");
-		sender.testConnection();
+		assertThatNoException().isThrownBy(sender::testConnection);
 	}
 
 	@Test
-	public void testConnectionWithFailure() throws MessagingException {
-		MockJavaMailSender sender = new MockJavaMailSender();
+	void testConnectionWithFailure() {
 		sender.setHost(null);
-		assertThatExceptionOfType(MessagingException.class).isThrownBy(
-				sender::testConnection);
+		assertThatExceptionOfType(MessagingException.class).isThrownBy(sender::testConnection);
+	}
+
+
+	private static Stream<String> addresses(Address[] addresses) {
+		return Arrays.stream(addresses).map(InternetAddress.class::cast).map(InternetAddress::getAddress);
 	}