View Javadoc

1   /*
2    * $Id: UrlHelperTest.java 449915 2006-09-26 05:48:00Z mrdon $
3    *
4    * Copyright 2006 The Apache Software Foundation.
5    *
6    * Licensed under the Apache License, Version 2.0 (the "License");
7    * you may not use this file except in compliance with the License.
8    * You may obtain a copy of the License at
9    *
10   *      http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  package org.apache.struts2.views.util;
19  
20  import java.util.HashMap;
21  import java.util.LinkedHashMap;
22  import java.util.Map;
23  import java.util.TreeMap;
24  
25  import javax.servlet.http.HttpServletRequest;
26  import javax.servlet.http.HttpServletResponse;
27  
28  import org.apache.struts2.StrutsConstants;
29  import org.apache.struts2.StrutsTestCase;
30  import org.apache.struts2.config.Settings;
31  
32  import com.mockobjects.dynamic.Mock;
33  
34  
35  /***
36   * Test case for UrlHelper.
37   * 
38   */
39  public class UrlHelperTest extends StrutsTestCase {
40  	
41  	
42  	
43  	public void testForceAddSchemeHostAndPort() throws Exception {
44  		String expectedUrl = "http://localhost/contextPath/path1/path2/myAction.action";
45  		
46  		Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
47  		mockHttpServletRequest.expectAndReturn("getScheme", "http");
48  		mockHttpServletRequest.expectAndReturn("getServerName", "localhost");
49          mockHttpServletRequest.expectAndReturn("getContextPath", "/contextPath");
50  
51          Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
52          mockHttpServletResponse.expectAndReturn("encodeURL", expectedUrl, expectedUrl);
53  		
54  		String result = UrlHelper.buildUrl("/path1/path2/myAction.action", (HttpServletRequest) mockHttpServletRequest.proxy(), (HttpServletResponse)mockHttpServletResponse.proxy(), null, "http", true, true, true);
55  		assertEquals(expectedUrl, result);
56  		mockHttpServletRequest.verify();
57  	}
58  	
59  	public void testDoNotForceAddSchemeHostAndPort() throws Exception {
60  		String expectedUrl = "/contextPath/path1/path2/myAction.action";
61  		
62  		Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
63  		mockHttpServletRequest.expectAndReturn("getScheme", "http");
64  		mockHttpServletRequest.expectAndReturn("getServerName", "localhost");
65          mockHttpServletRequest.expectAndReturn("getContextPath", "/contextPath");
66  
67          Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
68          mockHttpServletResponse.expectAndReturn("encodeURL", expectedUrl, expectedUrl);
69  		
70  		String result = UrlHelper.buildUrl("/path1/path2/myAction.action", (HttpServletRequest)mockHttpServletRequest.proxy(), (HttpServletResponse)mockHttpServletResponse.proxy(), null, "http", true, true, false);
71  		
72  		assertEquals(expectedUrl, result);
73  	}
74  	
75  	
76  	public void testBuildParametersStringWithUrlHavingSomeExistingParameters() throws Exception {
77  		String expectedUrl = "http://localhost:8080/myContext/myPage.jsp?initParam=initValue&param1=value1&param2=value2";
78  		
79  		Map parameters = new LinkedHashMap();
80  		parameters.put("param1", "value1");
81  		parameters.put("param2", "value2");
82  		
83  		StringBuffer url = new StringBuffer("http://localhost:8080/myContext/myPage.jsp?initParam=initValue");
84  		
85  		UrlHelper.buildParametersString(parameters, url);
86  		
87  		assertEquals(
88  		   expectedUrl, url.toString());
89  	}
90  	
91  	
92  
93      public void testBuildWithRootContext() {
94          String expectedUrl = "/MyAction.action";
95  
96          Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
97          mockHttpServletRequest.expectAndReturn("getContextPath", "/");
98          mockHttpServletRequest.expectAndReturn("getScheme", "http");
99  
100         Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
101         mockHttpServletResponse.expectAndReturn("encodeURL", expectedUrl, expectedUrl);
102 
103         String actualUrl = UrlHelper.buildUrl(expectedUrl, (HttpServletRequest) mockHttpServletRequest.proxy(),
104                 (HttpServletResponse) mockHttpServletResponse.proxy(), new HashMap());
105         assertEquals(expectedUrl, actualUrl);
106     }
107 
108     /***
109      * just one &, not &
110      */
111     public void testBuildUrlCorrectlyAddsAmp() {
112         String expectedString = "my.actionName?foo=bar&hello=world";
113         Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
114         mockHttpServletRequest.expectAndReturn("getScheme", "http");
115         Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
116         mockHttpServletResponse.expectAndReturn("encodeURL", expectedString, expectedString);
117 
118         String actionName = "my.actionName";
119         TreeMap params = new TreeMap();
120         params.put("hello", "world");
121         params.put("foo", "bar");
122 
123         String urlString = UrlHelper.buildUrl(actionName, (HttpServletRequest) mockHttpServletRequest.proxy(), (HttpServletResponse) mockHttpServletResponse.proxy(), params);
124         assertEquals(expectedString, urlString);
125     }
126 
127     public void testBuildUrlWithStringArray() {
128         String expectedString = "my.actionName?foo=bar&hello=earth&hello=mars";
129         Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
130         mockHttpServletRequest.expectAndReturn("getScheme", "http");
131         Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
132         mockHttpServletResponse.expectAndReturn("encodeURL", expectedString, expectedString);
133 
134         String actionName = "my.actionName";
135         TreeMap params = new TreeMap();
136         params.put("hello", new String[]{"earth", "mars"});
137         params.put("foo", "bar");
138 
139         String urlString = UrlHelper.buildUrl(actionName, (HttpServletRequest) mockHttpServletRequest.proxy(), (HttpServletResponse) mockHttpServletResponse.proxy(), params);
140         assertEquals(expectedString, urlString);
141     }
142 
143     /***
144      * The UrlHelper should build a URL that starts with "https" followed by the server name when the scheme of the
145      * current request is "http" and the port for the "https" scheme is 443.
146      */
147     public void testSwitchToHttpsScheme() {
148         String expectedString = "https://www.mydomain.com/mywebapp/MyAction.action?foo=bar&hello=earth&hello=mars";
149 
150         Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
151         mockHttpServletRequest.expectAndReturn("getServerName", "www.mydomain.com");
152         mockHttpServletRequest.expectAndReturn("getScheme", "http");
153         mockHttpServletRequest.expectAndReturn("getServerPort", 80);
154         mockHttpServletRequest.expectAndReturn("getContextPath", "/mywebapp");
155 
156         Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
157         mockHttpServletResponse.expectAndReturn("encodeURL", expectedString, expectedString);
158 
159         String actionName = "/MyAction.action";
160         TreeMap params = new TreeMap();
161         params.put("hello", new String[]{"earth", "mars"});
162         params.put("foo", "bar");
163 
164         String urlString = UrlHelper.buildUrl(actionName, (HttpServletRequest) mockHttpServletRequest.proxy(), (HttpServletResponse) mockHttpServletResponse.proxy(), params, "https", true, true);
165         assertEquals(expectedString, urlString);
166     }
167 
168     /***
169      * The UrlHelper should build a URL that starts with "http" followed by the server name when the scheme of the
170      * current request is "https" and the port for the "http" scheme is 80.
171      */
172     public void testSwitchToHttpScheme() {
173         String expectedString = "http://www.mydomain.com/mywebapp/MyAction.action?foo=bar&hello=earth&hello=mars";
174 
175         Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
176         mockHttpServletRequest.expectAndReturn("getServerName", "www.mydomain.com");
177         mockHttpServletRequest.expectAndReturn("getScheme", "https");
178         mockHttpServletRequest.expectAndReturn("getServerPort", 443);
179         mockHttpServletRequest.expectAndReturn("getContextPath", "/mywebapp");
180 
181         Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
182         mockHttpServletResponse.expectAndReturn("encodeURL", expectedString, expectedString);
183 
184         String actionName = "/MyAction.action";
185         TreeMap params = new TreeMap();
186         params.put("hello", new String[]{"earth", "mars"});
187         params.put("foo", "bar");
188 
189         String urlString = UrlHelper.buildUrl(actionName, (HttpServletRequest) mockHttpServletRequest.proxy(), (HttpServletResponse) mockHttpServletResponse.proxy(), params, "http", true, true);
190         assertEquals(expectedString, urlString);
191     }
192 
193     /***
194      * This test is similar to {@link #testSwitchToHttpsScheme()} with the HTTP port equal to 7001 and the HTTPS port
195      * equal to 7002.
196      */
197     public void testSwitchToHttpsNonDefaultPort() {
198 
199         String expectedString = "https://www.mydomain.com:7002/mywebapp/MyAction.action?foo=bar&hello=earth&hello=mars";
200 
201         Settings.set(StrutsConstants.STRUTS_URL_HTTP_PORT, "7001");
202         Settings.set(StrutsConstants.STRUTS_URL_HTTPS_PORT, "7002");
203 
204         Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
205         mockHttpServletRequest.expectAndReturn("getServerName", "www.mydomain.com");
206         mockHttpServletRequest.expectAndReturn("getScheme", "http");
207         mockHttpServletRequest.expectAndReturn("getServerPort", 7001);
208         mockHttpServletRequest.expectAndReturn("getContextPath", "/mywebapp");
209 
210         Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
211         mockHttpServletResponse.expectAndReturn("encodeURL", expectedString, expectedString);
212 
213         String actionName = "/MyAction.action";
214         TreeMap params = new TreeMap();
215         params.put("hello", new String[]{"earth", "mars"});
216         params.put("foo", "bar");
217 
218         String urlString = UrlHelper.buildUrl(actionName, (HttpServletRequest) mockHttpServletRequest.proxy(), (HttpServletResponse) mockHttpServletResponse.proxy(), params, "https", true, true);
219         assertEquals(expectedString, urlString);
220     }
221 
222     /***
223      * This test is similar to {@link #testSwitchToHttpScheme()} with the HTTP port equal to 7001 and the HTTPS port
224      * equal to port 7002.
225      */
226     public void testSwitchToHttpNonDefaultPort() {
227 
228         String expectedString = "http://www.mydomain.com:7001/mywebapp/MyAction.action?foo=bar&hello=earth&hello=mars";
229 
230         Settings.set(StrutsConstants.STRUTS_URL_HTTP_PORT, "7001");
231         Settings.set(StrutsConstants.STRUTS_URL_HTTPS_PORT, "7002");
232 
233         Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
234         mockHttpServletRequest.expectAndReturn("getServerName", "www.mydomain.com");
235         mockHttpServletRequest.expectAndReturn("getScheme", "https");
236         mockHttpServletRequest.expectAndReturn("getServerPort", 7002);
237         mockHttpServletRequest.expectAndReturn("getContextPath", "/mywebapp");
238 
239         Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
240         mockHttpServletResponse.expectAndReturn("encodeURL", expectedString, expectedString);
241 
242         String actionName = "/MyAction.action";
243         TreeMap params = new TreeMap();
244         params.put("hello", new String[]{"earth", "mars"});
245         params.put("foo", "bar");
246 
247         String urlString = UrlHelper.buildUrl(actionName, (HttpServletRequest) mockHttpServletRequest.proxy(), (HttpServletResponse) mockHttpServletResponse.proxy(), params, "http", true, true);
248         assertEquals(expectedString, urlString);
249     }
250 
251     /***
252      * The UrlHelper should build a URL that starts with "https" followed by the server name when the scheme of the
253      * current request is "http" and the port for the "https" scheme is 443. When the request has been forwarded
254      * in a Servlet 2.4 container, the UrlHelper should use the javax.servlet.forward.request_uri request attribute
255      * instead of a call to HttpServletRequest#getRequestURI().
256      */
257     public void testForwardedRequest() {
258         String expectedString = "https://www.example.com/mywebapp/product/widget/promo.html";
259 
260         Mock mockHttpServletRequest = new Mock(HttpServletRequest.class);
261         mockHttpServletRequest.expectAndReturn("getServerName", "www.example.com");
262         mockHttpServletRequest.expectAndReturn("getScheme", "http");
263         mockHttpServletRequest.expectAndReturn("getServerPort", 80);
264         mockHttpServletRequest.expectAndReturn("getContextPath", "/mywebapp");
265         mockHttpServletRequest.expectAndReturn("getAttribute", "javax.servlet.forward.request_uri", "/mywebapp/product/widget/");
266         mockHttpServletRequest.expectAndReturn("getRequestURI", "/mywebapp/");
267 
268         Mock mockHttpServletResponse = new Mock(HttpServletResponse.class);
269         mockHttpServletResponse.expectAndReturn("encodeURL", expectedString, expectedString);
270 
271         String actionName = "promo.html";
272         Map params = new TreeMap();
273 
274         String urlString = UrlHelper.buildUrl(actionName, (HttpServletRequest) mockHttpServletRequest.proxy(), (HttpServletResponse) mockHttpServletResponse.proxy(), params, "https", true, true);
275         assertEquals(expectedString, urlString);
276     }
277     
278     
279     public void testParseQuery() throws Exception {
280     	Map result = UrlHelper.parseQueryString("aaa=aaaval&bbb=bbbval&ccc=");
281     	
282     	assertEquals(result.get("aaa"), "aaaval");
283     	assertEquals(result.get("bbb"), "bbbval");
284     	assertEquals(result.get("ccc"), "");
285     }
286     
287     public void testParseEmptyQuery() throws Exception {
288     	Map result = UrlHelper.parseQueryString("");
289     	
290     	assertNotNull(result);
291     	assertEquals(result.size(), 0);
292     }
293     
294     public void testParseNullQuery() throws Exception {
295     	Map result = UrlHelper.parseQueryString(null);
296     	
297     	assertNotNull(result);
298     	assertEquals(result.size(), 0);
299     }
300     
301     
302     public void testTranslateAndEncode() throws Exception {
303     	String defaultI18nEncoding = Settings.get(StrutsConstants.STRUTS_I18N_ENCODING);
304     	try {
305     		Settings.set(StrutsConstants.STRUTS_I18N_ENCODING, "UTF-8");
306     		String result = UrlHelper.translateAndEncode("\u65b0\u805e");
307     		String expectedResult = "%E6%96%B0%E8%81%9E";
308     	
309     		assertEquals(result, expectedResult);
310     	}
311     	finally {
312     		Settings.set(StrutsConstants.STRUTS_I18N_ENCODING, defaultI18nEncoding);
313     	}
314     }
315     
316     public void testTranslateAndDecode() throws Exception {
317     	String defaultI18nEncoding = Settings.get(StrutsConstants.STRUTS_I18N_ENCODING);
318     	try {
319     		Settings.set(StrutsConstants.STRUTS_I18N_ENCODING, "UTF-8");
320     		String result = UrlHelper.translateAndDecode("%E6%96%B0%E8%81%9E");
321     		String expectedResult = "\u65b0\u805e";
322     	
323     		assertEquals(result, expectedResult);
324     	}
325     	finally {
326     		Settings.set(StrutsConstants.STRUTS_I18N_ENCODING, defaultI18nEncoding);
327     	}
328     }
329 }