Save This Page
1 /*
2 * ========================================================================
3 *
4 * Copyright 2003-2004 The Apache Software Foundation.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * ========================================================================
19 */
20 package org.apache.cactus.integration.ant.deployment.webapp;
21
22 import java.io.ByteArrayInputStream;
23 import java.util.Iterator;
24
25 import javax.xml.parsers.DocumentBuilder;
26 import javax.xml.parsers.DocumentBuilderFactory;
27 import javax.xml.parsers.ParserConfigurationException;
28
29 import junit.framework.TestCase;
30
31 import org.w3c.dom.Document;
32 import org.w3c.dom.Element;
33
34 /**
35 * Unit tests for {@link WebXmlMerger}.
36 *
37 * TODO: we need more tests for the security sections and the various references
38 *
39 * @version $Id: TestWebXmlMerger.java,v 1.1 2004/05/31 20:05:21 vmassol Exp $
40 */
41 public final class TestWebXmlMerger extends TestCase
42 {
43 /**
44 * The document builder factory.
45 */
46 private DocumentBuilderFactory factory;
47
48 /**
49 * The JAXP document builder.
50 */
51 private DocumentBuilder builder;
52
53 /**
54 * @see TestCase#setUp
55 */
56 public void setUp() throws ParserConfigurationException
57 {
58 factory = DocumentBuilderFactory.newInstance();
59 factory.setValidating(false);
60 factory.setNamespaceAware(false);
61
62 builder = factory.newDocumentBuilder();
63 }
64
65 /**
66 * Tests whether a single filter is correctly merged into an empty
67 * descriptor.
68 *
69 * @throws Exception If an unexpected error occurs
70 */
71 public void testMergeOneFilterIntoEmptyDocument() throws Exception
72 {
73 String srcXml = "<web-app></web-app>";
74 Document srcDoc =
75 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
76 WebXml srcWebXml = new WebXml(srcDoc);
77 String mergeXml = "<web-app>"
78 + " <filter>"
79 + " <filter-name>f1</filter-name>"
80 + " <filter-class>fclass1</filter-class>"
81 + " </filter>"
82 + "</web-app>";
83 Document mergeDoc =
84 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
85 WebXml mergeWebXml = new WebXml(mergeDoc);
86 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
87 merger.mergeFilters(mergeWebXml);
88 assertTrue(srcWebXml.hasFilter("f1"));
89 }
90
91 /**
92 * Tests whether a single context param is correctly merged into an empty
93 * descriptor.
94 *
95 * @throws Exception If an unexpected error occurs
96 */
97 public void testMergeOneContextParamIntoEmptyDocument() throws Exception
98 {
99 String srcXml = "<web-app></web-app>";
100 Document srcDoc =
101 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
102 WebXml srcWebXml = new WebXml(srcDoc);
103 String mergeXml = "<web-app>"
104 + " <context-param>"
105 + " <param-name>param</param-name>"
106 + " <param-value>value</param-value>"
107 + " </context-param>"
108 + "</web-app>";
109 Document mergeDoc =
110 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
111 WebXml mergeWebXml = new WebXml(mergeDoc);
112 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
113 merger.mergeContextParams(mergeWebXml);
114 assertTrue(srcWebXml.hasContextParam("param"));
115 }
116
117 /**
118 * Tests whether a single filter is correctly merged into a descriptor that
119 * already contains another filter.
120 *
121 * @throws Exception If an unexpected error occurs
122 */
123 public void testMergeOneFilterIntoDocumentWithAnotherFilter()
124 throws Exception
125 {
126 String srcXml = "<web-app>"
127 + " <filter>"
128 + " <filter-name>f1</filter-name>"
129 + " <filter-class>fclass1</filter-class>"
130 + " </filter>"
131 + "</web-app>";
132 Document srcDoc =
133 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
134 WebXml srcWebXml = new WebXml(srcDoc);
135 String mergeXml = "<web-app>"
136 + " <filter>"
137 + " <filter-name>f2</filter-name>"
138 + " <filter-class>fclass2</filter-class>"
139 + " </filter>"
140 + "</web-app>";
141 Document mergeDoc =
142 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
143 WebXml mergeWebXml = new WebXml(mergeDoc);
144 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
145 merger.mergeFilters(mergeWebXml);
146 assertTrue(srcWebXml.hasFilter("f1"));
147 assertTrue(srcWebXml.hasFilter("f2"));
148 }
149
150 /**
151 * Tests whether a single context param is correctly merged into a
152 * descriptor that already contains another context param.
153 *
154 * @throws Exception If an unexpected error occurs
155 */
156 public void testMergeOneContextParamIntoDocumentWithAnotherContextParam()
157 throws Exception
158 {
159 String srcXml = "<web-app>"
160 + " <context-param>"
161 + " <param-name>param1</param-name>"
162 + " <param-value>value1</param-value>"
163 + " </context-param>"
164 + "</web-app>";
165 Document srcDoc =
166 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
167 WebXml srcWebXml = new WebXml(srcDoc);
168 String mergeXml = "<web-app>"
169 + " <context-param>"
170 + " <param-name>param2</param-name>"
171 + " <param-value>value2</param-value>"
172 + " </context-param>"
173 + "</web-app>";
174 Document mergeDoc =
175 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
176 WebXml mergeWebXml = new WebXml(mergeDoc);
177 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
178 merger.mergeContextParams(mergeWebXml);
179 assertTrue(srcWebXml.hasContextParam("param1"));
180 assertTrue(srcWebXml.hasContextParam("param2"));
181 }
182
183 /**
184 * Tests whether a single filter in the merge descriptor is ignored because
185 * a filter with the same name already exists in the source descriptor.
186 *
187 * @throws Exception If an unexpected error occurs
188 */
189 public void testMergeOneFilterIntoDocumentWithSameFilter()
190 throws Exception
191 {
192 String srcXml = "<web-app>"
193 + " <filter>"
194 + " <filter-name>f1</filter-name>"
195 + " <filter-class>fclass1</filter-class>"
196 + " </filter>"
197 + "</web-app>";
198 Document srcDoc =
199 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
200 WebXml srcWebXml = new WebXml(srcDoc);
201 String mergeXml = srcXml;
202 Document mergeDoc =
203 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
204 WebXml mergeWebXml = new WebXml(mergeDoc);
205 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
206 merger.mergeFilters(mergeWebXml);
207 assertTrue(srcWebXml.hasFilter("f1"));
208 }
209
210 /**
211 * Tests whether a single context param in the merge descriptor is ignored
212 * because a context param with the same name already exists in the source
213 * descriptor.
214 *
215 * @throws Exception If an unexpected error occurs
216 */
217 public void testMergeOneContextParamIntoDocumentWithSameContextParam()
218 throws Exception
219 {
220 String srcXml = "<web-app>"
221 + " <context-param>"
222 + " <param-name>param</param-name>"
223 + " <param-value>value</param-value>"
224 + " </context-param>"
225 + "</web-app>";
226 Document srcDoc =
227 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
228 WebXml srcWebXml = new WebXml(srcDoc);
229 String mergeXml = srcXml;
230 Document mergeDoc =
231 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
232 WebXml mergeWebXml = new WebXml(mergeDoc);
233 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
234 merger.mergeContextParams(mergeWebXml);
235 assertTrue(srcWebXml.hasContextParam("param"));
236 }
237
238 /**
239 * Tests whether a filter initialization parameter is merged into the
240 * descriptor.
241 *
242 * @throws Exception If an unexpected error occurs
243 */
244 public void testMergeOneFilterIntoDocumentWithSameFilterAndParam()
245 throws Exception
246 {
247 String srcXml = "<web-app>"
248 + " <filter>"
249 + " <filter-name>f1</filter-name>"
250 + " <filter-class>fclass1</filter-class>"
251 + " </filter>"
252 + "</web-app>";
253 Document srcDoc =
254 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
255 WebXml srcWebXml = new WebXml(srcDoc);
256 String mergeXml = "<web-app>"
257 + " <filter>"
258 + " <filter-name>f1</filter-name>"
259 + " <filter-class>fclass1</filter-class>"
260 + " <init-param>"
261 + " <param-name>f1param1</param-name>"
262 + " <param-value>f1param1value</param-value>"
263 + " </init-param>"
264 + " </filter>"
265 + "</web-app>";
266 Document mergeDoc =
267 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
268 WebXml mergeWebXml = new WebXml(mergeDoc);
269 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
270 merger.mergeFilters(mergeWebXml);
271 assertTrue(srcWebXml.hasFilter("f1"));
272 Iterator initParams = srcWebXml.getFilterInitParamNames("f1");
273 assertEquals("f1param1", initParams.next());
274 assertTrue(!initParams.hasNext());
275 }
276
277 /**
278 * Tests whether a single filter is correctly merged into a descriptor that
279 * already contains multiple other filter definitions.
280 *
281 * @throws Exception If an unexpected error occurs
282 */
283 public void testMergeOneFilterIntoDocumentWithMultipleFilters()
284 throws Exception
285 {
286 String srcXml = "<web-app>"
287 + " <filter>"
288 + " <filter-name>f1</filter-name>"
289 + " <filter-class>fclass1</filter-class>"
290 + " </filter>"
291 + " <filter>"
292 + " <filter-name>f2</filter-name>"
293 + " <filter-class>fclass2</filter-class>"
294 + " </filter>"
295 + " <filter>"
296 + " <filter-name>f3</filter-name>"
297 + " <filter-class>fclass3</filter-class>"
298 + " </filter>"
299 + "</web-app>";
300 Document srcDoc =
301 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
302 WebXml srcWebXml = new WebXml(srcDoc);
303 String mergeXml = "<web-app>"
304 + " <filter>"
305 + " <filter-name>f4</filter-name>"
306 + " <filter-class>fclass4</filter-class>"
307 + " </filter>"
308 + "</web-app>";
309 Document mergeDoc =
310 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
311 WebXml mergeWebXml = new WebXml(mergeDoc);
312 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
313 merger.mergeFilters(mergeWebXml);
314 Iterator filterNames = srcWebXml.getFilterNames();
315 assertEquals("f1", filterNames.next());
316 assertEquals("f2", filterNames.next());
317 assertEquals("f3", filterNames.next());
318 assertEquals("f4", filterNames.next());
319 assertTrue(!filterNames.hasNext());
320 }
321
322 /**
323 * Tests whether multiple filters are correctly merged into an empty
324 * descriptor.
325 *
326 * @throws Exception If an unexpected error occurs
327 */
328 public void testMergeMultipleFiltersIntoEmptyDocument() throws Exception
329 {
330 String srcXml = "<web-app></web-app>";
331 Document srcDoc =
332 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
333 WebXml srcWebXml = new WebXml(srcDoc);
334 String mergeXml = "<web-app>"
335 + " <filter>"
336 + " <filter-name>f1</filter-name>"
337 + " <filter-class>fclass1</filter-class>"
338 + " </filter>"
339 + " <filter>"
340 + " <filter-name>f2</filter-name>"
341 + " <filter-class>fclass2</filter-class>"
342 + " </filter>"
343 + " <filter>"
344 + " <filter-name>f3</filter-name>"
345 + " <filter-class>fclass3</filter-class>"
346 + " </filter>"
347 + "</web-app>";
348 Document mergeDoc =
349 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
350 WebXml mergeWebXml = new WebXml(mergeDoc);
351 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
352 merger.mergeFilters(mergeWebXml);
353 Iterator filterNames = srcWebXml.getFilterNames();
354 assertEquals("f1", filterNames.next());
355 assertEquals("f2", filterNames.next());
356 assertEquals("f3", filterNames.next());
357 assertTrue(!filterNames.hasNext());
358 }
359
360 /**
361 * Tests whether a filter with one mapping is correctly merged into an empty
362 * descriptor.
363 *
364 * @throws Exception If an unexpected error occurs
365 */
366 public void testMergeOneFilterWithOneMappingIntoEmptyDocument()
367 throws Exception
368 {
369 String srcXml = "<web-app></web-app>";
370 Document srcDoc =
371 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
372 WebXml srcWebXml = new WebXml(srcDoc);
373 String mergeXml = "<web-app>"
374 + " <filter>"
375 + " <filter-name>f1</filter-name>"
376 + " <filter-class>fclass1</filter-class>"
377 + " </filter>"
378 + " <filter-mapping>"
379 + " <filter-name>f1</filter-name>"
380 + " <url-pattern>/f1mapping1</url-pattern>"
381 + " </filter-mapping>"
382 + "</web-app>";
383 Document mergeDoc =
384 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
385 WebXml mergeWebXml = new WebXml(mergeDoc);
386 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
387 merger.mergeFilters(mergeWebXml);
388 assertTrue(srcWebXml.hasFilter("f1"));
389 Iterator filterMappings = srcWebXml.getFilterMappings("f1");
390 assertEquals("/f1mapping1", filterMappings.next());
391 assertTrue(!filterMappings.hasNext());
392 }
393
394 /**
395 * Tests wether a single filter with multiple mappings is correctly merged
396 * into an empty descriptor.
397 *
398 * @throws Exception If an unexpected error occurs
399 */
400 public void testMergeOneFilterWithMultipleMappingsIntoEmptyDocument()
401 throws Exception
402 {
403 String srcXml = "<web-app></web-app>";
404 Document srcDoc =
405 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
406 WebXml srcWebXml = new WebXml(srcDoc);
407 String mergeXml = "<web-app>"
408 + " <filter>"
409 + " <filter-name>f1</filter-name>"
410 + " <filter-class>fclass1</filter-class>"
411 + " </filter>"
412 + " <filter-mapping>"
413 + " <filter-name>f1</filter-name>"
414 + " <url-pattern>/f1mapping1</url-pattern>"
415 + " </filter-mapping>"
416 + " <filter-mapping>"
417 + " <filter-name>f1</filter-name>"
418 + " <url-pattern>/f1mapping2</url-pattern>"
419 + " </filter-mapping>"
420 + " <filter-mapping>"
421 + " <filter-name>f1</filter-name>"
422 + " <url-pattern>/f1mapping3</url-pattern>"
423 + " </filter-mapping>"
424 + "</web-app>";
425 Document mergeDoc =
426 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
427 WebXml mergeWebXml = new WebXml(mergeDoc);
428 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
429 merger.mergeFilters(mergeWebXml);
430 assertTrue(srcWebXml.hasFilter("f1"));
431 Iterator filterMappings = srcWebXml.getFilterMappings("f1");
432 assertEquals("/f1mapping1", filterMappings.next());
433 assertEquals("/f1mapping2", filterMappings.next());
434 assertEquals("/f1mapping3", filterMappings.next());
435 assertTrue(!filterMappings.hasNext());
436 }
437
438 /**
439 * Tests whether a single servlet is correctly merged into an empty
440 * descriptor.
441 *
442 * @throws Exception If an unexpected error occurs
443 */
444 public void testMergeOneServletIntoEmptyDocument() throws Exception
445 {
446 String srcXml = "<web-app></web-app>";
447 Document srcDoc =
448 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
449 WebXml srcWebXml = new WebXml(srcDoc);
450 String mergeXml = "<web-app>"
451 + " <servlet>"
452 + " <servlet-name>s1</servlet-name>"
453 + " <servlet-class>sclass1</servlet-class>"
454 + " </servlet>"
455 + "</web-app>";
456 Document mergeDoc =
457 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
458 WebXml mergeWebXml = new WebXml(mergeDoc);
459 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
460 merger.mergeServlets(mergeWebXml);
461 assertTrue(srcWebXml.hasServlet("s1"));
462 }
463
464 /**
465 * Tests whether a single servlet is correctly merged into a descriptor that
466 * already contains the definition of an other servlet.
467 *
468 * @throws Exception If an unexpected error occurs
469 */
470 public void testMergeOneServletIntoDocumentWithAnotherServlet()
471 throws Exception
472 {
473 String srcXml = "<web-app>"
474 + " <servlet>"
475 + " <servlet-name>s1</servlet-name>"
476 + " <servlet-class>sclass1</servlet-class>"
477 + " </servlet>"
478 + "</web-app>";
479 Document srcDoc =
480 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
481 WebXml srcWebXml = new WebXml(srcDoc);
482 String mergeXml = "<web-app>"
483 + " <servlet>"
484 + " <servlet-name>s2</servlet-name>"
485 + " <servlet-class>sclass2</servlet-class>"
486 + " </servlet>"
487 + "</web-app>";
488 Document mergeDoc =
489 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
490 WebXml mergeWebXml = new WebXml(mergeDoc);
491 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
492 merger.mergeServlets(mergeWebXml);
493 assertTrue(srcWebXml.hasServlet("s1"));
494 assertTrue(srcWebXml.hasServlet("s2"));
495 }
496
497 /**
498 * Tests whether a single servlet is correctly merged into a descriptor that
499 * already contains the definition of a servlet with the same name.
500 *
501 * @throws Exception If an unexpected error occurs
502 */
503 public void testMergeOneServletIntoDocumentWithSameServlet()
504 throws Exception
505 {
506 String srcXml = "<web-app>"
507 + " <servlet>"
508 + " <servlet-name>s1</servlet-name>"
509 + " <servlet-class>sclass1</servlet-class>"
510 + " </servlet>"
511 + "</web-app>";
512 Document srcDoc =
513 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
514 WebXml srcWebXml = new WebXml(srcDoc);
515 String mergeXml = "<web-app>"
516 + " <servlet>"
517 + " <servlet-name>s1</servlet-name>"
518 + " <servlet-class>sclass1</servlet-class>"
519 + " </servlet>"
520 + "</web-app>";
521 Document mergeDoc =
522 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
523 WebXml mergeWebXml = new WebXml(mergeDoc);
524 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
525 merger.mergeServlets(mergeWebXml);
526 assertTrue(srcWebXml.hasServlet("s1"));
527 }
528
529 /**
530 * Tets whether a servlet with an initialization parameter is correctly
531 * merged into a descriptor that contains the definition of a servlet with
532 * the same name.
533 *
534 * @throws Exception If an unexpected error occurs
535 */
536 public void testMergeOneServletIntoDocumentWithSameServletAndParam()
537 throws Exception
538 {
539 String srcXml = "<web-app>"
540 + " <servlet>"
541 + " <servlet-name>s1</servlet-name>"
542 + " <servlet-class>sclass1</servlet-class>"
543 + " </servlet>"
544 + "</web-app>";
545 Document srcDoc =
546 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
547 WebXml srcWebXml = new WebXml(srcDoc);
548 String mergeXml = "<web-app>"
549 + " <servlet>"
550 + " <servlet-name>s1</servlet-name>"
551 + " <servlet-class>sclass1</servlet-class>"
552 + " <init-param>"
553 + " <param-name>s1param1</param-name>"
554 + " <param-value>s1param1value</param-value>"
555 + " </init-param>"
556 + " </servlet>"
557 + "</web-app>";
558 Document mergeDoc =
559 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
560 WebXml mergeWebXml = new WebXml(mergeDoc);
561 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
562 merger.mergeServlets(mergeWebXml);
563 assertTrue(srcWebXml.hasServlet("s1"));
564 Iterator initParams = srcWebXml.getServletInitParamNames("s1");
565 assertEquals("s1param1", initParams.next());
566 assertTrue(!initParams.hasNext());
567 assertEquals("s1param1value",
568 srcWebXml.getServletInitParam("s1", "s1param1"));
569 }
570
571 /**
572 * Tests whether a single servlet is correctly merged into a descriptor with
573 * multiple servlets.
574 *
575 * @throws Exception If an unexpected error occurs
576 */
577 public void testMergeOneServletIntoDocumentWithMultipleServlets()
578 throws Exception
579 {
580 String srcXml = "<web-app>"
581 + " <servlet>"
582 + " <servlet-name>s1</servlet-name>"
583 + " <servlet-class>sclass1</servlet-class>"
584 + " </servlet>"
585 + " <servlet>"
586 + " <servlet-name>s2</servlet-name>"
587 + " <servlet-class>sclass2</servlet-class>"
588 + " </servlet>"
589 + " <servlet>"
590 + " <servlet-name>s3</servlet-name>"
591 + " <servlet-class>sclass3</servlet-class>"
592 + " </servlet>"
593 + "</web-app>";
594 Document srcDoc =
595 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
596 WebXml srcWebXml = new WebXml(srcDoc);
597 String mergeXml = "<web-app>"
598 + " <servlet>"
599 + " <servlet-name>s4</servlet-name>"
600 + " <servlet-class>sclass4</servlet-class>"
601 + " </servlet>"
602 + "</web-app>";
603 Document mergeDoc =
604 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
605 WebXml mergeWebXml = new WebXml(mergeDoc);
606 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
607 merger.mergeServlets(mergeWebXml);
608 Iterator servletNames = srcWebXml.getServletNames();
609 assertEquals("s1", servletNames.next());
610 assertEquals("s2", servletNames.next());
611 assertEquals("s3", servletNames.next());
612 assertEquals("s4", servletNames.next());
613 assertTrue(!servletNames.hasNext());
614 }
615
616 /**
617 * Verifies that servlet init parameters are added after the load-on-startup
618 * element of an already existing servlet definition.
619 *
620 * @throws Exception If an unexpected error occurs
621 */
622 public void testMergingServletWithInitParamsThatIsAlreadyDefined()
623 throws Exception
624 {
625 String srcXml = "<web-app>".trim()
626 + " <servlet>".trim()
627 + " <servlet-name>s1</servlet-name>".trim()
628 + " <servlet-class>sclass1</servlet-class>".trim()
629 + " <load-on-startup>1</load-on-startup>".trim()
630 + " </servlet>".trim()
631 + "</web-app>";
632 Document srcDoc =
633 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
634 WebXml srcWebXml = new WebXml(srcDoc);
635 String mergeXml = "<web-app>"
636 + " <servlet>".trim()
637 + " <servlet-name>s1</servlet-name>".trim()
638 + " <servlet-class>sclass1</servlet-class>".trim()
639 + " <init-param>".trim()
640 + " <param-name>s1param1</param-name>".trim()
641 + " <param-value>s1param1value</param-value>".trim()
642 + " </init-param>".trim()
643 + " </servlet>".trim()
644 + "</web-app>";
645 Document mergeDoc =
646 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
647 WebXml mergeWebXml = new WebXml(mergeDoc);
648 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
649 merger.mergeServlets(mergeWebXml);
650 Element servletElement = srcWebXml.getServlet("s1");
651 assertEquals("load-on-startup",
652 ((Element) servletElement.getLastChild()).getTagName());
653 }
654
655 /**
656 * Tests whether multiple servlet in the merge file are correctly inserted
657 * into an empty descriptor.
658 *
659 * @throws Exception If an unexpected error occurs
660 */
661 public void testMergeMultipleServletsIntoEmptyDocument() throws Exception
662 {
663 String srcXml = "<web-app></web-app>";
664 Document srcDoc =
665 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
666 WebXml srcWebXml = new WebXml(srcDoc);
667 String mergeXml = "<web-app>"
668 + " <servlet>"
669 + " <servlet-name>s1</servlet-name>"
670 + " <servlet-class>sclass1</servlet-class>"
671 + " </servlet>"
672 + " <servlet>"
673 + " <servlet-name>s2</servlet-name>"
674 + " <servlet-class>sclass2</servlet-class>"
675 + " </servlet>"
676 + " <servlet>"
677 + " <servlet-name>s3</servlet-name>"
678 + " <servlet-class>sclass3</servlet-class>"
679 + " </servlet>"
680 + "</web-app>";
681 Document mergeDoc =
682 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
683 WebXml mergeWebXml = new WebXml(mergeDoc);
684 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
685 merger.mergeServlets(mergeWebXml);
686 Iterator servletNames = srcWebXml.getServletNames();
687 assertEquals("s1", servletNames.next());
688 assertEquals("s2", servletNames.next());
689 assertEquals("s3", servletNames.next());
690 assertTrue(!servletNames.hasNext());
691 }
692
693 /**
694 * Tests whether a single servlet with one mapping is correctly inserted
695 * into an empty descriptor.
696 *
697 * @throws Exception If an unexpected error occurs
698 */
699 public void testMergeOneServletWithOneMappingIntoEmptyDocument()
700 throws Exception
701 {
702 String srcXml = "<web-app></web-app>";
703 Document srcDoc =
704 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
705 WebXml srcWebXml = new WebXml(srcDoc);
706 String mergeXml = "<web-app>"
707 + " <servlet>"
708 + " <servlet-name>s1</servlet-name>"
709 + " <servlet-class>sclass1</servlet-class>"
710 + " </servlet>"
711 + " <servlet-mapping>"
712 + " <servlet-name>s1</servlet-name>"
713 + " <url-pattern>/s1mapping1</url-pattern>"
714 + " </servlet-mapping>"
715 + "</web-app>";
716 Document mergeDoc =
717 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
718 WebXml mergeWebXml = new WebXml(mergeDoc);
719 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
720 merger.mergeServlets(mergeWebXml);
721 assertTrue(srcWebXml.hasServlet("s1"));
722 Iterator servletMappings = srcWebXml.getServletMappings("s1");
723 assertEquals("/s1mapping1", servletMappings.next());
724 assertTrue(!servletMappings.hasNext());
725 }
726
727 /**
728 * Tests whether a single servlet with multiple mappings is correctly
729 * inserted into an empty descriptor.
730 *
731 * @throws Exception If an unexpected error occurs
732 */
733 public void testMergeOneServletWithMultipleMappingsIntoEmptyDocument()
734 throws Exception
735 {
736 String srcXml = "<web-app></web-app>";
737 Document srcDoc =
738 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
739 WebXml srcWebXml = new WebXml(srcDoc);
740 String mergeXml = "<web-app>"
741 + " <servlet>"
742 + " <servlet-name>s1</servlet-name>"
743 + " <servlet-class>sclass1</servlet-class>"
744 + " </servlet>"
745 + " <servlet-mapping>"
746 + " <servlet-name>s1</servlet-name>"
747 + " <url-pattern>/s1mapping1</url-pattern>"
748 + " </servlet-mapping>"
749 + " <servlet-mapping>"
750 + " <servlet-name>s1</servlet-name>"
751 + " <url-pattern>/s1mapping2</url-pattern>"
752 + " </servlet-mapping>"
753 + " <servlet-mapping>"
754 + " <servlet-name>s1</servlet-name>"
755 + " <url-pattern>/s1mapping3</url-pattern>"
756 + " </servlet-mapping>"
757 + "</web-app>";
758 Document mergeDoc =
759 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
760 WebXml mergeWebXml = new WebXml(mergeDoc);
761 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
762 merger.mergeServlets(mergeWebXml);
763 assertTrue(srcWebXml.hasServlet("s1"));
764 Iterator servletMappings = srcWebXml.getServletMappings("s1");
765 assertEquals("/s1mapping1", servletMappings.next());
766 assertEquals("/s1mapping2", servletMappings.next());
767 assertEquals("/s1mapping3", servletMappings.next());
768 assertTrue(!servletMappings.hasNext());
769 }
770
771 /**
772 * Tests whether a single security role is correctly inserted into an empty
773 * descriptor.
774 *
775 * @throws Exception If an unexpected error occurs
776 */
777 public void testMergeSecurityRoleIntoEmptyDocument()
778 throws Exception
779 {
780 String srcXml = "<web-app></web-app>";
781 Document srcDoc =
782 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
783 WebXml srcWebXml = new WebXml(srcDoc);
784 String mergeXml = "<web-app>"
785 + " <security-role>"
786 + " <role-name>role1</role-name>"
787 + " </security-role>"
788 + "</web-app>";
789 Document mergeDoc =
790 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
791 WebXml mergeWebXml = new WebXml(mergeDoc);
792 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
793 merger.mergeSecurityRoles(mergeWebXml);
794 Iterator securityRoleNames = srcWebXml.getSecurityRoleNames();
795 assertTrue(securityRoleNames.hasNext());
796 assertEquals("role1", securityRoleNames.next());
797 assertTrue(!securityRoleNames.hasNext());
798 }
799
800 /**
801 * Tests whether a single security role is ignored when the source
802 * descriptor already contains a role with the same name.
803 *
804 * @throws Exception If an unexpected error occurs
805 */
806 public void testMergeSecurityRoleIntoDocumentWithSameRole()
807 throws Exception
808 {
809 String srcXml = "<web-app>"
810 + " <security-role>"
811 + " <description>A role</description>"
812 + " <role-name>role1</role-name>"
813 + " </security-role>"
814 + "</web-app>";
815 Document srcDoc =
816 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
817 WebXml srcWebXml = new WebXml(srcDoc);
818 String mergeXml = "<web-app>"
819 + " <security-role>"
820 + " <role-name>role1</role-name>"
821 + " </security-role>"
822 + "</web-app>";
823 Document mergeDoc =
824 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
825 WebXml mergeWebXml = new WebXml(mergeDoc);
826 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
827 merger.mergeSecurityRoles(mergeWebXml);
828 Iterator securityRoleNames = srcWebXml.getSecurityRoleNames();
829 assertTrue(securityRoleNames.hasNext());
830 assertEquals("role1", securityRoleNames.next());
831 assertTrue(!securityRoleNames.hasNext());
832 }
833
834 /**
835 * Tests whether a single EJB reference is correctly inserted into an empty
836 * descriptor.
837 *
838 * @throws Exception If an unexpected error occurs
839 */
840 public void testMergeOneEjbRefIntoEmptyDocument()
841 throws Exception
842 {
843 String srcXml = "<web-app></web-app>";
844 Document srcDoc =
845 builder.parse(new ByteArrayInputStream(srcXml.getBytes()));
846 WebXml srcWebXml = new WebXml(srcDoc);
847 String mergeXml = "<web-app>"
848 + " <ejb-ref>"
849 + " <ejb-ref-name>ejbref1</ejb-ref-name>"
850 + " <ejb-ref-type>ejbref1.type</ejb-ref-type>"
851 + " <home>ejbref1.homeInterface</home>"
852 + " <remote>ejbref1.remoteInterface</remote>"
853 + " </ejb-ref>"
854 + "</web-app>";
855 Document mergeDoc =
856 builder.parse(new ByteArrayInputStream(mergeXml.getBytes()));
857 WebXml mergeWebXml = new WebXml(mergeDoc);
858 WebXmlMerger merger = new WebXmlMerger(srcWebXml);
859 merger.mergeEjbRefs(mergeWebXml);
860 Iterator ejbRefs = srcWebXml.getElements(WebXmlTag.EJB_REF);
861 assertTrue(ejbRefs.hasNext());
862 }
863
864 }