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 }