com.consol.citrus.http.client.HttpClient Java Examples

@Before
public void before(Scenario scenario) {
    if (httpClient == null && citrus.getCitrusContext().getReferenceResolver().resolveAll(HttpClient.class).size() == 1L) {
        httpClient = citrus.getCitrusContext().getReferenceResolver().resolve(HttpClient.class);
    } else {
        httpClient = new HttpClientBuilder().build();
    }

    timeout = httpClient.getEndpointConfiguration().getTimeout();

    requestHeaders = new HashMap<>();
    responseHeaders = new HashMap<>();
    requestParams = new HashMap<>();
    requestMessageType = CitrusSettings.DEFAULT_MESSAGE_TYPE;
    responseMessageType = CitrusSettings.DEFAULT_MESSAGE_TYPE;
    requestBody = null;
    responseBody = null;
    bodyValidationExpressions = new HashMap<>();
    outboundDictionary = null;
    inboundDictionary = null;
}
 

/**
 * Get secure http client implementation with trust all strategy and noop host name verifier.
 * @return
 */
private org.apache.http.client.HttpClient sslClient() {
    try {
        SSLContext sslcontext = SSLContexts
                .custom()
                .loadTrustMaterial(TrustAllStrategy.INSTANCE)
                .build();

        SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(
                sslcontext, NoopHostnameVerifier.INSTANCE);

        return HttpClients
                .custom()
                .setSSLSocketFactory(sslSocketFactory)
                .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                .build();
    } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException e) {
        throw new CitrusRuntimeException("Failed to create http client for ssl connection", e);
    }
}
 

@DataProvider
public Object[][] converterData() {
    return new Object[][] {
        new Object[] {new JmsEndpointModelConverter(), new JmsEndpointModel(), new JmsEndpoint(), "jms().asynchronous()"},
        new Object[] {new ChannelEndpointModelConverter(), new ChannelEndpointModel(), new ChannelEndpoint(), "channel()"},
        new Object[] {new CamelEndpointModelConverter(), new CamelEndpointModel(), new CamelEndpoint(), "camel()"},
        new Object[] {new VertxEndpointModelConverter(), new VertxEndpointModel(), new VertxEndpoint(), "vertx()"},
        new Object[] {new HttpClientModelConverter(), new HttpClientModel(), new HttpClient(), "http().client()"},
        new Object[] {new HttpServerModelConverter(), new HttpServerModel(), new HttpServer(), "http().server()"},
        new Object[] {new WebServiceClientModelConverter(), new WebServiceClientModel(), new WebServiceClient(), "soap().client()"},
        new Object[] {new WebServiceServerModelConverter(), new WebServiceServerModel(), new WebServiceServer(), "soap().server()"},
        new Object[] {new WebSocketClientModelConverter(), new WebSocketClientModel(), new WebServiceClient(), "websocket().client()"},
        new Object[] {new WebSocketServerModelConverter(), new WebSocketServerModel(), new WebSocketServer(), "websocket().server()"},
        new Object[] {new FtpClientModelConverter(), new FtpClientModel(), new FtpClient(), "ftp().client()"},
        new Object[] {new FtpServerModelConverter(), new FtpServerModel(), new FtpServer(), "ftp().server()"},
        new Object[] {new JdbcServerModelConverter(), new JdbcServerModel(), new JdbcServer(), "jdbc().server()"},
        new Object[] {new SshClientModelConverter(), new SshClientModel(), new SshClient(), "ssh().client()"},
        new Object[] {new SshServerModelConverter(), new SshServerModel(), new SshServer(), "ssh().server()"},
        new Object[] {new RmiClientModelConverter(), new RmiClientModel(), new RmiClient(), "rmi().client()"},
        new Object[] {new RmiServerModelConverter(), new RmiServerModel(), new RmiServer(), "rmi().server()"},
        new Object[] {new JmxClientModelConverter(), new JmxClientModel(), new JmxClient(), "jmx().client()"},
        new Object[] {new JmxServerModelConverter(), new JmxServerModel(), new JmxServer(), "jmx().server()"},
        new Object[] {new MailClientModelConverter(), new MailClientModel(), new MailClient(), "mail().client()"},
        new Object[] {new MailServerModelConverter(), new MailServerModel(), new MailServer(), "mail().server()"}
    };
}
 

@Given("^HTTP client \"([^\"\\s]+)\"$")
public void setClient(String id) {
    if (!citrus.getCitrusContext().getReferenceResolver().isResolvable(id)) {
        throw new CitrusRuntimeException("Unable to find http client for id: " + id);
    }

    httpClient = citrus.getCitrusContext().getReferenceResolver().resolve(id, HttpClient.class);
}
 

