001    // Copyright 2005 The Apache Software Foundation
002    //
003    // Licensed under the Apache License, Version 2.0 (the "License");
004    // you may not use this file except in compliance with the License.
005    // You may obtain a copy of the License at
006    //
007    //     http://www.apache.org/licenses/LICENSE-2.0
008    //
009    // Unless required by applicable law or agreed to in writing, software
010    // distributed under the License is distributed on an "AS IS" BASIS,
011    // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012    // See the License for the specific language governing permissions and
013    // limitations under the License.
014    
015    package org.apache.tapestry.web;
016    
017    import static org.easymock.EasyMock.expect;
018    import static org.easymock.EasyMock.expectLastCall;
019    
020    import java.io.IOException;
021    import java.util.List;
022    
023    import org.apache.hivemind.ApplicationRuntimeException;
024    import org.testng.annotations.Test;
025    
026    import javax.servlet.RequestDispatcher;
027    import javax.servlet.ServletException;
028    import javax.servlet.http.HttpServletRequest;
029    import javax.servlet.http.HttpServletResponse;
030    import javax.servlet.http.HttpSession;
031    
032    /**
033     * Tests for {@link org.apache.tapestry.web.ServletWebRequest}.
034     * 
035     * @author Howard M. Lewis Ship
036     * @since 4.0
037     */
038    @Test
039    public class TestServletWebRequest extends BaseWebTestCase
040    {
041        private HttpServletRequest newHttpRequest()
042        {
043            return newMock(HttpServletRequest.class);
044        }
045    
046        private HttpServletResponse newResponse()
047        {
048            return newMock(HttpServletResponse.class);
049        }
050    
051        private RequestDispatcher newDispatcher()
052        {
053            return newMock(RequestDispatcher.class);
054        }
055    
056        public void testGetParameterNames()
057        {
058            HttpServletRequest request = newHttpRequest();
059            HttpServletResponse response = newResponse();
060    
061            expect(request.getParameterNames()).andReturn(newEnumeration());
062            
063            replay();
064    
065            WebRequest wr = new ServletWebRequest(request, response);
066    
067            List l = wr.getParameterNames();
068    
069            checkList(l);
070    
071            verify();
072        }
073    
074        public void testGetParameterValue()
075        {
076            HttpServletRequest request = newHttpRequest();
077            HttpServletResponse response = newResponse();
078    
079            String value = "William Orbit";
080    
081            expect(request.getParameter("artist")).andReturn(value);
082    
083            replay();
084    
085            WebRequest wr = new ServletWebRequest(request, response);
086    
087            assertSame(value, wr.getParameterValue("artist"));
088    
089            verify();
090        }
091    
092        public void testGetParameterValues()
093        {
094            HttpServletRequest request = newHttpRequest();
095            HttpServletResponse response = newResponse();
096    
097            String[] values =
098            { "William Orbit", "Steely Dan" };
099    
100            expect(request.getParameterValues("artist")).andReturn(values);
101    
102            replay();
103    
104            WebRequest wr = new ServletWebRequest(request, response);
105    
106            assertSame(values, wr.getParameterValues("artist"));
107    
108            verify();
109        }
110    
111        public void testGetContextPath()
112        {
113            HttpServletRequest request = newHttpRequest();
114            HttpServletResponse response = newResponse();
115    
116            expect(request.getContextPath()).andReturn("/foo");
117    
118            replay();
119    
120            WebRequest wr = new ServletWebRequest(request, response);
121    
122            assertEquals("/foo", wr.getContextPath());
123    
124            verify();
125        }
126    
127        public void testGetAttributeNames()
128        {
129            HttpServletRequest request = newHttpRequest();
130            HttpServletResponse response = newResponse();
131    
132            expect(request.getAttributeNames()).andReturn(newEnumeration());
133            
134            replay();
135    
136            WebRequest wr = new ServletWebRequest(request, response);
137    
138            List l = wr.getAttributeNames();
139    
140            checkList(l);
141    
142            verify();
143        }
144    
145        public void testGetAttribute()
146        {
147            HttpServletRequest request = newHttpRequest();
148            HttpServletResponse response = newResponse();
149    
150            Object attribute = new Object();
151    
152            expect(request.getAttribute("attr")).andReturn(attribute);
153    
154            replay();
155    
156            WebRequest wr = new ServletWebRequest(request, response);
157    
158            assertSame(attribute, wr.getAttribute("attr"));
159    
160            verify();
161        }
162    
163        public void testSetAttribute()
164        {
165            HttpServletRequest request = newHttpRequest();
166            HttpServletResponse response = newResponse();
167    
168            Object attribute = new Object();
169    
170            request.setAttribute("name", attribute);
171    
172            replay();
173    
174            WebRequest wr = new ServletWebRequest(request, response);
175    
176            wr.setAttribute("name", attribute);
177    
178            verify();
179        }
180    
181        public void testSetAttributeToNull()
182        {
183            HttpServletRequest request = newHttpRequest();
184            HttpServletResponse response = newResponse();
185    
186            request.removeAttribute("tonull");
187    
188            replay();
189    
190            WebRequest wr = new ServletWebRequest(request, response);
191    
192            wr.setAttribute("tonull", null);
193    
194            verify();
195        }
196    
197        public void testGetSession()
198        {
199            HttpServletRequest request = newHttpRequest();
200            HttpServletResponse response = newResponse();
201            HttpSession session = newSession();
202    
203            trainGetSession(request, false, null);
204    
205            // Get it, doesn't exist, wreate false
206    
207            replay();
208    
209            WebRequest wr = new ServletWebRequest(request, response);
210    
211            assertNull(wr.getSession(false));
212    
213            verify();
214    
215            trainGetSession(request, true, session);
216    
217            // #2: Get it, wreate is true, it is wreated.
218    
219            replay();
220    
221            WebSession cs = wr.getSession(true);
222    
223            verify();
224    
225            // #3: Cached in local variable, make sure same
226            // think returned.
227    
228            replay();
229    
230            assertSame(cs, wr.getSession(false));
231    
232            verify();
233        }
234    
235        private void trainGetSession(HttpServletRequest request, boolean create, HttpSession session)
236        {
237            expect(request.getSession(create)).andReturn(session);
238        }
239    
240        private HttpSession newSession()
241        {
242            return newMock(HttpSession.class);
243        }
244    
245        public void testGetScheme()
246        {
247            HttpServletRequest request = newHttpRequest();
248            HttpServletResponse response = newResponse();
249    
250            expect(request.getScheme()).andReturn("http");
251    
252            replay();
253    
254            WebRequest wr = new ServletWebRequest(request, response);
255    
256            assertEquals("http", wr.getScheme());
257    
258            verify();
259        }
260    
261        public void testGetServerName()
262        {
263            HttpServletRequest request = newHttpRequest();
264            HttpServletResponse response = newResponse();
265    
266            expect(request.getServerName()).andReturn("www.myhost.com");
267    
268            replay();
269    
270            WebRequest wr = new ServletWebRequest(request, response);
271    
272            assertEquals("www.myhost.com", wr.getServerName());
273    
274            verify();
275        }
276    
277        public void testGetServerPort()
278        {
279            HttpServletRequest request = newHttpRequest();
280            HttpServletResponse response = newResponse();
281    
282            expect(request.getServerPort()).andReturn(80);
283            
284            replay();
285    
286            WebRequest wr = new ServletWebRequest(request, response);
287    
288            assertEquals(80, wr.getServerPort());
289    
290            verify();
291        }
292    
293        public void testGetRequestURI()
294        {
295            HttpServletRequest request = newHttpRequest();
296            HttpServletResponse response = newResponse();
297    
298            expect(request.getRequestURI()).andReturn("/foo/bar");
299    
300            replay();
301    
302            WebRequest wr = new ServletWebRequest(request, response);
303    
304            assertEquals("/foo/bar", wr.getRequestURI());
305    
306            verify();
307        }
308    
309        public void testForwardInternal() throws Exception
310        {
311            HttpServletRequest request = newHttpRequest();
312            HttpServletResponse response = newResponse();
313            RequestDispatcher dispatcher = newDispatcher();
314    
315            trainGetRequestDispatcher(request, "/local.html", dispatcher);
316    
317            dispatcher.forward(request, response);
318    
319            replay();
320    
321            WebRequest wr = new ServletWebRequest(request, response);
322    
323            wr.forward("local.html");
324    
325            verify();
326        }
327    
328        public void testForwardNull() throws Exception
329        {
330            HttpServletRequest request = newHttpRequest();
331            HttpServletResponse response = newResponse();
332            RequestDispatcher dispatcher = newDispatcher();
333    
334            trainGetRequestDispatcher(request, "/", dispatcher);
335    
336            dispatcher.forward(request, response);
337    
338            replay();
339    
340            WebRequest wr = new ServletWebRequest(request, response);
341    
342            wr.forward(null);
343    
344            verify();
345        }
346    
347        private void trainGetRequestDispatcher(HttpServletRequest request, String path,
348                RequestDispatcher dispatcher)
349        {
350            expect(request.getRequestDispatcher(path)).andReturn(dispatcher);
351        }
352    
353        public void testForwardInternalNoDispatcher() throws Exception
354        {
355            HttpServletRequest request = newHttpRequest();
356            HttpServletResponse response = newResponse();
357    
358            trainGetRequestDispatcher(request, "/local.html", null);
359    
360            replay();
361    
362            WebRequest wr = new ServletWebRequest(request, response);
363    
364            try
365            {
366                wr.forward("local.html");
367                unreachable();
368            }
369            catch (ApplicationRuntimeException ex)
370            {
371                assertEquals(
372                        "Unable to find a request dispatcher for local resource '/local.html'.",
373                        ex.getMessage());
374            }
375    
376            verify();
377        }
378    
379        public void testForwardInternalFailure() throws Exception
380        {
381            HttpServletRequest request = newHttpRequest();
382            HttpServletResponse response = newResponse();
383            RequestDispatcher dispatcher = newDispatcher();
384    
385            Throwable t1 = new ServletException("Mock Servlet Exception");
386    
387            trainGetRequestDispatcher(request, "/servlet-exception.html", dispatcher);
388    
389            dispatcher.forward(request, response);
390            expectLastCall().andThrow(t1);
391    
392            replay();
393    
394            WebRequest wr = new ServletWebRequest(request, response);
395    
396            try
397            {
398                wr.forward("servlet-exception.html");
399                unreachable();
400            }
401            catch (ApplicationRuntimeException ex)
402            {
403                assertEquals(
404                        "Unable to forward to local resource '/servlet-exception.html': Mock Servlet Exception",
405                        ex.getMessage());
406                assertSame(t1, ex.getRootCause());
407            }
408    
409            verify();
410    
411            Throwable t2 = new IOException("Mock IO Exception");
412    
413            trainGetRequestDispatcher(request, "/io-exception.html", dispatcher);
414    
415            dispatcher.forward(request, response);
416            expectLastCall().andThrow(t2);
417    
418            replay();
419    
420            try
421            {
422                wr.forward("io-exception.html");
423                unreachable();
424            }
425            catch (ApplicationRuntimeException ex)
426            {
427                assertEquals(
428                        "Unable to forward to local resource '/io-exception.html': Mock IO Exception",
429                        ex.getMessage());
430                assertSame(t2, ex.getRootCause());
431            }
432    
433            verify();
434        }
435    
436        public void testForwardExternal() throws Exception
437        {
438            HttpServletRequest request = newHttpRequest();
439            HttpServletResponse response = newResponse();
440    
441            expect(response.encodeRedirectURL("http://foo.bar")).andReturn("<encoded: http://foo.bar>");
442            
443            response.sendRedirect("<encoded: http://foo.bar>");
444    
445            replay();
446    
447            WebRequest wr = new ServletWebRequest(request, response);
448    
449            wr.forward("http://foo.bar");
450    
451            verify();
452        }
453    
454        public void testForwardExternalFailure() throws Exception
455        {
456            HttpServletRequest request = newHttpRequest();
457            HttpServletResponse response = newMock(HttpServletResponse.class);
458    
459            Throwable t = new IOException("Mock IO Exception");
460    
461            expect(response.encodeRedirectURL("/")).andReturn("<encoded: http://foo.bar>");
462            
463            response.sendRedirect("<encoded: http://foo.bar>");
464            expectLastCall().andThrow(t);
465            
466            replay();
467    
468            WebRequest wr = new ServletWebRequest(request, response);
469    
470            try
471            {
472                wr.forward("/");
473                unreachable();
474            }
475            catch (ApplicationRuntimeException ex)
476            {
477                assertEquals("Unable to redirect to /: Mock IO Exception", ex.getMessage());
478                assertSame(t, ex.getRootCause());
479            }
480    
481            verify();
482        }
483    
484        public void testGetActivationPath()
485        {
486            HttpServletRequest request = newHttpRequest();
487            HttpServletResponse response = newResponse();
488    
489            expect(request.getServletPath()).andReturn("/foo");
490            
491            replay();
492    
493            WebRequest wr = new ServletWebRequest(request, response);
494    
495            assertEquals("/foo", wr.getActivationPath());
496    
497            verify();
498        }
499    
500        public void testGetPathInfo()
501        {
502            HttpServletRequest request = newHttpRequest();
503            HttpServletResponse response = newResponse();
504    
505            expect(request.getPathInfo()).andReturn("bar/baz");
506            
507            replay();
508    
509            WebRequest wr = new ServletWebRequest(request, response);
510    
511            assertEquals("bar/baz", wr.getPathInfo());
512    
513            verify();
514        }
515    }