javax.mail.event.TransportEvent Java Examples

@Test
public void testDoNotCheckFormHeader() throws Exception {
    Properties properties = new Properties();
    properties.setProperty("mail.smtpjms.validateFrom", "false");
    SmtpJmsTransport transport = new SmtpJmsTransport(Session.getInstance(properties), new URLName("jms"));
    Message message = Mockito.mock(Message.class);
    TransportListener listener = Mockito.mock(TransportListener.class);
    Address[] to = new Address[]{ new InternetAddress("[email protected]") };
    transport.addTransportListener(listener);
    transport.sendMessage(message, to);
    waitForListeners();
    ArgumentCaptor<TransportEvent> transportEventArgumentCaptor = ArgumentCaptor.forClass(TransportEvent.class);
    verify(listener).messageDelivered(transportEventArgumentCaptor.capture());
    TransportEvent event = transportEventArgumentCaptor.getValue();
    assertEquals(message, event.getMessage());
    assertEquals(TransportEvent.MESSAGE_DELIVERED, event.getType());
    assertArrayEquals(to, event.getValidSentAddresses());
}
 

@Test
public void testListenerOnSuccess() throws Exception {
    Address[] to = new Address[] {new InternetAddress("[email protected]")};
    Message message = generateMessage();
    TransportListener transportListener = Mockito.mock(TransportListener.class);
    AbstractFileTransport transport = (AbstractFileTransport) session.getTransport("filemsg");
    transport.addTransportListener(transportListener);
    transport.sendMessage(message, to);
    waitForListeners();
    ArgumentCaptor<TransportEvent> transportEventArgumentCaptor = ArgumentCaptor.forClass(TransportEvent.class);
    verify(transportListener).messageDelivered(transportEventArgumentCaptor.capture());
    TransportEvent event = transportEventArgumentCaptor.getValue();
    assertEquals(message, event.getMessage());
    assertEquals(TransportEvent.MESSAGE_DELIVERED, event.getType());
    assertArrayEquals(to, event.getValidSentAddresses());
    verify(transportListener).messageDelivered(any(TransportEvent.class));
}
 

@Override
public void sendMessage(final Message msg, final Address[] addresses) throws MessagingException {
    for (final Address a : addresses) {
        final MockMailbox mailbox = MockMailbox.get(a);
        if (mailbox.getInbox().isSimulateError()) {

            notifyTransportListeners(TransportEvent.MESSAGE_NOT_DELIVERED, new Address[0], addresses, new Address[0], msg);

            throw new MessagingException("Simulated error sending message to " + a);

        }

        mailbox.getInbox().add(new MimeMessage((MimeMessage) msg));
        notifyTransportListeners(TransportEvent.MESSAGE_DELIVERED, addresses, new Address[0], new Address[0], msg);
    }
}
 

@Test
public void testFailOnJms() throws Exception {
    Message message = Mockito.mock(Message.class);
    Address[] to = new Address[] { new InternetAddress("[email protected]") };
    when(message.getFrom()).thenReturn(new Address[] { new InternetAddress("[email protected]") });
    doThrow(new JMSException("mock")).when(queueSender).send(any(javax.jms.Message.class));
    try {
        transport.sendMessage(message, to);
        fail();
    } catch (MessagingException ex) {
        waitForListeners();
        ArgumentCaptor<TransportEvent> transportEventArgumentCaptor = ArgumentCaptor.forClass(TransportEvent.class);
        verify(transportListener).messageNotDelivered(transportEventArgumentCaptor.capture());
        TransportEvent event = transportEventArgumentCaptor.getValue();
        assertEquals(message, event.getMessage());
        assertEquals(TransportEvent.MESSAGE_NOT_DELIVERED, event.getType());
        assertArrayEquals(new Address[0], event.getValidSentAddresses());
        assertArrayEquals(to, event.getValidUnsentAddresses());
    }
}
 

@Test
public void testSendWithoutFrom() throws Exception {
    Message message = Mockito.mock(Message.class);
    Address[] sendTo = new Address[] { new InternetAddress("[email protected]") };
    try {
        transport.sendMessage(message, sendTo);
        fail();
    } catch (MessagingException ex) {
        waitForListeners();
        ArgumentCaptor<TransportEvent> transportEventArgumentCaptor = ArgumentCaptor.forClass(TransportEvent.class);
        verify(transportListener, times(1)).messageNotDelivered(transportEventArgumentCaptor.capture());
        TransportEvent event = transportEventArgumentCaptor.getValue();
        assertEquals(message, event.getMessage());
        assertEquals(TransportEvent.MESSAGE_NOT_DELIVERED, event.getType());
        assertArrayEquals(new Address[0], event.getInvalidAddresses());
        assertArrayEquals(new Address[0], event.getValidSentAddresses());
        assertArrayEquals(sendTo, event.getValidUnsentAddresses());
    }
}
 

