| /* |
| * 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.myfaces.test.mock; |
| |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.UnsupportedEncodingException; |
| import java.io.Writer; |
| import java.net.URLEncoder; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import javax.faces.context.Flash; |
| import javax.servlet.ServletContext; |
| import javax.servlet.http.Cookie; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import javax.servlet.http.HttpSession; |
| |
| /** |
| * <p>Mock implementation of <code>ExternalContext</code> that includes the semantics |
| * added by JavaServer Faces 2.0.</p> |
| * |
| * @author Leonardo Uribe |
| * @since 1.0.0 |
| * |
| */ |
| public abstract class MockExternalContext20 extends MockExternalContext12 |
| { |
| |
| // ------------------------------------------------------------ Constructors |
| |
| public MockExternalContext20(ServletContext context, |
| HttpServletRequest request, HttpServletResponse response) |
| { |
| super(context, request, response); |
| } |
| |
| public String getMimeType(String file) |
| { |
| return context.getMimeType(file); |
| } |
| |
| // ------------------------------------------------------ Instance Variables |
| |
| private static final String URL_PARAM_SEPERATOR = "&"; |
| private static final String URL_QUERY_SEPERATOR = "?"; |
| private static final String URL_FRAGMENT_SEPERATOR = "#"; |
| private static final String URL_NAME_VALUE_PAIR_SEPERATOR = "="; |
| |
| // ----------------------------------------------------- Mock Object Methods |
| |
| // ------------------------------------------------- ExternalContext Methods |
| |
| public String encodeBookmarkableURL(String baseUrl, |
| Map<String, List<String>> parameters) |
| { |
| return response.encodeURL(encodeURL(baseUrl, parameters)); |
| } |
| |
| private String encodeURL(String baseUrl, |
| Map<String, List<String>> parameters) |
| { |
| String fragment = null; |
| String queryString = null; |
| Map<String, List<String>> paramMap = new HashMap<String, List<String>>(); |
| |
| //extract any URL fragment |
| int index = baseUrl.indexOf(URL_FRAGMENT_SEPERATOR); |
| if (index != -1) |
| { |
| fragment = baseUrl.substring(index + 1); |
| baseUrl = baseUrl.substring(0, index); |
| } |
| |
| //extract the current query string and add the params to the paramMap |
| index = baseUrl.indexOf(URL_QUERY_SEPERATOR); |
| if (index != -1) |
| { |
| queryString = baseUrl.substring(index + 1); |
| baseUrl = baseUrl.substring(0, index); |
| String[] nameValuePairs = queryString.split(URL_PARAM_SEPERATOR); |
| for (int i = 0; i < nameValuePairs.length; i++) |
| { |
| String[] currentPair = nameValuePairs[i] |
| .split(URL_NAME_VALUE_PAIR_SEPERATOR); |
| if (currentPair[1] != null) |
| { |
| ArrayList<String> value = new ArrayList<String>(1); |
| value.add(currentPair[1]); |
| paramMap.put(currentPair[0], value); |
| } |
| } |
| } |
| |
| //add/update with new params on the paramMap |
| if (parameters != null && parameters.size() > 0) |
| { |
| for (Map.Entry<String, List<String>> pair : parameters.entrySet()) |
| { |
| if (pair.getKey() != null && pair.getKey().trim().length() != 0) |
| { |
| paramMap.put(pair.getKey(), pair.getValue()); |
| } |
| } |
| } |
| |
| // start building the new URL |
| StringBuilder newUrl = new StringBuilder(baseUrl); |
| |
| //now add the updated param list onto the url |
| if (paramMap.size() > 0) |
| { |
| boolean isFirstPair = true; |
| for (Map.Entry<String, List<String>> pair : paramMap.entrySet()) |
| { |
| for (String value : pair.getValue()) |
| { |
| if (!isFirstPair) |
| { |
| newUrl.append(URL_PARAM_SEPERATOR); |
| } |
| else |
| { |
| newUrl.append(URL_QUERY_SEPERATOR); |
| isFirstPair = false; |
| } |
| |
| newUrl.append(pair.getKey()); |
| newUrl.append(URL_NAME_VALUE_PAIR_SEPERATOR); |
| try |
| { |
| newUrl.append(URLEncoder.encode(value, |
| getResponseCharacterEncoding())); |
| } |
| catch (UnsupportedEncodingException e) |
| { |
| //shouldn't ever get here |
| throw new UnsupportedOperationException( |
| "Encoding type=" |
| + getResponseCharacterEncoding() |
| + " not supported", e); |
| } |
| } |
| } |
| } |
| |
| //add the fragment back on (if any) |
| if (fragment != null) |
| { |
| newUrl.append(URL_FRAGMENT_SEPERATOR + fragment); |
| } |
| |
| return newUrl.toString(); |
| } |
| |
| public String encodeRedirectURL(String baseUrl, |
| Map<String, List<String>> parameters) |
| { |
| return response.encodeRedirectURL(encodeURL(baseUrl, parameters)); |
| } |
| |
| @Override |
| public String encodePartialActionURL(String url) |
| { |
| return ((HttpServletResponse) response).encodeURL(url); |
| } |
| |
| public String getContextName() |
| { |
| return context.getServletContextName(); |
| } |
| |
| public String getRealPath(String path) |
| { |
| return context.getRealPath(path); |
| } |
| |
| public void responseSendError(int statusCode, String message) |
| throws IOException |
| { |
| if (message == null) |
| { |
| response.sendError(statusCode); |
| } |
| else |
| { |
| response.sendError(statusCode, message); |
| } |
| } |
| |
| public void setResponseHeader(String name, String value) |
| { |
| response.setHeader(name, value); |
| } |
| |
| public String getRequestScheme() |
| { |
| return request.getScheme(); |
| } |
| |
| public String getRequestServerName() |
| { |
| return request.getServerName(); |
| } |
| |
| public int getRequestServerPort() |
| { |
| return request.getServerPort(); |
| } |
| |
| public OutputStream getResponseOutputStream() throws IOException |
| { |
| return response.getOutputStream(); |
| } |
| |
| public Writer getResponseOutputWriter() throws IOException |
| { |
| return response.getWriter(); |
| } |
| |
| @Override |
| public void setResponseContentType(String contentType) |
| { |
| response.setContentType(contentType); |
| } |
| |
| public Flash getFlash() |
| { |
| return MockFlash.getCurrentInstance(this); |
| } |
| |
| @Override |
| public void setResponseContentLength(int length) |
| { |
| response.setContentLength(length); |
| } |
| |
| @Override |
| public int getRequestContentLength() |
| { |
| return request.getContentLength(); |
| } |
| |
| @Override |
| public int getResponseBufferSize() |
| { |
| return response.getBufferSize(); |
| } |
| |
| @Override |
| public void setResponseBufferSize(int size) |
| { |
| response.setBufferSize(size); |
| } |
| |
| @Override |
| public void setResponseStatus(int statusCode) |
| { |
| response.setStatus(statusCode); |
| } |
| |
| @Override |
| public void invalidateSession() |
| { |
| HttpSession session = request.getSession(false); |
| if (session != null) |
| { |
| session.invalidate(); |
| } |
| } |
| |
| @Override |
| public boolean isResponseCommitted() |
| { |
| return response.isCommitted(); |
| } |
| |
| @Override |
| public void responseFlushBuffer() throws IOException |
| { |
| response.flushBuffer(); |
| } |
| |
| @Override |
| public void responseReset() |
| { |
| response.reset(); |
| } |
| |
| @Override |
| public void addResponseCookie(String name, String value, |
| Map<String, Object> properties) |
| { |
| Cookie cookie = new Cookie(name, value); |
| if (properties != null) |
| { |
| for (Map.Entry<String, Object> entry : properties.entrySet()) |
| { |
| String propertyKey = entry.getKey(); |
| Object propertyValue = entry.getValue(); |
| if ("comment".equals(propertyKey)) |
| { |
| cookie.setComment((String) propertyValue); |
| continue; |
| } |
| else if ("domain".equals(propertyKey)) |
| { |
| cookie.setDomain((String)propertyValue); |
| continue; |
| } |
| else if ("maxAge".equals(propertyKey)) |
| { |
| cookie.setMaxAge((Integer) propertyValue); |
| continue; |
| } |
| else if ("secure".equals(propertyKey)) |
| { |
| cookie.setSecure((Boolean) propertyValue); |
| continue; |
| } |
| else if ("path".equals(propertyKey)) |
| { |
| cookie.setPath((String) propertyValue); |
| continue; |
| } |
| throw new IllegalArgumentException("Unused key when creating Cookie"); |
| } |
| } |
| response.addCookie(cookie); |
| } |
| |
| @Override |
| public void addResponseHeader(String name, String value) |
| { |
| response.addHeader(name, value); |
| } |
| |
| } |