test/session/TestSimpleSession.java

package test.session;

import junit.framework.TestCase;
import org.apache.axis.EngineConfiguration;
import org.apache.axis.MessageContext;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.configuration.DefaultEngineConfigurationFactory;
import org.apache.axis.configuration.SimpleProvider;
import org.apache.axis.configuration.XMLStringProvider;
import org.apache.axis.deployment.wsdd.WSDDConstants;
import org.apache.axis.handlers.SimpleSessionHandler;
import org.apache.axis.handlers.soap.SOAPService;
import org.apache.axis.providers.java.RPCProvider;
import org.apache.axis.server.AxisServer;
import org.apache.axis.session.Session;
import org.apache.axis.session.SimpleSession;
import org.apache.axis.transport.local.LocalTransport;

import javax.xml.rpc.ServiceException;
import javax.xml.rpc.server.ServiceLifecycle;

/**
 * Test the SimpleSession implementation (using SOAP headers for session
 * maintenance)
 *
 * @author Glen Daniels (gdaniels@apache.org)
 */
public class TestSimpleSession extends TestCase implements ServiceLifecycle {
    static final String clientWSDD =
            "<deployment xmlns=\"http://xml.apache.org/axis/wsdd/\" " +
                  "xmlns:java=\"" + WSDDConstants.URI_WSDD_JAVA + "\">\n" +
            " <handler type=\"java:org.apache.axis.handlers.SimpleSessionHandler\" " +
                      "name=\"SimpleSessionHandler\"/>\n" +
            " <service name=\"sessionTest\">\n" +
            "  <requestFlow><handler type=\"SimpleSessionHandler\"/></requestFlow>\n" +
            "  <responseFlow><handler type=\"SimpleSessionHandler\"/></responseFlow>\n" +
            " </service>\n" +
            " <transport name=\"local\" " +
                "pivot=\"java:org.apache.axis.transport.local.LocalSender\"/>\n" +
            "</deployment>";
    static XMLStringProvider clientProvider = new XMLStringProvider(clientWSDD);

    /**
     * Default constructor for use as service
     */
    public TestSimpleSession()
    {
        super("serviceTest");
    }

    public TestSimpleSession(String name)
    {
        super(name);
    }
    
    public void testSessionAPI() {
        SimpleSession session = new SimpleSession();
        Object val = new Float(5.6666);
        session.set("test", val);
        
        assertEquals("\"test\" equals \"" + session.get("test") + "\", not \"" + val + "\" as expected",
                     val, session.get("test"));
        
        session.remove("test");
        
        assertNull("Did not remove \"test\" from the session successfully", session.get("test"));
    }

    /**
     * Actually test the session functionality using SOAP headers.
     *
     * Deploy a simple RPC service which returns a session-based call
     * counter.  Check it out using local transport.  To do this we need to
     * make sure the SimpleSessionHandler is deployed on the request and
     * response chains of both the client and the server.
     *
     */
    public void testSessionService() throws Exception
    {
        // Set up the server side
        SimpleSessionHandler sessionHandler = new SimpleSessionHandler();
        // Set a 3-second reap period, and a 3-second timeout
        sessionHandler.setReapPeriodicity(3);
        sessionHandler.setDefaultSessionTimeout(3);

        SOAPService service = new SOAPService(sessionHandler,
                                              new RPCProvider(),
                                              sessionHandler);

        service.setName("sessionTestService");
        service.setOption("scope", "session");
        service.setOption("className", "test.session.TestSimpleSession");
        service.setOption("allowedMethods", "counter");

        EngineConfiguration defaultConfig =
            (new DefaultEngineConfigurationFactory()).getServerEngineConfig();
        SimpleProvider config = new SimpleProvider(defaultConfig);
        config.deployService("sessionTest", service);

        AxisServer server = new AxisServer(config);

        // Set up the client side (using the WSDD above)
        Service svc = new Service(clientProvider);
        Call call = (Call)svc.createCall();
        svc.setMaintainSession(true);
        call.setTransport(new LocalTransport(server));

        // Try it - first invocation should return 1.
        Integer count = (Integer)call.invoke("sessionTest", "counter", null);
        assertNotNull("count was null!", count);
        assertEquals("count was wrong", 1, count.intValue());

        // We should have init()ed a single service object
        assertEquals("Wrong # of calls to init()!", 1, initCalls);

        // Next invocation should return 2, assuming the session-based
        // counter is working.
        count = (Integer)call.invoke("sessionTest", "counter", null);
        assertEquals("count was wrong", 2, count.intValue());

        // We should still have 1
        assertEquals("Wrong # of calls to init()!", 1, initCalls);

        // Now start fresh and confirm a new session
        Service svc2 = new Service(clientProvider);
        Call call2 = (Call)svc2.createCall();
        svc2.setMaintainSession(true);
        call2.setTransport(new LocalTransport(server));

        // New session should cause us to return 1 again.
        count = (Integer)call2.invoke("sessionTest", "counter", null);
        assertNotNull("count was null on third call!", count);
        assertEquals("New session count was incorrect", 1,
                     count.intValue());

        // We should have init()ed 2 service objects now
        assertEquals("Wrong # of calls to init()!", 2, initCalls);
        // And no destroy()s yet...
        assertEquals("Shouldn't have called destroy() yet!", 0, destroyCalls);

        // Wait around a few seconds to let the first session time out
        Thread.sleep(4000);

        // And now we should get a new session, therefore going back to 1
        count = (Integer)call.invoke("sessionTest", "counter", null);
        assertEquals("count after timeout was incorrect", 1, count.intValue());

        // Check init/destroy counts
        assertEquals("Wrong # of calls to init()!", 3, initCalls);
        assertEquals("Wrong # of calls to destroy()!", 2, destroyCalls);
    }

    /**
     * This is our service method for testing session data.  Simply
     * increments a session-scoped counter.
     */
    public Integer counter() throws Exception
    {
        Session session = MessageContext.getCurrentContext().getSession();
        if (session == null)
            throw new Exception("No session in MessageContext!");
        Integer count = (Integer)session.get("counter");
        if (count == null) {
            count = new Integer(0);
        }
        count = new Integer(count.intValue() + 1);
        session.set("counter", count);
        return count;
    }

    public static void main(String args[]) throws Exception
    {
        TestSimpleSession test = new TestSimpleSession("test");
        test.testSessionAPI();
        test.testSessionService();
    }

    private static int initCalls = 0;
    private static int destroyCalls = 0;

    /**
     * After a service endpoint object (an instance of a service
     * endpoint class) is instantiated, the JAX-RPC runtime system
     * invokes the init method.The service endpoint class uses the
     * init method to initialize its configuration and setup access
     * to any external resources.
     *  @param   context Initialization context for a JAX-RPC service
     endpoint; Carries javax.servlet.ServletContext
     for the servlet based JAX-RPC endpoints
     *  @throws  ServiceException If any error in initialization of the
     service endpoint; or if any illegal context has
     been provided in the init method
     */
    public void init(Object context) throws ServiceException {
        initCalls++;
    }

    /**
     * JAX-RPC runtime system ends the lifecycle of a service endpoint
     * object by invoking the destroy method. The service endpoint
     * releases its resourcesin the implementation of the destroy
     * method.
     */
    public void destroy() {
        destroyCalls++;
    }
}