    001    package org.apache.turbine.modules;
    002
    003    /*
    004     * Licensed to the Apache Software Foundation (ASF) under one
    005     * or more contributor license agreements.  See the NOTICE file
    006     * distributed with this work for additional information
    007     * regarding copyright ownership.  The ASF licenses this file
    008     * to you under the Apache License, Version 2.0 (the
    009     * "License"); you may not use this file except in compliance
    010     * with the License.  You may obtain a copy of the License at
    011     *
    012     *   http://www.apache.org/licenses/LICENSE-2.0
    013     *
    014     * Unless required by applicable law or agreed to in writing,
    015     * software distributed under the License is distributed on an
    016     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    017     * KIND, either express or implied.  See the License for the
    018     * specific language governing permissions and limitations
    019     * under the License.
    020     */
    021
    022
    023    import java.util.HashMap;
    024    import java.util.Map;
    025    import java.util.Vector;
    026
    027    import javax.servlet.http.HttpServletResponse;
    028
    029    import junit.framework.Assert;
    030
    031    import org.apache.turbine.Turbine;
    032    import org.apache.turbine.modules.actions.VelocityActionDoesNothing;
    033    import org.apache.turbine.om.security.User;
    034    import org.apache.turbine.pipeline.DefaultPipelineData;
    035    import org.apache.turbine.pipeline.PipelineData;
    036    import org.apache.turbine.test.BaseTestCase;
    037    import org.apache.turbine.test.EnhancedMockHttpServletRequest;
    038    import org.apache.turbine.test.EnhancedMockHttpSession;
    039    import org.apache.turbine.util.RunData;
    040    import org.apache.turbine.util.TurbineConfig;
    041
    042    import com.mockobjects.servlet.MockHttpServletResponse;
    043    import com.mockobjects.servlet.MockServletConfig;
    044    /**
    045     * This test case is to verify whether exceptions in Velocity actions are
    046     * properly bubbled up when action.event.bubbleexception=true.  Or, if
    047     * action.event.bubbleexception=false, then the exceptions should be
    048     * logged and sunk.
    049     *
    050     * @author     <a href="mailto:epugh@upstate.com">Eric Pugh</a>
    051     * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a>
    052     */
    053    public class ActionLoaderTest extends BaseTestCase {
    054            private static TurbineConfig tc = null;
    055            private MockServletConfig config = null;
    056            private EnhancedMockHttpServletRequest request = null;
    057            private EnhancedMockHttpSession session = null;
    058            private HttpServletResponse response = null;
    059
    060        /*
    061             * @see TestCase#setUp()
    062             */
    063            protected void setUp() throws Exception {
    064                    super.setUp();
    065                    config = new MockServletConfig();
    066                    config.setupNoParameters();
    067                    request = new EnhancedMockHttpServletRequest();
    068                    request.setupServerName("bob");
    069                    request.setupGetProtocol("http");
    070                    request.setupScheme("scheme");
    071                    request.setupPathInfo("damn");
    072                    request.setupGetServletPath("damn2");
    073                    request.setupGetContextPath("wow");
    074                    request.setupGetContentType("html/text");
    075                    request.setupAddHeader("Content-type", "html/text");
    076                    request.setupAddHeader("Accept-Language", "en-US");
    077                    Vector v = new Vector();
    078                    request.setupGetParameterNames(v.elements());
    079                    session = new EnhancedMockHttpSession();
    080                    response = new MockHttpServletResponse();
    081                    session.setupGetAttribute(User.SESSION_KEY, null);
    082                    request.setSession(session);
    083                    tc =
    084                            new TurbineConfig(
    085                                    ".",
    086                                    "/conf/test/CompleteTurbineResources.properties");
    087                    tc.initialize();
    088            }
    089            /*
    090             * @see TestCase#tearDown()
    091             */
    092            protected void tearDown() throws Exception {
    093                    super.tearDown();
    094                    if (tc != null) {
    095                            tc.dispose();
    096                    }
    097            }
    098            /**
    099             * Constructor for VelocityErrorScreenTest.
    100             * @param arg0
    101             */
    102            public ActionLoaderTest(String arg0) throws Exception {
    103                    super(arg0);
    104            }
    105            /**
    106             * This unit test verifies that if your standard doPerform is called,
    107             * and it throws an Exception, the exception is bubbled up out of the ActionLoader...
    108             *
    109             * @throws Exception If something goes wrong with the unit test
    110             */
    111            public void testDoPerformBubblesException() throws Exception {
    112                    RunData data = getRunData(request,response,config);
    113                    PipelineData pipelineData = new DefaultPipelineData();
    114                    Map runDataMap = new HashMap();
    115                    runDataMap.put(RunData.class, data);
    116                    pipelineData.put(RunData.class, runDataMap);
    117                    data.setAction("VelocityActionThrowsException");
    118                    try {
    119                            ActionLoader.getInstance().exec(data, data.getAction());
    120                            fail("Should have thrown an exception");
    121                    } catch (Exception e) {
    122                            //good
    123                    }
    124
    125                    try {
    126                            ActionLoader.getInstance().exec(pipelineData, data.getAction());
    127                            fail("Should have thrown an exception");
    128                    } catch (Exception e) {
    129                            //good
    130                    }
    131            }
    132            /**
    133               * This unit test verifies that if an Action Event doEventSubmit_ is called, and it throws an Exception, the
    134               * exception is bubbled up out of the ActionLoader...
    135               *
    136               * @throws Exception If something goes wrong with the unit test
    137               */
    138            public void testActionEventBubblesException() throws Exception {
    139                    // can't seem to figure out how to setup the Mock Request with the right parameters...
    140                    request.setupAddParameter("eventSubmit_doCauseexception", "foo");
    141                    RunData data = getRunData(request,response,config);
    142                    PipelineData pipelineData = new DefaultPipelineData();
    143                    Map runDataMap = new HashMap();
    144                    runDataMap.put(RunData.class, data);
    145                    pipelineData.put(RunData.class, runDataMap);
    146                    data.setAction("VelocityActionThrowsException");
    147                    data.getParameters().add("eventSubmit_doCauseexception", "foo");
    148                    assertTrue(
    149                            data.getParameters().containsKey("eventSubmit_doCauseexception"));
    150                    try {
    151                            ActionLoader.getInstance().exec(data, data.getAction());
    152                            fail("Should have bubbled out an exception thrown by the action.");
    153                    } catch (Exception e) {
    154                            //good
    155                    }
    156                    try {
    157                            ActionLoader.getInstance().exec(pipelineData, data.getAction());
    158                            fail("Should have bubbled out an exception thrown by the action.");
    159                    } catch (Exception e) {
    160                            //good
    161                    }
    162            }
    163
    164            /**
    165             * This unit test verifies that if your standard doPerform is called,
    166             * and it throws an Exception, if the action.event.bubbleexception
    167         * property is set to false then the exception is NOT bubbled up
    168             *
    169             * @throws Exception If something goes wrong with the unit test
    170             */
    171            public void testDoPerformDoesntBubbleException() throws Exception {
    172                    Turbine.getConfiguration().setProperty("action.event.bubbleexception",Boolean.FALSE);
    173                    assertFalse(Turbine.getConfiguration().getBoolean("action.event.bubbleexception"));
    174                    RunData data = getRunData(request,response,config);
    175                    PipelineData pipelineData = new DefaultPipelineData();
    176                    Map runDataMap = new HashMap();
    177                    runDataMap.put(RunData.class, data);
    178                    pipelineData.put(RunData.class, runDataMap);
    179                    data.setAction("VelocityActionThrowsException");
    180                    try {
    181                            ActionLoader.getInstance().exec(data, data.getAction());
    182
    183                    } catch (Exception e) {
    184                            fail("Should NOT have thrown an exception:" + e.getMessage());
    185                    }
    186                    try {
    187                            ActionLoader.getInstance().exec(pipelineData, data.getAction());
    188
    189                    } catch (Exception e) {
    190                            fail("Should NOT have thrown an exception:" + e.getMessage());
    191                    }
    192            }
    193            /**
    194         * This unit test verifies that if an Action Event doEventSubmit_ is called,
    195         * and it throws an Exception, if the action.event.bubbleexception
    196         * property is set to false then the exception is NOT bubbled up
    197         *
    198         * @throws Exception If something goes wrong with the unit test
    199         */
    200            public void testActionEventDoesntBubbleException() throws Exception {
    201                    // can't seem to figure out how to setup the Mock Request with the right parameters...
    202                    Turbine.getConfiguration().setProperty("action.event.bubbleexception",Boolean.FALSE);
    203                    request.setupAddParameter("eventSubmit_doCauseexception", "foo");
    204                    RunData data = getRunData(request,response,config);
    205                    PipelineData pipelineData = new DefaultPipelineData();
    206                    Map runDataMap = new HashMap();
    207                    runDataMap.put(RunData.class, data);
    208                    pipelineData.put(RunData.class, runDataMap);
    209                    data.setAction("VelocityActionThrowsException");
    210                    data.getParameters().add("eventSubmit_doCauseexception", "foo");
    211                    assertTrue(
    212                            data.getParameters().containsKey("eventSubmit_doCauseexception"));
    213
    214                    try {
    215                            ActionLoader.getInstance().exec(data, data.getAction());
    216                    } catch (Exception e) {
    217                            fail("Should NOT have thrown an exception:" + e.getMessage());
    218                    }
    219                    try {
    220                            ActionLoader.getInstance().exec(pipelineData, data.getAction());
    221                    } catch (Exception e) {
    222                            fail("Should NOT have thrown an exception:" + e.getMessage());
    223                    }
    224            }
    225            public void testNonexistentActionCausesError() throws Exception {
    226                RunData data = getRunData(request,response,config);
    227                    PipelineData pipelineData = new DefaultPipelineData();
    228                    Map runDataMap = new HashMap();
    229                    runDataMap.put(RunData.class, data);
    230                    pipelineData.put(RunData.class, runDataMap);
    231                    data.setAction("ImaginaryAction");
    232                    try {
    233                            ActionLoader.getInstance().exec(data, "boo");
    234                            fail("Should have thrown an exception");
    235                    } catch (Exception e) {
    236                            //good
    237                    }
    238                    try {
    239                            ActionLoader.getInstance().exec(pipelineData, "boo");
    240                            fail("Should have thrown an exception");
    241                    } catch (Exception e) {
    242                            //good
    243                    }
    244            }
    245
    246            public void testDoPerformWithRunData() throws Exception
    247            {
    248                RunData data = getRunData(request,response,config);
    249                    data.setAction("VelocityActionDoesNothing");
    250                    try {
    251                            ActionLoader.getInstance().exec(data, data.getAction());
    252                    } catch (Exception e) {
    253                        e.printStackTrace();
    254                        Assert.fail("Should not have thrown an exception.");
    255                    }
    256
    257            }
    258
    259            public void testDoPerformWithPipelineData() throws Exception
    260            {
    261                RunData data = getRunData(request,response,config);
    262            PipelineData pipelineData = data;
    263                    data.setAction("VelocityActionDoesNothing");
    264                    int numberOfCalls = VelocityActionDoesNothing.numberOfCalls;
    265                    int pipelineDataCalls = VelocityActionDoesNothing.pipelineDataCalls;
    266                    int runDataCalls = VelocityActionDoesNothing.runDataCalls;
    267                    try {
    268                            ActionLoader.getInstance().exec(pipelineData, data.getAction());
    269                    } catch (Exception e) {
    270                        e.printStackTrace();
    271                        Assert.fail("Should not have thrown an exception.");
    272                    }
    273                    assertEquals(numberOfCalls+1,VelocityActionDoesNothing.numberOfCalls);
    274                    assertEquals(runDataCalls,VelocityActionDoesNothing.runDataCalls);
    275                    assertEquals(pipelineDataCalls+1,VelocityActionDoesNothing.pipelineDataCalls);
    276
    277            }
    278
    279    }