@Test
public void testListenerOnError() throws Exception {
    TransportListener transportListener = Mockito.mock(TransportListener.class);
    AbstractFileTransport transport = (AbstractFileTransport) session.getTransport("filemsg");
    transport.addTransportListener(transportListener);
    MimeMessage message = Mockito.mock(MimeMessage.class);
    when(message.getFrom()).thenReturn(new Address[]{new InternetAddress("[email protected]")});
    doThrow(new IOException()).when(message).writeTo(any(OutputStream.class));
    try {
        transport.sendMessage(message, new Address[]{new InternetAddress("[email protected]")});
        Assert.fail("Exception expected");
    } catch (MessagingException ex) {
        waitForListeners();
        verify(transportListener, times(1)).messageNotDelivered(any(TransportEvent.class));
    }
}
 

@Test(expected = MessagingException.class)
public void testErrorWritingMessage() throws Exception {
    Message message = Mockito.mock(Message.class);
    when(message.getFrom()).thenReturn(new Address[] { new InternetAddress("[email protected]") });
    when(message.getHeader(eq("Message-ID"))).thenReturn(new String[] {"mockMID"});
    doThrow(new IOException("mock")).when(message).writeTo(any(OutputStream.class));
    try {
        transport.sendMessage(message, new Address[]{new InternetAddress("[email protected]")});
    } finally {
        waitForListeners();
        verify(transportListener).messageNotDelivered(any(TransportEvent.class));
    }
}
 

@Test
public void transportNOPTest() throws Exception {
    TransportListener transportListener = Mockito.mock(TransportListener.class);
    Message message = generateMessage();
    Transport transport = session.getTransport("nop");
    transport.addTransportListener(transportListener);
    transport.sendMessage(message, toAddress);
    waitForListeners();
    ArgumentCaptor<TransportEvent> transportEventArgumentCaptor = ArgumentCaptor.forClass(TransportEvent.class);
    verify(transportListener).messageDelivered(transportEventArgumentCaptor.capture());
    TransportEvent event = transportEventArgumentCaptor.getValue();
    assertEquals(message, event.getMessage());
    assertEquals(TransportEvent.MESSAGE_DELIVERED, event.getType());
    assertArrayEquals(toAddress, event.getValidSentAddresses());
}
 

@Test
public void testSend() throws Exception {
    final Address[] sendTo = new Address[] { new InternetAddress("[email protected]") };
    Message message = Mockito.mock(Message.class);
    when(message.getHeader(eq(SmtpJmsTransport.X_SEND_PRIORITY))).thenReturn(new String[]{"low"});
    when(message.getFrom()).thenReturn(new Address[] { new InternetAddress("[email protected]") });
    when(message.getSubject()).thenReturn("msgSubject!");
    transport.sendMessage(message, sendTo);
    ArgumentCaptor<byte[]> bytesCaptor = ArgumentCaptor.forClass(byte[].class);
    verify(bytesMessage, times(1)).writeBytes(bytesCaptor.capture());
    byte[] messageBuffer = bytesCaptor.getValue();
    assertNotNull(messageBuffer);
    ObjectInputStream input = new ObjectInputStream(new ByteArrayInputStream(messageBuffer));
    String protocol = input.readUTF();
    Address[] inAddr = (Address[]) input.readObject();
    assertEquals(1, inAddr.length);
    assertArrayEquals(sendTo, inAddr);
    assertEquals("smtp", protocol);
    verify(message, times(1)).writeTo(any(ObjectOutputStream.class));
    waitForListeners();
    ArgumentCaptor<TransportEvent> transportEventArgumentCaptor = ArgumentCaptor.forClass(TransportEvent.class);
    verify(transportListener, times(1)).messageDelivered(transportEventArgumentCaptor.capture());
    TransportEvent event = transportEventArgumentCaptor.getValue();
    assertEquals(message, event.getMessage());
    assertArrayEquals(new Address[0], event.getInvalidAddresses());
    assertArrayEquals(sendTo, event.getValidSentAddresses());
    assertArrayEquals(new Address[0], event.getValidUnsentAddresses());
}
 

