ServerConfig.java

package fr.sii.ogham.testing.extension.junit.sms.config;

import fr.sii.ogham.testing.sms.simulator.config.Credentials;
import fr.sii.ogham.testing.sms.simulator.config.*;
import fr.sii.ogham.testing.util.RandomPortUtils;
import ogham.testing.io.github.resilience4j.retry.RetryConfig;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static fr.sii.ogham.testing.extension.junit.sms.config.SlowConfig.noWait;
import static fr.sii.ogham.testing.extension.junit.sms.config.SlowConfig.waitFor;
import static fr.sii.ogham.testing.util.RandomPortUtils.PORT_RANGE_MAX;
import static fr.sii.ogham.testing.util.RandomPortUtils.PORT_RANGE_MIN;
import static java.time.Duration.ofMillis;
import static java.util.stream.Collectors.toList;
import static ogham.testing.io.github.resilience4j.core.IntervalFunction.ofExponentialBackoff;

/**
 * Builder to generate a {@link SimulatorConfiguration}.
 *
 * <p>
 * Default configuration:
 * <ul>
 * <li>Starts on random port</li>
 * <li>No delay</li>
 * <li>No credentials</li>
 * <li>Do not keep messages between tests</li>
 * </ul>
 *
 * @author Aurélien Baudet
 */
public class ServerConfig {
    private PortConfig portConfig;
    private final List<Credentials> credentials = new ArrayList<>();
    private SmppServerConfig annotationConfig;
    private SlowConfig slowConfig;
    private boolean keepMessages;
    private RetryConfig startRetryConfig;

    /**
     * Start the server with a fixed port.
     *
     * @param port the port value
     * @return this instance for fluent chaining
     */
    public ServerConfig port(int port) {
        this.portConfig = new FixedPortConfig(port);
        return this;
    }

    /**
     * Start the server with a random port.
     * <p>
     * The port is contained in the range
     * [{@link RandomPortUtils#PORT_RANGE_MIN},
     * {@link RandomPortUtils#PORT_RANGE_MAX}].
     *
     * @return this instance for fluent chaining
     */
    public ServerConfig randomPort() {
        return randomPort(PORT_RANGE_MAX);
    }

    /**
     * Start the server with a random port.
     * <p>
     * The port is contained in the range
     * [{@link RandomPortUtils#PORT_RANGE_MIN}, {@code maxPort}].
     *
     * @param maxPort the maximum port value
     * @return this instance for fluent chaining
     */
    public ServerConfig randomPort(int maxPort) {
        return randomPort(PORT_RANGE_MIN, maxPort);
    }

    /**
     * Start the server with a random port.
     * <p>
     * The port is contained in the range [{@code minPort}, {@code maxPort}].
     *
     * @param minPort the minimum port value
     * @param maxPort the maximum port value
     * @return this instance for fluent chaining
     */
    public ServerConfig randomPort(int minPort, int maxPort) {
        this.portConfig = new RandomPortConfig(minPort, maxPort);
        return this;
    }

    /**
     * Register allowed credentials.
     *
     * @param systemId the system_id
     * @param password the password
     * @return this instance for fluent chaining
     */
    public ServerConfig credentials(String systemId, String password) {
        credentials.add(new Credentials(systemId, password));
        return this;
    }

    /**
     * Configure the simulator to behave like a slow server.
     *
     * @return the builder to control slow delays
     */
    public SlowConfig slow() {
        if (slowConfig == null) {
            slowConfig = new SlowConfig(this);
        }
        return slowConfig;
    }

    /**
     * Merge with configuration provided by annotation.
     * <p>
     * The configuration provided by the annotation takes precedence over
     * configuration using builder methods. The aim is to be able to provide
     * common configuration for the test class using JUnit rules and be able to
     * override some configuration for a particular test.
     *
     * @param annotationConfig the annotation configuration
     * @return this instance for fluent chaining
     */
    public ServerConfig annotationConfig(SmppServerConfig annotationConfig) {
        this.annotationConfig = annotationConfig;
        return this;
    }

    /**
     * If the server is restarted, it indicates if received messages in the
     * previous session should be kept (true) or dropped (false).
     *
     * @param keep indicate if messages should be kept or not between sessions
     * @return this instance for fluent chaining
     */
    public ServerConfig keepMessages(boolean keep) {
        keepMessages = keep;
        return this;
    }

    /**
     * Server may not start correctly (because port was available but is not
     * available anymore for example).
     * <p>
     * In such case, the server will be restarted until it starts successfully, or
     * it fails due to maximum attempts reached.
     *
     * @param retryConfig the retry configuration
     * @return this instance for fluent chaining
     */
    public ServerConfig startRetry(RetryConfig retryConfig) {
        this.startRetryConfig = retryConfig;
        return this;
    }

    /**
     * Create the final {@link SimulatorConfiguration} that is used by the SMPP
     * server.
     *
     * @return the simulator configuration
     */
    public SimulatorConfiguration build() {
        SimulatorConfiguration config = new SimulatorConfiguration();
        config.setPort(buildPort());
        config.setCredentials(buildCredentials());
        config.setServerDelays(buildServerDelays());
        config.setKeepMessages(keepMessages);
        config.setStartRetryConfig(buildStartRetryConfig());
        return config;
    }

    private ServerPortProvider buildPort() {
        if (portConfig == null) {
            return new RandomPortConfig(PORT_RANGE_MIN, PORT_RANGE_MAX).build();
        }
        return portConfig.build();
    }

