From 59e84441966e586da01f5a587e641e574ffbc49d Mon Sep 17 00:00:00 2001 From: Jeremy Grelle Date: Tue, 11 Nov 2008 17:12:34 +0000 Subject: [PATCH] SWF-899 - FlowResourceELResolver does not work outside of Web Flow environment --- .../expression/el/FlowResourceELResolver.java | 18 +- .../el/ImplicitFlowVariableELResolver.java | 6 +- .../el/ScopeSearchingELResolver.java | 2 +- .../el/FlowDependentELResolverTestCase.java | 67 +++++ .../el/FlowResourceELResolverTests.java | 103 +++++++ .../ImplicitFlowVariableELResolverTests.java | 263 ++++++++++++++++++ .../el/ScopeSearchingELResolverTests.java | 247 ++++++++++++++++ 7 files changed, 702 insertions(+), 4 deletions(-) create mode 100644 spring-webflow/src/test/java/org/springframework/webflow/expression/el/FlowDependentELResolverTestCase.java create mode 100644 spring-webflow/src/test/java/org/springframework/webflow/expression/el/FlowResourceELResolverTests.java create mode 100644 spring-webflow/src/test/java/org/springframework/webflow/expression/el/ImplicitFlowVariableELResolverTests.java create mode 100644 spring-webflow/src/test/java/org/springframework/webflow/expression/el/ScopeSearchingELResolverTests.java diff --git a/spring-webflow/src/main/java/org/springframework/webflow/expression/el/FlowResourceELResolver.java b/spring-webflow/src/main/java/org/springframework/webflow/expression/el/FlowResourceELResolver.java index a4ea132d..89a86eee 100644 --- a/spring-webflow/src/main/java/org/springframework/webflow/expression/el/FlowResourceELResolver.java +++ b/spring-webflow/src/main/java/org/springframework/webflow/expression/el/FlowResourceELResolver.java @@ -20,7 +20,7 @@ import org.springframework.webflow.execution.RequestContextHolder; */ public class FlowResourceELResolver extends ELResolver { - private String RESOURCE_BUNDLE_KEY = "resourceBundle"; + static final String RESOURCE_BUNDLE_KEY = "resourceBundle"; private RequestContext requestContext; @@ -46,6 +46,10 @@ public class FlowResourceELResolver extends ELResolver { } public Class getType(ELContext context, Object base, Object property) { + RequestContext requestContext = getRequestContext(); + if (requestContext == null) { + return null; + } if (base == null && RESOURCE_BUNDLE_KEY.equals(property)) { context.setPropertyResolved(true); return MessageSource.class; @@ -61,6 +65,10 @@ public class FlowResourceELResolver extends ELResolver { } public Object getValue(ELContext context, Object base, Object property) { + RequestContext requestContext = getRequestContext(); + if (requestContext == null) { + return null; + } if (base == null && RESOURCE_BUNDLE_KEY.equals(property)) { context.setPropertyResolved(true); return getMessageSource(); @@ -76,6 +84,10 @@ public class FlowResourceELResolver extends ELResolver { } public boolean isReadOnly(ELContext context, Object base, Object property) { + RequestContext requestContext = getRequestContext(); + if (base != null || requestContext == null) { + return false; + } if (base == null && RESOURCE_BUNDLE_KEY.equals(property)) { context.setPropertyResolved(true); return true; @@ -84,6 +96,10 @@ public class FlowResourceELResolver extends ELResolver { } public void setValue(ELContext context, Object base, Object property, Object value) { + RequestContext requestContext = getRequestContext(); + if (base != null || requestContext == null) { + return; + } if (base == null && RESOURCE_BUNDLE_KEY.equals(property)) { throw new PropertyNotWritableException("The flow's MessageSource is not writable."); } diff --git a/spring-webflow/src/main/java/org/springframework/webflow/expression/el/ImplicitFlowVariableELResolver.java b/spring-webflow/src/main/java/org/springframework/webflow/expression/el/ImplicitFlowVariableELResolver.java index 09454053..ee2a1e7a 100644 --- a/spring-webflow/src/main/java/org/springframework/webflow/expression/el/ImplicitFlowVariableELResolver.java +++ b/spring-webflow/src/main/java/org/springframework/webflow/expression/el/ImplicitFlowVariableELResolver.java @@ -100,7 +100,8 @@ public class ImplicitFlowVariableELResolver extends ELResolver { } public boolean isReadOnly(ELContext context, Object base, Object property) { - if (base != null) { + RequestContext requestContext = getRequestContext(); + if (base != null || requestContext == null) { return false; } if (ImplicitVariables.matches(property)) { @@ -112,7 +113,8 @@ public class ImplicitFlowVariableELResolver extends ELResolver { } public void setValue(ELContext context, Object base, Object property, Object value) { - if (base != null) { + RequestContext requestContext = getRequestContext(); + if (base != null || requestContext == null) { return; } if (ImplicitVariables.matches(property)) { diff --git a/spring-webflow/src/main/java/org/springframework/webflow/expression/el/ScopeSearchingELResolver.java b/spring-webflow/src/main/java/org/springframework/webflow/expression/el/ScopeSearchingELResolver.java index 5d3c28c8..c07bf449 100644 --- a/spring-webflow/src/main/java/org/springframework/webflow/expression/el/ScopeSearchingELResolver.java +++ b/spring-webflow/src/main/java/org/springframework/webflow/expression/el/ScopeSearchingELResolver.java @@ -25,7 +25,7 @@ import org.springframework.webflow.execution.RequestContextHolder; /** * Custom EL resolver that searches the current request context for variables to resolve. The search algorithm looks in - * request scope first, then flash scope, then flow scope, then conversation scope. + * request scope first, then flash scope, then view scope, then flow scope, then conversation scope. * * Suitable for use along side other variable resolvers to support EL binding expressions like "#{bean.property}" where * "bean" could be a property in any supported scope. diff --git a/spring-webflow/src/test/java/org/springframework/webflow/expression/el/FlowDependentELResolverTestCase.java b/spring-webflow/src/test/java/org/springframework/webflow/expression/el/FlowDependentELResolverTestCase.java new file mode 100644 index 00000000..454ac972 --- /dev/null +++ b/spring-webflow/src/test/java/org/springframework/webflow/expression/el/FlowDependentELResolverTestCase.java @@ -0,0 +1,67 @@ +package org.springframework.webflow.expression.el; + +import java.util.List; + +import javax.el.ELContext; + +import junit.framework.TestCase; + +import org.springframework.binding.expression.el.DefaultELContext; +import org.springframework.binding.expression.el.DefaultELResolver; +import org.springframework.webflow.engine.ViewState; +import org.springframework.webflow.execution.RequestContext; +import org.springframework.webflow.execution.RequestContextHolder; +import org.springframework.webflow.execution.View; +import org.springframework.webflow.execution.ViewFactory; +import org.springframework.webflow.test.MockFlowSession; +import org.springframework.webflow.test.MockRequestContext; + +public abstract class FlowDependentELResolverTestCase extends TestCase { + + protected ELContext context; + + public void setUp() { + context = new DefaultELContext(new DefaultELResolver(getCustomResolvers()), null, null); + } + + public void tearDown() { + RequestContextHolder.setRequestContext(null); + } + + public void testGetType_NoActiveFlow() { + assertNull("getType should return null when no flow is active", context.getELResolver().getType(context, null, + getBaseVariable())); + assertFalse(context.isPropertyResolved()); + } + + public void testGetValue_NoActiveFlow() { + assertNull("getValue should return null when no flow is active", context.getELResolver().getValue(context, + null, getBaseVariable())); + assertFalse(context.isPropertyResolved()); + } + + public void testIsReadOnly_NoActiveFlow() { + assertFalse("isReadOnly should return false when no flow is active", context.getELResolver().isReadOnly( + context, null, getBaseVariable())); + assertFalse(context.isPropertyResolved()); + } + + public void testSetValue_NoActiveFlow() { + context.getELResolver().setValue(context, null, getBaseVariable(), null); + assertFalse("setValue should be a no-op when no flow is active", context.isPropertyResolved()); + } + + protected void initView(MockRequestContext requestContext) { + ((MockFlowSession) requestContext.getFlowExecutionContext().getActiveSession()).setState(new ViewState( + requestContext.getRootFlow(), "view", new ViewFactory() { + public View getView(RequestContext context) { + throw new UnsupportedOperationException("Auto-generated method stub"); + } + })); + } + + protected abstract String getBaseVariable(); + + protected abstract List getCustomResolvers(); + +} diff --git a/spring-webflow/src/test/java/org/springframework/webflow/expression/el/FlowResourceELResolverTests.java b/spring-webflow/src/test/java/org/springframework/webflow/expression/el/FlowResourceELResolverTests.java new file mode 100644 index 00000000..04942de7 --- /dev/null +++ b/spring-webflow/src/test/java/org/springframework/webflow/expression/el/FlowResourceELResolverTests.java @@ -0,0 +1,103 @@ +package org.springframework.webflow.expression.el; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; + +import javax.el.PropertyNotFoundException; +import javax.el.PropertyNotWritableException; + +import org.springframework.context.MessageSource; +import org.springframework.context.support.StaticMessageSource; +import org.springframework.web.context.support.StaticWebApplicationContext; +import org.springframework.webflow.engine.Flow; +import org.springframework.webflow.execution.RequestContextHolder; +import org.springframework.webflow.test.MockRequestContext; + +public class FlowResourceELResolverTests extends FlowDependentELResolverTestCase { + + public void testGetType_BaseVariable() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertEquals(getBaseVariable() + " should have a type of MessageSource", MessageSource.class, context + .getELResolver().getType(context, null, getBaseVariable())); + } + + public void testGetType_ResolvableCode() { + StaticMessageSource ms = new StaticMessageSource(); + ms.addMessage("foo.bar", Locale.getDefault(), "hello"); + + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertEquals("Message should resolve to a type of String", String.class, context.getELResolver().getType( + context, ms, "foo.bar")); + } + + public void testGetType_InvalidCode() { + StaticMessageSource ms = new StaticMessageSource(); + ms.addMessage("foo.bar", Locale.getDefault(), "hello"); + + RequestContextHolder.setRequestContext(new MockRequestContext()); + try { + context.getELResolver().getType(context, ms, "foo.baz"); + fail("Message should not be resolvable"); + } catch (PropertyNotFoundException ex) { + // expected + } + } + + public void testGetValue_BaseVariable() { + MockRequestContext requestContext = new MockRequestContext(); + ((Flow) requestContext.getActiveFlow()).setApplicationContext(new StaticWebApplicationContext()); + RequestContextHolder.setRequestContext(requestContext); + assertTrue(getBaseVariable() + " should resolve to an instance of MessageSource", context.getELResolver() + .getValue(context, null, getBaseVariable()) instanceof MessageSource); + + } + + public void testGetValue_ResolvableCode() { + StaticMessageSource ms = new StaticMessageSource(); + ms.addMessage("foo.bar", Locale.getDefault(), "hello"); + + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertEquals("Message should resolve to a valid message value", "hello", context.getELResolver().getValue( + context, ms, "foo.bar")); + } + + public void testGetValue_InvalidCode() { + StaticMessageSource ms = new StaticMessageSource(); + ms.addMessage("foo.bar", Locale.getDefault(), "hello"); + + RequestContextHolder.setRequestContext(new MockRequestContext()); + try { + context.getELResolver().getValue(context, ms, "foo.baz"); + fail("Message should not be resolvable"); + } catch (PropertyNotFoundException ex) { + // expected + } + } + + public void testIsReadOnly_BaseVariable() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertTrue("isReadOnly should return true for the base variable", context.getELResolver().isReadOnly(context, + null, getBaseVariable())); + } + + public void testSetValue_BaseVariable() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + try { + context.getELResolver().setValue(context, null, getBaseVariable(), null); + fail("setValue should fail for a base variable of " + getBaseVariable()); + } catch (PropertyNotWritableException ex) { + // expected + } + } + + protected String getBaseVariable() { + return FlowResourceELResolver.RESOURCE_BUNDLE_KEY; + } + + protected List getCustomResolvers() { + List resolvers = new ArrayList(); + resolvers.add(new FlowResourceELResolver()); + return resolvers; + } +} diff --git a/spring-webflow/src/test/java/org/springframework/webflow/expression/el/ImplicitFlowVariableELResolverTests.java b/spring-webflow/src/test/java/org/springframework/webflow/expression/el/ImplicitFlowVariableELResolverTests.java new file mode 100644 index 00000000..854966d8 --- /dev/null +++ b/spring-webflow/src/test/java/org/springframework/webflow/expression/el/ImplicitFlowVariableELResolverTests.java @@ -0,0 +1,263 @@ +package org.springframework.webflow.expression.el; + +import java.security.Principal; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import javax.el.PropertyNotWritableException; + +import org.springframework.binding.message.MessageContext; +import org.springframework.util.ClassUtils; +import org.springframework.webflow.context.ExternalContext; +import org.springframework.webflow.core.collection.MutableAttributeMap; +import org.springframework.webflow.core.collection.ParameterMap; +import org.springframework.webflow.execution.Event; +import org.springframework.webflow.execution.FlowExecutionContext; +import org.springframework.webflow.execution.RequestContextHolder; +import org.springframework.webflow.test.MockExternalContext; +import org.springframework.webflow.test.MockFlowExecutionContext; +import org.springframework.webflow.test.MockFlowExecutionKey; +import org.springframework.webflow.test.MockRequestContext; + +public class ImplicitFlowVariableELResolverTests extends FlowDependentELResolverTestCase { + + private static final List vars = new ArrayList(); + { + vars.add("requestParameters"); + vars.add("requestScope"); + vars.add("flashScope"); + vars.add("viewScope"); + vars.add("flowScope"); + vars.add("conversationScope"); + vars.add("messageContext"); + vars.add("externalContext"); + vars.add("flowExecutionContext"); + vars.add("flowExecutionUrl"); + vars.add("currentUser"); + vars.add("currentEvent"); + }; + + public void testGetType_RequestParameters() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertTrue(ClassUtils.isAssignable(ParameterMap.class, context.getELResolver().getType(context, null, + "requestParameters"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_RequestScope() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertTrue(ClassUtils.isAssignable(MutableAttributeMap.class, context.getELResolver().getType(context, null, + "requestScope"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_FlashScope() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertTrue(ClassUtils.isAssignable(MutableAttributeMap.class, context.getELResolver().getType(context, null, + "flashScope"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_ViewScope() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + initView(requestContext); + + assertTrue(ClassUtils.isAssignable(MutableAttributeMap.class, context.getELResolver().getType(context, null, + "viewScope"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_FlowScope() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertTrue(ClassUtils.isAssignable(MutableAttributeMap.class, context.getELResolver().getType(context, null, + "flowScope"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_ConversationScope() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertTrue(ClassUtils.isAssignable(MutableAttributeMap.class, context.getELResolver().getType(context, null, + "conversationScope"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_MessageContext() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertTrue(ClassUtils.isAssignable(MessageContext.class, context.getELResolver().getType(context, null, + "messageContext"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_ExternalContext() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertTrue(ClassUtils.isAssignable(ExternalContext.class, context.getELResolver().getType(context, null, + "externalContext"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_FlowExecutionContext() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + assertTrue(ClassUtils.isAssignable(FlowExecutionContext.class, context.getELResolver().getType(context, null, + "flowExecutionContext"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_FlowExecutionUrl() { + MockRequestContext requestContext = new MockRequestContext(); + ((MockFlowExecutionContext) requestContext.getFlowExecutionContext()).setKey(new MockFlowExecutionKey("e1s1")); + RequestContextHolder.setRequestContext(requestContext); + + assertTrue(ClassUtils.isAssignable(String.class, context.getELResolver().getType(context, null, + "flowExecutionUrl"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_CurrentUser() { + MockRequestContext requestContext = new MockRequestContext(); + ((MockExternalContext) requestContext.getExternalContext()).setCurrentUser("jjg"); + RequestContextHolder.setRequestContext(requestContext); + + assertTrue(ClassUtils.isAssignable(Principal.class, context.getELResolver().getType(context, null, + "currentUser"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetType_CurrentEvent() { + MockRequestContext requestContext = new MockRequestContext(); + requestContext.setCurrentEvent(new Event(this, "foo")); + RequestContextHolder.setRequestContext(requestContext); + assertTrue(ClassUtils.isAssignable(Event.class, context.getELResolver().getType(context, null, "currentEvent"))); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_RequestParameters() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getRequestParameters(), context.getELResolver().getValue(context, null, + "requestParameters")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_RequestScope() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getRequestScope(), context.getELResolver().getValue(context, null, "requestScope")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_FlashScope() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getFlashScope(), context.getELResolver().getValue(context, null, "flashScope")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_ViewScope() { + MockRequestContext requestContext = new MockRequestContext(); + initView(requestContext); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getViewScope(), context.getELResolver().getValue(context, null, "viewScope")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_FlowScope() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getFlowScope(), context.getELResolver().getValue(context, null, "flowScope")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_ConversationScope() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getConversationScope(), context.getELResolver().getValue(context, null, + "conversationScope")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_MessageContext() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getMessageContext(), context.getELResolver() + .getValue(context, null, "messageContext")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_ExternalContext() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getExternalContext(), context.getELResolver().getValue(context, null, + "externalContext")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_FlowExecutionContext() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getFlowExecutionContext(), context.getELResolver().getValue(context, null, + "flowExecutionContext")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_FlowExecutionUrl() { + MockRequestContext requestContext = new MockRequestContext(); + ((MockFlowExecutionContext) requestContext.getFlowExecutionContext()).setKey(new MockFlowExecutionKey("e1s1")); + RequestContextHolder.setRequestContext(requestContext); + assertEquals(requestContext.getFlowExecutionUrl(), context.getELResolver().getValue(context, null, + "flowExecutionUrl")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_CurrentUser() { + MockRequestContext requestContext = new MockRequestContext(); + ((MockExternalContext) requestContext.getExternalContext()).setCurrentUser("jjg"); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getExternalContext().getCurrentUser(), context.getELResolver().getValue(context, + null, "currentUser")); + assertTrue(context.isPropertyResolved()); + } + + public void testGetValue_CurrentEvent() { + MockRequestContext requestContext = new MockRequestContext(); + requestContext.setCurrentEvent(new Event(this, "foo")); + RequestContextHolder.setRequestContext(requestContext); + assertSame(requestContext.getCurrentEvent(), context.getELResolver().getValue(context, null, "currentEvent")); + assertTrue(context.isPropertyResolved()); + } + + public void testIsReadOnly_AllVars() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + Iterator i = vars.iterator(); + while (i.hasNext()) { + String var = (String) i.next(); + assertTrue(context.getELResolver().isReadOnly(context, null, var)); + } + } + + public void testSetValue_AllVars() { + RequestContextHolder.setRequestContext(new MockRequestContext()); + Iterator i = vars.iterator(); + while (i.hasNext()) { + String var = (String) i.next(); + try { + context.getELResolver().setValue(context, null, var, new Object()); + fail("setValue should not be allowed"); + } catch (PropertyNotWritableException ex) { + assertTrue(context.isPropertyResolved()); + } + } + } + + protected String getBaseVariable() { + return "flowScope"; + } + + protected List getCustomResolvers() { + List resolvers = new ArrayList(); + resolvers.add(new ImplicitFlowVariableELResolver()); + return resolvers; + } + +} diff --git a/spring-webflow/src/test/java/org/springframework/webflow/expression/el/ScopeSearchingELResolverTests.java b/spring-webflow/src/test/java/org/springframework/webflow/expression/el/ScopeSearchingELResolverTests.java new file mode 100644 index 00000000..24dd6620 --- /dev/null +++ b/spring-webflow/src/test/java/org/springframework/webflow/expression/el/ScopeSearchingELResolverTests.java @@ -0,0 +1,247 @@ +package org.springframework.webflow.expression.el; + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.webflow.execution.RequestContextHolder; +import org.springframework.webflow.test.MockRequestContext; + +public class ScopeSearchingELResolverTests extends FlowDependentELResolverTestCase { + + public void testGetType_RequestScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getRequestScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertEquals(MyBean.class, context.getELResolver().getType(context, null, getBaseVariable())); + } + + public void testGetType_FlashScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getFlashScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertEquals(MyBean.class, context.getELResolver().getType(context, null, getBaseVariable())); + } + + public void testGetType_ViewScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + initView(requestContext); + + requestContext.getViewScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertEquals(MyBean.class, context.getELResolver().getType(context, null, getBaseVariable())); + } + + public void testGetType_FlowScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getFlowScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertEquals(MyBean.class, context.getELResolver().getType(context, null, getBaseVariable())); + } + + public void testGetType_ConversationScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getConversationScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertEquals(MyBean.class, context.getELResolver().getType(context, null, getBaseVariable())); + } + + public void testGetType_NotFound() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertNull(context.getELResolver().getType(context, null, getBaseVariable())); + assertFalse(context.isPropertyResolved()); + } + + public void testGetValue_RequestScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getRequestScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertSame(foo, context.getELResolver().getValue(context, null, getBaseVariable())); + } + + public void testGetValue_FlashScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getFlashScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertSame(foo, context.getELResolver().getValue(context, null, getBaseVariable())); + } + + public void testGetValue_ViewScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + initView(requestContext); + requestContext.getViewScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertSame(foo, context.getELResolver().getValue(context, null, getBaseVariable())); + } + + public void testGetValue_FlowScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getFlowScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertSame(foo, context.getELResolver().getValue(context, null, getBaseVariable())); + } + + public void testGetValue_ConversationScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getConversationScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertSame(foo, context.getELResolver().getValue(context, null, getBaseVariable())); + } + + public void testGetValue_NotFound() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertNull(context.getELResolver().getValue(context, null, getBaseVariable())); + assertFalse(context.isPropertyResolved()); + } + + public void testIsReadOnly_RequestScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getRequestScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertFalse(context.getELResolver().isReadOnly(context, null, getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testIsReadOnly_FlashScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getFlashScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertFalse(context.getELResolver().isReadOnly(context, null, getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testIsReadOnly_ViewScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + initView(requestContext); + requestContext.getViewScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertFalse(context.getELResolver().isReadOnly(context, null, getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testIsReadOnly_FlowScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getFlowScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertFalse(context.getELResolver().isReadOnly(context, null, getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testIsReadOnly_ConversationScope() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getConversationScope().put(getBaseVariable(), foo); + RequestContextHolder.setRequestContext(requestContext); + assertFalse(context.getELResolver().isReadOnly(context, null, getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testIsReadOnly_NotFound() { + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + assertFalse(context.getELResolver().isReadOnly(context, null, getBaseVariable())); + assertFalse(context.isPropertyResolved()); + } + + public void testSetValue_RequestScope() { + MyBean foo1 = new MyBean(); + MyBean foo2 = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getRequestScope().put(getBaseVariable(), foo1); + RequestContextHolder.setRequestContext(requestContext); + context.getELResolver().setValue(context, null, getBaseVariable(), foo2); + assertSame(foo2, requestContext.getRequestScope().get(getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testSetValue_FlashScope() { + MyBean foo1 = new MyBean(); + MyBean foo2 = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getFlashScope().put(getBaseVariable(), foo1); + RequestContextHolder.setRequestContext(requestContext); + context.getELResolver().setValue(context, null, getBaseVariable(), foo2); + assertSame(foo2, requestContext.getFlashScope().get(getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testSetValue_ViewScope() { + MyBean foo1 = new MyBean(); + MyBean foo2 = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + initView(requestContext); + requestContext.getViewScope().put(getBaseVariable(), foo1); + RequestContextHolder.setRequestContext(requestContext); + context.getELResolver().setValue(context, null, getBaseVariable(), foo2); + assertSame(foo2, requestContext.getViewScope().get(getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testSetValue_FlowScope() { + MyBean foo1 = new MyBean(); + MyBean foo2 = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getFlowScope().put(getBaseVariable(), foo1); + RequestContextHolder.setRequestContext(requestContext); + context.getELResolver().setValue(context, null, getBaseVariable(), foo2); + assertSame(foo2, requestContext.getFlowScope().get(getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testSetValue_ConversationScope() { + MyBean foo1 = new MyBean(); + MyBean foo2 = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + requestContext.getConversationScope().put(getBaseVariable(), foo1); + RequestContextHolder.setRequestContext(requestContext); + context.getELResolver().setValue(context, null, getBaseVariable(), foo2); + assertSame(foo2, requestContext.getConversationScope().get(getBaseVariable())); + assertTrue(context.isPropertyResolved()); + } + + public void testSetValue_NotFound() { + MyBean foo = new MyBean(); + MockRequestContext requestContext = new MockRequestContext(); + RequestContextHolder.setRequestContext(requestContext); + context.getELResolver().setValue(context, null, getBaseVariable(), foo); + assertFalse(context.isPropertyResolved()); + } + + protected String getBaseVariable() { + return "foo"; + } + + protected List getCustomResolvers() { + List resolvers = new ArrayList(); + resolvers.add(new ScopeSearchingELResolver()); + return resolvers; + } + + private static class MyBean { + + private String bar = ""; + + public void setBar(String bar) { + this.bar = bar; + } + + public String getBar() { + return this.bar; + } + } +}