001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one
003: * or more contributor license agreements. See the NOTICE file
004: * distributed with this work for additional information
005: * regarding copyright ownership. The ASF licenses this file
006: * to you under the Apache License, Version 2.0 (the
007: * "License"); you may not use this file except in compliance
008: * with the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing,
013: * software distributed under the License is distributed on an
014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015: * KIND, either express or implied. See the License for the
016: * specific language governing permissions and limitations
017: * under the License.
018: */
019: package org.apache.axis2.phaserule;
020:
021: import org.apache.axis2.engine.Phase;
022: import org.apache.axis2.engine.Handler;
023: import org.apache.axis2.engine.AxisConfiguration;
024: import org.apache.axis2.engine.DispatchPhase;
025: import org.apache.axis2.phaseresolver.PhaseHolder;
026: import org.apache.axis2.phaseresolver.PhaseException;
027: import org.apache.axis2.description.HandlerDescription;
028: import org.apache.axis2.description.PhaseRule;
029: import org.apache.axis2.AxisFault;
030: import org.apache.axis2.context.MessageContext;
031: import org.apache.axis2.context.ConfigurationContext;
032:
033: import java.util.ArrayList;
034: import java.util.Iterator;
035:
036: import junit.framework.TestCase;
037:
038: /**
039: * Test various PhaseRule configurations
040: */
041: public class PhaseRuleTests extends TestCase {
042:
043: // Some shared Handlers and HandlerDescriptions
044: // TODO : Factor out shared data for these tests
045:
046: public void testBefore() throws AxisFault {
047: ArrayList phases = new ArrayList();
048: Phase p1 = new Phase("PhaseA");
049: phases.add(p1);
050: Phase p2 = new Phase("PhaseB");
051: phases.add(p2);
052:
053: MessageContext msg = new ConfigurationContext(
054: new AxisConfiguration()).createMessageContext();
055:
056: PhaseHolder ph = new PhaseHolder(phases);
057: HandlerDescription hm = new HandlerDescription();
058: hm.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
059: Handler h1 = new PhaseRuleHandler();
060: h1.init(hm);
061: ((PhaseRuleHandler) h1).setName("First");
062: hm.setHandler(h1);
063: hm.setName("H1");
064: PhaseRule rule = new PhaseRule();
065: rule.setPhaseName("PhaseA");
066: hm.setRules(rule);
067: ph.addHandler(hm);
068:
069: HandlerDescription hm1 = new HandlerDescription();
070: hm1.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
071: Handler h2 = new PhaseRuleHandler();
072: ((PhaseRuleHandler) h2).setName("Second");
073: h2.init(hm1);
074: hm1.setHandler(h2);
075: hm1.setName("H2");
076: PhaseRule rule1 = new PhaseRule();
077: rule1.setPhaseName("PhaseA");
078: rule1.setBefore("H1");
079: hm1.setRules(rule1);
080: ph.addHandler(hm1);
081:
082: ArrayList handlers = p1.getHandlers();
083: Handler handler = (Handler) handlers.get(0);
084: if (handler != h2) {
085: fail("Computed Hnadler order is wrong ");
086: }
087: handler = (Handler) handlers.get(1);
088: if (handler != h1) {
089: fail("Computed Hnadler order is wrong ");
090: }
091: p1.invoke(msg);
092: }
093:
094: public void testBeforewithNoFirst() throws AxisFault {
095: ArrayList phases = new ArrayList();
096: Phase p1 = new Phase("PhaseA");
097: phases.add(p1);
098: Phase p2 = new Phase("PhaseB");
099: phases.add(p2);
100:
101: MessageContext msg = new ConfigurationContext(
102: new AxisConfiguration()).createMessageContext();
103: PhaseHolder ph = new PhaseHolder(phases);
104:
105: HandlerDescription hm1 = new HandlerDescription();
106: hm1.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
107: Handler h2 = new PhaseRuleHandler();
108: ((PhaseRuleHandler) h2).setName("Second");
109: h2.init(hm1);
110: hm1.setHandler(h2);
111: hm1.setName("H2");
112: PhaseRule rule1 = new PhaseRule();
113: rule1.setPhaseName("PhaseA");
114: rule1.setBefore("H1");
115: hm1.setRules(rule1);
116: ph.addHandler(hm1);
117:
118: HandlerDescription hm = new HandlerDescription();
119: hm.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
120: Handler h1 = new PhaseRuleHandler();
121: h1.init(hm);
122: ((PhaseRuleHandler) h1).setName("First");
123: hm.setHandler(h1);
124: hm.setName("H1");
125: PhaseRule rule = new PhaseRule();
126: rule.setPhaseName("PhaseA");
127: hm.setRules(rule);
128: ph.addHandler(hm);
129:
130: ArrayList handlers = p1.getHandlers();
131: Handler handler = (Handler) handlers.get(0);
132: if (handler != h2) {
133: fail("Computed Handler order is wrong ");
134: }
135: handler = (Handler) handlers.get(1);
136: if (handler != h1) {
137: fail("Computed Handler order is wrong ");
138: }
139: p1.invoke(msg);
140: }
141:
142: public void testBeforeAfter() throws Exception {
143: ArrayList phases = new ArrayList();
144: Phase p1 = new Phase("PhaseA");
145: phases.add(p1);
146: Phase p2 = new Phase("PhaseB");
147: phases.add(p2);
148:
149: PhaseHolder ph = new PhaseHolder(phases);
150: HandlerDescription hm = new HandlerDescription();
151: hm.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
152: PhaseRuleHandler h1 = new PhaseRuleHandler();
153: h1.init(hm);
154: h1.setName("First");
155: hm.setHandler(h1);
156: hm.setName("H1");
157: PhaseRule rule = new PhaseRule();
158: rule.setPhaseName("PhaseA");
159: hm.setRules(rule);
160: ph.addHandler(hm);
161:
162: HandlerDescription hm1 = new HandlerDescription();
163: hm1.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
164: Handler h2 = new PhaseRuleHandler();
165: ((PhaseRuleHandler) h2).setName("Forth");
166: h2.init(hm1);
167: hm1.setHandler(h2);
168: hm1.setName("H2");
169: PhaseRule rule1 = new PhaseRule();
170: rule1.setPhaseName("PhaseA");
171: hm1.setRules(rule1);
172: ph.addHandler(hm1);
173:
174: HandlerDescription hm3 = new HandlerDescription();
175: hm3.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
176: Handler h3 = new PhaseRuleHandler();
177: ((PhaseRuleHandler) h3).setName("Second");
178: h3.init(hm3);
179: hm3.setHandler(h3);
180: hm3.setName("H3");
181: PhaseRule rule3 = new PhaseRule();
182: rule3.setPhaseName("PhaseA");
183: rule3.setAfter("H1");
184: hm3.setRules(rule3);
185: ph.addHandler(hm3);
186:
187: HandlerDescription hm4 = new HandlerDescription();
188: hm4.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
189: Handler h4 = new PhaseRuleHandler();
190: ((PhaseRuleHandler) h4).setName("Third");
191: h4.init(hm4);
192: hm4.setHandler(h4);
193: hm4.setName("H4");
194: PhaseRule rule4 = new PhaseRule();
195: rule4.setPhaseName("PhaseA");
196: rule4.setAfter("H1");
197: rule4.setBefore("H2");
198: hm4.setRules(rule4);
199: ph.addHandler(hm4);
200:
201: ArrayList handlers = p1.getHandlers();
202: boolean foundH1 = false;
203: boolean foundH4 = false;
204:
205: for (Iterator iterator = handlers.iterator(); iterator
206: .hasNext();) {
207: Handler handler = (Handler) iterator.next();
208: if (h3 == handler) {
209: if (!foundH1)
210: fail("H3 found before H1");
211: }
212: if (h1 == handler)
213: foundH1 = true;
214: if (h2 == handler) {
215: if (!foundH4) {
216: fail("H2 found before H4");
217: }
218: }
219: if (h4 == handler) {
220: if (!foundH1) {
221: fail("H4 found before H1");
222: }
223: foundH4 = true;
224: }
225: }
226: }
227:
228: public void testPhaseFirst() throws AxisFault {
229: ArrayList phases = new ArrayList();
230: Phase p1 = new Phase("PhaseA");
231: phases.add(p1);
232: Phase p2 = new Phase("PhaseB");
233: phases.add(p2);
234: PhaseHolder ph = new PhaseHolder(phases);
235: HandlerDescription hm = new HandlerDescription();
236: hm.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
237: Handler h1 = new PhaseRuleHandler();
238: h1.init(hm);
239: ((PhaseRuleHandler) h1).setName("PhaseFirstHandler");
240: hm.setHandler(h1);
241: hm.setName("H1");
242: PhaseRule rule = new PhaseRule();
243: rule.setPhaseName("PhaseA");
244: rule.setPhaseFirst(true);
245: hm.setRules(rule);
246: ph.addHandler(hm);
247:
248: HandlerDescription hm1 = new HandlerDescription();
249: hm1.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
250: Handler h2 = new PhaseRuleHandler();
251: ((PhaseRuleHandler) h2).setName("Second Handler");
252: h2.init(hm1);
253: hm1.setHandler(h2);
254: hm1.setName("H2");
255: PhaseRule rule1 = new PhaseRule();
256: rule1.setPhaseName("PhaseA");
257: rule1.setBefore("H1");
258: hm1.setRules(rule1);
259: try {
260: ph.addHandler(hm1);
261: } catch (PhaseException e) {
262: return;
263: }
264: fail("Succeeded in deploying after PhaseFirst handler!");
265: }
266:
267: public void testPhaseLast() throws AxisFault {
268: ArrayList phases = new ArrayList();
269: Phase p1 = new Phase("PhaseA");
270: phases.add(p1);
271: Phase p2 = new Phase("PhaseB");
272: phases.add(p2);
273:
274: PhaseHolder ph = new PhaseHolder(phases);
275: HandlerDescription hm = new HandlerDescription();
276: hm.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
277: Handler h1 = new PhaseRuleHandler();
278: h1.init(hm);
279: ((PhaseRuleHandler) h1).setName("PhaseLast");
280: hm.setHandler(h1);
281: hm.setName("H1");
282: PhaseRule rule = new PhaseRule();
283: rule.setPhaseName("PhaseA");
284: rule.setPhaseLast(true);
285: hm.setRules(rule);
286: ph.addHandler(hm);
287:
288: HandlerDescription hm1 = new HandlerDescription();
289: hm1.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
290: Handler h2 = new PhaseRuleHandler();
291: ((PhaseRuleHandler) h2).setName("Second Handler");
292: h2.init(hm1);
293: hm1.setHandler(h2);
294: hm1.setName("H2");
295: PhaseRule rule1 = new PhaseRule();
296: rule1.setPhaseName("PhaseA");
297: rule1.setAfter("H1");
298: hm1.setRules(rule1);
299: try {
300: ph.addHandler(hm1);
301: } catch (PhaseException e) {
302: return;
303: }
304: fail("Succeeded in deploying after PhaseLast handler!");
305: }
306:
307: public void testPhaseRules() throws Exception {
308: // TODO : What is this testing exactly?
309: ArrayList inPhase = new AxisConfiguration().getInFlowPhases();
310: Phase transportIN = new Phase("TransportIn");
311: Phase preDispatch = new Phase("PreDispatch");
312: DispatchPhase dispatchPhase = new DispatchPhase();
313: dispatchPhase.setName("Dispatch");
314:
315: inPhase.add(transportIN);
316: inPhase.add(preDispatch);
317: inPhase.add(dispatchPhase);
318:
319: PhaseHolder ph = new PhaseHolder(inPhase);
320:
321: HandlerDescription hm = new HandlerDescription();
322: hm.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
323: Handler h1 = new PhaseRuleHandler();
324: h1.init(hm);
325: hm.setHandler(h1);
326: hm.setName("H1");
327: PhaseRule rule = new PhaseRule();
328: rule.setPhaseName("PreDispatch");
329: rule.setPhaseFirst(true);
330: hm.setRules(rule);
331: ph.addHandler(hm);
332:
333: HandlerDescription hm1 = new HandlerDescription();
334: hm1.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
335: Handler h2 = new PhaseRuleHandler();
336: h2.init(hm1);
337: hm1.setHandler(h2);
338: hm1.setName("H2");
339: PhaseRule rule1 = new PhaseRule();
340: rule1.setPhaseName("PreDispatch");
341: rule1.setAfter("H1");
342: hm1.setRules(rule1);
343: ph.addHandler(hm1);
344:
345: HandlerDescription hm2 = new HandlerDescription();
346: hm2.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
347: Handler h3 = new PhaseRuleHandler();
348: h3.init(hm2);
349: hm2.setHandler(h3);
350: hm2.setName("H3");
351: PhaseRule rule2 = new PhaseRule();
352: rule2.setPhaseName("PreDispatch");
353: rule2.setAfter("H1");
354: rule2.setBefore("H2");
355: hm2.setRules(rule2);
356: ph.addHandler(hm2);
357:
358: HandlerDescription hm3 = new HandlerDescription();
359: hm3.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
360: Handler h4 = new PhaseRuleHandler();
361: h4.init(hm3);
362: hm3.setHandler(h4);
363: hm3.setName("H4");
364: PhaseRule rule3 = new PhaseRule();
365: rule3.setPhaseName("Dispatch");
366: hm3.setRules(rule3);
367: ph.addHandler(hm3);
368: }
369:
370: public void testSingleHandler() throws Exception {
371: ArrayList phases = new ArrayList();
372: Phase p1 = new Phase("PhaseA");
373: phases.add(p1);
374: Phase p2 = new Phase("PhaseB");
375: phases.add(p2);
376:
377: PhaseHolder ph = new PhaseHolder(phases);
378: HandlerDescription hm = new HandlerDescription();
379: hm.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
380: Handler h1 = new PhaseRuleHandler();
381: h1.init(hm);
382: ((PhaseRuleHandler) h1).setName("PhaseFirstHandler");
383: hm.setHandler(h1);
384: hm.setName("H1");
385: PhaseRule rule = new PhaseRule();
386: rule.setPhaseName("PhaseA");
387: rule.setPhaseFirst(true);
388: rule.setPhaseLast(true);
389: hm.setRules(rule);
390: ph.addHandler(hm);
391:
392: HandlerDescription hm1 = new HandlerDescription();
393: hm1.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
394: Handler h2 = new PhaseRuleHandler();
395: ((PhaseRuleHandler) h2).setName("Second Handler");
396: h2.init(hm1);
397: hm1.setHandler(h2);
398: hm1.setName("H2");
399: PhaseRule rule1 = new PhaseRule();
400: rule1.setPhaseName("PhaseA");
401: rule1.setAfter("H1");
402: hm1.setRules(rule1);
403: try {
404: ph.addHandler(hm1);
405: } catch (PhaseException e) {
406: // Caught expected Exception
407: return;
408: }
409: fail("This should fail with : can only have one handler, since there is a "
410: + "handler with both phaseFirst and PhaseLast true ");
411: }
412:
413: public void testInvalidPhaseFirst() {
414: ArrayList phases = new ArrayList();
415: Phase p1 = new Phase("PhaseA");
416: phases.add(p1);
417: Phase p2 = new Phase("PhaseB");
418: phases.add(p2);
419:
420: PhaseHolder ph = new PhaseHolder(phases);
421: HandlerDescription hm = new HandlerDescription();
422: hm.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
423: Handler h1 = new PhaseRuleHandler();
424: h1.init(hm);
425: ((PhaseRuleHandler) h1).setName("PhaseFirstHandler");
426: hm.setHandler(h1);
427: hm.setName("H1");
428: PhaseRule rule = new PhaseRule();
429: rule.setPhaseName("PhaseA");
430: rule.setPhaseFirst(true);
431: rule.setBefore("H2");
432: hm.setRules(rule);
433: try {
434: // This should fail
435: ph.addHandler(hm);
436: fail("Incorrectly added Handler with both PhaseFirst and before name");
437: } catch (PhaseException e) {
438: // Perfect, caught the expected Exception
439: }
440: }
441:
442: public void testInvalidPhaseFirst1() {
443: try {
444: ArrayList phases = new ArrayList();
445: Phase p1 = new Phase("PhaseA");
446: phases.add(p1);
447: Phase p2 = new Phase("PhaseB");
448: phases.add(p2);
449:
450: PhaseHolder ph = new PhaseHolder(phases);
451: HandlerDescription hm = new HandlerDescription();
452: hm
453: .setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
454: Handler h1 = new PhaseRuleHandler();
455: h1.init(hm);
456: ((PhaseRuleHandler) h1).setName("PhaseFirstHandler");
457: hm.setHandler(h1);
458: hm.setName("H1");
459: PhaseRule rule = new PhaseRule();
460: rule.setPhaseName("PhaseA");
461: rule.setPhaseFirst(true);
462: hm.setRules(rule);
463: ph.addHandler(hm);
464:
465: HandlerDescription hm1 = new HandlerDescription();
466: hm1
467: .setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
468: Handler h2 = new PhaseRuleHandler();
469: ((PhaseRuleHandler) h2).setName("Second Handler");
470: h2.init(hm1);
471: hm1.setHandler(h2);
472: hm1.setName("H2");
473: PhaseRule rule1 = new PhaseRule();
474: rule1.setPhaseName("PhaseA");
475: rule1.setPhaseFirst(true);
476: hm1.setRules(rule1);
477: ph.addHandler(hm1);
478: fail("This should be faild with PhaseFirst already has been set, cannot have two "
479: + "phaseFirst Handler for same phase ");
480: } catch (AxisFault axisFault) {
481: }
482: }
483:
484: public void testPhaseLastErrors() throws Exception {
485: ArrayList phases = new ArrayList();
486: Phase p1 = new Phase("PhaseA");
487: phases.add(p1);
488: Phase p2 = new Phase("PhaseB");
489: phases.add(p2);
490:
491: PhaseHolder ph = new PhaseHolder(phases);
492: HandlerDescription hm = new HandlerDescription();
493: hm.setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
494: Handler h1 = new PhaseRuleHandler();
495: h1.init(hm);
496: ((PhaseRuleHandler) h1).setName("PhaseFirstHandler");
497: hm.setHandler(h1);
498: hm.setName("H1");
499: PhaseRule rule = new PhaseRule();
500: rule.setPhaseName("PhaseA");
501: rule.setPhaseLast(true);
502: rule.setBefore("H2");
503: hm.setRules(rule);
504: try {
505: ph.addHandler(hm);
506: } catch (PhaseException e) {
507: return;
508: }
509:
510: fail("Handler with PhaseLast cannot also have before/after set");
511: }
512:
513: public void testInvalidPhaseLast() {
514: try {
515: ArrayList phases = new ArrayList();
516: Phase p1 = new Phase("PhaseA");
517: phases.add(p1);
518: Phase p2 = new Phase("PhaseB");
519: phases.add(p2);
520:
521: PhaseHolder ph = new PhaseHolder(phases);
522: HandlerDescription hm = new HandlerDescription();
523: hm
524: .setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
525: Handler h1 = new PhaseRuleHandler();
526: h1.init(hm);
527: ((PhaseRuleHandler) h1).setName("PhaseLast");
528: hm.setHandler(h1);
529: hm.setName("H1");
530: PhaseRule rule = new PhaseRule();
531: rule.setPhaseName("PhaseA");
532: rule.setPhaseLast(true);
533: hm.setRules(rule);
534: ph.addHandler(hm);
535:
536: HandlerDescription hm1 = new HandlerDescription();
537: hm1
538: .setClassName("org.apache.axis2.phaserule.PhaseRuleHandler");
539: Handler h2 = new PhaseRuleHandler();
540: ((PhaseRuleHandler) h2).setName("Second Handler");
541: h2.init(hm1);
542: hm1.setHandler(h2);
543: hm1.setName("H2");
544: PhaseRule rule1 = new PhaseRule();
545: rule1.setPhaseName("PhaseA");
546: rule1.setPhaseLast(true);
547: hm1.setRules(rule1);
548: ph.addHandler(hm1);
549: fail("This should be faild with Phaselast already has been set, cannot have two "
550: + "phaseLast Handler for same phase ");
551: } catch (AxisFault axisFault) {
552: }
553: }
554:
555: /**
556: * This test makes sure we can't add a Handler to a Phase when the
557: * before and after constraints don't make sense.
558: *
559: * @throws Exception if there's an error
560: */
561: public void testBadBeforeAndAfters() throws Exception {
562: PhaseRuleHandler h1 = new PhaseRuleHandler("a");
563: HandlerDescription hd = new HandlerDescription("a");
564: h1.init(hd);
565:
566: PhaseRuleHandler h2 = new PhaseRuleHandler("c");
567: hd = new HandlerDescription("c");
568: h2.init(hd);
569:
570: Phase phase = new Phase();
571: phase.addHandler(h1);
572: phase.addHandler(h2);
573:
574: PhaseRule badRule = new PhaseRule();
575: badRule.setBefore("a");
576: badRule.setAfter("c");
577:
578: hd = new HandlerDescription("b");
579: PhaseRuleHandler h3 = new PhaseRuleHandler("b");
580: h3.init(hd);
581:
582: hd.setHandler(h3);
583: hd.setRules(badRule);
584: try {
585: phase.addHandler(hd);
586: fail("Bad PhaseRule was accepted!");
587: } catch (PhaseException e) {
588: // Correct - exception caught
589: }
590: }
591: }
|