wicket.protocol.http.MockServletContext.java Source code

Java tutorial

Introduction

Here is the source code for wicket.protocol.http.MockServletContext.java

Source

/*
 * $Id: MockServletContext.java 5844 2006-05-24 20:53:56 +0000 (Wed, 24 May
 * 2006) joco01 $ $Revision: 6318 $ $Date: 2006-05-24 20:53:56 +0000 (Wed, 24
 * May 2006) $
 * 
 * ==============================================================================
 * 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 wicket.protocol.http;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.servlet.RequestDispatcher;
import javax.servlet.Servlet;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import wicket.Application;
import wicket.util.value.ValueMap;

/**
 * Mock implementation of the servlet context for testing purposes. This
 * implementation supports all of the standard context methods except that
 * request dispatching just indicates what is being dispatched to, rather than
 * doing the actual dispatch.
 * <p>
 * The context can be configured with a path parameter that should point to an
 * absolute directory location that represents the place where the contents of
 * the WAR bundle are located. Setting this value allows all of the resource
 * location functionality to work as in a fully functioning web application.
 * This value is not set then not resource location functionality will work and
 * instead null will always be returned.
 * 
 * @author Chris Turner
 */
public class MockServletContext implements ServletContext {
    private static final Log log = LogFactory.getLog(MockServletContext.class);

    private Application application;

    private Map<String, Object> attributes = new HashMap<String, Object>();

    private ValueMap initParameters = new ValueMap();

    /** Map of mime types */
    private final ValueMap mimeTypes = new ValueMap();

    private File webappRoot;

    /**
     * Create the mock object. As part of the creation, the context ets the root
     * directory where web application content is stored. This must be an
     * ABSOLUTE directory relative to where the tests are being executed. For
     * example: <code>System.getProperty("user.dir") +
     * "/src/webapp"</code>
     * 
     * @param application
     *            The application that this context is for
     * @param path
     *            The path to the root of the web application
     */
    public MockServletContext(final Application application, final String path) {
        this.application = application;

        webappRoot = null;
        if (path != null) {
            webappRoot = new File(path);
            if (!webappRoot.exists() || !webappRoot.isDirectory()) {
                log.warn("WARNING: The webapp root directory is invalid: " + path);
                webappRoot = null;
            }
        }

        mimeTypes.put("html", "text/html");
        mimeTypes.put("htm", "text/html");
        mimeTypes.put("css", "text/css");
        mimeTypes.put("xml", "text/xml");
        mimeTypes.put("js", "text/plain");
        mimeTypes.put("gif", "image/gif");
        mimeTypes.put("jpg", "image/jpeg");
        mimeTypes.put("png", "image/png");
    }

    /**
     * Add an init parameter.
     * 
     * @param name
     *            The parameter name
     * @param value
     *            The parameter value
     */
    public void addInitParameter(final String name, final String value) {
        initParameters.put(name, value);
    }

    // Configuration methods

    /**
     * Add a new recognised mime type.
     * 
     * @param fileExtension
     *            The file extension (e.g. "jpg")
     * @param mimeType
     *            The mime type (e.g. "image/jpeg")
     */
    public void addMimeType(final String fileExtension, final String mimeType) {
        mimeTypes.put(fileExtension, mimeType);
    }

    /**
     * Get an attribute with the given name.
     * 
     * @param name
     *            The attribute name
     * @return The value, or null
     */
    public Object getAttribute(final String name) {
        return attributes.get(name);
    }

    /**
     * Get all of the attribute names.
     * 
     * @return The attribute names
     */
    public Enumeration<String> getAttributeNames() {
        return Collections.enumeration(attributes.keySet());
    }

    // ServletContext interface methods

    /**
     * Get the context for the given URL path
     * 
     * @param name
     *            The url path
     * @return Always returns this
     */
    public ServletContext getContext(String name) {
        return this;
    }

    /**
     * Get the init parameter with the given name.
     * 
     * @param name
     *            The name
     * @return The parameter, or null if no such parameter
     */
    public String getInitParameter(final String name) {
        return initParameters.getString(name);
    }

    /**
     * Get the name of all of the init parameters.
     * 
     * @return The init parameter names
     */
    public Enumeration<String> getInitParameterNames() {
        return Collections.enumeration(initParameters.keySet());
    }

    /**
     * @return Always 2
     */
    public int getMajorVersion() {
        return 2;
    }

    /**
     * Get the mime type for the given file. Uses a hardcoded map of mime types
     * set at initialisation time.
     * 
     * @param name
     *            The name to get the mime type for
     * @return The mime type
     */
    public String getMimeType(final String name) {
        int index = name.lastIndexOf('.');
        if (index == -1 || index == (name.length() - 1)) {
            return null;
        } else {
            return mimeTypes.getString(name.substring(index + 1));
        }
    }

    /**
     * @return Always 3
     */
    public int getMinorVersion() {
        return 3;
    }

    /**
     * Wicket does not use the RequestDispatcher, so this implementation just
     * returns a dummy value.
     * 
     * @param name
     *            The name of the servlet or JSP
     * @return The dispatcher
     */
    public RequestDispatcher getNamedDispatcher(final String name) {
        return getRequestDispatcher(name);
    }

