Unit Testing Struts 2 Actions

June 30, 2008

Hopefully this will help others who are trying to unit test Struts 2 Actions.

My goal is to be able to unit test my actions in the full Struts 2 context with the Interceptor stack being run which includes validation.  The big advantage of this type of testing is that it allows you test you validation logic, the Interceptor configuration for you actions, and the results configuration.

The current information on Struts 2 website regarding unit testing was not very helpful.  The guides page has 2 links to external blogs with some example code for unit testing with Spring.  I used these as starting points but since I’m not using Spring and the examples were heavily dependent on Spring I ended up spending a lot of time in the debugger figuring out how to make this work.

Below is my StrutsTestContext class it makes use of Mockrunner mock Http Servlet classes (mockrunner-servlet.jar).  (If you wish to use a different mock package it should be easy enough to make the change.)

The way this works is you first have to create a Dispatcher which reads your struts configuration. You then use the Dispatcher to create an ActionProxy with the desired request parameters and session attributes.  The ActionProxy will give you access to the Action object so you can set properties or inject mock objects for your test.  You next execute the ActionProxy to run the Interceptor stack and your action, this returns the result so you can test it for correctness.  You can also test the mock Http servlet objects to ensure other result effects have occured (e.g. a session attribute was changed.)

This has been updated for Struts 2.1.6 on 3/5/2009.

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package test.struts;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.dispatcher.Dispatcher;
import org.apache.struts2.dispatcher.mapper.ActionMapping;
import com.mockrunner.mock.web.MockHttpServletRequest;
import com.mockrunner.mock.web.MockHttpServletResponse;
import com.mockrunner.mock.web.MockHttpSession;
import com.mockrunner.mock.web.MockServletContext;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionProxy;
import com.opensymphony.xwork2.ActionProxyFactory;
import com.opensymphony.xwork2.inject.Container;
import com.opensymphony.xwork2.util.ValueStack;
import com.opensymphony.xwork2.util.ValueStackFactory;

public class StrutsTestContext
{
    public StrutsTestContext(Dispatcher dispatcher,
                             MockServletContext servletContext)
    {
        this.dispatcher = dispatcher;
        this.mockServletContext = servletContext;
    }

    private Dispatcher              dispatcher;
    private MockServletContext      mockServletContext;
    private MockHttpServletRequest  mockRequest;
    private MockHttpServletResponse mockResponse;

    public static Dispatcher prepareDispatcher()
    {
        return prepareDispatcher(null, null);
    }

    public static Dispatcher prepareDispatcher(
           ServletContext servletContext,
           Map<String, String> params)
    {
        if (params == null)
        {
            params = new HashMap<String, String>();
        }
        Dispatcher dispatcher = new Dispatcher(servletContext, params);
        dispatcher.init();
        Dispatcher.setInstance(dispatcher);
        return dispatcher;
    }

    public static ActionProxy createActionProxy(
          Dispatcher dispatcher,
          String namespace,
          String actionName,
          HttpServletRequest request,
          HttpServletResponse response,
          ServletContext servletContext) throws Exception
    {
        // BEGIN: Change for Struts 2.1.6
        Container container = dispatcher.getContainer();
        ValueStack stack = container.getInstance(ValueStackFactory.class).createValueStack();
        ActionContext.setContext(new ActionContext(stack.getContext()));
        // END: Change for Struts 2.1.6

        ServletActionContext.setRequest(request);
        ServletActionContext.setResponse(response);
        ServletActionContext.setServletContext(servletContext);

        ActionMapping mapping = null;
        return dispatcher.getContainer()
           .getInstance(ActionProxyFactory.class)
           .createActionProxy(
            namespace,
            actionName,
            dispatcher.createContextMap(
                request, response, mapping, servletContext),
            true, // execute result
            false);
    }

    public ActionProxy createActionProxy(
               String namespace,
               String actionName,
               Map<String, String> requestParams,
               Map<String, Object> sessionAttributes) throws Exception
    {
        mockRequest = new MockHttpServletRequest();
        mockRequest.setSession(new MockHttpSession());
        mockResponse = new MockHttpServletResponse();

        if (requestParams != null)
        {
            for (Map.Entry<String, String> param :
                       requestParams.entrySet())
            {
                mockRequest.setupAddParameter(param.getKey(),
                                              param.getValue());
            }
        }
        if (sessionAttributes != null)
        {
            for (Map.Entry<String, ?> attribute :
                      sessionAttributes.entrySet())
            {
                mockRequest.getSession().setAttribute(
                    attribute.getKey(),
                    attribute.getValue());
            }
        }

        return createActionProxy(
            dispatcher, namespace, actionName,
            mockRequest, mockResponse, mockServletContext);
    }

    public Dispatcher getDispatcher()
    {
        return dispatcher;
    }

    public MockHttpServletRequest getMockRequest()
    {
        return mockRequest;
    }

    public MockHttpServletResponse getMockResponse()
    {
        return mockResponse;
    }

    public MockServletContext getMockServletContext()
    {
        return mockServletContext;
    }

}

Here is an example of using this class to unit test a Login Action.

/*
** Create a Dispatcher.
** This is an expensive operation as it has to load all
** the struts configuration so you will want to reuse the Dispatcher for
** multiple tests instead of re-creating it each time.
**
** In this example I'm setting configuration parameter to override the
** values in struts.xml.
*/
  HashMap<String, String> params = new HashMap<String, String>();
  // Override struts.xml config constants to use a guice test module
  params.put("struts.objectFactory", "guice");
  params.put("guice.module", "test.MyModule");

  MockServletContext servletContext = new MockServletContext();
  Dispatcher dispatcher = StrutsTestContext.prepareDispatcher(
       servletContext, params);

/*
**  Create an ActionProxy based on the namespace and action.
**  Pass in request parameters and session attributes needed for this
**  test.
*/
  StrutsTestContext context = new StrutsTestContext(
      dispatcher, servletContext);
  Map<String, String> requestParams = new HashMap<String, String>();
  Map<String, Object> sessionAttributes = new HashMap<String, Object>();
  requestParams.put("username", "test");
  requestParams.put("password", "test");

  ActionProxy proxy = context.createActionProxy(
      "/admin",      // namespace
      "LoginSubmit", // Action
      requestParams,
      sessionAttributes);

  assertTrue(proxy.getAction() instanceof LoginAction);

  // Get the Action object from the proxy
  LoginAction action = (LoginAction) proxy.getAction();

  // Inject any mock objects or set any action properties needed
  action.setXXX(new MockXXX());

  // Run the Struts Interceptor stack and the Action
  String result = proxy.execute();

  // Check the results
  assertEquals("success", result);

  // Check the user was redirected as expected
  assertEquals(true, context.getMockResponse().wasRedirectSent());
  assertEquals("/admin/WelcomeUser.action",
      context.getMockResponse().getHeader("Location"));

  // Check the session Login object was set
  assertEquals(mockLogin,
      context.getMockRequest().getSession().getAttribute(
         Constants.SESSION_LOGIN));