GreenMail

https://greenmail-mail-test.github.io/greenmail
Admin
GreenMail is an open source, lightweight, and sandboxed suite of email servers (SMTP, POP3, IMAP)...
Tokens:5,644
Snippets:67
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Start GreenMail Standalone Bound to 0.0.0.0

Source: https://greenmail-mail-test.github.io/greenmail

Initializes all mail protocols and the API, binding the server to all network interfaces.

```bash
java -Dgreenmail.setup.test.all -Dgreenmail.users=test1:pwd1 \
     -Dgreenmail.hostname=0.0.0.0 \
     -jar greenmail-standalone.jar
```

--------------------------------

### Start GreenMail Standalone Application

Source: https://greenmail-mail-test.github.io/greenmail

Command to execute the GreenMail standalone JAR file.

```bash
java [OPTIONS] -jar greenmail-standalone.jar
```

--------------------------------

### Start GreenMail Standalone with SMTP Only

Source: https://greenmail-mail-test.github.io/greenmail

Configures and starts only the SMTP service on a specific host and port.

```bash
java -Dgreenmail.smtp.hostname=127.0.0.1 -Dgreenmail.smtp.port=4025 \
     -jar greenmail-standalone.jar
```

--------------------------------

### Manual GreenMail Lifecycle Management

Source: https://greenmail-mail-test.github.io/greenmail

Demonstrates starting and stopping the GreenMail server manually for simple email sending tests.

```java

/** See code on GitHub */
GreenMail greenMail = new GreenMail(); //uses test ports by default
greenMail.start();
GreenMailUtil.sendTextEmailTest("to@localhost", "from@localhost", "some subject",
                                "some body"); // --- Place your sending code here
assertEquals("some body", greenMail.getReceivedMessages()[0].getContent());
greenMail.stop();
```

--------------------------------

### Start GreenMail Standalone for All Protocols

Source: https://greenmail-mail-test.github.io/greenmail

Initializes SMTP, SMTPS, IMAP, IMAPS, POP3, and POP3S services with two user accounts.

```bash
java -Dgreenmail.setup.test.all -Dgreenmail.users=test1:pwd1,test2:pwd2@example.com \
     -jar greenmail-standalone.jar
```

--------------------------------

### Start GreenMail Standalone for SMTP and IMAP

Source: https://greenmail-mail-test.github.io/greenmail

Initializes SMTP and IMAP services on localhost with a single user account.

```bash
java -Dgreenmail.setup.test.smtp -Dgreenmail.setup.test.imap \
     -Dgreenmail.users=test1:pwd1 -jar greenmail-standalone.jar
```

--------------------------------

### JUnit 4 Rule-based GreenMail Setup

Source: https://greenmail-mail-test.github.io/greenmail

Uses the GreenMailRule to manage the server lifecycle automatically for each test method.

```java

/** See code on GitHub */
@Rule
public final GreenMailRule greenMail = new GreenMailRule(ServerSetupTest.SMTP);

@Test
public void testSomething() {
    GreenMailUtil.sendTextEmailTest("to@localhost", "from@localhost", "subject", "body");
    MimeMessage[] emails = greenMail.getReceivedMessages();
    assertEquals(1, emails.length);
    assertEquals("subject", emails[0].getSubject());
    assertEquals("body", emails[0].getContent());
    // ...
}
```

--------------------------------

### Dynamic Port Detection for GreenMail

Source: https://greenmail-mail-test.github.io/greenmail

Starts the server on an available port to avoid collisions in parallel test environments.

```java

/** See code on GitHub */
GreenMail greenMailWithDynamicPort = new GreenMail(ServerSetupTest.SMTP.dynamicPort()); // Try to find available port
greenMailWithDynamicPort.start();
try {
    GreenMailUtil.sendTextEmail(
        "to@localhost", "from@localhost", "some subject", "Sent using available port detection",
        greenMailWithDynamicPort.getSmtp().getServerSetup()); // Important: Pass dynamic port setup here
    assertEquals("Sent using available port detection", greenMailWithDynamicPort.getReceivedMessages()[0].getContent());
    assertNotEquals("Dynamic port must differ", ServerSetupTest.SMTP.getPort(), greenMailWithDynamicPort.getSmtp().getPort());
} finally {
    greenMailWithDynamicPort.stop();
}
```

--------------------------------

### JUnit 5 Extension-based GreenMail Setup

Source: https://greenmail-mail-test.github.io/greenmail

