001: package com.mockrunner.test.web;
002:
003: import java.io.BufferedReader;
004: import java.io.IOException;
005: import java.util.ArrayList;
006: import java.util.Enumeration;
007: import java.util.List;
008:
009: import javax.servlet.RequestDispatcher;
010: import javax.servlet.ServletException;
011: import javax.servlet.ServletInputStream;
012: import javax.servlet.ServletRequest;
013: import javax.servlet.ServletRequestAttributeEvent;
014: import javax.servlet.ServletRequestAttributeListener;
015: import javax.servlet.ServletResponse;
016: import javax.servlet.http.Cookie;
017:
018: import junit.framework.TestCase;
019:
020: import com.mockrunner.mock.web.MockHttpServletRequest;
021: import com.mockrunner.mock.web.MockHttpSession;
022: import com.mockrunner.mock.web.MockRequestDispatcher;
023:
024: public class MockHttpServletRequestTest extends TestCase {
025: private MockHttpServletRequest request;
026:
027: protected void setUp() {
028: request = new MockHttpServletRequest();
029: }
030:
031: protected void tearDown() {
032: request = null;
033: }
034:
035: public void testResetAll() throws Exception {
036: request.setAttribute("key", "value");
037: request.addHeader("header", "headervalue");
038: request.setContentLength(5);
039: request.resetAll();
040: assertNull(request.getAttribute("key"));
041: assertNull(request.getHeader("header"));
042: assertEquals(-1, request.getContentLength());
043: }
044:
045: public void testAttributeListenerCalled() {
046: TestAttributeListener listener1 = new TestAttributeListener();
047: TestAttributeListener listener2 = new TestAttributeListener();
048: TestAttributeListener listener3 = new TestAttributeListener();
049: request.addAttributeListener(listener1);
050: request.addAttributeListener(listener2);
051: request.addAttributeListener(listener3);
052: request.setAttribute("key", "value");
053: assertTrue(listener1.wasAttributeAddedCalled());
054: assertTrue(listener2.wasAttributeAddedCalled());
055: assertTrue(listener3.wasAttributeAddedCalled());
056: assertFalse(listener1.wasAttributeReplacedCalled());
057: assertFalse(listener2.wasAttributeReplacedCalled());
058: assertFalse(listener3.wasAttributeReplacedCalled());
059: listener1.reset();
060: listener2.reset();
061: listener3.reset();
062: request.setAttribute("key", "value1");
063: assertFalse(listener1.wasAttributeAddedCalled());
064: assertFalse(listener2.wasAttributeAddedCalled());
065: assertFalse(listener3.wasAttributeAddedCalled());
066: assertTrue(listener1.wasAttributeReplacedCalled());
067: assertTrue(listener2.wasAttributeReplacedCalled());
068: assertTrue(listener3.wasAttributeReplacedCalled());
069: request.removeAttribute("key");
070: assertTrue(listener1.wasAttributeRemovedCalled());
071: assertTrue(listener2.wasAttributeRemovedCalled());
072: assertTrue(listener3.wasAttributeRemovedCalled());
073: }
074:
075: public void testAttributeListenerValues() {
076: TestAttributeOrderListener listener = new TestAttributeOrderListener();
077: request.addAttributeListener(listener);
078: request.setAttribute("key", "value");
079: assertEquals("key", listener.getAddedEventKey());
080: assertEquals("value", listener.getAddedEventValue());
081: request.setAttribute("key", "anotherValue");
082: assertEquals("key", listener.getReplacedEventKey());
083: assertEquals("value", listener.getReplacedEventValue());
084: request.removeAttribute("key");
085: assertEquals("key", listener.getRemovedEventKey());
086: assertEquals("anotherValue", listener.getRemovedEventValue());
087: }
088:
089: public void testAttributeListenerNullValue() {
090: TestAttributeListener listener = new TestAttributeListener();
091: request.addAttributeListener(listener);
092: request.setAttribute("key", null);
093: assertFalse(listener.wasAttributeAddedCalled());
094: request.setAttribute("key", "xyz");
095: assertTrue(listener.wasAttributeAddedCalled());
096: request.setAttribute("key", null);
097: assertTrue(listener.wasAttributeRemovedCalled());
098: assertFalse(listener.wasAttributeReplacedCalled());
099: listener.reset();
100: request.setAttribute("key", "xyz");
101: assertTrue(listener.wasAttributeAddedCalled());
102: assertFalse(listener.wasAttributeReplacedCalled());
103: request.removeAttribute("myKey");
104: assertFalse(listener.wasAttributeRemovedCalled());
105: }
106:
107: public void testGetAttributeNames() {
108: Enumeration enumeration = request.getAttributeNames();
109: assertFalse(enumeration.hasMoreElements());
110: request.setAttribute("key", null);
111: enumeration = request.getAttributeNames();
112: assertFalse(enumeration.hasMoreElements());
113: request.setAttribute("key1", "value1");
114: request.setAttribute("key2", "value2");
115: assertEquals("value1", request.getAttribute("key1"));
116: assertEquals("value2", request.getAttribute("key2"));
117: enumeration = request.getAttributeNames();
118: List testList = new ArrayList();
119: testList.add(enumeration.nextElement());
120: testList.add(enumeration.nextElement());
121: assertFalse(enumeration.hasMoreElements());
122: assertTrue(testList.contains("key1"));
123: assertTrue(testList.contains("key2"));
124: request.setAttribute("key2", null);
125: assertNull(request.getAttribute("key2"));
126: enumeration = request.getAttributeNames();
127: testList = new ArrayList();
128: testList.add(enumeration.nextElement());
129: assertFalse(enumeration.hasMoreElements());
130: assertTrue(testList.contains("key1"));
131: request.setAttribute("key1", null);
132: assertNull(request.getAttribute("key1"));
133: enumeration = request.getAttributeNames();
134: assertFalse(enumeration.hasMoreElements());
135: }
136:
137: public void testAddRequestParameter() throws Exception {
138: request.setupAddParameter("abc", "abc");
139: assertEquals("abc", request.getParameter("abc"));
140: request.setupAddParameter("abc", "123");
141: assertEquals("123", request.getParameter("abc"));
142: assertEquals(1, request.getParameterValues("abc").length);
143: request.setupAddParameter("abc", new String[] { "123", "456" });
144: assertEquals("123", request.getParameter("abc"));
145: assertEquals(2, request.getParameterValues("abc").length);
146: assertEquals("123", request.getParameterValues("abc")[0]);
147: assertEquals("456", request.getParameterValues("abc")[1]);
148: }
149:
150: public void testHeaders() {
151: request.addHeader("testHeader", "xyz");
152: request.addHeader("testHeader", "abc");
153: Enumeration headers = request.getHeaders("testHeader");
154: List list = new ArrayList();
155: list.add(headers.nextElement());
156: list.add(headers.nextElement());
157: assertFalse(headers.hasMoreElements());
158: assertTrue(list.contains("xyz"));
159: assertTrue(list.contains("abc"));
160: assertNull(request.getHeader("anotherHeader"));
161: request.addHeader("dateHeader",
162: "Friday, 06 Feb 2004 22:59:48 GMT");
163: headers = request.getHeaderNames();
164: list = new ArrayList();
165: list.add(headers.nextElement());
166: list.add(headers.nextElement());
167: assertFalse(headers.hasMoreElements());
168: assertTrue(list.contains("testHeader"));
169: assertTrue(list.contains("dateHeader"));
170: long date = request.getDateHeader("dateHeader");
171: assertEquals(1076108388000l, date);
172: assertEquals(-1, request.getDateHeader("anotherDateHeader"));
173: request.setHeader("dateHeader", "3.3.1980");
174: try {
175: request.getDateHeader("dateHeader");
176: fail();
177: } catch (IllegalArgumentException exc) {
178: //should throw exception
179: }
180: request.setHeader("intHeader", "25");
181: int value = request.getIntHeader("intHeader");
182: assertEquals(25, value);
183: assertEquals(-1, request.getIntHeader("anotherIntHeader"));
184: request.setHeader("intHeader", "xyz");
185: try {
186: request.getIntHeader("intHeader");
187: fail();
188: } catch (NumberFormatException exc) {
189: //should throw exception
190: }
191: request.clearHeaders();
192: headers = request.getHeaderNames();
193: assertFalse(headers.hasMoreElements());
194: }
195:
196: public void testHeadersCaseInsensitive() {
197: request.addHeader("testHeader", "xyz");
198: request.addHeader("TESTHeader", "abc");
199: Enumeration headers = request.getHeaders("testHeader");
200: List list = new ArrayList();
201: list.add(headers.nextElement());
202: list.add(headers.nextElement());
203: assertFalse(headers.hasMoreElements());
204: assertTrue(list.contains("xyz"));
205: assertTrue(list.contains("abc"));
206: request.addHeader("MYHEADER1", "xyz");
207: request.addHeader("myHeader2", "abc");
208: assertEquals("xyz", request.getHeader("myheader1"));
209: assertEquals("abc", request.getHeader("MYHEADER2"));
210: headers = request.getHeaderNames();
211: List headerNames = new ArrayList();
212: while (headers.hasMoreElements()) {
213: headerNames.add(headers.nextElement());
214: }
215: assertEquals(3, headerNames.size());
216: assertTrue(headerNames.contains("testHeader"));
217: assertTrue(headerNames.contains("MYHEADER1"));
218: assertTrue(headerNames.contains("myHeader2"));
219: }
220:
221: public void testCookies() {
222: request.addCookie(new Cookie("name1", "value1"));
223: request.addCookie(new Cookie("name2", "value2"));
224: request.addCookie(new Cookie("name3", "value3"));
225: Cookie[] cookies = request.getCookies();
226: assertTrue(cookies.length == 3);
227: assertEquals("name1", cookies[0].getName());
228: assertEquals("value1", cookies[0].getValue());
229: assertEquals("name2", cookies[1].getName());
230: assertEquals("value2", cookies[1].getValue());
231: assertEquals("name3", cookies[2].getName());
232: assertEquals("value3", cookies[2].getValue());
233: }
234:
235: public void testBodyContent() throws Exception {
236: request.setBodyContent("test\nanothertestäöü");
237: BufferedReader reader = request.getReader();
238: assertEquals("test", reader.readLine());
239: assertEquals("anothertestäöü", reader.readLine());
240: assertEquals(-1, reader.read());
241: request.setBodyContent(new byte[] { 0, -128, 3, 127, 55 });
242: ServletInputStream stream = request.getInputStream();
243: assertEquals(0, stream.read());
244: assertEquals(-128, (byte) stream.read());
245: assertEquals(3, stream.read());
246: assertEquals(127, stream.read());
247: assertEquals(55, stream.read());
248: }
249:
250: public void testRequestDispatcher() throws Exception {
251: final String rdPath1 = "rdPathOne";
252: final String rdPath2 = "rdPathTwo";
253: final String rdPath3 = "rdPathThree";
254:
255: assertEquals(0, request.getRequestDispatcherMap().size());
256:
257: MockRequestDispatcher rd1 = (MockRequestDispatcher) request
258: .getRequestDispatcher(rdPath1);
259: assertEquals(rdPath1, rd1.getPath());
260: assertNull(rd1.getForwardedRequest());
261: assertNull(rd1.getIncludedRequest());
262:
263: assertEquals(1, request.getRequestDispatcherMap().size());
264: assertTrue(request.getRequestDispatcherMap().containsKey(
265: rdPath1));
266: assertSame(rd1, request.getRequestDispatcherMap().get(rdPath1));
267:
268: MockRequestDispatcher actualRd2 = new MockRequestDispatcher();
269: request.setRequestDispatcher(rdPath2, actualRd2);
270: MockRequestDispatcher rd2 = (MockRequestDispatcher) request
271: .getRequestDispatcher(rdPath2);
272: assertEquals(rdPath2, rd2.getPath());
273: assertSame(actualRd2, rd2);
274: assertNull(rd1.getForwardedRequest());
275: assertNull(rd1.getIncludedRequest());
276:
277: assertEquals(2, request.getRequestDispatcherMap().size());
278: assertTrue(request.getRequestDispatcherMap().containsKey(
279: rdPath2));
280: assertSame(rd2, request.getRequestDispatcherMap().get(rdPath2));
281:
282: RequestDispatcher actualRd3 = new TestRequestDispatcher();
283: request.setRequestDispatcher(rdPath3, actualRd3);
284: RequestDispatcher rd3 = request.getRequestDispatcher(rdPath3);
285: assertSame(actualRd3, rd3);
286:
287: assertEquals(3, request.getRequestDispatcherMap().size());
288: assertTrue(request.getRequestDispatcherMap().containsKey(
289: rdPath3));
290: assertSame(rd3, request.getRequestDispatcherMap().get(rdPath3));
291:
292: request.clearRequestDispatcherMap();
293: assertEquals(0, request.getRequestDispatcherMap().size());
294: }
295:
296: public void testSessionCreation() throws Exception {
297: request.setSession(new MockHttpSession());
298: assertNull(request.getSession(false));
299: assertNotNull(request.getSession());
300: assertNotNull(request.getSession(false));
301: assertNotNull(request.getSession(true));
302: request = new MockHttpServletRequest();
303: request.setSession(new MockHttpSession());
304: assertNotNull(request.getSession(true));
305: assertNotNull(request.getSession(false));
306: }
307:
308: private class TestAttributeListener implements
309: ServletRequestAttributeListener {
310: private boolean wasAttributeAddedCalled = false;
311: private boolean wasAttributeReplacedCalled = false;
312: private boolean wasAttributeRemovedCalled = false;
313:
314: public void attributeAdded(ServletRequestAttributeEvent event) {
315: wasAttributeAddedCalled = true;
316: }
317:
318: public void attributeRemoved(ServletRequestAttributeEvent event) {
319: wasAttributeRemovedCalled = true;
320: }
321:
322: public void attributeReplaced(ServletRequestAttributeEvent event) {
323: wasAttributeReplacedCalled = true;
324: }
325:
326: public void reset() {
327: wasAttributeAddedCalled = false;
328: wasAttributeReplacedCalled = false;
329: wasAttributeRemovedCalled = false;
330: }
331:
332: public boolean wasAttributeAddedCalled() {
333: return wasAttributeAddedCalled;
334: }
335:
336: public boolean wasAttributeRemovedCalled() {
337: return wasAttributeRemovedCalled;
338: }
339:
340: public boolean wasAttributeReplacedCalled() {
341: return wasAttributeReplacedCalled;
342: }
343: }
344:
345: private class TestAttributeOrderListener implements
346: ServletRequestAttributeListener {
347: private String addedEventKey;
348: private Object addedEventValue;
349: private String replacedEventKey;
350: private Object replacedEventValue;
351: private String removedEventKey;
352: private Object removedEventValue;
353:
354: public void attributeAdded(ServletRequestAttributeEvent event) {
355: addedEventKey = event.getName();
356: addedEventValue = event.getValue();
357: }
358:
359: public void attributeRemoved(ServletRequestAttributeEvent event) {
360: removedEventKey = event.getName();
361: removedEventValue = event.getValue();
362: }
363:
364: public void attributeReplaced(ServletRequestAttributeEvent event) {
365: replacedEventKey = event.getName();
366: replacedEventValue = event.getValue();
367: }
368:
369: public String getAddedEventKey() {
370: return addedEventKey;
371: }
372:
373: public Object getAddedEventValue() {
374: return addedEventValue;
375: }
376:
377: public String getRemovedEventKey() {
378: return removedEventKey;
379: }
380:
381: public Object getRemovedEventValue() {
382: return removedEventValue;
383: }
384:
385: public String getReplacedEventKey() {
386: return replacedEventKey;
387: }
388:
389: public Object getReplacedEventValue() {
390: return replacedEventValue;
391: }
392: }
393:
394: private class TestRequestDispatcher implements RequestDispatcher {
395:
396: public void forward(ServletRequest request,
397: ServletResponse response) throws ServletException,
398: IOException {
399:
400: }
401:
402: public void include(ServletRequest request,
403: ServletResponse response) throws ServletException,
404: IOException {
405:
406: }
407: }
408: }
|