Mock Network Servers

/**
 * Dummy SMTP server for testing email appenders
 * Implements Runnable for background operation
 */
public class SimpleSmtpServer implements Runnable {
    
    /**
     * Default SMTP port number
     */
    public static final int DEFAULT_SMTP_PORT = 25;
    
    /**
     * Starts SMTP server on default port (25)
     * @return Running SimpleSmtpServer instance
     */
    public static SimpleSmtpServer start();
    
    /**
     * Starts SMTP server on specified port
     * @param port Port number to bind to
     * @return Running SimpleSmtpServer instance
     */
    public static SimpleSmtpServer start(int port);
    
    /**
     * Checks if server is stopped
     * @return true if server is stopped, false if running
     */
    public synchronized boolean isStopped();
    
    /**
     * Stops the SMTP server
     */
    public synchronized void stop();
    
    /**
     * Gets iterator over received email messages
     * @return Iterator of SmtpMessage objects
     */
    public synchronized Iterator<SmtpMessage> getReceivedEmail();
    
    /**
     * Gets count of received email messages
     * @return Number of received emails
     */
    public synchronized int getReceivedEmailSize();
    
    /**
     * Gets the port the server is bound to
     * @return Port number
     */
    public int getPort();
}

/**
 * SMTP message representation for testing
 */
public class SmtpMessage {
    
    /**
     * Gets the message headers
     * @return Map of header names to values
     */
    public Map<String, String> getHeaders();
    
    /**
     * Gets the message body
     * @return Message body as string
     */
    public String getBody();
    
    /**
     * Gets the sender address
     * @return Sender email address
     */
    public String getFrom();
    
    /**
     * Gets the recipient addresses
     * @return List of recipient email addresses
     */
    public List<String> getTo();
    
    /**
     * Gets the message subject
     * @return Email subject line
     */
    public String getSubject();
}

/**
 * SMTP request representation
 */
public class SmtpRequest {
    
    /**
     * Gets the SMTP command
     * @return SMTP command string
     */
    public String getCommand();
    
    /**
     * Gets the command parameters
     * @return Command parameters
     */
    public String getParameters();
}

/**
 * SMTP response representation
 */
public class SmtpResponse {
    
    /**
     * Gets the response code
     * @return SMTP response code
     */
    public int getCode();
    
    /**
     * Gets the response message
     * @return Response message text
     */
    public String getMessage();
}

/**
 * SMTP state management for testing
 */
public class SmtpState {
    
    /**
     * Gets the current SMTP session state
     * @return Current state name
     */
    public String getCurrentState();
    
    /**
     * Transitions to new state
     * @param newState The new state to transition to
     */
    public void setState(String newState);
}

/**
 * SMTP action type definitions
 */
public class SmtpActionType {
    
    public static final String CONNECT = "CONNECT";
    public static final String HELO = "HELO";
    public static final String MAIL_FROM = "MAIL_FROM";
    public static final String RCPT_TO = "RCPT_TO";
    public static final String DATA = "DATA";
    public static final String QUIT = "QUIT";
}

import org.apache.logging.log4j.core.test.smtp.SimpleSmtpServer;
import org.apache.logging.log4j.core.test.smtp.SmtpMessage;

public class SmtpAppenderTest {
    
    @Test
    public void testSmtpAppender() throws Exception {
        // Start mock SMTP server
        SimpleSmtpServer smtpServer = SimpleSmtpServer.start(2525);
        
        try {
            // Configure SMTP appender to use localhost:2525
            Logger logger = LogManager.getLogger();
            logger.error("Test error message");
            
            // Wait for message processing
            Thread.sleep(1000);
            
            // Verify email was sent
            assertEquals(1, smtpServer.getReceivedEmailSize());
            
            Iterator<SmtpMessage> messages = smtpServer.getReceivedEmail();
            SmtpMessage message = messages.next();
            
            assertEquals("Log4j Error", message.getSubject());
            assertTrue(message.getBody().contains("Test error message"));
            
        } finally {
            smtpServer.stop();
        }
    }
}

/**
 * Base class for mock syslog servers
 * Abstract class extending Thread for background operation
 */
public abstract class MockSyslogServer extends Thread {
    
    /**
     * Gets the local port the server is bound to
     * @return Port number
     */
    public abstract int getLocalPort();
    
    /**
     * Shuts down the syslog server
     */
    public void shutdown();
    
    /**
     * Gets count of received syslog messages
     * @return Number of received messages
     */
    public int getNumberOfReceivedMessages();
    
    /**
     * Gets list of received syslog messages
     * @return List of message strings
     */
    public List<String> getMessageList();
    
    /**
     * Clears all received messages
     */
    public void clear();
}

/**
 * Factory for creating mock syslog servers
 */
public class MockSyslogServerFactory {
    
    /**
     * Creates TCP syslog server
     * @param port Port to bind to (0 for random available port)
     * @return MockTcpSyslogServer instance
     */
    public static MockTcpSyslogServer createTcpSyslogServer(int port);
    
    /**
     * Creates UDP syslog server
     * @param port Port to bind to (0 for random available port)
     * @return MockUdpSyslogServer instance
     */
    public static MockUdpSyslogServer createUdpSyslogServer(int port);
    