@Test
public void testNoAddresses() throws Exception {
    Message message = Mockito.mock(Message.class);
    when(message.getFrom()).thenReturn(new Address[] { new InternetAddress("[email protected]") });
    try {
        transport.sendMessage(message, new Address[]{}); // empty address list
        fail();
    } catch (MessagingException ex) {
        waitForListeners();
        verify(transportListener).messageNotDelivered(any(TransportEvent.class));
    }
}
 

@Test(expected = MessagingException.class)
public void testNoFromNull() throws Exception {
    try {
        message.setFrom((String) null);
        transport.validateAndPrepare(message, new Address[]{});
    } finally {
        waitForListeners();
        verify(transportListener).messageNotDelivered(any(TransportEvent.class));
    }
}
 

@Override
public void sendMessage(
                         Message arg0,
                         Address[] arg1 ) throws MessagingException {

    log.info("Fake message sending");

    if (deliveryState == DELIVERY_STATE.DELIVERED) {
        notifyTransportListeners(TransportEvent.MESSAGE_DELIVERED, null, null, null, null);
    } else if (deliveryState == DELIVERY_STATE.PARTIALLY_DELIVERED) {
        notifyTransportListeners(TransportEvent.MESSAGE_PARTIALLY_DELIVERED, null, null, null, null);
    } else if (deliveryState == DELIVERY_STATE.ERROR_DELIVERING) {
        notifyTransportListeners(TransportEvent.MESSAGE_NOT_DELIVERED, null, null, null, null);
    }
}
 

/**
 * {@inheritDoc} This acks the notification by invoking {@link NotificationContext#ack(String)}
 */
public void messageDelivered(TransportEvent event) {
    LOG.debug("Got messageDelivered event {}", event);
    String notificationId = msgNotificationMap.remove(event.getMessage());
    if (notificationId != null) {
        ctx.ack(notificationId);
    }
}
 

@Test
public void testSendWitEmptyFrom() throws Exception {
    Message message = Mockito.mock(Message.class);
    when(message.getFrom()).thenReturn(new Address[0]);
    try {
        transport.sendMessage(message, new Address[]{new InternetAddress("[email protected]")});
        fail();
    } catch (MessagingException ex) {
        waitForListeners();
        verify(transportListener, times(1)).messageNotDelivered(any(TransportEvent.class));
    }
}
 

private void fail(Message message, Address[] addresses, String msg) throws MessagingException {
	notifyTransportListeners(TransportEvent.MESSAGE_NOT_DELIVERED, ADDRESSES_EMPTY, addresses, ADDRESSES_EMPTY, message);
	throw new MessagingException(msg);
}
 

public void messageNotDelivered(
                                 TransportEvent e ) {

    processResult(DELIVERY_STATE.ERROR_DELIVERING);
}
 

public void messagePartiallyDelivered(
                                       TransportEvent e ) {

    processResult(DELIVERY_STATE.ERROR_DELIVERING);
}
 

/**
 * {@inheritDoc} This fails the notification by invoking {@link NotificationContext#fail(String)}
 */
public void messageNotDelivered(TransportEvent event) {
    LOG.debug("Got messageNotDelivered event {}", event);
    handleFail(event);
}
 

public void messageDelivered(
                              TransportEvent e ) {

    processResult(DELIVERY_STATE.DELIVERED);
}
 

private void fail(Message message, Address[] addresses, String msg) throws MessagingException {
    Address[] empty = new Address[0];
    notifyTransportListeners(TransportEvent.MESSAGE_NOT_DELIVERED, empty, addresses, empty, message);
    throw new MessagingException(msg);
}
 

@Override
public void sendMessage(Message msg, Address[] addresses) throws MessagingException {
    validateAndPrepare(msg, addresses);
    logger.info("Message {subject=" + msg.getSubject() + ", to=" + Arrays.asList(addresses) + "}");
    notifyTransportListeners(TransportEvent.MESSAGE_DELIVERED, msg.getAllRecipients(), ADDRESSES_EMPTY, ADDRESSES_EMPTY, msg);
}
 

private void handleFail(TransportEvent event) {
    String notificationId = msgNotificationMap.remove(event.getMessage());
    if (notificationId != null) {
        ctx.fail(notificationId);
    }
}
 

/**
 * {@inheritDoc}
 * <p/>
 * TODO: See if partially delivered should be handled separately
 */
public void messagePartiallyDelivered(TransportEvent event) {
    LOG.debug("Got messagePartiallyDelivered event {}", event);
    handleFail(event);
}