001 package com.mockrunner.mock.web; 002 003 import java.io.ByteArrayInputStream; 004 import java.io.InputStream; 005 import java.net.MalformedURLException; 006 import java.net.URL; 007 import java.util.ArrayList; 008 import java.util.Collection; 009 import java.util.Collections; 010 import java.util.Enumeration; 011 import java.util.HashMap; 012 import java.util.HashSet; 013 import java.util.List; 014 import java.util.Map; 015 import java.util.Set; 016 import java.util.Vector; 017 018 import javax.servlet.RequestDispatcher; 019 import javax.servlet.Servlet; 020 import javax.servlet.ServletContext; 021 import javax.servlet.ServletContextAttributeEvent; 022 import javax.servlet.ServletContextAttributeListener; 023 import javax.servlet.ServletException; 024 025 import com.mockrunner.util.common.StreamUtil; 026 027 /** 028 * Mock implementation of <code>ServletContext</code>. 029 */ 030 public class MockServletContext implements ServletContext 031 { 032 private Map attributes; 033 private Map requestDispatchers; 034 private Map contexts; 035 private Map initParameters; 036 private Map mimeTypes; 037 private Map realPaths; 038 private Map resources; 039 private Map resourcePaths; 040 private Map resourceStreams; 041 private String servletContextName; 042 private List attributeListener; 043 044 public MockServletContext() 045 { 046 resetAll(); 047 } 048 049 /** 050 * Resets the state of this object to the default values 051 */ 052 public synchronized void resetAll() 053 { 054 attributes = new HashMap(); 055 requestDispatchers = new HashMap(); 056 contexts = new HashMap(); 057 initParameters = new HashMap(); 058 mimeTypes = new HashMap(); 059 realPaths = new HashMap(); 060 resources = new HashMap(); 061 resourcePaths = new HashMap(); 062 resourceStreams = new HashMap(); 063 attributeListener = new ArrayList(); 064 } 065 066 public synchronized void addAttributeListener(ServletContextAttributeListener listener) 067 { 068 attributeListener.add(listener); 069 } 070 071 public synchronized void clearAttributes() 072 { 073 attributes.clear(); 074 } 075 076 public synchronized Object getAttribute(String key) 077 { 078 return attributes.get(key); 079 } 080 081 public synchronized Enumeration getAttributeNames() 082 { 083 Vector attKeys = new Vector(attributes.keySet()); 084 return attKeys.elements(); 085 } 086 087 public synchronized void removeAttribute(String key) 088 { 089 Object value = attributes.get(key); 090 attributes.remove(key); 091 if(null != value) 092 { 093 callAttributeListenersRemovedMethod(key, value); 094 } 095 } 096 097 public synchronized void setAttribute(String key, Object value) 098 { 099 Object oldValue = attributes.get(key); 100 if(null == value) 101 { 102 attributes.remove(key); 103 } 104 else 105 { 106 attributes.put(key, value); 107 } 108 handleAttributeListenerCalls(key, value, oldValue); 109 } 110 111 public synchronized RequestDispatcher getNamedDispatcher(String name) 112 { 113 return getRequestDispatcher(name); 114 } 115 116 public synchronized RequestDispatcher getRequestDispatcher(String path) 117 { 118 RequestDispatcher dispatcher = (RequestDispatcher)requestDispatchers.get(path); 119 if(null == dispatcher) 120 { 121 dispatcher = new MockRequestDispatcher(); 122 setRequestDispatcher(path, dispatcher); 123 } 124 return dispatcher; 125 } 126 127 /** 128 * Returns the map of <code>RequestDispatcher</code> objects. The specified path 129 * maps to the corresponding <code>RequestDispatcher</code> object. 130 * @return the map of <code>RequestDispatcher</code> objects 131 */ 132 public synchronized Map getRequestDispatcherMap() 133 { 134 return Collections.unmodifiableMap(requestDispatchers); 135 } 136 137 /** 138 * Clears the map of <code>RequestDispatcher</code> objects. 139 */ 140 public synchronized void clearRequestDispatcherMap() 141 { 142 requestDispatchers.clear(); 143 } 144 145 /** 146 * Sets a <code>RequestDispatcher</code> that will be returned when calling 147 * {@link #getRequestDispatcher} or {@link #getNamedDispatcher} 148 * with the specified path or name. 149 * If no <code>RequestDispatcher</code> 150 * is set for the specified path, {@link #getRequestDispatcher} and 151 * {@link #getNamedDispatcher} automatically create a new one. 152 * @param path the path for the <code>RequestDispatcher</code> 153 * @param dispatcher the <code>RequestDispatcher</code> object 154 */ 155 public synchronized void setRequestDispatcher(String path, RequestDispatcher dispatcher) 156 { 157 if(dispatcher instanceof MockRequestDispatcher) 158 { 159 ((MockRequestDispatcher)dispatcher).setPath(path); 160 } 161 requestDispatchers.put(path, dispatcher); 162 } 163 164 public synchronized ServletContext getContext(String url) 165 { 166 return (ServletContext)contexts.get(url); 167 } 168 169 public synchronized void setContext(String url, ServletContext context) 170 { 171 contexts.put(url, context); 172 } 173 174 public synchronized void clearInitParameters() 175 { 176 initParameters.clear(); 177 } 178 179 public synchronized String getInitParameter(String name) 180 { 181 return (String)initParameters.get(name); 182 } 183 184 public synchronized void setInitParameter(String name, String value) 185 { 186 initParameters.put(name, value); 187 } 188 189 public synchronized void setInitParameters(Map parameters) 190 { 191 initParameters.putAll(parameters); 192 } 193 194 public synchronized Enumeration getInitParameterNames() 195 { 196 return new Vector(initParameters.keySet()).elements(); 197 } 198 199 public synchronized int getMajorVersion() 200 { 201 return 2; 202 } 203 204 public synchronized int getMinorVersion() 205 { 206 return 3; 207 } 208 209 public synchronized String getMimeType(String file) 210 { 211 return (String)mimeTypes.get(file); 212 } 213 214 public synchronized void setMimeType(String file, String type) 215 { 216 mimeTypes.put(file, type); 217 } 218 219 public synchronized String getRealPath(String path) 220 { 221 return (String)realPaths.get(path); 222 } 223 224 public synchronized void setRealPath(String path, String realPath) 225 { 226 realPaths.put(path, realPath); 227 } 228 229 public synchronized URL getResource(String path) throws MalformedURLException 230 { 231 return (URL)resources.get(path); 232 } 233 234 public synchronized void setResource(String path, URL url) 235 { 236 resources.put(path, url); 237 } 238 239 public synchronized InputStream getResourceAsStream(String path) 240 { 241 byte[] data = (byte[])resourceStreams.get(path); 242 if(null == data) return null; 243 return new ByteArrayInputStream(data); 244 } 245 246 public synchronized void setResourceAsStream(String path, InputStream inputStream) 247 { 248 setResourceAsStream(path, StreamUtil.getStreamAsByteArray(inputStream)); 249 } 250 251 public synchronized void setResourceAsStream(String path, byte[] data) 252 { 253 byte[] copy = (byte[])data.clone(); 254 resourceStreams.put(path, copy); 255 } 256 257 public synchronized Set getResourcePaths(String path) 258 { 259 Set set = (Set)resourcePaths.get(path); 260 if(null == set) return null; 261 return Collections.unmodifiableSet(set); 262 } 263 264 public synchronized void addResourcePaths(String path, Collection pathes) 265 { 266 Set set = (Set)resourcePaths.get(path); 267 if(null == set) 268 { 269 set = new HashSet(); 270 resourcePaths.put(path, set); 271 } 272 set.addAll(pathes); 273 } 274 275 public synchronized void addResourcePath(String path, String resourcePath) 276 { 277 ArrayList list = new ArrayList(); 278 list.add(resourcePath); 279 addResourcePaths(path, list); 280 } 281 282 public synchronized String getServerInfo() 283 { 284 return "Mockrunner Server"; 285 } 286 287 public synchronized Servlet getServlet(String arg0) throws ServletException 288 { 289 return null; 290 } 291 292 public synchronized String getServletContextName() 293 { 294 return servletContextName; 295 } 296 297 public synchronized void setServletContextName(String servletContextName) 298 { 299 this.servletContextName = servletContextName; 300 } 301 302 public synchronized Enumeration getServletNames() 303 { 304 return new Vector().elements(); 305 } 306 307 public synchronized Enumeration getServlets() 308 { 309 return new Vector().elements(); 310 } 311 312 public synchronized void log(Exception exc, String message) 313 { 314 315 } 316 317 public synchronized void log(String message, Throwable exc) 318 { 319 320 } 321 322 public synchronized void log(String message) 323 { 324 325 } 326 327 private synchronized void handleAttributeListenerCalls(String key, Object value, Object oldValue) 328 { 329 if(null != oldValue) 330 { 331 if(value != null) 332 { 333 callAttributeListenersReplacedMethod(key, oldValue); 334 } 335 else 336 { 337 callAttributeListenersRemovedMethod(key, oldValue); 338 } 339 } 340 else 341 { 342 if(value != null) 343 { 344 callAttributeListenersAddedMethod(key, value); 345 } 346 347 } 348 } 349 350 private synchronized void callAttributeListenersAddedMethod(String key, Object value) 351 { 352 for(int ii = 0; ii < attributeListener.size(); ii++) 353 { 354 ServletContextAttributeEvent event = new ServletContextAttributeEvent(this, key, value); 355 ((ServletContextAttributeListener)attributeListener.get(ii)).attributeAdded(event); 356 } 357 } 358 359 private synchronized void callAttributeListenersReplacedMethod(String key, Object value) 360 { 361 for(int ii = 0; ii < attributeListener.size(); ii++) 362 { 363 ServletContextAttributeEvent event = new ServletContextAttributeEvent(this, key, value); 364 ((ServletContextAttributeListener)attributeListener.get(ii)).attributeReplaced(event); 365 } 366 } 367 368 private synchronized void callAttributeListenersRemovedMethod(String key, Object value) 369 { 370 for(int ii = 0; ii < attributeListener.size(); ii++) 371 { 372 ServletContextAttributeEvent event = new ServletContextAttributeEvent(this, key, value); 373 ((ServletContextAttributeListener)attributeListener.get(ii)).attributeRemoved(event); 374 } 375 } 376 }