001 package com.mockrunner.mock.web;
002
003 import java.io.IOException;
004 import java.io.Writer;
005 import java.util.Enumeration;
006 import java.util.HashMap;
007 import java.util.Iterator;
008 import java.util.NoSuchElementException;
009 import java.util.Stack;
010
011 import javax.servlet.RequestDispatcher;
012 import javax.servlet.Servlet;
013 import javax.servlet.ServletConfig;
014 import javax.servlet.ServletContext;
015 import javax.servlet.ServletException;
016 import javax.servlet.ServletRequest;
017 import javax.servlet.ServletResponse;
018 import javax.servlet.http.HttpServletRequest;
019 import javax.servlet.http.HttpSession;
020 import javax.servlet.jsp.JspWriter;
021 import javax.servlet.jsp.PageContext;
022 import javax.servlet.jsp.el.ExpressionEvaluator;
023 import javax.servlet.jsp.el.VariableResolver;
024 import javax.servlet.jsp.tagext.BodyContent;
025
026 /**
027 * Mock implementation of <code>PageContext</code>.
028 */
029 //Some methods of this class were copied from org.apache.struts.mock.MockPageContext
030 //and modified
031 public class MockPageContext extends PageContext
032 {
033 protected ServletConfig config;
034 protected ServletRequest request;
035 protected ServletResponse response;
036 private JspWriter jspWriter;
037 private Stack outStack;
038 private Exception exception;
039 private Object page;
040 private HashMap attributes;
041 private ExpressionEvaluator evaluator;
042 private VariableResolver resolver;
043
044 public MockPageContext()
045 {
046 this(null, null, null);
047 }
048
049 public MockPageContext(ServletConfig config, ServletRequest request, ServletResponse response)
050 {
051 this.config = config;
052 this.request = request;
053 this.response = response;
054 jspWriter = new MockJspWriter();
055 outStack = new Stack();
056 attributes = new HashMap();
057 evaluator = new MockExpressionEvaluator();
058 resolver = new MockVariableResolver();
059 }
060
061 /**
062 * This method allows to set custom implementations
063 * of <code>JspWriter</code>. Per default, {@link MockJspWriter}
064 * is used.
065 * @param jspWriter the <code>JspWriter</code>
066 */
067 public void setJspWriter(JspWriter jspWriter)
068 {
069 this.jspWriter = jspWriter;
070 }
071
072 public void setPage(Object page)
073 {
074 this.page = page;
075 }
076
077 public void setServletConfig(ServletConfig config)
078 {
079 this.config = config;
080 }
081
082 public void setServletRequest(ServletRequest request)
083 {
084 this.request = request;
085 }
086
087 public void setServletResponse(ServletResponse response)
088 {
089 this.response = response;
090 }
091
092 public void setException(Exception exception)
093 {
094 this.exception = exception;
095 }
096
097 public Object findAttribute(String name)
098 {
099 Object value = getAttribute(name, PageContext.PAGE_SCOPE);
100 if(value == null)
101 {
102 value = getAttribute(name, PageContext.REQUEST_SCOPE);
103 }
104 if(value == null)
105 {
106 value = getAttribute(name, PageContext.SESSION_SCOPE);
107 }
108 if(value == null)
109 {
110 value = getAttribute(name, PageContext.APPLICATION_SCOPE);
111 }
112 return value;
113 }
114
115 public Object getAttribute(String name)
116 {
117 return getAttribute(name, PageContext.PAGE_SCOPE);
118 }
119
120 public Object getAttribute(String name, int scope)
121 {
122 if(scope == PageContext.PAGE_SCOPE)
123 {
124 return attributes.get(name);
125 }
126 else if(scope == PageContext.REQUEST_SCOPE)
127 {
128 if(null == request) return null;
129 return request.getAttribute(name);
130 }
131 else if(scope == PageContext.SESSION_SCOPE)
132 {
133 if(null == getSession()) return null;
134 return getSession().getAttribute(name);
135 }
136 else if(scope == PageContext.APPLICATION_SCOPE)
137 {
138 if(null == getServletContext()) return null;
139 return getServletContext().getAttribute(name);
140 }
141 else
142 {
143 throw new IllegalArgumentException("Invalid scope " + scope);
144 }
145 }
146
147 public void removeAttribute(String name)
148 {
149 int scope = getAttributesScope(name);
150 if (scope != 0)
151 {
152 removeAttribute(name, scope);
153 }
154 }
155
156 public void removeAttribute(String name, int scope)
157 {
158 if(scope == PageContext.PAGE_SCOPE)
159 {
160 attributes.remove(name);
161 }
162 else if(scope == PageContext.REQUEST_SCOPE)
163 {
164 if(request != null)
165 {
166 request.removeAttribute(name);
167 }
168 }
169 else if(scope == PageContext.SESSION_SCOPE)
170 {
171 if(getSession() != null)
172 {
173 getSession().removeAttribute(name);
174 }
175 }
176 else if(scope == PageContext.APPLICATION_SCOPE)
177 {
178 if(getServletContext() != null)
179 {
180 getServletContext().removeAttribute(name);
181 }
182 }
183 else
184 {
185 throw new IllegalArgumentException("Invalid scope " + scope);
186 }
187 }
188
189 public void setAttribute(String name, Object value)
190 {
191 setAttribute(name, value, PageContext.PAGE_SCOPE);
192 }
193
194
195 public void setAttribute(String name, Object value, int scope)
196 {
197 if(scope == PageContext.PAGE_SCOPE)
198 {
199 attributes.put(name, value);
200 }
201 else if(scope == PageContext.REQUEST_SCOPE)
202 {
203 if(request != null)
204 {
205 request.setAttribute(name, value);
206 }
207 }
208 else if(scope == PageContext.SESSION_SCOPE)
209 {
210 if(getSession() != null)
211 {
212 getSession().setAttribute(name, value);
213 }
214 }
215 else if(scope == PageContext.APPLICATION_SCOPE)
216 {
217 if(getServletContext() != null)
218 {
219 getServletContext().setAttribute(name, value);
220 }
221 }
222 else
223 {
224 throw new IllegalArgumentException("Invalid scope " + scope);
225 }
226 }
227
228 public int getAttributesScope(String name)
229 {
230 if(getAttribute(name, PageContext.PAGE_SCOPE) != null)
231 {
232 return PageContext.PAGE_SCOPE;
233 }
234 else if(getAttribute(name, PageContext.REQUEST_SCOPE) != null)
235 {
236 return PageContext.REQUEST_SCOPE;
237 }
238 else if(getAttribute(name, PageContext.SESSION_SCOPE) != null)
239 {
240 return PageContext.SESSION_SCOPE;
241 }
242 else if(getAttribute(name, PageContext.APPLICATION_SCOPE) != null)
243 {
244 return PageContext.APPLICATION_SCOPE;
245 }
246 return 0;
247 }
248
249 public Enumeration getAttributeNamesInScope(int scope)
250 {
251 if(scope == PageContext.PAGE_SCOPE)
252 {
253 return new WrappedEnumeration(attributes.keySet().iterator());
254 }
255 else if(scope == PageContext.REQUEST_SCOPE)
256 {
257 if(request == null) return new NullEnumeration();
258 return request.getAttributeNames();
259 }
260 else if(scope == PageContext.SESSION_SCOPE)
261 {
262 if(getSession() == null) return new NullEnumeration();
263 return getSession().getAttributeNames();
264 }
265 else if(scope == PageContext.APPLICATION_SCOPE)
266 {
267 if(getServletContext() == null) return new NullEnumeration();
268 return getServletContext().getAttributeNames();
269 }
270 else
271 {
272 throw new IllegalArgumentException("Invalid scope " + scope);
273 }
274 }
275
276 public JspWriter getOut()
277 {
278 return jspWriter;
279 }
280
281 public Exception getException()
282 {
283 return exception;
284 }
285
286 public Object getPage()
287 {
288 return page;
289 }
290
291 public ServletRequest getRequest()
292 {
293 return request;
294 }
295
296 public ServletResponse getResponse()
297 {
298 return response;
299 }
300
301 public ServletConfig getServletConfig()
302 {
303 return config;
304 }
305
306 public ServletContext getServletContext()
307 {
308 if(null == config) return null;
309 return config.getServletContext();
310 }
311
312
313 public HttpSession getSession()
314 {
315 if(null == request) return null;
316 return ((HttpServletRequest)request).getSession();
317 }
318
319 public void handlePageException(Exception exc)
320 {
321
322 }
323
324 public void handlePageException(Throwable thr)
325 {
326
327 }
328
329 public void forward(String path) throws ServletException, IOException
330 {
331 if(null != request)
332 {
333 RequestDispatcher dispatcher = request.getRequestDispatcher(path);
334 if(null != dispatcher)
335 {
336 dispatcher.forward(request, response);
337 }
338 }
339 }
340
341 public void include(String path) throws ServletException, IOException
342 {
343 if(null != request)
344 {
345 RequestDispatcher dispatcher = request.getRequestDispatcher(path);
346 if(null != dispatcher)
347 {
348 dispatcher.include(request, response);
349 }
350 }
351 }
352
353 public void include(String path, boolean flush) throws ServletException, IOException
354 {
355 if(flush)
356 {
357 jspWriter.flush();
358 }
359 include(path);
360 }
361
362 public void initialize(Servlet servlet, ServletRequest request,
363 ServletResponse response, String errorPageURL,
364 boolean needsSession, int bufferSize,
365 boolean autoFlush)
366 {
367 this.config = servlet.getServletConfig();
368 this.request = request;
369 this.response = response;
370 jspWriter = new MockJspWriter();
371 outStack = new Stack();
372 attributes = new HashMap();
373 }
374
375 public JspWriter popBody()
376 {
377 jspWriter = (JspWriter)outStack.pop();
378 return jspWriter;
379 }
380
381 public BodyContent pushBody()
382 {
383 outStack.push(jspWriter);
384 jspWriter = new MockBodyContent(jspWriter);
385 return (BodyContent)jspWriter;
386 }
387
388 public JspWriter pushBody(Writer writer)
389 {
390 outStack.push(jspWriter);
391 jspWriter = new MockJspWriter(writer);
392 return jspWriter;
393 }
394
395 public void release()
396 {
397 jspWriter = new MockJspWriter();
398 outStack = new Stack();
399 }
400
401 /**
402 * Sets the expression evaluator. The default expression evaluator
403 * is {@link MockExpressionEvaluator}.
404 * @param evaluator the <code>ExpressionEvaluator</code>
405 */
406 public void setExpressionEvaluator(ExpressionEvaluator evaluator)
407 {
408 this.evaluator = evaluator;
409 }
410
411 /**
412 * Sets the variable resolver. The default variable resolver
413 * is {@link MockVariableResolver}.
414 * @param resolver the <code>VariableResolver</code>
415 */
416 public void setVariableResolver(VariableResolver resolver)
417 {
418 this.resolver = resolver;
419 }
420
421 public ExpressionEvaluator getExpressionEvaluator()
422 {
423 return evaluator;
424 }
425
426 public VariableResolver getVariableResolver()
427 {
428 return resolver;
429 }
430
431 private class NullEnumeration implements Enumeration
432 {
433 public boolean hasMoreElements()
434 {
435 return false;
436 }
437
438 public Object nextElement()
439 {
440 throw new NoSuchElementException();
441 }
442 }
443
444 private class WrappedEnumeration implements Enumeration
445 {
446 private Iterator iterator;
447
448 public WrappedEnumeration(Iterator iterator)
449 {
450 this.iterator = iterator;
451 }
452
453 public boolean hasMoreElements()
454 {
455 return iterator.hasNext();
456 }
457
458 public Object nextElement()
459 {
460 return iterator.next();
461 }
462 }
463 }