View Javadoc

1   /*
2    * $Id: PortletUrlTagTest.java 476696 2006-11-19 03:56:18Z tmjee $
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  package org.apache.struts2.views.jsp;
22  
23  import java.lang.reflect.Field;
24  import java.util.Arrays;
25  import java.util.HashMap;
26  import java.util.Iterator;
27  import java.util.Map;
28  
29  import javax.portlet.PortletMode;
30  import javax.portlet.PortletRequest;
31  import javax.portlet.PortletResponse;
32  import javax.portlet.PortletURL;
33  import javax.portlet.RenderRequest;
34  import javax.portlet.RenderResponse;
35  import javax.portlet.WindowState;
36  import javax.servlet.http.HttpServletRequest;
37  import javax.servlet.http.HttpServletResponse;
38  import javax.servlet.jsp.PageContext;
39  
40  import junit.textui.TestRunner;
41  
42  import org.apache.struts2.dispatcher.Dispatcher;
43  import org.apache.struts2.portlet.PortletActionConstants;
44  import org.apache.struts2.portlet.util.PortletUrlHelper;
45  import org.jmock.Mock;
46  import org.jmock.cglib.MockObjectTestCase;
47  import org.jmock.core.Constraint;
48  
49  import com.mockobjects.servlet.MockJspWriter;
50  import com.opensymphony.xwork2.ActionContext;
51  import com.opensymphony.xwork2.util.ValueStack;
52  import com.opensymphony.xwork2.util.ValueStackFactory;
53  
54  /***
55   */
56  public class PortletUrlTagTest extends MockObjectTestCase {
57  
58      URLTag tag = new URLTag();
59  
60      Mock mockHttpReq = null;
61  
62      Mock mockHttpRes = null;
63  
64      Mock mockPortletReq = null;
65  
66      Mock mockPortletRes = null;
67  
68      Mock mockPageCtx = null;
69  
70      Mock mockPortletUrl = null;
71  
72      MockJspWriter mockJspWriter = null;
73  
74      ValueStack stack = null;
75  
76      public static void main(String[] args) {
77          TestRunner.run(PortletUrlTagTest.class);
78      }
79  
80      public void setUp() throws Exception {
81          super.setUp();
82  
83          Dispatcher du = new Dispatcher(null, new HashMap());
84          du.init();
85          Dispatcher.setInstance(du);
86  
87          mockPortletApiAvailable();
88  
89          stack = ValueStackFactory.getFactory().createValueStack();
90  
91  
92          mockHttpReq = mock(HttpServletRequest.class);
93          mockHttpRes = mock(HttpServletResponse.class);
94          mockPortletReq = mock(RenderRequest.class);
95          mockPortletRes = mock(RenderResponse.class);
96          mockPageCtx = mock(PageContext.class);
97          mockPortletUrl = mock(PortletURL.class);
98          mockJspWriter = new MockJspWriter();
99  
100         mockPageCtx.stubs().method("getRequest").will(
101                 returnValue((HttpServletRequest) mockHttpReq.proxy()));
102         mockPageCtx.stubs().method("getResponse").will(
103                 returnValue((HttpServletResponse) mockHttpRes.proxy()));
104         mockPageCtx.stubs().method("getOut").will(returnValue(mockJspWriter));
105 
106         mockHttpReq.stubs().method("getScheme").will(returnValue("http"));
107         mockHttpReq.stubs().method("getAttribute").with(
108                 eq("struts.valueStack")).will(returnValue(stack));
109         mockHttpReq.stubs().method("getAttribute").with(
110                 eq("javax.portlet.response")).will(
111                 returnValue((PortletResponse) mockPortletRes.proxy()));
112         mockHttpReq.stubs().method("getAttribute").with(
113                 eq("javax.portlet.request")).will(
114                 returnValue((PortletRequest) mockPortletReq.proxy()));
115 
116         mockPortletReq.stubs().method("getPortletMode").will(returnValue(PortletMode.VIEW));
117         mockPortletReq.stubs().method("getWindowState").will(returnValue(WindowState.NORMAL));
118         mockPortletReq.stubs().method("getContextPath").will(returnValue("/contextPath"));
119 
120         tag.setPageContext((PageContext) mockPageCtx.proxy());
121 
122         Map modeMap = new HashMap();
123         modeMap.put(PortletMode.VIEW, "/view");
124         modeMap.put(PortletMode.HELP, "/help");
125         modeMap.put(PortletMode.EDIT, "/edit");
126         Map sessionMap = new HashMap();
127         Map contextMap = new HashMap();
128         contextMap.put(ActionContext.SESSION, sessionMap);
129         contextMap.put(PortletActionConstants.REQUEST, mockPortletReq.proxy());
130         contextMap.put(PortletActionConstants.RESPONSE, mockPortletRes.proxy());
131         contextMap.put(PortletActionConstants.PHASE, PortletActionConstants.RENDER_PHASE);
132         contextMap.put(PortletActionConstants.MODE_NAMESPACE_MAP, modeMap);
133         ActionContext ctx = new ActionContext(contextMap);
134         ctx.setValueStack(stack);
135         ActionContext.setContext(ctx);
136     }
137 
138     /***
139      *
140      */
141     private void mockPortletApiAvailable() {
142         try {
143             Field field = Dispatcher.class.getDeclaredField("portletSupportActive");
144             field.setAccessible(true);
145             field.set(null, Boolean.TRUE);
146         }
147         catch(Exception e) {
148 
149         }
150 
151     }
152 
153     public void testEnsureParamsAreStringArrays() {
154         Map params = new HashMap();
155         params.put("param1", "Test1");
156         params.put("param2", new String[] { "Test2" });
157 
158         Map result = PortletUrlHelper.ensureParamsAreStringArrays(params);
159         assertEquals(2, result.size());
160         assertTrue(result.get("param1") instanceof String[]);
161     }
162 
163     public void testSetWindowState() throws Exception {
164 
165         PortletMode mode = PortletMode.VIEW;
166 
167         mockHttpReq.stubs().method("getQueryString").will(returnValue(""));
168 
169         mockPortletRes.expects(once()).method("createRenderURL").will(
170                 returnValue((PortletURL) mockPortletUrl.proxy()));
171 
172         Map paramMap = new HashMap();
173         paramMap.put(PortletActionConstants.ACTION_PARAM, new String[]{"/view/testAction"});
174         paramMap.put(PortletActionConstants.MODE_PARAM, new String[]{mode.toString()});
175 
176         mockPortletUrl.expects(once()).method("setParameters").with(new ParamMapConstraint(paramMap));
177         mockPortletUrl.expects(once()).method("setWindowState").with(eq(WindowState.MAXIMIZED));
178         mockPortletUrl.expects(once()).method("setPortletMode").with(eq(PortletMode.VIEW));
179 
180         tag.setAction("testAction");
181         tag.setWindowState("maximized");
182         tag.doStartTag();
183         tag.doEndTag();
184 
185     }
186 
187     public void testSetPortletMode() throws Exception  {
188 
189         PortletMode mode = PortletMode.HELP;
190 
191         mockHttpReq.stubs().method("getQueryString").will(returnValue(""));
192 
193         mockPortletRes.expects(once()).method("createRenderURL").will(
194                 returnValue((PortletURL) mockPortletUrl.proxy()));
195 
196         Map paramMap = new HashMap();
197         paramMap.put(PortletActionConstants.ACTION_PARAM, new String[]{"/help/testAction"});
198         paramMap.put(PortletActionConstants.MODE_PARAM, new String[]{mode.toString()});
199 
200         mockPortletUrl.expects(once()).method("setParameters").with(new ParamMapConstraint(paramMap));
201         mockPortletUrl.expects(once()).method("setPortletMode").with(eq(PortletMode.HELP));
202         mockPortletUrl.expects(once()).method("setWindowState").with(eq(WindowState.NORMAL));
203 
204         tag.setAction("testAction");
205         tag.setPortletMode("help");
206         tag.doStartTag();
207         tag.doEndTag();
208     }
209 
210     public void testUrlWithQueryParams() throws Exception {
211 
212         PortletMode mode = PortletMode.VIEW;
213 
214         mockHttpReq.stubs().method("getQueryString").will(returnValue(""));
215 
216         mockPortletRes.expects(once()).method("createRenderURL").will(
217                 returnValue((PortletURL) mockPortletUrl.proxy()));
218 
219         Map paramMap = new HashMap();
220         paramMap.put(PortletActionConstants.ACTION_PARAM, new String[]{"/view/testAction"});
221         paramMap.put("testParam1", new String[]{"testValue1"});
222         paramMap.put(PortletActionConstants.MODE_PARAM, new String[]{mode.toString()});
223 
224         mockPortletUrl.expects(once()).method("setParameters").with(new ParamMapConstraint(paramMap));
225         mockPortletUrl.expects(once()).method("setPortletMode").with(eq(PortletMode.VIEW));
226         mockPortletUrl.expects(once()).method("setWindowState").with(eq(WindowState.NORMAL));
227 
228         tag.setAction("testAction?testParam1=testValue1");
229         tag.doStartTag();
230         tag.doEndTag();
231     }
232 
233     public void testActionUrl() throws Exception {
234 
235         PortletMode mode = PortletMode.VIEW;
236 
237         mockHttpReq.stubs().method("getQueryString").will(returnValue(""));
238 
239         mockPortletRes.expects(once()).method("createActionURL").will(
240                 returnValue((PortletURL) mockPortletUrl.proxy()));
241 
242         Map paramMap = new HashMap();
243         paramMap.put(PortletActionConstants.ACTION_PARAM, new String[]{"/view/testAction"});
244         paramMap.put(PortletActionConstants.MODE_PARAM, new String[]{mode.toString()});
245 
246         mockPortletUrl.expects(once()).method("setParameters").with(new ParamMapConstraint(paramMap));
247         mockPortletUrl.expects(once()).method("setPortletMode").with(eq(PortletMode.VIEW));
248         mockPortletUrl.expects(once()).method("setWindowState").with(eq(WindowState.NORMAL));
249 
250         tag.setAction("testAction");
251         tag.setPortletUrlType("action");
252         tag.doStartTag();
253         tag.doEndTag();
254     }
255 
256     public void testResourceUrl() throws Exception {
257         mockHttpReq.stubs().method("getQueryString").will(returnValue(""));
258         mockPortletRes.expects(once()).method("encodeURL").will(returnValue("/contextPath/image.gif"));
259         mockJspWriter.setExpectedData("/contextPath/image.gif");
260         tag.setValue("image.gif");
261         tag.doStartTag();
262         tag.doEndTag();
263         mockJspWriter.verify();
264     }
265 
266     public void testResourceUrlWithNestedParam() throws Exception {
267         mockHttpReq.stubs().method("getQueryString").will(returnValue(""));
268         mockPortletRes.expects(once()).method("encodeURL").with(eq("/contextPath/image.gif?testParam1=testValue1")).will(returnValue("/contextPath/image.gif?testParam1=testValue1"));
269         mockJspWriter.setExpectedData("/contextPath/image.gif?testParam1=testValue1");
270 
271         ParamTag paramTag = new ParamTag();
272         paramTag.setPageContext((PageContext)mockPageCtx.proxy());
273         paramTag.setParent(tag);
274         paramTag.setName("testParam1");
275         paramTag.setValue("'testValue1'");
276         tag.setValue("image.gif");
277         tag.doStartTag();
278         paramTag.doStartTag();
279         paramTag.doEndTag();
280         tag.doEndTag();
281         mockJspWriter.verify();
282     }
283 
284     public void testResourceUrlWithTwoNestedParam() throws Exception {
285         mockHttpReq.stubs().method("getQueryString").will(returnValue(""));
286         mockPortletRes.expects(once()).method("encodeURL").with(eq("/contextPath/image.gif?testParam1=testValue1&testParam2=testValue2")).will(returnValue("/contextPath/image.gif?testParam1=testValue1&testParam2=testValue2"));
287         mockJspWriter.setExpectedData("/contextPath/image.gif?testParam1=testValue1&testParam2=testValue2");
288 
289         ParamTag paramTag = new ParamTag();
290         paramTag.setPageContext((PageContext)mockPageCtx.proxy());
291         paramTag.setParent(tag);
292         paramTag.setName("testParam1");
293         paramTag.setValue("'testValue1'");
294         ParamTag paramTag2 = new ParamTag();
295         paramTag2.setPageContext((PageContext)mockPageCtx.proxy());
296         paramTag2.setParent(tag);
297         paramTag2.setName("testParam2");
298         paramTag2.setValue("'testValue2'");
299         tag.setValue("image.gif");
300         tag.doStartTag();
301         paramTag.doStartTag();
302         paramTag.doEndTag();
303         paramTag2.doStartTag();
304         paramTag2.doEndTag();
305         tag.doEndTag();
306         mockJspWriter.verify();
307     }
308 
309     private static class ParamMapConstraint implements Constraint {
310 
311         private Map myExpectedMap = null;
312         private Map myActualMap = null;
313 
314         public ParamMapConstraint(Map expectedMap) {
315             if(expectedMap == null) {
316                 throw new IllegalArgumentException("Use an isNull constraint instead!");
317             }
318             myExpectedMap = expectedMap;
319         }
320 
321         /* (non-Javadoc)
322          * @see org.jmock.core.Constraint#eval(java.lang.Object)
323          */
324         public boolean eval(Object val) {
325             myActualMap = (Map)val;
326             boolean result = false;
327             if(val != null) {
328                 if(myExpectedMap.size() == myActualMap.size()) {
329                     Iterator keys = myExpectedMap.keySet().iterator();
330                     boolean allSame = true;
331                     while(keys.hasNext()) {
332                         Object key = keys.next();
333                         if(!myActualMap.containsKey(key)) {
334                             allSame = false;
335                             break;
336                         }
337                         else {
338                             String[] expected = (String[])myExpectedMap.get(key);
339                             String[] actual = (String[])myActualMap.get(key);
340                             if(!Arrays.equals(expected, actual)) {
341                                 allSame = false;
342                                 break;
343                             }
344                         }
345                     }
346                     result = allSame;
347                 }
348             }
349             return result;
350         }
351 
352         /* (non-Javadoc)
353          * @see org.jmock.core.SelfDescribing#describeTo(java.lang.StringBuffer)
354          */
355         public StringBuffer describeTo(StringBuffer sb) {
356             return sb.append(myExpectedMap);
357         }
358 
359 
360 
361     }
362 
363 }