0001: /**
0002: * Licensed to the Apache Software Foundation (ASF) under one
0003: * or more contributor license agreements. See the NOTICE file
0004: * distributed with this work for additional information
0005: * regarding copyright ownership. The ASF licenses this file
0006: * to you under the Apache License, Version 2.0 (the
0007: * "License"); you may not use this file except in compliance
0008: * with the License. You may obtain a copy of the License at
0009: *
0010: * http://www.apache.org/licenses/LICENSE-2.0
0011: *
0012: * Unless required by applicable law or agreed to in writing,
0013: * software distributed under the License is distributed on an
0014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
0015: * KIND, either express or implied. See the License for the
0016: * specific language governing permissions and limitations
0017: * under the License.
0018: */package org.apache.cxf.jaxws.handler;
0019:
0020: import java.io.ByteArrayOutputStream;
0021: import java.io.OutputStream;
0022: import java.util.ArrayList;
0023: import java.util.List;
0024: import java.util.Map;
0025:
0026: import javax.xml.soap.MessageFactory;
0027: import javax.xml.soap.SOAPException;
0028: import javax.xml.soap.SOAPMessage;
0029: import javax.xml.transform.OutputKeys;
0030: import javax.xml.transform.Source;
0031: import javax.xml.transform.Transformer;
0032: import javax.xml.transform.TransformerFactory;
0033: import javax.xml.transform.stream.StreamResult;
0034: import javax.xml.ws.ProtocolException;
0035: import javax.xml.ws.handler.Handler;
0036: import javax.xml.ws.handler.LogicalHandler;
0037: import javax.xml.ws.handler.LogicalMessageContext;
0038: import javax.xml.ws.handler.MessageContext;
0039: import javax.xml.ws.handler.soap.SOAPMessageContext;
0040:
0041: import org.apache.cxf.binding.soap.SoapMessage;
0042: import org.apache.cxf.jaxws.context.WrappedMessageContext;
0043: import org.apache.cxf.jaxws.handler.logical.LogicalMessageContextImpl;
0044: import org.apache.cxf.jaxws.handler.soap.SOAPMessageContextImpl;
0045: import org.apache.cxf.message.Exchange;
0046: import org.apache.cxf.message.ExchangeImpl;
0047: import org.apache.cxf.message.Message;
0048: import org.apache.cxf.message.MessageImpl;
0049: import org.junit.Assert;
0050: import org.junit.Before;
0051: import org.junit.Test;
0052:
0053: public class HandlerChainInvokerTest extends Assert {
0054:
0055: private static final int HANDLER_COUNT = 4;
0056:
0057: HandlerChainInvoker invoker;
0058: Message message;
0059: LogicalMessageContext lmc;
0060: MessageContext pmc;
0061:
0062: TestLogicalHandler[] logicalHandlers = new TestLogicalHandler[HANDLER_COUNT];
0063: TestProtocolHandler[] protocolHandlers = new TestProtocolHandler[HANDLER_COUNT];
0064:
0065: @Before
0066: public void setUp() {
0067: AbstractHandlerBase.clear();
0068:
0069: List<Handler> handlers = new ArrayList<Handler>();
0070: for (int i = 0; i < logicalHandlers.length; i++) {
0071: logicalHandlers[i] = new TestLogicalHandler();
0072: handlers.add(logicalHandlers[i]);
0073: }
0074: for (int i = 0; i < protocolHandlers.length; i++) {
0075: protocolHandlers[i] = new TestProtocolHandler();
0076: handlers.add(protocolHandlers[i]);
0077: }
0078:
0079: invoker = new HandlerChainInvoker(handlers);
0080:
0081: message = new MessageImpl();
0082: Exchange e = new ExchangeImpl();
0083: message.setExchange(e);
0084: lmc = new LogicalMessageContextImpl(message);
0085: pmc = new WrappedMessageContext(message);
0086: /*
0087: payload = new DOMSource();
0088: message.setContent(Source.class, payload);*/
0089:
0090: }
0091:
0092: @Test
0093: public void testInvokeEmptyHandlerChain() {
0094: invoker = new HandlerChainInvoker(new ArrayList<Handler>());
0095: assertTrue(invoker.invokeLogicalHandlers(false, lmc));
0096: assertTrue(invoker.invokeProtocolHandlers(false, pmc));
0097: }
0098:
0099: @Test
0100: public void testHandlerPartitioning() {
0101:
0102: assertEquals(HANDLER_COUNT, invoker.getLogicalHandlers().size());
0103: for (Handler h : invoker.getLogicalHandlers()) {
0104: assertTrue(h instanceof LogicalHandler);
0105: }
0106:
0107: assertEquals(HANDLER_COUNT, invoker.getProtocolHandlers()
0108: .size());
0109: for (Handler h : invoker.getProtocolHandlers()) {
0110: assertTrue(!(h instanceof LogicalHandler));
0111: }
0112:
0113: }
0114:
0115: @Test
0116: public void testInvokeHandlersInbound() {
0117:
0118: invoker.setInbound();
0119: assertTrue(invoker.isInbound());
0120: checkProtocolHandlersInvoked(false);
0121:
0122: assertEquals(4, invoker.getInvokedHandlers().size());
0123: assertTrue(invoker.isInbound());
0124:
0125: checkLogicalHandlersInvoked(false, true);
0126: assertEquals(8, invoker.getInvokedHandlers().size());
0127: assertTrue(invoker.isInbound());
0128:
0129: assertFalse(invoker.isClosed());
0130: assertTrue(logicalHandlers[0].getInvokeOrderOfHandleMessage() > logicalHandlers[1]
0131: .getInvokeOrderOfHandleMessage());
0132: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleMessage() > protocolHandlers[0]
0133: .getInvokeOrderOfHandleMessage());
0134: assertTrue(protocolHandlers[0].getInvokeOrderOfHandleMessage() > protocolHandlers[1]
0135: .getInvokeOrderOfHandleMessage());
0136: }
0137:
0138: @Test
0139: public void testLogicalHandlerReturnFalseOutboundResponseExpected() {
0140:
0141: assertEquals(0, logicalHandlers[0].getHandleMessageCount());
0142: assertEquals(0, logicalHandlers[1].getHandleMessageCount());
0143: assertEquals(0, logicalHandlers[2].getHandleMessageCount());
0144:
0145: assertTrue(invoker.isOutbound());
0146:
0147: // invoke the handlers. when a handler returns false, processing
0148: // of handlers is stopped and message direction is reversed.
0149: logicalHandlers[1].setHandleMessageRet(false);
0150:
0151: boolean ret = invoker.invokeLogicalHandlers(false, lmc);
0152:
0153: assertEquals(false, ret);
0154: assertFalse(invoker.isClosed());
0155: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0156: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0157: assertEquals(0, logicalHandlers[2].getHandleMessageCount());
0158: assertTrue(invoker.isInbound());
0159:
0160: // the next time invokeHandler is invoked, the 'next' handler is invoked.
0161: // As message direction has been reversed this means the that the previous
0162: // one on the list is actually invoked.
0163: logicalHandlers[1].setHandleMessageRet(true);
0164:
0165: ret = invoker.invokeLogicalHandlers(false, lmc);
0166: assertTrue(ret);
0167: assertFalse(invoker.isClosed());
0168: assertEquals(2, logicalHandlers[0].getHandleMessageCount());
0169: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0170: assertEquals(0, logicalHandlers[2].getHandleMessageCount());
0171: assertTrue(invoker.isInbound());
0172: }
0173:
0174: @Test
0175: public void testLogicalHandlerInboundProcessingStoppedResponseExpected() {
0176:
0177: assertEquals(0, logicalHandlers[0].getHandleMessageCount());
0178: assertEquals(0, logicalHandlers[1].getHandleMessageCount());
0179:
0180: invoker.setInbound();
0181:
0182: logicalHandlers[1].setHandleMessageRet(false);
0183: boolean ret = invoker.invokeLogicalHandlers(false, lmc);
0184: assertFalse(invoker.isClosed());
0185:
0186: assertEquals(false, ret);
0187: assertEquals(0, logicalHandlers[0].getHandleMessageCount());
0188: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0189: assertTrue(invoker.isOutbound());
0190: }
0191:
0192: @Test
0193: public void testHandleMessageReturnsFalseOutbound() {
0194: protocolHandlers[2].setHandleMessageRet(false);
0195:
0196: assertTrue(invoker.isOutbound());
0197:
0198: boolean continueProcessing = true;
0199: invoker.setLogicalMessageContext(lmc);
0200: continueProcessing = invoker.invokeLogicalHandlers(false, lmc);
0201: invoker.setProtocolMessageContext(pmc);
0202: continueProcessing = invoker.invokeProtocolHandlers(false, pmc);
0203:
0204: assertFalse((Boolean) pmc
0205: .get(SOAPMessageContext.MESSAGE_OUTBOUND_PROPERTY));
0206: assertFalse((Boolean) lmc
0207: .get(LogicalMessageContext.MESSAGE_OUTBOUND_PROPERTY));
0208: assertTrue(invoker.isInbound());
0209: assertFalse(continueProcessing);
0210:
0211: protocolHandlers[2].setHandleMessageRet(true);
0212: invoker.setProtocolMessageContext(pmc);
0213: continueProcessing = invoker.invokeProtocolHandlers(false, pmc);
0214: invoker.setLogicalMessageContext(lmc);
0215: continueProcessing = invoker.invokeLogicalHandlers(false, lmc);
0216:
0217: assertEquals(2, logicalHandlers[0].getHandleMessageCount());
0218: assertEquals(2, logicalHandlers[1].getHandleMessageCount());
0219: assertEquals(2, logicalHandlers[2].getHandleMessageCount());
0220: assertEquals(2, logicalHandlers[3].getHandleMessageCount());
0221: assertEquals(2, protocolHandlers[0].getHandleMessageCount());
0222: assertEquals(2, protocolHandlers[1].getHandleMessageCount());
0223: assertEquals(1, protocolHandlers[2].getHandleMessageCount());
0224: assertEquals(0, protocolHandlers[3].getHandleMessageCount());
0225: assertTrue(logicalHandlers[3].getInvokeOrderOfHandleMessage() < logicalHandlers[2]
0226: .getInvokeOrderOfHandleMessage());
0227: assertTrue(logicalHandlers[2].getInvokeOrderOfHandleMessage() < logicalHandlers[1]
0228: .getInvokeOrderOfHandleMessage());
0229: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleMessage() < logicalHandlers[0]
0230: .getInvokeOrderOfHandleMessage());
0231: assertTrue(protocolHandlers[0].getInvokeOrderOfHandleMessage() < logicalHandlers[3]
0232: .getInvokeOrderOfHandleMessage());
0233: assertTrue(protocolHandlers[2].getInvokeOrderOfHandleMessage() < protocolHandlers[1]
0234: .getInvokeOrderOfHandleMessage());
0235:
0236: assertEquals(0, logicalHandlers[0].getCloseCount());
0237: assertEquals(0, logicalHandlers[1].getCloseCount());
0238: assertEquals(0, logicalHandlers[2].getCloseCount());
0239: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0240: assertEquals(0, logicalHandlers[1].getHandleFaultCount());
0241: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0242:
0243: assertEquals(0, protocolHandlers[0].getCloseCount());
0244: assertEquals(0, protocolHandlers[1].getCloseCount());
0245: assertEquals(0, protocolHandlers[2].getCloseCount());
0246: assertEquals(0, protocolHandlers[0].getHandleFaultCount());
0247: assertEquals(0, protocolHandlers[1].getHandleFaultCount());
0248: assertEquals(0, protocolHandlers[2].getHandleFaultCount());
0249: }
0250:
0251: @Test
0252: public void testHandleMessageThrowsProtocolExceptionOutbound() {
0253: ProtocolException pe = new ProtocolException("banzai");
0254: protocolHandlers[2].setException(pe);
0255:
0256: invoker.setRequestor(true);
0257: assertTrue(invoker.isOutbound());
0258:
0259: boolean continueProcessing = true;
0260: invoker.setLogicalMessageContext(lmc);
0261: continueProcessing = invoker.invokeLogicalHandlers(false, lmc);
0262: assertTrue(continueProcessing);
0263:
0264: //create an empty SOAP body for testing
0265: try {
0266: pmc = new SOAPMessageContextImpl(new SoapMessage(message));
0267: MessageFactory factory = MessageFactory.newInstance();
0268: SOAPMessage soapMessage = factory.createMessage();
0269: ((SOAPMessageContext) pmc).setMessage(soapMessage);
0270: } catch (SOAPException e) {
0271: //do nothing
0272: }
0273:
0274: try {
0275: invoker.setProtocolMessageContext(pmc);
0276: continueProcessing = invoker.invokeProtocolHandlers(false,
0277: pmc);
0278: fail("did not get expected exception");
0279: } catch (ProtocolException e) {
0280: assertEquals("banzai", e.getMessage());
0281: }
0282:
0283: assertFalse((Boolean) pmc
0284: .get(SOAPMessageContext.MESSAGE_OUTBOUND_PROPERTY));
0285: assertFalse((Boolean) lmc
0286: .get(LogicalMessageContext.MESSAGE_OUTBOUND_PROPERTY));
0287: assertTrue(invoker.isInbound());
0288:
0289: //the message is replaced by fault message
0290: Source responseMessage = lmc.getMessage().getPayload();
0291: //System.out.println(getSourceAsString(responseMessage));
0292: assertTrue(getSourceAsString(responseMessage).indexOf("banzai") > -1);
0293:
0294: //assertFalse(continueProcessing);
0295:
0296: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0297: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0298: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0299: assertEquals(1, logicalHandlers[3].getHandleMessageCount());
0300: assertEquals(1, protocolHandlers[0].getHandleMessageCount());
0301: assertEquals(1, protocolHandlers[1].getHandleMessageCount());
0302: assertEquals(1, protocolHandlers[2].getHandleMessageCount());
0303: assertEquals(0, protocolHandlers[3].getHandleMessageCount());
0304: assertTrue(logicalHandlers[3].getInvokeOrderOfHandleMessage() < protocolHandlers[0]
0305: .getInvokeOrderOfHandleMessage());
0306: assertTrue(protocolHandlers[1].getInvokeOrderOfHandleMessage() < protocolHandlers[2]
0307: .getInvokeOrderOfHandleMessage());
0308:
0309: assertEquals(1, logicalHandlers[0].getCloseCount());
0310: assertEquals(1, logicalHandlers[1].getCloseCount());
0311: assertEquals(1, logicalHandlers[2].getCloseCount());
0312: assertEquals(1, logicalHandlers[3].getCloseCount());
0313:
0314: assertEquals(1, protocolHandlers[0].getCloseCount());
0315: assertEquals(1, protocolHandlers[1].getCloseCount());
0316: assertEquals(1, protocolHandlers[2].getCloseCount());
0317: assertEquals(0, protocolHandlers[3].getCloseCount());
0318:
0319: assertTrue(protocolHandlers[2].getInvokeOrderOfClose() < protocolHandlers[1]
0320: .getInvokeOrderOfClose());
0321: assertTrue(protocolHandlers[0].getInvokeOrderOfClose() < logicalHandlers[3]
0322: .getInvokeOrderOfClose());
0323:
0324: assertEquals(1, logicalHandlers[0].getHandleFaultCount());
0325: assertEquals(1, logicalHandlers[1].getHandleFaultCount());
0326: assertEquals(1, logicalHandlers[2].getHandleFaultCount());
0327: assertEquals(1, logicalHandlers[3].getHandleFaultCount());
0328:
0329: assertEquals(1, protocolHandlers[0].getHandleFaultCount());
0330: assertEquals(1, protocolHandlers[1].getHandleFaultCount());
0331: assertEquals(0, protocolHandlers[2].getHandleFaultCount());
0332: assertEquals(0, protocolHandlers[3].getHandleFaultCount());
0333:
0334: assertTrue(protocolHandlers[0].getInvokeOrderOfHandleFault() < logicalHandlers[3]
0335: .getInvokeOrderOfHandleFault());
0336: assertTrue(protocolHandlers[2].getInvokeOrderOfHandleFault() < protocolHandlers[1]
0337: .getInvokeOrderOfHandleFault());
0338: }
0339:
0340: @Test
0341: public void testHandleFaultReturnsFalseOutbound() {
0342: ProtocolException pe = new ProtocolException("banzai");
0343: protocolHandlers[2].setException(pe);
0344: protocolHandlers[0].setHandleFaultRet(false);
0345:
0346: invoker.setRequestor(true);
0347: assertTrue(invoker.isOutbound());
0348:
0349: boolean continueProcessing = true;
0350: invoker.setLogicalMessageContext(lmc);
0351: continueProcessing = invoker.invokeLogicalHandlers(false, lmc);
0352: assertTrue(continueProcessing);
0353:
0354: try {
0355: invoker.setProtocolMessageContext(pmc);
0356: continueProcessing = invoker.invokeProtocolHandlers(false,
0357: pmc);
0358: fail("did not get expected exception");
0359: } catch (ProtocolException e) {
0360: assertEquals("banzai", e.getMessage());
0361: }
0362:
0363: assertFalse((Boolean) pmc
0364: .get(SOAPMessageContext.MESSAGE_OUTBOUND_PROPERTY));
0365: assertFalse((Boolean) lmc
0366: .get(LogicalMessageContext.MESSAGE_OUTBOUND_PROPERTY));
0367: assertTrue(invoker.isInbound());
0368: //assertFalse(continueProcessing);
0369:
0370: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0371: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0372: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0373: assertEquals(1, logicalHandlers[3].getHandleMessageCount());
0374: assertEquals(1, protocolHandlers[0].getHandleMessageCount());
0375: assertEquals(1, protocolHandlers[1].getHandleMessageCount());
0376: assertEquals(1, protocolHandlers[2].getHandleMessageCount());
0377: assertEquals(0, protocolHandlers[3].getHandleMessageCount());
0378: assertTrue(logicalHandlers[3].getInvokeOrderOfHandleMessage() < protocolHandlers[0]
0379: .getInvokeOrderOfHandleMessage());
0380: assertTrue(protocolHandlers[1].getInvokeOrderOfHandleMessage() < protocolHandlers[2]
0381: .getInvokeOrderOfHandleMessage());
0382:
0383: assertEquals(1, logicalHandlers[0].getCloseCount());
0384: assertEquals(1, logicalHandlers[1].getCloseCount());
0385: assertEquals(1, logicalHandlers[2].getCloseCount());
0386: assertEquals(1, logicalHandlers[3].getCloseCount());
0387:
0388: assertEquals(1, protocolHandlers[0].getCloseCount());
0389: assertEquals(1, protocolHandlers[1].getCloseCount());
0390: assertEquals(1, protocolHandlers[2].getCloseCount());
0391: assertEquals(0, protocolHandlers[3].getCloseCount());
0392:
0393: assertTrue(protocolHandlers[2].getInvokeOrderOfClose() < protocolHandlers[1]
0394: .getInvokeOrderOfClose());
0395: assertTrue(protocolHandlers[0].getInvokeOrderOfClose() < logicalHandlers[3]
0396: .getInvokeOrderOfClose());
0397:
0398: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0399: assertEquals(0, logicalHandlers[1].getHandleFaultCount());
0400: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0401: assertEquals(0, logicalHandlers[3].getHandleFaultCount());
0402:
0403: assertEquals(1, protocolHandlers[0].getHandleFaultCount());
0404: assertEquals(1, protocolHandlers[1].getHandleFaultCount());
0405: assertEquals(0, protocolHandlers[2].getHandleFaultCount());
0406: assertEquals(0, protocolHandlers[3].getHandleFaultCount());
0407:
0408: assertTrue(protocolHandlers[2].getInvokeOrderOfHandleFault() < protocolHandlers[1]
0409: .getInvokeOrderOfHandleFault());
0410: }
0411:
0412: @Test
0413: public void testHandleMessageReturnsTrue() {
0414: assertFalse(invoker.faultRaised());
0415:
0416: logicalHandlers[0].setHandleMessageRet(true);
0417: logicalHandlers[1].setHandleMessageRet(true);
0418: logicalHandlers[2].setHandleMessageRet(true);
0419: logicalHandlers[3].setHandleMessageRet(true);
0420:
0421: boolean continueProcessing = true;
0422: continueProcessing = invoker.invokeLogicalHandlers(false, lmc);
0423:
0424: assertTrue(continueProcessing);
0425:
0426: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0427: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0428: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0429: assertEquals(1, logicalHandlers[3].getHandleMessageCount());
0430: assertTrue(logicalHandlers[0].getInvokeOrderOfHandleMessage() < logicalHandlers[1]
0431: .getInvokeOrderOfHandleMessage());
0432: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleMessage() < logicalHandlers[2]
0433: .getInvokeOrderOfHandleMessage());
0434: assertTrue(logicalHandlers[2].getInvokeOrderOfHandleMessage() < logicalHandlers[3]
0435: .getInvokeOrderOfHandleMessage());
0436: assertEquals(0, logicalHandlers[0].getCloseCount());
0437: assertEquals(0, logicalHandlers[1].getCloseCount());
0438: assertEquals(0, logicalHandlers[2].getCloseCount());
0439: assertEquals(0, logicalHandlers[3].getCloseCount());
0440: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0441: assertEquals(0, logicalHandlers[1].getHandleFaultCount());
0442: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0443: assertEquals(0, logicalHandlers[3].getHandleFaultCount());
0444: }
0445:
0446: //JAX-WS 9.3.2.1:
0447: //Return false This indicates that normal message processing should cease. Subsequent actions
0448: //depend on whether the message exchange pattern (MEP) in use requires a response to the
0449: //message currently being processed or not:
0450: //Response The message direction is reversed, the runtime invokes handleMessage on the next
0451: //handler or dispatches the message (see section 9.1.2.2) if there are no further handlers.
0452: @Test
0453: public void testHandleMessageReturnsFalseWithResponseExpected() {
0454: assertFalse(invoker.faultRaised());
0455:
0456: logicalHandlers[0].setHandleMessageRet(true);
0457: logicalHandlers[1].setHandleMessageRet(true);
0458: logicalHandlers[2].setHandleMessageRet(false);
0459: logicalHandlers[3].setHandleMessageRet(true);
0460: invoker.setResponseExpected(true);
0461:
0462: boolean continueProcessing = true;
0463: invoker.setLogicalMessageContext(lmc);
0464: continueProcessing = invoker.invokeLogicalHandlers(false, lmc);
0465:
0466: assertFalse(continueProcessing);
0467:
0468: assertFalse((Boolean) lmc
0469: .get(LogicalMessageContext.MESSAGE_OUTBOUND_PROPERTY));
0470:
0471: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0472: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0473: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0474: assertEquals(0, logicalHandlers[3].getHandleMessageCount());
0475:
0476: logicalHandlers[2].setHandleMessageRet(true);
0477: invoker.invokeLogicalHandlers(false, lmc);
0478:
0479: assertEquals(2, logicalHandlers[0].getHandleMessageCount());
0480: assertEquals(2, logicalHandlers[1].getHandleMessageCount());
0481: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0482: assertEquals(0, logicalHandlers[3].getHandleMessageCount());
0483: assertTrue(logicalHandlers[3].getInvokeOrderOfHandleMessage() < logicalHandlers[2]
0484: .getInvokeOrderOfHandleMessage());
0485: assertTrue(logicalHandlers[2].getInvokeOrderOfHandleMessage() < logicalHandlers[1]
0486: .getInvokeOrderOfHandleMessage());
0487: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleMessage() < logicalHandlers[0]
0488: .getInvokeOrderOfHandleMessage());
0489:
0490: assertEquals(0, logicalHandlers[0].getCloseCount());
0491: assertEquals(0, logicalHandlers[1].getCloseCount());
0492: assertEquals(0, logicalHandlers[2].getCloseCount());
0493: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0494: assertEquals(0, logicalHandlers[1].getHandleFaultCount());
0495: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0496: }
0497:
0498: //JAX-WS 9.3.2.1:
0499: //Return false This indicates that normal message processing should cease. Subsequent actions
0500: //depend on whether the message exchange pattern (MEP) in use requires a response to the
0501: //message currently being processed or not:
0502: //No response Normal message processing stops, close is called on each previously invoked handler
0503: //in the chain, the message is dispatched
0504: @Test
0505: public void testHandleMessageReturnsFalseWithNoResponseExpected() {
0506: assertFalse(invoker.faultRaised());
0507:
0508: logicalHandlers[0].setHandleMessageRet(true);
0509: logicalHandlers[1].setHandleMessageRet(true);
0510: logicalHandlers[2].setHandleMessageRet(false);
0511: logicalHandlers[3].setHandleMessageRet(true);
0512: invoker.setResponseExpected(false);
0513:
0514: boolean continueProcessing = true;
0515: continueProcessing = invoker.invokeLogicalHandlers(false, lmc);
0516:
0517: assertFalse(continueProcessing);
0518:
0519: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0520: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0521: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0522: assertEquals(0, logicalHandlers[3].getHandleMessageCount());
0523: assertTrue(logicalHandlers[0].getInvokeOrderOfHandleMessage() < logicalHandlers[1]
0524: .getInvokeOrderOfHandleMessage());
0525: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleMessage() < logicalHandlers[2]
0526: .getInvokeOrderOfHandleMessage());
0527:
0528: //Close is invoked outside HandlerChainInvoker, eg, in SOAPHandlerInterceptor
0529: assertEquals(0, logicalHandlers[0].getCloseCount());
0530: assertEquals(0, logicalHandlers[1].getCloseCount());
0531: assertEquals(0, logicalHandlers[2].getCloseCount());
0532: assertEquals(0, logicalHandlers[3].getCloseCount());
0533:
0534: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0535: assertEquals(0, logicalHandlers[1].getHandleFaultCount());
0536: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0537: assertEquals(0, logicalHandlers[3].getHandleFaultCount());
0538: }
0539:
0540: //JAX-WS 9.3.2.1:
0541: //Throw ProtocolException or a subclass This indicates that normal message processing should cease.
0542: //Subsequent actions depend on whether the MEP in use requires a response to the message currently
0543: //being processed or not:
0544: //Response Normal message processing stops, fault message processing starts. The message direction
0545: //is reversed, if the message is not already a fault message then it is replaced with a fault message,
0546: //and the runtime invokes handleFault on the next handler or dispatches the message (see
0547: //section 9.1.2.2) if there are no further handlers.
0548: @Test
0549: public void testHandleMessageThrowsProtocolExceptionWithResponseExpected() {
0550: assertFalse(invoker.faultRaised());
0551:
0552: ProtocolException pe = new ProtocolException("banzai");
0553: logicalHandlers[2].setException(pe);
0554:
0555: invoker.setRequestor(true);
0556:
0557: //boolean continueProcessing = true;
0558: try {
0559: invoker.setLogicalMessageContext(lmc);
0560: invoker.invokeLogicalHandlers(false, lmc);
0561: fail("did not get expected exception");
0562: } catch (ProtocolException e) {
0563: assertEquals("banzai", e.getMessage());
0564: }
0565:
0566: assertTrue(invoker.faultRaised());
0567: //assertFalse(continueProcessing);
0568: //assertTrue(invoker.isClosed());
0569: assertSame(pe, invoker.getFault());
0570:
0571: assertFalse((Boolean) lmc
0572: .get(LogicalMessageContext.MESSAGE_OUTBOUND_PROPERTY));
0573:
0574: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0575: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0576: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0577: assertEquals(0, logicalHandlers[3].getHandleMessageCount());
0578: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleMessage() < logicalHandlers[2]
0579: .getInvokeOrderOfHandleMessage());
0580:
0581: assertEquals(1, logicalHandlers[0].getHandleFaultCount());
0582: assertEquals(1, logicalHandlers[1].getHandleFaultCount());
0583: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0584: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0585: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleFault() < logicalHandlers[0]
0586: .getInvokeOrderOfHandleFault());
0587:
0588: assertEquals(1, logicalHandlers[0].getCloseCount());
0589: assertEquals(1, logicalHandlers[1].getCloseCount());
0590: assertEquals(1, logicalHandlers[2].getCloseCount());
0591: assertEquals(0, logicalHandlers[3].getCloseCount());
0592: /*
0593:
0594: continueProcessing = invoker.invokeLogicalHandlers(false, lmc);
0595:
0596: assertFalse(continueProcessing);
0597: assertTrue(invoker.faultRaised());
0598: assertTrue(invoker.isClosed());
0599: assertSame(pe, invoker.getFault());
0600:
0601: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0602: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0603: assertEquals(1, logicalHandlers[0].getHandleFaultCount());
0604: assertEquals(0, logicalHandlers[1].getHandleFaultCount());*/
0605: }
0606:
0607: //JAX-WS 9.3.2.1:
0608: //Throw ProtocolException or a subclass This indicates that normal message processing should cease.
0609: //Subsequent actions depend on whether the MEP in use requires a response to the message currently
0610: //being processed or not:
0611: //No response Normal message processing stops, close is called on each previously invoked handler
0612: //in the chain, the exception is dispatched
0613: @Test
0614: public void testHandleMessageThrowsProtocolExceptionWithNoResponseExpected() {
0615: assertFalse(invoker.faultRaised());
0616:
0617: ProtocolException pe = new ProtocolException("banzai");
0618: logicalHandlers[2].setException(pe);
0619: invoker.setResponseExpected(false);
0620: invoker.setRequestor(true);
0621:
0622: //boolean continueProcessing = true;
0623: try {
0624: invoker.invokeLogicalHandlers(false, lmc);
0625: fail("did not get expected exception");
0626: } catch (ProtocolException e) {
0627: assertEquals("banzai", e.getMessage());
0628: }
0629: assertTrue(invoker.faultRaised());
0630: //assertFalse(continueProcessing);
0631: //assertTrue(invoker.isClosed());
0632: assertSame(pe, invoker.getFault());
0633:
0634: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0635: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0636: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0637: assertEquals(0, logicalHandlers[3].getHandleMessageCount());
0638: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleMessage() < logicalHandlers[2]
0639: .getInvokeOrderOfHandleMessage());
0640:
0641: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0642: assertEquals(0, logicalHandlers[1].getHandleFaultCount());
0643: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0644: assertEquals(0, logicalHandlers[3].getHandleFaultCount());
0645:
0646: assertEquals(1, logicalHandlers[0].getCloseCount());
0647: assertEquals(1, logicalHandlers[1].getCloseCount());
0648: assertEquals(1, logicalHandlers[2].getCloseCount());
0649: assertEquals(0, logicalHandlers[3].getCloseCount());
0650: assertTrue(logicalHandlers[1].getInvokeOrderOfClose() < logicalHandlers[0]
0651: .getInvokeOrderOfClose());
0652: }
0653:
0654: //Throw any other runtime exception This indicates that normal message processing should cease.
0655: //Subsequent actions depend on whether the MEP in use includes a response to the message currently being
0656: //processed or not:
0657: //Response Normal message processing stops, close is called on each previously invoked handler in
0658: //the chain, the message direction is reversed, and the exception is dispatched
0659: @Test
0660: public void testHandleMessageThrowsRuntimeExceptionWithResponseExpected() {
0661: assertFalse(invoker.faultRaised());
0662:
0663: RuntimeException re = new RuntimeException("banzai");
0664: logicalHandlers[1].setException(re);
0665: invoker.setRequestor(true);
0666:
0667: //boolean continueProcessing = true;
0668: try {
0669: invoker.invokeLogicalHandlers(false, lmc);
0670: fail("did not get expected exception");
0671: } catch (RuntimeException e) {
0672: assertEquals("banzai", e.getMessage());
0673: }
0674:
0675: //assertTrue(invoker.faultRaised());
0676: //assertFalse(continueProcessing);
0677: assertTrue(invoker.isClosed());
0678: //assertSame(re, invoker.getFault());
0679:
0680: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0681: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0682: assertEquals(0, logicalHandlers[2].getHandleMessageCount());
0683: assertEquals(0, logicalHandlers[3].getHandleMessageCount());
0684: assertTrue(logicalHandlers[0].getInvokeOrderOfHandleMessage() < logicalHandlers[1]
0685: .getInvokeOrderOfHandleMessage());
0686:
0687: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0688: assertEquals(0, logicalHandlers[1].getHandleFaultCount());
0689: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0690: assertEquals(0, logicalHandlers[3].getHandleFaultCount());
0691: assertEquals(1, logicalHandlers[0].getCloseCount());
0692: assertEquals(1, logicalHandlers[1].getCloseCount());
0693: assertEquals(0, logicalHandlers[2].getCloseCount());
0694: assertEquals(0, logicalHandlers[3].getCloseCount());
0695: }
0696:
0697: @Test
0698: public void testFaultRaised() {
0699:
0700: assertFalse(invoker.faultRaised());
0701:
0702: invoker.setFault(new ProtocolException("test exception"));
0703: assertTrue(invoker.faultRaised());
0704:
0705: // reset
0706: invoker.setFault(null);
0707: assertFalse(invoker.faultRaised());
0708:
0709: invoker.setFault(true);
0710: assertTrue(invoker.faultRaised());
0711:
0712: // reset
0713: invoker.setFault(false);
0714: invoker.setFault(null);
0715: assertFalse(invoker.faultRaised());
0716:
0717: invoker.setFault(true);
0718: invoker.setFault(new ProtocolException("test exception"));
0719: }
0720:
0721: // JAXB spec 9.3.2.2: Throw ProtocolException or a subclass This indicates
0722: // that fault message processing should cease. Fault message processing
0723: // stops, close is called on each previously invoked handler in the chain, the
0724: // exception is dispatched
0725: @Test
0726: public void testHandleFaultThrowsProtocolException() {
0727: ProtocolException pe = new ProtocolException("banzai");
0728: ProtocolException pe2 = new ProtocolException("banzai2");
0729: // throw exception during handleFault processing
0730: logicalHandlers[2].setException(pe);
0731: logicalHandlers[1].setFaultException(pe2);
0732: invoker.setRequestor(true);
0733:
0734: boolean continueProcessing = false;
0735: try {
0736: continueProcessing = invoker.invokeLogicalHandlers(false,
0737: lmc);
0738: fail("did not get expected exception");
0739: } catch (ProtocolException e) {
0740: assertEquals("banzai2", e.getMessage());
0741: }
0742:
0743: assertFalse(continueProcessing);
0744: assertTrue(invoker.isClosed());
0745:
0746: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0747: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0748: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0749: assertEquals(0, logicalHandlers[3].getHandleMessageCount());
0750: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleMessage() < logicalHandlers[2]
0751: .getInvokeOrderOfHandleMessage());
0752:
0753: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0754: assertEquals(1, logicalHandlers[1].getHandleFaultCount());
0755: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0756:
0757: assertEquals(1, logicalHandlers[0].getCloseCount());
0758: assertEquals(1, logicalHandlers[1].getCloseCount());
0759: assertEquals(1, logicalHandlers[2].getCloseCount());
0760: assertEquals(0, logicalHandlers[3].getCloseCount());
0761: assertTrue(logicalHandlers[2].getInvokeOrderOfClose() < logicalHandlers[1]
0762: .getInvokeOrderOfClose());
0763: assertTrue(logicalHandlers[1].getInvokeOrderOfClose() < logicalHandlers[0]
0764: .getInvokeOrderOfClose());
0765:
0766: }
0767:
0768: // JAXB spec 9.3.2.2: Throw any other runtime exception This indicates
0769: // that fault message processing should cease. Fault message processing stops,
0770: // close is called on each previously invoked handler in the chain, the exception is
0771: // dispatched
0772: @Test
0773: public void testHandleFaultThrowsRuntimeException() {
0774: ProtocolException pe = new ProtocolException("banzai");
0775: RuntimeException re = new RuntimeException("banzai");
0776: // throw exception during handleFault processing
0777: logicalHandlers[2].setException(pe);
0778: logicalHandlers[1].setFaultException(re);
0779: invoker.setRequestor(true);
0780:
0781: boolean continueProcessing = false;
0782: try {
0783: continueProcessing = invoker.invokeLogicalHandlers(false,
0784: lmc);
0785: fail("did not get expected exception");
0786: } catch (RuntimeException e) {
0787: assertEquals("banzai", e.getMessage());
0788: }
0789:
0790: assertFalse(continueProcessing);
0791: assertTrue(invoker.isClosed());
0792:
0793: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0794: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0795: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0796: assertEquals(0, logicalHandlers[3].getHandleMessageCount());
0797:
0798: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0799: assertEquals(1, logicalHandlers[1].getHandleFaultCount());
0800: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0801:
0802: assertEquals(1, logicalHandlers[0].getCloseCount());
0803: assertEquals(1, logicalHandlers[1].getCloseCount());
0804: assertEquals(1, logicalHandlers[2].getCloseCount());
0805: assertEquals(0, logicalHandlers[3].getCloseCount());
0806: assertTrue(logicalHandlers[2].getInvokeOrderOfClose() < logicalHandlers[1]
0807: .getInvokeOrderOfClose());
0808: assertTrue(logicalHandlers[1].getInvokeOrderOfClose() < logicalHandlers[0]
0809: .getInvokeOrderOfClose());
0810: }
0811:
0812: //JAXB spec 9.3.2.2: Return true This indicates that fault message processing
0813: //should continue. The runtime invokes handle Fault on the next handler or dispatches
0814: //the fault message (see section 9.1.2.2) if there are no further handlers.
0815: @Test
0816: public void testHandleFaultReturnsTrue() {
0817: ProtocolException pe = new ProtocolException("banzai");
0818: logicalHandlers[2].setException(pe);
0819: invoker.setRequestor(true);
0820:
0821: logicalHandlers[0].setHandleFaultRet(true);
0822: logicalHandlers[1].setHandleFaultRet(true);
0823: logicalHandlers[2].setHandleFaultRet(true);
0824: logicalHandlers[3].setHandleFaultRet(true);
0825:
0826: boolean continueProcessing = false;
0827: try {
0828: continueProcessing = invoker.invokeLogicalHandlers(false,
0829: lmc);
0830: fail("did not get expected exception");
0831: } catch (RuntimeException e) {
0832: assertEquals("banzai", e.getMessage());
0833: }
0834:
0835: assertFalse(continueProcessing);
0836: //assertTrue(invoker.isClosed());
0837:
0838: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0839: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0840: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0841: assertEquals(0, logicalHandlers[3].getHandleMessageCount());
0842:
0843: assertEquals(1, logicalHandlers[0].getHandleFaultCount());
0844: assertEquals(1, logicalHandlers[1].getHandleFaultCount());
0845: assertEquals(0, logicalHandlers[2].getHandleFaultCount());
0846: assertEquals(0, logicalHandlers[3].getHandleFaultCount());
0847: assertTrue(logicalHandlers[1].getInvokeOrderOfHandleFault() < logicalHandlers[0]
0848: .getInvokeOrderOfHandleFault());
0849:
0850: assertEquals(1, logicalHandlers[0].getCloseCount());
0851: assertEquals(1, logicalHandlers[1].getCloseCount());
0852: assertEquals(1, logicalHandlers[2].getCloseCount());
0853: assertEquals(0, logicalHandlers[3].getCloseCount());
0854: }
0855:
0856: //JAXB spec 9.3.2.2: Return false This indicates that fault message processing
0857: //should cease. Fault message processing stops, close is called on each previously invoked
0858: //handler in the chain, the fault message is dispatched
0859: @Test
0860: public void testHandleFaultReturnsFalse() {
0861: ProtocolException pe = new ProtocolException("banzai");
0862: logicalHandlers[3].setException(pe);
0863: invoker.setRequestor(true);
0864:
0865: logicalHandlers[0].setHandleFaultRet(true);
0866: logicalHandlers[1].setHandleFaultRet(true);
0867: logicalHandlers[2].setHandleFaultRet(false);
0868: logicalHandlers[3].setHandleFaultRet(true);
0869:
0870: boolean continueProcessing = false;
0871: try {
0872: continueProcessing = invoker.invokeLogicalHandlers(false,
0873: lmc);
0874: fail("did not get expected exception");
0875: } catch (RuntimeException e) {
0876: assertEquals("banzai", e.getMessage());
0877: }
0878:
0879: assertFalse(continueProcessing);
0880: //assertTrue(invoker.isClosed());
0881:
0882: assertEquals(1, logicalHandlers[0].getHandleMessageCount());
0883: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0884: assertEquals(1, logicalHandlers[2].getHandleMessageCount());
0885: assertEquals(1, logicalHandlers[3].getHandleMessageCount());
0886:
0887: assertEquals(0, logicalHandlers[0].getHandleFaultCount());
0888: assertEquals(0, logicalHandlers[1].getHandleFaultCount());
0889: assertEquals(1, logicalHandlers[2].getHandleFaultCount());
0890: assertEquals(0, logicalHandlers[3].getHandleFaultCount());
0891:
0892: assertEquals(1, logicalHandlers[0].getCloseCount());
0893: assertEquals(1, logicalHandlers[1].getCloseCount());
0894: assertEquals(1, logicalHandlers[2].getCloseCount());
0895: assertEquals(1, logicalHandlers[3].getCloseCount());
0896:
0897: assertTrue(logicalHandlers[3].getInvokeOrderOfClose() < logicalHandlers[2]
0898: .getInvokeOrderOfClose());
0899: assertTrue(logicalHandlers[2].getInvokeOrderOfClose() < logicalHandlers[1]
0900: .getInvokeOrderOfClose());
0901: assertTrue(logicalHandlers[1].getInvokeOrderOfClose() < logicalHandlers[0]
0902: .getInvokeOrderOfClose());
0903: }
0904:
0905: @Test
0906: public void testMEPComplete() {
0907:
0908: invoker.invokeLogicalHandlers(false, lmc);
0909: invoker.invokeProtocolHandlers(false, pmc);
0910: assertEquals(8, invoker.getInvokedHandlers().size());
0911:
0912: invoker.mepComplete(message);
0913:
0914: assertTrue("close not invoked on logicalHandlers",
0915: logicalHandlers[0].isCloseInvoked());
0916: assertTrue("close not invoked on logicalHandlers",
0917: logicalHandlers[1].isCloseInvoked());
0918: assertTrue("close not invoked on protocolHandlers",
0919: protocolHandlers[0].isCloseInvoked());
0920: assertTrue("close not invoked on protocolHandlers",
0921: protocolHandlers[1].isCloseInvoked());
0922:
0923: assertTrue(
0924: "incorrect invocation order of close",
0925: protocolHandlers[1].getInvokeOrderOfClose() < protocolHandlers[0]
0926: .getInvokeOrderOfClose());
0927: assertTrue(
0928: "incorrect invocation order of close",
0929: protocolHandlers[0].getInvokeOrderOfClose() < logicalHandlers[1]
0930: .getInvokeOrderOfClose());
0931: assertTrue(
0932: "incorrect invocation order of close",
0933: logicalHandlers[1].getInvokeOrderOfClose() < logicalHandlers[0]
0934: .getInvokeOrderOfClose());
0935: }
0936:
0937: @Test
0938: public void testResponseExpectedDefault() {
0939: assertTrue(invoker.isResponseExpected());
0940: }
0941:
0942: /* test invoking logical handlers when processing has been aborted
0943: * with both protocol and logical handlers in invokedHandlers list.
0944: *
0945: */
0946: @Test
0947: public void testInvokedAlreadyInvokedMixed() {
0948:
0949: // simulate an invocation being aborted by a logical handler
0950: //
0951: logicalHandlers[1].setHandleMessageRet(false);
0952: invoker.setInbound();
0953: invoker.invokeProtocolHandlers(true, pmc);
0954: invoker.invokeLogicalHandlers(true, lmc);
0955:
0956: assertEquals(7, invoker.getInvokedHandlers().size());
0957: // assertTrue(!invoker.getInvokedHandlers().contains(logicalHandlers[1]));
0958: assertTrue(invoker.getInvokedHandlers().contains(
0959: protocolHandlers[0]));
0960: assertTrue(invoker.getInvokedHandlers().contains(
0961: protocolHandlers[1]));
0962: assertEquals(0, logicalHandlers[0].getHandleMessageCount());
0963: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0964:
0965: logicalHandlers[1].setHandleMessageRet(true);
0966: invoker.invokeLogicalHandlers(true, lmc);
0967: invoker.invokeProtocolHandlers(true, pmc);
0968:
0969: assertEquals(2, protocolHandlers[0].getHandleMessageCount());
0970: assertEquals(2, protocolHandlers[1].getHandleMessageCount());
0971:
0972: assertEquals(1, logicalHandlers[1].getHandleMessageCount());
0973: assertEquals(0, logicalHandlers[0].getHandleMessageCount());
0974: assertEquals(2, protocolHandlers[0].getHandleMessageCount());
0975: assertEquals(2, protocolHandlers[1].getHandleMessageCount());
0976:
0977: }
0978:
0979: /*public void testHandlerReturnFalse() {
0980: logicalHandlers[1].setHandleMessageRet(false);
0981: invoker.setInbound();
0982: doInvokeProtocolHandlers(true);
0983: invoker.invokeLogicalHandlers(true, lmc);
0984:
0985: }*/
0986:
0987: protected void checkLogicalHandlersInvoked(
0988: boolean outboundProperty, boolean requestorProperty) {
0989:
0990: invoker.invokeLogicalHandlers(requestorProperty, lmc);
0991:
0992: assertNotNull(message
0993: .get(MessageContext.MESSAGE_OUTBOUND_PROPERTY));
0994: assertEquals(outboundProperty, message
0995: .get(MessageContext.MESSAGE_OUTBOUND_PROPERTY));
0996: // assertNotNull(message.get(ObjectMessageContext.REQUESTOR_ROLE_PROPERTY));
0997: // assertEquals(requestorProperty, message.get(ObjectMessageContext.REQUESTOR_ROLE_PROPERTY));
0998: assertTrue("handler not invoked", logicalHandlers[0]
0999: .isHandleMessageInvoked());
1000: assertTrue("handler not invoked", logicalHandlers[1]
1001: .isHandleMessageInvoked());
1002: assertTrue(invoker.getInvokedHandlers().contains(
1003: logicalHandlers[0]));
1004: assertTrue(invoker.getInvokedHandlers().contains(
1005: logicalHandlers[1]));
1006: }
1007:
1008: protected void checkProtocolHandlersInvoked(boolean outboundProperty) {
1009:
1010: invoker.invokeProtocolHandlers(false, pmc);
1011:
1012: assertTrue("handler not invoked", protocolHandlers[0]
1013: .isHandleMessageInvoked());
1014: assertTrue("handler not invoked", protocolHandlers[1]
1015: .isHandleMessageInvoked());
1016:
1017: assertTrue(invoker.getInvokedHandlers().contains(
1018: protocolHandlers[0]));
1019: assertTrue(invoker.getInvokedHandlers().contains(
1020: protocolHandlers[1]));
1021: }
1022:
1023: private String getSourceAsString(Source s) {
1024: String result = "";
1025:
1026: try {
1027: Transformer transformer = TransformerFactory.newInstance()
1028: .newTransformer();
1029: transformer.setOutputProperty(
1030: OutputKeys.OMIT_XML_DECLARATION, "yes");
1031: transformer.setOutputProperty(OutputKeys.METHOD, "xml");
1032: OutputStream out = new ByteArrayOutputStream();
1033: StreamResult streamResult = new StreamResult();
1034: streamResult.setOutputStream(out);
1035: transformer.transform(s, streamResult);
1036: return streamResult.getOutputStream().toString();
1037: } catch (Exception e) {
1038: //do nothing
1039: }
1040: return result;
1041: }
1042:
1043: static class TestProtocolHandler extends
1044: AbstractHandlerBase<SOAPMessageContext> {
1045:
1046: }
1047:
1048: static class TestLogicalHandler extends
1049: AbstractHandlerBase<LogicalMessageContextImpl> implements
1050: LogicalHandler<LogicalMessageContextImpl> {
1051:
1052: }
1053:
1054: static class AbstractHandlerBase<T extends MessageContext>
1055: implements Handler<T> {
1056:
1057: private static int sinvokedOrder;
1058: private static int sid;
1059:
1060: private int invokeOrderOfHandleMessage;
1061: private int invokeOrderOfHandleFault;
1062: private int invokeOrderOfClose;
1063: private final int id = ++sid;
1064:
1065: private int handleMessageInvoked;
1066: private int handleFaultInvoked;
1067: private boolean handleMessageRet = true;
1068: private boolean handleFaultRet = true;
1069: private RuntimeException exception;
1070: private RuntimeException faultException;
1071:
1072: private int closeInvoked;
1073:
1074: public void reset() {
1075: handleMessageInvoked = 0;
1076: handleFaultInvoked = 0;
1077: handleMessageRet = true;
1078: }
1079:
1080: public boolean handleMessage(T arg0) {
1081: invokeOrderOfHandleMessage = ++sinvokedOrder;
1082: handleMessageInvoked++;
1083:
1084: if (exception != null) {
1085: RuntimeException e = exception;
1086: exception = null;
1087: throw e;
1088: }
1089:
1090: return handleMessageRet;
1091: }
1092:
1093: public boolean handleFault(T arg0) {
1094: invokeOrderOfHandleFault = ++sinvokedOrder;
1095: handleFaultInvoked++;
1096:
1097: if (faultException != null) {
1098: throw faultException;
1099: }
1100:
1101: return handleFaultRet;
1102: }
1103:
1104: public void close(MessageContext arg0) {
1105: invokeOrderOfClose = ++sinvokedOrder;
1106: closeInvoked++;
1107: }
1108:
1109: public void init(Map<String, Object> arg0) {
1110: // TODO Auto-generated method stub
1111: }
1112:
1113: public void destroy() {
1114: // TODO Auto-generated method stub
1115: }
1116:
1117: public int getHandleMessageCount() {
1118: return handleMessageInvoked;
1119: }
1120:
1121: public int getHandleFaultCount() {
1122: return handleFaultInvoked;
1123: }
1124:
1125: public boolean isHandleMessageInvoked() {
1126: return handleMessageInvoked > 0;
1127: }
1128:
1129: public boolean isCloseInvoked() {
1130: return closeInvoked > 0;
1131: }
1132:
1133: public int getCloseCount() {
1134: return closeInvoked;
1135: }
1136:
1137: public int getInvokeOrderOfHandleMessage() {
1138: return invokeOrderOfHandleMessage;
1139: }
1140:
1141: public int getInvokeOrderOfHandleFault() {
1142: return invokeOrderOfHandleFault;
1143: }
1144:
1145: public int getInvokeOrderOfClose() {
1146: return invokeOrderOfClose;
1147: }
1148:
1149: public void setHandleMessageRet(boolean ret) {
1150: handleMessageRet = ret;
1151: }
1152:
1153: public void setHandleFaultRet(boolean ret) {
1154: handleFaultRet = ret;
1155: }
1156:
1157: public String toString() {
1158: return "[" + super .toString() + " id: " + id
1159: + " invoke order: " + invokeOrderOfHandleMessage
1160: + "]";
1161: }
1162:
1163: public void setException(RuntimeException rte) {
1164: exception = rte;
1165: }
1166:
1167: public void setFaultException(RuntimeException rte) {
1168: faultException = rte;
1169: }
1170:
1171: public static void clear() {
1172: sinvokedOrder = 0;
1173: sid = 0;
1174: }
1175: }
1176:
1177: }
|