    /**
     * Get the real file path of the given resource name.
     * 
     * @param name
     *            The name
     * @return The real path or null
     */
    public String getRealPath(String name) {
        if (webappRoot == null) {
            return null;
        }

        if (name.startsWith("/")) {
            name = name.substring(1);
        }

        File f = new File(webappRoot, name);
        if (!f.exists()) {
            return null;
        } else {
            return f.getPath();
        }
    }

    /**
     * Wicket does not use the RequestDispatcher, so this implementation just
     * returns a dummy value.
     * 
     * @param name
     *            The name of the resource to get the dispatcher for
     * @return The dispatcher
     */
    public RequestDispatcher getRequestDispatcher(final String name) {
        return new RequestDispatcher() {
            public void forward(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException {
                servletResponse.getWriter().write("FORWARD TO RESOURCE: " + name);
            }

            public void include(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException {
                servletResponse.getWriter().write("INCLUDE OF RESOURCE: " + name);
            }
        };
    }

    /**
     * Get the URL for a particular resource that is relative to the web app
     * root directory.
     * 
     * @param name
     *            The name of the resource to get
     * @return The resource, or null if resource not found
     * @throws MalformedURLException
     *             If the URL is invalid
     */
    public URL getResource(String name) throws MalformedURLException {
        if (webappRoot == null) {
            return null;
        }

        if (name.startsWith("/")) {
            name = name.substring(1);
        }

        File f = new File(webappRoot, name);
        if (!f.exists()) {
            return null;
        } else {
            return f.toURI().toURL();
        }
    }

    /**
     * Get an input stream for a particular resource that is relative to the web
     * app root directory.
     * 
     * @param name
     *            The name of the resource to get
     * @return The input stream for the resource, or null of resource is not
     *         found
     */
    public InputStream getResourceAsStream(String name) {
        if (webappRoot == null) {
            return null;
        }

        if (name.startsWith("/")) {
            name = name.substring(1);
        }

        File f = new File(webappRoot, name);
        if (!f.exists()) {
            return null;
        } else {
            try {
                return new FileInputStream(f);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
                return null;
            }
        }
    }

    /**
     * Get the resource paths starting from the web app root directory and then
     * relative to the the given name.
     * 
     * @param name
     *            The starting name
     * @return The set of resource paths at this location
     */
    public Set<String> getResourcePaths(String name) {
        if (webappRoot == null) {
            return new HashSet<String>();
        }

        if (name.startsWith("/")) {
            name = name.substring(1);
        }
        if (name.endsWith("/")) {
            name = name.substring(0, name.length() - 1);
        }
        String[] elements = null;
        if (name.trim().length() == 0) {
            elements = new String[0];
        } else {
            elements = name.split("/");
        }

        File current = webappRoot;
        for (String element : elements) {
            File[] files = current.listFiles();
            boolean match = false;
            for (File element0 : files) {
                if (element0.getName().equals(element) && element0.isDirectory()) {
                    current = element0;
                    match = true;
                    break;
                }
            }
            if (!match) {
                return null;
            }
        }

        File[] files = current.listFiles();
        Set<String> result = new HashSet<String>();
        int stripLength = webappRoot.getPath().length();
        for (File element : files) {
            String s = element.getPath().substring(stripLength).replace('\\', '/');
            if (element.isDirectory()) {
                s = s + "/";
            }
            result.add(s);
        }
        return result;
    }

    /**
     * Get the server info.
     * 
     * @return The server info
     */
    public String getServerInfo() {
        return "Wicket Mock Test Environment v1.0";
    }

    /**
     * NOT USED - Servlet Spec requires that this always returns null.
     * 
     * @param name
     *            Not used
     * @return null
     * @throws ServletException
     *             Not used
     */
    public Servlet getServlet(String name) throws ServletException {
        return null;
    }

    /**
     * Return the name of the servlet context.
     * 
     * @return The name
     */
    public String getServletContextName() {
        return application.getName();
    }

    /**
     * NOT USED - Servlet spec requires that this always returns null.
     * 
     * @return null
     */
    public Enumeration getServletNames() {
        return null;
    }

    /**
     * NOT USED - Servlet spec requires that this always returns null.
     * 
     * @return null
     */
    public Enumeration getServlets() {
        return null;
    }

    /**
     * As part of testing we always log to the console.
     * 
     * @param e
     *            The exception to log
     * @param msg
     *            The message to log
     */
    public void log(Exception e, String msg) {
        log.error(msg, e);
    }

    /**
     * As part of testing we always log to the console.
     * 
     * @param msg
     *            The message to log
     */
    public void log(String msg) {
        log.info(msg);
    }

    /**
     * As part of testing we always log to the console.
     * 
     * @param msg
     *            The message to log
     * @param cause
     *            The cause exception
     */
    public void log(String msg, Throwable cause) {
        log.error(msg, cause);
    }

    /**
     * Remove an attribute with the given name.
     * 
     * @param name
     *            The name
     */
    public void removeAttribute(final String name) {
        attributes.remove(name);
    }

    /**
     * Set an attribute.
     * 
     * @param name
     *            The name of the attribute
     * @param o
     *            The value
     */
    public void setAttribute(final String name, final Object o) {
        attributes.put(name, o);
    }
}