Uses the GreenMailExtension to manage the server lifecycle within the JUnit 5 test lifecycle.

```java

/** See code on GitHub */
@RegisterExtension
static GreenMailExtension greenMail = new GreenMailExtension(ServerSetupTest.SMTP);

@Test
@DisplayName("Send test")
void testSend() {
    GreenMailUtil.sendTextEmailTest("to@localhost", "from@localhost", "some subject", "some body");
    final MimeMessage[] receivedMessages = greenMail.getReceivedMessages();
    final MimeMessage receivedMessage = receivedMessages[0];
    assertEquals("some body", receivedMessage.getContent());
}
```

--------------------------------

### Configure GreenMail Standalone via System Properties

Source: https://greenmail-mail-test.github.io/greenmail

Use these system properties to configure GreenMail services, users, and security settings at startup.

```bash
-Dgreenmail.setup.all
```

```bash
-Dgreenmail.setup.test.all
```

```bash
-Dgreenmail.smtp.hostname=127.0.0.1 -Dgreenmail.smtp.port=3025
```

```bash
-Dgreenmail.smtp.port=3025 -Dgreenmail.smtp.hostname=127.0.0.1
```

```bash
-Dgreenmail.smtp.port=3025 -Dgreenmail.imap.port=3143 -Dgreenmail.hostname=0.0.0.0
```

```bash
-Dgreenmail.users=foo:pwd@bar.com,jabber:wocky@monster.local,foo1:bar
```

```bash
-Dgreenmail.users.login=email
```

```bash
-Dgreenmail.tls.keystore.file=/home/greenmail/greenmail.p12
```

```bash
-Dgreenmail.tls.keystore.password=changeit
```

```bash
-Dgreenmail.tls.key.password=changeit4key
```

```bash
-Dgreenmail.auth.disabled
```

```bash
-Dgreenmail.verbose
```

```bash
-Dgreenmail.sieve.ignore.detail
```

```bash
-Dgreenmail.startup.timeout=2000
```

```bash
-Dgreenmail.preload.dir=/tmp/preload-example
```

--------------------------------

### Test Email Retrieval with GreenMailRule

Source: https://greenmail-mail-test.github.io/greenmail

Demonstrates setting up a user and delivering messages to a mailbox for testing POP3 or IMAP retrieval logic.

```java
@Rule
public final GreenMailRule greenMail = new GreenMailRule(ServerSetupTest.SMTP_IMAP);

@Test
public void testReceive() throws MessagingException {
    GreenMailUser user = greenMail.setUser("to@localhost", "login-id", "password");
    user.deliver(createMimeMessage()); // You can either create a more complex message...
    GreenMailUtil.sendTextEmailTest("to@localhost", "from@localhost",
        "subject", "body"); // ...or use the default messages

    assertEquals(2, greenMail.getReceivedMessages().length); // // --- Place your POP3 or IMAP retrieve code here
}
```

--------------------------------

### Configure Dynamic Port Allocation

Source: https://greenmail-mail-test.github.io/greenmail

Sets up a GreenMail server on a dynamically assigned port and sends a test email using that configuration.

```java

@Rule
public final GreenMailRule greenMail = new GreenMailRule(ServerSetup.SMTP.dynamicPort());

GreenMailUtil.sendTextEmail("to@localhost", "from@localhost", "subject", "body",
    greenMail.getSmtp().getServerSetup());

```

--------------------------------

### Configure Log4j via System Property

Source: https://greenmail-mail-test.github.io/greenmail

Overrides the default log4j configuration by providing a custom file path.

```bash
-Dlog4j.configuration=file:///tmp/log4j.xml
```

--------------------------------

### Configure GreenMail Docker Container with Environment Variables

Source: https://greenmail-mail-test.github.io/greenmail

Passes custom JVM and GreenMail configuration options to the container using environment variables.

```bash
docker run -t -i \
           -e GREENMAIL_OPTS='-Dgreenmail.setup.test.all -Dgreenmail.hostname=0.0.0.0 -Dgreenmail.auth.disabled -Dgreenmail.verbose' \
           -e JAVA_OPTS='-Djava.net.preferIPv4Stack=true -Xmx512m' \
           -p 3025:3025 -p 3110:3110 -p 3143:3143 \
           -p 3465:3465 -p 3993:3993 -p 3995:3995 -p 8080:8080 \
           greenmail/standalone:2.0.1
```

--------------------------------

### Integrate GreenMail with Spring Framework

Source: https://greenmail-mail-test.github.io/greenmail

