src/test/org/apache/turbine/modules/ActionLoaderTest.java

package org.apache.turbine.modules;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.ServletConfig;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.turbine.Turbine;
import org.apache.turbine.modules.actions.VelocityActionDoesNothing;
import org.apache.turbine.pipeline.DefaultPipelineData;
import org.apache.turbine.pipeline.PipelineData;
import org.apache.turbine.services.velocity.VelocityService;
import org.apache.turbine.test.BaseTestCase;
import org.apache.turbine.util.RunData;
import org.apache.turbine.util.TurbineConfig;
import org.apache.velocity.context.Context;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

/**
 * This test case is to verify whether exceptions in Velocity actions are
 * properly bubbled up when action.event.bubbleexception=true. Or, if
 * action.event.bubbleexception=false, then the exceptions should be logged and
 * sunk.
 *
 * Changes 2014/Jun/26 (gk): removed Constructor with String parameter as no Test VelocityErrorScreenTest is found and JUnit does not allow it.
 *
 * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
 * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a>
 */
public class ActionLoaderTest extends BaseTestCase
{
    private static TurbineConfig tc = null;
    private ServletConfig config = null;
    private HttpServletRequest request = null;
    private HttpServletResponse response = null;

    /*
     * @see TestCase#setUp()
     */

    @BeforeClass
    public static void init()
    {
        tc = new TurbineConfig(".", "/conf/test/CompleteTurbineResources.properties");
        tc.initialize();
    }

    @Before
    public void setUpBefore() throws Exception
    {
        config = mock(ServletConfig.class);
        request = getMockRequest();
        response = mock(HttpServletResponse.class);
    }

    /*
     * @see TestCase#tearDown()
     */
    @AfterClass
    public static void tearDown() throws Exception
    {
        if (tc != null)
        {
            tc.dispose();
        }
    }

    /**
     * This unit test verifies that if your standard doPerform is called, and it
     * throws an Exception, the exception is bubbled up out of the
     * ActionLoader...
     *
     * @throws Exception
     *             If something goes wrong with the unit test
     */
    @Test
    public void testDoPerformBubblesException() throws Exception
    {
        System.out.println("tcturbine:"+ tc.getTurbine());
    }

    /**
     * This unit test verifies that if an Action Event doEventSubmit_ is called,
     * and it throws an Exception, the exception is bubbled up out of the
     * ActionLoader...
     *
     * @throws Exception
     *             If something goes wrong with the unit test
     */
    @Test
    public void testActionEventBubblesException() throws Exception
    {
        when(request.getParameterValues("eventSubmit_doCauseexception")).thenReturn(new String[] { "foo" });
        RunData data = getRunData(request, response, config);
        PipelineData pipelineData = new DefaultPipelineData();
        Map<Class<?>, Object> runDataMap = new HashMap<>();
        runDataMap.put(RunData.class, data);
        pipelineData.put(RunData.class, runDataMap);
        data.setAction("VelocityActionThrowsException");
        data.getParameters().add("eventSubmit_doCauseexception", "foo");
        assertTrue(data.getParameters().containsKey("eventSubmit_doCauseexception"));
        try
        {
            ActionLoader.getInstance().exec(data, data.getAction());
            fail("Should have bubbled out an exception thrown by the action.");
        }
        catch (Exception e)
        {
            // good
        }
        try
        {
            ActionLoader.getInstance().exec(pipelineData, data.getAction());
            fail("Should have bubbled out an exception thrown by the action.");
        }
        catch (Exception e)
        {
            // good
        }
    }

    /**
     * This unit test verifies that if your standard doPerform is called, and it
     * throws an Exception, if the action.event.bubbleexception property is set
     * to false then the exception is NOT bubbled up
     *
     * @throws Exception
     *             If something goes wrong with the unit test
     */
    @Test
    public void testDoPerformDoesntBubbleException() throws Exception
    {
        Turbine.getConfiguration().setProperty("action.event.bubbleexception", Boolean.FALSE);
        assertFalse(Turbine.getConfiguration().getBoolean("action.event.bubbleexception"));
        RunData data = getRunData(request, response, config);
        PipelineData pipelineData = new DefaultPipelineData();
        Map<Class<?>, Object> runDataMap = new HashMap<>();
        runDataMap.put(RunData.class, data);
        pipelineData.put(RunData.class, runDataMap);
        data.setAction("VelocityActionThrowsException");
        try
        {
            ActionLoader.getInstance().exec(data, data.getAction());
        }
        catch (Exception e)
        {
            fail("Should NOT have thrown an exception:" + e.getMessage());
        }
        try
        {
            ActionLoader.getInstance().exec(pipelineData, data.getAction());
        }
        catch (Exception e)
        {
            fail("Should NOT have thrown an exception:" + e.getMessage());
        }
    }

