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    
019    import java.io.CharArrayWriter;
020    import java.io.IOException;
021    import java.io.PrintWriter;
022    
023    import org.apache.commons.logging.Log;
024    import org.apache.hivemind.ApplicationRuntimeException;
025    import org.apache.tapestry.BaseComponentTestCase;
026    import org.apache.tapestry.util.ContentType;
027    import org.testng.annotations.Test;
028    
029    import javax.servlet.ServletOutputStream;
030    import javax.servlet.http.HttpServletResponse;
031    
032    /**
033     * Tests for {@link org.apache.tapestry.web.ServletWebResponse}.
034     * 
035     * @author Howard M. Lewis Ship
036     * @since 4.0
037     */
038    @Test
039    public class ServletWebResponseTest extends BaseComponentTestCase
040    {
041        private static class MockServletOutputStream extends ServletOutputStream
042        {
043            public void write(int b) throws IOException
044            {
045            }
046        }
047    
048        public void testGetOutputStream() throws Exception
049        {
050            HttpServletResponse response = newResponse();
051    
052            ServletOutputStream stream = new MockServletOutputStream();
053    
054            response.setContentType("foo/bar");
055            expect(response.getOutputStream()).andReturn(stream);
056    
057            replay();
058    
059            ServletWebResponse swr = new ServletWebResponse(response);
060    
061            assertSame(stream, swr.getOutputStream(new ContentType("foo/bar")));
062    
063            verify();
064        }
065    
066        public void testGetOutputStreamFailure() throws Exception
067        {
068            HttpServletResponse response = newResponse();
069    
070            Throwable t = new IOException("Simulated failure.");
071    
072            response.setContentType("foo/bar");
073            expect(response.getOutputStream()).andThrow(t);
074    
075            replay();
076    
077            ServletWebResponse swr = new ServletWebResponse(response);
078    
079            try
080            {
081                swr.getOutputStream(new ContentType("foo/bar"));
082                unreachable();
083            }
084            catch (ApplicationRuntimeException ex)
085            {
086                assertEquals(
087                        "Error opening response stream for content type foo/bar: Simulated failure.",
088                        ex.getMessage());
089                assertSame(t, ex.getRootCause());
090            }
091        }
092    
093        public void testGetPrintWriter() throws Exception
094        {
095            PrintWriter writer = new PrintWriter(new CharArrayWriter());
096    
097            HttpServletResponse response = newResponse();
098    
099            response.setContentType("foo/bar");
100            
101            trainGetWriter(response, writer);
102    
103            replay();
104    
105            ServletWebResponse swr = new ServletWebResponse(response);
106    
107            assertSame(writer, swr.getPrintWriter(new ContentType("foo/bar")));
108    
109            verify();
110        }
111    
112        private void trainGetWriter(HttpServletResponse response, PrintWriter writer) throws IOException
113        {
114            expect(response.getWriter()).andReturn(writer);
115        }
116        
117        
118    
119        public void testGetSecondPrintWriter() throws Exception
120        {
121            PrintWriter writer1 = new PrintWriter(new CharArrayWriter());
122            PrintWriter writer2 = new PrintWriter(new CharArrayWriter());
123    
124            HttpServletResponse response = newResponse();
125    
126            response.setContentType("foo/bar");
127            
128            trainGetWriter(response, writer1);
129            
130            replay();
131    
132            ServletWebResponse swr = new ServletWebResponse(response);
133    
134            assertSame(writer1, swr.getPrintWriter(new ContentType("foo/bar")));
135    
136            verify();
137    
138            response.reset();
139            response.setContentType("biff/bazz");
140            
141            trainGetWriter(response, writer2);
142            
143            replay();
144    
145            assertSame(writer2, swr.getPrintWriter(new ContentType("biff/bazz")));
146    
147            verify();
148        }
149        
150        public void testGetSecondPrintWriterTomcatPatch() throws Exception
151        {
152            PrintWriter writer1 = new PrintWriter(new CharArrayWriter());
153            PrintWriter writer2 = new PrintWriter(new CharArrayWriter());
154    
155            HttpServletResponse response = newResponse();
156            Log log = newLog();
157    
158            response.setContentType("foo/bar");
159            
160            trainGetWriter(response, writer1);
161            
162            replay();
163    
164            ServletWebResponse swr = new ServletWebResponse(response, log, true);
165    
166            assertSame(writer1, swr.getPrintWriter(new ContentType("foo/bar")));
167    
168            verify();
169    
170            response.reset();
171    
172            trainGetWriter(response, writer2);
173            
174            replay();
175    
176            assertSame(writer2, swr.getPrintWriter(new ContentType("foo/bar")));
177    
178            verify();
179        }
180        
181        public void testGetSecondPrintWriterDifferentContentTypeTomcatPatch() throws Exception
182        {
183            PrintWriter writer1 = new PrintWriter(new CharArrayWriter());
184            PrintWriter writer2 = new PrintWriter(new CharArrayWriter());
185    
186            HttpServletResponse response = newResponse();
187            Log log = newLog();
188    
189            response.setContentType("foo/bar");
190            
191            trainGetWriter(response, writer1);
192            
193            replay();
194    
195            ServletWebResponse swr = new ServletWebResponse(response, log, true);
196    
197            assertSame(writer1, swr.getPrintWriter(new ContentType("foo/bar")));
198    
199            verify();
200    
201            response.reset();
202            
203            log.warn("Unable to change response content type from 'foo/bar' to 'biff/bazz' (following a reset). See Tapestry issue TAPESTRY-607.");
204            
205            trainGetWriter(response, writer2);
206            
207            replay();
208    
209            assertSame(writer2, swr.getPrintWriter(new ContentType("biff/bazz")));
210    
211            verify();
212        }    
213    
214        public void testGetPrintWriterFailure() throws Exception
215        {
216            HttpServletResponse response = newResponse();
217    
218            Throwable t = new IOException("Simulated failure.");
219    
220            response.setContentType("foo/bar");
221            expect(response.getWriter()).andThrow(t);
222    
223            replay();
224    
225            ServletWebResponse swr = new ServletWebResponse(response);
226    
227            try
228            {
229                swr.getPrintWriter(new ContentType("foo/bar"));
230                unreachable();
231            }
232            catch (ApplicationRuntimeException ex)
233            {
234                assertEquals(
235                        "Error opening response writer for content type foo/bar: Simulated failure.",
236                        ex.getMessage());
237                assertSame(t, ex.getRootCause());
238            }
239        }
240    
241        public void testReset()
242        {
243            HttpServletResponse response = newResponse();
244    
245            response.reset();
246    
247            replay();
248    
249            ServletWebResponse swr = new ServletWebResponse(response);
250    
251            swr.reset();
252    
253            verify();
254        }
255    
256        private HttpServletResponse newResponse()
257        {
258            return newMock(HttpServletResponse.class);
259        }
260    
261        public void testSetHeaderMethods() throws Exception
262        {
263            HttpServletResponse response = newResponse();
264    
265            response.setHeader("fie", "fie");
266            response.setDateHeader("expires", -1);
267            response.setIntHeader("size", 33);
268            response.sendError(99, "foo!");
269    
270            replay();
271    
272            ServletWebResponse swr = new ServletWebResponse(response);
273    
274            swr.setHeader("fie", "fie");
275            swr.setDateHeader("expires", -1);
276            swr.setIntHeader("size", 33);
277            swr.sendError(99, "foo!");
278    
279            verify();
280    
281        }
282    
283    }