    /**
     * Creates TLS syslog server
     * @param port Port to bind to (0 for random available port)
     * @return MockTlsSyslogServer instance
     */
    public static MockTlsSyslogServer createTlsSyslogServer(int port);
}

/**
 * TCP syslog server mock
 */
public class MockTcpSyslogServer extends MockSyslogServer {
    
    /**
     * Creates TCP syslog server on specified port
     * @param port Port to bind to
     */
    public MockTcpSyslogServer(int port);
}

/**
 * UDP syslog server mock
 */
public class MockUdpSyslogServer extends MockSyslogServer {
    
    /**
     * Creates UDP syslog server on specified port
     * @param port Port to bind to
     */
    public MockUdpSyslogServer(int port);
}

/**
 * TLS syslog server mock
 */
public class MockTlsSyslogServer extends MockSyslogServer {
    
    /**
     * Creates TLS syslog server on specified port
     * @param port Port to bind to
     */
    public MockTlsSyslogServer(int port);
}

/**
 * TLS syslog input stream reader base class
 */
public abstract class TlsSyslogInputStreamReaderBase {
    
    /**
     * Reads syslog messages from TLS input stream
     * @param inputStream The TLS input stream
     * @return List of parsed syslog messages
     */
    public abstract List<String> readMessages(InputStream inputStream);
}

/**
 * Standard TLS syslog input stream reader
 */
public class TlsSyslogInputStreamReader extends TlsSyslogInputStreamReaderBase {
    
    /**
     * Reads RFC 5424 compliant TLS syslog messages
     * @param inputStream The TLS input stream
     * @return List of parsed syslog messages
     */
    public List<String> readMessages(InputStream inputStream);
}

/**
 * Legacy BSD TLS syslog input stream reader
 */
public class LegacyBsdTlsSyslogInputStreamReader extends TlsSyslogInputStreamReaderBase {
    
    /**
     * Reads legacy BSD format TLS syslog messages
     * @param inputStream The TLS input stream
     * @return List of parsed syslog messages
     */
    public List<String> readMessages(InputStream inputStream);
}

/**
 * TLS syslog message format definitions
 */
public enum TlsSyslogMessageFormat {
    
    /** RFC 5424 compliant format */
    RFC_5424,
    
    /** Legacy BSD format */
    LEGACY_BSD
}

/**
 * TLS syslog testing utilities
 */
public class TlsSyslogTestUtil {
    
    /**
     * Creates SSL context for testing TLS syslog
     * @return SSL context configured for testing
     */
    public static SSLContext createTestSSLContext();
    
    /**
     * Creates test certificate for TLS syslog testing
     * @return X509Certificate for testing
     */
    public static X509Certificate createTestCertificate();
}

import org.apache.logging.log4j.core.test.net.mock.MockSyslogServerFactory;
import org.apache.logging.log4j.core.test.net.mock.MockUdpSyslogServer;

public class SyslogAppenderTest {
    
    @Test
    public void testUdpSyslogAppender() throws Exception {
        // Start mock UDP syslog server
        MockUdpSyslogServer syslogServer = MockSyslogServerFactory.createUdpSyslogServer(0);
        syslogServer.start();
        
        int port = syslogServer.getLocalPort();
        
        try {
            // Configure syslog appender to use localhost:port
            Logger logger = LogManager.getLogger();
            logger.info("Test syslog message");
            
            // Wait for message processing
            Thread.sleep(500);
            
            // Verify message was received
            assertEquals(1, syslogServer.getNumberOfReceivedMessages());
            
            List<String> messages = syslogServer.getMessageList();
            assertTrue(messages.get(0).contains("Test syslog message"));
            
        } finally {
            syslogServer.shutdown();
        }
    }
    
    @Test
    public void testTcpSyslogAppender() throws Exception {
        MockTcpSyslogServer tcpServer = MockSyslogServerFactory.createTcpSyslogServer(0);
        tcpServer.start();
        
        // Similar testing pattern for TCP
    }
    
    @Test
    public void testTlsSyslogAppender() throws Exception {
        MockTlsSyslogServer tlsServer = MockSyslogServerFactory.createTlsSyslogServer(0);
        tlsServer.start();
        
        // TLS-specific testing with certificates
    }
}

// 1. Start mock server
SimpleSmtpServer server = SimpleSmtpServer.start(2525);

// 2. Configure appender to use mock server
// 3. Perform logging that should trigger email

// 4. Verify messages
assertEquals(expectedCount, server.getReceivedEmailSize());
SmtpMessage message = server.getReceivedEmail().next();
assertEquals(expectedSubject, message.getSubject());

// 5. Clean up
server.stop();

// 1. Create and start mock server
MockUdpSyslogServer server = MockSyslogServerFactory.createUdpSyslogServer(0);
server.start();

// 2. Get assigned port
int port = server.getLocalPort();

// 3. Configure syslog appender
// 4. Perform logging

// 5. Verify messages
List<String> messages = server.getMessageList();
assertEquals(expectedCount, messages.size());

// 6. Clean up
server.shutdown();