diff --git a/plugins/junit-portlet/pom.xml b/plugins/junit-portlet/pom.xml new file mode 100644 index 000000000..adfab0000 --- /dev/null +++ b/plugins/junit-portlet/pom.xml @@ -0,0 +1,89 @@ + + + + 4.0.0 + + org.apache.struts + struts2-plugins + 2.6-SNAPSHOT + + + struts2-junit-portlet-plugin + jar + Struts 2 JUnit Portlet Plugin + + + + org.springframework + spring-test + + + org.springframework + spring-core + + + org.springframework + spring-context + + + org.springframework + spring-web + + + org.apache.struts + struts2-junit-plugin + + + org.apache.struts + struts2-spring-plugin + true + + + javax.servlet.jsp + jsp-api + provided + + + junit + junit + + + + + javax.portlet + portlet-api + provided + + + + + javax.servlet + javax.servlet-api + 3.1.0 + test + + + + UTF-8 + + diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockActionRequest.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockActionRequest.java new file mode 100644 index 000000000..390df5cda --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockActionRequest.java @@ -0,0 +1,86 @@ +/* + * Copyright 2002-2009 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import javax.portlet.ActionRequest; +import javax.portlet.PortalContext; +import javax.portlet.PortletContext; +import javax.portlet.PortletMode; + +/** + * Mock implementation of the {@link javax.portlet.ActionRequest} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockActionRequest extends MockClientDataRequest implements ActionRequest { + + /** + * Create a new MockActionRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @see org.springframework.mock.web.portlet.MockPortalContext + * @see org.springframework.mock.web.portlet.MockPortletContext + */ + public MockActionRequest() { + super(); + } + + /** + * Create a new MockActionRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @param actionName the name of the action to trigger + */ + public MockActionRequest(String actionName) { + super(); + setParameter(ActionRequest.ACTION_NAME, actionName); + } + + /** + * Create a new MockActionRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @param portletMode the mode that the portlet runs in + */ + public MockActionRequest(PortletMode portletMode) { + super(); + setPortletMode(portletMode); + } + + /** + * Create a new MockActionRequest with a default {@link MockPortalContext}. + * @param portletContext the PortletContext that the request runs in + */ + public MockActionRequest(PortletContext portletContext) { + super(portletContext); + } + + /** + * Create a new MockActionRequest. + * @param portalContext the PortalContext that the request runs in + * @param portletContext the PortletContext that the request runs in + */ + public MockActionRequest(PortalContext portalContext, PortletContext portletContext) { + super(portalContext, portletContext); + } + + + @Override + protected String getLifecyclePhase() { + return ACTION_PHASE; + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockActionResponse.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockActionResponse.java new file mode 100644 index 000000000..b120ffd87 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockActionResponse.java @@ -0,0 +1,132 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.IOException; +import java.util.Map; +import javax.portlet.ActionResponse; +import javax.portlet.PortalContext; +import javax.portlet.PortletMode; +import javax.portlet.PortletModeException; +import javax.portlet.WindowState; +import javax.portlet.WindowStateException; + +import org.springframework.util.Assert; + +/** + * Mock implementation of the {@link javax.portlet.ActionResponse} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockActionResponse extends MockStateAwareResponse implements ActionResponse { + + private boolean redirectAllowed = true; + + private String redirectedUrl; + + + /** + * Create a new MockActionResponse with a default {@link MockPortalContext}. + * @see MockPortalContext + */ + public MockActionResponse() { + super(); + } + + /** + * Create a new MockActionResponse. + * @param portalContext the PortalContext defining the supported + * PortletModes and WindowStates + */ + public MockActionResponse(PortalContext portalContext) { + super(portalContext); + } + + + @Override + public void setWindowState(WindowState windowState) throws WindowStateException { + if (this.redirectedUrl != null) { + throw new IllegalStateException("Cannot set WindowState after sendRedirect has been called"); + } + super.setWindowState(windowState); + this.redirectAllowed = false; + } + + @Override + public void setPortletMode(PortletMode portletMode) throws PortletModeException { + if (this.redirectedUrl != null) { + throw new IllegalStateException("Cannot set PortletMode after sendRedirect has been called"); + } + super.setPortletMode(portletMode); + this.redirectAllowed = false; + } + + @Override + public void setRenderParameters(Map parameters) { + if (this.redirectedUrl != null) { + throw new IllegalStateException("Cannot set render parameters after sendRedirect has been called"); + } + super.setRenderParameters(parameters); + this.redirectAllowed = false; + } + + @Override + public void setRenderParameter(String key, String value) { + if (this.redirectedUrl != null) { + throw new IllegalStateException("Cannot set render parameters after sendRedirect has been called"); + } + super.setRenderParameter(key, value); + this.redirectAllowed = false; + } + + @Override + public void setRenderParameter(String key, String[] values) { + if (this.redirectedUrl != null) { + throw new IllegalStateException("Cannot set render parameters after sendRedirect has been called"); + } + super.setRenderParameter(key, values); + this.redirectAllowed = false; + } + + @Override + public void sendRedirect(String location) throws IOException { + if (!this.redirectAllowed) { + throw new IllegalStateException( + "Cannot call sendRedirect after windowState, portletMode, or renderParameters have been set"); + } + Assert.notNull(location, "Redirect URL must not be null"); + this.redirectedUrl = location; + } + + @Override + public void sendRedirect(String location, String renderUrlParamName) throws IOException { + sendRedirect(location); + if (renderUrlParamName != null) { + // NOTE: Changed since original Spring 4.3.x version. + // Cannot call setRenderParameter(renderUrlParamName, location) here as it always results in an IllegalStateException - since a redirect has been called. + // Due to this, we call super.setRenderParameter() directly, otherwise this method can never successfully be called. + super.setRenderParameter(renderUrlParamName, location); + } + } + + public String getRedirectedUrl() { + return this.redirectedUrl; + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockBaseURL.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockBaseURL.java new file mode 100644 index 000000000..c0a1995e9 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockBaseURL.java @@ -0,0 +1,161 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.io.Writer; +import java.net.URLEncoder; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; +import javax.portlet.BaseURL; +import javax.portlet.PortletSecurityException; + +import org.springframework.util.Assert; +import org.springframework.util.StringUtils; + +/** + * Mock implementation of the {@link javax.portlet.BaseURL} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public abstract class MockBaseURL implements BaseURL { + + public static final String URL_TYPE_RENDER = "render"; + + public static final String URL_TYPE_ACTION = "action"; + + private static final String ENCODING = "UTF-8"; + + + protected final Map parameters = new LinkedHashMap(); + + private boolean secure = false; + + private final Map properties = new LinkedHashMap(); + + + //--------------------------------------------------------------------- + // BaseURL methods + //--------------------------------------------------------------------- + + @Override + public void setParameter(String key, String value) { + Assert.notNull(key, "Parameter key must be null"); + Assert.notNull(value, "Parameter value must not be null"); + this.parameters.put(key, new String[] {value}); + } + + @Override + public void setParameter(String key, String[] values) { + Assert.notNull(key, "Parameter key must be null"); + Assert.notNull(values, "Parameter values must not be null"); + this.parameters.put(key, values); + } + + @Override + public void setParameters(Map parameters) { + Assert.notNull(parameters, "Parameters Map must not be null"); + this.parameters.clear(); + this.parameters.putAll(parameters); + } + + public Set getParameterNames() { + return this.parameters.keySet(); + } + + public String getParameter(String name) { + String[] arr = this.parameters.get(name); + return (arr != null && arr.length > 0 ? arr[0] : null); + } + + public String[] getParameterValues(String name) { + return this.parameters.get(name); + } + + @Override + public Map getParameterMap() { + return Collections.unmodifiableMap(this.parameters); + } + + @Override + public void setSecure(boolean secure) throws PortletSecurityException { + this.secure = secure; + } + + public boolean isSecure() { + return this.secure; + } + + @Override + public void write(Writer out) throws IOException { + out.write(toString()); + } + + @Override + public void write(Writer out, boolean escapeXML) throws IOException { + out.write(toString()); + } + + @Override + public void addProperty(String key, String value) { + String[] values = this.properties.get(key); + if (values != null) { + this.properties.put(key, StringUtils.addStringToArray(values, value)); + } + else { + this.properties.put(key, new String[] {value}); + } + } + + @Override + public void setProperty(String key, String value) { + this.properties.put(key, new String[] {value}); + } + + public Map getProperties() { + return Collections.unmodifiableMap(this.properties); + } + + + protected String encodeParameter(String name, String value) { + try { + return URLEncoder.encode(name, ENCODING) + "=" + URLEncoder.encode(value, ENCODING); + } + catch (UnsupportedEncodingException ex) { + return null; + } + } + + protected String encodeParameter(String name, String[] values) { + try { + StringBuilder sb = new StringBuilder(); + for (int i = 0, n = values.length; i < n; i++) { + sb.append(i > 0 ? ";" : "").append(URLEncoder.encode(name, ENCODING)).append("=") + .append(URLEncoder.encode(values[i], ENCODING)); + } + return sb.toString(); + } + catch (UnsupportedEncodingException ex) { + return null; + } + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockCacheControl.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockCacheControl.java new file mode 100644 index 000000000..f0ae50ac2 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockCacheControl.java @@ -0,0 +1,78 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import javax.portlet.CacheControl; + +/** + * Mock implementation of the {@link javax.portlet.CacheControl} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public class MockCacheControl implements CacheControl { + + private int expirationTime = 0; + + private boolean publicScope = false; + + private String etag; + + private boolean useCachedContent = false; + + + @Override + public int getExpirationTime() { + return this.expirationTime; + } + + @Override + public void setExpirationTime(int time) { + this.expirationTime = time; + } + + @Override + public boolean isPublicScope() { + return this.publicScope; + } + + @Override + public void setPublicScope(boolean publicScope) { + this.publicScope = publicScope; + } + + @Override + public String getETag() { + return this.etag; + } + + @Override + public void setETag(String token) { + this.etag = token; + } + + @Override + public boolean useCachedContent() { + return this.useCachedContent; + } + + @Override + public void setUseCachedContent(boolean useCachedContent) { + this.useCachedContent = useCachedContent; + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockClientDataRequest.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockClientDataRequest.java new file mode 100644 index 000000000..44792d1de --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockClientDataRequest.java @@ -0,0 +1,135 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; +import java.io.UnsupportedEncodingException; +import javax.portlet.ClientDataRequest; +import javax.portlet.PortalContext; +import javax.portlet.PortletContext; + +/** + * Mock implementation of the {@link javax.portlet.ClientDataRequest} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public class MockClientDataRequest extends MockPortletRequest implements ClientDataRequest { + + private String characterEncoding; + + private byte[] content; + + private String contentType; + + private String method; + + + /** + * Create a new MockClientDataRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @see org.springframework.mock.web.portlet.MockPortalContext + * @see org.springframework.mock.web.portlet.MockPortletContext + */ + public MockClientDataRequest() { + super(); + } + + /** + * Create a new MockClientDataRequest with a default {@link MockPortalContext}. + * @param portletContext the PortletContext that the request runs in + */ + public MockClientDataRequest(PortletContext portletContext) { + super(portletContext); + } + + /** + * Create a new MockClientDataRequest. + * @param portalContext the PortalContext that the request runs in + * @param portletContext the PortletContext that the request runs in + */ + public MockClientDataRequest(PortalContext portalContext, PortletContext portletContext) { + super(portalContext, portletContext); + } + + + public void setContent(byte[] content) { + this.content = content; + } + + @Override + public InputStream getPortletInputStream() throws IOException { + if (this.content != null) { + return new ByteArrayInputStream(this.content); + } + else { + return null; + } + } + + @Override + public void setCharacterEncoding(String characterEncoding) { + this.characterEncoding = characterEncoding; + } + + @Override + public BufferedReader getReader() throws UnsupportedEncodingException { + if (this.content != null) { + InputStream sourceStream = new ByteArrayInputStream(this.content); + Reader sourceReader = (this.characterEncoding != null) ? + new InputStreamReader(sourceStream, this.characterEncoding) : new InputStreamReader(sourceStream); + return new BufferedReader(sourceReader); + } + else { + return null; + } + } + + @Override + public String getCharacterEncoding() { + return this.characterEncoding; + } + + public void setContentType(String contentType) { + this.contentType = contentType; + } + + @Override + public String getContentType() { + return this.contentType; + } + + @Override + public int getContentLength() { + return (this.content != null ? content.length : -1); + } + + public void setMethod(String method) { + this.method = method; + } + + @Override + public String getMethod() { + return this.method; + } + +} \ No newline at end of file diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockEvent.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockEvent.java new file mode 100644 index 000000000..2e9a41126 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockEvent.java @@ -0,0 +1,91 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.Serializable; +import javax.portlet.Event; +import javax.xml.namespace.QName; + +/** + * Mock implementation of the {@link javax.portlet.Event} interface. + * + * @author Juergen Hoeller + * @since 3.0 + * @see MockEventRequest + */ +public class MockEvent implements Event { + + private final QName name; + + private final Serializable value; + + + /** + * Create a new MockEvent with the given name. + * @param name the name of the event + */ + public MockEvent(QName name) { + this.name = name; + this.value = null; + } + + /** + * Create a new MockEvent with the given name and value. + * @param name the name of the event + * @param value the associated payload of the event + */ + public MockEvent(QName name, Serializable value) { + this.name = name; + this.value = value; + } + + /** + * Create a new MockEvent with the given name. + * @param name the name of the event + */ + public MockEvent(String name) { + this.name = new QName(name); + this.value = null; + } + + /** + * Create a new MockEvent with the given name and value. + * @param name the name of the event + * @param value the associated payload of the event + */ + public MockEvent(String name, Serializable value) { + this.name = new QName(name); + this.value = value; + } + + + @Override + public QName getQName() { + return this.name; + } + + @Override + public String getName() { + return this.name.getLocalPart(); + } + + @Override + public Serializable getValue() { + return this.value; + } + +} \ No newline at end of file diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockEventRequest.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockEventRequest.java new file mode 100644 index 000000000..c05551137 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockEventRequest.java @@ -0,0 +1,90 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import javax.portlet.Event; +import javax.portlet.EventRequest; +import javax.portlet.PortalContext; +import javax.portlet.PortletContext; + +/** + * Mock implementation of the {@link javax.portlet.EventRequest} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public class MockEventRequest extends MockPortletRequest implements EventRequest { + + private final Event event; + + private String method; + + + /** + * Create a new MockEventRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @param event the event that this request wraps + * @see MockEvent + */ + public MockEventRequest(Event event) { + super(); + this.event = event; + } + + /** + * Create a new MockEventRequest with a default {@link MockPortalContext}. + * @param event the event that this request wraps + * @param portletContext the PortletContext that the request runs in + * @see MockEvent + */ + public MockEventRequest(Event event, PortletContext portletContext) { + super(portletContext); + this.event = event; + } + + /** + * Create a new MockEventRequest. + * @param event the event that this request wraps + * @param portalContext the PortletContext that the request runs in + * @param portletContext the PortletContext that the request runs in + */ + public MockEventRequest(Event event, PortalContext portalContext, PortletContext portletContext) { + super(portalContext, portletContext); + this.event = event; + } + + + @Override + protected String getLifecyclePhase() { + return EVENT_PHASE; + } + + @Override + public Event getEvent() { + return this.event; + } + + public void setMethod(String method) { + this.method = method; + } + + @Override + public String getMethod() { + return this.method; + } + +} \ No newline at end of file diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockEventResponse.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockEventResponse.java new file mode 100644 index 000000000..9bda32e0d --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockEventResponse.java @@ -0,0 +1,35 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import javax.portlet.EventRequest; +import javax.portlet.EventResponse; + +/** + * Mock implementation of the {@link javax.portlet.EventResponse} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public class MockEventResponse extends MockStateAwareResponse implements EventResponse { + + @Override + public void setRenderParameters(EventRequest request) { + setRenderParameters(request.getParameterMap()); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockMimeResponse.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockMimeResponse.java new file mode 100644 index 000000000..cb654cb6c --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockMimeResponse.java @@ -0,0 +1,259 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.PrintWriter; +import java.io.UnsupportedEncodingException; +import java.io.Writer; +import java.util.Collections; +import java.util.Enumeration; +import java.util.Locale; +import javax.portlet.CacheControl; +import javax.portlet.MimeResponse; +import javax.portlet.PortalContext; +import javax.portlet.PortletRequest; +import javax.portlet.PortletURL; +import javax.portlet.ResourceURL; + +import org.springframework.util.CollectionUtils; +import org.springframework.web.util.WebUtils; + +/** + * Mock implementation of the {@link javax.portlet.MimeResponse} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public class MockMimeResponse extends MockPortletResponse implements MimeResponse { + + private PortletRequest request; + + private String contentType; + + private String characterEncoding = WebUtils.DEFAULT_CHARACTER_ENCODING; + + private PrintWriter writer; + + private Locale locale = Locale.getDefault(); + + private int bufferSize = 4096; + + private final ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + + private final CacheControl cacheControl = new MockCacheControl(); + + private boolean committed; + + private String includedUrl; + + private String forwardedUrl; + + + /** + * Create a new MockMimeResponse with a default {@link MockPortalContext}. + * @see org.springframework.mock.web.portlet.MockPortalContext + */ + public MockMimeResponse() { + super(); + } + + /** + * Create a new MockMimeResponse. + * @param portalContext the PortalContext defining the supported + * PortletModes and WindowStates + */ + public MockMimeResponse(PortalContext portalContext) { + super(portalContext); + } + + /** + * Create a new MockMimeResponse. + * @param portalContext the PortalContext defining the supported + * PortletModes and WindowStates + * @param request the corresponding render/resource request that this response + * is being generated for + */ + public MockMimeResponse(PortalContext portalContext, PortletRequest request) { + super(portalContext); + this.request = request; + } + + + //--------------------------------------------------------------------- + // RenderResponse methods + //--------------------------------------------------------------------- + + @Override + public void setContentType(String contentType) { + if (this.request != null) { + Enumeration supportedTypes = this.request.getResponseContentTypes(); + if (!CollectionUtils.contains(supportedTypes, contentType)) { + throw new IllegalArgumentException("Content type [" + contentType + "] not in supported list: " + + Collections.list(supportedTypes)); + } + } + this.contentType = contentType; + } + + @Override + public String getContentType() { + return this.contentType; + } + + public void setCharacterEncoding(String characterEncoding) { + this.characterEncoding = characterEncoding; + } + + @Override + public String getCharacterEncoding() { + return this.characterEncoding; + } + + @Override + public PrintWriter getWriter() throws UnsupportedEncodingException { + if (this.writer == null) { + Writer targetWriter = (this.characterEncoding != null + ? new OutputStreamWriter(this.outputStream, this.characterEncoding) + : new OutputStreamWriter(this.outputStream)); + this.writer = new PrintWriter(targetWriter); + } + return this.writer; + } + + public byte[] getContentAsByteArray() { + flushBuffer(); + return this.outputStream.toByteArray(); + } + + public String getContentAsString() throws UnsupportedEncodingException { + flushBuffer(); + return (this.characterEncoding != null) + ? this.outputStream.toString(this.characterEncoding) + : this.outputStream.toString(); + } + + public void setLocale(Locale locale) { + this.locale = locale; + } + + @Override + public Locale getLocale() { + return this.locale; + } + + @Override + public void setBufferSize(int bufferSize) { + this.bufferSize = bufferSize; + } + + @Override + public int getBufferSize() { + return this.bufferSize; + } + + @Override + public void flushBuffer() { + if (this.writer != null) { + this.writer.flush(); + } + if (this.outputStream != null) { + try { + this.outputStream.flush(); + } + catch (IOException ex) { + throw new IllegalStateException("Could not flush OutputStream: " + ex.getMessage()); + } + } + this.committed = true; + } + + @Override + public void resetBuffer() { + if (this.committed) { + throw new IllegalStateException("Cannot reset buffer - response is already committed"); + } + this.outputStream.reset(); + } + + public void setCommitted(boolean committed) { + this.committed = committed; + } + + @Override + public boolean isCommitted() { + return this.committed; + } + + @Override + public void reset() { + resetBuffer(); + this.characterEncoding = null; + this.contentType = null; + this.locale = null; + } + + @Override + public OutputStream getPortletOutputStream() throws IOException { + return this.outputStream; + } + + @Override + public PortletURL createRenderURL() { + return new MockPortletURL(getPortalContext(), MockPortletURL.URL_TYPE_RENDER); + } + + @Override + public PortletURL createActionURL() { + return new MockPortletURL(getPortalContext(), MockPortletURL.URL_TYPE_ACTION); + } + + @Override + public ResourceURL createResourceURL() { + return new MockResourceURL(); + } + + @Override + public CacheControl getCacheControl() { + return this.cacheControl; + } + + + //--------------------------------------------------------------------- + // Methods for MockPortletRequestDispatcher + //--------------------------------------------------------------------- + + public void setIncludedUrl(String includedUrl) { + this.includedUrl = includedUrl; + } + + public String getIncludedUrl() { + return this.includedUrl; + } + + public void setForwardedUrl(String forwardedUrl) { + this.forwardedUrl = forwardedUrl; + } + + public String getForwardedUrl() { + return this.forwardedUrl; + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockMultipartActionRequest.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockMultipartActionRequest.java new file mode 100644 index 000000000..396e8cfd3 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockMultipartActionRequest.java @@ -0,0 +1,101 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import org.springframework.util.Assert; +import org.springframework.util.LinkedMultiValueMap; +import org.springframework.util.MultiValueMap; +import org.springframework.web.multipart.MultipartFile; +import org.apache.struts2.mock.web.portlet.multipart.MultipartActionRequest; + +/** + * Mock implementation of the + * {@link org.springframework.web.portlet.multipart.MultipartActionRequest} interface. + * + *

Useful for testing application controllers that access multipart uploads. + * The {@link org.springframework.mock.web.MockMultipartFile} can be used to + * populate these mock requests with files. + * + * @author Juergen Hoeller + * @author Arjen Poutsma + * @since 2.0 + * @see org.springframework.mock.web.MockMultipartFile + */ +public class MockMultipartActionRequest extends MockActionRequest implements MultipartActionRequest { + + private final MultiValueMap multipartFiles = + new LinkedMultiValueMap(); + + + /** + * Add a file to this request. The parameter name from the multipart + * form is taken from the {@link org.springframework.web.multipart.MultipartFile#getName()}. + * @param file multipart file to be added + */ + public void addFile(MultipartFile file) { + Assert.notNull(file, "MultipartFile must not be null"); + this.multipartFiles.add(file.getName(), file); + } + + @Override + public Iterator getFileNames() { + return this.multipartFiles.keySet().iterator(); + } + + @Override + public MultipartFile getFile(String name) { + return this.multipartFiles.getFirst(name); + } + + @Override + public List getFiles(String name) { + List multipartFiles = this.multipartFiles.get(name); + if (multipartFiles != null) { + return multipartFiles; + } + else { + return Collections.emptyList(); + } + } + + @Override + public Map getFileMap() { + return this.multipartFiles.toSingleValueMap(); + } + + @Override + public MultiValueMap getMultiFileMap() { + return new LinkedMultiValueMap(this.multipartFiles); + } + + @Override + public String getMultipartContentType(String paramOrFileName) { + MultipartFile file = getFile(paramOrFileName); + if (file != null) { + return file.getContentType(); + } + else { + return null; + } + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortalContext.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortalContext.java new file mode 100644 index 000000000..0c7eccf5e --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortalContext.java @@ -0,0 +1,106 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.portlet.PortalContext; +import javax.portlet.PortletMode; +import javax.portlet.WindowState; + +/** + * Mock implementation of the {@link javax.portlet.PortalContext} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockPortalContext implements PortalContext { + + private final Map properties = new HashMap(); + + private final List portletModes; + + private final List windowStates; + + + /** + * Create a new MockPortalContext + * with default PortletModes (VIEW, EDIT, HELP) + * and default WindowStates (NORMAL, MAXIMIZED, MINIMIZED). + * @see javax.portlet.PortletMode + * @see javax.portlet.WindowState + */ + public MockPortalContext() { + this.portletModes = new ArrayList(3); + this.portletModes.add(PortletMode.VIEW); + this.portletModes.add(PortletMode.EDIT); + this.portletModes.add(PortletMode.HELP); + + this.windowStates = new ArrayList(3); + this.windowStates.add(WindowState.NORMAL); + this.windowStates.add(WindowState.MAXIMIZED); + this.windowStates.add(WindowState.MINIMIZED); + } + + /** + * Create a new MockPortalContext with the given PortletModes and WindowStates. + * @param supportedPortletModes the List of supported PortletMode instances + * @param supportedWindowStates the List of supported WindowState instances + * @see javax.portlet.PortletMode + * @see javax.portlet.WindowState + */ + public MockPortalContext(List supportedPortletModes, List supportedWindowStates) { + this.portletModes = new ArrayList(supportedPortletModes); + this.windowStates = new ArrayList(supportedWindowStates); + } + + + @Override + public String getPortalInfo() { + return "MockPortal/1.0"; + } + + public void setProperty(String name, String value) { + this.properties.put(name, value); + } + + @Override + public String getProperty(String name) { + return this.properties.get(name); + } + + @Override + public Enumeration getPropertyNames() { + return Collections.enumeration(this.properties.keySet()); + } + + @Override + public Enumeration getSupportedPortletModes() { + return Collections.enumeration(this.portletModes); + } + + @Override + public Enumeration getSupportedWindowStates() { + return Collections.enumeration(this.windowStates); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletConfig.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletConfig.java new file mode 100644 index 000000000..33d7e901c --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletConfig.java @@ -0,0 +1,194 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.util.Collections; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Locale; +import java.util.Map; +import java.util.ResourceBundle; +import java.util.Set; +import javax.portlet.PortletConfig; +import javax.portlet.PortletContext; +import javax.xml.XMLConstants; +import javax.xml.namespace.QName; + +import org.springframework.util.Assert; + +/** + * Mock implementation of the {@link javax.portlet.PortletConfig} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockPortletConfig implements PortletConfig { + + private final PortletContext portletContext; + + private final String portletName; + + private final Map resourceBundles = new HashMap(); + + private final Map initParameters = new LinkedHashMap(); + + private final Set publicRenderParameterNames = new LinkedHashSet(); + + private String defaultNamespace = XMLConstants.NULL_NS_URI; + + private final Set publishingEventQNames = new LinkedHashSet(); + + private final Set processingEventQNames = new LinkedHashSet(); + + private final Set supportedLocales = new LinkedHashSet(); + + private final Map containerRuntimeOptions = new LinkedHashMap(); + + + /** + * Create a new MockPortletConfig with a default {@link MockPortletContext}. + */ + public MockPortletConfig() { + this(null, ""); + } + + /** + * Create a new MockPortletConfig with a default {@link MockPortletContext}. + * @param portletName the name of the portlet + */ + public MockPortletConfig(String portletName) { + this(null, portletName); + } + + /** + * Create a new MockPortletConfig. + * @param portletContext the PortletContext that the portlet runs in + */ + public MockPortletConfig(PortletContext portletContext) { + this(portletContext, ""); + } + + /** + * Create a new MockPortletConfig. + * @param portletContext the PortletContext that the portlet runs in + * @param portletName the name of the portlet + */ + public MockPortletConfig(PortletContext portletContext, String portletName) { + this.portletContext = (portletContext != null ? portletContext : new MockPortletContext()); + this.portletName = portletName; + } + + + @Override + public String getPortletName() { + return this.portletName; + } + + @Override + public PortletContext getPortletContext() { + return this.portletContext; + } + + public void setResourceBundle(Locale locale, ResourceBundle resourceBundle) { + Assert.notNull(locale, "Locale must not be null"); + this.resourceBundles.put(locale, resourceBundle); + } + + @Override + public ResourceBundle getResourceBundle(Locale locale) { + Assert.notNull(locale, "Locale must not be null"); + return this.resourceBundles.get(locale); + } + + public void addInitParameter(String name, String value) { + Assert.notNull(name, "Parameter name must not be null"); + this.initParameters.put(name, value); + } + + @Override + public String getInitParameter(String name) { + Assert.notNull(name, "Parameter name must not be null"); + return this.initParameters.get(name); + } + + @Override + public Enumeration getInitParameterNames() { + return Collections.enumeration(this.initParameters.keySet()); + } + + public void addPublicRenderParameterName(String name) { + this.publicRenderParameterNames.add(name); + } + + @Override + public Enumeration getPublicRenderParameterNames() { + return Collections.enumeration(this.publicRenderParameterNames); + } + + public void setDefaultNamespace(String defaultNamespace) { + this.defaultNamespace = defaultNamespace; + } + + @Override + public String getDefaultNamespace() { + return this.defaultNamespace; + } + + public void addPublishingEventQName(QName name) { + this.publishingEventQNames.add(name); + } + + @Override + public Enumeration getPublishingEventQNames() { + return Collections.enumeration(this.publishingEventQNames); + } + + public void addProcessingEventQName(QName name) { + this.processingEventQNames.add(name); + } + + @Override + public Enumeration getProcessingEventQNames() { + return Collections.enumeration(this.processingEventQNames); + } + + public void addSupportedLocale(Locale locale) { + this.supportedLocales.add(locale); + } + + @Override + public Enumeration getSupportedLocales() { + return Collections.enumeration(this.supportedLocales); + } + + public void addContainerRuntimeOption(String key, String value) { + this.containerRuntimeOptions.put(key, new String[] {value}); + } + + public void addContainerRuntimeOption(String key, String[] values) { + this.containerRuntimeOptions.put(key, values); + } + + @Override + public Map getContainerRuntimeOptions() { + return Collections.unmodifiableMap(this.containerRuntimeOptions); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletContext.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletContext.java new file mode 100644 index 000000000..3cf0a5d47 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletContext.java @@ -0,0 +1,285 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.File; +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.HashSet; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; +import javax.portlet.PortletContext; +import javax.portlet.PortletRequestDispatcher; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.springframework.core.io.DefaultResourceLoader; +import org.springframework.core.io.Resource; +import org.springframework.core.io.ResourceLoader; +import org.springframework.util.Assert; +import org.springframework.web.util.WebUtils; + +/** + * Mock implementation of the {@link javax.portlet.PortletContext} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockPortletContext implements PortletContext { + + private static final String TEMP_DIR_SYSTEM_PROPERTY = "java.io.tmpdir"; + + + private final Log logger = LogFactory.getLog(getClass()); + + private final String resourceBasePath; + + private final ResourceLoader resourceLoader; + + private final Map attributes = new LinkedHashMap(); + + private final Map initParameters = new LinkedHashMap(); + + private String portletContextName = "MockPortletContext"; + + private Set containerRuntimeOptions = new LinkedHashSet(); + + + /** + * Create a new MockPortletContext with no base path and a + * DefaultResourceLoader (i.e. the classpath root as WAR root). + * @see org.springframework.core.io.DefaultResourceLoader + */ + public MockPortletContext() { + this("", null); + } + + /** + * Create a new MockPortletContext using a DefaultResourceLoader. + * @param resourceBasePath the WAR root directory (should not end with a slash) + * @see org.springframework.core.io.DefaultResourceLoader + */ + public MockPortletContext(String resourceBasePath) { + this(resourceBasePath, null); + } + + /** + * Create a new MockPortletContext, using the specified ResourceLoader + * and no base path. + * @param resourceLoader the ResourceLoader to use (or null for the default) + */ + public MockPortletContext(ResourceLoader resourceLoader) { + this("", resourceLoader); + } + + /** + * Create a new MockPortletContext. + * @param resourceBasePath the WAR root directory (should not end with a slash) + * @param resourceLoader the ResourceLoader to use (or null for the default) + */ + public MockPortletContext(String resourceBasePath, ResourceLoader resourceLoader) { + this.resourceBasePath = (resourceBasePath != null ? resourceBasePath : ""); + this.resourceLoader = (resourceLoader != null ? resourceLoader : new DefaultResourceLoader()); + + // Use JVM temp dir as PortletContext temp dir. + String tempDir = System.getProperty(TEMP_DIR_SYSTEM_PROPERTY); + if (tempDir != null) { + this.attributes.put(WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE, new File(tempDir)); + } + } + + /** + * Build a full resource location for the given path, + * prepending the resource base path of this MockPortletContext. + * @param path the path as specified + * @return the full resource path + */ + protected String getResourceLocation(String path) { + if (!path.startsWith("/")) { + path = "/" + path; + } + return this.resourceBasePath + path; + } + + + @Override + public String getServerInfo() { + return "MockPortal/1.0"; + } + + @Override + public PortletRequestDispatcher getRequestDispatcher(String path) { + if (!path.startsWith("/")) { + throw new IllegalArgumentException( + "PortletRequestDispatcher path at PortletContext level must start with '/'"); + } + return new MockPortletRequestDispatcher(path); + } + + @Override + public PortletRequestDispatcher getNamedDispatcher(String path) { + return null; + } + + @Override + public InputStream getResourceAsStream(String path) { + Resource resource = this.resourceLoader.getResource(getResourceLocation(path)); + try { + return resource.getInputStream(); + } + catch (IOException ex) { + logger.info("Couldn't open InputStream for " + resource, ex); + return null; + } + } + + @Override + public int getMajorVersion() { + return 2; + } + + @Override + public int getMinorVersion() { + return 0; + } + + @Override + public String getMimeType(String filePath) { + return null; + } + + @Override + public String getRealPath(String path) { + Resource resource = this.resourceLoader.getResource(getResourceLocation(path)); + try { + return resource.getFile().getAbsolutePath(); + } + catch (IOException ex) { + logger.info("Couldn't determine real path of resource " + resource, ex); + return null; + } + } + + @Override + public Set getResourcePaths(String path) { + Resource resource = this.resourceLoader.getResource(getResourceLocation(path)); + try { + File file = resource.getFile(); + String[] fileList = file.list(); + String prefix = (path.endsWith("/") ? path : path + "/"); + Set resourcePaths = new HashSet(fileList.length); + for (String fileEntry : fileList) { + resourcePaths.add(prefix + fileEntry); + } + return resourcePaths; + } + catch (IOException ex) { + logger.info("Couldn't get resource paths for " + resource, ex); + return null; + } + } + + @Override + public URL getResource(String path) throws MalformedURLException { + Resource resource = this.resourceLoader.getResource(getResourceLocation(path)); + try { + return resource.getURL(); + } + catch (IOException ex) { + logger.info("Couldn't get URL for " + resource, ex); + return null; + } + } + + @Override + public Object getAttribute(String name) { + return this.attributes.get(name); + } + + @Override + public Enumeration getAttributeNames() { + return Collections.enumeration(this.attributes.keySet()); + } + + @Override + public void setAttribute(String name, Object value) { + if (value != null) { + this.attributes.put(name, value); + } + else { + this.attributes.remove(name); + } + } + + @Override + public void removeAttribute(String name) { + this.attributes.remove(name); + } + + public void addInitParameter(String name, String value) { + Assert.notNull(name, "Parameter name must not be null"); + this.initParameters.put(name, value); + } + + @Override + public String getInitParameter(String name) { + Assert.notNull(name, "Parameter name must not be null"); + return this.initParameters.get(name); + } + + @Override + public Enumeration getInitParameterNames() { + return Collections.enumeration(this.initParameters.keySet()); + } + + @Override + public void log(String message) { + logger.info(message); + } + + @Override + public void log(String message, Throwable t) { + logger.info(message, t); + } + + public void setPortletContextName(String portletContextName) { + this.portletContextName = portletContextName; + } + + @Override + public String getPortletContextName() { + return this.portletContextName; + } + + public void addContainerRuntimeOption(String key) { + this.containerRuntimeOptions.add(key); + } + + @Override + public Enumeration getContainerRuntimeOptions() { + return Collections.enumeration(this.containerRuntimeOptions); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletPreferences.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletPreferences.java new file mode 100644 index 000000000..60ceca2bf --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletPreferences.java @@ -0,0 +1,123 @@ +/* + * Copyright 2002-2009 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.IOException; +import java.util.Collections; +import java.util.Enumeration; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; +import javax.portlet.PortletPreferences; +import javax.portlet.PreferencesValidator; +import javax.portlet.ReadOnlyException; +import javax.portlet.ValidatorException; + +import org.springframework.util.Assert; + +/** + * Mock implementation of the {@link javax.portlet.PortletPreferences} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockPortletPreferences implements PortletPreferences { + + private PreferencesValidator preferencesValidator; + + private final Map preferences = new LinkedHashMap(); + + private final Set readOnly = new HashSet(); + + + public void setReadOnly(String key, boolean readOnly) { + Assert.notNull(key, "Key must not be null"); + if (readOnly) { + this.readOnly.add(key); + } + else { + this.readOnly.remove(key); + } + } + + @Override + public boolean isReadOnly(String key) { + Assert.notNull(key, "Key must not be null"); + return this.readOnly.contains(key); + } + + @Override + public String getValue(String key, String def) { + Assert.notNull(key, "Key must not be null"); + String[] values = this.preferences.get(key); + return (values != null && values.length > 0 ? values[0] : def); + } + + @Override + public String[] getValues(String key, String[] def) { + Assert.notNull(key, "Key must not be null"); + String[] values = this.preferences.get(key); + return (values != null && values.length > 0 ? values : def); + } + + @Override + public void setValue(String key, String value) throws ReadOnlyException { + setValues(key, new String[] {value}); + } + + @Override + public void setValues(String key, String[] values) throws ReadOnlyException { + Assert.notNull(key, "Key must not be null"); + if (isReadOnly(key)) { + throw new ReadOnlyException("Preference '" + key + "' is read-only"); + } + this.preferences.put(key, values); + } + + @Override + public Enumeration getNames() { + return Collections.enumeration(this.preferences.keySet()); + } + + @Override + public Map getMap() { + return Collections.unmodifiableMap(this.preferences); + } + + @Override + public void reset(String key) throws ReadOnlyException { + Assert.notNull(key, "Key must not be null"); + if (isReadOnly(key)) { + throw new ReadOnlyException("Preference '" + key + "' is read-only"); + } + this.preferences.remove(key); + } + + public void setPreferencesValidator(PreferencesValidator preferencesValidator) { + this.preferencesValidator = preferencesValidator; + } + + @Override + public void store() throws IOException, ValidatorException { + if (this.preferencesValidator != null) { + this.preferencesValidator.validate(this); + } + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletRequest.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletRequest.java new file mode 100644 index 000000000..02ac4a3d9 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletRequest.java @@ -0,0 +1,565 @@ +/* + * Copyright 2002-2014 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.security.Principal; +import java.util.Collections; +import java.util.Enumeration; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import javax.portlet.PortalContext; +import javax.portlet.PortletContext; +import javax.portlet.PortletMode; +import javax.portlet.PortletPreferences; +import javax.portlet.PortletRequest; +import javax.portlet.PortletSession; +import javax.portlet.WindowState; +import javax.servlet.http.Cookie; + +import org.springframework.util.Assert; +import org.springframework.util.CollectionUtils; + +/** + * Mock implementation of the {@link javax.portlet.PortletRequest} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockPortletRequest implements PortletRequest { + + private boolean active = true; + + private final PortalContext portalContext; + + private final PortletContext portletContext; + + private PortletSession session; + + private WindowState windowState = WindowState.NORMAL; + + private PortletMode portletMode = PortletMode.VIEW; + + private PortletPreferences portletPreferences = new MockPortletPreferences(); + + private final Map> properties = new LinkedHashMap>(); + + private final Map attributes = new LinkedHashMap(); + + private final Map parameters = new LinkedHashMap(); + + private String authType = null; + + private String contextPath = ""; + + private String remoteUser = null; + + private Principal userPrincipal = null; + + private final Set userRoles = new HashSet(); + + private boolean secure = false; + + private boolean requestedSessionIdValid = true; + + private final List responseContentTypes = new LinkedList(); + + private final List locales = new LinkedList(); + + private String scheme = "http"; + + private String serverName = "localhost"; + + private int serverPort = 80; + + private String windowID; + + private Cookie[] cookies; + + private final Set publicParameterNames = new HashSet(); + + + /** + * Create a new MockPortletRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @see MockPortalContext + * @see MockPortletContext + */ + public MockPortletRequest() { + this(null, null); + } + + /** + * Create a new MockPortletRequest with a default {@link MockPortalContext}. + * @param portletContext the PortletContext that the request runs in + * @see MockPortalContext + */ + public MockPortletRequest(PortletContext portletContext) { + this(null, portletContext); + } + + /** + * Create a new MockPortletRequest. + * @param portalContext the PortalContext that the request runs in + * @param portletContext the PortletContext that the request runs in + */ + public MockPortletRequest(PortalContext portalContext, PortletContext portletContext) { + this.portalContext = (portalContext != null ? portalContext : new MockPortalContext()); + this.portletContext = (portletContext != null ? portletContext : new MockPortletContext()); + this.responseContentTypes.add("text/html"); + this.locales.add(Locale.ENGLISH); + this.attributes.put(LIFECYCLE_PHASE, getLifecyclePhase()); + } + + + //--------------------------------------------------------------------- + // Lifecycle methods + //--------------------------------------------------------------------- + + /** + * Return the Portlet 2.0 lifecycle id for the current phase. + */ + protected String getLifecyclePhase() { + return null; + } + + /** + * Return whether this request is still active (that is, not completed yet). + */ + public boolean isActive() { + return this.active; + } + + /** + * Mark this request as completed. + */ + public void close() { + this.active = false; + } + + /** + * Check whether this request is still active (that is, not completed yet), + * throwing an IllegalStateException if not active anymore. + */ + protected void checkActive() throws IllegalStateException { + if (!this.active) { + throw new IllegalStateException("Request is not active anymore"); + } + } + + + //--------------------------------------------------------------------- + // PortletRequest methods + //--------------------------------------------------------------------- + + @Override + public boolean isWindowStateAllowed(WindowState windowState) { + return CollectionUtils.contains(this.portalContext.getSupportedWindowStates(), windowState); + } + + @Override + public boolean isPortletModeAllowed(PortletMode portletMode) { + return CollectionUtils.contains(this.portalContext.getSupportedPortletModes(), portletMode); + } + + public void setPortletMode(PortletMode portletMode) { + Assert.notNull(portletMode, "PortletMode must not be null"); + this.portletMode = portletMode; + } + + @Override + public PortletMode getPortletMode() { + return this.portletMode; + } + + public void setWindowState(WindowState windowState) { + Assert.notNull(windowState, "WindowState must not be null"); + this.windowState = windowState; + } + + @Override + public WindowState getWindowState() { + return this.windowState; + } + + public void setPreferences(PortletPreferences preferences) { + Assert.notNull(preferences, "PortletPreferences must not be null"); + this.portletPreferences = preferences; + } + + @Override + public PortletPreferences getPreferences() { + return this.portletPreferences; + } + + public void setSession(PortletSession session) { + this.session = session; + if (session instanceof MockPortletSession) { + MockPortletSession mockSession = ((MockPortletSession) session); + mockSession.access(); + } + } + + @Override + public PortletSession getPortletSession() { + return getPortletSession(true); + } + + @Override + public PortletSession getPortletSession(boolean create) { + checkActive(); + // Reset session if invalidated. + if (this.session instanceof MockPortletSession && ((MockPortletSession) this.session).isInvalid()) { + this.session = null; + } + // Create new session if necessary. + if (this.session == null && create) { + this.session = new MockPortletSession(this.portletContext); + } + return this.session; + } + + /** + * Set a single value for the specified property. + *

If there are already one or more values registered for the given + * property key, they will be replaced. + */ + public void setProperty(String key, String value) { + Assert.notNull(key, "Property key must not be null"); + List list = new LinkedList(); + list.add(value); + this.properties.put(key, list); + } + + /** + * Add a single value for the specified property. + *

If there are already one or more values registered for the given + * property key, the given value will be added to the end of the list. + */ + public void addProperty(String key, String value) { + Assert.notNull(key, "Property key must not be null"); + List oldList = this.properties.get(key); + if (oldList != null) { + oldList.add(value); + } + else { + List list = new LinkedList(); + list.add(value); + this.properties.put(key, list); + } + } + + @Override + public String getProperty(String key) { + Assert.notNull(key, "Property key must not be null"); + List list = this.properties.get(key); + return (list != null && list.size() > 0 ? list.get(0) : null); + } + + @Override + public Enumeration getProperties(String key) { + Assert.notNull(key, "property key must not be null"); + return Collections.enumeration(this.properties.get(key)); + } + + @Override + public Enumeration getPropertyNames() { + return Collections.enumeration(this.properties.keySet()); + } + + @Override + public PortalContext getPortalContext() { + return this.portalContext; + } + + public void setAuthType(String authType) { + this.authType = authType; + } + + @Override + public String getAuthType() { + return this.authType; + } + + public void setContextPath(String contextPath) { + this.contextPath = contextPath; + } + + @Override + public String getContextPath() { + return this.contextPath; + } + + public void setRemoteUser(String remoteUser) { + this.remoteUser = remoteUser; + } + + @Override + public String getRemoteUser() { + return this.remoteUser; + } + + public void setUserPrincipal(Principal userPrincipal) { + this.userPrincipal = userPrincipal; + } + + @Override + public Principal getUserPrincipal() { + return this.userPrincipal; + } + + public void addUserRole(String role) { + this.userRoles.add(role); + } + + @Override + public boolean isUserInRole(String role) { + return this.userRoles.contains(role); + } + + @Override + public Object getAttribute(String name) { + checkActive(); + return this.attributes.get(name); + } + + @Override + public Enumeration getAttributeNames() { + checkActive(); + return Collections.enumeration(this.attributes.keySet()); + } + + public void setParameters(Map parameters) { + Assert.notNull(parameters, "Parameters Map must not be null"); + this.parameters.clear(); + this.parameters.putAll(parameters); + } + + public void setParameter(String key, String value) { + Assert.notNull(key, "Parameter key must be null"); + Assert.notNull(value, "Parameter value must not be null"); + this.parameters.put(key, new String[] {value}); + } + + public void setParameter(String key, String[] values) { + Assert.notNull(key, "Parameter key must be null"); + Assert.notNull(values, "Parameter values must not be null"); + this.parameters.put(key, values); + } + + public void addParameter(String name, String value) { + addParameter(name, new String[] {value}); + } + + public void addParameter(String name, String[] values) { + String[] oldArr = this.parameters.get(name); + if (oldArr != null) { + String[] newArr = new String[oldArr.length + values.length]; + System.arraycopy(oldArr, 0, newArr, 0, oldArr.length); + System.arraycopy(values, 0, newArr, oldArr.length, values.length); + this.parameters.put(name, newArr); + } + else { + this.parameters.put(name, values); + } + } + + @Override + public String getParameter(String name) { + String[] arr = this.parameters.get(name); + return (arr != null && arr.length > 0 ? arr[0] : null); + } + + @Override + public Enumeration getParameterNames() { + return Collections.enumeration(this.parameters.keySet()); + } + + @Override + public String[] getParameterValues(String name) { + return this.parameters.get(name); + } + + @Override + public Map getParameterMap() { + return Collections.unmodifiableMap(this.parameters); + } + + public void setSecure(boolean secure) { + this.secure = secure; + } + + @Override + public boolean isSecure() { + return this.secure; + } + + @Override + public void setAttribute(String name, Object value) { + checkActive(); + if (value != null) { + this.attributes.put(name, value); + } + else { + this.attributes.remove(name); + } + } + + @Override + public void removeAttribute(String name) { + checkActive(); + this.attributes.remove(name); + } + + @Override + public String getRequestedSessionId() { + PortletSession session = this.getPortletSession(); + return (session != null ? session.getId() : null); + } + + public void setRequestedSessionIdValid(boolean requestedSessionIdValid) { + this.requestedSessionIdValid = requestedSessionIdValid; + } + + @Override + public boolean isRequestedSessionIdValid() { + return this.requestedSessionIdValid; + } + + public void addResponseContentType(String responseContentType) { + this.responseContentTypes.add(responseContentType); + } + + public void addPreferredResponseContentType(String responseContentType) { + this.responseContentTypes.add(0, responseContentType); + } + + @Override + public String getResponseContentType() { + return this.responseContentTypes.get(0); + } + + @Override + public Enumeration getResponseContentTypes() { + return Collections.enumeration(this.responseContentTypes); + } + + public void addLocale(Locale locale) { + this.locales.add(locale); + } + + public void addPreferredLocale(Locale locale) { + this.locales.add(0, locale); + } + + @Override + public Locale getLocale() { + return this.locales.get(0); + } + + @Override + public Enumeration getLocales() { + return Collections.enumeration(this.locales); + } + + public void setScheme(String scheme) { + this.scheme = scheme; + } + + @Override + public String getScheme() { + return this.scheme; + } + + public void setServerName(String serverName) { + this.serverName = serverName; + } + + @Override + public String getServerName() { + return this.serverName; + } + + public void setServerPort(int serverPort) { + this.serverPort = serverPort; + } + + @Override + public int getServerPort() { + return this.serverPort; + } + + public void setWindowID(String windowID) { + this.windowID = windowID; + } + + @Override + public String getWindowID() { + return this.windowID; + } + + public void setCookies(Cookie... cookies) { + this.cookies = cookies; + } + + @Override + public Cookie[] getCookies() { + return this.cookies; + } + + @Override + public Map getPrivateParameterMap() { + if (!this.publicParameterNames.isEmpty()) { + Map filtered = new LinkedHashMap(); + for (String key : this.parameters.keySet()) { + if (!this.publicParameterNames.contains(key)) { + filtered.put(key, this.parameters.get(key)); + } + } + return filtered; + } + else { + return Collections.unmodifiableMap(this.parameters); + } + } + + @Override + public Map getPublicParameterMap() { + if (!this.publicParameterNames.isEmpty()) { + Map filtered = new LinkedHashMap(); + for (String key : this.parameters.keySet()) { + if (this.publicParameterNames.contains(key)) { + filtered.put(key, this.parameters.get(key)); + } + } + return filtered; + } + else { + return Collections.emptyMap(); + } + } + + public void registerPublicParameter(String name) { + this.publicParameterNames.add(name); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletRequestDispatcher.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletRequestDispatcher.java new file mode 100644 index 000000000..e80f774a6 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletRequestDispatcher.java @@ -0,0 +1,87 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.IOException; +import javax.portlet.PortletException; +import javax.portlet.PortletRequest; +import javax.portlet.PortletRequestDispatcher; +import javax.portlet.PortletResponse; +import javax.portlet.RenderRequest; +import javax.portlet.RenderResponse; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.springframework.util.Assert; + +/** + * Mock implementation of the {@link javax.portlet.PortletRequestDispatcher} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockPortletRequestDispatcher implements PortletRequestDispatcher { + + private final Log logger = LogFactory.getLog(getClass()); + + private final String url; + + + /** + * Create a new MockPortletRequestDispatcher for the given URL. + * @param url the URL to dispatch to. + */ + public MockPortletRequestDispatcher(String url) { + Assert.notNull(url, "URL must not be null"); + this.url = url; + } + + + @Override + public void include(RenderRequest request, RenderResponse response) throws PortletException, IOException { + include((PortletRequest) request, (PortletResponse) response); + } + + @Override + public void include(PortletRequest request, PortletResponse response) throws PortletException, IOException { + Assert.notNull(request, "Request must not be null"); + Assert.notNull(response, "Response must not be null"); + if (!(response instanceof MockMimeResponse)) { + throw new IllegalArgumentException("MockPortletRequestDispatcher requires MockMimeResponse"); + } + ((MockMimeResponse) response).setIncludedUrl(this.url); + if (logger.isDebugEnabled()) { + logger.debug("MockPortletRequestDispatcher: including URL [" + this.url + "]"); + } + } + + @Override + public void forward(PortletRequest request, PortletResponse response) throws PortletException, IOException { + Assert.notNull(request, "Request must not be null"); + Assert.notNull(response, "Response must not be null"); + if (!(response instanceof MockMimeResponse)) { + throw new IllegalArgumentException("MockPortletRequestDispatcher requires MockMimeResponse"); + } + ((MockMimeResponse) response).setForwardedUrl(this.url); + if (logger.isDebugEnabled()) { + logger.debug("MockPortletRequestDispatcher: forwarding to URL [" + this.url + "]"); + } + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletResponse.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletResponse.java new file mode 100644 index 000000000..1e69a5392 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletResponse.java @@ -0,0 +1,202 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; +import javax.portlet.PortalContext; +import javax.portlet.PortletResponse; +import javax.servlet.http.Cookie; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; + +import org.w3c.dom.DOMException; +import org.w3c.dom.Document; +import org.w3c.dom.Element; + +import org.springframework.util.Assert; + +/** + * Mock implementation of the {@link javax.portlet.PortletResponse} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockPortletResponse implements PortletResponse { + + private final PortalContext portalContext; + + private final Map properties = new LinkedHashMap(); + + private String namespace = ""; + + private final Set cookies = new LinkedHashSet(); + + private final Map xmlProperties = new LinkedHashMap(); + + private Document xmlDocument; + + + /** + * Create a new MockPortletResponse with a default {@link MockPortalContext}. + * @see MockPortalContext + */ + public MockPortletResponse() { + this(null); + } + + /** + * Create a new MockPortletResponse. + * @param portalContext the PortalContext defining the supported + * PortletModes and WindowStates + */ + public MockPortletResponse(PortalContext portalContext) { + this.portalContext = (portalContext != null ? portalContext : new MockPortalContext()); + } + + /** + * Return the PortalContext that this MockPortletResponse runs in, + * defining the supported PortletModes and WindowStates. + */ + public PortalContext getPortalContext() { + return this.portalContext; + } + + + //--------------------------------------------------------------------- + // PortletResponse methods + //--------------------------------------------------------------------- + + @Override + public void addProperty(String key, String value) { + Assert.notNull(key, "Property key must not be null"); + String[] oldArr = this.properties.get(key); + if (oldArr != null) { + String[] newArr = new String[oldArr.length + 1]; + System.arraycopy(oldArr, 0, newArr, 0, oldArr.length); + newArr[oldArr.length] = value; + this.properties.put(key, newArr); + } + else { + this.properties.put(key, new String[] {value}); + } + } + + @Override + public void setProperty(String key, String value) { + Assert.notNull(key, "Property key must not be null"); + this.properties.put(key, new String[] {value}); + } + + public Set getPropertyNames() { + return Collections.unmodifiableSet(this.properties.keySet()); + } + + public String getProperty(String key) { + Assert.notNull(key, "Property key must not be null"); + String[] arr = this.properties.get(key); + return (arr != null && arr.length > 0 ? arr[0] : null); + } + + public String[] getProperties(String key) { + Assert.notNull(key, "Property key must not be null"); + return this.properties.get(key); + } + + @Override + public String encodeURL(String path) { + return path; + } + + public void setNamespace(String namespace) { + this.namespace = namespace; + } + + @Override + public String getNamespace() { + return this.namespace; + } + + @Override + public void addProperty(Cookie cookie) { + Assert.notNull(cookie, "Cookie must not be null"); + this.cookies.add(cookie); + } + + public Cookie[] getCookies() { + return this.cookies.toArray(new Cookie[this.cookies.size()]); + } + + public Cookie getCookie(String name) { + Assert.notNull(name, "Cookie name must not be null"); + for (Cookie cookie : this.cookies) { + if (name.equals(cookie.getName())) { + return cookie; + } + } + return null; + } + + @Override + public void addProperty(String key, Element value) { + Assert.notNull(key, "Property key must not be null"); + Element[] oldArr = this.xmlProperties.get(key); + if (oldArr != null) { + Element[] newArr = new Element[oldArr.length + 1]; + System.arraycopy(oldArr, 0, newArr, 0, oldArr.length); + newArr[oldArr.length] = value; + this.xmlProperties.put(key, newArr); + } + else { + this.xmlProperties.put(key, new Element[] {value}); + } + } + + + public Set getXmlPropertyNames() { + return Collections.unmodifiableSet(this.xmlProperties.keySet()); + } + + public Element getXmlProperty(String key) { + Assert.notNull(key, "Property key must not be null"); + Element[] arr = this.xmlProperties.get(key); + return (arr != null && arr.length > 0 ? arr[0] : null); + } + + public Element[] getXmlProperties(String key) { + Assert.notNull(key, "Property key must not be null"); + return this.xmlProperties.get(key); + } + + @Override + public Element createElement(String tagName) throws DOMException { + if (this.xmlDocument == null) { + try { + this.xmlDocument = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); + } + catch (ParserConfigurationException ex) { + throw new DOMException(DOMException.INVALID_STATE_ERR, ex.toString()); + } + } + return this.xmlDocument.createElement(tagName); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletSession.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletSession.java new file mode 100644 index 000000000..ca1a44ae7 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletSession.java @@ -0,0 +1,249 @@ +/* + * Copyright 2002-2013 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.util.Collections; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import javax.portlet.PortletContext; +import javax.portlet.PortletSession; +import javax.servlet.http.HttpSessionBindingEvent; +import javax.servlet.http.HttpSessionBindingListener; + +import org.springframework.mock.web.MockHttpSession; + +/** + * Mock implementation of the {@link javax.portlet.PortletSession} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockPortletSession implements PortletSession { + + private static int nextId = 1; + + + private final String id = Integer.toString(nextId++); + + private final long creationTime = System.currentTimeMillis(); + + private int maxInactiveInterval; + + private long lastAccessedTime = System.currentTimeMillis(); + + private final PortletContext portletContext; + + private final Map portletAttributes = new HashMap(); + + private final Map applicationAttributes = new HashMap(); + + private boolean invalid = false; + + private boolean isNew = true; + + + /** + * Create a new MockPortletSession with a default {@link MockPortletContext}. + * @see MockPortletContext + */ + public MockPortletSession() { + this(null); + } + + /** + * Create a new MockPortletSession. + * @param portletContext the PortletContext that the session runs in + */ + public MockPortletSession(PortletContext portletContext) { + this.portletContext = (portletContext != null ? portletContext : new MockPortletContext()); + } + + + @Override + public Object getAttribute(String name) { + return this.portletAttributes.get(name); + } + + @Override + public Object getAttribute(String name, int scope) { + if (scope == PortletSession.PORTLET_SCOPE) { + return this.portletAttributes.get(name); + } + else if (scope == PortletSession.APPLICATION_SCOPE) { + return this.applicationAttributes.get(name); + } + return null; + } + + @Override + public Enumeration getAttributeNames() { + return Collections.enumeration(this.portletAttributes.keySet()); + } + + @Override + public Enumeration getAttributeNames(int scope) { + if (scope == PortletSession.PORTLET_SCOPE) { + return Collections.enumeration(this.portletAttributes.keySet()); + } + else if (scope == PortletSession.APPLICATION_SCOPE) { + return Collections.enumeration(this.applicationAttributes.keySet()); + } + return null; + } + + @Override + public long getCreationTime() { + return this.creationTime; + } + + @Override + public String getId() { + return this.id; + } + + public void access() { + this.lastAccessedTime = System.currentTimeMillis(); + setNew(false); + } + + @Override + public long getLastAccessedTime() { + return this.lastAccessedTime; + } + + @Override + public int getMaxInactiveInterval() { + return this.maxInactiveInterval; + } + + /** + * Clear all of this session's attributes. + */ + public void clearAttributes() { + doClearAttributes(this.portletAttributes); + doClearAttributes(this.applicationAttributes); + } + + protected void doClearAttributes(Map attributes) { + for (Iterator> it = attributes.entrySet().iterator(); it.hasNext();) { + Map.Entry entry = it.next(); + String name = entry.getKey(); + Object value = entry.getValue(); + it.remove(); + if (value instanceof HttpSessionBindingListener) { + ((HttpSessionBindingListener) value).valueUnbound( + new HttpSessionBindingEvent(new MockHttpSession(), name, value)); + } + } + } + + @Override + public void invalidate() { + this.invalid = true; + clearAttributes(); + } + + public boolean isInvalid() { + return this.invalid; + } + + public void setNew(boolean value) { + this.isNew = value; + } + + @Override + public boolean isNew() { + return this.isNew; + } + + @Override + public void removeAttribute(String name) { + this.portletAttributes.remove(name); + } + + @Override + public void removeAttribute(String name, int scope) { + if (scope == PortletSession.PORTLET_SCOPE) { + this.portletAttributes.remove(name); + } + else if (scope == PortletSession.APPLICATION_SCOPE) { + this.applicationAttributes.remove(name); + } + } + + @Override + public void setAttribute(String name, Object value) { + if (value != null) { + this.portletAttributes.put(name, value); + } + else { + this.portletAttributes.remove(name); + } + } + + @Override + public void setAttribute(String name, Object value, int scope) { + if (scope == PortletSession.PORTLET_SCOPE) { + if (value != null) { + this.portletAttributes.put(name, value); + } + else { + this.portletAttributes.remove(name); + } + } + else if (scope == PortletSession.APPLICATION_SCOPE) { + if (value != null) { + this.applicationAttributes.put(name, value); + } + else { + this.applicationAttributes.remove(name); + } + } + } + + @Override + public void setMaxInactiveInterval(int interval) { + this.maxInactiveInterval = interval; + } + + @Override + public PortletContext getPortletContext() { + return this.portletContext; + } + + @Override + public Map getAttributeMap() { + return Collections.unmodifiableMap(this.portletAttributes); + } + + @Override + public Map getAttributeMap(int scope) { + if (scope == PortletSession.PORTLET_SCOPE) { + return Collections.unmodifiableMap(this.portletAttributes); + } + else if (scope == PortletSession.APPLICATION_SCOPE) { + return Collections.unmodifiableMap(this.applicationAttributes); + } + else { + return Collections.emptyMap(); + } + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletURL.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletURL.java new file mode 100644 index 000000000..503807e7c --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockPortletURL.java @@ -0,0 +1,121 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.util.Map; +import javax.portlet.PortalContext; +import javax.portlet.PortletMode; +import javax.portlet.PortletModeException; +import javax.portlet.PortletURL; +import javax.portlet.WindowState; +import javax.portlet.WindowStateException; + +import org.springframework.util.Assert; +import org.springframework.util.CollectionUtils; + +/** + * Mock implementation of the {@link javax.portlet.PortletURL} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockPortletURL extends MockBaseURL implements PortletURL { + + public static final String URL_TYPE_RENDER = "render"; + + public static final String URL_TYPE_ACTION = "action"; + + + private final PortalContext portalContext; + + private final String urlType; + + private WindowState windowState; + + private PortletMode portletMode; + + + /** + * Create a new MockPortletURL for the given URL type. + * @param portalContext the PortalContext defining the supported + * PortletModes and WindowStates + * @param urlType the URL type, for example "render" or "action" + * @see #URL_TYPE_RENDER + * @see #URL_TYPE_ACTION + */ + public MockPortletURL(PortalContext portalContext, String urlType) { + Assert.notNull(portalContext, "PortalContext is required"); + this.portalContext = portalContext; + this.urlType = urlType; + } + + + //--------------------------------------------------------------------- + // PortletURL methods + //--------------------------------------------------------------------- + + @Override + public void setWindowState(WindowState windowState) throws WindowStateException { + if (!CollectionUtils.contains(this.portalContext.getSupportedWindowStates(), windowState)) { + throw new WindowStateException("WindowState not supported", windowState); + } + this.windowState = windowState; + } + + @Override + public WindowState getWindowState() { + return this.windowState; + } + + @Override + public void setPortletMode(PortletMode portletMode) throws PortletModeException { + if (!CollectionUtils.contains(this.portalContext.getSupportedPortletModes(), portletMode)) { + throw new PortletModeException("PortletMode not supported", portletMode); + } + this.portletMode = portletMode; + } + + @Override + public PortletMode getPortletMode() { + return this.portletMode; + } + + @Override + public void removePublicRenderParameter(String name) { + this.parameters.remove(name); + } + + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(encodeParameter("urlType", this.urlType)); + if (this.windowState != null) { + sb.append(";").append(encodeParameter("windowState", this.windowState.toString())); + } + if (this.portletMode != null) { + sb.append(";").append(encodeParameter("portletMode", this.portletMode.toString())); + } + for (Map.Entry entry : this.parameters.entrySet()) { + sb.append(";").append(encodeParameter("param_" + entry.getKey(), entry.getValue())); + } + return (isSecure() ? "https:" : "http:") + + "//localhost/mockportlet?" + sb.toString(); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockRenderRequest.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockRenderRequest.java new file mode 100644 index 000000000..fe5c11a6c --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockRenderRequest.java @@ -0,0 +1,94 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import javax.portlet.PortalContext; +import javax.portlet.PortletContext; +import javax.portlet.PortletMode; +import javax.portlet.RenderRequest; +import javax.portlet.WindowState; + +/** + * Mock implementation of the {@link javax.portlet.RenderRequest} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockRenderRequest extends MockPortletRequest implements RenderRequest { + + /** + * Create a new MockRenderRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @see MockPortalContext + * @see MockPortletContext + */ + public MockRenderRequest() { + super(); + } + + /** + * Create a new MockRenderRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @param portletMode the mode that the portlet runs in + */ + public MockRenderRequest(PortletMode portletMode) { + super(); + setPortletMode(portletMode); + } + + /** + * Create a new MockRenderRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @param portletMode the mode that the portlet runs in + * @param windowState the window state to run the portlet in + */ + public MockRenderRequest(PortletMode portletMode, WindowState windowState) { + super(); + setPortletMode(portletMode); + setWindowState(windowState); + } + + /** + * Create a new MockRenderRequest with a default {@link MockPortalContext}. + * @param portletContext the PortletContext that the request runs in + */ + public MockRenderRequest(PortletContext portletContext) { + super(portletContext); + } + + /** + * Create a new MockRenderRequest. + * @param portalContext the PortletContext that the request runs in + * @param portletContext the PortletContext that the request runs in + */ + public MockRenderRequest(PortalContext portalContext, PortletContext portletContext) { + super(portalContext, portletContext); + } + + + @Override + protected String getLifecyclePhase() { + return RENDER_PHASE; + } + + @Override + public String getETag() { + return getProperty(RenderRequest.ETAG); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockRenderResponse.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockRenderResponse.java new file mode 100644 index 000000000..defa5e9f7 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockRenderResponse.java @@ -0,0 +1,90 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.util.Collection; +import javax.portlet.PortalContext; +import javax.portlet.PortletMode; +import javax.portlet.RenderRequest; +import javax.portlet.RenderResponse; + +/** + * Mock implementation of the {@link javax.portlet.RenderResponse} interface. + * + * @author John A. Lewis + * @author Juergen Hoeller + * @since 2.0 + */ +public class MockRenderResponse extends MockMimeResponse implements RenderResponse { + + private String title; + + private Collection nextPossiblePortletModes; + + + /** + * Create a new MockRenderResponse with a default {@link MockPortalContext}. + * @see MockPortalContext + */ + public MockRenderResponse() { + super(); + } + + /** + * Create a new MockRenderResponse. + * @param portalContext the PortalContext defining the supported + * PortletModes and WindowStates + */ + public MockRenderResponse(PortalContext portalContext) { + super(portalContext); + } + + /** + * Create a new MockRenderResponse. + * @param portalContext the PortalContext defining the supported + * PortletModes and WindowStates + * @param request the corresponding render request that this response + * is generated for + */ + public MockRenderResponse(PortalContext portalContext, RenderRequest request) { + super(portalContext, request); + } + + + //--------------------------------------------------------------------- + // RenderResponse methods + //--------------------------------------------------------------------- + + @Override + public void setTitle(String title) { + this.title = title; + } + + public String getTitle() { + return this.title; + } + + @Override + public void setNextPossiblePortletModes(Collection portletModes) { + this.nextPossiblePortletModes = portletModes; + } + + public Collection getNextPossiblePortletModes() { + return this.nextPossiblePortletModes; + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockResourceRequest.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockResourceRequest.java new file mode 100644 index 000000000..421217069 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockResourceRequest.java @@ -0,0 +1,132 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.Map; +import javax.portlet.PortalContext; +import javax.portlet.PortletContext; +import javax.portlet.RenderRequest; +import javax.portlet.ResourceRequest; + +/** + * Mock implementation of the {@link javax.portlet.ResourceRequest} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public class MockResourceRequest extends MockClientDataRequest implements ResourceRequest { + + private String resourceID; + + private String cacheability; + + private final Map privateRenderParameterMap = new LinkedHashMap(); + + + /** + * Create a new MockResourceRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @see org.springframework.mock.web.portlet.MockPortalContext + * @see org.springframework.mock.web.portlet.MockPortletContext + */ + public MockResourceRequest() { + super(); + } + + /** + * Create a new MockResourceRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @param resourceID the resource id for this request + */ + public MockResourceRequest(String resourceID) { + super(); + this.resourceID = resourceID; + } + + /** + * Create a new MockResourceRequest with a default {@link MockPortalContext} + * and a default {@link MockPortletContext}. + * @param url the resource URL for this request + */ + public MockResourceRequest(MockResourceURL url) { + super(); + this.resourceID = url.getResourceID(); + this.cacheability = url.getCacheability(); + } + + /** + * Create a new MockResourceRequest with a default {@link MockPortalContext}. + * @param portletContext the PortletContext that the request runs in + */ + public MockResourceRequest(PortletContext portletContext) { + super(portletContext); + } + + /** + * Create a new MockResourceRequest. + * @param portalContext the PortalContext that the request runs in + * @param portletContext the PortletContext that the request runs in + */ + public MockResourceRequest(PortalContext portalContext, PortletContext portletContext) { + super(portalContext, portletContext); + } + + + @Override + protected String getLifecyclePhase() { + return RESOURCE_PHASE; + } + + public void setResourceID(String resourceID) { + this.resourceID = resourceID; + } + + @Override + public String getResourceID() { + return this.resourceID; + } + + public void setCacheability(String cacheLevel) { + this.cacheability = cacheLevel; + } + + @Override + public String getCacheability() { + return this.cacheability; + } + + @Override + public String getETag() { + return getProperty(RenderRequest.ETAG); + } + + public void addPrivateRenderParameter(String key, String value) { + this.privateRenderParameterMap.put(key, new String[] {value}); + } + + public void addPrivateRenderParameter(String key, String[] values) { + this.privateRenderParameterMap.put(key, values); + } + + @Override + public Map getPrivateRenderParameterMap() { + return Collections.unmodifiableMap(this.privateRenderParameterMap); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockResourceResponse.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockResourceResponse.java new file mode 100644 index 000000000..06bba7a00 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockResourceResponse.java @@ -0,0 +1,41 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import javax.portlet.ResourceResponse; + +/** + * Mock implementation of the {@link javax.portlet.ResourceResponse} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public class MockResourceResponse extends MockMimeResponse implements ResourceResponse { + + private int contentLength = 0; + + + @Override + public void setContentLength(int len) { + this.contentLength = len; + } + + public int getContentLength() { + return this.contentLength; + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockResourceURL.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockResourceURL.java new file mode 100644 index 000000000..e38e08986 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockResourceURL.java @@ -0,0 +1,73 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.util.Map; +import javax.portlet.ResourceURL; + +/** + * Mock implementation of the {@link javax.portlet.ResourceURL} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public class MockResourceURL extends MockBaseURL implements ResourceURL { + + private String resourceID; + + private String cacheability; + + + //--------------------------------------------------------------------- + // ResourceURL methods + //--------------------------------------------------------------------- + + @Override + public void setResourceID(String resourceID) { + this.resourceID = resourceID; + } + + public String getResourceID() { + return this.resourceID; + } + + @Override + public void setCacheability(String cacheLevel) { + this.cacheability = cacheLevel; + } + + @Override + public String getCacheability() { + return this.cacheability; + } + + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(encodeParameter("resourceID", this.resourceID)); + if (this.cacheability != null) { + sb.append(";").append(encodeParameter("cacheability", this.cacheability)); + } + for (Map.Entry entry : this.parameters.entrySet()) { + sb.append(";").append(encodeParameter("param_" + entry.getKey(), entry.getValue())); + } + return (isSecure() ? "https:" : "http:") + + "//localhost/mockportlet?" + sb.toString(); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockStateAwareResponse.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockStateAwareResponse.java new file mode 100644 index 000000000..bb085ba21 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/MockStateAwareResponse.java @@ -0,0 +1,165 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.Serializable; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.Map; +import javax.portlet.PortalContext; +import javax.portlet.PortletMode; +import javax.portlet.PortletModeException; +import javax.portlet.StateAwareResponse; +import javax.portlet.WindowState; +import javax.portlet.WindowStateException; +import javax.xml.namespace.QName; + +import org.springframework.util.Assert; +import org.springframework.util.CollectionUtils; + +/** + * Mock implementation of the {@link javax.portlet.StateAwareResponse} interface. + * + * @author Juergen Hoeller + * @since 3.0 + */ +public class MockStateAwareResponse extends MockPortletResponse implements StateAwareResponse { + + private WindowState windowState; + + private PortletMode portletMode; + + private final Map renderParameters = new LinkedHashMap(); + + private final Map events = new HashMap(); + + + /** + * Create a new MockActionResponse with a default {@link MockPortalContext}. + * @see org.springframework.mock.web.portlet.MockPortalContext + */ + public MockStateAwareResponse() { + super(); + } + + /** + * Create a new MockActionResponse. + * @param portalContext the PortalContext defining the supported + * PortletModes and WindowStates + */ + public MockStateAwareResponse(PortalContext portalContext) { + super(portalContext); + } + + + @Override + public void setWindowState(WindowState windowState) throws WindowStateException { + if (!CollectionUtils.contains(getPortalContext().getSupportedWindowStates(), windowState)) { + throw new WindowStateException("WindowState not supported", windowState); + } + this.windowState = windowState; + } + + @Override + public WindowState getWindowState() { + return this.windowState; + } + + @Override + public void setPortletMode(PortletMode portletMode) throws PortletModeException { + if (!CollectionUtils.contains(getPortalContext().getSupportedPortletModes(), portletMode)) { + throw new PortletModeException("PortletMode not supported", portletMode); + } + this.portletMode = portletMode; + } + + @Override + public PortletMode getPortletMode() { + return this.portletMode; + } + + @Override + public void setRenderParameters(Map parameters) { + Assert.notNull(parameters, "Parameters Map must not be null"); + this.renderParameters.clear(); + this.renderParameters.putAll(parameters); + } + + @Override + public void setRenderParameter(String key, String value) { + Assert.notNull(key, "Parameter key must not be null"); + Assert.notNull(value, "Parameter value must not be null"); + this.renderParameters.put(key, new String[] {value}); + } + + @Override + public void setRenderParameter(String key, String[] values) { + Assert.notNull(key, "Parameter key must not be null"); + Assert.notNull(values, "Parameter values must not be null"); + this.renderParameters.put(key, values); + } + + public String getRenderParameter(String key) { + Assert.notNull(key, "Parameter key must not be null"); + String[] arr = this.renderParameters.get(key); + return (arr != null && arr.length > 0 ? arr[0] : null); + } + + public String[] getRenderParameterValues(String key) { + Assert.notNull(key, "Parameter key must not be null"); + return this.renderParameters.get(key); + } + + public Iterator getRenderParameterNames() { + return this.renderParameters.keySet().iterator(); + } + + @Override + public Map getRenderParameterMap() { + return Collections.unmodifiableMap(this.renderParameters); + } + + @Override + public void removePublicRenderParameter(String name) { + this.renderParameters.remove(name); + } + + @Override + public void setEvent(QName name, Serializable value) { + this.events.put(name, value); + } + + @Override + public void setEvent(String name, Serializable value) { + this.events.put(new QName(name), value); + } + + public Iterator getEventNames() { + return this.events.keySet().iterator(); + } + + public Serializable getEvent(QName name) { + return this.events.get(name); + } + + public Serializable getEvent(String name) { + return this.events.get(new QName(name)); + } + +} \ No newline at end of file diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/ServletWrappingPortletContext.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/ServletWrappingPortletContext.java new file mode 100644 index 000000000..70f8b86db --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/ServletWrappingPortletContext.java @@ -0,0 +1,161 @@ +/* + * Copyright 2002-2016 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet; + +import java.io.InputStream; +import java.net.MalformedURLException; +import java.net.URL; +import java.util.Collections; +import java.util.Enumeration; +import java.util.Set; +import javax.portlet.PortletContext; +import javax.portlet.PortletRequestDispatcher; +import javax.servlet.ServletContext; + +import org.springframework.util.Assert; + +/** + * Mock implementation of the {@link javax.portlet.PortletContext} interface, + * wrapping an underlying {@link javax.servlet.ServletContext}. + * + * @author Juergen Hoeller + * @since 3.0 + * @see MockPortletContext + */ +public class ServletWrappingPortletContext implements PortletContext { + + private final ServletContext servletContext; + + + /** + * Create a new PortletContext wrapping the given ServletContext. + * @param servletContext the ServletContext to wrap + */ + public ServletWrappingPortletContext(ServletContext servletContext) { + Assert.notNull(servletContext, "ServletContext must not be null"); + this.servletContext = servletContext; + } + + /** + * Return the underlying ServletContext that this PortletContext wraps. + */ + public final ServletContext getServletContext() { + return this.servletContext; + } + + + @Override + public String getServerInfo() { + return this.servletContext.getServerInfo(); + } + + @Override + public PortletRequestDispatcher getRequestDispatcher(String path) { + return null; + } + + @Override + public PortletRequestDispatcher getNamedDispatcher(String name) { + return null; + } + + @Override + public InputStream getResourceAsStream(String path) { + return this.servletContext.getResourceAsStream(path); + } + + @Override + public int getMajorVersion() { + return 2; + } + + @Override + public int getMinorVersion() { + return 0; + } + + @Override + public String getMimeType(String file) { + return this.servletContext.getMimeType(file); + } + + @Override + public String getRealPath(String path) { + return this.servletContext.getRealPath(path); + } + + @Override + public Set getResourcePaths(String path) { + return this.servletContext.getResourcePaths(path); + } + + @Override + public URL getResource(String path) throws MalformedURLException { + return this.servletContext.getResource(path); + } + + @Override + public Object getAttribute(String name) { + return this.servletContext.getAttribute(name); + } + + @Override + public Enumeration getAttributeNames() { + return this.servletContext.getAttributeNames(); + } + + @Override + public String getInitParameter(String name) { + return this.servletContext.getInitParameter(name); + } + + @Override + public Enumeration getInitParameterNames() { + return this.servletContext.getInitParameterNames(); + } + + @Override + public void log(String msg) { + this.servletContext.log(msg); + } + + @Override + public void log(String message, Throwable throwable) { + this.servletContext.log(message, throwable); + } + + @Override + public void removeAttribute(String name) { + this.servletContext.removeAttribute(name); + } + + @Override + public void setAttribute(String name, Object object) { + this.servletContext.setAttribute(name, object); + } + + @Override + public String getPortletContextName() { + return this.servletContext.getServletContextName(); + } + + @Override + public Enumeration getContainerRuntimeOptions() { + return Collections.enumeration(Collections.emptySet()); + } + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/multipart/MultipartActionRequest.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/multipart/MultipartActionRequest.java new file mode 100644 index 000000000..6df611fe2 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/multipart/MultipartActionRequest.java @@ -0,0 +1,41 @@ +/* + * Copyright 2002-2008 the original author or authors. + * + * 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 + * + * https://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.struts2.mock.web.portlet.multipart; + +import javax.portlet.ActionRequest; + +import org.springframework.web.multipart.MultipartRequest; + +/** + * Interface which provides additional methods for dealing with multipart + * content within a portlet request, allowing to access uploaded files. + * Implementations also need to override the standard ActionRequest + * methods for parameter access, making multipart parameters available. + * + *

A concrete implementation is {@link DefaultMultipartActionRequest}. + * + * @author Juergen Hoeller + * @since 2.0 + * @see PortletMultipartResolver + * @see org.springframework.web.multipart.MultipartFile + * @see javax.portlet.ActionRequest#getParameter + * @see javax.portlet.ActionRequest#getParameterNames + * @see javax.portlet.ActionRequest#getParameterMap + */ +public interface MultipartActionRequest extends ActionRequest, MultipartRequest { + +} diff --git a/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/multipart/package-info.java b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/multipart/package-info.java new file mode 100644 index 000000000..0ed9b6066 --- /dev/null +++ b/plugins/junit-portlet/src/main/java/org/apache/struts2/mock/web/portlet/multipart/package-info.java @@ -0,0 +1,38 @@ +/* + * Copyright 2002-2016 the original author or authors. + * + * 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 + * + * https://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. + */ +/* + * This package is a copy of the org.springframework.web.portlet.multipart package from Spring 4.3.x + * (org.springframework, spring-webmvc-portlet, EasyMock) or + * existing Portlet API mock objects. + */ +package org.apache.struts2.mock.web.portlet; \ No newline at end of file diff --git a/plugins/junit-portlet/src/site/site.xml b/plugins/junit-portlet/src/site/site.xml new file mode 100644 index 000000000..54fdcf4f4 --- /dev/null +++ b/plugins/junit-portlet/src/site/site.xml @@ -0,0 +1,56 @@ + + + + + org.apache.maven.skins + maven-fluido-skin + ${fluido-skin.version} + + + Apache Software Foundation + http://www.apache.org/images/asf-logo.gif + http://www.apache.org/ + + + Apache Struts + http://struts.apache.org/img/struts-logo.svg + http://struts.apache.org/ + + + + + + + + + +

+ + +
+ + Apache Struts, Struts, Apache, the Apache feather logo, and the Apache Struts project + logos are trademarks of The Apache Software Foundation. + ]]> +
+ + diff --git a/plugins/junit-portlet/src/test/java/org/apache/struts2/StrutsSpringPortletMockObjectsTest.java b/plugins/junit-portlet/src/test/java/org/apache/struts2/StrutsSpringPortletMockObjectsTest.java new file mode 100644 index 000000000..6ba60f3d3 --- /dev/null +++ b/plugins/junit-portlet/src/test/java/org/apache/struts2/StrutsSpringPortletMockObjectsTest.java @@ -0,0 +1,1596 @@ +/* + * Copyright 2020 Apache Software Foundation. + * + * 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 org.apache.struts2; + +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.PrintWriter; +import java.net.MalformedURLException; +import java.nio.charset.StandardCharsets; +import java.security.Principal; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Enumeration; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.Locale; +import java.util.Map; +import java.util.ResourceBundle; +import java.util.Set; +import javax.portlet.ActionRequest; +import javax.portlet.PortletMode; +import javax.portlet.PortletPreferences; +import javax.portlet.PortletRequest; +import javax.portlet.PortletSession; +import javax.portlet.PortletURL; +import javax.portlet.PreferencesValidator; +import javax.portlet.ReadOnlyException; +import javax.portlet.ResourceURL; +import javax.portlet.ValidatorException; +import javax.portlet.WindowState; +import javax.security.auth.Subject; +import javax.servlet.http.Cookie; +import javax.xml.namespace.QName; +import org.apache.struts2.mock.web.portlet.MockActionRequest; +import org.apache.struts2.mock.web.portlet.MockActionResponse; +import org.apache.struts2.mock.web.portlet.MockCacheControl; +import org.apache.struts2.mock.web.portlet.MockClientDataRequest; +import org.apache.struts2.mock.web.portlet.MockEvent; +import org.apache.struts2.mock.web.portlet.MockEventRequest; +import org.apache.struts2.mock.web.portlet.MockEventResponse; +import org.apache.struts2.mock.web.portlet.MockMimeResponse; +import org.apache.struts2.mock.web.portlet.MockMultipartActionRequest; +import org.apache.struts2.mock.web.portlet.MockPortalContext; +import org.apache.struts2.mock.web.portlet.MockPortletConfig; +import org.apache.struts2.mock.web.portlet.MockPortletContext; +import org.apache.struts2.mock.web.portlet.MockPortletPreferences; +import org.apache.struts2.mock.web.portlet.MockPortletRequest; +import org.apache.struts2.mock.web.portlet.MockPortletRequestDispatcher; +import org.apache.struts2.mock.web.portlet.MockPortletResponse; +import org.apache.struts2.mock.web.portlet.MockPortletSession; +import org.apache.struts2.mock.web.portlet.MockPortletURL; +import org.apache.struts2.mock.web.portlet.MockRenderRequest; +import org.apache.struts2.mock.web.portlet.MockRenderResponse; +import org.apache.struts2.mock.web.portlet.MockResourceRequest; +import org.apache.struts2.mock.web.portlet.MockResourceResponse; +import org.apache.struts2.mock.web.portlet.MockResourceURL; +import org.apache.struts2.mock.web.portlet.MockStateAwareResponse; +import org.apache.struts2.mock.web.portlet.ServletWrappingPortletContext; +import org.springframework.mock.web.MockServletContext; +import org.springframework.util.MultiValueMap; +import org.springframework.web.multipart.MultipartFile; +import org.springframework.web.util.WebUtils; +import org.w3c.dom.Element; + +/** + * Basic test class for Portlet Mock Object testing + * + */ +public class StrutsSpringPortletMockObjectsTest extends StrutsSpringTestCase { + + /** + * An empty preferences validator for code coverage only + */ + private static class BasicPreferencesValidator implements PreferencesValidator { + + @Override + public void validate(PortletPreferences preferences) throws ValidatorException { + throw new UnsupportedOperationException("Not supported yet."); + } + + } + + public void testApplicationContext() { + assertNotNull(applicationContext); + } + + public void testContextLocations() { + assertNotNull(getContextLocations()); + } + + public void testMockActionRequest() { + final String TEST_ACTIONNAME = "TEST_ACTIONNAME"; + + // Call each constructor in sequence, do some basic checks + MockActionRequest mockActionRequest = new MockActionRequest(); // Only test is to confirm constructor completes without exception + mockActionRequest = new MockActionRequest(TEST_ACTIONNAME); + assertEquals("Action name (ActionRequest.ACTION_NAME) " + TEST_ACTIONNAME + " not set ?", TEST_ACTIONNAME, mockActionRequest.getParameter(ActionRequest.ACTION_NAME)); + mockActionRequest = new MockActionRequest(PortletMode.VIEW); + assertEquals("PortletMode.VIEW not set ?", PortletMode.VIEW, mockActionRequest.getPortletMode()); + + final MockPortletContext mockPortletContext = new MockPortletContext(); + final MockPortalContext mockPortalContext = new MockPortalContext(); + mockActionRequest = new MockActionRequest(mockPortletContext); // Only test is to confirm constructor completes without exception + mockActionRequest = new MockActionRequest(mockPortalContext, mockPortletContext); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockActionRequest.getPortalContext()); + } + + public void testMockActionResponse() { + final String TEST_PARAM = "TEST_PARAM"; + final String TEST_PARAM2 = "TEST_PARAM2"; + final String TEST_PARAM3 = "TEST_PARAM3"; + final String TEST_PARAM_VALUE = "NORMALVALUE"; + final String[] TEST_PARAM_ARRAYVALUE = { "ARRAYVALUE1", "ARRAYVALUE2" }; + final String[] TEST_PARAM_ARRAYVALUE2 = { "ARRAYVALUE3", "ARRAYVALUE4" }; + final String TEST_REDIRECT_URL = "localhost:8080/fakeurl"; + final String TEST_RENDER_URLPARAM_NAME = "fake_render_url_param_name"; + + // Call each constructor in sequence, do some basic checks + MockActionResponse mockActionResponse = new MockActionResponse(); + try { + mockActionResponse.setPortletMode(PortletMode.VIEW); + } catch (Exception ex) { + fail("MockActionResponse portlet mode set failed. Exception: " + ex); + } + assertEquals("PortletMode.VIEW not set ?", PortletMode.VIEW, mockActionResponse.getPortletMode()); + + final MockPortalContext mockPortalContext = new MockPortalContext(); + mockActionResponse = new MockActionResponse(mockPortalContext); // Only test is to confirm constructor completes without exception + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockActionResponse.getPortalContext()); + mockActionResponse.setRenderParameter(TEST_PARAM, TEST_PARAM_VALUE); + mockActionResponse.setRenderParameter(TEST_PARAM2, TEST_PARAM_ARRAYVALUE); + assertEquals("Portal test render parameter value not as expected ?", TEST_PARAM_VALUE, mockActionResponse.getRenderParameter(TEST_PARAM)); + assertEquals("Portal test render parameter value not as expected ?", TEST_PARAM_ARRAYVALUE[0], mockActionResponse.getRenderParameter(TEST_PARAM2)); + final Map renderParametersMap = new LinkedHashMap<>(); + renderParametersMap.put(TEST_PARAM3, TEST_PARAM_ARRAYVALUE2); + mockActionResponse.setRenderParameters(renderParametersMap); + assertEquals("Portal test render parameter value not cleared as expected ?", null, mockActionResponse.getRenderParameter(TEST_PARAM)); + assertEquals("Portal test render parameter value not cleared as expected ?", null, mockActionResponse.getRenderParameter(TEST_PARAM2)); + assertEquals("Portal test render parameter map value not as expected ?", renderParametersMap, mockActionResponse.getRenderParameterMap()); + + try { + mockActionResponse.sendRedirect(TEST_REDIRECT_URL); + fail("Able to redirect after windowState/portletMode/renderParameters set ?"); + } catch (IllegalStateException ise) { + // Expected failure + } catch (Exception ex) { + fail("MockActionResponse sendredirect failed. Exception: " + ex); + } + mockActionResponse = new MockActionResponse(); // Clean mock response + try { + mockActionResponse.sendRedirect(TEST_REDIRECT_URL); + } catch (Exception ex) { + fail("MockActionResponse sendredirect failed. Exception: " + ex); + } + assertEquals("Redirect url not as expected ?", TEST_REDIRECT_URL, mockActionResponse.getRedirectedUrl()); + mockActionResponse = new MockActionResponse(); // Clean mock response + try { + // Note: The original Spring 4.3.x mock implementation always threw an IllegalStateException when calling the method below. + mockActionResponse.sendRedirect(TEST_REDIRECT_URL, TEST_RENDER_URLPARAM_NAME); + } catch (Exception ex) { + fail("MockActionResponse sendredirect failed. Exception: " + ex); + } + assertEquals("Redirect url not as expected ?", TEST_REDIRECT_URL, mockActionResponse.getRedirectedUrl()); + assertEquals("Redirect url render parameter not as expected ?", TEST_REDIRECT_URL, mockActionResponse.getRenderParameter(TEST_RENDER_URLPARAM_NAME)); + } + + public void testMockCacheControl() { + final int TEST_EXPIRATION_TIME = 30; + final String TEST_ETAG = "TEST_ETAG"; + + // Call each constructor in sequence, do some basic checks + MockCacheControl mockCacheControl = new MockCacheControl(); + assertEquals("Initial expiry not as expected ?", 0, mockCacheControl.getExpirationTime()); + assertFalse("Initial scope public ?", mockCacheControl.isPublicScope()); + assertFalse("Initial use cache true ?", mockCacheControl.useCachedContent()); + mockCacheControl.setExpirationTime(TEST_EXPIRATION_TIME); + assertEquals("Initial expiry not as expected ?", TEST_EXPIRATION_TIME, mockCacheControl.getExpirationTime()); + mockCacheControl.setPublicScope(true); + assertTrue("Updated scope not public ?", mockCacheControl.isPublicScope()); + mockCacheControl.setPublicScope(false); + assertFalse("Updated scope still public ?", mockCacheControl.isPublicScope()); + mockCacheControl.setETag(TEST_ETAG); + assertEquals("ETag not not as expected ?", TEST_ETAG, mockCacheControl.getETag()); + mockCacheControl.setUseCachedContent(true); + assertTrue("Updated use cache not true ?", mockCacheControl.useCachedContent()); + mockCacheControl.setUseCachedContent(false); + assertFalse("Updated use cache still true ?", mockCacheControl.useCachedContent()); + } + + public void testMockClientDataRequest() { + final String TEST_FAKECONTENT = "Some fake content for the test."; + final byte[] TEST_FAKECONTENT_ASBYTES = TEST_FAKECONTENT.getBytes(StandardCharsets.UTF_8); + final String TEST_CONTENT_TYPE = "text/html"; + final String TEST_METHOD = "POST"; + + // Call each constructor in sequence, do some basic checks + MockClientDataRequest mockClientDataRequest = new MockClientDataRequest(); // Only test is to confirm constructor completes without exception + final MockPortletContext mockPortletContext = new MockPortletContext(); + final MockPortalContext mockPortalContext = new MockPortalContext(); + mockClientDataRequest = new MockClientDataRequest(mockPortletContext); // Only test is to confirm constructor completes without exception + mockClientDataRequest = new MockClientDataRequest(mockPortalContext, mockPortletContext); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockClientDataRequest.getPortalContext()); + mockClientDataRequest.setContent(TEST_FAKECONTENT_ASBYTES); + assertEquals("Content length not as expected ?", TEST_FAKECONTENT_ASBYTES.length, mockClientDataRequest.getContentLength()); + mockClientDataRequest.setCharacterEncoding(StandardCharsets.UTF_8.name()); + assertEquals("Charset not as expected ?", StandardCharsets.UTF_8.name(), mockClientDataRequest.getCharacterEncoding()); + mockClientDataRequest.setContentType(TEST_CONTENT_TYPE); + assertEquals("Content-type not as expected ?", TEST_CONTENT_TYPE, mockClientDataRequest.getContentType()); + mockClientDataRequest.setMethod(TEST_METHOD); + assertEquals("Method not as expected ?", TEST_METHOD, mockClientDataRequest.getMethod()); + try ( InputStream inputStream = mockClientDataRequest.getPortletInputStream() ) { + final byte[] readContent = new byte[mockClientDataRequest.getContentLength()]; + inputStream.read(readContent, 0, readContent.length); + assertTrue("Read byte array does not match original ?", Arrays.equals(TEST_FAKECONTENT_ASBYTES, readContent)); + } catch (Exception ex) { + fail("MockClientDataRequest read inputstream failed. Exception: " + ex); + } + try ( BufferedReader bufferedReader = mockClientDataRequest.getReader() ) { + final String theOnlyLine = bufferedReader.readLine(); + assertEquals("Read line does not match original ?", TEST_FAKECONTENT, theOnlyLine); + } catch (Exception ex) { + fail("MockClientDataRequest read inputstream failed. Exception: " + ex); + } + } + + public void testMockEvent() { + final String TEST_EVENT = "TEST_EVENT"; + final String TEST_EVENT_VALUE = "TEST_EVENT_VALUE"; + final QName TEST_QNAME = new QName(TEST_EVENT); + + // Call each constructor in sequence, do some basic checks + MockEvent mockClientDataRequest = new MockEvent(TEST_EVENT); + assertEquals("Initial value not null ?", null, mockClientDataRequest.getValue()); + assertEquals("Event name does not match ?", TEST_EVENT, mockClientDataRequest.getName()); + assertEquals("Event QName does not match ?", new QName(TEST_EVENT), mockClientDataRequest.getQName()); + mockClientDataRequest = new MockEvent(TEST_EVENT, TEST_EVENT_VALUE); + assertEquals("Initial value not as expected ?", TEST_EVENT_VALUE, mockClientDataRequest.getValue()); + assertEquals("Event name does not match ?", TEST_EVENT, mockClientDataRequest.getName()); + assertEquals("Event QName does not match ?", new QName(TEST_EVENT), mockClientDataRequest.getQName()); + mockClientDataRequest = new MockEvent(TEST_QNAME); + assertEquals("Initial value not null ?", null, mockClientDataRequest.getValue()); + assertEquals("Event name does not match ?", TEST_EVENT, mockClientDataRequest.getName()); + assertEquals("Event QName does not match ?", TEST_QNAME, mockClientDataRequest.getQName()); + mockClientDataRequest = new MockEvent(TEST_QNAME, TEST_EVENT_VALUE); + assertEquals("Initial value not as expected ?", TEST_EVENT_VALUE, mockClientDataRequest.getValue()); + assertEquals("Event name does not match ?", TEST_EVENT, mockClientDataRequest.getName()); + assertEquals("Event QName does not match ?", TEST_QNAME, mockClientDataRequest.getQName()); + } + + public void testMockEventRequest() { + final MockEvent TEST_MOCKEVENT = new MockEvent("MockEventName", "MockEventValue"); + final String TEST_METHOD = "POST"; + + // Call each constructor in sequence, do some basic checks + MockEventRequest mockEventRequest = new MockEventRequest(TEST_MOCKEVENT); + assertEquals("Event not the event set ?", TEST_MOCKEVENT, mockEventRequest.getEvent()); + mockEventRequest.setMethod(TEST_METHOD); + assertEquals("Method not the method set ?", TEST_METHOD, mockEventRequest.getMethod()); + final MockPortletContext mockPortletContext = new MockPortletContext(); + final MockPortalContext mockPortalContext = new MockPortalContext(); + mockEventRequest = new MockEventRequest(TEST_MOCKEVENT, mockPortletContext); // Only test is to confirm constructor completes without exception + mockEventRequest = new MockEventRequest(TEST_MOCKEVENT, mockPortalContext, mockPortletContext); // Only test is to confirm constructor completes without exception + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockEventRequest.getPortalContext()); + } + + public void testMockEventResponse() { + // Call each constructor in sequence, do some basic checks + MockEventResponse mockEventResponse = new MockEventResponse(); // Only test is to confirm constructor completes without exception + } + + public void testMockMimeResponse() {; + final String TEST_CONTENT_TYPE = "text/html"; + final int TEST_BUFFERSIZE = 8192; + final String TEST_INCLUDED_URL = "localhost:8080/fakeincludedurl"; + final String TEST_FORWARDED_URL = "localhost:8080/fakeforwardedurl"; + final String TEST_FAKECONTENT = "Some fake content for the test."; + final byte[] TEST_FAKECONTENT_ASBYTES = TEST_FAKECONTENT.getBytes(StandardCharsets.UTF_8); + + // Call each constructor in sequence, do some basic checks + MockMimeResponse mockMimeResponse = new MockMimeResponse(); + assertEquals("Default character encoding not as expected ?", WebUtils.DEFAULT_CHARACTER_ENCODING, mockMimeResponse.getCharacterEncoding()); + assertEquals("Default locale not as expected ?", Locale.getDefault(), mockMimeResponse.getLocale()); + assertTrue("Default buffersize not as expected ?", mockMimeResponse.getBufferSize() >= 4096); + assertFalse("Mock response already committed ?", mockMimeResponse.isCommitted()); + final MockPortalContext mockPortalContext = new MockPortalContext(); + final MockPortletContext mockPortletContext = new MockPortletContext(); + final MockPortletRequest mockPortletRequest = new MockPortletRequest(mockPortalContext, mockPortletContext); + mockMimeResponse = new MockMimeResponse(mockPortalContext); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockMimeResponse.getPortalContext()); + mockMimeResponse = new MockMimeResponse(mockPortalContext, mockPortletRequest); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockMimeResponse.getPortalContext()); + mockMimeResponse.setContentType(TEST_CONTENT_TYPE); + assertEquals("Content-type not as expected ?", TEST_CONTENT_TYPE, mockMimeResponse.getContentType()); + mockMimeResponse.setCharacterEncoding(StandardCharsets.UTF_8.name()); + assertEquals("Charset not as expected ?", StandardCharsets.UTF_8.name(), mockMimeResponse.getCharacterEncoding()); + mockMimeResponse.setBufferSize(TEST_BUFFERSIZE); + assertEquals("Buffersize not as expected ?", TEST_BUFFERSIZE, mockMimeResponse.getBufferSize()); + mockMimeResponse.setCommitted(true); + assertTrue("Response not committed ?", mockMimeResponse.isCommitted()); + mockMimeResponse.setCommitted(false); + assertFalse("Response still committed ?", mockMimeResponse.isCommitted()); + mockMimeResponse.setIncludedUrl(TEST_INCLUDED_URL); + assertEquals("Included URL not as expected ?", TEST_INCLUDED_URL, mockMimeResponse.getIncludedUrl()); + mockMimeResponse.setForwardedUrl(TEST_FORWARDED_URL); + assertEquals("Forwarded URL not as expected ?", TEST_FORWARDED_URL, mockMimeResponse.getForwardedUrl()); + try { + assertNotNull("OutputStream null ?", mockMimeResponse.getPortletOutputStream()); + } catch (Exception ex) { + fail("MockMimeResponse get outputstream failed. Exception: " + ex); + } + PortletURL portletUrl = mockMimeResponse.createRenderURL(); + assertNotNull("RenderURL null ?", portletUrl); + portletUrl = mockMimeResponse.createActionURL(); + assertNotNull("ActionURL null ?", portletUrl); + ResourceURL resourceURL = mockMimeResponse.createResourceURL(); + assertNotNull("ResourceURL null ?", resourceURL); + assertNotNull("CacheControl null ?", mockMimeResponse.getCacheControl()); + + try { + OutputStream outputStream = mockMimeResponse.getPortletOutputStream(); + assertNotNull("OutputStream null ?", outputStream); + outputStream.write(TEST_FAKECONTENT_ASBYTES); + final byte[] writeResult = mockMimeResponse.getContentAsByteArray(); + assertTrue("Written byte array does not match original ?", Arrays.equals(TEST_FAKECONTENT_ASBYTES, writeResult)); + assertTrue("Buffer not committed after processing ?", mockMimeResponse.isCommitted()); + } catch (Exception ex) { + fail("MockMimeResponse get/process outputstream failed. Exception: " + ex); + } + try { + mockMimeResponse.resetBuffer(); + } catch (IllegalStateException ise) { + // Expected failure + } + + mockMimeResponse.setCommitted(false); + mockMimeResponse.resetBuffer(); + try { + PrintWriter printWriter = mockMimeResponse.getWriter(); + assertNotNull("PrintWriter null ?", printWriter); + printWriter.print(TEST_FAKECONTENT); + mockMimeResponse.flushBuffer(); + final byte[] writeResult = mockMimeResponse.getContentAsByteArray(); + assertTrue("Written byte array does not match original ?", Arrays.equals(TEST_FAKECONTENT_ASBYTES, writeResult)); + assertTrue("Buffer not committed after processing ?", mockMimeResponse.isCommitted()); + final String writeResultAsString = mockMimeResponse.getContentAsString(); + assertEquals("Written result does not match original ?", TEST_FAKECONTENT, writeResultAsString); + } catch (Exception ex) { + fail("MockMimeResponse get/process printwriter failed. Exception: " + ex); + } + try { + mockMimeResponse.reset(); + } catch (IllegalStateException ise) { + // Expected failure + } + + mockMimeResponse.setCommitted(false); + mockMimeResponse.reset(); + assertNull("After reset, character encoding not null ?", mockMimeResponse.getCharacterEncoding()); + assertNull("After reset, content-type not null ?", mockMimeResponse.getContentType()); + assertNull("After reset, locale not null ?", mockMimeResponse.getLocale()); + } + + public void testMockMultipartActionRequest() { + final String TEST_FILENAME = "TEST_TEMPFILE"; + final String TEST_FILENAME2 = "TEST_TEMPFILE2"; + final String TEST_CONTENT_TYPE = "text/html"; + final String TEST_FAKECONTENT = "Some fake content for the test."; + final byte[] TEST_FAKECONTENT_ASBYTES = TEST_FAKECONTENT.getBytes(StandardCharsets.UTF_8); + + // Call each constructor in sequence, do some basic checks + MockMultipartActionRequest mockMultipartActionRequest = new MockMultipartActionRequest(); + assertFalse("Initial multipartrequest has file names ?", mockMultipartActionRequest.getFileNames().hasNext()); + assertTrue("Initial multipartrequest has nonempty map ?", mockMultipartActionRequest.getFileMap().isEmpty()); + assertTrue("Initial multipartrequest has nonempty multivalue map ?", mockMultipartActionRequest.getMultiFileMap().isEmpty()); + final MultipartFile multipartFile = new TestMockMultipartFile(TEST_FILENAME, TEST_FILENAME, TEST_CONTENT_TYPE, TEST_FAKECONTENT_ASBYTES); + final MultipartFile multipartFile2 = new TestMockMultipartFile(TEST_FILENAME2, TEST_FILENAME2, TEST_CONTENT_TYPE, TEST_FAKECONTENT_ASBYTES); + mockMultipartActionRequest.addFile(multipartFile); + assertTrue("Multipartrequest does not have file names ?", mockMultipartActionRequest.getFileNames().hasNext()); + assertFalse("Multipartrequest does not have nonempty map ?", mockMultipartActionRequest.getFileMap().isEmpty()); + assertFalse("Multipartrequest does not have nonempty multivalue map ?", mockMultipartActionRequest.getMultiFileMap().isEmpty()); + mockMultipartActionRequest.addFile(multipartFile2); + assertTrue("Multipartrequest does not have file names ?", mockMultipartActionRequest.getFileNames().hasNext()); + assertFalse("Multipartrequest does not have nonempty map ?", mockMultipartActionRequest.getFileMap().isEmpty()); + assertFalse("Multipartrequest does not have nonempty multivalue map ?", mockMultipartActionRequest.getMultiFileMap().isEmpty()); + assertEquals("Retrieved file 1 not as expected ?", multipartFile, mockMultipartActionRequest.getFile(TEST_FILENAME)); + assertEquals("Retrieved file 1 content-type not as expected ?", TEST_CONTENT_TYPE, mockMultipartActionRequest.getMultipartContentType(TEST_FILENAME)); + assertEquals("Retrieved file 2 not as expected ?", multipartFile2, mockMultipartActionRequest.getFile(TEST_FILENAME2)); + assertEquals("Retrieved file 2 content-type not as expected ?", TEST_CONTENT_TYPE, mockMultipartActionRequest.getMultipartContentType(TEST_FILENAME2)); + final Map fileMap = mockMultipartActionRequest.getFileMap(); + assertNotNull("File map is null ?", fileMap); + assertTrue("File 1 name not in map ?", fileMap.containsKey(TEST_FILENAME)); + assertTrue("File 2 name not in map ?", fileMap.containsKey(TEST_FILENAME2)); + assertTrue("File 1 not in map ?", fileMap.containsValue(multipartFile)); + assertTrue("File 2 not in map ?", fileMap.containsValue(multipartFile2)); + MultiValueMap fileMultiValueMap = mockMultipartActionRequest.getMultiFileMap(); + assertNotNull("MultiValue file map is null ?", fileMultiValueMap); + MultipartFile retrievedFile = fileMultiValueMap.getFirst(TEST_FILENAME); + assertNotNull("File 1 1st value is null ?", retrievedFile); + assertEquals("File 1 not in multivalue map ?", multipartFile, retrievedFile); + retrievedFile = fileMultiValueMap.getFirst(TEST_FILENAME2); + assertNotNull("File 2 1st value is null ?", retrievedFile); + assertEquals("File 2 not in multivalue map ?", multipartFile2, retrievedFile); + } + + public void testMockPortalContext() { + final String TEST_PROPERTY = "TEST_PROPERTY"; + final String TEST_PROPERTY_VALUE = "Property_Value_1"; + final String TEST_PROPERTY2 = "TEST_PROPERTY2"; + final String TEST_PROPERTY2_VALUE = "Property_Value_2"; + + // Call each constructor in sequence, do some basic checks + final MockPortalContext mockPortalContext = new MockPortalContext(); + assertNotNull("MockPortalContext portalInfo null ?", mockPortalContext.getPortalInfo()); + assertNotNull("MockPortalContext property names null ?", mockPortalContext.getPropertyNames()); + assertFalse("MockPortalConext initial propertyNames not empty ?", mockPortalContext.getPropertyNames().hasMoreElements()); + final Enumeration supportedPortletModes = mockPortalContext.getSupportedPortletModes(); + assertNotNull("MockPortalContext supported portlet modes null ?", supportedPortletModes); + final ArrayList portletModeList = new ArrayList<>(); + while (supportedPortletModes.hasMoreElements()) { + portletModeList.add(supportedPortletModes.nextElement()); + } + assertEquals("MockPortalContext does not support three modes ?", 3, portletModeList.size()); + assertTrue("MockPortalContext does not contain PortletMode.VIEW ?", portletModeList.contains(PortletMode.VIEW)); + assertTrue("MockPortalContext does not contain PortletMode.EDIT ?", portletModeList.contains(PortletMode.EDIT)); + assertTrue("MockPortalContext does not contain PortletMode.HELP ?", portletModeList.contains(PortletMode.HELP)); + + final Enumeration supportedWindowStates = mockPortalContext.getSupportedWindowStates(); + assertNotNull("MockPortalContext supported window modes null ?", supportedWindowStates); + final ArrayList windowStateList = new ArrayList<>(); + while (supportedWindowStates.hasMoreElements()) { + windowStateList.add(supportedWindowStates.nextElement()); + } + assertEquals("MockPortalContext does not support three states ?", 3, windowStateList.size()); + assertTrue("MockPortalContext does not contain WindowState.NORMAL ?", windowStateList.contains(WindowState.NORMAL)); + assertTrue("MockPortalContext does not contain WindowState.MAXIMIZED ?", windowStateList.contains(WindowState.MAXIMIZED)); + assertTrue("MockPortalContext does not contain WindowState.MINIMIZED ?", windowStateList.contains(WindowState.MINIMIZED)); + + mockPortalContext.setProperty(TEST_PROPERTY, TEST_PROPERTY_VALUE); + mockPortalContext.setProperty(TEST_PROPERTY2, TEST_PROPERTY2_VALUE); + final Enumeration propertyNames = mockPortalContext.getPropertyNames(); + assertNotNull("MockPortalContext property names null ?", propertyNames); + final ArrayList propertyNamesList = new ArrayList<>(); + while (propertyNames.hasMoreElements()) { + propertyNamesList.add(propertyNames.nextElement()); + } + assertEquals("MockPortalContext does not contain two properties ?", 2, propertyNamesList.size()); + assertTrue("MockPortalContext does not contain property name " + TEST_PROPERTY + " ?", propertyNamesList.contains(TEST_PROPERTY)); + assertTrue("MockPortalContext does not contain property name " + TEST_PROPERTY2 + " ?", propertyNamesList.contains(TEST_PROPERTY2)); + assertEquals("MockPortalContext value of property name " + TEST_PROPERTY + " not as expected ?", TEST_PROPERTY_VALUE, mockPortalContext.getProperty(TEST_PROPERTY)); + assertEquals("MockPortalContext value of property name " + TEST_PROPERTY2 + " not as expected ?", TEST_PROPERTY2_VALUE, mockPortalContext.getProperty(TEST_PROPERTY2)); + } + + public void testMockPortletConfig() { + final String TEST_PORTLETNAME = "TestPortletName"; + final String TEST_INITPARAM = "TEST_INITPARAM"; + final String TEST_INITPARAM_VALUE = "Init_Value_1"; + final String TEST_INITPARAM2= "TEST_INITPARAM2"; + final String TEST_INITPARAM_VALUE2 = "Init_Value_2"; + final String TEST_RENDERPARAM_NAME = "Test_RenderParam_1"; + final String TEST_RENDERPARAM_NAME2 = "Test_RenderParam_2"; + final String TEST_DEFAULTNAMESPACE = "Test_Default_Namespace"; + final QName TEST_QNAME = new QName(TEST_PORTLETNAME); + final QName TEST_QNAME2 = new QName(TEST_DEFAULTNAMESPACE); + final String TEST_RUNTIME_OPTION = "TEST_RUNTIME_OPTION"; + final String TEST_RUNTIME_OPTION2 = "TEST_RUNTIME_OPTION2"; + final String TEST_RUNTIME_VALUE1 = "Test_Runtime_Option1"; + final String TEST_RUNTIME_VALUE2 = "Test_Runtime_Option2"; + + // Call each constructor in sequence, do some basic checks + MockPortletConfig mockPortletConfig = new MockPortletConfig(); + assertNotNull("MockPortletConfig default PortletContext is null ?", mockPortletConfig.getPortletContext()); + assertEquals("MockPortletConfig default name not empty string ?", "", mockPortletConfig.getPortletName()); + mockPortletConfig = new MockPortletConfig(TEST_PORTLETNAME); + assertNotNull("MockPortletConfig default PortletContext is null ?", mockPortletConfig.getPortletContext()); + assertEquals("MockPortletConfig name not constructor set value ?", TEST_PORTLETNAME, mockPortletConfig.getPortletName()); + final MockPortletContext mockPortletContext = new MockPortletContext(); + mockPortletConfig = new MockPortletConfig(mockPortletContext, TEST_PORTLETNAME); + assertEquals("MockPortletConfig PortletContext constructor set value ?", mockPortletContext, mockPortletConfig.getPortletContext()); + assertEquals("MockPortletConfig name not constructor set value ?", TEST_PORTLETNAME, mockPortletConfig.getPortletName()); + assertNull("MockPortletConfig default locale resource bundle not null ?", mockPortletConfig.getResourceBundle(Locale.getDefault())); + final ResourceBundle resourceBundle = new TetMockResourceBundle(); + mockPortletConfig.setResourceBundle(Locale.getDefault(), resourceBundle); + assertEquals("Default locale resource bundle not set value ?", resourceBundle, mockPortletConfig.getResourceBundle(Locale.getDefault())); + + assertNull(TEST_INITPARAM + " present before set ?", mockPortletConfig.getInitParameter(TEST_INITPARAM)); + assertNull(TEST_INITPARAM2 + " present before set ?", mockPortletConfig.getInitParameter(TEST_INITPARAM)); + mockPortletConfig.addInitParameter(TEST_INITPARAM, TEST_INITPARAM_VALUE); + mockPortletConfig.addInitParameter(TEST_INITPARAM2, TEST_INITPARAM_VALUE2); + assertEquals("Retrieved init parameter 1 does not match set value ?", TEST_INITPARAM_VALUE, mockPortletConfig.getInitParameter(TEST_INITPARAM)); + assertEquals("Retrieved init parameter 2 does not match set value ?", TEST_INITPARAM_VALUE2, mockPortletConfig.getInitParameter(TEST_INITPARAM2)); + final Enumeration initParameterNames = mockPortletConfig.getInitParameterNames(); + int initParameterNameCount = 0; + assertNotNull("InitParameter names null after additions ?", initParameterNames); + assertTrue("InitParameter names empty after additions ?", initParameterNames.hasMoreElements()); + while (initParameterNames.hasMoreElements()) { + initParameterNameCount++; + String currentInitParameterName = initParameterNames.nextElement(); + assertTrue("Initparam name not one of two expected matches ?", TEST_INITPARAM.equals(currentInitParameterName) || + TEST_INITPARAM2.equals(currentInitParameterName)); + } + assertEquals("InitParameter names size not 2 ?", 2, initParameterNameCount); + + assertFalse("Initial renderparam names not empty ?", mockPortletConfig.getPublicRenderParameterNames().hasMoreElements()); + mockPortletConfig.addPublicRenderParameterName(TEST_RENDERPARAM_NAME); + mockPortletConfig.addPublicRenderParameterName(TEST_RENDERPARAM_NAME2); + final Enumeration publicRenderParameterNames = mockPortletConfig.getPublicRenderParameterNames(); + int publicRenderParameterNameCount = 0; + assertNotNull("PublicRenderParameter names null after additions ?", publicRenderParameterNames); + assertTrue("PublicRenderParameter names empty after additions ?", publicRenderParameterNames.hasMoreElements()); + while (publicRenderParameterNames.hasMoreElements()) { + publicRenderParameterNameCount++; + String currentPublicRenderParameterName = publicRenderParameterNames.nextElement(); + assertTrue("PublicRenderParameter name not one of two expected matches ?", TEST_RENDERPARAM_NAME.equals(currentPublicRenderParameterName) || + TEST_RENDERPARAM_NAME2.equals(currentPublicRenderParameterName)); + } + assertEquals("PublicRenderParameter names size not 2 ?", 2, publicRenderParameterNameCount); + mockPortletConfig.setDefaultNamespace(TEST_DEFAULTNAMESPACE); + assertEquals("Default namespace not set value ?", TEST_DEFAULTNAMESPACE, mockPortletConfig.getDefaultNamespace()); + + assertFalse("Initial publishing event QNames not empty ?", mockPortletConfig.getPublishingEventQNames().hasMoreElements()); + assertFalse("Initial processing event QNames not empty ?", mockPortletConfig.getProcessingEventQNames().hasMoreElements()); + mockPortletConfig.addPublishingEventQName(TEST_QNAME); + mockPortletConfig.addProcessingEventQName(TEST_QNAME2); + final Enumeration publishingEventQNames = mockPortletConfig.getPublishingEventQNames(); + assertNotNull("PublishingEventQNames names null after additions ?", publishingEventQNames); + assertTrue("PublishingEventQNames names empty after additions ?", publishingEventQNames.hasMoreElements()); + final QName firstPublishingEventQName = publishingEventQNames.nextElement(); + assertEquals("First publishing event QName not set value ?", TEST_QNAME, firstPublishingEventQName); + final Enumeration processingEventQNames = mockPortletConfig.getProcessingEventQNames(); + assertNotNull("ProcessingEventQNames names null after additions ?", processingEventQNames); + assertTrue("ProcessingEventQNames names empty after additions ?", processingEventQNames.hasMoreElements()); + final QName firstProcessingEventQName = processingEventQNames.nextElement(); + assertEquals("First processing event QName not set value ?", TEST_QNAME2, firstProcessingEventQName); + + assertFalse("Initial supported locales not empty ?", mockPortletConfig.getSupportedLocales().hasMoreElements()); + mockPortletConfig.addSupportedLocale(Locale.getDefault()); + final Enumeration supportedLocales = mockPortletConfig.getSupportedLocales(); + assertNotNull("Supported locales null after additions ?", supportedLocales); + assertTrue("Supported locales names empty after additions ?", supportedLocales.hasMoreElements()); + final Locale firstSupportedLocale = supportedLocales.nextElement(); + assertEquals("First supported locale not set value ?", Locale.getDefault(), firstSupportedLocale); + + assertTrue("Portlet runtime options not empty before set ?", mockPortletConfig.getContainerRuntimeOptions().isEmpty()); + mockPortletConfig.addContainerRuntimeOption(TEST_RUNTIME_OPTION, TEST_RUNTIME_VALUE1); + mockPortletConfig.addContainerRuntimeOption(TEST_RUNTIME_OPTION2, TEST_RUNTIME_VALUE2); + final Map containerRuntimeOptions = mockPortletConfig.getContainerRuntimeOptions(); + assertNotNull("Runtime options null after additions ?", containerRuntimeOptions); + assertFalse("Runtime options empty after additions ?", containerRuntimeOptions.isEmpty()); + assertTrue("Runtime option 1 not present after setting ?", containerRuntimeOptions.containsKey(TEST_RUNTIME_OPTION)); + assertTrue("Runtime option 2 not present after setting ?", containerRuntimeOptions.containsKey(TEST_RUNTIME_OPTION2)); + assertEquals("Runtime option 1 not equal to set value ?", TEST_RUNTIME_VALUE1, containerRuntimeOptions.get(TEST_RUNTIME_OPTION)[0]); + assertEquals("Runtime option 2 not equal to set value ?", TEST_RUNTIME_VALUE2, containerRuntimeOptions.get(TEST_RUNTIME_OPTION2)[0]); + } + + public void testMockPortletContext() { + final String TEST_ATTRIBUTE = "TEST_ATTRIBUTE"; + final String TEST_ATTRIBUTE_VALUE = "Attribute_Value_1"; + final String TEST_ATTRIBUTE2 = "TEST_ATTRIBUTE2"; + final String TEST_ATTRIBUTE_VALUE2 = "Attribute_Value_2"; + final String TEST_INITPARAM = "TEST_INITPARAM"; + final String TEST_INITPARAM_VALUE = "Init_Value_1"; + final String TEST_INITPARAM2 = "TEST_INITPARAM2"; + final String TEST_INITPARAM_VALUE2 = "Init_Value_2"; + final String TEST_CONTEXT_NAME = "TEST_CONTEXT_NAME"; + final String TEST_RUNTIME_OPTION = "TEST_RUNTIME_OPTION"; + final String TEST_RUNTIME_OPTION2 = "TEST_RUNTIME_OPTION2"; + + // Call each constructor in sequence, do some basic checks + final MockPortletContext mockPortletContext = new MockPortletContext(); + assertNotNull("MockPortletContext serverInfo null ?", mockPortletContext.getServerInfo()); + try { + assertNotNull("MockPortletContext PortletRequestDispatcher null ?", mockPortletContext.getRequestDispatcher("IllegalPrefix")); + fail("PortletRequestDispatcher path must start with /"); + } catch (IllegalArgumentException iae) { + // Expected exception + } + assertNotNull("MockPortletContext PortletRequestDispatcher for / null ?", mockPortletContext.getRequestDispatcher("/")); + assertNull("MockPortletContext named PortletRequestDispatcher not null ?", mockPortletContext.getNamedDispatcher("SomeName")); + assertNotNull("MockPortletContext resource stream for / null ?", mockPortletContext.getResourceAsStream("/")); + assertNull("MockPortletContext resource stream for /ThisDoesNotExist not null ?", mockPortletContext.getResourceAsStream("/ThisDoesNotExist")); + assertTrue("MockPortletContext major version not >= 2 ?", mockPortletContext.getMajorVersion() >= 2); + assertTrue("MockPortletContext minor version not >= 0 ?", mockPortletContext.getMajorVersion() >= 0); + assertNull("MockPortletContext MIME type for / not null ?", mockPortletContext.getMimeType("/")); + assertNotNull("MockPortletContext real path for / null ?", mockPortletContext.getRealPath("/")); + assertNull("MockPortletContext real path for /ThisDoesNotExist not null ? ?", mockPortletContext.getRealPath("/ThisDoesNotExist")); + assertNotNull("MockPortletContext resource paths for / null ?", mockPortletContext.getResourcePaths("/")); + assertNull("MockPortletContext resource paths for / null ?", mockPortletContext.getResourcePaths("/ThisDoesNotExist")); + try { + assertNotNull("MockPortletContext resource URL for / null ?", mockPortletContext.getResource("/")); + } catch (MalformedURLException mue) { + fail("MockPortletContext resource URL for / failed. Exception: " + mue); + } + try { + assertNull("MockPortletContext resource URL for /ThisDoesNotExist not null ?", mockPortletContext.getResource("/ThisDoesNotExist")); + } catch (MalformedURLException mue) { + fail("MockPortletContext resource URL for /ThisDoesNotExist failed. Exception: " + mue); + } + + assertNull(TEST_ATTRIBUTE + " present before set ?", mockPortletContext.getAttribute(TEST_ATTRIBUTE)); + assertNull(TEST_ATTRIBUTE2 + " present before set ?", mockPortletContext.getAttribute(TEST_ATTRIBUTE2)); + mockPortletContext.setAttribute(TEST_ATTRIBUTE, TEST_ATTRIBUTE_VALUE); + mockPortletContext.setAttribute(TEST_ATTRIBUTE2, TEST_ATTRIBUTE_VALUE2); + assertEquals("Retrieved atribute 1 does not match set value ?", TEST_ATTRIBUTE_VALUE, mockPortletContext.getAttribute(TEST_ATTRIBUTE)); + assertEquals("Retrieved atribute 2 does not match set value ?", TEST_ATTRIBUTE_VALUE2, mockPortletContext.getAttribute(TEST_ATTRIBUTE2)); + final Enumeration attributeNames = mockPortletContext.getAttributeNames(); + int attributeNameCount = 0; + assertNotNull("Attribute names null after additions ?", attributeNames); + assertTrue("Attribute names empty after additions ?", attributeNames.hasMoreElements()); + while (attributeNames.hasMoreElements()) { + attributeNameCount++; + String currentAttibuteName = attributeNames.nextElement(); + assertTrue("Attribute name not one of two or three expected matches ?", TEST_ATTRIBUTE.equals(currentAttibuteName) || + TEST_ATTRIBUTE2.equals(currentAttibuteName) || + WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE.equals(currentAttibuteName)); + } + assertTrue("Atribute names size not 2 or 3 ?", attributeNameCount >= 2 && attributeNameCount <= 3); + + assertNull(TEST_INITPARAM + " present before set ?", mockPortletContext.getInitParameter(TEST_INITPARAM)); + assertNull(TEST_INITPARAM2 + " present before set ?", mockPortletContext.getInitParameter(TEST_INITPARAM)); + mockPortletContext.addInitParameter(TEST_INITPARAM, TEST_INITPARAM_VALUE); + mockPortletContext.addInitParameter(TEST_INITPARAM2, TEST_INITPARAM_VALUE2); + assertEquals("Retrieved init parameter 1 does not match set value ?", TEST_INITPARAM_VALUE, mockPortletContext.getInitParameter(TEST_INITPARAM)); + assertEquals("Retrieved init parameter 2 does not match set value ?", TEST_INITPARAM_VALUE2, mockPortletContext.getInitParameter(TEST_INITPARAM2)); + final Enumeration initParameterNames = mockPortletContext.getInitParameterNames(); + int initParameterNameCount = 0; + assertNotNull("InitParameter names null after additions ?", initParameterNames); + assertTrue("InitParameter names empty after additions ?", initParameterNames.hasMoreElements()); + while (initParameterNames.hasMoreElements()) { + initParameterNameCount++; + String currentInitParameterName = initParameterNames.nextElement(); + assertTrue("Initparam name not one of two expected matches ?", TEST_INITPARAM.equals(currentInitParameterName) || + TEST_INITPARAM2.equals(currentInitParameterName)); + } + assertEquals("InitParameter names size not 2 ?", 2, initParameterNameCount); + + mockPortletContext.log("Test logging call"); + mockPortletContext.log("Test logging call", new Exception("Fake Exception")); + + assertEquals("Default portlet context name not as expected ?", "MockPortletContext", mockPortletContext.getPortletContextName()); + mockPortletContext.setPortletContextName(TEST_CONTEXT_NAME); + assertEquals("Portlet context name not equal to set value ?", TEST_CONTEXT_NAME, mockPortletContext.getPortletContextName()); + + assertFalse("Portlet runtime options not empty before set ?", mockPortletContext.getContainerRuntimeOptions().hasMoreElements()); + mockPortletContext.addContainerRuntimeOption(TEST_RUNTIME_OPTION); + mockPortletContext.addContainerRuntimeOption(TEST_RUNTIME_OPTION2); + final Enumeration containerRuntimeOptions = mockPortletContext.getContainerRuntimeOptions(); + int containerRuntimeOptionsCount = 0; + assertNotNull("Runtime options null after additions ?", containerRuntimeOptions); + assertTrue("Runtime options empty after additions ?", containerRuntimeOptions.hasMoreElements()); + while (containerRuntimeOptions.hasMoreElements()) { + containerRuntimeOptionsCount++; + String currentRuntimeOption = containerRuntimeOptions.nextElement(); + assertTrue("Runtime option not one of two expected matches ?", TEST_RUNTIME_OPTION.equals(currentRuntimeOption) || + TEST_RUNTIME_OPTION2.equals(currentRuntimeOption)); + } + assertEquals("Runtime options size not 2 ?", 2, containerRuntimeOptionsCount); + } + + public void testMockPortletPreferences() { + final String PORTLET_READONLY = "PORTLET_READONLY"; + final String PORTLET_READONLY_VALUE = "Readonly_Value_1"; + final String PORTLET_READONLY2 = "PORTLET_READONLY2"; + final String PORTLET_READONLY2_VALUE = "Readonly_Value_2"; + final String PORTLET_WRITEABLE = "PORTLET_WRITEABLE"; + final String PORTLET_WRITEABLE_VALUE = "Writeable_Value_1"; + final String PORTLET_WRITEABLE2 = "PORTLET_WRITEABLE2"; + final String PORTLET_WRITEABLE2_VALUE = "Writeable_Value_2"; + final String PORTLET_WRITEABLE_ARRAY = "PORTLET_WRITEABLE_ARRAY"; + final String[] PORTLET_WRITEABLE_ARRAY_VALUE = { "Writeable_Array_Value_1", "Writeable_Array_Value" }; + + // Call each constructor in sequence, do some basic checks + final MockPortletPreferences mockPortletPreferences = new MockPortletPreferences(); + assertFalse("MockPortletPreferences initial preferences names non-empty ?", mockPortletPreferences.getNames().hasMoreElements()); + assertTrue("MockPortletPreferences initial preferences non-empty ?", mockPortletPreferences.getMap().isEmpty()); + + // Test set readonly permitted before key exists + assertFalse(PORTLET_READONLY + " readonly before set ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY)); + assertFalse(PORTLET_READONLY2 + " readonly before set ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY2)); + mockPortletPreferences.setReadOnly(PORTLET_READONLY, true); + mockPortletPreferences.setReadOnly(PORTLET_READONLY2, true); + assertTrue(PORTLET_READONLY + " not readonly after set ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY)); + assertTrue(PORTLET_READONLY2 + " not readonly after set ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY2)); + mockPortletPreferences.setReadOnly(PORTLET_READONLY, false); + mockPortletPreferences.setReadOnly(PORTLET_READONLY2, false); + assertFalse(PORTLET_READONLY + " readonly after clear ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY)); + assertFalse(PORTLET_READONLY2 + " readonly after clear ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY2)); + + try { + // Test initial set and replace + mockPortletPreferences.setValue(PORTLET_READONLY, PORTLET_READONLY_VALUE); + assertEquals("Set value mismatch ?", PORTLET_READONLY_VALUE, mockPortletPreferences.getValue(PORTLET_READONLY, null)); + mockPortletPreferences.setValue(PORTLET_READONLY, PORTLET_READONLY_VALUE); + assertEquals("Set value mismatch ?", PORTLET_READONLY_VALUE, mockPortletPreferences.getValue(PORTLET_READONLY, null)); + } catch (Exception ex) { + fail("Setvalue failed unexpectedly: " + ex); + } + try { + // Test initial set and replace + mockPortletPreferences.setValue(PORTLET_READONLY2, PORTLET_READONLY2_VALUE); + assertEquals("Set value mismatch ?", PORTLET_READONLY2_VALUE, mockPortletPreferences.getValue(PORTLET_READONLY2, null)); + mockPortletPreferences.setValue(PORTLET_READONLY2, PORTLET_READONLY2_VALUE); + assertEquals("Set value mismatch ?", PORTLET_READONLY2_VALUE, mockPortletPreferences.getValue(PORTLET_READONLY2, null)); + } catch (Exception ex) { + fail("Setvalue failed unexpectedly: " + ex); + } + + mockPortletPreferences.setReadOnly(PORTLET_READONLY, true); + mockPortletPreferences.setReadOnly(PORTLET_READONLY2, true); + try { + // Test set of readonly value fails + mockPortletPreferences.setValue(PORTLET_READONLY, PORTLET_READONLY_VALUE); + fail("Setvalue worked unexpectedly for readonly value"); + } catch (Exception ex) { + assertTrue("Unexpected exception type failure ? Ex: " + ex, ex instanceof ReadOnlyException); + assertTrue(PORTLET_READONLY + " is not readonly ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY)); + } + try { + // Test reset of readonly value fails + mockPortletPreferences.reset(PORTLET_READONLY); + fail("Reset worked unexpectedly for readonly value"); + } catch (Exception ex) { + assertTrue("Unexpected exception type failure ? Ex: " + ex, ex instanceof ReadOnlyException); + assertTrue(PORTLET_READONLY + " is not readonly ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY)); + } + try { + // Test set of readonly value fails + mockPortletPreferences.setValue(PORTLET_READONLY2, PORTLET_READONLY2_VALUE); + fail("Setvalue worked unexpectedly for readonly value"); + } catch (Exception ex) { + assertTrue("Unexpected exception type failure ? Ex: " + ex, ex instanceof ReadOnlyException); + assertTrue(PORTLET_READONLY2 + " is not readonly ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY2)); + } + try { + // Test reset of readonly value fails + mockPortletPreferences.reset(PORTLET_READONLY2); + fail("Reset worked unexpectedly for readonly value"); + } catch (Exception ex) { + assertTrue("Unexpected exception type failure ? Ex: " + ex, ex instanceof ReadOnlyException); + assertTrue(PORTLET_READONLY2 + " is not readonly ?", mockPortletPreferences.isReadOnly(PORTLET_READONLY2)); + } + + try { + // Test initial set, get and reset + mockPortletPreferences.setValue(PORTLET_WRITEABLE, PORTLET_WRITEABLE_VALUE); + mockPortletPreferences.setValue(PORTLET_WRITEABLE2, PORTLET_WRITEABLE2_VALUE); + assertEquals("Set value mismatch ?", PORTLET_WRITEABLE_VALUE, mockPortletPreferences.getValue(PORTLET_WRITEABLE, null)); + assertEquals("Set value mismatch ?", PORTLET_WRITEABLE2_VALUE, mockPortletPreferences.getValue(PORTLET_WRITEABLE2, null)); + assertFalse(PORTLET_WRITEABLE + " is readonly ?", mockPortletPreferences.isReadOnly(PORTLET_WRITEABLE)); + assertFalse(PORTLET_WRITEABLE2 + " is readonly ?", mockPortletPreferences.isReadOnly(PORTLET_WRITEABLE2)); + mockPortletPreferences.reset(PORTLET_WRITEABLE); + mockPortletPreferences.reset(PORTLET_WRITEABLE2); + assertEquals("After reset getValue with null not null ?", null, mockPortletPreferences.getValue(PORTLET_WRITEABLE, null)); + assertEquals("After reset getValue with null not null ?", null, mockPortletPreferences.getValue(PORTLET_WRITEABLE2, null)); + } catch (Exception ex) { + fail("Set/Get/Reset failed unexpectedly: " + ex); + } + + try { + // Test initial array set, get, names and map + mockPortletPreferences.setValues(PORTLET_WRITEABLE_ARRAY, PORTLET_WRITEABLE_ARRAY_VALUE); + + assertEquals("Set values mismatch ?", PORTLET_WRITEABLE_ARRAY_VALUE, mockPortletPreferences.getValues(PORTLET_WRITEABLE_ARRAY, null)); + assertFalse(PORTLET_WRITEABLE_ARRAY + " is readonly ?", mockPortletPreferences.isReadOnly(PORTLET_WRITEABLE_ARRAY)); + + // There should be two readonly attributes plus the array attribute present at this point + final Enumeration preferencesNames = mockPortletPreferences.getNames(); + assertNotNull("Preferences names null after additions ?", preferencesNames); + assertTrue("Preferences names empty after additions ?", preferencesNames.hasMoreElements()); + int preferencesNameCount = 0; + while (preferencesNames.hasMoreElements()) { + preferencesNameCount++; + String currentPreferencesName = preferencesNames.nextElement(); + assertTrue("Preferences name not one of three expected matches ?", PORTLET_WRITEABLE_ARRAY.equals(currentPreferencesName) || + PORTLET_READONLY.equals(currentPreferencesName) || + PORTLET_READONLY2.equals(currentPreferencesName)); + } + assertEquals("Preferences names size not 3 ?", 3, preferencesNameCount); + + final Map preferencesMap = mockPortletPreferences.getMap(); + assertNotNull("Preferences map null ?", preferencesMap); + assertEquals("Preferences map size not 3 ?", 3, preferencesMap.size()); + assertTrue("Map does not contain expected key ?", preferencesMap.containsKey(PORTLET_WRITEABLE_ARRAY)); + assertTrue("Map does not contain expected key ?", preferencesMap.containsKey(PORTLET_READONLY)); + assertTrue("Map does not contain expected key ?", preferencesMap.containsKey(PORTLET_READONLY2)); + assertTrue("Map does not contain expected value ?", preferencesMap.containsValue(PORTLET_WRITEABLE_ARRAY_VALUE)); + assertTrue("Map does not contain expected value ?", preferencesMap.containsValue(mockPortletPreferences.getValues(PORTLET_READONLY, null))); + assertTrue("Map does not contain expected value ?", preferencesMap.containsValue(mockPortletPreferences.getValues(PORTLET_READONLY2, null))); + } catch (Exception ex) { + fail("Set/Get/Names/Map failed unexpectedly: " + ex); + } + + // Verify store behaviour without validator present + try { + mockPortletPreferences.store(); + } catch (Exception ex) { + fail("Store without validator failed ? Exception: " + ex); + } + // Verify store behaviour with validator present + try { + mockPortletPreferences.setPreferencesValidator(new BasicPreferencesValidator()); + mockPortletPreferences.store(); + fail("Basic validator did not prevent store as expected ?"); + } catch (Exception ex) { + assertTrue("Basic validator did not produce UnsupportedOperationException ?", ex instanceof UnsupportedOperationException); + } + // Verify store behaviour after validator cleared + try { + mockPortletPreferences.setPreferencesValidator(null); + mockPortletPreferences.store(); + } catch (Exception ex) { + fail("Store after clearing validator failed ? Exception: " + ex); + } + } + + public void testMockPortletRequest() { + final String TEST_DEFAULT_CONTENT_TYPE = "text/html"; + final String TEST_CONTENT_TYPE = "text/plain"; + final String TEST_CONTENT_TYPE2 = "text/csv"; + final String TEST_PROPERTY = "TEST_PROPERTY"; + final String TEST_PROPERTY_VALUE = "Property_Value_1"; + final String TEST_PROPERTY2 = "TEST_PROPERTY2"; + final String TEST_PROPERTY2_VALUE = "Property_Value_2"; + final String TEST_AUTHTYPE = "Test_Auth_Type"; + final String TEST_FAKECONTEXTPATH = "/fakeContextPath"; + final String TEST_FAKEREMOTEUSER = "fakeRemoteUser"; + final String TEST_FAKEUSERROLE = "fakeUserRole"; + final String TEST_ATTRIBUTE = "TEST_ATTRIBUTE"; + final String TEST_ATTRIBUTE_VALUE = "Attribute_Value_1"; + final String TEST_ATTRIBUTE2 = "TEST_ATTRIBUTE2"; + final String TEST_ATTRIBUTE_VALUE2 = "Attribute_Value_2"; + final String TEST_PARAM = "TEST_PARAM"; + final String TEST_PARAM_VALUE = "Param_Value_1"; + final String TEST_PARAM2 = "TEST_PARAM2"; + final String TEST_PARAM_VALUE2 = "PARAM_Value_2"; + final String TEST_ARRAYPARAM = "TEST_ARRAYPARAM"; + final String[] TEST_PARAM_ARRAYVALUE = { "ARRAYVALUE1", "ARRAYVALUE2" }; + final String TEST_SCHEME = "file"; + final String TEST_HOST = "localhost2"; + final int TEST_PORT = 8080; + final String TEST_WINDOWID = "TEST_WINDOWID"; + final String TEST_COOKIE_ID = "TEST_COOKIE_ID"; + final String TEST_COOKIE_ID2 = "TEST_COOKIE_ID2"; + final String TEST_COOKIE_VALUE = "Cookie_Value"; + final String TEST_COOKIE_VALUE2 = "Cookie_Value2"; + final Cookie PORLET_TEST_COOKIE = new Cookie(TEST_COOKIE_ID, TEST_COOKIE_VALUE); + final Cookie PORLET_TEST_COOKIE2 = new Cookie(TEST_COOKIE_ID2, TEST_COOKIE_VALUE2); + + // Call each constructor in sequence, do some basic checks + MockPortletRequest mockPortletRequest = new MockPortletRequest(); + assertTrue("Default active state not true ?", mockPortletRequest.isActive()); + assertEquals("Default portlet mode not as expected ?", PortletMode.VIEW, mockPortletRequest.getPortletMode()); + assertEquals("Default window state not as expected ?", WindowState.NORMAL, mockPortletRequest.getWindowState()); + assertNotNull("Default preferences is null ?", mockPortletRequest.getPreferences()); + assertNotNull("Default portlet session is null ?", mockPortletRequest.getPortletSession()); + assertNotNull("Default portal context is null ?", mockPortletRequest.getPortalContext()); + assertEquals("Default context path not empty string ?", "", mockPortletRequest.getContextPath()); + assertNull("Default remote user not null ?", mockPortletRequest.getRemoteUser()); + assertNull("Default user principal not null ?", mockPortletRequest.getUserPrincipal()); + assertFalse("Default secure state not false ?", mockPortletRequest.isSecure()); + assertTrue("Default request sessionid not valid ?", mockPortletRequest.isRequestedSessionIdValid()); + assertEquals("Default locale not as expected ?", Locale.ENGLISH, mockPortletRequest.getLocale()); + assertEquals("Default response content-type not as expected ?", TEST_DEFAULT_CONTENT_TYPE, mockPortletRequest.getResponseContentType()); + assertNull("Default lifecycle phase attribute not null ?", mockPortletRequest.getAttribute(PortletRequest.LIFECYCLE_PHASE)); + assertEquals("Default scheme not as expected ?", "http", mockPortletRequest.getScheme()); + assertEquals("Default server name not as expected ?", "localhost", mockPortletRequest.getServerName()); + assertEquals("Default server port not as expected ?", 80, mockPortletRequest.getServerPort()); + final MockPortalContext mockPortalContext = new MockPortalContext(); + final MockPortletContext mockPortletContext = new MockPortletContext(); + mockPortletRequest = new MockPortletRequest(mockPortletContext); // Only test is to confirm constructor completes without exception + mockPortletRequest = new MockPortletRequest(mockPortalContext, mockPortletContext); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockPortletRequest.getPortalContext()); + mockPortletRequest.addResponseContentType(TEST_CONTENT_TYPE); + mockPortletRequest.addResponseContentType(TEST_CONTENT_TYPE2); + Enumeration contentTypes = mockPortletRequest.getResponseContentTypes(); + assertNotNull("MockPortletRequest content-types null ?", contentTypes); + final ArrayList contentTypesList = new ArrayList<>(); + while (contentTypes.hasMoreElements()) { + contentTypesList.add(contentTypes.nextElement()); + } + assertEquals("MockPortletRequest does not contain three content-types ?", 3, contentTypesList.size()); + assertTrue("MockPortletRequest does not contain content-type " + TEST_CONTENT_TYPE + " ?", contentTypesList.contains(TEST_CONTENT_TYPE)); + assertTrue("MockPortletRequest does not contain content-type " + TEST_CONTENT_TYPE2 + " ?", contentTypesList.contains(TEST_CONTENT_TYPE2)); + assertTrue("MockPortletRequest does not contain default content-type + " + TEST_DEFAULT_CONTENT_TYPE + " ?", contentTypesList.contains(TEST_DEFAULT_CONTENT_TYPE)); + assertTrue("View portlet mode not allowed ?", mockPortletRequest.isPortletModeAllowed(PortletMode.VIEW)); + assertTrue("Edit portlet mode not allowed ?", mockPortletRequest.isPortletModeAllowed(PortletMode.EDIT)); + assertTrue("Help portlet mode not allowed ?", mockPortletRequest.isPortletModeAllowed(PortletMode.HELP)); + assertTrue("Normal window state not allowed ?", mockPortletRequest.isWindowStateAllowed(WindowState.NORMAL)); + assertTrue("Maximized window state not allowed ?", mockPortletRequest.isWindowStateAllowed(WindowState.MAXIMIZED)); + assertTrue("Minimized window state not allowed ?", mockPortletRequest.isWindowStateAllowed(WindowState.MINIMIZED)); + mockPortletRequest.setPortletMode(PortletMode.EDIT); + assertEquals("Portlet mode does not match set value ?", PortletMode.EDIT, mockPortletRequest.getPortletMode()); + mockPortletRequest.setWindowState(WindowState.MAXIMIZED); + assertEquals("Window state does not match set value ?", WindowState.MAXIMIZED, mockPortletRequest.getWindowState()); + final MockPortletPreferences mockPortletPreferences = new MockPortletPreferences(); + mockPortletRequest.setPreferences(mockPortletPreferences); + assertEquals("Portlet preferences does not match set value ?", mockPortletPreferences, mockPortletRequest.getPreferences()); + final MockPortletSession mockPortletSession = new MockPortletSession(mockPortletContext); + mockPortletRequest.setSession(mockPortletSession); + assertEquals("Portlet session does not match set value ?", mockPortletSession, mockPortletRequest.getPortletSession()); + assertTrue("Set request sessionid not valid ?", mockPortletRequest.isRequestedSessionIdValid()); + mockPortletRequest.setRequestedSessionIdValid(false); + assertFalse("Set request sessionid still valid after set invalid ?", mockPortletRequest.isRequestedSessionIdValid()); + mockPortletRequest.setRequestedSessionIdValid(true); + assertTrue("Set request sessionid not valid after set valid ?", mockPortletRequest.isRequestedSessionIdValid()); + + mockPortletRequest.setProperty(TEST_PROPERTY, TEST_PROPERTY_VALUE); + mockPortletRequest.setProperty(TEST_PROPERTY2, TEST_PROPERTY2_VALUE); + final Enumeration propertyNames = mockPortletRequest.getPropertyNames(); + assertNotNull("MockPortalContext property names null ?", propertyNames); + final ArrayList propertyNamesList = new ArrayList<>(); + while (propertyNames.hasMoreElements()) { + propertyNamesList.add(propertyNames.nextElement()); + } + assertEquals("MockPortletRequest does not contain two properties ?", 2, propertyNamesList.size()); + assertTrue("MockPortletRequest does not contain property name " + TEST_PROPERTY + " ?", propertyNamesList.contains(TEST_PROPERTY)); + assertTrue("MockPortletRequest does not contain property name " + TEST_PROPERTY2 + " ?", propertyNamesList.contains(TEST_PROPERTY2)); + assertEquals("MockPortletRequest value of property name " + TEST_PROPERTY + " not as expected ?", TEST_PROPERTY_VALUE, mockPortletRequest.getProperty(TEST_PROPERTY)); + assertEquals("MockPortletRequest value of property name " + TEST_PROPERTY2 + " not as expected ?", TEST_PROPERTY2_VALUE, mockPortletRequest.getProperty(TEST_PROPERTY2)); + mockPortletRequest.addProperty(TEST_PROPERTY, TEST_PROPERTY2_VALUE); + final Enumeration propertiesForName = mockPortletRequest.getProperties(TEST_PROPERTY); + assertNotNull("MockPortletRequest properties for " + TEST_PROPERTY + " is null ?", propertiesForName); + final ArrayList propertiesForNameList = new ArrayList<>(); + while (propertiesForName.hasMoreElements()) { + propertiesForNameList.add(propertiesForName.nextElement()); + } + assertEquals("MockPortletRequest does not contain two values for " + TEST_PROPERTY + " ?", 2, propertiesForNameList.size()); + assertTrue("MockPortletRequest does not contain expected value for property name " + TEST_PROPERTY + " ?", propertiesForNameList.contains(TEST_PROPERTY_VALUE)); + assertTrue("MockPortletRequest does not contain expected value for propety name " + TEST_PROPERTY + " ?", propertiesForNameList.contains(TEST_PROPERTY2_VALUE)); + + mockPortletRequest.setAuthType(TEST_AUTHTYPE); + assertEquals("Authtype not equal to set value ?", TEST_AUTHTYPE, mockPortletRequest.getAuthType()); + mockPortletRequest.setContextPath(TEST_FAKECONTEXTPATH); + assertEquals("Context path not equal to set value ?", TEST_FAKECONTEXTPATH, mockPortletRequest.getContextPath()); + mockPortletRequest.setRemoteUser(TEST_FAKEREMOTEUSER); + assertEquals("Remote user not equal to set value ?", TEST_FAKEREMOTEUSER, mockPortletRequest.getRemoteUser()); + final TestMockPrincipal testMockPrincipal = new TestMockPrincipal(); + mockPortletRequest.setUserPrincipal(testMockPrincipal); + assertEquals("User principal not equal to set value ?", testMockPrincipal, mockPortletRequest.getUserPrincipal()); + mockPortletRequest.addUserRole(TEST_FAKEUSERROLE); + assertTrue("Usser not in added role ?", mockPortletRequest.isUserInRole(TEST_FAKEUSERROLE)); + + assertNull(TEST_PARAM + " present before set ?", mockPortletRequest.getParameter(TEST_PARAM)); + assertNull(TEST_PARAM2 + " present before set ?", mockPortletRequest.getParameter(TEST_PARAM)); + mockPortletRequest.addParameter(TEST_PARAM, TEST_PARAM_VALUE); + mockPortletRequest.addParameter(TEST_PARAM2, TEST_PARAM_VALUE2); + assertEquals("Retrieved parameter 1 does not match set value ?", TEST_PARAM_VALUE, mockPortletRequest.getParameter(TEST_PARAM)); + assertEquals("Retrieved parameter 2 does not match set value ?", TEST_PARAM_VALUE2, mockPortletRequest.getParameter(TEST_PARAM2)); + final Enumeration parameterNames = mockPortletRequest.getParameterNames(); + int parameterNameCount = 0; + assertNotNull("Parameter names null after additions ?", parameterNames); + assertTrue("Parameter names empty after additions ?", parameterNames.hasMoreElements()); + while (parameterNames.hasMoreElements()) { + parameterNameCount++; + String currentParameterName = parameterNames.nextElement(); + assertTrue("Param name not one of two expected matches ?", TEST_PARAM.equals(currentParameterName) || + TEST_PARAM2.equals(currentParameterName)); + } + assertEquals("Parameter names size not 2 ?", 2, parameterNameCount); + mockPortletRequest.addParameter(TEST_ARRAYPARAM, TEST_PARAM_ARRAYVALUE); + assertTrue("Array parameter value not set as expected ?", Arrays.equals(TEST_PARAM_ARRAYVALUE, mockPortletRequest.getParameterValues(TEST_ARRAYPARAM))); + final Map parameterMap = mockPortletRequest.getParameterMap(); + assertNotNull("Parameter map is null ?", parameterMap); + assertTrue("Expected parameter not present ?", parameterMap.containsKey(TEST_PARAM)); + assertTrue("Expected parameter not present ?", parameterMap.containsKey(TEST_PARAM2)); + assertTrue("Expected parameter not present ?", parameterMap.containsKey(TEST_ARRAYPARAM)); + + assertNull(TEST_ATTRIBUTE + " present before set ?", mockPortletRequest.getAttribute(TEST_ATTRIBUTE)); + assertNull(TEST_ATTRIBUTE2 + " present before set ?", mockPortletRequest.getAttribute(TEST_ATTRIBUTE2)); + mockPortletRequest.setAttribute(TEST_ATTRIBUTE, TEST_ATTRIBUTE_VALUE); + mockPortletRequest.setAttribute(TEST_ATTRIBUTE2, TEST_ATTRIBUTE_VALUE2); + assertEquals("Retrieved atribute 1 does not match set value ?", TEST_ATTRIBUTE_VALUE, mockPortletRequest.getAttribute(TEST_ATTRIBUTE)); + assertEquals("Retrieved atribute 2 does not match set value ?", TEST_ATTRIBUTE_VALUE2, mockPortletRequest.getAttribute(TEST_ATTRIBUTE2)); + final Enumeration attributeNames = mockPortletRequest.getAttributeNames(); + int attributeNameCount = 0; + assertNotNull("Attribute names null after additions ?", attributeNames); + assertTrue("Attribute names empty after additions ?", attributeNames.hasMoreElements()); + while (attributeNames.hasMoreElements()) { + attributeNameCount++; + String currentAttibuteName = attributeNames.nextElement(); + assertTrue("Attribute name not one of two or three expected matches ?", TEST_ATTRIBUTE.equals(currentAttibuteName) || + TEST_ATTRIBUTE2.equals(currentAttibuteName) || + PortletRequest.LIFECYCLE_PHASE.equals(currentAttibuteName)); + } + assertTrue("Atribute names size not 2 or 3 ?", attributeNameCount >= 2 && attributeNameCount <= 3); + + mockPortletRequest.addPreferredLocale(Locale.FRENCH); + assertEquals("Preferred locale not as expected ?", Locale.FRENCH, mockPortletRequest.getLocale()); + final Enumeration locales = mockPortletRequest.getLocales(); + assertNotNull("Locales null after additions ?", locales); + assertTrue("Locales names empty after additions ?", locales.hasMoreElements()); + final Locale firstLocale = locales.nextElement(); + assertEquals("First locale not set value ?", Locale.FRENCH, firstLocale); + final Locale secondLocale = locales.nextElement(); + assertEquals("Second locale not default value ?", Locale.ENGLISH, secondLocale); + mockPortletRequest.setScheme(TEST_SCHEME); + assertEquals("Scheme not equal to set value ?", TEST_SCHEME, mockPortletRequest.getScheme()); + mockPortletRequest.setServerName(TEST_HOST); + assertEquals("Server name not equal to set value ?", TEST_HOST, mockPortletRequest.getServerName()); + mockPortletRequest.setServerPort(TEST_PORT); + assertEquals("Server port not equal to set value ?", TEST_PORT, mockPortletRequest.getServerPort()); + mockPortletRequest.setWindowID(TEST_WINDOWID); + assertEquals("Window id not equal to set value ?", TEST_WINDOWID, mockPortletRequest.getWindowID()); + + mockPortletRequest.setCookies(PORLET_TEST_COOKIE, PORLET_TEST_COOKIE2); + final Cookie[] cookies = mockPortletRequest.getCookies(); + assertNotNull("Cookies array null ?", cookies); + assertEquals("Cookies array length not 2 ?", 2, cookies.length); + for (Cookie cookie : cookies) { + assertTrue("Cookie not one of set cookies ?", PORLET_TEST_COOKIE.equals(cookie) || PORLET_TEST_COOKIE2.equals(cookie)); + } + + final Map originalPrivateParameters = mockPortletRequest.getPrivateParameterMap(); + final Map originalPublicParameters = mockPortletRequest.getPublicParameterMap(); + assertNotNull("Original private parameters map is null ?", originalPrivateParameters); + assertFalse("Original private parameters map is empty ?", originalPrivateParameters.isEmpty()); + assertTrue("Original private parameters map does not contain " + TEST_PARAM + " ?", originalPrivateParameters.containsKey(TEST_PARAM)); + assertTrue("Original private parameters map does not contain " + TEST_PARAM2 + " ?", originalPrivateParameters.containsKey(TEST_PARAM2)); + assertNotNull("Original public parameters map is null ?", originalPublicParameters); + assertTrue("Original public parameters map is not empty ?", originalPublicParameters.isEmpty()); + mockPortletRequest.registerPublicParameter(TEST_PARAM2); + final Map updatedPrivateParameters = mockPortletRequest.getPrivateParameterMap(); + final Map updatedPublicParameters = mockPortletRequest.getPublicParameterMap(); + assertNotNull("Updated private parameters map is null ?", updatedPrivateParameters); + assertFalse("Updated private parameters map is empty ?", updatedPrivateParameters.isEmpty()); + assertFalse("Updated private parameters map contains " + TEST_PARAM2 + " ?", updatedPrivateParameters.containsKey(TEST_PARAM2)); + assertTrue("Updated private parameters map does not contain " + TEST_PARAM + " ?", updatedPrivateParameters.containsKey(TEST_PARAM)); + assertNotNull("Updated public parameters map is null ?", updatedPublicParameters); + assertFalse("Updated public parameters map is empty ?", updatedPublicParameters.isEmpty()); + assertFalse("Updated public parameters map contains " + TEST_PARAM + " ?", updatedPublicParameters.containsKey(TEST_PARAM)); + assertTrue("Updated public parameters map does not contain " + TEST_PARAM2 + " ?", updatedPublicParameters.containsKey(TEST_PARAM2)); + } + + public void testMockPortletRequestDispatcher() { + final String TEST_DISPATCH_URL = "localhost:8080/fakeurl"; + + // Call each constructor in sequence, do some basic checks + MockPortletRequestDispatcher mockPortletRequestDispatcher = new MockPortletRequestDispatcher(TEST_DISPATCH_URL); + final MockRenderRequest mockRenderRequest = new MockRenderRequest(); + final MockRenderResponse mockRenderResponse = new MockRenderResponse(); + try { + mockPortletRequestDispatcher.include(mockRenderRequest, mockRenderResponse); + } catch (Exception ex) { + fail("MockPortletRequestDispatcher include (render) failed. Exception: " + ex); + } + final MockPortletRequest mockPortletRequest = new MockPortletRequest(); + final MockPortletResponse mockPortletResponse = new MockPortletResponse(); + final MockMimeResponse mockMimeResponse = new MockMimeResponse(); + try { + mockPortletRequestDispatcher.include(mockPortletRequest, mockPortletResponse); + fail("Include of non-MockMimeResponse did not throw an exception ?"); + } catch (IllegalArgumentException iae) { + // Expected failure + } catch (Exception ex) { + fail("MockPortletRequestDispatcher include (portlet) failed. Exception: " + ex); + } + try { + mockPortletRequestDispatcher.include(mockPortletRequest, mockMimeResponse); + } catch (Exception ex) { + fail("MockPortletRequestDispatcher include (portlet) failed. Exception: " + ex); + } + try { + mockPortletRequestDispatcher.forward(mockPortletRequest, mockPortletResponse); + fail("Forward of non-MockMimeResponse did not throw an exception ?"); + } catch (IllegalArgumentException iae) { + // Expected failure + } catch (Exception ex) { + fail("MockPortletRequestDispatcher forward failed. Exception: " + ex); + } + try { + mockPortletRequestDispatcher.forward(mockPortletRequest, mockMimeResponse); + } catch (Exception ex) { + fail("MockPortletRequestDispatcher forward failed. Exception: " + ex); + } + } + + public void testMockPortletResponse() { + final String TEST_ENCODE_URL = "localhost:8080/fakeforwardedurl?param1=param with spaces"; + final String TEST_NAMESPACE = "Test_Namespace"; + final String TEST_PROPERTY = "TEST_PROPERTY"; + final String TEST_PROPERTY_VALUE = "Property_Value_1"; + final String TEST_PROPERTY2 = "TEST_PROPERTY2"; + final String TEST_PROPERTY2_VALUE = "Property_Value_2"; + final String TEST_XMLPROPERTY = "TEST_XMLPROPERTY"; + final String TEST_XML_TAGNAME = "TEST_XML_TAGNAME"; + final String TEST_COOKIE_ID = "TEST_COOKIE_ID"; + + // Call each constructor in sequence, do some basic checks + MockPortletResponse mockPortletResponse = new MockPortletResponse(); + assertEquals("Default namespace not as expected ?", "", mockPortletResponse.getNamespace()); + assertNotNull("Default portal context null ?", mockPortletResponse.getPortalContext()); + assertEquals("Encoded URL not as expected ?", TEST_ENCODE_URL, mockPortletResponse.encodeURL(TEST_ENCODE_URL)); // Mock URL encode does nothing + mockPortletResponse.setNamespace(TEST_NAMESPACE); + assertEquals("Set namespace not as expected ?", TEST_NAMESPACE, mockPortletResponse.getNamespace()); + final MockPortalContext mockPortalContext = new MockPortalContext(); + mockPortletResponse = new MockPortletResponse(mockPortalContext); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockPortletResponse.getPortalContext()); + + mockPortletResponse.setProperty(TEST_PROPERTY, TEST_PROPERTY_VALUE); + mockPortletResponse.setProperty(TEST_PROPERTY2, TEST_PROPERTY2_VALUE); + final Set propertyNames = mockPortletResponse.getPropertyNames(); + assertNotNull("MockPortletResponse property names null ?", propertyNames); + assertEquals("MockPortletResponse does not contain two properties ?", 2, propertyNames.size()); + assertTrue("MockPortletResponse does not contain property name " + TEST_PROPERTY + " ?", propertyNames.contains(TEST_PROPERTY)); + assertTrue("MockPortletResponse does not contain property name " + TEST_PROPERTY2 + " ?", propertyNames.contains(TEST_PROPERTY2)); + assertEquals("MockPortletResponse value of property name " + TEST_PROPERTY + " not as expected ?", TEST_PROPERTY_VALUE, mockPortletResponse.getProperty(TEST_PROPERTY)); + assertEquals("MockPortletResponse value of property name " + TEST_PROPERTY2 + " not as expected ?", TEST_PROPERTY2_VALUE, mockPortletResponse.getProperty(TEST_PROPERTY2)); + mockPortletResponse.addProperty(TEST_PROPERTY, TEST_PROPERTY2_VALUE); + final String[] propertiesForName = mockPortletResponse.getProperties(TEST_PROPERTY); + assertNotNull("MockPortletResponse properties for " + TEST_PROPERTY + " is null ?", propertiesForName); + final ArrayList propertiesForNameList = new ArrayList<>(); + propertiesForNameList.addAll(Arrays.asList(propertiesForName)); + assertEquals("MockPortletResponse does not contain two values for " + TEST_PROPERTY + " ?", 2, propertiesForNameList.size()); + assertTrue("MockPortletResponse does not contain expected value for property name " + TEST_PROPERTY + " ?", propertiesForNameList.contains(TEST_PROPERTY_VALUE)); + assertTrue("MockPortletResponse does not contain expected value for propety name " + TEST_PROPERTY + " ?", propertiesForNameList.contains(TEST_PROPERTY2_VALUE)); + + final Cookie[] cookies = mockPortletResponse.getCookies(); + assertNotNull("Cookies array null ?", cookies); + assertEquals("Cookies array length not 0 ?", 0, cookies.length); + assertNull("Cookie found ?", mockPortletResponse.getCookie(TEST_COOKIE_ID)); + + Set xmlPropertyNames = mockPortletResponse.getXmlPropertyNames(); + assertNotNull("MockPortletResponse XML property names null ?", xmlPropertyNames); + assertTrue("XML properites set not empty ?", xmlPropertyNames.isEmpty()); + assertNull("XML property found ?", mockPortletResponse.getXmlProperty(TEST_XMLPROPERTY)); + Element[] xmlProperties = mockPortletResponse.getXmlProperties(TEST_XMLPROPERTY); + assertNull("XML properties found ?", xmlProperties); + Element element = mockPortletResponse.createElement(TEST_XML_TAGNAME); + assertNotNull("MockPortletResponse XML element null ?", element); + mockPortletResponse.addProperty(TEST_XMLPROPERTY, element); + xmlPropertyNames = mockPortletResponse.getXmlPropertyNames(); + assertNotNull("MockPortletResponse XML property names null ?", xmlPropertyNames); + assertFalse("XML properites set empty ?", xmlPropertyNames.isEmpty()); + assertNotNull("XML property not found ?", mockPortletResponse.getXmlProperty(TEST_XMLPROPERTY)); + xmlProperties = mockPortletResponse.getXmlProperties(TEST_XMLPROPERTY); + assertNotNull("XML properties not found ?", xmlProperties); + assertEquals("XML properties not expected size ?", 1, xmlProperties.length); + assertEquals("XML property at index 0 not element value ?", element, xmlProperties[0]); + } + + public void testMockPortletSession() { + final String TEST_ATTRIBUTE = "TEST_ATTRIBUTE"; + final String TEST_ATTRIBUTE_VALUE = "Attribute_Value_1"; + final String TEST_ATTRIBUTE2 = "TEST_ATTRIBUTE2"; + final String TEST_ATTRIBUTE_VALUE2 = "Attribute_Value_2"; + final long TEST_START_TIME = System.currentTimeMillis(); + final int TEST_MAXINACTIVE_INTERVAL = 300; + + // Call each constructor in sequence, do some basic checks + MockPortletSession mockPortletSession = new MockPortletSession(); + final String INITIAL_SESSION_ID = mockPortletSession.getId(); + assertNotNull("MockPortletSession session id null ?", INITIAL_SESSION_ID); + assertFalse("MockPortletSession session is invalid ?", mockPortletSession.isInvalid()); + assertTrue("MockPortletSession session is not new ?", mockPortletSession.isNew()); + mockPortletSession.setNew(false); + assertFalse("MockPortletSession session is still new ?", mockPortletSession.isNew()); + mockPortletSession.setNew(true); + assertTrue("MockPortletSession session is not new after set ?", mockPortletSession.isNew()); + assertEquals("MockPortletSession max inactive interval not 0 ?", 0, mockPortletSession.getMaxInactiveInterval()); + assertNotNull("Default portlet context null ?", mockPortletSession.getPortletContext()); + assertTrue("MockPortletSession session creation time in past ?", mockPortletSession.getCreationTime() >= TEST_START_TIME); + assertTrue("MockPortletSession session last accessed time in past ?", mockPortletSession.getLastAccessedTime() >= TEST_START_TIME); + assertTrue("MockPortletSession session last accessed time older than creation time ?", mockPortletSession.getLastAccessedTime() >= mockPortletSession.getCreationTime()); + assertNotNull("Default portlet attribute map null ?", mockPortletSession.getAttributeMap()); + assertNotNull("Default portlet portletscope attribute map null ?", mockPortletSession.getAttributeMap(PortletSession.PORTLET_SCOPE)); + assertNotNull("Default portlet applicationscope attribute map null ?", mockPortletSession.getAttributeMap(PortletSession.APPLICATION_SCOPE)); + final MockPortletContext mockPortletContext = new MockPortletContext(); + mockPortletSession = new MockPortletSession(mockPortletContext); + assertEquals("MockPortletSession portletcontext not equal to set value ?", mockPortletContext, mockPortletSession.getPortletContext()); + final String NEW_SESSION_ID = mockPortletSession.getId(); + assertNotNull("MockPortletSession session id null ?", NEW_SESSION_ID); + assertFalse("Original and new session id match ?", NEW_SESSION_ID.equals(INITIAL_SESSION_ID)); + + assertNull(TEST_ATTRIBUTE + " present before set ?", mockPortletSession.getAttribute(TEST_ATTRIBUTE)); + assertNull(TEST_ATTRIBUTE2 + " present before set ?", mockPortletSession.getAttribute(TEST_ATTRIBUTE2)); + mockPortletSession.setAttribute(TEST_ATTRIBUTE, TEST_ATTRIBUTE_VALUE); + mockPortletSession.setAttribute(TEST_ATTRIBUTE2, TEST_ATTRIBUTE_VALUE2); + assertEquals("Retrieved atribute 1 does not match set value ?", TEST_ATTRIBUTE_VALUE, mockPortletSession.getAttribute(TEST_ATTRIBUTE)); + assertEquals("Retrieved atribute 2 does not match set value ?", TEST_ATTRIBUTE_VALUE2, mockPortletSession.getAttribute(TEST_ATTRIBUTE2)); + final Enumeration attributeNames = mockPortletSession.getAttributeNames(); + int attributeNameCount = 0; + assertNotNull("Attribute names null after additions ?", attributeNames); + assertTrue("Attribute names empty after additions ?", attributeNames.hasMoreElements()); + while (attributeNames.hasMoreElements()) { + attributeNameCount++; + String currentAttibuteName = attributeNames.nextElement(); + assertTrue("Attribute name not one of two expected matches ?", TEST_ATTRIBUTE.equals(currentAttibuteName) || + TEST_ATTRIBUTE2.equals(currentAttibuteName)); + } + assertEquals("Atribute names size not expected value ?", 2, attributeNameCount); + assertNull(TEST_ATTRIBUTE + " present before set (application scope) ?", mockPortletSession.getAttribute(TEST_ATTRIBUTE, PortletSession.APPLICATION_SCOPE)); + assertNull(TEST_ATTRIBUTE2 + " present before set (application scope) ?", mockPortletSession.getAttribute(TEST_ATTRIBUTE2, PortletSession.APPLICATION_SCOPE)); + mockPortletSession.setAttribute(TEST_ATTRIBUTE, TEST_ATTRIBUTE_VALUE, PortletSession.APPLICATION_SCOPE); + mockPortletSession.setAttribute(TEST_ATTRIBUTE2, TEST_ATTRIBUTE_VALUE2, PortletSession.APPLICATION_SCOPE); + assertEquals("Retrieved atribute 1 does not match set value (application scope) ?", TEST_ATTRIBUTE_VALUE, mockPortletSession.getAttribute(TEST_ATTRIBUTE, PortletSession.APPLICATION_SCOPE)); + assertEquals("Retrieved atribute 2 does not match set value (application scope) ?", TEST_ATTRIBUTE_VALUE2, mockPortletSession.getAttribute(TEST_ATTRIBUTE2, PortletSession.APPLICATION_SCOPE)); + final Enumeration attributeNamesApplication = mockPortletSession.getAttributeNames(PortletSession.APPLICATION_SCOPE); + int attributeNameCountApplication = 0; + assertNotNull("Attribute names null after additions (application scope) ?", attributeNamesApplication); + assertTrue("Attribute names empty after additions (application scope) ?", attributeNamesApplication.hasMoreElements()); + while (attributeNamesApplication.hasMoreElements()) { + attributeNameCountApplication++; + String currentAttibuteName = attributeNamesApplication.nextElement(); + assertTrue("Attribute name not one of two expected matches (application scope) ?", TEST_ATTRIBUTE.equals(currentAttibuteName) || + TEST_ATTRIBUTE2.equals(currentAttibuteName)); + } + assertEquals("Atribute names size not expected value (application scope) ?", 2, attributeNameCount); + + assertTrue("MockPortletSession session is not new ?", mockPortletSession.isNew()); + mockPortletSession.access(); + assertFalse("MockPortletSession session is still new after access ?", mockPortletSession.isNew()); + mockPortletSession.setMaxInactiveInterval(TEST_MAXINACTIVE_INTERVAL); + assertEquals("MockPortletSession max inactive interval not set value ?", TEST_MAXINACTIVE_INTERVAL, mockPortletSession.getMaxInactiveInterval()); + mockPortletSession.removeAttribute(TEST_ATTRIBUTE2); + assertNull(TEST_ATTRIBUTE2 + " still present after removal ?", mockPortletSession.getAttribute(TEST_ATTRIBUTE2)); + mockPortletSession.removeAttribute(TEST_ATTRIBUTE, PortletSession.APPLICATION_SCOPE); + assertNull(TEST_ATTRIBUTE + " still present after removal (application scope) ?", mockPortletSession.getAttribute(TEST_ATTRIBUTE, PortletSession.APPLICATION_SCOPE)); + final long BEFORE_INVALIDATE_TIME = System.currentTimeMillis(); + mockPortletSession.invalidate(); + assertTrue("MockPortletSession session is still valid after invalidate ?", mockPortletSession.isInvalid()); + assertNull(TEST_ATTRIBUTE + " still present after invalidate ?", mockPortletSession.getAttribute(TEST_ATTRIBUTE)); + assertNull(TEST_ATTRIBUTE2 + " still present after removal (application scope) ?", mockPortletSession.getAttribute(TEST_ATTRIBUTE2, PortletSession.APPLICATION_SCOPE)); + assertTrue("MockPortletSession session last accessed time older than creation time ?", mockPortletSession.getLastAccessedTime() >= mockPortletSession.getCreationTime()); + assertTrue("MockPortletSession session last accessed time older than time before invalidation ?", mockPortletSession.getLastAccessedTime() >= BEFORE_INVALIDATE_TIME); + } + + public void testMockPortletURL() { + final String TEST_PARAMETER = "TEST_PARAMETER"; + + // Call each constructor in sequence, do some basic checks + final MockPortalContext mockPortalContext = new MockPortalContext(); + final MockPortletURL mockPortletURL = new MockPortletURL(mockPortalContext, MockPortletURL.URL_TYPE_RENDER); + assertNull("MockPortletURL default portlet mode not null ?", mockPortletURL.getPortletMode()); + assertNull("MockPortletURL default window state not null ?", mockPortletURL.getWindowState()); + try { + mockPortletURL.setWindowState(WindowState.MAXIMIZED); + } catch (Exception ex) { + fail("MockPortletURL window state set failed. Exception: " + ex); + } + assertEquals("Window state does not match set value ?", WindowState.MAXIMIZED, mockPortletURL.getWindowState()); + try { + mockPortletURL.setPortletMode(PortletMode.VIEW); + } catch (Exception ex) { + fail("MockPortletURL portlet mode set failed. Exception: " + ex); + } + assertEquals("PortletMode.VIEW not set ?", PortletMode.VIEW, mockPortletURL.getPortletMode()); + final String portletURLAsString = mockPortletURL.toString(); + assertNotNull("MockPortletURL toString() result null ?", portletURLAsString); + assertTrue("MockPortletURL toString() result is empty ?", portletURLAsString.length() > 0); + mockPortletURL.removePublicRenderParameter(TEST_PARAMETER); // Just confirm no exception + } + + public void testMockRenderRequest() { + final MockPortletContext mockPortletContext = new MockPortletContext(); + final MockPortalContext mockPortalContext = new MockPortalContext(); + + // Call each constructor in sequence, do some basic checks + MockRenderRequest mockRenderRequest = new MockRenderRequest(); + assertNull("MockRenderRequest ETag not null ?", mockRenderRequest.getETag()); + mockRenderRequest = new MockRenderRequest(PortletMode.HELP); + assertEquals("MockRenderRequest portlet mode does not match constructor-set value ?", PortletMode.HELP, mockRenderRequest.getPortletMode()); + mockRenderRequest = new MockRenderRequest(PortletMode.HELP, WindowState.MAXIMIZED); + assertEquals("MockRenderRequest portlet mode does not match constructor-set value ?", PortletMode.HELP, mockRenderRequest.getPortletMode()); + assertEquals("MockRenderRequest window state does not match constructor-set value ?", WindowState.MAXIMIZED, mockRenderRequest.getWindowState()); + mockRenderRequest = new MockRenderRequest(mockPortletContext); // Only test is to confirm constructor completes without exception + mockRenderRequest = new MockRenderRequest(mockPortalContext, mockPortletContext); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockRenderRequest.getPortalContext()); + } + + public void testMockRenderResponse() { + final String TEST_TITLE = "TEST_TITLE"; + + // Call each constructor in sequence, do some basic checks + final MockPortalContext mockPortalContext = new MockPortalContext(); + final MockRenderRequest mockRenderRequest = new MockRenderRequest(); + MockRenderResponse mockRenderResponse = new MockRenderResponse(); + assertNull("MockRenderResponse title not null ?", mockRenderResponse.getTitle()); + mockRenderResponse = new MockRenderResponse(mockPortalContext); // Only test is to confirm constructor completes without exception + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockRenderResponse.getPortalContext()); + mockRenderResponse = new MockRenderResponse(mockPortalContext, mockRenderRequest); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockRenderResponse.getPortalContext()); + mockRenderResponse.setTitle(TEST_TITLE); + assertEquals("Title does not match set value ?", TEST_TITLE, mockRenderResponse.getTitle()); + final Collection portletModes = new ArrayList<>(); + portletModes.add(PortletMode.EDIT); + portletModes.add(PortletMode.VIEW); + mockRenderResponse.setNextPossiblePortletModes(portletModes); + assertEquals("Next possible portlet modes not equal to set value ?", portletModes, mockRenderResponse.getNextPossiblePortletModes()); + } + + public void testMockResourceRequest() { + final String TEST_RESOURCEID = "TEST_RESOURCEID"; + final String TEST_CACHEABILITY = "TEST_CACHEABILITY"; + final String TEST_PARAM = "TEST_PARAM"; + final String TEST_PARAM2 = "TEST_PARAM2"; + final String TEST_PARAM_VALUE = "NORMALVALUE"; + final String[] TEST_PARAM_ARRAYVALUE = { "ARRAYVALUE1", "ARRAYVALUE2" }; + + // Call each constructor in sequence, do some basic checks + MockResourceRequest mockResourceRequest = new MockResourceRequest(); + assertNull("Default resource id not null ?", mockResourceRequest.getResourceID()); + assertNull("Default cacheability not null ?", mockResourceRequest.getCacheability()); + assertNull("Default ETag not null ?", mockResourceRequest.getETag()); + mockResourceRequest = new MockResourceRequest(TEST_RESOURCEID); + assertEquals("Resource id not set value ?", TEST_RESOURCEID, mockResourceRequest.getResourceID()); + final MockPortletContext mockPortletContext = new MockPortletContext(); + final MockPortalContext mockPortalContext = new MockPortalContext(); + final MockResourceURL mockResourceURL = new MockResourceURL(); + mockResourceRequest = new MockResourceRequest(mockResourceURL); // Only test is to confirm constructor completes without exception + mockResourceRequest = new MockResourceRequest(mockPortletContext); // Only test is to confirm constructor completes without exception + mockResourceRequest = new MockResourceRequest(mockPortalContext, mockPortletContext); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockResourceRequest.getPortalContext()); + mockResourceRequest.setCacheability(TEST_CACHEABILITY); + assertEquals("Cacheability does not match set value ?", TEST_CACHEABILITY, mockResourceRequest.getCacheability()); + mockResourceRequest.addPrivateRenderParameter(TEST_PARAM, TEST_PARAM_VALUE); + mockResourceRequest.addPrivateRenderParameter(TEST_PARAM2, TEST_PARAM_ARRAYVALUE); + final Map privateRenderParameterMap = mockResourceRequest.getPrivateRenderParameterMap(); + assertNotNull("Parameter map is null ?", privateRenderParameterMap); + assertTrue("Expected parameter not present ?", privateRenderParameterMap.containsKey(TEST_PARAM)); + assertTrue("Expected parameter not present ?", privateRenderParameterMap.containsKey(TEST_PARAM2)); + } + + public void testMockResourceResponse() { + final int TEST_CONTENT_LENGTH = 4096; + + // Call each constructor in sequence, do some basic checks + MockResourceResponse mockResourceRequest = new MockResourceResponse(); + assertEquals("MockResourceResponse initial content length not 0 ?", 0, mockResourceRequest.getContentLength()); + mockResourceRequest.setContentLength(TEST_CONTENT_LENGTH); + assertEquals("Content length not equal to set value ?", TEST_CONTENT_LENGTH, mockResourceRequest.getContentLength()); + } + + public void testMockResourceURL() { + final String TEST_RESOURCEID = "TEST_RESOURCEID"; + final String TEST_CACHEABILITY = "TEST_CACHEABILITY"; + + // Call each constructor in sequence, do some basic checks + MockResourceURL mockResourceURL = new MockResourceURL(); + assertNull("Default resource id not null ?", mockResourceURL.getResourceID()); + assertNull("Default cacheability not null ?", mockResourceURL.getCacheability()); + mockResourceURL.setResourceID(TEST_RESOURCEID); + assertEquals("Resource id not set value ?", TEST_RESOURCEID, mockResourceURL.getResourceID()); + mockResourceURL.setCacheability(TEST_CACHEABILITY); + assertEquals("Cacheability does not match set value ?", TEST_CACHEABILITY, mockResourceURL.getCacheability()); + final String resourceURLAsString = mockResourceURL.toString(); + assertNotNull("MockResourceURL toString() result null ?", resourceURLAsString); + assertTrue("MockResourceURL toString() result is empty ?", resourceURLAsString.length() > 0); + } + + public void testMockStateAwareResponse() { + final String TEST_PORTLETNAME = "TestPortletName"; + final String TEST_DEFAULTNAMESPACE = "Test_Default_Namespace"; + final String TEST_QNAME3_STRING = "TestQname3String"; + final QName TEST_QNAME = new QName(TEST_PORTLETNAME); + final QName TEST_QNAME2 = new QName(TEST_DEFAULTNAMESPACE); + final String TEST_QNAME_VALUE = "Test_Qname_Value"; + final String TEST_QNAME2_VALUE = "Test_Qname2_Value"; + final String TEST_QNAME3_VALUE = "Test_Qname3_Value"; + final String TEST_PARAM = "TEST_PARAM"; + final String TEST_PARAM2 = "TEST_PARAM2"; + final String TEST_PARAM3 = "TEST_PARAM3"; + final String TEST_PARAM_VALUE = "NORMALVALUE"; + final String[] TEST_PARAM_ARRAYVALUE = { "ARRAYVALUE1", "ARRAYVALUE2" }; + final String[] TEST_PARAM_ARRAYVALUE2 = { "ARRAYVALUE3", "ARRAYVALUE4" }; + + // Call each constructor in sequence, do some basic checks + MockStateAwareResponse mockStateAwareResponse = new MockStateAwareResponse(); + try { + mockStateAwareResponse.setPortletMode(PortletMode.VIEW); + } catch (Exception ex) { + fail("MockStateAwareResponse portlet mode set failed. Exception: " + ex); + } + assertEquals("PortletMode.VIEW not set ?", PortletMode.VIEW, mockStateAwareResponse.getPortletMode()); + try { + mockStateAwareResponse.setPortletMode(PortletMode.EDIT); + } catch (Exception ex) { + fail("MockStateAwareResponse portlet mode set failed. Exception: " + ex); + } + assertEquals("Portlet mode does not match set value ?", PortletMode.EDIT, mockStateAwareResponse.getPortletMode()); + try { + mockStateAwareResponse.setWindowState(WindowState.MAXIMIZED); + } catch (Exception ex) { + fail("MockStateAwareResponse portlet mode set failed. Exception: " + ex); + } + assertEquals("Window state does not match set value ?", WindowState.MAXIMIZED, mockStateAwareResponse.getWindowState()); + final MockPortalContext mockPortalContext = new MockPortalContext(); + mockStateAwareResponse = new MockStateAwareResponse(mockPortalContext); + assertEquals("Portal context does not match constructor-set value ?", mockPortalContext, mockStateAwareResponse.getPortalContext()); + + assertNull("Initial event already present ?", mockStateAwareResponse.getEvent(TEST_PORTLETNAME)); + assertNull("Initial event already present ?", mockStateAwareResponse.getEvent(TEST_QNAME)); + assertNull("Initial event already present ?", mockStateAwareResponse.getEvent(TEST_DEFAULTNAMESPACE)); + assertNull("Initial event already present ?", mockStateAwareResponse.getEvent(TEST_QNAME2)); + mockStateAwareResponse.setEvent(TEST_QNAME, TEST_QNAME_VALUE); + mockStateAwareResponse.setEvent(TEST_QNAME2, TEST_QNAME2_VALUE); + mockStateAwareResponse.setEvent(TEST_QNAME3_STRING, TEST_QNAME3_VALUE); + assertEquals("First event QName not set value ?", TEST_QNAME_VALUE, mockStateAwareResponse.getEvent(TEST_QNAME)); + assertEquals("Second event QName not set value ?", TEST_QNAME2_VALUE, mockStateAwareResponse.getEvent(TEST_QNAME2)); + assertEquals("Third event QName not set value ?", TEST_QNAME3_VALUE, mockStateAwareResponse.getEvent(TEST_QNAME3_STRING)); + final Iterator eventQNames = mockStateAwareResponse.getEventNames(); + assertNotNull("Event names iterator null ?", eventQNames); + while (eventQNames.hasNext()) { + QName currentQName = eventQNames.next(); + assertNotNull("Iterator QName entry null ?", currentQName); + assertTrue("Iterator QName name not one of two or three expected matches ?", currentQName.getLocalPart().equals(TEST_QNAME.getLocalPart()) || + currentQName.getLocalPart().equals(TEST_QNAME2.getLocalPart()) || + currentQName.getLocalPart().equals(TEST_QNAME3_STRING)); + } + + mockStateAwareResponse.setRenderParameter(TEST_PARAM, TEST_PARAM_VALUE); + mockStateAwareResponse.setRenderParameter(TEST_PARAM2, TEST_PARAM_ARRAYVALUE); + assertEquals("Portal test render parameter value not as expected ?", TEST_PARAM_VALUE, mockStateAwareResponse.getRenderParameter(TEST_PARAM)); + assertEquals("Portal test render parameter value not as expected ?", TEST_PARAM_ARRAYVALUE[0], mockStateAwareResponse.getRenderParameter(TEST_PARAM2)); + final Iterator renderParameterNames = mockStateAwareResponse.getRenderParameterNames(); + assertNotNull("Render parameter names iterator null ?", renderParameterNames); + while (renderParameterNames.hasNext()) { + String currentParameter = renderParameterNames.next(); + assertNotNull("Iterator parameter entry null ?", currentParameter); + assertTrue("Iterator parameter name not one of two or three expected matches ?", currentParameter.equals(TEST_PARAM) || + currentParameter.equals(TEST_PARAM2) || + currentParameter.equals(TEST_PARAM3)); + } + final String[] renderParameterValuesParam2 = mockStateAwareResponse.getRenderParameterValues(TEST_PARAM2); + assertTrue("Render parameter value2 not as expected ?", Arrays.equals(TEST_PARAM_ARRAYVALUE, renderParameterValuesParam2)); + final Map renderParametersMap = new LinkedHashMap<>(); + renderParametersMap.put(TEST_PARAM3, TEST_PARAM_ARRAYVALUE2); + mockStateAwareResponse.setRenderParameters(renderParametersMap); + assertEquals("Portal test render parameter value not cleared as expected ?", null, mockStateAwareResponse.getRenderParameter(TEST_PARAM)); + assertEquals("Portal test render parameter value not cleared as expected ?", null, mockStateAwareResponse.getRenderParameter(TEST_PARAM2)); + assertEquals("Portal test render parameter map value not as expected ?", renderParametersMap, mockStateAwareResponse.getRenderParameterMap()); + } + + public void testServletWrappingPortletContext() { + final String TEST_ATTRIBUTE = "TEST_ATTRIBUTE"; + final String TEST_ATTRIBUTE_VALUE = "Attribute_Value_1"; + final String TEST_ATTRIBUTE2 = "TEST_ATTRIBUTE2"; + final String TEST_ATTRIBUTE_VALUE2 = "Attribute_Value_2"; + final String TEST_INITPARAM = "TEST_INITPARAM"; + final String TEST_INITPARAM2 = "TEST_INITPARAM2"; + + // Call each constructor in sequence, do some basic checks + final MockServletContext mockServletContext = new MockServletContext(); + final ServletWrappingPortletContext servletWrappingPortletContext = new ServletWrappingPortletContext(mockServletContext); + assertNotNull("ServletWrappingPortletContext serverInfo null ?", servletWrappingPortletContext.getServerInfo()); + assertNull("ServletWrappingPortletContext PortletRequestDispatcher not null (illegal prefix) ?", servletWrappingPortletContext.getRequestDispatcher("IllegalPrefix")); + assertNull("ServletWrappingPortletContext PortletRequestDispatcher not null ?", servletWrappingPortletContext.getRequestDispatcher("/")); + assertNotNull("ServletWrappingPortletContext resource stream for / null ?", servletWrappingPortletContext.getResourceAsStream("/")); + assertNull("ServletWrappingPortletContext resource stream for /ThisDoesNotExist not null ?", servletWrappingPortletContext.getResourceAsStream("/ThisDoesNotExist")); + assertTrue("ServletWrappingPortletContext major version not >= 2 ?", servletWrappingPortletContext.getMajorVersion() >= 2); + assertTrue("ServletWrappingPortletContext minor version not >= 0 ?", servletWrappingPortletContext.getMajorVersion() >= 0); + assertNull("ServletWrappingPortletContext MIME type for / not null ?", servletWrappingPortletContext.getMimeType("/")); + assertNotNull("ServletWrappingPortletContext real path for / null ?", servletWrappingPortletContext.getRealPath("/")); + assertNull("ServletWrappingPortletContext real path for /ThisDoesNotExist not null ? ?", servletWrappingPortletContext.getRealPath("/ThisDoesNotExist")); + assertNull("ServletWrappingPortletContext resource paths for / not null ?", servletWrappingPortletContext.getResourcePaths("/")); + assertNull("ServletWrappingPortletContext resource paths for / null ?", servletWrappingPortletContext.getResourcePaths("/ThisDoesNotExist")); + try { + assertNotNull("ServletWrappingPortletContext resource URL for / null ?", servletWrappingPortletContext.getResource("/")); + } catch (MalformedURLException mue) { + fail("ServletWrappingPortletContext resource URL for / failed. Exception: " + mue); + } + try { + assertNull("ServletWrappingPortletContext resource URL for /ThisDoesNotExist not null ?", servletWrappingPortletContext.getResource("/ThisDoesNotExist")); + } catch (MalformedURLException mue) { + fail("ServletWrappingPortletContext resource URL for /ThisDoesNotExist failed. Exception: " + mue); + } + + assertNull(TEST_ATTRIBUTE + " present before set ?", servletWrappingPortletContext.getAttribute(TEST_ATTRIBUTE)); + assertNull(TEST_ATTRIBUTE2 + " present before set ?", servletWrappingPortletContext.getAttribute(TEST_ATTRIBUTE2)); + servletWrappingPortletContext.setAttribute(TEST_ATTRIBUTE, TEST_ATTRIBUTE_VALUE); + servletWrappingPortletContext.setAttribute(TEST_ATTRIBUTE2, TEST_ATTRIBUTE_VALUE2); + assertEquals("Retrieved atribute 1 does not match set value ?", TEST_ATTRIBUTE_VALUE, servletWrappingPortletContext.getAttribute(TEST_ATTRIBUTE)); + assertEquals("Retrieved atribute 2 does not match set value ?", TEST_ATTRIBUTE_VALUE2, servletWrappingPortletContext.getAttribute(TEST_ATTRIBUTE2)); + final Enumeration attributeNames = servletWrappingPortletContext.getAttributeNames(); + int attributeNameCount = 0; + assertNotNull("Attribute names null after additions ?", attributeNames); + assertTrue("Attribute names empty after additions ?", attributeNames.hasMoreElements()); + while (attributeNames.hasMoreElements()) { + attributeNameCount++; + String currentAttibuteName = attributeNames.nextElement(); + assertTrue("Attribute name not one of two or three expected matches ?", TEST_ATTRIBUTE.equals(currentAttibuteName) || + TEST_ATTRIBUTE2.equals(currentAttibuteName) || + WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE.equals(currentAttibuteName)); + } + assertTrue("Atribute names size not 2 or 3 ?", attributeNameCount >= 2 && attributeNameCount <= 3); + + assertNull(TEST_INITPARAM + " present before set ?", servletWrappingPortletContext.getInitParameter(TEST_INITPARAM)); + assertNull(TEST_INITPARAM2 + " present before set ?", servletWrappingPortletContext.getInitParameter(TEST_INITPARAM)); + servletWrappingPortletContext.log("Test logging call"); + servletWrappingPortletContext.log("Test logging call", new Exception("Fake Exception")); + assertEquals("Default portlet context name not as expected ?", "MockServletContext", servletWrappingPortletContext.getPortletContextName()); + assertFalse("Portlet runtime options not empty before set ?", servletWrappingPortletContext.getContainerRuntimeOptions().hasMoreElements()); + } + // -------- Continue writing tests here -------------- + + class TestMockMultipartFile implements MultipartFile { + private String name; + private String originalFilename; + private String contentType; + private int size; + private byte[] bytes; + + public TestMockMultipartFile(String name, String originalFilename, String contentType, byte[] bytes) { + this.name = name; + this.originalFilename = originalFilename; + this.contentType = contentType; + if (bytes != null) { + this.bytes = Arrays.copyOf(bytes, bytes.length); + } else { + bytes = null; + } + } + + @Override + public String getName() { + return name; + } + + @Override + public String getOriginalFilename() { + return this.originalFilename; + } + + @Override + public String getContentType() { + return contentType; + } + + @Override + public boolean isEmpty() { + return (bytes != null ? bytes.length > 0 : true); + } + + @Override + public long getSize() { + return (bytes != null ? bytes.length : 0); + } + + @Override + public byte[] getBytes() throws IOException { + return bytes; + } + + @Override + public InputStream getInputStream() throws IOException { + return new ByteArrayInputStream(bytes); + } + + @Override + public void transferTo(File file) throws IOException, IllegalStateException { + throw new UnsupportedOperationException("Not supported yet."); + } + } + + class TetMockResourceBundle extends ResourceBundle { + + @Override + protected Object handleGetObject(String key) { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Enumeration getKeys() { + throw new UnsupportedOperationException("Not supported yet."); + } + } + + class TestMockPrincipal implements Principal { + + @Override + public String getName() { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public boolean implies(Subject subject) { + return Principal.super.implies(subject); + } + } +} diff --git a/plugins/junit-portlet/src/test/resources/applicationContext.xml b/plugins/junit-portlet/src/test/resources/applicationContext.xml new file mode 100644 index 000000000..106fd6cf4 --- /dev/null +++ b/plugins/junit-portlet/src/test/resources/applicationContext.xml @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/plugins/pom.xml b/plugins/pom.xml index 66bb555d9..fdee6ed12 100644 --- a/plugins/pom.xml +++ b/plugins/pom.xml @@ -45,6 +45,7 @@ jfreechart json junit + junit-portlet osgi oval pell-multipart diff --git a/plugins/portlet/pom.xml b/plugins/portlet/pom.xml index c5198b8bb..5fc648046 100644 --- a/plugins/portlet/pom.xml +++ b/plugins/portlet/pom.xml @@ -40,6 +40,12 @@ true + + org.apache.struts + struts2-junit-portlet-plugin + true + + org.apache.struts struts2-velocity-plugin diff --git a/plugins/portlet/src/main/java/org/apache/struts2/StrutsPortletTestCase.java b/plugins/portlet/src/main/java/org/apache/struts2/StrutsPortletTestCase.java index 0c9801d3a..0f07ea927 100644 --- a/plugins/portlet/src/main/java/org/apache/struts2/StrutsPortletTestCase.java +++ b/plugins/portlet/src/main/java/org/apache/struts2/StrutsPortletTestCase.java @@ -23,11 +23,11 @@ import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.LogManager; import org.apache.struts2.portlet.PortletConstants; import org.apache.struts2.portlet.PortletPhase; -import org.springframework.mock.web.portlet.MockPortletContext; -import org.springframework.mock.web.portlet.MockPortletRequest; -import org.springframework.mock.web.portlet.MockPortletResponse; -import org.springframework.mock.web.portlet.MockPortletSession; -import org.springframework.mock.web.portlet.MockStateAwareResponse; +import org.apache.struts2.mock.web.portlet.MockPortletContext; +import org.apache.struts2.mock.web.portlet.MockPortletRequest; +import org.apache.struts2.mock.web.portlet.MockPortletResponse; +import org.apache.struts2.mock.web.portlet.MockPortletSession; +import org.apache.struts2.mock.web.portlet.MockStateAwareResponse; import javax.portlet.PortletMode; import java.util.HashMap; diff --git a/plugins/portlet/src/main/java/org/apache/struts2/portlet/PortletRequestMap.java b/plugins/portlet/src/main/java/org/apache/struts2/portlet/PortletRequestMap.java index df9dc108f..ec13f1295 100644 --- a/plugins/portlet/src/main/java/org/apache/struts2/portlet/PortletRequestMap.java +++ b/plugins/portlet/src/main/java/org/apache/struts2/portlet/PortletRequestMap.java @@ -20,6 +20,7 @@ package org.apache.struts2.portlet; import javax.portlet.PortletRequest; import java.util.AbstractMap; +import java.util.ArrayList; import java.util.Enumeration; import java.util.HashSet; import java.util.Set; @@ -49,9 +50,14 @@ public class PortletRequestMap extends AbstractMap { public void clear() { entries = null; Enumeration keys = request.getAttributeNames(); - + ArrayList keyStrings = new ArrayList<>(); + // Depending on the underlying collection, a ConcurrentModificationException may occur if we attempt + // to remove attributes while iterating over the keys Enumeration. Instead use an interim collection to + // gather all the keys and then remove them. while (keys.hasMoreElements()) { - String key = (String) keys.nextElement(); + keyStrings.add((String) keys.nextElement()); + } + for (String key : keyStrings){ request.removeAttribute(key); } } diff --git a/plugins/portlet/src/test/java/org/apache/struts2/components/PortletUrlRendererTest.java b/plugins/portlet/src/test/java/org/apache/struts2/components/PortletUrlRendererTest.java index 39c512565..02720435a 100644 --- a/plugins/portlet/src/test/java/org/apache/struts2/components/PortletUrlRendererTest.java +++ b/plugins/portlet/src/test/java/org/apache/struts2/components/PortletUrlRendererTest.java @@ -24,9 +24,9 @@ import com.opensymphony.xwork2.util.ValueStack; import org.apache.struts2.StrutsStatics; import org.apache.struts2.StrutsTestCase; import org.apache.struts2.portlet.PortletConstants; -import org.springframework.mock.web.portlet.MockMimeResponse; -import org.springframework.mock.web.portlet.MockPortletContext; -import org.springframework.mock.web.portlet.MockPortletRequest; +import org.apache.struts2.mock.web.portlet.MockMimeResponse; +import org.apache.struts2.mock.web.portlet.MockPortletContext; +import org.apache.struts2.mock.web.portlet.MockPortletRequest; import javax.portlet.PortletContext; import javax.portlet.PortletMode; diff --git a/plugins/portlet/src/test/java/org/apache/struts2/portlet/PortletRequestMapTest.java b/plugins/portlet/src/test/java/org/apache/struts2/portlet/PortletRequestMapTest.java index 19d4c6771..a282f2e8d 100644 --- a/plugins/portlet/src/test/java/org/apache/struts2/portlet/PortletRequestMapTest.java +++ b/plugins/portlet/src/test/java/org/apache/struts2/portlet/PortletRequestMapTest.java @@ -25,7 +25,7 @@ import java.util.Set; import javax.portlet.PortletRequest; import org.jmock.MockObjectTestCase; -import org.springframework.mock.web.portlet.MockPortletRequest; +import org.apache.struts2.mock.web.portlet.MockPortletRequest; /** diff --git a/plugins/portlet/src/test/java/org/apache/struts2/portlet/PortletSessionMapTest.java b/plugins/portlet/src/test/java/org/apache/struts2/portlet/PortletSessionMapTest.java index d666cc6db..a92c52167 100644 --- a/plugins/portlet/src/test/java/org/apache/struts2/portlet/PortletSessionMapTest.java +++ b/plugins/portlet/src/test/java/org/apache/struts2/portlet/PortletSessionMapTest.java @@ -26,7 +26,7 @@ import javax.portlet.PortletSession; import junit.framework.TestCase; -import org.springframework.mock.web.portlet.MockPortletRequest; +import org.apache.struts2.mock.web.portlet.MockPortletRequest; /** diff --git a/plugins/portlet/src/test/java/org/apache/struts2/portlet/dispatcher/Jsr168DispatcherTest.java b/plugins/portlet/src/test/java/org/apache/struts2/portlet/dispatcher/Jsr168DispatcherTest.java index be2ea3518..0c54cf235 100644 --- a/plugins/portlet/src/test/java/org/apache/struts2/portlet/dispatcher/Jsr168DispatcherTest.java +++ b/plugins/portlet/src/test/java/org/apache/struts2/portlet/dispatcher/Jsr168DispatcherTest.java @@ -30,8 +30,8 @@ import org.easymock.EasyMock; import org.jmock.Mock; import org.jmock.cglib.MockObjectTestCase; import org.jmock.core.Constraint; -import org.springframework.mock.web.portlet.MockPortletConfig; -import org.springframework.mock.web.portlet.MockPortletContext; +import org.apache.struts2.mock.web.portlet.MockPortletConfig; +import org.apache.struts2.mock.web.portlet.MockPortletContext; import javax.portlet.*; import java.util.*; diff --git a/plugins/portlet/src/test/java/org/apache/struts2/portlet/dispatcher/Jsr286DispatcherTest.java b/plugins/portlet/src/test/java/org/apache/struts2/portlet/dispatcher/Jsr286DispatcherTest.java index c5f4346fa..843f4ce85 100644 --- a/plugins/portlet/src/test/java/org/apache/struts2/portlet/dispatcher/Jsr286DispatcherTest.java +++ b/plugins/portlet/src/test/java/org/apache/struts2/portlet/dispatcher/Jsr286DispatcherTest.java @@ -30,8 +30,8 @@ import org.easymock.EasyMock; import org.jmock.Mock; import org.jmock.cglib.MockObjectTestCase; import org.jmock.core.Constraint; -import org.springframework.mock.web.portlet.MockPortletConfig; -import org.springframework.mock.web.portlet.MockPortletContext; +import org.apache.struts2.mock.web.portlet.MockPortletConfig; +import org.apache.struts2.mock.web.portlet.MockPortletContext; import javax.portlet.*; import java.util.*; diff --git a/pom.xml b/pom.xml index b5786b722..2c83f3119 100644 --- a/pom.xml +++ b/pom.xml @@ -569,6 +569,11 @@ struts2-junit-plugin ${project.version} + + org.apache.struts + struts2-junit-portlet-plugin + ${project.version} + org.apache.struts struts2-convention-plugin