1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.apache.commons.chain.web.servlet;
17
18
19 import junit.framework.Test;
20 import junit.framework.TestSuite;
21 import org.apache.commons.chain.Context;
22 import org.apache.commons.chain.impl.ContextBaseTestCase;
23 import org.apache.commons.chain.web.WebContext;
24
25 import javax.servlet.ServletContext;
26 import javax.servlet.http.HttpServletRequest;
27 import javax.servlet.http.HttpServletResponse;
28 import javax.servlet.http.HttpSession;
29 import java.util.HashMap;
30 import java.util.Iterator;
31 import java.util.Map;
32 import java.util.Set;
33
34
35 /***
36 * Extension of <code>ContextBaseTestCase</code> to validate the
37 * extra functionality of this implementation.
38 */
39
40 public class ServletWebContextTestCase extends ContextBaseTestCase {
41
42
43
44
45 /***
46 * Construct a new instance of this test case.
47 *
48 * @param name Name of the test case
49 */
50 public ServletWebContextTestCase(String name) {
51 super(name);
52 }
53
54
55
56
57
58
59 protected ServletContext scontext = null;
60 protected HttpServletRequest request = null;
61 protected HttpServletResponse response = null;
62 protected HttpSession session = null;
63
64
65
66
67
68 /***
69 * Set up instance variables required by this test case.
70 */
71 public void setUp() {
72 scontext = new MockServletContext();
73 scontext.setAttribute("akey1", "avalue1");
74 scontext.setAttribute("akey2", "avalue2");
75 scontext.setAttribute("akey3", "avalue3");
76 scontext.setAttribute("akey4", "avalue4");
77 ((MockServletContext) scontext).addInitParameter("ikey1", "ivalue1");
78 ((MockServletContext) scontext).addInitParameter("ikey2", "ivalue2");
79 ((MockServletContext) scontext).addInitParameter("ikey3", "ivalue3");
80 session = new MockHttpSession(scontext);
81 session.setAttribute("skey1", "svalue1");
82 session.setAttribute("skey2", "svalue2");
83 session.setAttribute("skey3", "svalue3");
84 request = new MockHttpServletRequest("/context", "/servlet",
85 "/path/info", "a=b&c=d",
86 session);
87 request.setAttribute("rkey1", "rvalue1");
88 request.setAttribute("rkey2", "rvalue2");
89 ((MockHttpServletRequest) request).addHeader("hkey1", "hvalue1");
90 ((MockHttpServletRequest) request).addHeader("hkey2", "hvalue2a");
91 ((MockHttpServletRequest) request).addHeader("hkey2", "hvalue2b");
92 ((MockHttpServletRequest) request).addParameter("pkey1", "pvalue1");
93 ((MockHttpServletRequest) request).addParameter("pkey2", "pvalue2a");
94 ((MockHttpServletRequest) request).addParameter("pkey2", "pvalue2b");
95 response = new MockHttpServletResponse();
96 context = createContext();
97 }
98
99
100 /***
101 * Return the tests included in this test suite.
102 */
103 public static Test suite() {
104 return (new TestSuite(ServletWebContextTestCase.class));
105 }
106
107
108 /***
109 * Tear down instance variables required by this test case.
110 */
111 public void tearDown() {
112 scontext = null;
113 session = null;
114 request = null;
115 response = null;
116 context = null;
117 }
118
119
120
121
122
123
124 public void testApplicationScope() {
125
126 Map map = ((WebContext) context).getApplicationScope();
127 assertNotNull(map);
128
129
130 checkMapSize(map, 4);
131 assertEquals("avalue1", (String) map.get("akey1"));
132 assertEquals("avalue2", (String) map.get("akey2"));
133 assertEquals("avalue3", (String) map.get("akey3"));
134 assertEquals("avalue4", (String) map.get("akey4"));
135
136
137 checkEntrySet(map, true);
138
139
140 scontext.removeAttribute("akey1");
141 checkMapSize(map, 3);
142 assertNull(map.get("akey1"));
143
144
145 map.remove("akey2");
146 checkMapSize(map, 2);
147 assertNull(scontext.getAttribute("akey2"));
148
149
150 scontext.setAttribute("akeyA", "avalueA");
151 checkMapSize(map, 3);
152 assertEquals("avalueA", (String) map.get("akeyA"));
153
154
155 map.put("akeyB", "avalueB");
156 checkMapSize(map, 4);
157 assertEquals("avalueB", (String) scontext.getAttribute("akeyB"));
158
159
160 scontext.setAttribute("akeyA", "newvalueA");
161 checkMapSize(map, 4);
162 assertEquals("newvalueA", (String) map.get("akeyA"));
163
164
165 map.put("akeyB", "newvalueB");
166 assertEquals(4, map.size());
167 assertEquals("newvalueB", (String) scontext.getAttribute("akeyB"));
168
169
170 map.clear();
171 checkMapSize(map, 0);
172
173 }
174
175
176
177
178 public void testEquals() {
179
180
181
182
183 assertTrue(context.equals(context));
184 assertTrue(context.hashCode() == context.hashCode());
185
186
187 Context other = new ServletWebContext(scontext, request, response);
188
189 assertTrue(context.hashCode() == other.hashCode());
190
191
192 other.put("bop", "bop value");
193
194 assertTrue(context.hashCode() != other.hashCode());
195
196
197 other = new ServletWebContext(scontext, request, response);
198 context.put("bop", "bop value");
199
200 assertTrue(context.hashCode() != other.hashCode());
201
202 }
203
204
205
206 public void testHeader() {
207
208 Map map = ((WebContext) context).getHeader();
209 assertNotNull(map);
210
211
212 checkMapSize(map, 2);
213 assertEquals("hvalue1", (String) map.get("hkey1"));
214 assertEquals("hvalue2a", (String) map.get("hkey2"));
215 assertTrue(map.containsKey("hkey1"));
216 assertTrue(map.containsKey("hkey2"));
217 assertTrue(map.containsValue("hvalue1"));
218 assertTrue(map.containsValue("hvalue2a"));
219
220
221 checkEntrySet(map, false);
222
223
224 try {
225 map.clear();
226 fail("Should have thrown UnsupportedOperationException");
227 } catch (UnsupportedOperationException e) {
228 ;
229 }
230 try {
231 map.put("hkey3", "hvalue3");
232 fail("Should have thrown UnsupportedOperationException");
233 } catch (UnsupportedOperationException e) {
234 ;
235 }
236 try {
237 map.putAll(new HashMap());
238 fail("Should have thrown UnsupportedOperationException");
239 } catch (UnsupportedOperationException e) {
240 ;
241 }
242 try {
243 map.remove("hkey1");
244 fail("Should have thrown UnsupportedOperationException");
245 } catch (UnsupportedOperationException e) {
246 ;
247 }
248
249 }
250
251
252
253 public void testHeaderValues() {
254
255 Map map = ((WebContext) context).getHeaderValues();
256 assertNotNull(map);
257
258
259 checkMapSize(map, 2);
260 Object value1 = map.get("hkey1");
261 assertNotNull(value1);
262 assertTrue(value1 instanceof String[]);
263 String values1[] = (String[]) value1;
264 assertEquals(1, values1.length);
265 assertEquals("hvalue1", values1[0]);
266 Object value2 = map.get("hkey2");
267 assertNotNull(value2);
268 assertTrue(value2 instanceof String[]);
269 String values2[] = (String[]) value2;
270 assertEquals(2, values2.length);
271 assertEquals("hvalue2a", values2[0]);
272 assertEquals("hvalue2b", values2[1]);
273 assertTrue(map.containsKey("hkey1"));
274 assertTrue(map.containsKey("hkey2"));
275 assertTrue(map.containsValue(values1));
276 assertTrue(map.containsValue(values2));
277
278
279 checkEntrySet(map, false);
280
281
282 try {
283 map.clear();
284 fail("Should have thrown UnsupportedOperationException");
285 } catch (UnsupportedOperationException e) {
286 ;
287 }
288 try {
289 map.put("hkey3", values2);
290 fail("Should have thrown UnsupportedOperationException");
291 } catch (UnsupportedOperationException e) {
292 ;
293 }
294 try {
295 map.putAll(new HashMap());
296 fail("Should have thrown UnsupportedOperationException");
297 } catch (UnsupportedOperationException e) {
298 ;
299 }
300 try {
301 map.remove("hkey1");
302 fail("Should have thrown UnsupportedOperationException");
303 } catch (UnsupportedOperationException e) {
304 ;
305 }
306
307 }
308
309
310
311 public void testInitParam() {
312
313 Map map = ((WebContext) context).getInitParam();
314 assertNotNull(map);
315
316
317 checkMapSize(map, 3);
318 assertEquals("ivalue1", (String) map.get("ikey1"));
319 assertEquals("ivalue2", (String) map.get("ikey2"));
320 assertEquals("ivalue3", (String) map.get("ikey3"));
321 assertTrue(map.containsKey("ikey1"));
322 assertTrue(map.containsKey("ikey2"));
323 assertTrue(map.containsKey("ikey3"));
324 assertTrue(map.containsValue("ivalue1"));
325 assertTrue(map.containsValue("ivalue2"));
326 assertTrue(map.containsValue("ivalue3"));
327
328
329 checkEntrySet(map, false);
330
331
332 try {
333 map.clear();
334 fail("Should have thrown UnsupportedOperationException");
335 } catch (UnsupportedOperationException e) {
336 ;
337 }
338 try {
339 map.put("ikey4", "ivalue4");
340 fail("Should have thrown UnsupportedOperationException");
341 } catch (UnsupportedOperationException e) {
342 ;
343 }
344 try {
345 map.putAll(new HashMap());
346 fail("Should have thrown UnsupportedOperationException");
347 } catch (UnsupportedOperationException e) {
348 ;
349 }
350 try {
351 map.remove("ikey1");
352 fail("Should have thrown UnsupportedOperationException");
353 } catch (UnsupportedOperationException e) {
354 ;
355 }
356
357 }
358
359
360
361 public void testParam() {
362
363 Map map = ((WebContext) context).getParam();
364 assertNotNull(map);
365
366
367 checkMapSize(map, 2);
368 assertEquals("pvalue1", (String) map.get("pkey1"));
369 assertEquals("pvalue2a", (String) map.get("pkey2"));
370 assertTrue(map.containsKey("pkey1"));
371 assertTrue(map.containsKey("pkey2"));
372 assertTrue(map.containsValue("pvalue1"));
373 assertTrue(map.containsValue("pvalue2a"));
374
375 checkEntrySet(map, false);
376
377
378 try {
379 map.clear();
380 fail("Should have thrown UnsupportedOperationException");
381 } catch (UnsupportedOperationException e) {
382 ;
383 }
384 try {
385 map.put("pkey3", "pvalue3");
386 fail("Should have thrown UnsupportedOperationException");
387 } catch (UnsupportedOperationException e) {
388 ;
389 }
390 try {
391 map.putAll(new HashMap());
392 fail("Should have thrown UnsupportedOperationException");
393 } catch (UnsupportedOperationException e) {
394 ;
395 }
396 try {
397 map.remove("pkey1");
398 fail("Should have thrown UnsupportedOperationException");
399 } catch (UnsupportedOperationException e) {
400 ;
401 }
402
403 }
404
405
406
407 public void testParamValues() {
408
409 Map map = ((WebContext) context).getParamValues();
410 assertNotNull(map);
411
412
413 checkMapSize(map, 2);
414 Object value1 = map.get("pkey1");
415 assertNotNull(value1);
416 assertTrue(value1 instanceof String[]);
417 String values1[] = (String[]) value1;
418 assertEquals(1, values1.length);
419 assertEquals("pvalue1", values1[0]);
420 Object value2 = map.get("pkey2");
421 assertNotNull(value2);
422 assertTrue(value2 instanceof String[]);
423 String values2[] = (String[]) value2;
424 assertEquals(2, values2.length);
425 assertEquals("pvalue2a", values2[0]);
426 assertEquals("pvalue2b", values2[1]);
427 assertTrue(map.containsKey("pkey1"));
428 assertTrue(map.containsKey("pkey2"));
429 assertTrue(map.containsValue(values1));
430 assertTrue(map.containsValue(values2));
431
432
433 try {
434 map.clear();
435 fail("Should have thrown UnsupportedOperationException");
436 } catch (UnsupportedOperationException e) {
437 ;
438 }
439 try {
440 map.put("pkey3", values2);
441 fail("Should have thrown UnsupportedOperationException");
442 } catch (UnsupportedOperationException e) {
443 ;
444 }
445 try {
446 map.putAll(new HashMap());
447 fail("Should have thrown UnsupportedOperationException");
448 } catch (UnsupportedOperationException e) {
449 ;
450 }
451 try {
452 map.remove("pkey1");
453 fail("Should have thrown UnsupportedOperationException");
454 } catch (UnsupportedOperationException e) {
455 ;
456 }
457
458 }
459
460
461
462 public void testPristine() {
463
464 super.testPristine();
465 ServletWebContext swcontext = (ServletWebContext) context;
466
467
468 assertNotNull(swcontext.getApplicationScope());
469 assertNotNull(swcontext.getHeader());
470 assertNotNull(swcontext.getHeaderValues());
471 assertNotNull(swcontext.getInitParam());
472 assertNotNull(swcontext.getParam());
473 assertNotNull(swcontext.getParamValues());
474 assertNotNull(swcontext.getRequestScope());
475 assertNotNull(swcontext.getSessionScope());
476
477
478 assertTrue(swcontext.getApplicationScope() ==
479 swcontext.get("applicationScope"));
480 assertTrue(swcontext.getHeader() ==
481 swcontext.get("header"));
482 assertTrue(swcontext.getHeaderValues() ==
483 swcontext.get("headerValues"));
484 assertTrue(swcontext.getInitParam() ==
485 swcontext.get("initParam"));
486 assertTrue(swcontext.getParam() ==
487 swcontext.get("param"));
488 assertTrue(swcontext.getParamValues() ==
489 swcontext.get("paramValues"));
490 assertTrue(swcontext.getRequestScope() ==
491 swcontext.get("requestScope"));
492 assertTrue(swcontext.getSessionScope() ==
493 swcontext.get("sessionScope"));
494
495 }
496
497
498
499 public void testRelease() {
500
501 ServletWebContext swcontext = (ServletWebContext) context;
502 swcontext.release();
503
504
505 assertNull(swcontext.getApplicationScope());
506 assertNull(swcontext.getHeader());
507 assertNull(swcontext.getHeaderValues());
508 assertNull(swcontext.getInitParam());
509 assertNull(swcontext.getParam());
510 assertNull(swcontext.getParamValues());
511 assertNull(swcontext.getRequestScope());
512 assertNull(swcontext.getSessionScope());
513
514
515 assertNull(swcontext.get("applicationScope"));
516 assertNull(swcontext.get("header"));
517 assertNull(swcontext.get("headerValues"));
518 assertNull(swcontext.get("initParam"));
519 assertNull(swcontext.get("param"));
520 assertNull(swcontext.get("paramValues"));
521 assertNull(swcontext.get("requestScope"));
522 assertNull(swcontext.get("sessionScope"));
523
524 }
525
526
527
528 public void testRequestScope() {
529
530 Map map = ((WebContext) context).getRequestScope();
531 assertNotNull(map);
532
533
534 checkMapSize(map, 2);
535 assertEquals("rvalue1", (String) map.get("rkey1"));
536 assertEquals("rvalue2", (String) map.get("rkey2"));
537
538
539 checkEntrySet(map, true);
540
541
542 request.removeAttribute("rkey1");
543 checkMapSize(map, 1);
544 assertNull(map.get("rkey1"));
545
546
547 map.remove("rkey2");
548 checkMapSize(map, 0);
549 assertNull(request.getAttribute("rkey2"));
550
551
552 request.setAttribute("rkeyA", "rvalueA");
553 checkMapSize(map, 1);
554 assertEquals("rvalueA", (String) map.get("rkeyA"));
555
556
557 map.put("rkeyB", "rvalueB");
558 checkMapSize(map, 2);
559 assertEquals("rvalueB", (String) request.getAttribute("rkeyB"));
560
561
562 request.setAttribute("rkeyA", "newvalueA");
563 checkMapSize(map, 2);
564 assertEquals("newvalueA", (String) map.get("rkeyA"));
565
566
567 map.put("rkeyB", "newvalueB");
568 checkMapSize(map, 2);
569 assertEquals("newvalueB", (String) request.getAttribute("rkeyB"));
570
571
572 map.clear();
573 checkMapSize(map, 0);
574
575 }
576
577
578
579 public void testSessionScope() {
580
581 Map map = ((WebContext) context).getSessionScope();
582 assertNotNull(map);
583
584
585 checkMapSize(map, 3);
586 assertEquals("svalue1", (String) map.get("skey1"));
587 assertEquals("svalue2", (String) map.get("skey2"));
588 assertEquals("svalue3", (String) map.get("skey3"));
589
590
591 checkEntrySet(map, true);
592
593
594 session.removeAttribute("skey1");
595 checkMapSize(map, 2);
596 assertNull(map.get("skey1"));
597
598
599 map.remove("skey2");
600 checkMapSize(map, 1);
601 assertNull(session.getAttribute("skey2"));
602
603
604 session.setAttribute("skeyA", "svalueA");
605 checkMapSize(map, 2);
606 assertEquals("svalueA", (String) map.get("skeyA"));
607
608
609 map.put("skeyB", "svalueB");
610 checkMapSize(map, 3);
611 assertEquals("svalueB", (String) session.getAttribute("skeyB"));
612
613
614 session.setAttribute("skeyA", "newvalueA");
615 checkMapSize(map, 3);
616 assertEquals("newvalueA", (String) map.get("skeyA"));
617
618
619 map.put("skeyB", "newvalueB");
620 checkMapSize(map, 3);
621 assertEquals("newvalueB", (String) session.getAttribute("skeyB"));
622
623
624 map.clear();
625 checkMapSize(map, 0);
626
627 }
628
629
630
631
632
633 protected void checkMapSize(Map map, int size) {
634
635 assertEquals(size, map.size());
636
637 int nk = 0;
638 Iterator keys = map.keySet().iterator();
639 while (keys.hasNext()) {
640 keys.next();
641 nk++;
642 }
643 assertEquals(size, nk);
644
645 int nv = 0;
646 Iterator values = map.entrySet().iterator();
647 while (values.hasNext()) {
648 values.next();
649 nv++;
650 }
651 assertEquals(size, nv);
652
653 assertEquals(size, map.values().size());
654 }
655
656
657 protected void checkEntrySet(Map map, boolean modifiable) {
658 assertTrue(map.size() > 1);
659 Set entries = map.entrySet();
660 assertTrue(map.size() == entries.size());
661 Object o = entries.iterator().next();
662
663 assertTrue(o instanceof Map.Entry);
664
665 if (!modifiable) {
666 try {
667 ((Map.Entry)o).setValue(new Object());
668 fail("Should have thrown UnsupportedOperationException");
669 } catch (UnsupportedOperationException e) {
670 ;
671 }
672 } else {
673
674 Map.Entry e = (Map.Entry)o;
675 e.setValue(e.setValue(new Object()));
676 }
677 }
678
679
680 protected Context createContext() {
681 return (new ServletWebContext(scontext, request, response));
682 }
683
684
685 }