package test.RPCDispatch;
import junit.framework.TestCase;
import org.apache.axis.AxisFault;
import org.apache.axis.Constants;
import org.apache.axis.Message;
import org.apache.axis.MessageContext;
import org.apache.axis.configuration.SimpleProvider;
import org.apache.axis.description.OperationDesc;
import org.apache.axis.description.JavaServiceDesc;
import org.apache.axis.encoding.TypeMapping;
import org.apache.axis.encoding.TypeMappingRegistry;
import org.apache.axis.encoding.ser.BeanDeserializerFactory;
import org.apache.axis.encoding.ser.BeanSerializerFactory;
import org.apache.axis.handlers.soap.SOAPService;
import org.apache.axis.message.RPCElement;
import org.apache.axis.message.RPCParam;
import org.apache.axis.message.SOAPEnvelope;
import org.apache.axis.providers.java.RPCProvider;
import org.apache.axis.server.AxisServer;
import org.xml.sax.SAXException;
import javax.xml.namespace.QName;
import java.util.Vector;
import org.custommonkey.xmlunit.XMLTestCase;
import org.apache.axis.AxisEngine;
/**
* Test org.apache.axis.handlers.RPCDispatcher
*
* @author Sam Ruby <rubys@us.ibm.com>
*/
public class TestSerializedRPC extends XMLTestCase {
private final String header =
"<?xml version=\"1.0\"?>\n" +
"<soap:Envelope " +
"xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" " +
"xmlns:soapenc=\"http://schemas.xmlsoap.org/soap/encoding/\" " +
"xmlns:xsi=\"" + Constants.URI_DEFAULT_SCHEMA_XSI + "\" " +
"xmlns:xsd=\"" + Constants.URI_DEFAULT_SCHEMA_XSD + "\">\n" +
"<soap:Body>\n";
private final String footer =
"</soap:Body>\n" +
"</soap:Envelope>\n";
private SimpleProvider provider = new SimpleProvider();
private AxisServer engine = new AxisServer(provider);
QName firstParamName = null;
QName secondParamName = null;
private String SOAPAction = "urn:reverse";
public TestSerializedRPC(String name) throws Exception {
super(name);
engine.init();
// And deploy the type mapping
Class javaType = Data.class;
QName xmlType = new QName("urn:foo", "Data");
BeanSerializerFactory sf = new BeanSerializerFactory(javaType, xmlType);
BeanDeserializerFactory df = new BeanDeserializerFactory(javaType, xmlType);
TypeMappingRegistry tmr = engine.getTypeMappingRegistry();
TypeMapping tm =
tmr.getOrMakeTypeMapping(Constants.URI_DEFAULT_SOAP_ENC);
tm.register(javaType, xmlType, sf, df);
// Register the reverseString service
SOAPService reverse = new SOAPService(new RPCProvider());
reverse.setOption("className", "test.RPCDispatch.Service");
reverse.setOption("allowedMethods", "*");
JavaServiceDesc desc = new JavaServiceDesc();
desc.loadServiceDescByIntrospection(Service.class, tm);
reverse.setServiceDescription(desc);
provider.deployService(SOAPAction, reverse);
// Now we've got the service description loaded up. We're going to
// be testing parameter dispatch by name, so if debug info isn't
// compiled into the Service class, the names are going to be "in0",
// etc. Make sure they match.
OperationDesc oper = desc.getOperationByName("concatenate");
assertNotNull(oper);
firstParamName = oper.getParameter(0).getQName();
secondParamName = oper.getParameter(1).getQName();
}
/**
* Invoke a given RPC method, and return the result
* @param method action to be performed
* @param bodyStr XML body of the request
* @return Deserialized result
*/
private final Object rpc(String method, String bodyStr,
boolean setService)
throws AxisFault, SAXException
{
// Create the message context
MessageContext msgContext = new MessageContext(engine);
// Set the dispatch either by SOAPAction or methodNS
String methodNS = "urn:dont.match.me";
if (setService) {
msgContext.setTargetService(SOAPAction);
} else {
methodNS = SOAPAction;
}
String bodyElemHead = "<m:" + method + " xmlns:m=\"" +
methodNS + "\">";
String bodyElemFoot = "</m:" + method + ">";
// Construct the soap request
String msgStr = header + bodyElemHead + bodyStr +
bodyElemFoot + footer;
msgContext.setRequestMessage(new Message(msgStr));
msgContext.setTypeMappingRegistry(engine.getTypeMappingRegistry());
// Invoke the Axis engine
engine.invoke(msgContext);
// Extract the response Envelope
Message message = msgContext.getResponseMessage();
assertNotNull("Response message was null!", message);
SOAPEnvelope envelope = message.getSOAPEnvelope();
assertNotNull("SOAP envelope was null", envelope);
// Extract the body from the envelope
RPCElement body = (RPCElement)envelope.getFirstBody();
assertNotNull("SOAP body was null", body);
// Extract the list of parameters from the body
Vector arglist = body.getParams();
assertNotNull("SOAP argument list was null", arglist);
assertTrue("param.size()<=0 {Should be > 0}", arglist.size()>0);
// Return the first parameter
RPCParam param = (RPCParam) arglist.get(0);
return param.getObjectValue();
}
/**
* Test a simple method that reverses a string
*/
public void testSerReverseString() throws Exception {
String arg = "<arg0 xsi:type=\"xsd:string\">abc</arg0>";
// invoke the service and verify the result
assertEquals("Did not reverse the string as expected", "cba", rpc("reverseString", arg, true));
}
public void testSerReverseBodyDispatch() throws Exception {
String arg = "<arg0 xsi:type=\"xsd:string\">abc</arg0>";
// invoke the service and verify the result
assertEquals("Did not reverse the string as expected", "cba", rpc("reverseString", arg, false));
}
/**
* Test a method that reverses a data structure
*/
public void testSerReverseData() throws Exception {
// invoke the service and verify the result
String arg = "<arg0 xmlns:foo=\"urn:foo\" xsi:type=\"foo:Data\">";
arg += "<field1>5</field1><field2>abc</field2><field3>3</field3>";
arg += "</arg0>";
Data expected = new Data(3, "cba", 5);
assertEquals("Did not reverse data as expected", expected, rpc("reverseData", arg, true));
}
/**
* Test a method that reverses a data structure
*/
public void testReverseDataWithUntypedParam() throws Exception {
// invoke the service and verify the result
String arg = "<arg0 xmlns:foo=\"urn:foo\">";
arg += "<field1>5</field1><field2>abc</field2><field3>3</field3>";
arg += "</arg0>";
Data expected = new Data(3, "cba", 5);
assertEquals("Did not reverse data as expected", expected, rpc("reverseData", arg, true));
}
/**
* Test out-of-order parameters, using the names to match
*/
public void testOutOfOrderParams() throws Exception {
String body = "<" + secondParamName.getLocalPart() + " xmlns=\""+ secondParamName.getNamespaceURI() + "\">world!</" +
secondParamName.getLocalPart() + ">" +
"<" + firstParamName.getLocalPart() + " xmlns=\""+ firstParamName.getNamespaceURI() + "\">Hello, </" +
firstParamName.getLocalPart() + ">";
String expected = "Hello, world!";
assertEquals("Concatenated value was wrong",
expected,
rpc("concatenate", body, true));
}
/**
* Test DOM round tripping
*/
public void testArgAsDOM() throws Exception {
// invoke the service and verify the result
String arg = "<arg0 xmlns:foo=\"urn:foo\">";
arg += "<field1>5</field1><field2>abc</field2><field3>3</field3>";
arg += "</arg0>";
// invoke the service and verify the result
engine.setOption(AxisEngine.PROP_SEND_XSI, Boolean.FALSE);
assertXMLEqual("Did not echo arg correctly.", arg, rpc("argAsDOM", arg, true).toString());
}
public void testWrappedTypes() throws Exception
{
// boolean
String arg = "<arg0>true</arg0>";
Object expected = Boolean.TRUE;
assertEquals("method test failed with a boolean",
expected,
rpc("testBoolean", arg, true));
// boolean
arg = "<arg0>1</arg0>";
expected = Boolean.TRUE;
assertEquals("method test failed with a boolean",
expected,
rpc("testBoolean", arg, true));
// float
arg = "<arg0>NaN</arg0>";
expected = new Float(Float.NaN);
assertEquals("method test failed with a float",
expected,
rpc("testFloat", arg, true));
arg = "<arg0>INF</arg0>";
expected = new Float(Float.POSITIVE_INFINITY);
assertEquals("method test failed with a float",
expected,
rpc("testFloat", arg, true));
arg = "<arg0>-INF</arg0>";
expected = new Float(Float.NEGATIVE_INFINITY);
assertEquals("method test failed with a float",
expected,
rpc("testFloat", arg, true));
// double
arg = "<arg0>NaN</arg0>";
expected = new Double(Double.NaN);
assertEquals("method test failed with a double",
expected,
rpc("testDouble", arg, true));
arg = "<arg0>INF</arg0>";
expected = new Double(Double.POSITIVE_INFINITY);
assertEquals("method test failed with a double",
expected,
rpc("testDouble", arg, true));
arg = "<arg0>-INF</arg0>";
expected = new Double(Double.NEGATIVE_INFINITY);
assertEquals("method test failed with a double",
expected,
rpc("testDouble", arg, true));
}
/**
* Test overloaded method dispatch without the benefit of xsi:types
*/
public void testOverloadedMethodDispatch() throws Exception
{
// invoke the service for each overloaded method, and verify the results
// boolean
String arg = "<arg0>true</arg0>";
Object expected = Boolean.TRUE;
assertEquals("Overloaded method test failed with a boolean",
expected,
rpc("overloaded", arg, true));
// boolean, string
arg = "<arg0>true</arg0><arg1>hello world</arg1>";
expected = Boolean.TRUE + "hello world";
assertEquals("Overloaded method test failed with boolean, string",
expected,
rpc("overloaded", arg, true));
// string, boolean
arg = "<arg0>hello world</arg0><arg1>true</arg1>";
expected = "hello world" + Boolean.TRUE;
assertEquals("Overloaded method test failed with string, boolean",
expected,
rpc("overloaded", arg, true));
// int
arg = "<arg0>5</arg0>";
expected = new Integer(5);
assertEquals("Overloaded method test failed with an int",
expected,
rpc("overloaded", arg, true));
// int, string
arg = "<arg0>5</arg0><arg1>hello world</arg1>";
expected = 5 + "hello world";
assertEquals("Overloaded method test failed with int, string",
expected,
rpc("overloaded", arg, true));
}
// public void testEncodedArrayConversion() throws Exception {
// String arg = "<arg0>a simple string</arg0>";
// AxisFault fault = (AxisFault)rpc("arrayMethod", arg, true);
// assertTrue("Erroneous conversion occurred!",
// !fault.getFaultString().equals("You shouldn't have called me!"));
// }
}
|
