MessageExchangePatternsTest.java

package org.apache.axis2.description;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.xml.namespace.QName;

import junit.framework.Assert;
import junit.framework.Test;
import junit.framework.TestSuite;

import org.apache.axis2.AbstractTestCase;
import org.apache.axis2.wsdl.WSDLConstants;

/**
 * This is a data-driven test class that verifies that
 * <code>AxisBindingOperation</code>s, <code>AxisOpertion</code>s and
 * <code>AxisMessage</code>s objects are consistently built when the
 * <code>WSDLToAxisServiceBuilder.isServerSide</code> attribute is set both to
 * <code>true</code> and <code>false</code> and the <code>AxisService</code> is
 * populated. <p/> There are assertions that verify that operations' MEPs,
 * message labels, message directions AND schema elements tight to the specific
 * <code>AxisMessage</code>s are correctly populated.
 */
public class MessageExchangePatternsTest extends AbstractTestCase 
        implements WSDL2Constants {

    protected static final String WSDL_PATH = "wsdl/meps-wsdl11.wsdl";
    
    // Convenient access to reversed mappings
    private static final Map REVERSED_MEP;
    private static final Map REVERSED_DIRECTION;
    private static final Map REVERSED_MESSAGE_LABEL;
    private static final Map MESSAGE_LABEL_TO_DIRECTION;
    
    static {
        REVERSED_MEP = new HashMap();
        REVERSED_MEP.put(MEP_URI_OUT_IN, MEP_URI_IN_OUT);
        REVERSED_MEP.put(MEP_URI_OUT_ONLY, MEP_URI_IN_ONLY);
        REVERSED_MEP.put(MEP_URI_IN_OUT, MEP_URI_OUT_IN);
        // Axis2 maps the "robust-out-only" operation type as "out-only"
        REVERSED_MEP.put(MEP_URI_ROBUST_IN_ONLY, MEP_URI_OUT_ONLY);
        REVERSED_MEP.put(MEP_URI_IN_ONLY, MEP_URI_OUT_ONLY);

        REVERSED_DIRECTION = new HashMap();
        REVERSED_DIRECTION.put(WSDLConstants.WSDL_MESSAGE_DIRECTION_IN,
            WSDLConstants.WSDL_MESSAGE_DIRECTION_OUT);
        REVERSED_DIRECTION.put(WSDLConstants.WSDL_MESSAGE_DIRECTION_OUT,
            WSDLConstants.WSDL_MESSAGE_DIRECTION_IN);

        REVERSED_MESSAGE_LABEL = new HashMap();
        REVERSED_MESSAGE_LABEL.put(MESSAGE_LABEL_IN, MESSAGE_LABEL_OUT);
        REVERSED_MESSAGE_LABEL.put(MESSAGE_LABEL_OUT, MESSAGE_LABEL_IN);

        MESSAGE_LABEL_TO_DIRECTION = new HashMap();
        MESSAGE_LABEL_TO_DIRECTION.put(MESSAGE_LABEL_IN,
            WSDLConstants.WSDL_MESSAGE_DIRECTION_IN);
        MESSAGE_LABEL_TO_DIRECTION.put(MESSAGE_LABEL_OUT,
            WSDLConstants.WSDL_MESSAGE_DIRECTION_OUT);
    }
    
    protected static String getMEP(String serverSideMEP, boolean isServerSide) {
        return isServerSide ? serverSideMEP : (String)REVERSED_MEP.get(serverSideMEP);
    }
    
    protected static String getMessageDirection(String serverSideMessageDirection, boolean isServerSide) {
        return isServerSide ? serverSideMessageDirection : 
            (String)REVERSED_DIRECTION.get(serverSideMessageDirection);
    }
    
    protected static String getMessageLabel(String serverSideMessageLabel, boolean isServerSide) {
        return isServerSide ? serverSideMessageLabel : 
            (String)REVERSED_MESSAGE_LABEL.get(serverSideMessageLabel);
    }
    
    protected static String getDirectionFromMessageLabel(String serverSideMessageLabel, boolean isServerSide) {
        String serverSideMessageDirection = (String)MESSAGE_LABEL_TO_DIRECTION.get(serverSideMessageLabel);
        return getMessageDirection(serverSideMessageDirection, isServerSide);
    }

    private AxisBindingOperation bindingOperation;
    private TestConfig testConfig;

    public MessageExchangePatternsTest(String testName_) {
        super(testName_);
    }

    public static Test suite() {

        TestConfig[] testConfigs = buildTestConfigs(WSDL_PATH);

        String className = MessageExchangePatternsTest.class.getName();
        TestSuite suite = new TestSuite(className);
        for (int i = 0, n = testConfigs.length; i < n; i++) {
            /* Have JUnit create a TestCase instance for every test method of
               this class. */
            TestSuite testCases = new TestSuite(
                MessageExchangePatternsTest.class, testConfigs[i].toString());

            /* Loop through the TestCase instances and inject them with the test
               data. */
            Enumeration tests = testCases.tests();
            while (tests.hasMoreElements()) {
                MessageExchangePatternsTest test = 
                    (MessageExchangePatternsTest)tests.nextElement();
                test.setTestConfig(testConfigs[i]);
            }

            suite.addTest(testCases);
        }
        return suite;
    }

    protected static TestConfig[] buildTestConfigs(String wsdlPath) {
        // Populate WSDL information
        final String targetNamespace = "http://www.example.org";
        final QName serviceName = new QName(targetNamespace, "message-exchange-patterns");
        final Map operationNamesToServerSideMEP = new HashMap();
        operationNamesToServerSideMEP.put("out-in", MEP_URI_OUT_IN);
        operationNamesToServerSideMEP.put("out-only", MEP_URI_OUT_ONLY);
        operationNamesToServerSideMEP.put("in-out", MEP_URI_IN_OUT);
        operationNamesToServerSideMEP.put("robust-in-only", MEP_URI_ROBUST_IN_ONLY);
        // Axis2 maps the "robust-out-only" operation type as "out-only"
        operationNamesToServerSideMEP.put("robust-out-only", MEP_URI_OUT_ONLY);
        operationNamesToServerSideMEP.put("in-only", MEP_URI_IN_ONLY);
        final String[] portNames = {"soap11", "soap12"};
        final boolean isServerSide[] = {true, false};
        final QName inputSchemaElementName = new QName(targetNamespace, "generic-element-in");
        final QName outputSchemaElementName = new QName(targetNamespace, "generic-element-out");

        /* Create TestConfig objects using combinations between port types (2),
           operations (5) and the isServerSide flag */
        List testConfigs = new ArrayList();
        Iterator mepsIt = operationNamesToServerSideMEP.entrySet().iterator();
        while (mepsIt.hasNext()) {
            Map.Entry operationNameToMEP = (Map.Entry)mepsIt.next();
            QName operationName = new QName(targetNamespace, (String)operationNameToMEP.getKey());
            String serverSideMEP = (String)operationNameToMEP.getValue();
            for (int i = 0; i < portNames.length; i++) {
                OperationReference operationReference = new OperationReference(
                    wsdlPath, serviceName, portNames[i], operationName);
                for (int j = 0; j < isServerSide.length; j++) {
                    String expectedMEP = getMEP(serverSideMEP, isServerSide[j]);
                    testConfigs.add(new TestConfig(
                        operationReference, isServerSide[j], expectedMEP,
                        inputSchemaElementName, outputSchemaElementName
                    ));
                }
            }
        }
        return (TestConfig[])testConfigs.toArray(new TestConfig[testConfigs.size()]);
    }
    
    public String getName() {
        TestConfig testConfig = getTestConfig();
        return super.getName() + ". Expected MEP: " +
            testConfig.getExpectedMep() + " ; isServerSide: " +
            testConfig.isServerSide();
    }

    public void setUp() throws Exception {
        TestConfig testConfig = getTestConfig();
        OperationReference operationReference = testConfig.getOperationReference();
        InputStream contentTypeWsdlIn = getTestResource(operationReference.getWsdlPath());
        // Populate AxisService (WSDL port)
        WSDL11ToAxisServiceBuilder wsdl11Builder = new WSDL11ToAxisServiceBuilder(
            contentTypeWsdlIn, operationReference.getServiceName(),
            operationReference.getPortName());
        wsdl11Builder.setServerSide(testConfig.isServerSide());
        AxisService service = wsdl11Builder.populateService();

        // Get Binding Operation
        AxisEndpoint endpoint = service.getEndpoint(operationReference.getPortName());
        AxisBinding binding = endpoint.getBinding();
        bindingOperation = (AxisBindingOperation)binding.getChild(
            operationReference.getOperationName());
    }
    
    public void testMessageExchangePattern() {
        TestConfig testConfig = getTestConfig();
        AxisOperation axisOperation =  bindingOperation.getAxisOperation();
        Assert.assertEquals("The Message Exchange Pattern is not the expected", 
            testConfig.getExpectedMep(), axisOperation.getMessageExchangePattern());
    }
    
    public void testInputMessageDirection() {
        doTestMessageDirection(MESSAGE_LABEL_IN, 
            getTestConfig().getExpectedInputSchemaElementName());
    }
    
    public void testOutputMessageDirection() {
        doTestMessageDirection(MESSAGE_LABEL_OUT,
            getTestConfig().getExpectedOutputSchemaElementName());
    }
    
    protected void doTestMessageDirection(String serverSideMessageLabel,
                                          QName expectedSchemaElementName) {
        TestConfig testConfig = getTestConfig();
        AxisOperation axisOperation =  bindingOperation.getAxisOperation();
        
        String messageLabel = getMessageLabel(serverSideMessageLabel, 
            testConfig.isServerSide());
        String expectedDirection = getDirectionFromMessageLabel(serverSideMessageLabel, 
            testConfig.isServerSide());
        
        try {
            AxisMessage axisMessage = (AxisMessage)axisOperation.getMessage(messageLabel);
            
            Assert.assertEquals("The Message Direction is not the expected", 
                expectedDirection, axisMessage.getDirection());
            
            Assert.assertEquals("The Schema Element Name is not the expected", 
                expectedSchemaElementName, 
                axisMessage.getElementQName());
            
        } catch (UnsupportedOperationException e) {
            // OK, AxisOperation have no message within messageLabel
        }
    }

    protected TestConfig getTestConfig() {
        return testConfig;
    }

    protected void setTestConfig(TestConfig testConfig_) {
        testConfig = testConfig_;
    }
    
    protected static class TestConfig {

        private final OperationReference operationReference;
        private final boolean isServerSide;
        private final String expectedMep;
        private final QName expectedInputSchemaElementName;
        private final QName expectedOutputSchemaElementName;

        public TestConfig(OperationReference operationReference, 
                          boolean isServerSide,
                          String expectedMep,
                          QName expectedInputSchemaElementName,
                          QName expectedOutputSchemaElementName) {
            this.operationReference = operationReference;
            this.isServerSide = isServerSide;
            this.expectedMep = expectedMep;
            this.expectedInputSchemaElementName = expectedInputSchemaElementName;
            this.expectedOutputSchemaElementName = expectedOutputSchemaElementName;
        }
        
        public OperationReference getOperationReference() {
            return operationReference;
        }

        public boolean isServerSide() {
            return isServerSide;
        }

        public String getExpectedMep() {
            return expectedMep;
        }

        public QName getExpectedInputSchemaElementName() {
            return expectedInputSchemaElementName;
        }

        public QName getExpectedOutputSchemaElementName() {
            return expectedOutputSchemaElementName;
        }

        public String toString() {
            OperationReference opRef = getOperationReference();
            return "port:" + opRef.getPortName() + "; operation:" + 
                opRef.getOperationName() + "; isServerSide:" + isServerSide() + 
                "; expectedMEP:" + getExpectedMep();
        }
    }

}