Shows how to use GreenMailBean for Spring-based testing configurations.

```java

/** See GreenMailBeanTest.java
 * and GreenMailBeanTest-context.xml
*/
@Autowired
private GreenMailBean greenMailBean;

@Test
public void testCreate() {
    GreenMail greenMail = greenMailBean.getGreenMail();
    ...
}
```

--------------------------------

### Configure Mail Session Properties

Source: https://greenmail-mail-test.github.io/greenmail

Apply protocol-specific properties to mail sessions during GreenMail initialization.

```java
GreenMail greenMail = new GreenMail(new ServerSetup[]{
        ServerSetupTest.SMTP,
        ServerSetupTest.IMAP.mailSessionProperty("mail.imap.minidletime", "100")
});
Session session = greenMail.getImap().createSession(); // Will have configured property set
```

--------------------------------

### Manage GreenMail Users

Source: https://greenmail-mail-test.github.io/greenmail

Demonstrates creating users with specific login credentials and deleting them from the manager.

```java

GreenMail greenMail = ...
// Create user with login id equals email
GreenMailUser user1 = greenMail.setUser("foo@localhost", "some secret pwd");
// Create user with login id different than email
GreenMailUser user2 = greenMail.setUser("foo@localhost", "login-id", "some secret pwd");
...
greenMail.getManagers().getUserManager().deleteUser(user1); // Delete user

```

--------------------------------

### Test Email Sending and Receiving with JavaMail

Source: https://greenmail-mail-test.github.io/greenmail

Demonstrates using GreenMailRule to test SMTP sending and IMAP retrieval, including multiple ways to access received messages.

```java

/** See code on GitHub */
@Rule
public final GreenMailRule greenMail = new GreenMailRule(ServerSetupTest.SMTP_IMAP);

@Test
public void testSendAndReceive() throws MessagingException, ... {
    Session smtpSession = greenMail.getSmtp().createSession();

    Message msg = new MimeMessage(smtpSession);
    msg.setFrom(new InternetAddress("foo@example.com"));
    msg.addRecipient(Message.RecipientType.TO,
            new InternetAddress("bar@example.com"));
    msg.setSubject("Email sent to GreenMail via plain JavaMail");
    msg.setText("Fetch me via IMAP");
    Transport.send(msg);

    // Create user, as connect verifies pwd
    greenMail.setUser("bar@example.com", "bar@example.com", "secret-pwd");

    // Alternative 1: Create session and store or ...
    Session imapSession = greenMail.getImap().createSession();
    Store store = imapSession.getStore("imap");
    store.connect("bar@example.com", "secret-pwd");
    Folder inbox = store.getFolder("INBOX");
    inbox.open(Folder.READ_ONLY);
    Message msgReceived = inbox.getMessage(1);
    assertEquals(msg.getSubject(), msgReceived.getSubject());
    ...

    // Alternative 2: ... let GreenMail create and configure a store:
    IMAPStore imapStore = greenMail.getImap().createStore();
    imapStore.connect("bar@example.com", "secret-pwd");
    inbox = imapStore.getFolder("INBOX");
    inbox.open(Folder.READ_ONLY);
    msgReceived = inbox.getMessage(1);
    ...

    // Alternative 3: ... directly fetch sent message using GreenMail API
    assertEquals(1, greenMail.getReceivedMessagesForDomain("bar@example.com").length);
    msgReceived = greenMail.getReceivedMessagesForDomain("bar@example.com")[0];
    ...
}
```

--------------------------------

### Run GreenMail Standalone via Docker

Source: https://greenmail-mail-test.github.io/greenmail

Pulls and executes the GreenMail standalone Docker image with mapped ports.

```bash
docker pull greenmail/standalone:2.0.1
docker run -t -i -p 3025:3025 -p 3110:3110 -p 3143:3143 \
                 -p 3465:3465 -p 3993:3993 -p 3995:3995 -p 8080:8080 \
                 greenmail/standalone:2.0.1
```

--------------------------------

### Testing Email Retrieval

Source: https://greenmail-mail-test.github.io/greenmail

Demonstrates how to inject messages into a GreenMail user account for testing retrieval logic.

```java

/** See code on GitHub */
//Start all email servers using non-default ports.
GreenMail greenMail = new GreenMail(ServerSetupTest.ALL);
greenMail.start();

//Use random content to avoid potential residual lingering problems
final String subject = GreenMailUtil.random();
final String body = GreenMailUtil.random();
MimeMessage message = createMimeMessage(subject, body, greenMail); // Construct message
GreenMailUser user = greenMail.setUser("wael@localhost", "waelc", "soooosecret");
user.deliver(message);
assertEquals(1, greenMail.getReceivedMessages().length);

// --- Place your retrieve code here
greenMail.stop();
```

