001: package com.mockrunner.test.web;
002:
003: import java.io.ByteArrayInputStream;
004: import java.io.IOException;
005: import java.io.InputStream;
006: import java.net.URL;
007: import java.util.ArrayList;
008: import java.util.Arrays;
009: import java.util.Enumeration;
010: import java.util.HashMap;
011: import java.util.List;
012: import java.util.Map;
013: import java.util.Set;
014:
015: import javax.servlet.RequestDispatcher;
016: import javax.servlet.ServletContextAttributeEvent;
017: import javax.servlet.ServletContextAttributeListener;
018: import javax.servlet.ServletException;
019: import javax.servlet.ServletRequest;
020: import javax.servlet.ServletResponse;
021:
022: import junit.framework.TestCase;
023:
024: import com.mockrunner.mock.web.MockRequestDispatcher;
025: import com.mockrunner.mock.web.MockServletContext;
026: import com.mockrunner.util.common.StreamUtil;
027:
028: public class MockServletContextTest extends TestCase {
029: private MockServletContext context;
030:
031: protected void setUp() {
032: context = new MockServletContext();
033: }
034:
035: protected void tearDown() {
036: context = null;
037: }
038:
039: public void testResetAll() throws Exception {
040: context.setAttribute("key", "value");
041: context.addResourcePaths("path", new ArrayList());
042: context.setResource("path", new URL("file://test"));
043: context.resetAll();
044: assertNull(context.getAttribute("key"));
045: assertNull(context.getResourcePaths("path"));
046: assertNull(context.getResource("path"));
047: }
048:
049: public void testResources() throws Exception {
050: context.setResource("testPath", new URL("http://test"));
051: assertEquals(new URL("http://test"), context
052: .getResource("testPath"));
053: context.addResourcePath("testPath", "path1");
054: ArrayList list = new ArrayList();
055: list.add("path2");
056: list.add("path3");
057: context.addResourcePaths("testPath", list);
058: Set paths = context.getResourcePaths("testPath");
059: assertTrue(paths.size() == 3);
060: assertTrue(paths.contains("path1"));
061: assertTrue(paths.contains("path2"));
062: assertTrue(paths.contains("path3"));
063: assertNull(context.getResourcePaths("anotherTestPath"));
064: byte[] data = new byte[] { 1, 2, 3 };
065: context.setResourceAsStream("testPath", data);
066: InputStream stream = context.getResourceAsStream("testPath");
067: assertEquals(1, stream.read());
068: assertEquals(2, stream.read());
069: assertEquals(3, stream.read());
070: assertEquals(-1, stream.read());
071: data[0] = 5;
072: stream = context.getResourceAsStream("testPath");
073: assertEquals(1, stream.read());
074: assertEquals(2, stream.read());
075: assertEquals(3, stream.read());
076: assertEquals(-1, stream.read());
077: }
078:
079: public void testAttributeListenerCalled() {
080: TestAttributeListener listener1 = new TestAttributeListener();
081: TestAttributeListener listener2 = new TestAttributeListener();
082: TestAttributeListener listener3 = new TestAttributeListener();
083: context.addAttributeListener(listener1);
084: context.addAttributeListener(listener2);
085: context.addAttributeListener(listener3);
086: context.setAttribute("key", "value");
087: assertTrue(listener1.wasAttributeAddedCalled());
088: assertTrue(listener2.wasAttributeAddedCalled());
089: assertTrue(listener3.wasAttributeAddedCalled());
090: assertFalse(listener1.wasAttributeReplacedCalled());
091: assertFalse(listener2.wasAttributeReplacedCalled());
092: assertFalse(listener3.wasAttributeReplacedCalled());
093: listener1.reset();
094: listener2.reset();
095: listener3.reset();
096: context.setAttribute("key", "value1");
097: assertFalse(listener1.wasAttributeAddedCalled());
098: assertFalse(listener2.wasAttributeAddedCalled());
099: assertFalse(listener3.wasAttributeAddedCalled());
100: assertTrue(listener1.wasAttributeReplacedCalled());
101: assertTrue(listener2.wasAttributeReplacedCalled());
102: assertTrue(listener3.wasAttributeReplacedCalled());
103: context.removeAttribute("key");
104: assertTrue(listener1.wasAttributeRemovedCalled());
105: assertTrue(listener2.wasAttributeRemovedCalled());
106: assertTrue(listener3.wasAttributeRemovedCalled());
107: }
108:
109: public void testAttributeListenerValues() {
110: TestAttributeOrderListener listener = new TestAttributeOrderListener();
111: context.addAttributeListener(listener);
112: context.setAttribute("key", "value");
113: assertEquals("key", listener.getAddedEventKey());
114: assertEquals("value", listener.getAddedEventValue());
115: context.setAttribute("key", "anotherValue");
116: assertEquals("key", listener.getReplacedEventKey());
117: assertEquals("value", listener.getReplacedEventValue());
118: context.removeAttribute("key");
119: assertEquals("key", listener.getRemovedEventKey());
120: assertEquals("anotherValue", listener.getRemovedEventValue());
121: }
122:
123: public void testAttributeListenerNullValue() {
124: TestAttributeListener listener = new TestAttributeListener();
125: context.addAttributeListener(listener);
126: context.setAttribute("key", null);
127: assertFalse(listener.wasAttributeAddedCalled());
128: context.setAttribute("key", "xyz");
129: assertTrue(listener.wasAttributeAddedCalled());
130: context.setAttribute("key", null);
131: assertTrue(listener.wasAttributeRemovedCalled());
132: assertFalse(listener.wasAttributeReplacedCalled());
133: listener.reset();
134: context.setAttribute("key", "xyz");
135: assertTrue(listener.wasAttributeAddedCalled());
136: assertFalse(listener.wasAttributeReplacedCalled());
137: context.removeAttribute("myKey");
138: assertFalse(listener.wasAttributeRemovedCalled());
139: }
140:
141: public void testGetAttributeNames() {
142: Enumeration enumeration = context.getAttributeNames();
143: assertFalse(enumeration.hasMoreElements());
144: context.setAttribute("key", null);
145: enumeration = context.getAttributeNames();
146: assertFalse(enumeration.hasMoreElements());
147: context.setAttribute("key1", "value1");
148: context.setAttribute("key2", "value2");
149: assertEquals("value1", context.getAttribute("key1"));
150: assertEquals("value2", context.getAttribute("key2"));
151: enumeration = context.getAttributeNames();
152: List testList = new ArrayList();
153: testList.add(enumeration.nextElement());
154: testList.add(enumeration.nextElement());
155: assertFalse(enumeration.hasMoreElements());
156: assertTrue(testList.contains("key1"));
157: assertTrue(testList.contains("key2"));
158: context.setAttribute("key2", null);
159: assertNull(context.getAttribute("key2"));
160: enumeration = context.getAttributeNames();
161: testList = new ArrayList();
162: testList.add(enumeration.nextElement());
163: assertFalse(enumeration.hasMoreElements());
164: assertTrue(testList.contains("key1"));
165: context.setAttribute("key1", null);
166: assertNull(context.getAttribute("key1"));
167: enumeration = context.getAttributeNames();
168: assertFalse(enumeration.hasMoreElements());
169: }
170:
171: public void testRequestDispatcher() throws Exception {
172: final String rdPath1 = "rdPathOne";
173: final String rdPath2 = "rdPathTwo";
174: final String rdPath3 = "rdPathThree";
175:
176: assertEquals(0, context.getRequestDispatcherMap().size());
177:
178: MockRequestDispatcher rd1 = (MockRequestDispatcher) context
179: .getRequestDispatcher(rdPath1);
180: assertEquals(rdPath1, rd1.getPath());
181: assertNull(rd1.getForwardedRequest());
182: assertNull(rd1.getIncludedRequest());
183:
184: assertEquals(1, context.getRequestDispatcherMap().size());
185: assertTrue(context.getRequestDispatcherMap().containsKey(
186: rdPath1));
187: assertSame(rd1, context.getRequestDispatcherMap().get(rdPath1));
188:
189: MockRequestDispatcher actualRd2 = new MockRequestDispatcher();
190: context.setRequestDispatcher(rdPath2, actualRd2);
191: MockRequestDispatcher rd2 = (MockRequestDispatcher) context
192: .getRequestDispatcher(rdPath2);
193: assertEquals(rdPath2, rd2.getPath());
194: assertSame(actualRd2, rd2);
195: assertNull(rd1.getForwardedRequest());
196: assertNull(rd1.getIncludedRequest());
197:
198: rd2 = (MockRequestDispatcher) context
199: .getNamedDispatcher(rdPath2);
200: assertEquals(rdPath2, rd2.getPath());
201: assertSame(actualRd2, rd2);
202:
203: assertEquals(2, context.getRequestDispatcherMap().size());
204: assertTrue(context.getRequestDispatcherMap().containsKey(
205: rdPath2));
206: assertSame(rd2, context.getRequestDispatcherMap().get(rdPath2));
207:
208: RequestDispatcher actualRd3 = new TestRequestDispatcher();
209: context.setRequestDispatcher(rdPath3, actualRd3);
210: RequestDispatcher rd3 = context.getRequestDispatcher(rdPath3);
211: assertSame(actualRd3, rd3);
212:
213: rd3 = context.getNamedDispatcher(rdPath3);
214: assertSame(actualRd3, rd3);
215:
216: assertEquals(3, context.getRequestDispatcherMap().size());
217: assertTrue(context.getRequestDispatcherMap().containsKey(
218: rdPath3));
219: assertSame(rd3, context.getRequestDispatcherMap().get(rdPath3));
220:
221: context.clearRequestDispatcherMap();
222: assertEquals(0, context.getRequestDispatcherMap().size());
223: }
224:
225: public void testSetResourceAsStream() throws Exception {
226: byte[] input = { 1, 2, 3, 4 };
227: context.setResourceAsStream("testpath1", input);
228: InputStream result = context.getResourceAsStream("testpath1");
229: assertTrue(Arrays.equals(input, StreamUtil
230: .getStreamAsByteArray(result)));
231: context.setResourceAsStream("testpath2",
232: new ByteArrayInputStream(input));
233: result = context.getResourceAsStream("testpath2");
234: assertTrue(StreamUtil.compareStreams(new ByteArrayInputStream(
235: input), result));
236: }
237:
238: public void testGetContext() throws Exception {
239: assertNull(context.getContext("abc"));
240: context.setContext("abc", context);
241: assertSame(context, context.getContext("abc"));
242: MockServletContext anotherContext = new MockServletContext();
243: context.setContext("xyz", anotherContext);
244: assertSame(anotherContext, context.getContext("xyz"));
245: }
246:
247: public void testInitParameters() {
248: context.setInitParameter("key1", "value1");
249: Map parameters = new HashMap();
250: parameters.put("key2", "value2");
251: parameters.put("key3", "value3");
252: context.setInitParameters(parameters);
253: assertEquals("value1", context.getInitParameter("key1"));
254: assertEquals("value2", context.getInitParameter("key2"));
255: assertEquals("value3", context.getInitParameter("key3"));
256: Enumeration params = context.getInitParameterNames();
257: List list = new ArrayList();
258: list.add(params.nextElement());
259: list.add(params.nextElement());
260: list.add(params.nextElement());
261: assertFalse(params.hasMoreElements());
262: assertTrue(list.contains("key1"));
263: assertTrue(list.contains("key2"));
264: assertTrue(list.contains("key3"));
265: context.clearInitParameters();
266: assertNull(context.getInitParameter("key1"));
267: params = context.getInitParameterNames();
268: assertFalse(params.hasMoreElements());
269: }
270:
271: private class TestAttributeListener implements
272: ServletContextAttributeListener {
273: private boolean wasAttributeAddedCalled = false;
274: private boolean wasAttributeReplacedCalled = false;
275: private boolean wasAttributeRemovedCalled = false;
276:
277: public void attributeAdded(ServletContextAttributeEvent event) {
278: wasAttributeAddedCalled = true;
279: }
280:
281: public void attributeRemoved(ServletContextAttributeEvent event) {
282: wasAttributeRemovedCalled = true;
283: }
284:
285: public void attributeReplaced(ServletContextAttributeEvent event) {
286: wasAttributeReplacedCalled = true;
287: }
288:
289: public void reset() {
290: wasAttributeAddedCalled = false;
291: wasAttributeReplacedCalled = false;
292: wasAttributeRemovedCalled = false;
293: }
294:
295: public boolean wasAttributeAddedCalled() {
296: return wasAttributeAddedCalled;
297: }
298:
299: public boolean wasAttributeRemovedCalled() {
300: return wasAttributeRemovedCalled;
301: }
302:
303: public boolean wasAttributeReplacedCalled() {
304: return wasAttributeReplacedCalled;
305: }
306: }
307:
308: private class TestAttributeOrderListener implements
309: ServletContextAttributeListener {
310: private String addedEventKey;
311: private Object addedEventValue;
312: private String replacedEventKey;
313: private Object replacedEventValue;
314: private String removedEventKey;
315: private Object removedEventValue;
316:
317: public void attributeAdded(ServletContextAttributeEvent event) {
318: addedEventKey = event.getName();
319: addedEventValue = event.getValue();
320: }
321:
322: public void attributeRemoved(ServletContextAttributeEvent event) {
323: removedEventKey = event.getName();
324: removedEventValue = event.getValue();
325: }
326:
327: public void attributeReplaced(ServletContextAttributeEvent event) {
328: replacedEventKey = event.getName();
329: replacedEventValue = event.getValue();
330: }
331:
332: public String getAddedEventKey() {
333: return addedEventKey;
334: }
335:
336: public Object getAddedEventValue() {
337: return addedEventValue;
338: }
339:
340: public String getRemovedEventKey() {
341: return removedEventKey;
342: }
343:
344: public Object getRemovedEventValue() {
345: return removedEventValue;
346: }
347:
348: public String getReplacedEventKey() {
349: return replacedEventKey;
350: }
351:
352: public Object getReplacedEventValue() {
353: return replacedEventValue;
354: }
355: }
356:
357: private class TestRequestDispatcher implements RequestDispatcher {
358:
359: public void forward(ServletRequest request,
360: ServletResponse response) throws ServletException,
361: IOException {
362:
363: }
364:
365: public void include(ServletRequest request,
366: ServletResponse response) throws ServletException,
367: IOException {
368:
369: }
370: }
371: }
|