com.github.restdriver.clientdriver.ClientDriver Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rest-client-driver Show documentation
Test Driver to test your RESTful services
There is a newer version: 2.0.1
/**
 * Copyright © 2010-2011 Nokia
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.github.restdriver.clientdriver;

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

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.github.restdriver.clientdriver.exception.ClientDriverFailedExpectationException;
import com.github.restdriver.clientdriver.exception.ClientDriverInternalException;
import com.github.restdriver.clientdriver.exception.ClientDriverSetupException;
import com.github.restdriver.clientdriver.jetty.ClientDriverJettyHandler;

/**
 * The main class which acts as a facade for the Client Driver.
 */
public class ClientDriver {
    
    private static final Logger LOGGER = LoggerFactory.getLogger(ClientDriver.class);
    protected Server jettyServer;
    private ServerConnector jettyServerConnector;
    private int port = -1;
    private List listeners = new ArrayList();
    protected ClientDriverJettyHandler handler;
    
    /**
     * Constructor. This will find a free port, bind to it and start the server
     * up before it returns.
     * 
     * @param handler
     *            The {@link ClientDriverJettyHandler} to use.
     */
    public ClientDriver(ClientDriverJettyHandler handler) {
        this(handler, 0);
    }
    
    /**
     * Constructor. This will bind to the given port and start the server
     * up before it returns.
     * 
     * @param handler
     *            The {@link ClientDriverJettyHandler} to use.
     * @param port
     *            The port to listen on. Expect startup errors if this port is
     *            not free.
     */
    public ClientDriver(ClientDriverJettyHandler handler, int port) {
        this.handler = handler;
        this.jettyServer = createAndStartJetty(port);
    }

    /**
     * Convenience constructor for extending classes. This allows overwriting
     * and customization of the setup procedure.
     */
    protected ClientDriver() {

    }

    protected Server createAndStartJetty(int port) {
        Server jetty = new Server();
        jetty.setHandler(handler);
        ServerConnector connector = createConnector(jetty, port);
        jetty.addConnector(connector);
        try {
            jetty.start();
        } catch (Exception e) {
            throw new ClientDriverSetupException("Error starting jetty on port " + port, e);
        }
        this.port = connector.getLocalPort();
        this.jettyServerConnector = connector;
        return jetty;
    }

    protected SslContextFactory getSslContextFactory() {
        return null;
    }

    protected ServerConnector createConnector(Server jetty, int port) {
        ServerConnector connector = new ServerConnector(jetty, getSslContextFactory());
        connector.setHost(null);
        connector.setPort(port);
        return connector;
    }

    protected void replaceConnector(ServerConnector newConnector, Server jetty) {
        // get current connector and shut him down
        jettyServerConnector.shutdown();
        try {
            jettyServerConnector.stop();
        } catch (Exception e) {
            throw new ClientDriverInternalException("Error shutting down jetty connector during replacement", e);
        }
        jetty.removeConnector(jettyServerConnector);
        // add new and start him up
        jetty.addConnector(newConnector);
        try {
            newConnector.start();
        } catch (Exception e) {
            throw new ClientDriverInternalException("Error starting new jetty connector during replacement", e);
        }
    }
    
    public int getPort() {
        return port;
    }
    
    /**
     * Get the base URL which the ClientDriver is running on.
     * 
     * @return The base URL, which will be like "http://localhost:xxxx".
     *         There is no trailing slash on this
     */
    public String getBaseUrl() {
        return "http://localhost:" + port;
    }
    
    /**
     * Verifies that all expectations have been met and nothing unexpected has been requested.
     * 
     * If the verification fails, a {@link ClientDriverFailedExpectationException} is thrown with plenty of detail, and your test will fail!
     */
    public void verify() {
        LOGGER.info("Beginning verification");
        handler.checkForUnexpectedRequests();
        handler.checkForUnmatchedExpectations();
    }
    
    /**
     * Make the mock not fail fast on an unexpected request.
     */
    public void noFailFastOnUnexpectedRequest() {
        handler.noFailFastOnUnexpectedRequest();
    }
    
    /**
     * Resets the expectations and requests in the handler.
     */
    public void reset() {
        handler.reset();
    }
    
    /**
     * Shutdown the server without verifying expectations.
     */
    public void shutdownQuietly() {
        try {
            jettyServer.stop();
        } catch (Exception e) {
            throw new ClientDriverInternalException("Error shutting down jetty", e);
        } finally {
            completed();
        }
    }
    
    /**
     * Shutdown the server and calls {@link #verify()}.
     */
    public void shutdown() {
        shutdownQuietly();
        verify();
    }
    
    /**
     * Add in an expected {@link ClientDriverRequest}/{@link ClientDriverResponse} pair.
     * 
     * @param request
     *            The expected request
     * @param response
     *            The response to serve to that request
     * 
     * @return The newly added expectation.
     */
    public ClientDriverExpectation addExpectation(ClientDriverRequest request, ClientDriverResponse response) {
        return handler.addExpectation(request, response);
    }
    
    void addListener(ClientDriverListener listener) {
        listeners.add(listener);
    }
    
    private void completed() {
        for (ClientDriverListener listener : listeners) {
            listener.hasCompleted();
        }
    }
}