001: package com.mockrunner.test.web;
002:
003: import java.util.Arrays;
004:
005: import javax.el.ELResolver;
006: import javax.el.MethodExpression;
007: import javax.el.MethodInfo;
008: import javax.el.ValueExpression;
009: import javax.servlet.jsp.JspApplicationContext;
010: import javax.servlet.jsp.JspFactory;
011:
012: import org.apache.jasper.el.ELContextImpl;
013: import org.apache.jasper.runtime.JspApplicationContextImpl;
014:
015: import com.mockrunner.mock.web.JasperJspFactory;
016: import com.mockrunner.mock.web.MockHttpServletRequest;
017: import com.mockrunner.mock.web.WebMockObjectFactory;
018:
019: import junit.framework.TestCase;
020:
021: public class JasperJspFactoryTest extends TestCase {
022: private WebMockObjectFactory mockFactory;
023: private JasperJspFactory jasperFactory;
024:
025: protected void setUp() throws Exception {
026: super .setUp();
027: mockFactory = new WebMockObjectFactory();
028: jasperFactory = new JasperJspFactory();
029: }
030:
031: public void testConfigure() {
032: assertSame(jasperFactory, jasperFactory.configure(mockFactory));
033: assertTrue(jasperFactory.getJspApplicationContext(null) instanceof JspApplicationContextImpl);
034: assertSame(jasperFactory.getJspApplicationContext(null),
035: mockFactory.getMockServletContext().getAttribute(
036: JspApplicationContextImpl.class.getName()));
037: assertSame(jasperFactory.getPageContext(null, null, null, null,
038: true, 1, true), mockFactory.getMockPageContext());
039: assertTrue(mockFactory.getMockPageContext().getELContext() instanceof ELContextImpl);
040: }
041:
042: public void testResolveVariable() {
043: mockFactory.setDefaultJspFactory(jasperFactory
044: .configure(mockFactory));
045: mockFactory.getMockSession().setAttribute("test", "value");
046: ELResolver resolver = mockFactory.getMockPageContext()
047: .getELContext().getELResolver();
048: assertEquals("value", resolver.getValue(mockFactory
049: .getMockPageContext().getELContext(), null, "test"));
050: }
051:
052: public void testValueExpressionGetAndSet() {
053: mockFactory.setDefaultJspFactory(jasperFactory
054: .configure(mockFactory));
055: TestObject testObject = new TestObject();
056: testObject.setTestProperty("value");
057: mockFactory.getMockSession().setAttribute("test", testObject);
058: JspApplicationContext applicationContext = JspFactory
059: .getDefaultFactory().getJspApplicationContext(
060: mockFactory.getMockPageContext()
061: .getServletContext());
062: ValueExpression valueExpression = applicationContext
063: .getExpressionFactory()
064: .createValueExpression(
065: mockFactory.getMockPageContext().getELContext(),
066: "${test.testProperty}", String.class);
067: assertEquals("value", valueExpression.getValue(mockFactory
068: .getMockPageContext().getELContext()));
069: valueExpression.setValue(mockFactory.getMockPageContext()
070: .getELContext(), "anotherValue");
071: assertEquals("anotherValue", testObject.getTestProperty());
072: }
073:
074: public void testValueExpressionAttributes() {
075: mockFactory.setDefaultJspFactory(jasperFactory
076: .configure(mockFactory));
077: TestObject testObject = new TestObject();
078: testObject.setTestProperty("value");
079: mockFactory.getMockSession().setAttribute("test", testObject);
080: JspApplicationContext applicationContext = JspFactory
081: .getDefaultFactory().getJspApplicationContext(
082: mockFactory.getMockPageContext()
083: .getServletContext());
084: ValueExpression valueExpression = applicationContext
085: .getExpressionFactory()
086: .createValueExpression(
087: mockFactory.getMockPageContext().getELContext(),
088: "${test.testProperty}", String.class);
089: assertEquals(String.class, valueExpression.getExpectedType());
090: assertEquals(String.class, valueExpression.getType(mockFactory
091: .getMockPageContext().getELContext()));
092: assertFalse(valueExpression.isReadOnly(mockFactory
093: .getMockPageContext().getELContext()));
094: assertEquals("${test.testProperty}", valueExpression
095: .getExpressionString());
096: valueExpression = applicationContext
097: .getExpressionFactory()
098: .createValueExpression(
099: mockFactory.getMockPageContext().getELContext(),
100: "${test.testReadOnlyProperty}", Integer.class);
101: assertEquals(Integer.class, valueExpression.getExpectedType());
102: assertEquals(Integer.class, valueExpression.getType(mockFactory
103: .getMockPageContext().getELContext()));
104: assertTrue(valueExpression.isReadOnly(mockFactory
105: .getMockPageContext().getELContext()));
106: assertEquals("${test.testReadOnlyProperty}", valueExpression
107: .getExpressionString());
108: }
109:
110: public void testArithmeticValueExpression() {
111: mockFactory.setDefaultJspFactory(jasperFactory
112: .configure(mockFactory));
113: TestObject testObject = new TestObject();
114: mockFactory.getMockRequest().setAttribute("test", testObject);
115: assertExpressionEquals(
116: "${(test['testReadOnlyProperty'] + test.testArrayProperty[0]) == 26}",
117: "true");
118: }
119:
120: public void testDeferredValueExpression() {
121: mockFactory.setDefaultJspFactory(jasperFactory
122: .configure(mockFactory));
123: TestObject testObject = new TestObject();
124: testObject.setTestProperty("value");
125: mockFactory.getMockRequest().setAttribute("test", testObject);
126: assertExpressionEquals("#{test.testProperty}", "value");
127: mockFactory.getMockSession().setAttribute("test", "xyz");
128: assertExpressionEquals("#{sessionScope.test}", "xyz");
129: }
130:
131: public void testDeferredMethodExpression() {
132: mockFactory.setDefaultJspFactory(jasperFactory
133: .configure(mockFactory));
134: TestObject testObject = new TestObject();
135: mockFactory.getMockServletContext().setAttribute("test",
136: testObject);
137: JspApplicationContext applicationContext = JspFactory
138: .getDefaultFactory().getJspApplicationContext(
139: mockFactory.getMockPageContext()
140: .getServletContext());
141: MethodExpression methodExpression = applicationContext
142: .getExpressionFactory()
143: .createMethodExpression(
144: mockFactory.getMockPageContext().getELContext(),
145: "#{test.testMethod}", String.class,
146: new Class[] { String.class, });
147: assertEquals("Hello World", methodExpression.invoke(mockFactory
148: .getMockPageContext().getELContext(),
149: new String[] { "Hello World" }));
150: MethodInfo methodInfo = methodExpression
151: .getMethodInfo(mockFactory.getMockPageContext()
152: .getELContext());
153: assertEquals("testMethod", methodInfo.getName());
154: assertEquals(String.class, methodInfo.getReturnType());
155: assertTrue(Arrays.equals(new Class[] { String.class },
156: methodInfo.getParamTypes()));
157: assertEquals("#{test.testMethod}", methodExpression
158: .getExpressionString());
159: }
160:
161: public void testExpressionScopes() {
162: mockFactory.setDefaultJspFactory(jasperFactory
163: .configure(mockFactory));
164: mockFactory.getMockRequest().setAttribute("requesttest",
165: "requestvalue");
166: mockFactory.getMockSession().setAttribute("sessiontest",
167: "sessionvalue");
168: mockFactory.getMockPageContext().setAttribute("pagetest",
169: "pagevalue");
170: mockFactory.getMockServletContext().setAttribute(
171: "applicationtest", "applicationvalue");
172: assertExpressionEquals("${requestScope.requesttest}",
173: "requestvalue");
174: assertExpressionEquals("${sessionScope.sessiontest}",
175: "sessionvalue");
176: assertExpressionEquals("${pageScope.pagetest}", "pagevalue");
177: assertExpressionEquals("${applicationScope.applicationtest}",
178: "applicationvalue");
179: assertExpressionEquals("${requestScope.sessiontest}", "");
180: assertExpressionEquals("${pageScope.sessiontest}", "");
181: assertExpressionEquals("${applicationScope.requesttest}", "");
182: assertExpressionEquals("${sessionScope.requesttest}", "");
183: }
184:
185: public void testImplicitObjects() {
186: mockFactory.setDefaultJspFactory(jasperFactory
187: .configure(mockFactory));
188: MockHttpServletRequest request = mockFactory.getMockRequest();
189: request.setRequestURI("myRequestURI");
190: assertExpressionEquals("${pageContext.request.requestURI}",
191: "myRequestURI");
192: request.setupAddParameter("key1", "value1");
193: request.setupAddParameter("arraykey", new String[] {
194: "arrayvalue1", "arrayvalue2" });
195: assertExpressionEquals("${paramValues.key1[0]}", "value1");
196: assertExpressionEquals("${param['key1']}", "value1");
197: assertExpressionEquals("${paramValues.arraykey[0]}",
198: "arrayvalue1");
199: assertExpressionEquals("${paramValues.arraykey[1]}",
200: "arrayvalue2");
201: assertExpressionEquals("${param.arraykey}", "arrayvalue1");
202: request.addHeader("header", "value1");
203: request.addHeader("header", "value2");
204: assertExpressionEquals("${headerValues.header[0]}", "value1");
205: assertExpressionEquals("${headerValues.header[1]}", "value2");
206: assertExpressionEquals("${header.header}", "value1");
207: }
208:
209: private void assertExpressionEquals(String expression, String value) {
210: JspApplicationContext applicationContext = JspFactory
211: .getDefaultFactory().getJspApplicationContext(
212: mockFactory.getMockPageContext()
213: .getServletContext());
214: ValueExpression valueExpression = applicationContext
215: .getExpressionFactory()
216: .createValueExpression(
217: mockFactory.getMockPageContext().getELContext(),
218: expression, String.class);
219: assertEquals(value, valueExpression.getValue(mockFactory
220: .getMockPageContext().getELContext()));
221: }
222:
223: public static class TestObject {
224: private String testProperty;
225:
226: public String getTestProperty() {
227: return testProperty;
228: }
229:
230: public void setTestProperty(String testProperty) {
231: this .testProperty = testProperty;
232: }
233:
234: public String[] getTestArrayProperty() {
235: return new String[] { "1" };
236: }
237:
238: public Integer getTestReadOnlyProperty() {
239: return new Integer(25);
240: }
241:
242: public String testMethod(String test) {
243: return test;
244: }
245: }
246: }
|