    /**
     * This unit test verifies that if an Action Event doEventSubmit_ is called,
     * and it throws an Exception, if the action.event.bubbleexception property
     * is set to false then the exception is NOT bubbled up
     *
     * @throws Exception
     *             If something goes wrong with the unit test
     */
    @Test
    public void testActionEventDoesntBubbleException() throws Exception
    {
        // can't seem to figure out how to setup the Mock Request with the right
        // parameters...
        Turbine.getConfiguration().setProperty("action.event.bubbleexception", Boolean.FALSE);
        when(request.getParameterValues("eventSubmit_doCauseexception")).thenReturn(new String[] { "foo" });
        RunData data = getRunData(request, response, config);
        PipelineData pipelineData = new DefaultPipelineData();
        Map<Class<?>, Object> runDataMap = new HashMap<>();
        runDataMap.put(RunData.class, data);
        pipelineData.put(RunData.class, runDataMap);
        data.setAction("VelocityActionThrowsException");
        data.getParameters().add("eventSubmit_doCauseexception", "foo");
        assertTrue(data.getParameters().containsKey("eventSubmit_doCauseexception"));

        try
        {
            ActionLoader.getInstance().exec(data, data.getAction());
        }
        catch (Exception e)
        {
            fail("Should NOT have thrown an exception:" + e.getMessage());
        }
        try
        {
            ActionLoader.getInstance().exec(pipelineData, data.getAction());
        }
        catch (Exception e)
        {
            fail("Should NOT have thrown an exception:" + e.getMessage());
        }
    }

    /**
     * This unit test verifies that if an Action Event doEventSubmit_ is called,
     * a properly annotated method is being called
     *
     * @throws Exception
     *             If something goes wrong with the unit test
     */
    @Test
    public void testActionEventAnnotation() throws Exception
    {
        when(request.getParameterValues("eventSubmit_annotatedEvent")).thenReturn(new String[] { "foo" });
        RunData data = getRunData(request, response, config);
        PipelineData pipelineData = data;
        data.setAction("VelocityActionDoesNothing");
        data.getParameters().add("eventSubmit_annotatedEvent", "foo");

        int numberOfCalls = VelocityActionDoesNothing.numberOfCalls;
        int pipelineDataCalls = VelocityActionDoesNothing.pipelineDataCalls;
        int actionEventCalls = VelocityActionDoesNothing.actionEventCalls;
        try
        {
            ActionLoader.getInstance().exec(pipelineData, data.getAction());
        }
        catch (Exception e)
        {
            e.printStackTrace();
            fail("Should not have thrown an exception.");
        }
        assertEquals(numberOfCalls + 1, VelocityActionDoesNothing.numberOfCalls);
        assertEquals(pipelineDataCalls, VelocityActionDoesNothing.pipelineDataCalls);
        assertEquals(actionEventCalls + 1, VelocityActionDoesNothing.actionEventCalls);
    }

    @Test
    public void testNonexistentActionCausesError() throws Exception
    {
        RunData data = getRunData(request, response, config);
        PipelineData pipelineData = new DefaultPipelineData();
        Map<Class<?>, Object> runDataMap = new HashMap<>();
        runDataMap.put(RunData.class, data);
        pipelineData.put(RunData.class, runDataMap);
        data.setAction("ImaginaryAction");
        try
        {
            ActionLoader.getInstance().exec(data, "boo");
            fail("Should have thrown an exception");
        }
        catch (Exception e)
        {
            // good
        }
        try
        {
            ActionLoader.getInstance().exec(pipelineData, "boo");
            fail("Should have thrown an exception");
        }
        catch (Exception e)
        {
            // good
        }
    }

    @Test
    public void testDoPerformWithPipelineData() throws Exception
    {
        RunData data = getRunData(request, response, config);
        PipelineData pipelineData = data;
        data.setAction("VelocityActionDoesNothing");
        int numberOfCalls = VelocityActionDoesNothing.numberOfCalls;
        int pipelineDataCalls = VelocityActionDoesNothing.pipelineDataCalls;
        try
        {
            ActionLoader.getInstance().exec(pipelineData, data.getAction());
        }
        catch (Exception e)
        {
            e.printStackTrace();
            fail("Should not have thrown an exception.");
        }
        assertEquals(numberOfCalls + 1, VelocityActionDoesNothing.numberOfCalls);
        assertEquals(pipelineDataCalls + 1, VelocityActionDoesNothing.pipelineDataCalls);
    }

    @Test
    public void testDoPerformWithServiceInjection() throws Exception
    {
        RunData data = getRunData(request, response, config);
        PipelineData pipelineData = data;
        data.setAction("VelocityActionWithServiceInjection");

        try
        {
            ActionLoader.getInstance().exec(pipelineData, data.getAction());
            Context context = (Context)
                            data.getTemplateInfo().getTemplateContext(VelocityService.CONTEXT);
            assertTrue( context.get( "mykey" ) != null );
        }
        catch (Exception e)
        {
            e.printStackTrace();
            fail("Should not have thrown an exception.");
        }
    }
}