com.smartbear.readyapi.client.execution.ApiClientWrapper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ready-api-testserver-client Show documentation
Java client library for creating and executing test recipes against Ready!API TestServer
There is a newer version: 1.2.1
Show newest version
package com.smartbear.readyapi.client.execution;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.joda.JodaModule;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.GenericType;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.config.ClientConfig;
import com.sun.jersey.api.client.config.DefaultClientConfig;
import com.sun.jersey.client.urlconnection.HTTPSProperties;
import com.sun.jersey.multipart.FormDataMultiPart;
import com.sun.jersey.multipart.file.FileDataBodyPart;
import io.swagger.client.ApiClient;
import io.swagger.client.Pair;
import io.swagger.client.auth.Authentication;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.io.File;
import java.io.IOException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Most of this code is auto generated, with additional code for accepting self-signed server certificates.
 */
public class ApiClientWrapper extends ApiClient {

    private Client client;

    public  T invokeAPI(String path, String method, List queryParams, Object body, Map formParams, String accept, String contentType, String[] authNames, GenericType returnType) throws ApiException {
        Map headerParams = new HashMap<>();
        updateParamsForAuth(authNames, queryParams, headerParams);

        Client client = getClient();
        if (client == null) {
            throw new IllegalStateException("Could not create client instance");
        }

        StringBuilder b = new StringBuilder();
        b.append("?");
        if (queryParams != null) {
            for (Pair queryParam : queryParams) {
                if (!queryParam.getName().isEmpty()) {
                    b.append(escapeString(queryParam.getName()));
                    b.append("=");
                    b.append(escapeString(queryParam.getValue()));
                    b.append("&");
                }
            }
        }

        String querystring = b.substring(0, b.length() - 1);

        WebResource.Builder builder;
        if (accept == null) {
            builder = client.resource(getBasePath() + path + querystring).getRequestBuilder();
        } else {
            builder = client.resource(getBasePath() + path + querystring).accept(accept);
        }

        for (String key : headerParams.keySet()) {
            builder = builder.header(key, headerParams.get(key));
        }

        String encodedFormParams = null;
        if (contentType.startsWith("multipart/form-data")) {
            FormDataMultiPart mp = new FormDataMultiPart();
            for (Map.Entry param : formParams.entrySet()) {
                File file = param.getValue();
                mp.bodyPart(new FileDataBodyPart(param.getKey(), file, MediaType.APPLICATION_OCTET_STREAM_TYPE));
            }
            body = mp;
        }

        ClientResponse response = null;

        if ("GET".equals(method)) {
            response = (ClientResponse) builder.get(ClientResponse.class);
        } else if ("POST".equals(method)) {
            if (encodedFormParams != null) {
                response = builder.type(contentType).post(ClientResponse.class, encodedFormParams);
            } else if (body == null) {
                response = builder.post(ClientResponse.class, null);
            } else if (body instanceof FormDataMultiPart) {
                response = builder.type(contentType).post(ClientResponse.class, body);
            } else {
                response = builder.type(contentType).post(ClientResponse.class, serialize(body, contentType));
            }
        } else if ("PUT".equals(method)) {
            if (encodedFormParams != null) {
                response = builder.type(contentType).put(ClientResponse.class, encodedFormParams);
            } else if (body == null) {
                response = builder.put(ClientResponse.class, serialize(body, contentType));
            } else {
                response = builder.type(contentType).put(ClientResponse.class, serialize(body, contentType));
            }
        } else if ("DELETE".equals(method)) {
            if (encodedFormParams != null) {
                response = builder.type(contentType).delete(ClientResponse.class, encodedFormParams);
            } else if (body == null) {
                response = builder.delete(ClientResponse.class);
            } else {
                response = builder.type(contentType).delete(ClientResponse.class, serialize(body, contentType));
            }
        } else {
            throw new ApiException(500, "unknown method type " + method);
        }

        if (response.getStatusInfo() == ClientResponse.Status.NO_CONTENT) {
            return null;
        } else if (response.getStatusInfo().getFamily() == Response.Status.Family.SUCCESSFUL) {
            if (returnType == null) {
                return null;
            } else {
                return deserialize(response, returnType);
            }
        } else if (response.getStatusInfo().getStatusCode() == 429) {
            throw new UsageLimitException(response.getStatusInfo().getStatusCode(), getResponseBody(response),
                    response.getHeaders());
        } else {
            throw new ApiException(response.getStatusInfo().getStatusCode(), getResponseBody(response),
                    response.getHeaders());
        }
    }