--------------------------------

### Enable Verbose Logging

Source: https://greenmail-mail-test.github.io/greenmail

Configures the GreenMailRule to output debug information and protocol-level communication.

```java

@Rule
public final GreenMailRule greenMail = new GreenMailRule(ServerSetup.verbose(ServerSetupTest.SMTP_IMAP));

```

--------------------------------

### Configure GreenMail for Nested Test Classes

Source: https://greenmail-mail-test.github.io/greenmail

Override the beforeAll method to prevent 'Address already in use' errors when using @Nested test classes with per-method lifecycle disabled.

```java
public class NestedTest {
    @RegisterExtension
    protected static GreenMailExtension greenMail = new GreenMailExtension(ServerSetupTest.SMTP) {
        @Override
        public void beforeAll(ExtensionContext context) {
            if (context.getTestClass().isPresent()) {
                Class currentClass = context.getTestClass().get();
                if (!ModifierSupport.isStatic(currentClass) && currentClass.isMemberClass()) {
                    return;
                }
            }
            super.beforeAll(context);
        }
    }
        .withConfiguration(
            GreenMailConfiguration.aConfig().withUser("user", "pw"))
        .withPerMethodLifecycle(false);

    @Nested
    class NestedTestClass {
        @Test
        public void testA() {
            // test something
        }
    }
}
```

--------------------------------

### Test Email Sending with GreenMailRule

Source: https://greenmail-mail-test.github.io/greenmail

Uses the GreenMailRule to verify that an email sent via SMTP is correctly received by the test server.

```java
@Rule
public final GreenMailRule greenMail = new GreenMailRule(ServerSetupTest.SMTP);

@Test
public void testSend() throws MessagingException {
    GreenMailUtil.sendTextEmailTest("to@localhost", "from@localhost",
        "some subject", "some body"); // --- Place your sending code here instead
    assertEquals("some body", greenMail.getReceivedMessages()[0].getContent());
}
```

--------------------------------

### Search Received Messages Directly

Source: https://greenmail-mail-test.github.io/greenmail

Use predicates to query internal user mailboxes directly without relying on IMAP or POP3 protocols.

```java
// All messages received for emails ending with "localhost" and subject containing "match"
final List messages = greenMail.findReceivedMessages(
        u -> u.getEmail().toLowerCase().endsWith("localhost")      /* Predicate for user account, selecting users by email ending with 'localhost' */,
        m -> MimeMessageHelper.getSubject(m, "").contains("match") /* Predicate for messages, selecting messages with subject attribute containing "match"*/
    ).collect(Collectors.toList());
```

--------------------------------

### Advanced Email Sending and Verification

Source: https://greenmail-mail-test.github.io/greenmail

Uses asynchronous waiting and multipart content verification for more complex test scenarios.

```java

/** See code on GitHub */
GreenMail greenMail = new GreenMail(ServerSetupTest.ALL);
greenMail.start();

//Use random content to avoid potential residual lingering problems
final String subject = GreenMailUtil.random();
final String body = GreenMailUtil.random();

sendTestMails(subject, body); // --- Place your sending code here

//wait for max 5s for 1 email to arrive
//waitForIncomingEmail() is useful if you're sending stuff asynchronously in a separate thread
assertTrue(greenMail.waitForIncomingEmail(5000, 2));

//Retrieve using GreenMail API
Message[] messages = greenMail.getReceivedMessages();
assertEquals(2, messages.length);

// Simple message
assertEquals(subject, messages[0].getSubject());
assertEquals(body, messages[0].getContent());

//if you send content as a 2 part multipart...
true(messages[1].getContent() instanceof MimeMultipart);
MimeMultipart mp = (MimeMultipart) messages[1].getContent();
assertEquals(2, mp.getCount());
assertEquals("body1", mp.getBodyPart(0).getContent());
assertEquals("body2", mp.getBodyPart(1).getContent());

greenMail.stop();
```

--------------------------------

### Configure Attachment Discarding

Source: https://greenmail-mail-test.github.io/greenmail

Enables or disables discarding attachments after MIME validation to save memory during performance tests.

```bash
-Dgreenmail.attachments.discard=true
```
Tokens:
Raw