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.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;

/**
 * Test org.apache.axis.handlers.RPCDispatcher
 *
 * @author Sam Ruby <rubys@us.ibm.com>
 */
public class TestRPC extends TestCase {

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

    private String SOAPAction = "urn:reverse";

    public TestRPC(String name) {
        super(name);
        engine.init();
    }

    /**
     * Invoke a given RPC method, and return the result
     * @return Deserialized result
     */
    private final Object rpc(String method, Object[] parms)
        throws AxisFault, SAXException
    {

        // Create the message context
        MessageContext msgContext = new MessageContext(engine);

        // Set the dispatch either by SOAPAction or methodNS
        String methodNS = null;
        msgContext.setTargetService(SOAPAction);

        // Construct the soap request
        SOAPEnvelope envelope = new SOAPEnvelope();
        msgContext.setRequestMessage(new Message(envelope));
        RPCElement body = new RPCElement(methodNS, method, parms);
        envelope.addBodyElement(body);

        // Invoke the Axis engine
        engine.invoke(msgContext);

        // Extract the response Envelope
        Message message = msgContext.getResponseMessage();
        envelope = (SOAPEnvelope)message.getSOAPEnvelope();
        assertNotNull("SOAP envelope was null", envelope);

        // Extract the body from the envelope
        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);
        if (arglist.size()==0) return null;

        // Return the first parameter
        RPCParam param = (RPCParam) arglist.get(0);
        return param.getObjectValue();
    }

    /**
     * Test a simple method that reverses a string
     */
    public void testReverseString() throws Exception {
        // Register the reverseString service
        SOAPService reverse = new SOAPService(new RPCProvider());
        reverse.setOption("className", "test.RPCDispatch.Service");
        reverse.setOption("allowedMethods", "reverseString");
        provider.deployService(new QName(null,SOAPAction), reverse);

        // invoke the service and verify the result
        assertEquals("Did not reverse the string correctly.", "cba",
                     rpc("reverseString", new Object[] {"abc"}));
    }

    /**
     * Test a simple method that reverses a string (but fails)
     */
    public void testReverseStringThatShouldFail() throws Exception {
        try {
            // Register the reverseString service
            SOAPService reverse = new SOAPService(new RPCProvider());
            reverse.setOption("className", "test.RPCDispatch.Service");
            reverse.setOption("allowedMethods", "reverseString2");
            provider.deployService(new QName(null,SOAPAction), reverse);

            // invoke the service and verify the result
            rpc("reverseString", new Object[] {"abc"});
            throw new junit.framework.AssertionFailedError("Should not reach here");
        } catch (AxisFault af){
            //This test should cause an exception.
            return;
        }
    }
    
    /**
     * Test a simple method that reverses a string (with a comma delimiter
     */
    public void testReverseStringWithCommaDelimiter() throws Exception {
        // Register the reverseString service
        SOAPService reverse = new SOAPService(new RPCProvider());
        reverse.setOption("className", "test.RPCDispatch.Service");
        reverse.setOption("allowedMethods", "reverseString2,reverseString");
        provider.deployService(new QName(null,SOAPAction), reverse);

        // invoke the service and verify the result
        assertEquals("Did not reverse the string correctly.", "cba", rpc("reverseString", new Object[] {"abc"}));
    }

    /**
     * Test a simple method that reverses a string (with a space delimiter
     */
    public void testReverseStringWithSpaceDelimiter() throws Exception {
        // Register the reverseString service
        SOAPService reverse = new SOAPService(new RPCProvider());
        reverse.setOption("className", "test.RPCDispatch.Service");
        reverse.setOption("allowedMethods", "reverseString2 reverseString");
        provider.deployService(new QName(null,SOAPAction), reverse);

        // invoke the service and verify the result
        assertEquals("Did not reverse the string correctly.", "cba", rpc("reverseString", new Object[] {"abc"}));
    }

    /**
     * Test a simple method that reverses a string (with a '*'
     */
    public void testReverseStringWithStar() throws Exception {
        // Register the reverseString service
        SOAPService reverse = new SOAPService(new RPCProvider());
        reverse.setOption("className", "test.RPCDispatch.Service");
        reverse.setOption("allowedMethods", "*");
        provider.deployService(new QName(null,SOAPAction), reverse);

        // invoke the service and verify the result
        assertEquals("Did not reverse the string correctly.", "cba",
                     rpc("reverseString", new Object[] {"abc"}));
    }
    
    /**
     * Test a method that reverses a data structure
     */
    public void testReverseData() throws Exception {
        // Register the reverseData service
        SOAPService reverse = new SOAPService(new RPCProvider());
        reverse.setOption("className", "test.RPCDispatch.Service");
        reverse.setOption("allowedMethods", "reverseData");
        provider.deployService(new QName(null, SOAPAction), reverse);

        // invoke the service and verify the result
        Data input    = new Data(5, "abc", 3);
        Data expected = new Data(3, "cba", 5);
        assertEquals("Did not reverse the data as expected.", expected, rpc("reverseData", new Object[] {input}));
    }

    /**
     * Test a simple method that returns a field from the message context
     */
    public void testMessageContextImplicit() throws Exception {
        // Register the targetService service
        SOAPService tgtSvc = new SOAPService(new RPCProvider());
        tgtSvc.setOption("className", "test.RPCDispatch.Service");
        tgtSvc.setOption("allowedMethods", "targetServiceImplicit");
        provider.deployService(new QName(null, SOAPAction), tgtSvc);

        // invoke the service and verify the result
        assertEquals("SOAP Action did not equal the targetService.", 
            SOAPAction, rpc("targetServiceImplicit", new Object[] {}));
    }

    /**
     * Test a simple method that accepts and returns a null
     */
    public void testNull() throws Exception {
        // Register the echoInt service
        SOAPService echoInt = new SOAPService(new RPCProvider());
        echoInt.setOption("className", "test.RPCDispatch.Service");
        echoInt.setOption("allowedMethods", "echoInt");
        provider.deployService(new QName(null, SOAPAction), echoInt);

        // invoke the service and verify the result
        assertNull("The result was not null as expected.", rpc("echoInt", new Object[] {null}));
    }
    
    /**
     * Test faults
     */
    public void testSimpleFault() throws Exception {
        // Register the reverseData service
        SOAPService simpleFault = new SOAPService(new RPCProvider());
        simpleFault.setOption("className", "test.RPCDispatch.Service");
        simpleFault.setOption("allowedMethods", "simpleFault");
        provider.deployService(new QName(null, SOAPAction), simpleFault);

        try {
            rpc("simpleFault", new Object[] {"foobar"});
        } catch (AxisFault result) {
            assertEquals("faultString was not set correctly.",
                "test.RPCDispatch.Service$TestFault: foobar",
                result.getFaultString());
            return;
        }

        fail("Did not get an expected fault!");
    }

    public static void main(String args[])
    {
      try {
        TestRPC tester = new TestRPC("RPC test");
        tester.testReverseString();
        tester.testReverseData();
        tester.testSimpleFault();
        tester.testReverseStringThatShouldFail();
        tester.testReverseStringWithCommaDelimiter();
        tester.testReverseStringWithSpaceDelimiter();
        tester.testReverseStringWithStar();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
}