/*
HTTP stub server written in Java with embedded Jetty
Copyright (C) 2012 Alexander Zagniotov, Isa Goksu and Eric Mrak
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package io.github.azagniotov.stubby4j.client;
import io.github.azagniotov.stubby4j.annotations.CoberturaIgnore;
import io.github.azagniotov.stubby4j.cli.CommandLineInterpreter;
import io.github.azagniotov.stubby4j.http.StubbyHttpTransport;
import io.github.azagniotov.stubby4j.server.JettyFactory;
import io.github.azagniotov.stubby4j.server.StubbyManager;
import io.github.azagniotov.stubby4j.server.StubbyManagerFactory;
import io.github.azagniotov.stubby4j.stubs.StubHttpLifecycle;
import io.github.azagniotov.stubby4j.utils.ObjectUtils;
import io.github.azagniotov.stubby4j.yaml.YAMLParser;
import org.eclipse.jetty.http.HttpMethod;
import org.eclipse.jetty.http.HttpScheme;
import java.io.File;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public final class StubbyClient {
private static final ExecutorService EXECUTOR_SERVICE = Executors.newFixedThreadPool(1);
private StubbyManager stubbyManager;
public StubbyClient() {
}
/**
* Starts stubby using default ports of Stubs (8882), Admin (8889) and TlsStubs portals (7443) on localhost.
*
* @param yamlConfigurationFilename an absolute or relative file path for YAML stubs configuration file
* @throws Exception
*/
@CoberturaIgnore
public void startJetty(final String yamlConfigurationFilename) throws Exception {
startJetty(JettyFactory.DEFAULT_STUBS_PORT, JettyFactory.DEFAULT_SSL_PORT, JettyFactory.DEFAULT_ADMIN_PORT, JettyFactory.DEFAULT_HOST, yamlConfigurationFilename);
}
/**
* Starts stubby using default ports of Admin (8889) and TlsStubs portals (7443), and given Stubs portal port on localhost.
*
* @param stubsPort Stubs portal port
* @param yamlConfigurationFilename an absolute or relative file path for YAML stubs configuration file
* @throws Exception
*/
@CoberturaIgnore
public void startJetty(final int stubsPort, final String yamlConfigurationFilename) throws Exception {
startJetty(stubsPort, JettyFactory.DEFAULT_SSL_PORT, JettyFactory.DEFAULT_ADMIN_PORT, JettyFactory.DEFAULT_HOST, yamlConfigurationFilename);
}
/**
* Starts stubby using default port of TlsStubs (7443), and given Stubs and Admin portals ports on localhost.
*
* @param stubsPort Stubs portal port
* @param adminPort Admin portal port
* @param yamlConfigurationFilename an absolute or relative file path for YAML stubs configuration file
* @throws Exception
*/
@CoberturaIgnore
public void startJetty(final int stubsPort, final int adminPort, final String yamlConfigurationFilename) throws Exception {
startJetty(stubsPort, JettyFactory.DEFAULT_SSL_PORT, adminPort, JettyFactory.DEFAULT_HOST, yamlConfigurationFilename);
}
/**
* Starts stubby using given Stubs, TlsStubs and Admin portals ports on localhost.
*
* @param stubsPort Stubs portal port
* @param tlsPort TLS Stubs portal port
* @param adminPort Admin portal port
* @param yamlConfigurationFilename an absolute or relative file path for YAML stubs configuration file
* @throws Exception
*/
@CoberturaIgnore
public void startJetty(final int stubsPort, final int tlsPort, final int adminPort, final String yamlConfigurationFilename) throws Exception {
startJetty(stubsPort, tlsPort, adminPort, JettyFactory.DEFAULT_HOST, yamlConfigurationFilename);
}
/**
* Starts stubby using default port of TlsStubs (7443), and given Stubs and Admin portals ports on a given host address.
*
* @param stubsPort Stubs portal port
* @param adminPort Admin portal port
* @param addressToBind Address to bind Jetty
* @param yamlConfigurationFilename an absolute or relative file path for YAML stubs configuration file
* @throws Exception
*/
@CoberturaIgnore
public void startJetty(final int stubsPort, final int adminPort, final String addressToBind, final String yamlConfigurationFilename) throws Exception {
startJetty(stubsPort, JettyFactory.DEFAULT_SSL_PORT, adminPort, addressToBind, yamlConfigurationFilename);
}
/**
* Starts stubby using given Stubs, TlsStubs, Admin portals ports and host address.
*
* @param stubsPort Stubs portal port
* @param tlsPort TLS Stubs portal port
* @param adminPort Admin portal port
* @param addressToBind Address to bind Jetty
* @param yamlConfigurationFilename an absolute or relative file path for YAML stubs configuration file.
* @throws Exception
*/
@CoberturaIgnore
public void startJetty(final int stubsPort, final int tlsPort, final int adminPort, final String addressToBind, final String yamlConfigurationFilename) throws Exception {
final String[] args = new String[]{"-m", "-l", addressToBind, "-s", String.valueOf(stubsPort), "-a", String.valueOf(adminPort), "-t", String.valueOf(tlsPort)};
final CommandLineInterpreter commandLineInterpreter = new CommandLineInterpreter();
commandLineInterpreter.parseCommandLine(args);
final File configFile = new File(yamlConfigurationFilename);
final Future<List<StubHttpLifecycle>> stubLoadComputation =
EXECUTOR_SERVICE.submit(() -> new YAMLParser().parse(configFile.getParent(), configFile));
stubbyManager = new StubbyManagerFactory().construct(configFile, commandLineInterpreter.getCommandlineParams(), stubLoadComputation);
stubbyManager.startJetty();
}
/**
* Starts stubby using given Stubs, TlsStubs, Admin portals ports and host address without YAML configuration file.
*
* @param stubsPort Stubs portal port
* @param tlsPort TLS Stubs portal port
* @param adminPort Admin portal port
* @param addressToBind Address to bind Jetty
* @throws Exception
*/
@CoberturaIgnore
public void startJettyYamless(final int stubsPort, final int tlsPort, final int adminPort, final String addressToBind) throws Exception {
final String[] args = new String[]{"-m", "-l", addressToBind, "-s", String.valueOf(stubsPort), "-a", String.valueOf(adminPort), "-t", String.valueOf(tlsPort)};
final CommandLineInterpreter commandLineInterpreter = new CommandLineInterpreter();
commandLineInterpreter.parseCommandLine(args);
final URL url = StubbyClient.class.getResource("/yaml/empty-stub.yaml");
final File configFile = new File(url.getFile());
final Future<List<StubHttpLifecycle>> stubLoadComputation =
EXECUTOR_SERVICE.submit(() -> new YAMLParser().parse(configFile.getParent(), configFile));
stubbyManager = new StubbyManagerFactory().construct(configFile, commandLineInterpreter.getCommandlineParams(), stubLoadComputation);
stubbyManager.startJetty();
}
/**
* Stops Jetty if it is up
*
* @throws Exception
*/
@CoberturaIgnore
public void stopJetty() throws Exception {
if (ObjectUtils.isNotNull(stubbyManager)) {
stubbyManager.stopJetty();
}
}
/**
* Blocks until Jetty has finished
*
* @throws Exception
*/
@CoberturaIgnore
public void joinJetty() throws Exception {
if (ObjectUtils.isNotNull(stubbyManager)) {
stubbyManager.joinJetty();
}
}
/**
* Makes GET HTTP request to stubby
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param stubsPort port that stubby4j Stubs is running on
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doGet(final String host, final String uri, final int stubsPort) throws Exception {
return doGet(host, uri, stubsPort, null);
}
/**
* Makes GET HTTP request to stubby over TLS on stubby4j default TLS port: 7443
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doGetOverSsl(final String host, final String uri) throws Exception {
return doGetOverSsl(host, uri, JettyFactory.DEFAULT_SSL_PORT, null);
}
/**
* Makes GET HTTP request to stubby over TLS on stubby4j
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param port TLS port
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doGetOverSsl(final String host, final String uri, final int port) throws Exception {
return doGetOverSsl(host, uri, port, null);
}
/**
* Makes GET HTTP request to stubby over TLS on stubby4j default TLS port: 7443
* Also sets basic authorisation HTTP header using provided encoded credentials.
* The credentials should be base-64 encoded using the following format - username:password
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param port TLS port
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doGetOverSsl(final String host, final String uri, final int port, final Authorization authorization) throws Exception {
final StubbyRequest stubbyRequest = new StubbyRequest(HttpScheme.HTTPS.asString().toLowerCase(), HttpMethod.GET.asString(), uri, host, port, authorization);
return makeRequest(stubbyRequest);
}
/**
* Makes GET HTTP request to stubby
* Also sets basic authorisation HTTP header using provided encoded credentials.
* The credentials should be base-64 encoded using the following format - username:password
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param stubsPort port that stubby4j Stubs is running on
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doGet(final String host, final String uri, final int stubsPort, final Authorization authorization) throws Exception {
final StubbyRequest stubbyRequest = new StubbyRequest(HttpScheme.HTTP.asString().toLowerCase(), HttpMethod.GET.asString(), uri, host, stubsPort, authorization);
return makeRequest(stubbyRequest);
}
/**
* Makes GET HTTP request to stubby running on default host and port - localhost:8882
*
* @param uri URI for the HTTP request
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doGetUsingDefaults(final String uri) throws Exception {
return doGetUsingDefaults(uri, null);
}
/**
* Makes GET HTTP request to stubby running on default host and port - localhost:8882.
* Also sets basic authorisation HTTP header using provided encoded credentials.
* The credentials should be base-64 encoded using the following format - username:password
*
* @param uri URI for the HTTP request
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doGetUsingDefaults(final String uri, final Authorization authorization) throws Exception {
return doGet(JettyFactory.DEFAULT_HOST, uri, JettyFactory.DEFAULT_STUBS_PORT, authorization);
}
/**
* Makes POST HTTP request to stubby
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param stubsPort port that stubby4j Stubs is running on
* @param payload data to POST to the server
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doPost(final String host, final String uri, final int stubsPort, final String payload) throws Exception {
return doPost(host, uri, stubsPort, null, payload);
}
/**
* Makes POST HTTP request to stubby
* Also sets basic authorisation HTTP header using provided encoded credentials.
* The credentials should be base-64 encoded using the following format - username:password
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param stubsPort port that stubby4j Stubs is running on
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value
* @param payload data to POST to the server
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doPost(final String host, final String uri, final int stubsPort, final Authorization authorization, final String payload) throws Exception {
final StubbyRequest stubbyRequest = new StubbyRequest(HttpScheme.HTTP.asString().toLowerCase(), HttpMethod.POST.asString(), uri, host, stubsPort, authorization, payload);
return makeRequest(stubbyRequest);
}
/**
* Makes POST HTTP request to stubby running on default host and port - localhost:8882
*
* @param uri URI for the HTTP request
* @param payload data to POST to the server
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doPostUsingDefaults(final String uri, final String payload) throws Exception {
return doPostUsingDefaults(uri, payload, null);
}
/**
* Makes POST HTTP request to stubby running on default host and port - localhost:8882.
* Also sets basic authorisation HTTP header using provided encoded credentials.
* The credentials should be base-64 encoded using the following format - username:password
*
* @param uri URI for the HTTP request
* @param payload data to POST to the server
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doPostUsingDefaults(final String uri, final String payload, final Authorization authorization) throws Exception {
return doPost(JettyFactory.DEFAULT_HOST, uri, JettyFactory.DEFAULT_STUBS_PORT, authorization, payload);
}
/**
* Makes PUT HTTP request to stubby
* Also can set basic authorisation HTTP header using encoded credentials (if provided).
* The credentials should be base-64 encoded using the following format - username:password
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param stubsPort port that stubby4j Stubs is running on
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value (can be null)
* @param payload data to PUT to the server
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doPut(final String host, final String uri, final int stubsPort, final Authorization authorization, final String payload) throws Exception {
final StubbyRequest stubbyRequest = new StubbyRequest(HttpScheme.HTTP.asString().toLowerCase(), HttpMethod.PUT.asString(), uri, host, stubsPort, authorization, payload);
return makeRequest(stubbyRequest);
}
/**
* Makes PUT HTTP request to stubby over TLS on stubby4j default TLS port: 7443
* <p></p>
* Also can set basic authorisation HTTP header using encoded credentials (if provided).
* The credentials should be base-64 encoded using the following format - username:password
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param stubsPort port that stubby4j Stubs is running on
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value (can be null)
* @param payload data to PUT to the server
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doPutOverSsl(final String host, final String uri, final int stubsPort, final Authorization authorization, final String payload) throws Exception {
final StubbyRequest stubbyRequest = new StubbyRequest(HttpScheme.HTTPS.asString().toLowerCase(), HttpMethod.PUT.asString(), uri, host, stubsPort, authorization, payload);
return makeRequest(stubbyRequest);
}
/**
* Makes DELETE HTTP request to stubby
* Also can set basic authorisation HTTP header using encoded credentials (if provided).
* The credentials should be base-64 encoded using the following format - username:password
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param stubsPort port that stubby4j Stubs is running on
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value (can be null)
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doDelete(final String host, final String uri, final int stubsPort, final Authorization authorization) throws Exception {
final StubbyRequest stubbyRequest = new StubbyRequest(HttpScheme.HTTP.asString().toLowerCase(), HttpMethod.DELETE.asString(), uri, host, stubsPort, authorization);
return makeRequest(stubbyRequest);
}
/**
* Makes DELETE HTTP request to stubby over TLS on stubby4j default TLS port: 7443
* <p></p>
* Also can set basic authorisation HTTP header using encoded credentials (if provided).
* The credentials should be base-64 encoded using the following format - username:password
*
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param port TLS port
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse doDeleteOverSsl(final String host, final String uri, final int port, final Authorization authorization) throws Exception {
final StubbyRequest stubbyRequest = new StubbyRequest(HttpScheme.HTTPS.asString().toLowerCase(), HttpMethod.DELETE.asString(), uri, host, port, authorization);
return makeRequest(stubbyRequest);
}
/**
* Updated stubbed data with new data. This method creates a POST request to Admin portal
*
* @param url fully constructed URL which included HTTP scheme, host and port
* @param stubsData data to post
*/
@CoberturaIgnore
public StubbyResponse updateStubbedData(final String url, final String stubsData) throws Exception {
final URL adminUrl = new URL(url);
return makeRequest(adminUrl.getProtocol(), HttpMethod.POST.asString(), adminUrl.getHost(), adminUrl.getPath(), adminUrl.getPort(), stubsData);
}
/**
* Makes HTTP request to stubby.
*
* @param scheme HTTP protocol scheme, HTTP or HTTPS
* @param method HTTP method, currently supported: GET, HEAD, PUT, POST
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param port port that stubby4j Stubs is running on
* @param post data to POST to the server
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse makeRequest(final String scheme,
final String method,
final String host,
final String uri,
final int port,
final String post) throws Exception {
return makeRequest(scheme, method, host, uri, port, post, null);
}
/**
* Makes HTTP request to stubby.
*
* @param scheme HTTP protocol scheme, HTTP or HTTPS
* @param method HTTP method, currently supported: GET, HEAD, PUT, POST
* @param host host that stubby4j is running on
* @param uri URI for the HTTP request
* @param port port that stubby4j Stubs is running on
* @param post data to POST to the server
* @param authorization {@link Authorization} object holding the HTTP header authorization type and value
* @return StubbyResponse with HTTP status code and message from the server
* @throws Exception
*/
@CoberturaIgnore
public StubbyResponse makeRequest(final String scheme,
final String method,
final String host,
final String uri,
final int port,
final String post,
final Authorization authorization) throws Exception {
final StubbyRequest stubbyRequest = new StubbyRequest(scheme, method, uri, host, port, authorization, post);
return makeRequest(stubbyRequest);
}
private StubbyResponse makeRequest(final StubbyRequest stubbyRequest) throws Exception {
final Map<String, String> headers = new HashMap<>();
if (ObjectUtils.isNotNull(stubbyRequest.getAuthorization())) {
headers.put("Authorization", stubbyRequest.getAuthorization().asFullValue());
}
return new StubbyHttpTransport().getResponse(
stubbyRequest.getMethod(),
stubbyRequest.constructFullUrl(),
stubbyRequest.getPost(),
headers,
stubbyRequest.calculatePostLength());
}
}