Wiser的Junit测试用法

 package org.jbpm.process.workitem.email;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Random;
 import javax.mail.AuthenticationFailedException;
 import javax.mail.BodyPart;
 import javax.mail.Message.RecipientType;
 import javax.mail.Multipart;
 import javax.mail.Part;
 import javax.mail.internet.InternetAddress;
 import javax.mail.internet.MimeMessage;
 import org.drools.core.process.instance.impl.DefaultWorkItemManager;
 import org.drools.core.process.instance.impl.WorkItemImpl;
 import org.jbpm.test.util.AbstractBaseTest;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.kie.api.runtime.process.WorkItemManager;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.subethamail.smtp.AuthenticationHandler;
 import org.subethamail.smtp.AuthenticationHandlerFactory;
 import org.subethamail.smtp.auth.LoginAuthenticationHandlerFactory;
 import org.subethamail.smtp.auth.LoginFailedException;
 import org.subethamail.smtp.auth.MultipleAuthenticationHandlerFactory;
 import org.subethamail.smtp.auth.PlainAuthenticationHandlerFactory;
 import org.subethamail.smtp.auth.UsernamePasswordValidator;
 import org.subethamail.wiser.Wiser;
 import org.subethamail.wiser.WiserMessage;

 public class SendHtmlTest extends AbstractBaseTest {
     private static final Logger logger = LoggerFactory
             .getLogger(SendHtmlTest.class);
     private Wiser wiser;
     private String emailHost;
     private String emailPort;
     private static String authUsername = "cpark";
     private static String authPassword = "yourbehindwhat?";
     private Random random = new Random();
     private int uniqueTestNum = -1;

     @Before
     public void setUp() throws Exception {
         uniqueTestNum = random.nextInt(Integer.MAX_VALUE);
         emailHost = "localhost";
         int emailPortInt;
         do {
             emailPortInt = random.nextInt((2 * Short.MAX_VALUE - 1));
         } while (emailPortInt < 4096);
         emailPort = Integer.toString(emailPortInt);
         wiser = new Wiser(Integer.parseInt(emailPort));
         wiser.start();
     }

     @After
     public void tearDown() throws Exception {
         if (wiser != null) {
             wiser.getMessages().clear();
             wiser.stop();
             wiser = null;
         }
     }

     @SuppressWarnings("unused")
     private class ExtendedConnection extends Connection {
         private String extraField;
     }

     @Test
     public void testConnectionEquals() {
         Connection connA = new Connection();
         Connection connB = new Connection();
         // null test
         assertTrue(!connA.equals(null));
         // different class test
         assertTrue(!connA.equals("og"));
         // extended class test
         ExtendedConnection connExt = new ExtendedConnection();
         assertTrue(!connA.equals(connExt));
         // null fields test
         assertTrue(connA.equals(connB));
         // all null vs filled field test
         connA.setHost("Human");
         connA.setPort("Skin");
         connA.setUserName("Viral");
         connA.setPassword("Protein Gate");
         assertTrue(!connA.equals(connB));
         // filled field test
         connB.setHost(connA.getHost());
         connB.setPort(new String(connA.getPort()));
         connB.setUserName(connA.getUserName());
         connB.setPassword(connA.getPassword());
         assertTrue(connA.equals(connB));
         // some null vs filled field test
         connA.setPassword(null);
         connB.setPassword(null);
         assertTrue(connA.equals(connB));
         // boolean
         connA.setStartTls(true);
         assertTrue(!connA.equals(connB));
         connB.setStartTls(true);
         assertTrue(connA.equals(connB));
         connB.setStartTls(false);
         assertTrue(!connA.equals(connB));
     }

     @Test
     public void verifyWiserServerWorks() throws Exception {
         // Input
         String testMethodName = Thread.currentThread().getStackTrace()[1]
                 .getMethodName();
         String toAddress = "boyd@crowdergang.org";
         String fromAddress = "rgivens@kty.us.gov";
         // Setup email
         WorkItemImpl workItem = createEmailWorkItem(toAddress, fromAddress,
                 testMethodName);
         Connection connection = new Connection(emailHost, emailPort);
         sendAndCheckThatMessagesAreSent(workItem, connection);
     }

     @Test
     public void sendHtmlWithAuthentication() throws Exception {
         // Add authentication to Wiser SMTP server
         wiser.getServer().setAuthenticationHandlerFactory(
                 new TestAuthHandlerFactory());
         // Input
         String testMethodName = Thread.currentThread().getStackTrace()[1]
                 .getMethodName();
         String toAddress = "rgivens@kty.us.gov";
         String fromAddress = "whawkins@kty.us.gov";
         // Setup email
         WorkItemImpl workItem = createEmailWorkItem(toAddress, fromAddress,
                 testMethodName);
         Connection connection = new Connection(emailHost, emailPort,
                 authUsername, authPassword);
         sendAndCheckThatMessagesAreSent(workItem, connection);
     }

     @Test
     public void sendHtmlWithAuthenticationAndAttachments() throws Exception {
         // Add authentication to Wiser SMTP server
         wiser.getServer().setAuthenticationHandlerFactory(
                 new TestAuthHandlerFactory());
         // Input
         String testMethodName = Thread.currentThread().getStackTrace()[1]
                 .getMethodName();
         String toAddress = "rgivens@kty.us.gov";
         String fromAddress = "whawkins@kty.us.gov";
         // Setup email
         WorkItemImpl workItem = createEmailWorkItemWithAttachment(toAddress,
                 fromAddress, testMethodName);
         Connection connection = new Connection(emailHost, emailPort,
                 authUsername, authPassword);
         // send email
         Email email = EmailWorkItemHandler.createEmail(workItem, connection);
         SendHtml.sendHtml(email, connection);
         List<WiserMessage> messages = wiser.getMessages();
         assertEquals(1, messages.size());
         MimeMessage message = messages.get(0).getMimeMessage();
         assertEquals(workItem.getParameter("Subject"), message.getSubject());
         assertTrue(Arrays.equals(
                 InternetAddress.parse((String) workItem.getParameter("To")),
                 message.getRecipients(RecipientType.TO)));
         assertTrue(message.getContent() instanceof Multipart);
         Multipart multipart = (Multipart) message.getContent();
         assertEquals(2, multipart.getCount());
         for (int i = 0; i < multipart.getCount(); i++) {
             BodyPart bodyPart = multipart.getBodyPart(i);
             if (!Part.ATTACHMENT.equalsIgnoreCase(bodyPart.getDisposition())) {
                 continue;
                 // dealing with attachments only
             }
             assertEquals("email.gif", bodyPart.getFileName());
         }
     }

     @Test
     public void sendHtmlWithBadAuthentication() throws Exception {
         // Add authentication to Wiser SMTP server
         wiser.getServer().setAuthenticationHandlerFactory(
                 new TestAuthHandlerFactory());
         // Input
         String testMethodName = Thread.currentThread().getStackTrace()[1]
                 .getMethodName();
         String toAddress = "mags@bennetstore.com";
         String fromAddress = "rgivens@kty.us.gov";
         checkBadAuthentication(toAddress, fromAddress, testMethodName,
                 authUsername, "bad password");
         checkBadAuthentication(toAddress, fromAddress, testMethodName,
                 "badUserName", authPassword);
     }

     @Test
     public void useEmailWorkItemHandlerWithAuthentication() throws Exception {
         // Add authentication to Wiser SMTP server
         wiser.getServer().setAuthenticationHandlerFactory(
                 new TestAuthHandlerFactory());
         // Input
         String testMethodName = Thread.currentThread().getStackTrace()[1]
                 .getMethodName();
         String toAddress = "rgivens@yahoo.com";
         String fromAddress = "rgivens@kty.us.gov";
         EmailWorkItemHandler handler = new EmailWorkItemHandler();
         handler.setConnection(emailHost, emailPort, authUsername, authPassword);
         WorkItemImpl workItem = new WorkItemImpl();
         workItem.setParameter("To", toAddress);
         workItem.setParameter("From", fromAddress);
         workItem.setParameter("Reply-To", fromAddress);
         workItem.setParameter("Subject", "Test mail for " + testMethodName);
         workItem.setParameter("Body",
                 "Don't forget to check on Boyd later today.");
         WorkItemManager manager = new DefaultWorkItemManager(null);
         handler.executeWorkItem(workItem, manager);
         List<WiserMessage> messages = wiser.getMessages();
         assertEquals(1, messages.size());
         for (WiserMessage wiserMessage : messages) {
             MimeMessage message = wiserMessage.getMimeMessage();
             assertEquals(workItem.getParameter("Subject"), message.getSubject());
             assertTrue(Arrays.equals(InternetAddress.parse(toAddress),
                     message.getRecipients(RecipientType.TO)));
         }
     }

     /** * Helper methods */
     private void sendAndCheckThatMessagesAreSent(WorkItemImpl workItem,
             Connection connection) throws Exception {
         // send email
         Email email = EmailWorkItemHandler.createEmail(workItem, connection);
         SendHtml.sendHtml(email, connection);
         List<WiserMessage> messages = wiser.getMessages();
         assertEquals(1, messages.size());
         for (WiserMessage wiserMessage : messages) {
             MimeMessage message = wiserMessage.getMimeMessage();
             assertEquals(workItem.getParameter("Subject"), message.getSubject());
             assertTrue(Arrays
                     .equals(InternetAddress.parse((String) workItem
                             .getParameter("To")), message
                             .getRecipients(RecipientType.TO)));
         }
     }

     private void checkBadAuthentication(String toAddress, String fromAddress,
             String testMethodName, String username, String password) {
         // Setup email
         WorkItemImpl workItem = createEmailWorkItem(toAddress, fromAddress,
                 testMethodName);
         Connection connection = new Connection(emailHost, emailPort, username,
                 password);
         // send email
         Email email = EmailWorkItemHandler.createEmail(workItem, connection);
         try {
             SendHtml.sendHtml(email, connection);
         } catch (Throwable t) {
             assertTrue("Unexpected exception of type "
                     + t.getClass().getSimpleName() + ", not "
                     + t.getClass().getSimpleName(),
                     (t instanceof RuntimeException));
             assertNotNull("Expected RuntimeException to have a cause.",
                     t.getCause());
             Throwable cause = t.getCause();
             assertNotNull("Expected cause to have a cause.", cause.getCause());
             cause = cause.getCause();
             assertTrue("Unexpected exception of type "
                     + cause.getClass().getSimpleName() + ", not "
                     + cause.getClass().getSimpleName(),
                     (cause instanceof AuthenticationFailedException));
         }
     }

     private WorkItemImpl createEmailWorkItem(String toAddress,
             String fromAddress, String testMethodName) {
         WorkItemImpl workItem = new WorkItemImpl();
         workItem.setParameter("To", toAddress);
         workItem.setParameter("From", fromAddress);
         workItem.setParameter("Reply-To", fromAddress);
         String subject = this.getClass().getSimpleName() + " test message ["
                 + uniqueTestNum + "]";
         String body = "\nThis is the test message generated by the "
                 + testMethodName + " test (" + uniqueTestNum + ").\n";
         workItem.setParameter("Subject", subject);
         workItem.setParameter("Body", body);
         return workItem;
     }

     private WorkItemImpl createEmailWorkItemWithAttachment(String toAddress,
             String fromAddress, String testMethodName) {
         WorkItemImpl workItem = new WorkItemImpl();
         workItem.setParameter("To", toAddress);
         workItem.setParameter("From", fromAddress);
         workItem.setParameter("Reply-To", fromAddress);
         String subject = this.getClass().getSimpleName() + " test message ["
                 + uniqueTestNum + "]";
         String body = "\nThis is the test message generated by the "
                 + testMethodName + " test (" + uniqueTestNum + ").\n";
         workItem.setParameter("Subject", subject);
         workItem.setParameter("Body", body);
         workItem.setParameter("Attachments", "classpath:/icons/email.gif");
         return workItem;
     }

     private static class TestAuthHandlerFactory implements
             AuthenticationHandlerFactory {
         MultipleAuthenticationHandlerFactory authHandleFactory = new MultipleAuthenticationHandlerFactory();

         public TestAuthHandlerFactory() {
             UsernamePasswordValidator validator = new UsernamePasswordValidator() {
                 public void login(String username, String password)
                         throws LoginFailedException {
                     if (!authUsername.equals(username)
                             || !authPassword.equals(password)) {
                         logger.debug(
                                 "Tried to login with user/password [{}/{}]",
                                 username, password);
                         throw new LoginFailedException(
                                 "Incorrect password for user " + authUsername);
                     }
                 }
             };
             authHandleFactory.addFactory(new LoginAuthenticationHandlerFactory(
                     validator));
             authHandleFactory.addFactory(new PlainAuthenticationHandlerFactory(
                     validator));
         }

         public AuthenticationHandler create() {
             return authHandleFactory.create();
         }

         public List<String> getAuthenticationMechanisms() {
             return authHandleFactory.getAuthenticationMechanisms();
         }
     }
 }

关于javamail的Junit测试，找了很久才找到如何测试验证SMTP服务器。