1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 package org.apache.struts.mock;
22
23 import javax.servlet.Servlet;
24 import javax.servlet.ServletConfig;
25 import javax.servlet.ServletContext;
26 import javax.servlet.ServletRequest;
27 import javax.servlet.ServletResponse;
28 import javax.servlet.http.HttpServletRequest;
29 import javax.servlet.http.HttpSession;
30 import javax.servlet.jsp.JspWriter;
31 import javax.servlet.jsp.PageContext;
32 import javax.servlet.jsp.tagext.BodyContent;
33
34 import java.io.IOException;
35 import java.io.Reader;
36 import java.io.Writer;
37
38 import java.util.Collections;
39 import java.util.Enumeration;
40 import java.util.HashMap;
41
42 /**
43 * <p>Mock <strong>ServletContext</strong> object for low-level unit tests of
44 * Struts controller components. Coarser grained tests should be implemented
45 * in terms of the Cactus framework, instead of the mock object classes.</p>
46 *
47 * <p><strong>WARNING</strong> - Only the minimal set of methods needed to
48 * create unit tests is provided, plus additional methods to configure this
49 * object as necessary. Methods for unsupported operations will throw
50 * <code>UnsupportedOperationException</code>.</p>
51 *
52 * <p><strong>WARNING</strong> - Because unit tests operate in a single
53 * threaded environment, no synchronization is performed.</p>
54 *
55 * @version $Rev: 471754 $ $Date: 2005-05-07 12:45:39 -0400 (Sat, 07 May 2005)
56 * $
57 */
58 public class MockPageContext extends PageContext {
59
60 protected ServletContext application = null;
61 protected HashMap attributes = new HashMap();
62 protected ServletConfig config = null;
63 protected ServletRequest request = null;
64 protected ServletResponse response = null;
65 protected HttpSession session = null;
66 private boolean throwIOException;
67 private boolean returnBodyContent;
68
69
70 public MockPageContext() {
71 super();
72 }
73
74 public MockPageContext(ServletConfig config, ServletRequest request,
75 ServletResponse response) {
76 super();
77 setValues(config, request, response);
78 }
79
80 /**
81 * <p> Construct a new PageContext impl. </p>
82 *
83 * @param throwIOException Determines if the returned JspWriter should
84 * throw an IOException on any method call.
85 * @param returnBody Determines if getOut() should return a new
86 * <code>JspWriter</code> or a <code>BodyContent</code>.
87 */
88 public MockPageContext(boolean throwIOException, boolean returnBody) {
89 this.throwIOException = throwIOException;
90 this.returnBodyContent = returnBody;
91 }
92
93 private void checkAndThrow()
94 throws IOException {
95 if (throwIOException) {
96 throw new IOException();
97 }
98 }
99
100
101 public void setValues(ServletConfig config, ServletRequest request,
102 ServletResponse response) {
103 this.config = config;
104
105 if (config != null) {
106 this.application = config.getServletContext();
107 } else {
108 this.application = null;
109 }
110
111 this.request = request;
112 this.response = response;
113
114 if (request != null) {
115 session = ((HttpServletRequest) request).getSession(false);
116 } else {
117 this.session = null;
118 }
119 }
120
121
122 public Object findAttribute(String name) {
123 Object value = getAttribute(name, PageContext.PAGE_SCOPE);
124
125 if (value == null) {
126 value = getAttribute(name, PageContext.REQUEST_SCOPE);
127 }
128
129 if (value == null) {
130 value = getAttribute(name, PageContext.SESSION_SCOPE);
131 }
132
133 if (value == null) {
134 value = getAttribute(name, PageContext.APPLICATION_SCOPE);
135 }
136
137 return (value);
138 }
139
140 public void forward(String path) {
141 throw new UnsupportedOperationException();
142 }
143
144 public Object getAttribute(String name) {
145 return (getAttribute(name, PageContext.PAGE_SCOPE));
146 }
147
148 public Object getAttribute(String name, int scope) {
149 if (scope == PageContext.PAGE_SCOPE) {
150 return (attributes.get(name));
151 } else if (scope == PageContext.REQUEST_SCOPE) {
152 if (request != null) {
153 return (request.getAttribute(name));
154 }
155
156 return (null);
157 } else if (scope == PageContext.SESSION_SCOPE) {
158 if (session != null) {
159 return (session.getAttribute(name));
160 }
161
162 return (null);
163 } else if (scope == PageContext.APPLICATION_SCOPE) {
164 if (application != null) {
165 return (application.getAttribute(name));
166 }
167
168 return (null);
169 } else {
170 throw new IllegalArgumentException("Invalid scope " + scope);
171 }
172 }
173
174 public Enumeration getAttributeNamesInScope(int scope) {
175 if (scope == PageContext.PAGE_SCOPE) {
176 return (new MockEnumeration(attributes.keySet().iterator()));
177 } else if (scope == PageContext.REQUEST_SCOPE) {
178 if (request != null) {
179 return (request.getAttributeNames());
180 }
181
182 return (new MockEnumeration(Collections.EMPTY_LIST.iterator()));
183 } else if (scope == PageContext.SESSION_SCOPE) {
184 if (session != null) {
185 return (session.getAttributeNames());
186 }
187
188 return (new MockEnumeration(Collections.EMPTY_LIST.iterator()));
189 } else if (scope == PageContext.APPLICATION_SCOPE) {
190 if (application != null) {
191 return (application.getAttributeNames());
192 }
193
194 return new MockEnumeration(Collections.EMPTY_LIST.iterator());
195 } else {
196 throw new IllegalArgumentException("Invalid scope " + scope);
197 }
198 }
199
200 public int getAttributesScope(String name) {
201 if (attributes.get(name) != null) {
202 return (PageContext.PAGE_SCOPE);
203 } else if ((request != null) && (request.getAttribute(name) != null)) {
204 return (PageContext.REQUEST_SCOPE);
205 } else if ((session != null) && (session.getAttribute(name) != null)) {
206 return (PageContext.SESSION_SCOPE);
207 } else if ((application != null)
208 && (application.getAttribute(name) != null)) {
209 return (PageContext.APPLICATION_SCOPE);
210 } else {
211 return (0);
212 }
213 }
214
215 public Exception getException() {
216 throw new UnsupportedOperationException();
217 }
218
219 /**
220 * <p> Custom JspWriter that throws the specified exception (supplied on
221 * the constructor...if any), else it simply returns. </p>
222 */
223 public JspWriter getOut() {
224 JspWriter jspWriter =
225 new JspWriter(0, false) {
226 public void print(String s)
227 throws IOException {
228 checkAndThrow();
229 }
230
231 public void newLine()
232 throws IOException {
233 checkAndThrow();
234 }
235
236 public void print(boolean b)
237 throws IOException {
238 checkAndThrow();
239 }
240
241 public void print(char c)
242 throws IOException {
243 checkAndThrow();
244 }
245
246 public void print(int i)
247 throws IOException {
248 checkAndThrow();
249 }
250
251 public void print(long l)
252 throws IOException {
253 checkAndThrow();
254 }
255
256 public void print(float f)
257 throws IOException {
258 checkAndThrow();
259 }
260
261 public void print(double d)
262 throws IOException {
263 checkAndThrow();
264 }
265
266 public void print(char[] s)
267 throws IOException {
268 checkAndThrow();
269 }
270
271 public void print(Object obj)
272 throws IOException {
273 checkAndThrow();
274 }
275
276 public void println()
277 throws IOException {
278 checkAndThrow();
279 }
280
281 public void println(boolean x)
282 throws IOException {
283 checkAndThrow();
284 }
285
286 public void println(char x)
287 throws IOException {
288 checkAndThrow();
289 }
290
291 public void println(int x)
292 throws IOException {
293 checkAndThrow();
294 }
295
296 public void println(long x)
297 throws IOException {
298 checkAndThrow();
299 }
300
301 public void println(float x)
302 throws IOException {
303 checkAndThrow();
304 }
305
306 public void println(double x)
307 throws IOException {
308 checkAndThrow();
309 }
310
311 public void println(char[] x)
312 throws IOException {
313 checkAndThrow();
314 }
315
316 public void println(String x)
317 throws IOException {
318 checkAndThrow();
319 }
320
321 public void println(Object x)
322 throws IOException {
323 checkAndThrow();
324 }
325
326 public void clear()
327 throws IOException {
328 checkAndThrow();
329 }
330
331 public void clearBuffer()
332 throws IOException {
333 checkAndThrow();
334 }
335
336 public void flush()
337 throws IOException {
338 checkAndThrow();
339 }
340
341 public void close()
342 throws IOException {
343 checkAndThrow();
344 }
345
346 public int getRemaining() {
347 return 0;
348 }
349
350 public void write(char[] cbuf, int off, int len)
351 throws IOException {
352 checkAndThrow();
353 }
354 };
355
356 if (returnBodyContent) {
357 return new BodyContent(jspWriter) {
358 public Reader getReader() {
359 return null;
360 }
361
362 public String getString() {
363 return null;
364 }
365
366 public void writeOut(Writer out)
367 throws IOException {
368 checkAndThrow();
369 }
370
371 public void newLine()
372 throws IOException {
373 checkAndThrow();
374 }
375
376 public void print(boolean b)
377 throws IOException {
378 checkAndThrow();
379 }
380
381 public void print(char c)
382 throws IOException {
383 checkAndThrow();
384 }
385
386 public void print(int i)
387 throws IOException {
388 checkAndThrow();
389 }
390
391 public void print(long l)
392 throws IOException {
393 checkAndThrow();
394 }
395
396 public void print(float f)
397 throws IOException {
398 checkAndThrow();
399 }
400
401 public void print(double d)
402 throws IOException {
403 checkAndThrow();
404 }
405
406 public void print(char[] s)
407 throws IOException {
408 checkAndThrow();
409 }
410
411 public void print(String s)
412 throws IOException {
413 checkAndThrow();
414 }
415
416 public void print(Object obj)
417 throws IOException {
418 checkAndThrow();
419 }
420
421 public void println()
422 throws IOException {
423 checkAndThrow();
424 }
425
426 public void println(boolean x)
427 throws IOException {
428 checkAndThrow();
429 }
430
431 public void println(char x)
432 throws IOException {
433 checkAndThrow();
434 }
435
436 public void println(int x)
437 throws IOException {
438 checkAndThrow();
439 }
440
441 public void println(long x)
442 throws IOException {
443 checkAndThrow();
444 }
445
446 public void println(float x)
447 throws IOException {
448 checkAndThrow();
449 }
450
451 public void println(double x)
452 throws IOException {
453 checkAndThrow();
454 }
455
456 public void println(char[] x)
457 throws IOException {
458 checkAndThrow();
459 }
460
461 public void println(String x)
462 throws IOException {
463 checkAndThrow();
464 }
465
466 public void println(Object x)
467 throws IOException {
468 checkAndThrow();
469 }
470
471 public void clear()
472 throws IOException {
473 checkAndThrow();
474 }
475
476 public void clearBuffer()
477 throws IOException {
478 checkAndThrow();
479 }
480
481 public void close()
482 throws IOException {
483 checkAndThrow();
484 }
485
486 public int getRemaining() {
487 return 0;
488 }
489
490 public void write(char[] cbuf, int off, int len)
491 throws IOException {
492 checkAndThrow();
493 }
494 };
495 }
496
497 return jspWriter;
498 }
499
500 public Object getPage() {
501 throw new UnsupportedOperationException();
502 }
503
504 public ServletRequest getRequest() {
505 return (this.request);
506 }
507
508 public ServletResponse getResponse() {
509 return (this.response);
510 }
511
512 public ServletConfig getServletConfig() {
513 return (this.config);
514 }
515
516 public ServletContext getServletContext() {
517 return (this.application);
518 }
519
520 public HttpSession getSession() {
521 return (this.session);
522 }
523
524 public void handlePageException(Exception e) {
525 throw new UnsupportedOperationException();
526 }
527
528 public void handlePageException(Throwable t) {
529 throw new UnsupportedOperationException();
530 }
531
532 public void include(String path) {
533 throw new UnsupportedOperationException();
534 }
535
536 public void initialize(Servlet servlet, ServletRequest request,
537 ServletResponse response, String errorPageURL, boolean needsSession,
538 int bufferSize, boolean autoFlush) {
539 throw new UnsupportedOperationException();
540 }
541
542 public JspWriter popBody() {
543 throw new UnsupportedOperationException();
544 }
545
546 public BodyContent pushBody() {
547 throw new UnsupportedOperationException();
548 }
549
550 public void release() {
551 throw new UnsupportedOperationException();
552 }
553
554 public void removeAttribute(String name) {
555 int scope = getAttributesScope(name);
556
557 if (scope != 0) {
558 removeAttribute(name, scope);
559 }
560 }
561
562 public void removeAttribute(String name, int scope) {
563 if (scope == PageContext.PAGE_SCOPE) {
564 attributes.remove(name);
565 } else if (scope == PageContext.REQUEST_SCOPE) {
566 if (request != null) {
567 request.removeAttribute(name);
568 }
569 } else if (scope == PageContext.SESSION_SCOPE) {
570 if (session != null) {
571 session.removeAttribute(name);
572 }
573 } else if (scope == PageContext.APPLICATION_SCOPE) {
574 if (application != null) {
575 application.removeAttribute(name);
576 }
577 } else {
578 throw new IllegalArgumentException("Invalid scope " + scope);
579 }
580 }
581
582 public void setAttribute(String name, Object value) {
583 setAttribute(name, value, PageContext.PAGE_SCOPE);
584 }
585
586 public void setAttribute(String name, Object value, int scope) {
587 if (scope == PageContext.PAGE_SCOPE) {
588 attributes.put(name, value);
589 } else if (scope == PageContext.REQUEST_SCOPE) {
590 if (request != null) {
591 request.setAttribute(name, value);
592 }
593 } else if (scope == PageContext.SESSION_SCOPE) {
594 if (session != null) {
595 session.setAttribute(name, value);
596 }
597 } else if (scope == PageContext.APPLICATION_SCOPE) {
598 if (application != null) {
599 application.setAttribute(name, value);
600 }
601 } else {
602 throw new IllegalArgumentException("Invalid scope " + scope);
603 }
604 }
605 }