hope.kola.contract.restassured.RestConfiguration Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of it-kola-contract Show documentation
null
There is a newer version: 1.1.2-RELEASE
package hope.kola.contract.restassured;

import static java.util.concurrent.TimeUnit.NANOSECONDS;

import groovy.lang.Closure;
import groovy.lang.DelegatesTo;
import io.restassured.RestAssured;
import io.restassured.config.ConnectionConfig;
import io.restassured.config.OAuthConfig;
import io.restassured.config.RestAssuredConfig;
import java.util.concurrent.TimeUnit;

/**
 * All configuration mirror from the {@code
 * https://github.com/rest-assured/rest-assured/wiki/Usage#detailed-configuration} Easy for function
 * call manipulate
 *
 * @see {@link io.restassured.config.RestAssuredConfig}
 * @see RedirectConfigBuilder
 * @see LogConfigBuilder
 * @see DecoderConfigBuilder
 * @see EncoderConfigBuilder
 * @see MultiPartConfigBuilder
 * @see ParamConfigBuilder
 * @see HttpClientConfigBuilder
 */
public class RestConfiguration {

  protected MultiPartConfigBuilder multiPartConfig;
  private RedirectConfigBuilder redirectConfig;
  private LogConfigBuilder logConfig;
  private EncoderConfigBuilder encoderConfig;
  private DecoderConfigBuilder decoderConfig;

  private ParamConfigBuilder paramConfig;

  private CsrfConfigBuilder csrfConfig;

  private HttpClientConfigBuilder httpClientConfigBuilder;

  /** The idle time of connections to be closed */
  private Long idleTime;

  /** The time unit to for idleTime */
  private TimeUnit idleTimeUnit;

  private Boolean addEmptyAccessTokenToBaseString;

  public RestAssuredConfig toRestAssuredConfig() {
    RestAssuredConfig res = RestAssured.config();

    if (idleTime != null) {
      res =
          res.connectionConfig(
              ConnectionConfig.connectionConfig()
                  .closeIdleConnectionsAfterEachResponseAfter(idleTime, idleTimeUnit));
    }
    if (addEmptyAccessTokenToBaseString != null) {
      res =
          res.oauthConfig(
              OAuthConfig.oauthConfig()
                  .addEmptyAccessTokenToBaseString(addEmptyAccessTokenToBaseString));
    }
    if (multiPartConfig != null) {
      res = res.multiPartConfig(multiPartConfig.transform());
    }
    if (redirectConfig != null) {
      res = res.redirect(redirectConfig.transform());
    }
    if (logConfig != null) {
      res = res.logConfig(logConfig.transform());
    }
    if (encoderConfig != null) {
      res = res.encoderConfig(encoderConfig.transform());
    }
    if (decoderConfig != null) {
      res = res.decoderConfig(decoderConfig.transform());
    }
    if (paramConfig != null) {
      res = res.paramConfig(paramConfig.transform());
    }
    if (csrfConfig != null) {
      res = res.csrfConfig(csrfConfig.transform());
    }
    if (httpClientConfigBuilder != null) {
      res = res.httpClient(httpClientConfigBuilder.transform());
    }

    return res;
  }

  // Eventually the merger job
  public RestConfiguration merger(final RestConfiguration from) {
    RestConfiguration res = new RestConfiguration();

    res.multiPartConfig = multiPartConfig;
    res.redirectConfig = redirectConfig;
    res.logConfig = logConfig;
    res.encoderConfig = encoderConfig;
    res.decoderConfig = decoderConfig;
    res.paramConfig = paramConfig;
    res.csrfConfig = csrfConfig;

    res.idleTime = idleTime;
    res.idleTimeUnit = idleTimeUnit;
    res.addEmptyAccessTokenToBaseString = addEmptyAccessTokenToBaseString;

    if (from.multiPartConfig != null) {
      res.multiPartConfig =
          res.multiPartConfig == null
              ? from.multiPartConfig
              : res.multiPartConfig.merger(from.multiPartConfig);
    }
    if (from.redirectConfig != null) {
      res.redirectConfig =
          res.redirectConfig == null
              ? from.redirectConfig
              : res.redirectConfig.merger(from.redirectConfig);
    }
    if (from.logConfig != null) {
      res.logConfig = res.logConfig == null ? from.logConfig : res.logConfig.merger(from.logConfig);
    }
    if (from.encoderConfig != null) {
      res.encoderConfig =
          res.encoderConfig == null
              ? from.encoderConfig
              : res.encoderConfig.merger(from.encoderConfig);
    }

    if (from.decoderConfig != null) {
      res.decoderConfig =
          res.decoderConfig == null
              ? from.decoderConfig
              : res.decoderConfig.merger(from.decoderConfig);
    }
    if (from.paramConfig != null) {
      res.paramConfig =
          res.paramConfig == null ? from.paramConfig : res.paramConfig.merger(from.paramConfig);
    }
    if (from.csrfConfig != null) {
      res.csrfConfig =
          res.csrfConfig == null ? from.csrfConfig : res.csrfConfig.merger(from.csrfConfig);
    }

    if (from.idleTime != null) {
      res.idleTime = from.idleTime;
    }
    if (from.idleTimeUnit != null) {
      res.idleTimeUnit = from.idleTimeUnit;
    }
    if (from.addEmptyAccessTokenToBaseString != null) {
      res.addEmptyAccessTokenToBaseString = from.addEmptyAccessTokenToBaseString;
    }

    return res;
  }

