FileDocCategorySizeDatePackage
TestSerializedRPC.javaAPI DocApache Axis 1.412252Sat Apr 22 18:57:28 BST 2006test.RPCDispatch

TestSerializedRPC

public class TestSerializedRPC extends org.custommonkey.xmlunit.XMLTestCase
Test org.apache.axis.handlers.RPCDispatcher
author
Sam Ruby

Fields Summary
private final String
header
private final String
footer
private org.apache.axis.configuration.SimpleProvider
provider
private org.apache.axis.server.AxisServer
engine
QName
firstParamName
QName
secondParamName
private String
SOAPAction
Constructors Summary
public TestSerializedRPC(String name)


         
        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();
Methods Summary
private final java.lang.Objectrpc(java.lang.String method, java.lang.String bodyStr, boolean setService)
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


        // 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();
public voidtestArgAsDOM()
Test DOM round tripping

        // 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 voidtestOutOfOrderParams()
Test out-of-order parameters, using the names to match

        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));
public voidtestOverloadedMethodDispatch()
Test overloaded method dispatch without the benefit of xsi:types

        // 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 voidtestReverseDataWithUntypedParam()
Test a method that reverses a data structure

        // 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));
public voidtestSerReverseBodyDispatch()

        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));
public voidtestSerReverseData()
Test a method that reverses a data structure

        // 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));
public voidtestSerReverseString()
Test a simple method that reverses a string

        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 voidtestWrappedTypes()

        // 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));