| /* | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| */ | |
| package org.apache.axis2.jaxws.handler; | |
| import org.apache.axiom.om.OMAbstractFactory; | |
| import org.apache.axiom.om.OMFactory; | |
| import org.apache.axiom.soap.RolePlayer; | |
| import org.apache.axiom.soap.SOAPEnvelope; | |
| import org.apache.axiom.soap.SOAPFactory; | |
| import org.apache.axiom.soap.SOAPHeader; | |
| import org.apache.axiom.soap.SOAPHeaderBlock; | |
| import org.apache.axis2.AxisFault; | |
| import org.apache.axis2.Constants; | |
| import org.apache.axis2.context.ConfigurationContext; | |
| import org.apache.axis2.context.ConfigurationContextFactory; | |
| import org.apache.axis2.context.MessageContext; | |
| import org.apache.axis2.description.AxisService; | |
| import org.apache.axis2.engine.AxisConfiguration; | |
| import org.apache.axis2.jaxws.description.DescriptionFactory; | |
| import org.apache.axis2.jaxws.description.EndpointDescription; | |
| import org.apache.axis2.jaxws.description.ServiceDescription; | |
| import org.apache.axis2.jaxws.description.xml.handler.HandlerChainType; | |
| import org.apache.axis2.jaxws.description.xml.handler.HandlerChainsType; | |
| import org.apache.axis2.jaxws.description.xml.handler.HandlerType; | |
| import javax.jws.HandlerChain; | |
| import javax.jws.WebService; | |
| import javax.xml.namespace.QName; | |
| import javax.xml.ws.handler.Handler; | |
| import javax.xml.ws.handler.PortInfo; | |
| import java.util.ArrayList; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import junit.framework.TestCase; | |
| /** | |
| * Test Role (SOAP 1.2 terminology) or Actor (SOAP 1.1 terminology) mustUndertand processing. | |
| */ | |
| public class RoleBasedMustUndertandTests extends TestCase { | |
| private SOAPFactory soap11Factory; | |
| private SOAPFactory soap12Factory; | |
| private OMFactory omFactory; | |
| private String namespace = "http://RoleBasedMustUnderstandTest/good/namespace"; | |
| private String soap11Namespace = "http://schemas.xmlsoap.org/soap/envelope/"; | |
| private String header_ultimateReceiver = "header_ultimateReceiver"; | |
| private String header_ultimateReceiver_processed = "header_ultmiateReceiver_processed"; | |
| private String header_rolePlayed = "header_rolePlayed"; | |
| private String header_roleNotPlayed = "header_roleNotPlayed"; | |
| private String header_bindingAdded = "header_bindingAdded"; | |
| private String header_SoapNext = "header_SoapNext"; | |
| private String rolePlayed1 = "http://Role/Played/role1"; | |
| private String roleNotPlayed = "http://Role/Not/Played/role1"; | |
| private String roleBindingAdded = "http://Role/Added/By/Binding"; | |
| private String roleNoHeaders = "http://Role/Played/No/Headers"; | |
| private String roleHandlerAdded = "http://org/apache/axis2/jaxws/handler/AddedRole"; | |
| private String roleHandlerAdded2 = "http://org/apache/axis2/jaxws/handler/AddedRole2"; | |
| private String roleSoap11Next = "http://schemas.xmlsoap.org/soap/actor/next"; | |
| public RoleBasedMustUndertandTests(String testName) { | |
| super(testName); | |
| soap11Factory = OMAbstractFactory.getSOAP11Factory(); | |
| soap12Factory = OMAbstractFactory.getSOAP12Factory(); | |
| omFactory = OMAbstractFactory.getOMFactory(); | |
| } | |
| /** | |
| * Validate that handler information can be cached on the ServiceDescritpion on the server side. | |
| */ | |
| public void testCachingOnServer() { | |
| ServiceDescription serviceDesc = DescriptionFactory.createServiceDescription(RoleBasedMUServiceImpl.class); | |
| HandlerResolverImpl handlerResolver1 = new HandlerResolverImpl(serviceDesc); | |
| HandlerResolverImpl handlerResolver2 = new HandlerResolverImpl(serviceDesc); | |
| EndpointDescription epDesc = serviceDesc.getEndpointDescriptions()[0]; | |
| PortInfo portInfo = epDesc.getPortInfo(); | |
| List<String> roles1 = handlerResolver1.getRoles(portInfo); | |
| List<String> roles2 = handlerResolver2.getRoles(portInfo); | |
| assertNotNull(roles1); | |
| assertNotNull(roles2); | |
| assertTrue(roles1 == roles2); | |
| } | |
| /** | |
| * Validate that handler information can NOT be cached on the client. That is because the client | |
| * can specify handler information per instance of a service delegate. Those service | |
| * delegates could share a ServiceDescription, but since each service delegate could specify | |
| * unique handler information, we can't use common handler information stored on the | |
| * ServiceDescription | |
| */ | |
| public void testCachingOnClient() { | |
| ServiceDescription serviceDesc = DescriptionFactory.createServiceDescription(RoleBasedMUServiceImpl.class); | |
| HandlerResolverImpl handlerResolver1 = new HandlerResolverImpl(serviceDesc, "sd1"); | |
| HandlerResolverImpl handlerResolver2 = new HandlerResolverImpl(serviceDesc, "sd2"); | |
| EndpointDescription epDesc = serviceDesc.getEndpointDescriptions()[0]; | |
| PortInfo portInfo = epDesc.getPortInfo(); | |
| List<String> roles1 = handlerResolver1.getRoles(portInfo); | |
| List<String> roles2 = handlerResolver2.getRoles(portInfo); | |
| assertNotNull(roles1); | |
| assertNotNull(roles2); | |
| assertTrue(roles1 != roles2); | |
| } | |
| /** | |
| * The JAXWS Spec, section 10, says roles can be set on the SOAP binding. Verify that a | |
| * mustUnderstand header which is not processed for a role added by the SOAPBinding causes | |
| * a Not Understood fault | |
| */ | |
| public void testRoleAddedToSoapBinding() { | |
| RolePlayer rolePlayer = new UltimateDestinationRoles(); | |
| MessageContext mscCtx11 = createMessageContext(soap11Factory); | |
| // Note that since this role is UltimateReceiver, all unprocessed headers will be set | |
| // on the message context | |
| setUnprocessedHeaders(mscCtx11, rolePlayer); | |
| // Indicate we understand (e.g. via handlers) the headers for Ultimate Receiver and the | |
| // role we are acting in. We don't indicate we understand the header that the SOAPBinding | |
| // added, so that should cause an exception | |
| List<QName> understoodHeaders = new ArrayList<QName>(); | |
| understoodHeaders.add(new QName(namespace, header_ultimateReceiver)); | |
| understoodHeaders.add(new QName(namespace, header_rolePlayed)); | |
| // Create a list of additional roles that acted in (e.g. one played by a JAXWS | |
| // handler) | |
| List<String> headerRolesPlayed = bindingAddedRole(); | |
| try { | |
| HandlerUtils.checkMustUnderstand(mscCtx11, understoodHeaders, headerRolesPlayed); | |
| fail("Should have gotten NotUnderstood fault for header for role added by binding: " + header_bindingAdded); | |
| } catch (AxisFault af) { | |
| // Expected path; should get exception for ultimate receiver not processed. | |
| String checkFault = af.toString(); | |
| if (!checkFault.contains("Must Understand check failed") | |
| || !checkFault.contains(header_bindingAdded)) { | |
| fail("Did not get expected NotUnderstood AxisFault. Unexpected fault " + af); | |
| } | |
| } catch (Exception e) { | |
| fail("Caught unexpected exception + e"); | |
| } | |
| } | |
| /** | |
| * Test where there are no previous non-understood headers on the MessageContext and there's an | |
| * additional Role added by a JAXWS handler | |
| */ | |
| public void testOnlySoapBindingRole() { | |
| MessageContext mscCtx11 = createMessageContext(soap11Factory); | |
| // Note that we are not putting any non-understood headers on the message context | |
| // Create a list of additional roles (e.g. one played by a JAXWS | |
| // handler | |
| List<String> headerRolesPlayed = bindingAddedRole(); | |
| try { | |
| HandlerUtils.checkMustUnderstand(mscCtx11, null, headerRolesPlayed); | |
| fail("Should have gotten NotUnderstood fault for header for role added by binding: " + header_bindingAdded); | |
| } catch (AxisFault af) { | |
| // Expected path; should get exception for ultimate receiver not processed. | |
| String checkFault = af.toString(); | |
| if (!checkFault.contains("Must Understand check failed") | |
| || !checkFault.contains(header_bindingAdded)) { | |
| fail("Did not get expected NotUnderstood AxisFault. Unexpected fault " + af); | |
| } | |
| } catch (Exception e) { | |
| fail("Caught unexpected exception + e"); | |
| } | |
| } | |
| /** | |
| * Test that adding a role for headers that does not exist does not cause any fault | |
| */ | |
| public void testNoHeadersForSoapBindingRole() { | |
| MessageContext mscCtx11 = createMessageContext(soap11Factory); | |
| List<String> headerRolesPlayed = noHeadersRole(); | |
| try { | |
| HandlerUtils.checkMustUnderstand(mscCtx11, null, headerRolesPlayed); | |
| } catch (AxisFault af) { | |
| fail("Unexpected AxisFault "+ af); | |
| } catch (Exception e) { | |
| fail("Caught unexpected exception + e"); | |
| } | |
| } | |
| /** | |
| * A mustUnderstand header for a role not being acted in should NOT cause a notUnderstood | |
| * fault. | |
| */ | |
| public void testRoleNotActingIn() { | |
| RolePlayer rolePlayer = new UltimateDestinationRoles(); | |
| MessageContext mscCtx11 = createMessageContext(soap11Factory); | |
| // Note that since this role is UltimateReceiver, all unprocessed headers will be set | |
| // on the message context | |
| setUnprocessedHeaders(mscCtx11, rolePlayer); | |
| // Indicate we understand (e.g. via handlers) the headers for Ultimate Receiver and the | |
| // role we are acting in. This leaves the mustUnderstand header for the role we are not | |
| // acting in, which should not cause an exception. | |
| List<QName> understoodHeaders = new ArrayList<QName>(); | |
| understoodHeaders.add(new QName(namespace, header_ultimateReceiver)); | |
| understoodHeaders.add(new QName(namespace, header_rolePlayed)); | |
| try { | |
| HandlerUtils.checkMustUnderstand(mscCtx11, understoodHeaders, null); | |
| } catch (AxisFault e) { | |
| fail("Should not have caught an AxisFault " + e); | |
| } | |
| } | |
| /** | |
| * Test mustUnderstand processing for Ultimate Receiver with an understood header list | |
| * passed to the mustUnderstand checking | |
| */ | |
| public void testUltimateReceiverRoles() { | |
| RolePlayer rolePlayer = new UltimateDestinationRoles(); | |
| MessageContext mscCtx11 = createMessageContext(soap11Factory); | |
| setUnprocessedHeaders(mscCtx11, rolePlayer); | |
| // Indicate we understand (e.g. via handlers) all the headers. | |
| List<QName> understoodHeaders = new ArrayList<QName>(); | |
| understoodHeaders.add(new QName(namespace, header_ultimateReceiver)); | |
| understoodHeaders.add(new QName(namespace, header_rolePlayed)); | |
| try { | |
| HandlerUtils.checkMustUnderstand(mscCtx11, understoodHeaders, null); | |
| } catch (AxisFault e) { | |
| fail("Should not have caught an AxisFault " + e); | |
| } | |
| } | |
| /** | |
| * Verify that an Ultimate Receiver with no roles only yields the header with no role specified | |
| * as unprocessed and that passing a list of understood headers including just that one causes | |
| * the mustUnderstand checks to pass. | |
| */ | |
| public void testUltimateReceiver() { | |
| RolePlayer rolePlayer = new UltimateDestinationNoRoles(); | |
| MessageContext msgCtx = createMessageContext(soap11Factory); | |
| // Indicate the must understand header without an explicit role will be understood. | |
| // The other headers, with explicit roles, should not cause an error. | |
| setUnprocessedHeaders(msgCtx, rolePlayer); | |
| List<QName> understoodHeaders = new ArrayList<QName>(); | |
| understoodHeaders.add(new QName(namespace, header_ultimateReceiver)); | |
| try { | |
| HandlerUtils.checkMustUnderstand(msgCtx, understoodHeaders, null); | |
| } catch (AxisFault e) { | |
| fail("Should not have caught and AxisFault " + e); | |
| } | |
| } | |
| /** | |
| * Test mustUnderstand processing for Ultimate Receiver without additional understood headers | |
| * being passed to the checker. This should cause a notUnderstood fault | |
| */ | |
| public void testUltimateReceiverNoRoles() { | |
| RolePlayer rolePlayer = new UltimateDestinationNoRoles(); | |
| MessageContext messageContext11 = createMessageContext(soap11Factory); | |
| setUnprocessedHeaders(messageContext11, rolePlayer); | |
| try { | |
| HandlerUtils.checkMustUnderstand(messageContext11, null, null); | |
| fail("Should have gotten MustUnderstand Header Not Understood fault"); | |
| } catch (AxisFault af) { | |
| // Expected path; should get exception for ultimate receiver not processed. | |
| String checkFault = af.toString(); | |
| if (!checkFault.contains("Must Understand check failed") | |
| || !checkFault.contains(header_ultimateReceiver)) { | |
| fail("Did not get expected NotUnderstood AxisFault. Unexpected fault " + af); | |
| } | |
| } catch (Exception e) { | |
| fail("Caught unexpected exception + e"); | |
| } | |
| MessageContext messageContext12 = createMessageContext(soap12Factory); | |
| setUnprocessedHeaders(messageContext12, rolePlayer); | |
| try { | |
| HandlerUtils.checkMustUnderstand(messageContext12, null, null); | |
| fail("Should have gotten MustUnderstand Header Not Understood fault"); | |
| } catch (AxisFault af) { | |
| // Expected path; should get exception for ultimate receiver not processed. | |
| if (!af.toString().contains("Must Understand check failed")) { | |
| fail("Did not get expected NotUnderstood AxisFault. Unexpected fault " + af); | |
| } | |
| } catch (Exception e) { | |
| fail("Caught unexpected exception + e"); | |
| } | |
| } | |
| /** | |
| * Test a RolePlayer that is not an ultimate receiver and does not act in any roles | |
| * corresponding to headers. There should be no faults cause by the mustUnderstand headers | |
| */ | |
| public void testNotUltimateReceiverNoRoles() { | |
| RolePlayer rolePlayer = new NotUltimateDestinationNoRoles(); | |
| MessageContext msgCtx11 = createMessageContext(soap11Factory); | |
| setUnprocessedHeaders(msgCtx11, rolePlayer); | |
| try { | |
| HandlerUtils.checkMustUnderstand(msgCtx11, null, null); | |
| } catch (AxisFault e) { | |
| fail("Should not have caught and AxisFault"); | |
| } | |
| MessageContext msgCtx12 = createMessageContext(soap12Factory); | |
| setUnprocessedHeaders(msgCtx12, rolePlayer); | |
| try { | |
| HandlerUtils.checkMustUnderstand(msgCtx12, null, null); | |
| } catch (AxisFault e) { | |
| fail("Should not have caught and AxisFault"); | |
| } | |
| } | |
| /** | |
| * Test that the HandlerResolverImpl returns the correct roles defined in the handler config | |
| * file <soap-role> elements. | |
| */ | |
| public void testHandlerResolverGetRoles() { | |
| ServiceDescription serviceDesc = DescriptionFactory.createServiceDescription(RoleBasedMUServiceImpl.class); | |
| HandlerResolverImpl handlerResolver = new HandlerResolverImpl(serviceDesc); | |
| EndpointDescription epDesc = serviceDesc.getEndpointDescriptions()[0]; | |
| // Make sure the role information is specified in the handler config file | |
| HandlerChainsType epHandlerChains = epDesc.getHandlerChain(); | |
| assertNotNull(epHandlerChains); | |
| List<HandlerChainType> epHandlerChain = epHandlerChains.getHandlerChain(); | |
| assertEquals(1, epHandlerChain.size()); | |
| List<HandlerType> epHandler = epHandlerChain.get(0).getHandler(); | |
| assertEquals(1, epHandler.size()); | |
| HandlerType handlerType = epHandler.get(0); | |
| List<org.apache.axis2.jaxws.description.xml.handler.String> soapRoles = | |
| handlerType.getSoapRole(); | |
| assertNotNull(soapRoles); | |
| assertEquals(1, soapRoles.size()); | |
| String addedRole = soapRoles.get(0).getValue(); | |
| assertEquals(roleHandlerAdded, addedRole); | |
| // Now verify the role information in the handler config file correctly affects the | |
| // roles played returned from the Resolver | |
| PortInfo portInfo = epDesc.getPortInfo(); | |
| List<String> handlerRoles = handlerResolver.getRoles(portInfo); | |
| assertNotNull(handlerRoles); | |
| assertEquals(1, handlerRoles.size()); | |
| assertEquals(roleHandlerAdded, handlerRoles.get(0)); | |
| List<Handler> handlerChain = handlerResolver.getHandlerChain(portInfo); | |
| assertNotNull(handlerChain); | |
| assertEquals(1, handlerChain.size()); | |
| } | |
| /** | |
| * Test that multiple <soap-role> elements in the handler config file work correctly. | |
| */ | |
| public void testHandlerResolverGerRoles2() { | |
| ServiceDescription serviceDesc = DescriptionFactory.createServiceDescription(RoleBasedMUServiceImpl2.class); | |
| HandlerResolverImpl handlerResolver = new HandlerResolverImpl(serviceDesc); | |
| EndpointDescription epDesc = serviceDesc.getEndpointDescriptions()[0]; | |
| // Make sure the role information is specified in the handler config file | |
| HandlerChainsType epHandlerChains = epDesc.getHandlerChain(); | |
| assertNotNull(epHandlerChains); | |
| List<HandlerChainType> epHandlerChain = epHandlerChains.getHandlerChain(); | |
| assertEquals(1, epHandlerChain.size()); | |
| List<HandlerType> epHandler = epHandlerChain.get(0).getHandler(); | |
| assertEquals(1, epHandler.size()); | |
| HandlerType handlerType = epHandler.get(0); | |
| List<org.apache.axis2.jaxws.description.xml.handler.String> soapRoles = | |
| handlerType.getSoapRole(); | |
| assertNotNull(soapRoles); | |
| assertEquals(2, soapRoles.size()); | |
| ArrayList<String> checkRoles = new ArrayList<String>(); | |
| checkRoles.add(soapRoles.get(0).getValue()); | |
| checkRoles.add(soapRoles.get(1).getValue()); | |
| assertTrue(checkRoles.contains(roleHandlerAdded)); | |
| assertTrue(checkRoles.contains(roleHandlerAdded2)); | |
| // Now verify the role information in the handler config file correctly affects the | |
| // roles played returned from the Resolver | |
| PortInfo portInfo = epDesc.getPortInfo(); | |
| List<String> handlerRoles = handlerResolver.getRoles(portInfo); | |
| assertNotNull(handlerRoles); | |
| assertEquals(2, handlerRoles.size()); | |
| ArrayList<String> checkResolverRoles = new ArrayList<String>(); | |
| checkResolverRoles.add((String) handlerRoles.get(0)); | |
| checkResolverRoles.add((String) handlerRoles.get(1)); | |
| assertTrue(checkResolverRoles.contains(roleHandlerAdded)); | |
| assertTrue(checkResolverRoles.contains(roleHandlerAdded2)); | |
| List<Handler> handlerChain = handlerResolver.getHandlerChain(portInfo); | |
| assertNotNull(handlerChain); | |
| assertEquals(1, handlerChain.size()); | |
| } | |
| /** | |
| * Test that a RolePlayer with no roles doesn't cause any problems in the mustUnderstand | |
| * checking. | |
| */ | |
| public void testHandlerResolverEmptyRolesPlayed() { | |
| RolePlayer rolePlayer = new UltimateDestinationRoles(); | |
| MessageContext msgCtx11 = createMessageContext(soap11Factory); | |
| setUnprocessedHeaders(msgCtx11, rolePlayer); | |
| // Indicate we understand (e.g. via handlers) all the headers. | |
| List<QName> understoodHeaders = new ArrayList<QName>(); | |
| understoodHeaders.add(new QName(namespace, header_ultimateReceiver)); | |
| understoodHeaders.add(new QName(namespace, header_rolePlayed)); | |
| List<String> handlerRolePlayer = new ArrayList<String>(); | |
| try { | |
| HandlerUtils.checkMustUnderstand(msgCtx11, understoodHeaders, handlerRolePlayer); | |
| } catch (AxisFault e) { | |
| fail("Should not have caught and AxisFault"); | |
| } | |
| } | |
| // ============================================================================================= | |
| // Utility methods | |
| // ============================================================================================= | |
| private MessageContext createMessageContext(SOAPFactory soapFactory) { | |
| MessageContext messageContext = null; | |
| AxisService as1 = new AxisService("Service1"); | |
| ConfigurationContext cc = null; | |
| try { | |
| cc = ConfigurationContextFactory.createEmptyConfigurationContext(); | |
| AxisConfiguration ac = cc.getAxisConfiguration(); | |
| ac.addService(as1); | |
| messageContext = cc.createMessageContext(); | |
| messageContext.setAxisService(as1); | |
| SOAPEnvelope se = soapFactory.createSOAPEnvelope(); | |
| SOAPHeader sh = soapFactory.createSOAPHeader(se); | |
| SOAPHeaderBlock shb1 = sh.addHeaderBlock(header_ultimateReceiver, | |
| omFactory.createOMNamespace(namespace, header_ultimateReceiver)); | |
| // Since no role was set on the shb1, default is ultimate receiver | |
| shb1.setMustUnderstand(true); | |
| SOAPHeaderBlock shb2 = sh.addHeaderBlock(header_rolePlayed, | |
| omFactory.createOMNamespace(namespace, header_rolePlayed)); | |
| shb2.setRole(rolePlayed1); | |
| shb2.setMustUnderstand(true); | |
| SOAPHeaderBlock shb3 = sh.addHeaderBlock(header_roleNotPlayed, | |
| omFactory.createOMNamespace(namespace, header_roleNotPlayed)); | |
| shb3.setRole(roleNotPlayed); | |
| shb3.setMustUnderstand(true); | |
| SOAPHeaderBlock shb4 = sh.addHeaderBlock(header_bindingAdded, | |
| omFactory.createOMNamespace(namespace, header_bindingAdded)); | |
| shb4.setRole(roleBindingAdded); | |
| shb4.setMustUnderstand(true); | |
| // This header is destined for the ulmiate receiver, but it is already processed | |
| // so it shouldn't cause mustUnderstand fault | |
| SOAPHeaderBlock shb5 = sh.addHeaderBlock(header_ultimateReceiver_processed, | |
| omFactory.createOMNamespace(namespace, header_ultimateReceiver_processed)); | |
| // Since no role was set on the shb1, default is ultimate receiver | |
| shb5.setMustUnderstand(true); | |
| shb5.setProcessed(); | |
| // Header targeted for SOAP11 role of Next, not set to MustUnderstand | |
| SOAPHeaderBlock shb6 = sh.addHeaderBlock(header_SoapNext, | |
| omFactory.createOMNamespace(soap11Namespace, header_SoapNext)); | |
| shb6.setRole(roleSoap11Next); | |
| messageContext.setEnvelope(se); | |
| } catch (AxisFault e) { | |
| fail("Caught unexpected exception creating message context" + e); | |
| } | |
| return messageContext; | |
| } | |
| private void setUnprocessedHeaders(MessageContext messageContext, RolePlayer rolePlayer) { | |
| SOAPEnvelope envelope = messageContext.getEnvelope(); | |
| Iterator headerBlocks = envelope.getHeader().getHeadersToProcess(rolePlayer); | |
| List<QName> unprocessedHeaders = new ArrayList<QName>(); | |
| while (headerBlocks.hasNext()) { | |
| SOAPHeaderBlock headerBlock = (SOAPHeaderBlock) headerBlocks.next(); | |
| QName headerName = headerBlock.getQName(); | |
| // if this header block has been processed or mustUnderstand isn't | |
| // turned on then its cool | |
| if (headerBlock.isProcessed() || !headerBlock.getMustUnderstand()) { | |
| continue; | |
| } else { | |
| unprocessedHeaders.add(headerName); | |
| } | |
| } | |
| if(unprocessedHeaders !=null && unprocessedHeaders.size()>0){ | |
| messageContext.setProperty(Constants.UNPROCESSED_HEADER_QNAMES, unprocessedHeaders); | |
| } | |
| } | |
| private List<String> bindingAddedRole() { | |
| List<String> roles = new ArrayList<String>(); | |
| roles.add(roleBindingAdded); | |
| return roles; | |
| } | |
| private List<String> noHeadersRole() { | |
| List<String> roles = new ArrayList<String>(); | |
| roles.add(roleNoHeaders); | |
| return roles; | |
| } | |
| // ============================================================================================= | |
| // Inner Test Classes | |
| // ============================================================================================= | |
| class UltimateDestinationNoRoles implements RolePlayer { | |
| public List getRoles() { | |
| return null; | |
| } | |
| public boolean isUltimateDestination() { | |
| return true; | |
| } | |
| } | |
| class NotUltimateDestinationNoRoles implements RolePlayer { | |
| public List getRoles() { | |
| return null; | |
| } | |
| public boolean isUltimateDestination() { | |
| return false; | |
| } | |
| } | |
| class UltimateDestinationRoles implements RolePlayer { | |
| List<String> roles = new ArrayList<String>(); | |
| public UltimateDestinationRoles() { | |
| roles.add(rolePlayed1); | |
| } | |
| public List getRoles() { | |
| return roles; | |
| } | |
| public boolean isUltimateDestination() { | |
| return true; | |
| } | |
| } | |
| @WebService | |
| @HandlerChain(file="RoleBasedMustUnderstandTests.xml") | |
| class RoleBasedMUServiceImpl { | |
| } | |
| @WebService | |
| @HandlerChain(file="RoleBasedMustUnderstandTests2.xml") | |
| class RoleBasedMUServiceImpl2 { | |
| } | |
| } |