    private String getResponseBody(ClientResponse response) {
        String respBody = null;
        if (response.hasEntity()) {
            try {
                respBody = String.valueOf(response.getEntity(String.class));
            } catch (RuntimeException e) {
                // e.printStackTrace();
            }
        }
        return respBody;
    }

    private Client getClient() {
        if (this.client == null) {
            try {
                ClientConfig clientConfig = getClientConfigWithoutCertificateValidation();
                this.client = Client.create(clientConfig);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (KeyManagementException e) {
                e.printStackTrace();
            }
        }
        return this.client;
    }

    public String serialize(Object obj, String contentType) throws ApiException {
        try {
            ObjectMapper mapper = getObjectMapper();
            mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
            if (contentType.startsWith("application/json")) {
                return mapper.writeValueAsString(obj);
            }
        } catch (JsonProcessingException e) {
            throw new ApiException(400, "can not serialize object into Content-Type: " + contentType);
        }
        return null;
    }

    public ObjectMapper getObjectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        mapper.registerModule(new JodaModule());
        return mapper;
    }

    private void updateParamsForAuth(String[] authNames, List queryParams, Map headerParams) {
        for (String authName : authNames) {
            Authentication auth = getAuthentications().get(authName);
            if (auth == null) {
                throw new RuntimeException("Authentication undefined: " + authName);
            }
            auth.applyToParams(queryParams, headerParams);
        }
    }

    public  T deserialize(ClientResponse response, GenericType returnType) throws ApiException {
        String contentType = null;
        List contentTypes = response.getHeaders().get("Content-Type");
        if (contentTypes != null && !contentTypes.isEmpty()) {
            contentType = contentTypes.get(0);
        }
        if (contentType == null) {
            throw new ApiException(500, "missing Content-Type in response");
        }

        String body = "";
        if (response.hasEntity()) {
            body = response.getEntity(String.class);
        }

        if (contentType.startsWith("application/json")) {
            return deserialize(returnType, body);
        } else {
            throw new ApiException(500, "can not deserialize Content-Type: " + contentType);
        }
    }

    private  T deserialize(GenericType returnType, String body) throws ApiException {
        ObjectMapper mapper = getObjectMapper();
        JavaType javaType = mapper.constructType(returnType.getType());
        try {
            return mapper.readValue(body, javaType);
        } catch (IOException e) {
            if (returnType.getType().equals(String.class)) {
                return (T) body;
            } else {
                throw new ApiException(500, e.getMessage());
            }
        }
    }

    private ClientConfig getClientConfigWithoutCertificateValidation() throws NoSuchAlgorithmException, KeyManagementException {

        SSLContext sslContext = SSLContext.getInstance("TLS");
        TrustManager[] certs = new TrustManager[]{
                new X509TrustManager() {
                    @Override
                    public X509Certificate[] getAcceptedIssuers() {
                        return null;
                    }

                    @Override
                    public void checkServerTrusted(X509Certificate[] chain, String authType)
                            throws CertificateException {
                    }

                    @Override
                    public void checkClientTrusted(X509Certificate[] chain, String authType)
                            throws CertificateException {
                    }
                }
        };
        sslContext.init(null, certs, new SecureRandom());

        HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());

        ClientConfig config = new DefaultClientConfig();
        config.getProperties().put(HTTPSProperties.PROPERTY_HTTPS_PROPERTIES,
                new HTTPSProperties(new HostnameVerifier() {

                    @Override
                    public boolean verify(String hostname, SSLSession session) {
                        return true;
                    }
                }, sslContext));

        return config;
    }
}