    private List<Credentials> buildCredentials() {
        if (annotationConfig != null) {
            return Arrays.stream(annotationConfig.credentials()).map(c -> new Credentials(c.systemId(), c.password())).collect(toList());
        }
        return credentials;
    }

    private ServerDelays buildServerDelays() {
        if (annotationConfig != null) {
            return buildServerDelays(annotationConfig.slow());
        }
        if (slowConfig != null) {
            return slowConfig.build();
        }
        return null;
    }

    private RetryConfig buildStartRetryConfig() {
        if (startRetryConfig != null) {
            return startRetryConfig;
        }
        return RetryConfig.custom()
                .maxAttempts(5)
                .intervalFunction(ofExponentialBackoff(ofMillis(100)))
                .failAfterMaxAttempts(true)
                .build();
    }

    private static ServerDelays buildServerDelays(Slow slow) {
        ServerDelays delays = new ServerDelays();
        delays.setSendAlertNotificationWaiting(toAwaiter(slow.sendAlertNotificationDelay()));
        delays.setSendBindWaiting(toAwaiter(slow.sendBindDelay()));
        delays.setSendBindRespWaiting(toAwaiter(slow.sendBindRespDelay()));
        delays.setSendCancelSmWaiting(toAwaiter(slow.sendCancelSmDelay()));
        delays.setSendCancelSmRespWaiting(toAwaiter(slow.sendCancelSmRespDelay()));
        delays.setSendDataSmWaiting(toAwaiter(slow.sendDataSmDelay()));
        delays.setSendDataSmRespWaiting(toAwaiter(slow.sendDataSmRespDelay()));
        delays.setSendDeliverSmWaiting(toAwaiter(slow.sendDeliverSmDelay()));
        delays.setSendDeliverSmRespWaiting(toAwaiter(slow.sendDeliverSmRespDelay()));
        delays.setSendEnquireLinkWaiting(toAwaiter(slow.sendEnquireLinkDelay()));
        delays.setSendEnquireLinkRespWaiting(toAwaiter(slow.sendEnquireLinkRespDelay()));
        delays.setSendGenericNackWaiting(toAwaiter(slow.sendGenericNackDelay()));
        delays.setSendHeaderWaiting(toAwaiter(slow.sendHeaderDelay()));
        delays.setSendOutbindWaiting(toAwaiter(slow.sendOutbindDelay()));
        delays.setSendQuerySmWaiting(toAwaiter(slow.sendQuerySmDelay()));
        delays.setSendQuerySmRespWaiting(toAwaiter(slow.sendQuerySmRespDelay()));
        delays.setSendReplaceSmWaiting(toAwaiter(slow.sendReplaceSmDelay()));
        delays.setSendReplaceSmRespWaiting(toAwaiter(slow.sendReplaceSmRespDelay()));
        delays.setSendSubmitMultiWaiting(toAwaiter(slow.sendSubmitMultiDelay()));
        delays.setSendSubmitMultiRespWaiting(toAwaiter(slow.sendSubmitMultiRespDelay()));
        delays.setSendSubmitSmWaiting(toAwaiter(slow.sendSubmitSmDelay()));
        delays.setSendSubmitSmRespWaiting(toAwaiter(slow.sendSubmitSmRespDelay()));
        delays.setSendUnbindWaiting(toAwaiter(slow.sendUnbindDelay()));
        delays.setSendUnbindRespWaiting(toAwaiter(slow.sendUnbindRespDelay()));
        return delays;
    }

    private static Awaiter toAwaiter(long delayMs) {
        if (delayMs == 0) {
            return noWait();
        }
        return waitFor(delayMs);
    }
}



























































Active mutators

Tests examined

Report generated by PIT 1.13.1

1		package fr.sii.ogham.testing.extension.junit.sms.config;
2
3		import fr.sii.ogham.testing.sms.simulator.config.Credentials;
4		import fr.sii.ogham.testing.sms.simulator.config.*;
5		import fr.sii.ogham.testing.util.RandomPortUtils;
6		import ogham.testing.io.github.resilience4j.retry.RetryConfig;
7
8		import java.util.ArrayList;
9		import java.util.Arrays;
10		import java.util.List;
11
12		import static fr.sii.ogham.testing.extension.junit.sms.config.SlowConfig.noWait;
13		import static fr.sii.ogham.testing.extension.junit.sms.config.SlowConfig.waitFor;
14		import static fr.sii.ogham.testing.util.RandomPortUtils.PORT_RANGE_MAX;
15		import static fr.sii.ogham.testing.util.RandomPortUtils.PORT_RANGE_MIN;
16		import static java.time.Duration.ofMillis;
17		import static java.util.stream.Collectors.toList;
18		import static ogham.testing.io.github.resilience4j.core.IntervalFunction.ofExponentialBackoff;
19
20		/**
21		* Builder to generate a {@link SimulatorConfiguration}.
22		*
23		* <p>
24		* Default configuration:
25		* <ul>
26		* <li>Starts on random port</li>
27		* <li>No delay</li>
28		* <li>No credentials</li>
29		* <li>Do not keep messages between tests</li>
30		* </ul>
31		*
32		* @author Aurélien Baudet
33		*/
34		public class ServerConfig {
35		private PortConfig portConfig;
36		private final List<Credentials> credentials = new ArrayList<>();
37		private SmppServerConfig annotationConfig;
38		private SlowConfig slowConfig;
39		private boolean keepMessages;
40		private RetryConfig startRetryConfig;

ServerConfig.java

Mutations

Active mutators

Tests examined