RoleBasedMustUndertandTests.java

/*
 * 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 {
        
    }
}