  public void redirect(@DelegatesTo(RedirectConfigBuilder.class) Closure consumer) {
    if (redirectConfig == null) {
      redirectConfig = new RedirectConfigBuilder();
    }
    consumer.setDelegate(redirectConfig);
    consumer.call();
  }

  public void log(@DelegatesTo(LogConfigBuilder.class) Closure consumer) {
    if (logConfig == null) {
      logConfig = new LogConfigBuilder();
    }
    consumer.setDelegate(logConfig);
    consumer.call();
  }

  public void encoder(@DelegatesTo(EncoderConfigBuilder.class) Closure consumer) {
    if (encoderConfig == null) {
      encoderConfig = new EncoderConfigBuilder();
    }
    consumer.setDelegate(encoderConfig);
    consumer.call();
  }

  public void decoder(@DelegatesTo(DecoderConfigBuilder.class) Closure consumer) {
    if (decoderConfig == null) {
      decoderConfig = new DecoderConfigBuilder();
    }
    consumer.setDelegate(decoderConfig);
    consumer.call();
  }

  public void multiple(@DelegatesTo(MultiPartConfigBuilder.class) Closure consumer) {
    if (multiPartConfig == null) {
      multiPartConfig = new MultiPartConfigBuilder();
    }
    consumer.setDelegate(multiPartConfig);
    consumer.call();
  }

  public void param(@DelegatesTo(ParamConfigBuilder.class) Closure consumer) {
    if (paramConfig == null) {
      paramConfig = new ParamConfigBuilder();
    }
    consumer.setDelegate(paramConfig);
    consumer.call();
  }

  public void csrf(@DelegatesTo(CsrfConfigBuilder.class) Closure consumer) {
    if (csrfConfig == null) {
      csrfConfig = new CsrfConfigBuilder();
    }
    consumer.setDelegate(csrfConfig);
    consumer.call();
  }

  public void client(@DelegatesTo(HttpClientConfigBuilder.class) Closure consumer) {
    if (httpClientConfigBuilder == null) {
      httpClientConfigBuilder = new HttpClientConfigBuilder();
    }
    consumer.setDelegate(httpClientConfigBuilder);
    consumer.call();
  }

  /**
   * Close open connections that have idled for the amount of time specified in this config after
   * each response.
   *
   * @param idleTime The idle time of connections to be closed
   * @param timeUnit The time unit to for idleTime
   * @return A new ConnectionConfig instance with the updated configuration
   */
  public void closeIdleConnectionsAfterEachResponse(Long idleTime, TimeUnit timeUnit) {
    this.idleTime = idleTime;
    this.idleTimeUnit = timeUnit;
  }

  /**
   * Don't close idle connections after each request. This is the default configuration. If you're
   * downloading large amount of data using HTTP chunking this setting is required.
   */
  public void dontCloseIdleConnectionsAfterEachResponse() {
    this.idleTime = null;
    this.idleTimeUnit = null;
  }

  /**
   * Close open connections after each response. This is required if you plan to make a lot of
   * consecutive requests with small response bodies. It can also be enabled if you never receive
   * chunked HTTP responses.
   */
  public void closeIdleConnectionsAfterEachResponse() {
    this.idleTime = 0L;
    this.idleTimeUnit = NANOSECONDS;
  }

  /** Configure whether to add an empty oauth token for OAuth1 while generating Base string */
  public void addEmptyAccessTokenToBaseString(Boolean enable) {
    addEmptyAccessTokenToBaseString = enable;
  }

  public TimeUnit second() {
    return TimeUnit.SECONDS;
  }

  public TimeUnit minutes() {
    return TimeUnit.MINUTES;
  }

  public TimeUnit hours() {
    return TimeUnit.HOURS;
  }
}