/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.wicket.protocol.http.mock;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.security.Principal;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import javax.servlet.AsyncContext;
import javax.servlet.DispatcherType;
import javax.servlet.ReadListener;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpUpgradeHandler;
import javax.servlet.http.Part;
import org.apache.commons.fileupload.FileUploadBase;
import org.apache.wicket.Application;
import org.apache.wicket.WicketRuntimeException;
import org.apache.wicket.mock.MockRequestParameters;
import org.apache.wicket.request.Url;
import org.apache.wicket.request.Url.QueryParameter;
import org.apache.wicket.util.encoding.UrlDecoder;
import org.apache.wicket.util.encoding.UrlEncoder;
import org.apache.wicket.util.file.File;
import org.apache.wicket.util.io.IOUtils;
import org.apache.wicket.util.string.StringValue;
import org.apache.wicket.util.string.Strings;
import org.apache.wicket.util.value.ValueMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Mock servlet request. Implements all of the methods from the standard HttpServletRequest class
* plus helper methods to aid setting up a request.
*
* @author Chris Turner
*/
public class MockHttpServletRequest implements HttpServletRequest
{
/**
* A holder class for an uploaded file.
*
* @author Frank Bille (billen)
*/
private static class UploadedFile
{
private String fieldName;
private File file;
private String contentType;
/**
* Construct.
*
* @param fieldName
* @param file
* @param contentType
*/
public UploadedFile(String fieldName, File file, String contentType)
{
this.fieldName = fieldName;
this.file = file;
this.contentType = contentType;
}
/**
* @return The content type of the file. Mime type.
*/
public String getContentType()
{
return contentType;
}
/**
* @param contentType
* The content type.
*/
public void setContentType(String contentType)
{
this.contentType = contentType;
}
/**
* @return The field name.
*/
public String getFieldName()
{
return fieldName;
}
/**
* @param fieldName
*/
public void setFieldName(String fieldName)
{
this.fieldName = fieldName;
}
/**
* @return The uploaded file.
*/
public File getFile()
{
return file;
}
/**
* @param file
*/
public void setFile(File file)
{
this.file = file;
}
}
/** Logging object */
private static final Logger log = LoggerFactory.getLogger(MockHttpServletRequest.class);
/** The application */
private final Application application;
private final ValueMap attributes = new ValueMap();
private String authType;
private String characterEncoding = "UTF-8";
private final ServletContext context;
private final Map<Cookies.Key, Cookie> cookies = new LinkedHashMap<>();
private final ValueMap headers = new ValueMap();
private String method;
private final LinkedHashMap<String, String[]> parameters = new LinkedHashMap<>();
private final LinkedHashMap<String, Part> parts = new LinkedHashMap<>();
private String path;
private final HttpSession session;
private String url;
private Map<String, List<UploadedFile>> uploadedFiles;
private boolean useMultiPartContentType;
private boolean secure = false;
private String remoteAddr = "127.0.0.1";
private String scheme = "http";
private String serverName = "localhost";
private int serverPort = 80;
/**
* Create the request using the supplied session object. Note that in order for temporary
* sessions to work, the supplied session must be an instance of {@link MockHttpSession}
*
* @param application
* The application that this request is for
* @param session
* The session object
* @param context
* The current servlet context
* @param locale
* The current locale
*/
public MockHttpServletRequest(final Application application, final HttpSession session,
final ServletContext context, Locale locale)
{
this.application = application;
this.session = session;
this.context = context;
initialize(locale);
}
public MockHttpServletRequest(final Application application, final HttpSession session,
final ServletContext context)
{
this(application, session, context, Locale.getDefault());
}
/**
* Add a new cookie.
*
* @param cookie
* The cookie
*/
public void addCookie(final Cookie cookie)
{
cookies.put(Cookies.keyOf(cookie), cookie);
}
/**
* @param cookies
*/
public void addCookies(Iterable<Cookie> cookies)
{
for (Cookie cookie : cookies)
{
addCookie(cookie);
}
}
/**
* Add an uploaded file to the request. Use this to simulate a file that has been uploaded to a
* field.
*
* @param fieldName
* The fieldname of the upload field.
* @param file
* The file to upload.
* @param contentType
* The content type of the file. Must be a correct mimetype.
*/
public void addFile(String fieldName, File file, String contentType)
{
if (file != null) {
if (file.exists() == false)
{
throw new IllegalArgumentException(
"File does not exists. You must provide an existing file: "
+ file.getAbsolutePath());
}
if (file.isFile() == false)
{
throw new IllegalArgumentException(
"You can only add a File, which is not a directory. Only files can be uploaded.");
}
}
if (uploadedFiles == null)
{
uploadedFiles = new HashMap<>();
}
UploadedFile uf = new UploadedFile(fieldName, file, contentType);
List<UploadedFile> filesPerField = uploadedFiles.get(fieldName);
if (filesPerField == null)
{
filesPerField = new ArrayList<>();
uploadedFiles.put(fieldName, filesPerField);
}
filesPerField.add(uf);
setUseMultiPartContentType(true);
}
/**
* Add a header to the request.
*
* @param name
* The name of the header to add
* @param value
* The value
*/
public void addHeader(String name, String value)
{
@SuppressWarnings("unchecked")
List<String> list = (List<String>)headers.get(name);
if (list == null)
{
list = new ArrayList<>(1);
headers.put(name, list);
}
list.add(value);
}
/**
* Sets a header to the request. Overrides any previous value of this header.
*
* @param name
* The name of the header to add
* @param value
* The value
* @see #addHeader(String, String)
*/
public void setHeader(String name, String value)
{
@SuppressWarnings("unchecked")
List<String> list = (List<String>)headers.get(name);
if (list == null)
{
list = new ArrayList<>(1);
headers.put(name, list);
}
list.clear();
list.add(value);
}
/**
* @param name
* @param date
*/
public void addDateHeader(String name, long date)
{
DateFormat df = DateFormat.getDateInstance(DateFormat.FULL);
String dateString = df.format(new Date(date));
addHeader(name, dateString);
}
/**
* Get an attribute.
*
* @param name
* The attribute name
* @return The value, or null
*/
@Override
public Object getAttribute(final String name)
{
return attributes.get(name);
}
/**
* Get the names of all of the values.
*
* @return The names
*/
@Override
public Enumeration<String> getAttributeNames()
{
return Collections.enumeration(attributes.keySet());
}
// HttpServletRequest methods
/**
* Get the auth type.
*
* @return The auth type
*/
@Override
public String getAuthType()
{
return authType;
}
/**
* Get the current character encoding.
*
* @return The character encoding
*/
@Override
public String getCharacterEncoding()
{
return characterEncoding;
}
/**
* Get the current character set.
*
* @return The character set
*/
public Charset getCharset()
{
return Charset.forName(characterEncoding);
}
/**
* true will force Request generate multiPart ContentType and ContentLength
*
* @param useMultiPartContentType
*/
public void setUseMultiPartContentType(boolean useMultiPartContentType)
{
this.useMultiPartContentType = useMultiPartContentType;
}
/**
* Return the length of the content. This is always -1 except if useMultiPartContentType set as
* true. Then the length will be the length of the generated request.
*
* @return -1 if useMultiPartContentType is false. Else the length of the generated request.
*/
@Override
public int getContentLength()
{
if (useMultiPartContentType)
{
byte[] request = buildRequest();
return request.length;
}
return -1;
}
@Override
public long getContentLengthLong()
{
return getContentLength();
}
/**
* If useMultiPartContentType set as true return the correct content-type.
*
* @return The correct multipart content-type if useMultiPartContentType is true. Else null.
*/
@Override
public String getContentType()
{
if (useMultiPartContentType)
{
return FileUploadBase.MULTIPART_FORM_DATA + "; boundary=abcdefgABCDEFG";
}
return null;
}
/**
* Get the context path. For this mock implementation the name of the application is always
* returned.
*
* @return The context path
*/
@Override
public String getContextPath()
{
// return "/" + application.getName();
return "/context";
}
/**
* @param name
* @return Cookie
*/
public Cookie getCookie(String name)
{
Cookie[] cookies = getCookies();
if (cookies == null)
{
return null;
}
for (Cookie cookie : cookies)
{
if (cookie.getName().equals(name))
{
return Cookies.copyOf(cookie);
}
}
return null;
}
/**
* Get all of the cookies for this request.
*
* @return The cookies
*/
@Override
public Cookie[] getCookies()
{
if (cookies.isEmpty())
{
return null;
}
List<Cookie> cookieValues = new ArrayList<Cookie>();
cookieValues.addAll(cookies.values());
return cookieValues.toArray(new Cookie[cookieValues.size()]);
}
/**
* Get the given header as a date.
*
* @param name
* The header name
* @return The date, or -1 if header not found
* @throws IllegalArgumentException
* If the header cannot be converted
*/
@Override
public long getDateHeader(final String name) throws IllegalArgumentException
{
String value = getHeader(name);
if (value == null)
{
return -1;
}
DateFormat df = DateFormat.getDateInstance(DateFormat.FULL);
try
{
return df.parse(value).getTime();
}
catch (ParseException e)
{
throw new IllegalArgumentException("Can't convert header to date " + name + ": "
+ value);
}
}
/**
* Get the given header value.
*
* @param name
* The header name
* @return The header value or null
*/
@Override
public String getHeader(final String name)
{
@SuppressWarnings("unchecked")
final List<String> l = (List<String>)headers.get(name);
if (l == null || l.size() < 1)
{
return null;
}
else
{
return l.get(0);
}
}
/**
* Get the names of all of the headers.
*
* @return The header names
*/
@Override
public Enumeration<String> getHeaderNames()
{
return Collections.enumeration(headers.keySet());
}
/**
* Get enumeration of all header values with the given name.
*
* @param name
* The name
* @return The header values
*/
@Override
public Enumeration<String> getHeaders(final String name)
{
@SuppressWarnings("unchecked")
List<String> list = (List<String>)headers.get(name);
if (list == null)
{
list = new ArrayList<String>();
}
return Collections.enumeration(list);
}
/**
* Returns an input stream if there has been added some uploaded files. Use
* {@link #addFile(String, File, String)} to add some uploaded files.
*
* @return The input stream
* @throws IOException
* If an I/O related problem occurs
*/
@Override
public ServletInputStream getInputStream() throws IOException
{
byte[] request = buildRequest();
// Ok lets make an input stream to return
final ByteArrayInputStream bais = new ByteArrayInputStream(request);
return new ServletInputStream()
{
private boolean isFinished = false;
private boolean isReady = true;
@Override
public boolean isFinished()
{
return isFinished;
}
@Override
public boolean isReady()
{
return isReady;
}
@Override
public void setReadListener(ReadListener readListener)
{
}
@Override
public int read()
{
isFinished = true;
isReady = false;
return bais.read();
}
};
}
/**
* Get the given header as an int.
*
* @param name
* The header name
* @return The header value or -1 if header not found
* @throws NumberFormatException
* If the header is not formatted correctly
*/
@Override
public int getIntHeader(final String name)
{
String value = getHeader(name);
if (value == null)
{
return -1;
}
return Integer.valueOf(value);
}
/**
* Get the locale of the request. Attempts to decode the Accept-Language header and if not found
* returns the default locale of the JVM.
*
* @return The locale
*/
@Override
public Locale getLocale()
{
return getLocales().nextElement();
}
public void setLocale(Locale locale) {
setHeader("Accept-Language", locale.getLanguage() + '-' + locale.getCountry());
}
/**
*
* @param value
* @return locale
*/
private Locale getLocale(final String value)
{
final String[] bits = Strings.split(value, '-');
if (bits.length < 1)
{
return null;
}
final String language = bits[0].toLowerCase();
if (bits.length > 1)
{
final String country = bits[1].toUpperCase();
return new Locale(language, country);
}
else
{
return new Locale(language);
}
}
/**
* Return all the accepted locales. This implementation always returns just one.
*
* @return The locales
*/
@Override
public Enumeration<Locale> getLocales()
{
List<Locale> list = new ArrayList<>();
String header = getHeader("Accept-Language");
if (header != null)
{
int idxOfSemicolon = header.indexOf(';');
if (idxOfSemicolon > -1) {
header = header.substring(0 , idxOfSemicolon);
}
final String[] locales = Strings.split(header, ',');
for (String value : locales)
{
Locale locale = getLocale(value);
if (locale != null)
{
list.add(locale);
}
}
}
if (list.size() == 0)
{
list.add(Locale.getDefault());
}
return Collections.enumeration(list);
}
/**
* Get the method.
*
* @return The method
*/
@Override
public String getMethod()
{
return method;
}
/**
* Get the request parameter with the given name.
*
* @param name
* The parameter name
* @return The parameter value, or null
*/
@Override
public String getParameter(final String name)
{
String[] param = getParameterMap().get(name);
if (param == null)
{
return null;
}
else
{
return param[0];
}
}
/**
* Get the map of all of the parameters.
*
* @return The parameters
*/
@Override
public Map<String, String[]> getParameterMap()
{
Map<String, String[]> params = new HashMap<>(parameters);
for (String name : post.getParameterNames())
{
List<StringValue> values = post.getParameterValues(name);
for (StringValue value : values)
{
String[] present = params.get(name);
if (present == null)
{
params.put(name, new String[] { value.toString() });
}
else
{
String[] newval = new String[present.length + 1];
System.arraycopy(present, 0, newval, 0, present.length);
newval[newval.length - 1] = value.toString();
params.put(name, newval);
}
}
}
return params;
}
/**
* Get the names of all of the parameters.
*
* @return The parameter names
*/
@Override
public Enumeration<String> getParameterNames()
{
return Collections.enumeration(getParameterMap().keySet());
}
/**
* Get the values for the given parameter.
*
* @param name
* The name of the parameter
* @return The return values
*/
@Override
public String[] getParameterValues(final String name)
{
Object value = getParameterMap().get(name);
if (value == null)
{
return new String[0];
}
if (value instanceof String[])
{
return (String[])value;
}
else
{
String[] result = new String[1];
result[0] = value.toString();
return result;
}
}
/**
* Get the path info.
*
* @return The path info
*/
@Override
public String getPathInfo()
{
return path;
}
/**
* Always returns null.
*
* @return null
*/
@Override
public String getPathTranslated()
{
return null;
}
/**
* Get the protocol.
*
* @return Always HTTP/1.1
*/
@Override
public String getProtocol()
{
return "HTTP/1.1";
}
/**
* Get the query string part of the request.
*
* @return The query string
*/
@Override
public String getQueryString()
{
if (parameters.size() == 0)
{
return null;
}
else
{
final StringBuilder buf = new StringBuilder();
for (Iterator<String> iterator = parameters.keySet().iterator(); iterator.hasNext();)
{
final String name = iterator.next();
final String[] values = getParameterValues(name);
for (int i = 0; i < values.length; i++)
{
if (name != null)
{
buf.append(UrlEncoder.QUERY_INSTANCE.encode(name, getCharset()));
}
buf.append('=');
if (values[i] != null)
{
buf.append(UrlEncoder.QUERY_INSTANCE.encode(values[i], getCharset()));
}
if (i + 1 < values.length)
{
buf.append('&');
}
}
if (iterator.hasNext())
{
buf.append('&');
}
}
return buf.toString();
}
}
/**
* This feature is not implemented at this time as we are not supporting binary servlet input.
* This functionality may be added in the future.
*
* @return The reader
* @throws IOException
* If an I/O related problem occurs
*/
@Override
public BufferedReader getReader() throws IOException
{
return new BufferedReader(new InputStreamReader(getInputStream()));
}
/**
* Deprecated method - should not be used.
*
* @param name
* The name
* @return The path
* @deprecated Use ServletContext.getRealPath(String) instead.
*/
@Override
@Deprecated
public String getRealPath(String name)
{
return context.getRealPath(name);
}
/**
* @return the remote address of the client
*/
@Override
public String getRemoteAddr()
{
return remoteAddr;
}
/**
*
* @param addr
* Format: "aaa.bbb.ccc.ddd"
*/
public void setRemoteAddr(String addr)
{
remoteAddr = addr;
}
/**
* Get the remote host.
*
* @return Return 'localhost' by default
*/
@Override
public String getRemoteHost()
{
return "localhost";
}
/**
* Get the name of the remote user from the REMOTE_USER header.
*
* @return The name of the remote user
*/
@Override
public String getRemoteUser()
{
return getHeader("REMOTE_USER");
}
/**
* Return a dummy dispatcher that just records that dispatch has occurred without actually doing
* anything.
*
* @param name
* The name to dispatch to
* @return The dispatcher
*/
@Override
public RequestDispatcher getRequestDispatcher(String name)
{
return context.getRequestDispatcher(name);
}
/**
* Get the requested session id. Always returns the id of the current session.
*
* @return The session id
*/
@Override
public String getRequestedSessionId()
{
if (session instanceof MockHttpSession && ((MockHttpSession)session).isTemporary())
{
return null;
}
return session.getId();
}
/**
* Returns context path and servlet path concatenated, typically
* /applicationClassName/applicationClassName
*
* @return The path value
* @see javax.servlet.http.HttpServletRequest#getRequestURI()
*/
@Override
public String getRequestURI()
{
if (url == null)
{
return getContextPath() + getServletPath();
}
else
{
int index = url.indexOf("?");
if (index != -1)
{
return url.substring(0, index);
}
}
return url;
}
/**
* Try to build a rough URL.
*
* @return The url
* @see javax.servlet.http.HttpServletRequest#getRequestURL()
*/
@Override
public StringBuffer getRequestURL()
{
StringBuffer buf = new StringBuffer();
buf.append("http://localhost");
buf.append(getContextPath());
if (getPathInfo() != null)
{
buf.append(getPathInfo());
}
// No query parameter. See
// http://download.oracle.com/javaee/5/api/javax/servlet/http/HttpServletRequest.html#getRequestURL()
return buf;
}
/**
* Get the scheme.
*
* @return the scheme of this request
*/
@Override
public String getScheme()
{
return scheme;
}
/**
* Sets the scheme of this request
* <p/>
* set the <code>secure</code> flag accordingly (<code>true</code> for 'https',
* <code>false</code> otherwise)
*
* @param scheme
* protocol scheme (e.g. https, http, ftp)
*
* @see #isSecure()
*/
public void setScheme(String scheme)
{
this.scheme = scheme;
secure = "https".equalsIgnoreCase(scheme);
}
/**
* Get the server name.
*
* @return by default returns 'localhost'
*/
@Override
public String getServerName()
{
return serverName;
}
/**
* Set the server name.
*
* @param serverName
* content of 'Host' header
*/
public void setServerName(final String serverName)
{
this.serverName = serverName;
}
/**
* @return the server port of this request
*/
@Override
public int getServerPort()
{
return serverPort;
}
/**
* Sets the server port for this request
*
* @param port
*/
public void setServerPort(int port)
{
serverPort = port;
}
/**
* The servlet path may either be the application name or /. For test purposes we always return
* the servlet name.
*
* @return The servlet path
*/
@Override
public String getServletPath()
{
return "/servlet";
}
/**
* Get the sessions.
*
* @return The session
*/
@Override
public HttpSession getSession()
{
return getSession(true);
}
@Override
public String changeSessionId()
{
final HttpSession oldSession = getSession(false);
if (oldSession == null)
{
throw new IllegalStateException("There is no active session associated with the current request");
}
oldSession.invalidate();
final HttpSession newSession = getSession(true);
return newSession.getId();
}
/**
* Get the session.
*
* @param b
* Ignored, there is always a session
* @return The session
*/
@Override
public HttpSession getSession(boolean b)
{
HttpSession sess = null;
if (session instanceof MockHttpSession)
{
MockHttpSession mockHttpSession = (MockHttpSession)session;
if (b)
{
mockHttpSession.setTemporary(false);
}
if (mockHttpSession.isTemporary() == false)
{
sess = session;
}
}
return sess;
}
/**
* Get the user principal.
*
* @return A user principal
*/
@Override
public Principal getUserPrincipal()
{
final String user = getRemoteUser();
if (user == null)
{
return null;
}
else
{
return new Principal()
{
@Override
public String getName()
{
return user;
}
};
}
}
/**
* @return True if there has been added files to this request using
* {@link #addFile(String, File, String)}
*/
public boolean hasUploadedFiles()
{
return uploadedFiles != null;
}
/**
* Reset the request back to a default state.
* @param locale
*/
public void initialize(Locale locale)
{
authType = null;
method = "post";
cookies.clear();
setDefaultHeaders(locale);
path = null;
url = null;
characterEncoding = "UTF-8";
parameters.clear();
attributes.clear();
post.reset();
}
/**
* Check whether session id is from a cookie. Always returns true.
*
* @return Always true
*/
@Override
public boolean isRequestedSessionIdFromCookie()
{
return true;
}
/**
* Check whether session id is from a url rewrite. Always returns false.
*
* @return Always false
*/
@Override
public boolean isRequestedSessionIdFromUrl()
{
return false;
}
@Override
public boolean authenticate(HttpServletResponse response) throws IOException, ServletException
{
return false;
}
@Override
public void login(String username, String password) throws ServletException
{
}
@Override
public void logout() throws ServletException
{
}
@Override
public Collection<Part> getParts() throws IOException, ServletException
{
return parts.values();
}
@Override
public Part getPart(String name) throws IOException, ServletException
{
return parts.get(name);
}
@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> aClass) throws IOException, ServletException
{
return null;
}
public MockHttpServletRequest setPart(String name, Part part) {
parts.put(name, part);
return this;
}
/**
* Check whether session id is from a url rewrite. Always returns false.
*
* @return Always false
*/
@Override
public boolean isRequestedSessionIdFromURL()
{
return false;
}
/**
* Check whether the session id is valid.
*
* @return Always true
*/
@Override
public boolean isRequestedSessionIdValid()
{
return true;
}
/**
* @return <code>true</code> if this request's scheme is 'https', <code>false</code> - otherwise
*/
@Override
public boolean isSecure()
{
return secure;
}
/**
*
* @param secure
*/
public void setSecure(boolean secure)
{
this.secure = secure;
}
/**
* NOT IMPLEMENTED.
*
* @param name
* The role name
* @return Always false
*/
@Override
public boolean isUserInRole(String name)
{
return false;
}
/**
* Remove the given attribute.
*
* @param name
* The name of the attribute
*/
@Override
public void removeAttribute(final String name)
{
attributes.remove(name);
}
/**
* Set the given attribute.
*
* @param name
* The attribute name
* @param o
* The value to set
*/
@Override
public void setAttribute(final String name, final Object o)
{
attributes.put(name, o);
}
/**
* Set the auth type.
*
* @param authType
* The auth type
*/
public void setAuthType(final String authType)
{
this.authType = authType;
}
/**
* Set the character encoding.
*
* @param encoding
* The character encoding
* @throws UnsupportedEncodingException
* If encoding not supported
*/
@Override
public void setCharacterEncoding(final String encoding) throws UnsupportedEncodingException
{
characterEncoding = encoding;
}
/**
* Set the cookies.
*
* @param theCookies
* The cookies
*/
public void setCookies(final Cookie[] theCookies)
{
cookies.clear();
addCookies(Arrays.asList(theCookies));
}
/**
* Set the method.
*
* @param method
* The method
*/
public void setMethod(final String method)
{
this.method = method;
}
/**
* Set a parameter.
*
* @param name
* The name
* @param value
* The value
*/
public void setParameter(final String name, final String value)
{
if (value == null)
{
parameters.remove(name);
}
else
{
parameters.put(name, new String[] { value });
}
}
/**
* @param name
* @param value
*/
public void addParameter(final String name, final String value)
{
if (value == null)
{
return;
}
String[] val = parameters.get(name);
if (val == null)
{
parameters.put(name, new String[] { value });
}
else
{
String[] newval = new String[val.length + 1];
System.arraycopy(val, 0, newval, 0, val.length);
newval[val.length] = value;
parameters.put(name, newval);
}
}
/**
* Sets a map of parameters.
*
* @param parameters
* the parameters to set
*/
public void setParameters(final Map<String, String[]> parameters)
{
this.parameters.putAll(parameters);
}
/**
* Set the path that this request is supposed to be serving. The path is relative to the web
* application root and should start with a / character
*
* @param path
*/
public void setPath(final String path)
{
this.path = UrlDecoder.PATH_INSTANCE.decode(path, getCharset());
}
/**
* Set the complete url for this request. The url will be analyzed.
*
* @param url
*/
public void setURL(String url)
{
setUrl(Url.parse(url));
}
/**
* Helper method to create some default headers for the request
* @param l
*/
private void setDefaultHeaders(Locale l)
{
headers.clear();
addHeader("Accept", "text/xml,application/xml,application/xhtml+xml,"
+ "text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5");
addHeader("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
addHeader("Accept-Language", l.getLanguage().toLowerCase() + "-"
+ l.getCountry().toLowerCase() + "," + l.getLanguage().toLowerCase() + ";q=0.5");
addHeader("User-Agent",
"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:41.0) Gecko/20100101 Firefox/41.0");
}
private static final String crlf = "\r\n";
private static final String boundary = "--abcdefgABCDEFG";
private void newAttachment(OutputStream out) throws IOException
{
out.write(boundary.getBytes());
out.write(crlf.getBytes());
out.write("Content-Disposition: form-data".getBytes());
}
/**
* Build the request based on the uploaded files and the parameters.
*
* @return The request as a string.
*/
private byte[] buildRequest()
{
if (uploadedFiles == null && useMultiPartContentType == false)
{
if (post.getParameterNames().size() == 0)
{
return "".getBytes();
}
Url url = new Url();
for (final String parameterName : post.getParameterNames())
{
List<StringValue> values = post.getParameterValues(parameterName);
for (StringValue value : values)
{
url.addQueryParameter(parameterName, value.toString());
}
}
String body = url.toString().substring(1);
return body.getBytes();
}
try
{
// Build up the input stream based on the files and parameters
ByteArrayOutputStream out = new ByteArrayOutputStream();
// Add parameters
for (final String parameterName : post.getParameterNames())
{
List<StringValue> values = post.getParameterValues(parameterName);
for (StringValue value : values)
{
newAttachment(out);
out.write("; name=\"".getBytes());
out.write(parameterName.getBytes());
out.write("\"".getBytes());
out.write(crlf.getBytes());
out.write(crlf.getBytes());
out.write(value.toString().getBytes());
out.write(crlf.getBytes());
}
}
// Add files
if (uploadedFiles != null)
{
for (Map.Entry<String, List<UploadedFile>> entry : uploadedFiles.entrySet())
{
String fieldName = entry.getKey();
List<UploadedFile> files = entry.getValue();
for (UploadedFile uf : files)
{
newAttachment(out);
out.write("; name=\"".getBytes());
out.write(fieldName.getBytes());
out.write("\"; filename=\"".getBytes());
if (uf.getFile() != null) {
out.write(uf.getFile().getName().getBytes());
}
out.write("\"".getBytes());
out.write(crlf.getBytes());
out.write("Content-Type: ".getBytes());
out.write(uf.getContentType().getBytes());
out.write(crlf.getBytes());
out.write(crlf.getBytes());
if (uf.getFile() != null) {
// Load the file and put it into the the inputstream
FileInputStream fis = new FileInputStream(uf.getFile());
try
{
IOUtils.copy(fis, out);
}
finally
{
fis.close();
}
}
out.write(crlf.getBytes());
}
}
}
out.write(boundary.getBytes());
out.write("--".getBytes());
out.write(crlf.getBytes());
return out.toByteArray();
}
catch (IOException e)
{
// NOTE: IllegalStateException(Throwable) only exists since Java 1.5
throw new WicketRuntimeException(e);
}
}
/**
* @return local address
*/
@Override
public String getLocalAddr()
{
return "127.0.0.1";
}
/**
* @return local host name
*/
@Override
public String getLocalName()
{
return "127.0.0.1";
}
/**
* @return local port
*/
@Override
public int getLocalPort()
{
return 80;
}
/**
* @return remote port
*/
@Override
public int getRemotePort()
{
return 80;
}
/**
* @param url
*/
public void setUrl(Url url)
{
if (url.getProtocol() != null)
{
setScheme(url.getProtocol());
}
if (url.getHost() != null)
{
serverName = url.getHost();
}
if (url.getPort() != null)
{
serverPort = url.getPort();
}
String path = url.getPath(getCharset());
if (path.startsWith("/") == false)
{
path = getContextPath() + getServletPath() + '/' + path;
}
this.url = path;
if (path.startsWith(getContextPath()))
{
path = path.substring(getContextPath().length());
}
if (path.startsWith(getServletPath()))
{
path = path.substring(getServletPath().length());
}
setPath(path);
//
// We can't clear the parameters here because users may have set custom
// parameters in request. An better place to clear they is when tester
// setups the next request cycle
//
// parameters.clear();
for (QueryParameter parameter : url.getQueryParameters())
{
addParameter(parameter.getName(), parameter.getValue());
}
}
/**
* @return request url
*/
public Url getUrl()
{
final String urlString;
final String queryString = getQueryString();
if (Strings.isEmpty(queryString))
{
urlString = getRequestURI();
}
else
{
urlString = getRequestURI() + '?' + queryString;
}
final Url url = Url.parse(urlString, getCharset());
url.setProtocol(scheme);
url.setHost(serverName);
url.setPort(serverPort);
return url;
}
/**
* @return post parameters
*/
public MockRequestParameters getPostParameters()
{
return post;
}
/**
* @return filter prefix
*/
public String getFilterPrefix()
{
return getServletPath().substring(1);
}
private final MockRequestParameters post = new MockRequestParameters();
/**
* @return ServletContext
*/
public ServletContext getServletContext()
{
return context;
}
@Override
public AsyncContext startAsync() throws IllegalStateException
{
return null;
}
@Override
public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse)
throws IllegalStateException
{
return null;
}
@Override
public boolean isAsyncStarted()
{
return false;
}
@Override
public boolean isAsyncSupported()
{
return false;
}
@Override
public AsyncContext getAsyncContext()
{
return null;
}
@Override
public DispatcherType getDispatcherType()
{
return null;
}
}