modules/kernel/test/org/apache/axis2/description/MessageExchangePatternsTest.java - axis-axis2-java-core - Git at Google

 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();
         }
     }

 }
	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();
	}
	}

	}