@Bean
public HttpClient simulatorRestEndpoint() {
    return CitrusEndpoints.http().client()
            .requestUrl(String.format("http://localhost:%s", 8080))
            .contentType(MediaType.APPLICATION_JSON_VALUE)
            .build();
}
 

@Bean
public HttpClient simulatorRestEndpoint() {
    return CitrusEndpoints.http().client()
            .requestUrl(String.format("http://localhost:%s", 8080))
            .contentType(MediaType.APPLICATION_JSON_VALUE)
            .build();
}
 

@Bean
public HttpClient simulatorHttpClientEndpoint() {
    return CitrusEndpoints.http()
            .client()
            .timeout(defaultTimeout)
            .requestUrl(String.format("https://localhost:%s/", port))
            .requestFactory(sslRequestFactory())
            .build();
}
 

/**
 * Citrus Http client
 * do a sync request/reply over HTTP on localhost:8080/order with a GET call and timeout for 60 seconds
 */
@Bean
public HttpClient statusHttpClient() {
    return CitrusEndpoints.http()
            .client()
            .requestUrl("http://localhost:8080/order")
            .requestMethod(HttpMethod.GET)
            .contentType("text/xml")
            .timeout(60000L)
            .build();
}
 

@Bean
public HttpClient httpClient() {
    return CitrusEndpoints
            .http()
            .client()
            .requestUrl("http://localhost:8080/foo")
            .build();
}
 

@Bean("httpClient")
public HttpClient client() {
    return CitrusEndpoints
            .http()
            .client()
            .requestUrl("http://localhost:8080/foo")
            .build();
}
 

@Bean
public HttpClient todoListApiClient() {
    return new HttpClientBuilder()
            .requestUrl(String.format("http://localhost:%s", integrationContainer.getServerPort()))
            .build();
}
 

@Bean
public HttpClient todoApiClient() {
    return new HttpClientBuilder()
            .requestUrl(String.format("http://localhost:%s", integrationContainer.getServerPort()))
            .build();
}
 

@Override
public HttpClientModel convert(String id, HttpClient model) {
    HttpClientModel converted = convert(model);
    converted.setId(id);
    return converted;
}
 

@Bean
public HttpClient todoApiClient() {
    return new HttpClientBuilder()
            .requestUrl(String.format("http://localhost:%s", integrationContainer.getServerPort()))
            .build();
}
 

@Bean
public HttpClient webHookClient() {
    return new HttpClientBuilder()
            .requestUrl(String.format("http://localhost:%s/webhook/test-webhook", integrationContainer.getServerPort()))
            .build();
}
 

@Bean
public HttpClient webHookClient() {
    return new HttpClientBuilder()
            .requestUrl(String.format("http://localhost:%s/webhook/test-webhook", integrationContainer.getServerPort()))
            .build();
}
 

@Bean
public HttpClient webHookClient() {
    return new HttpClientBuilder()
            .requestUrl(String.format("http://localhost:%s/webhook/test-webhook", integrationContainer.getServerPort()))
            .build();
}
 

public ValidateStarter(@Qualifier("simulatorHttpClientEndpoint") HttpClient client) {
    this.client = client;
}
 

public CalculateStarter(@Qualifier("simulatorHttpClientEndpoint") HttpClient client) {
    this.client = client;
}
 

@Bean
public HttpClient webHookClient() {
    return new HttpClientBuilder()
            .requestUrl(String.format("http://localhost:%s/webhook/test-webhook", integrationContainer.getServerPort()))
            .build();
}
 

@Bean
public HttpClient petstoreClient() {
    return CitrusEndpoints.http().client()
            .requestUrl(String.format("http://localhost:%s/petstore/v2", 8080))
            .build();
}
 

@Bean
public HttpClient simulatorUiClient() {
    return CitrusEndpoints.http().client()
            .requestUrl(String.format("http://localhost:%s", 8080))
            .build();
}
 

@Bean
public HttpClient webHookClient() {
    return new HttpClientBuilder()
            .requestUrl(String.format("http://localhost:%s/webhook/contact", integrationContainer.getServerPort()))
            .build();
}
 

@Bean
public HttpClient simulatorClient() {
    return CitrusEndpoints.http().client()
            .requestUrl(String.format("http://localhost:%s/services/rest/simulator", 8080))
            .build();
}
 

@Bean
public HttpClient webHookClient() {
    return new HttpClientBuilder()
            .requestUrl(String.format("http://localhost:%s/webhook/quickstart", integrationContainer.getServerPort()))
            .build();
}
 

@Bean
public HttpClient simulatorClient() {
    return CitrusEndpoints.http().client()
            .requestUrl(String.format("http://localhost:%s/services/rest/simulator", 8080))
            .build();
}