moved multipart and bind to web project since independent of servlet and required by new native web request parameter map
This commit is contained in:
Keith Donald
@@ -1,90 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2006 the original author or authors.
|
||||
*
|
||||
* Licensed 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.
|
||||
*/
|
||||
|
||||
package org.springframework.web.bind;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.beans.TestBean;
|
||||
import org.springframework.validation.BindException;
|
||||
import org.springframework.validation.Errors;
|
||||
import org.springframework.validation.FieldError;
|
||||
import org.springframework.validation.ObjectError;
|
||||
|
||||
/**
|
||||
* @author Juergen Hoeller
|
||||
* @since 02.05.2003
|
||||
*/
|
||||
public class EscapedErrorsTests extends TestCase {
|
||||
|
||||
public void testEscapedErrors() {
|
||||
TestBean tb = new TestBean();
|
||||
tb.setName("empty &");
|
||||
|
||||
Errors errors = new EscapedErrors(new BindException(tb, "tb"));
|
||||
errors.rejectValue("name", "NAME_EMPTY &", null, "message: &");
|
||||
errors.rejectValue("age", "AGE_NOT_SET <tag>", null, "message: <tag>");
|
||||
errors.rejectValue("age", "AGE_NOT_32 <tag>", null, "message: <tag>");
|
||||
errors.reject("GENERAL_ERROR \" '", null, "message: \" '");
|
||||
|
||||
assertTrue("Correct errors flag", errors.hasErrors());
|
||||
assertTrue("Correct number of errors", errors.getErrorCount() == 4);
|
||||
assertTrue("Correct object name", "tb".equals(errors.getObjectName()));
|
||||
|
||||
assertTrue("Correct global errors flag", errors.hasGlobalErrors());
|
||||
assertTrue("Correct number of global errors", errors.getGlobalErrorCount() == 1);
|
||||
ObjectError globalError = errors.getGlobalError();
|
||||
assertTrue("Global error message escaped", "message: " '".equals(globalError.getDefaultMessage()));
|
||||
assertTrue("Global error code not escaped", "GENERAL_ERROR \" '".equals(globalError.getCode()));
|
||||
ObjectError globalErrorInList = (ObjectError) errors.getGlobalErrors().get(0);
|
||||
assertTrue("Same global error in list", globalError.getDefaultMessage().equals(globalErrorInList.getDefaultMessage()));
|
||||
ObjectError globalErrorInAllList = (ObjectError) errors.getAllErrors().get(3);
|
||||
assertTrue("Same global error in list", globalError.getDefaultMessage().equals(globalErrorInAllList.getDefaultMessage()));
|
||||
|
||||
assertTrue("Correct field errors flag", errors.hasFieldErrors());
|
||||
assertTrue("Correct number of field errors", errors.getFieldErrorCount() == 3);
|
||||
assertTrue("Correct number of field errors in list", errors.getFieldErrors().size() == 3);
|
||||
FieldError fieldError = errors.getFieldError();
|
||||
assertTrue("Field error code not escaped", "NAME_EMPTY &".equals(fieldError.getCode()));
|
||||
assertTrue("Field value escaped", "empty &".equals(errors.getFieldValue("name")));
|
||||
FieldError fieldErrorInList = (FieldError) errors.getFieldErrors().get(0);
|
||||
assertTrue("Same field error in list", fieldError.getDefaultMessage().equals(fieldErrorInList.getDefaultMessage()));
|
||||
|
||||
assertTrue("Correct name errors flag", errors.hasFieldErrors("name"));
|
||||
assertTrue("Correct number of name errors", errors.getFieldErrorCount("name") == 1);
|
||||
assertTrue("Correct number of name errors in list", errors.getFieldErrors("name").size() == 1);
|
||||
FieldError nameError = errors.getFieldError("name");
|
||||
assertTrue("Name error message escaped", "message: &".equals(nameError.getDefaultMessage()));
|
||||
assertTrue("Name error code not escaped", "NAME_EMPTY &".equals(nameError.getCode()));
|
||||
assertTrue("Name value escaped", "empty &".equals(errors.getFieldValue("name")));
|
||||
FieldError nameErrorInList = (FieldError) errors.getFieldErrors("name").get(0);
|
||||
assertTrue("Same name error in list", nameError.getDefaultMessage().equals(nameErrorInList.getDefaultMessage()));
|
||||
|
||||
assertTrue("Correct age errors flag", errors.hasFieldErrors("age"));
|
||||
assertTrue("Correct number of age errors", errors.getFieldErrorCount("age") == 2);
|
||||
assertTrue("Correct number of age errors in list", errors.getFieldErrors("age").size() == 2);
|
||||
FieldError ageError = errors.getFieldError("age");
|
||||
assertTrue("Age error message escaped", "message: <tag>".equals(ageError.getDefaultMessage()));
|
||||
assertTrue("Age error code not escaped", "AGE_NOT_SET <tag>".equals(ageError.getCode()));
|
||||
assertTrue("Age value not escaped", (new Integer(0)).equals(errors.getFieldValue("age")));
|
||||
FieldError ageErrorInList = (FieldError) errors.getFieldErrors("age").get(0);
|
||||
assertTrue("Same name error in list", ageError.getDefaultMessage().equals(ageErrorInList.getDefaultMessage()));
|
||||
FieldError ageError2 = (FieldError) errors.getFieldErrors("age").get(1);
|
||||
assertTrue("Age error 2 message escaped", "message: <tag>".equals(ageError2.getDefaultMessage()));
|
||||
assertTrue("Age error 2 code not escaped", "AGE_NOT_32 <tag>".equals(ageError2.getCode()));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,256 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2006 the original author or authors.
|
||||
*
|
||||
* Licensed 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.
|
||||
*/
|
||||
|
||||
package org.springframework.web.bind;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import java.beans.PropertyEditorSupport;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.springframework.beans.ITestBean;
|
||||
import org.springframework.beans.PropertyValue;
|
||||
import org.springframework.beans.PropertyValues;
|
||||
import org.springframework.beans.TestBean;
|
||||
import org.springframework.mock.web.MockHttpServletRequest;
|
||||
|
||||
/**
|
||||
* @author Rod Johnson
|
||||
* @author Juergen Hoeller
|
||||
* @author Chris Beams
|
||||
* @author Scott Andrews
|
||||
*/
|
||||
public class ServletRequestDataBinderTests {
|
||||
|
||||
@Test
|
||||
public void testBindingWithNestedObjectCreation() throws Exception {
|
||||
TestBean tb = new TestBean();
|
||||
|
||||
ServletRequestDataBinder binder = new ServletRequestDataBinder(tb, "person");
|
||||
binder.registerCustomEditor(ITestBean.class, new PropertyEditorSupport() {
|
||||
public void setAsText(String text) throws IllegalArgumentException {
|
||||
setValue(new TestBean());
|
||||
}
|
||||
});
|
||||
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("spouse", "someValue");
|
||||
request.addParameter("spouse.name", "test");
|
||||
binder.bind(request);
|
||||
|
||||
assertNotNull(tb.getSpouse());
|
||||
assertEquals("test", tb.getSpouse().getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFieldPrefixCausesFieldReset() throws Exception {
|
||||
TestBean target = new TestBean();
|
||||
ServletRequestDataBinder binder = new ServletRequestDataBinder(target);
|
||||
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("_postProcessed", "visible");
|
||||
request.addParameter("postProcessed", "on");
|
||||
binder.bind(request);
|
||||
assertTrue(target.isPostProcessed());
|
||||
|
||||
request.removeParameter("postProcessed");
|
||||
binder.bind(request);
|
||||
assertFalse(target.isPostProcessed());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFieldPrefixCausesFieldResetWithIgnoreUnknownFields() throws Exception {
|
||||
TestBean target = new TestBean();
|
||||
ServletRequestDataBinder binder = new ServletRequestDataBinder(target);
|
||||
binder.setIgnoreUnknownFields(false);
|
||||
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("_postProcessed", "visible");
|
||||
request.addParameter("postProcessed", "on");
|
||||
binder.bind(request);
|
||||
assertTrue(target.isPostProcessed());
|
||||
|
||||
request.removeParameter("postProcessed");
|
||||
binder.bind(request);
|
||||
assertFalse(target.isPostProcessed());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFieldDefault() throws Exception {
|
||||
TestBean target = new TestBean();
|
||||
ServletRequestDataBinder binder = new ServletRequestDataBinder(target);
|
||||
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("!postProcessed", "off");
|
||||
request.addParameter("postProcessed", "on");
|
||||
binder.bind(request);
|
||||
assertTrue(target.isPostProcessed());
|
||||
|
||||
request.removeParameter("postProcessed");
|
||||
binder.bind(request);
|
||||
assertFalse(target.isPostProcessed());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFieldDefaultPreemptsFieldMarker() throws Exception {
|
||||
TestBean target = new TestBean();
|
||||
ServletRequestDataBinder binder = new ServletRequestDataBinder(target);
|
||||
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("!postProcessed", "on");
|
||||
request.addParameter("_postProcessed", "visible");
|
||||
request.addParameter("postProcessed", "on");
|
||||
binder.bind(request);
|
||||
assertTrue(target.isPostProcessed());
|
||||
|
||||
request.removeParameter("postProcessed");
|
||||
binder.bind(request);
|
||||
assertTrue(target.isPostProcessed());
|
||||
|
||||
request.removeParameter("!postProcessed");
|
||||
binder.bind(request);
|
||||
assertFalse(target.isPostProcessed());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFieldDefaultNonBoolean() throws Exception {
|
||||
TestBean target = new TestBean();
|
||||
ServletRequestDataBinder binder = new ServletRequestDataBinder(target);
|
||||
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("!name", "anonymous");
|
||||
request.addParameter("name", "Scott");
|
||||
binder.bind(request);
|
||||
assertEquals("Scott", target.getName());
|
||||
|
||||
request.removeParameter("name");
|
||||
binder.bind(request);
|
||||
assertEquals("anonymous", target.getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithCommaSeparatedStringArray() throws Exception {
|
||||
TestBean target = new TestBean();
|
||||
ServletRequestDataBinder binder = new ServletRequestDataBinder(target);
|
||||
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("stringArray", "bar");
|
||||
request.addParameter("stringArray", "abc");
|
||||
request.addParameter("stringArray", "123,def");
|
||||
binder.bind(request);
|
||||
assertEquals("Expected all three items to be bound", 3, target.getStringArray().length);
|
||||
|
||||
request.removeParameter("stringArray");
|
||||
request.addParameter("stringArray", "123,def");
|
||||
binder.bind(request);
|
||||
assertEquals("Expected only 1 item to be bound", 1, target.getStringArray().length);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBindingWithNestedObjectCreationAndWrongOrder() throws Exception {
|
||||
TestBean tb = new TestBean();
|
||||
|
||||
ServletRequestDataBinder binder = new ServletRequestDataBinder(tb, "person");
|
||||
binder.registerCustomEditor(ITestBean.class, new PropertyEditorSupport() {
|
||||
public void setAsText(String text) throws IllegalArgumentException {
|
||||
setValue(new TestBean());
|
||||
}
|
||||
});
|
||||
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("spouse.name", "test");
|
||||
request.addParameter("spouse", "someValue");
|
||||
binder.bind(request);
|
||||
|
||||
assertNotNull(tb.getSpouse());
|
||||
assertEquals("test", tb.getSpouse().getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoPrefix() throws Exception {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("forname", "Tony");
|
||||
request.addParameter("surname", "Blair");
|
||||
request.addParameter("age", "" + 50);
|
||||
|
||||
ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
|
||||
doTestTony(pvs);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPrefix() throws Exception {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("test_forname", "Tony");
|
||||
request.addParameter("test_surname", "Blair");
|
||||
request.addParameter("test_age", "" + 50);
|
||||
|
||||
ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
|
||||
assertTrue("Didn't fidn normal when given prefix", !pvs.contains("forname"));
|
||||
assertTrue("Did treat prefix as normal when not given prefix", pvs.contains("test_forname"));
|
||||
|
||||
pvs = new ServletRequestParameterPropertyValues(request, "test");
|
||||
doTestTony(pvs);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoParameters() throws Exception {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
|
||||
assertTrue("Found no parameters", pvs.getPropertyValues().length == 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleValuesForParameter() throws Exception {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
String[] original = new String[] {"Tony", "Rod"};
|
||||
request.addParameter("forname", original);
|
||||
|
||||
ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
|
||||
assertTrue("Found 1 parameter", pvs.getPropertyValues().length == 1);
|
||||
assertTrue("Found array value", pvs.getPropertyValue("forname").getValue() instanceof String[]);
|
||||
String[] values = (String[]) pvs.getPropertyValue("forname").getValue();
|
||||
assertEquals("Correct values", Arrays.asList(values), Arrays.asList(original));
|
||||
}
|
||||
|
||||
/**
|
||||
* Must contain: forname=Tony surname=Blair age=50
|
||||
*/
|
||||
protected void doTestTony(PropertyValues pvs) throws Exception {
|
||||
assertTrue("Contains 3", pvs.getPropertyValues().length == 3);
|
||||
assertTrue("Contains forname", pvs.contains("forname"));
|
||||
assertTrue("Contains surname", pvs.contains("surname"));
|
||||
assertTrue("Contains age", pvs.contains("age"));
|
||||
assertTrue("Doesn't contain tory", !pvs.contains("tory"));
|
||||
|
||||
PropertyValue[] ps = pvs.getPropertyValues();
|
||||
Map<String, String> m = new HashMap<String, String>();
|
||||
m.put("forname", "Tony");
|
||||
m.put("surname", "Blair");
|
||||
m.put("age", "50");
|
||||
for (int i = 0; i < ps.length; i++) {
|
||||
Object val = m.get(ps[i].getName());
|
||||
assertTrue("Can't have unexpected value", val != null);
|
||||
assertTrue("Val i string", val instanceof String);
|
||||
assertTrue("val matches expected", val.equals(ps[i].getValue()));
|
||||
m.remove(ps[i].getName());
|
||||
}
|
||||
assertTrue("Map size is 0", m.size() == 0);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,465 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2007 the original author or authors.
|
||||
*
|
||||
* Licensed 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.
|
||||
*/
|
||||
|
||||
package org.springframework.web.bind;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.springframework.mock.web.MockHttpServletRequest;
|
||||
import org.springframework.util.StopWatch;
|
||||
|
||||
/**
|
||||
* @author Juergen Hoeller
|
||||
* @author Chris Beams
|
||||
* @since 06.08.2003
|
||||
*/
|
||||
public class ServletRequestUtilsTests {
|
||||
|
||||
@Test
|
||||
public void testIntParameter() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param1", "5");
|
||||
request.addParameter("param2", "e");
|
||||
request.addParameter("paramEmpty", "");
|
||||
|
||||
assertEquals(ServletRequestUtils.getIntParameter(request, "param1"), new Integer(5));
|
||||
assertEquals(ServletRequestUtils.getIntParameter(request, "param1", 6), 5);
|
||||
assertEquals(ServletRequestUtils.getRequiredIntParameter(request, "param1"), 5);
|
||||
|
||||
assertEquals(ServletRequestUtils.getIntParameter(request, "param2", 6), 6);
|
||||
try {
|
||||
ServletRequestUtils.getRequiredIntParameter(request, "param2");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
assertEquals(ServletRequestUtils.getIntParameter(request, "param3"), null);
|
||||
assertEquals(ServletRequestUtils.getIntParameter(request, "param3", 6), 6);
|
||||
try {
|
||||
ServletRequestUtils.getRequiredIntParameter(request, "param3");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
try {
|
||||
ServletRequestUtils.getRequiredIntParameter(request, "paramEmpty");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIntParameters() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param", new String[] {"1", "2", "3"});
|
||||
|
||||
request.addParameter("param2", "1");
|
||||
request.addParameter("param2", "2");
|
||||
request.addParameter("param2", "bogus");
|
||||
|
||||
int[] array = new int[] {1, 2, 3};
|
||||
int[] values = ServletRequestUtils.getRequiredIntParameters(request, "param");
|
||||
assertEquals(3, values.length);
|
||||
for (int i = 0; i < array.length; i++) {
|
||||
assertEquals(array[i], values[i]);
|
||||
}
|
||||
|
||||
try {
|
||||
ServletRequestUtils.getRequiredIntParameters(request, "param2");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLongParameter() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param1", "5");
|
||||
request.addParameter("param2", "e");
|
||||
request.addParameter("paramEmpty", "");
|
||||
|
||||
assertEquals(ServletRequestUtils.getLongParameter(request, "param1"), new Long(5L));
|
||||
assertEquals(ServletRequestUtils.getLongParameter(request, "param1", 6L), 5L);
|
||||
assertEquals(ServletRequestUtils.getRequiredIntParameter(request, "param1"), 5L);
|
||||
|
||||
assertEquals(ServletRequestUtils.getLongParameter(request, "param2", 6L), 6L);
|
||||
try {
|
||||
ServletRequestUtils.getRequiredLongParameter(request, "param2");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
assertEquals(ServletRequestUtils.getLongParameter(request, "param3"), null);
|
||||
assertEquals(ServletRequestUtils.getLongParameter(request, "param3", 6L), 6L);
|
||||
try {
|
||||
ServletRequestUtils.getRequiredLongParameter(request, "param3");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
try {
|
||||
ServletRequestUtils.getRequiredLongParameter(request, "paramEmpty");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLongParameters() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.setParameter("param", new String[] {"1", "2", "3"});
|
||||
|
||||
request.setParameter("param2", "0");
|
||||
request.setParameter("param2", "1");
|
||||
request.addParameter("param2", "2");
|
||||
request.addParameter("param2", "bogus");
|
||||
|
||||
long[] array = new long[] {1L, 2L, 3L};
|
||||
long[] values = ServletRequestUtils.getRequiredLongParameters(request, "param");
|
||||
assertEquals(3, values.length);
|
||||
for (int i = 0; i < array.length; i++) {
|
||||
assertEquals(array[i], values[i]);
|
||||
}
|
||||
|
||||
try {
|
||||
ServletRequestUtils.getRequiredLongParameters(request, "param2");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
request.setParameter("param2", new String[] {"1", "2"});
|
||||
values = ServletRequestUtils.getRequiredLongParameters(request, "param2");
|
||||
assertEquals(2, values.length);
|
||||
assertEquals(1, values[0]);
|
||||
assertEquals(2, values[1]);
|
||||
|
||||
request.removeParameter("param2");
|
||||
try {
|
||||
ServletRequestUtils.getRequiredLongParameters(request, "param2");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFloatParameter() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param1", "5.5");
|
||||
request.addParameter("param2", "e");
|
||||
request.addParameter("paramEmpty", "");
|
||||
|
||||
assertTrue(ServletRequestUtils.getFloatParameter(request, "param1").equals(new Float(5.5f)));
|
||||
assertTrue(ServletRequestUtils.getFloatParameter(request, "param1", 6.5f) == 5.5f);
|
||||
assertTrue(ServletRequestUtils.getRequiredFloatParameter(request, "param1") == 5.5f);
|
||||
|
||||
assertTrue(ServletRequestUtils.getFloatParameter(request, "param2", 6.5f) == 6.5f);
|
||||
try {
|
||||
ServletRequestUtils.getRequiredFloatParameter(request, "param2");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
assertTrue(ServletRequestUtils.getFloatParameter(request, "param3") == null);
|
||||
assertTrue(ServletRequestUtils.getFloatParameter(request, "param3", 6.5f) == 6.5f);
|
||||
try {
|
||||
ServletRequestUtils.getRequiredFloatParameter(request, "param3");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
try {
|
||||
ServletRequestUtils.getRequiredFloatParameter(request, "paramEmpty");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFloatParameters() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param", new String[] {"1.5", "2.5", "3"});
|
||||
|
||||
request.addParameter("param2", "1.5");
|
||||
request.addParameter("param2", "2");
|
||||
request.addParameter("param2", "bogus");
|
||||
|
||||
float[] array = new float[] {1.5F, 2.5F, 3};
|
||||
float[] values = ServletRequestUtils.getRequiredFloatParameters(request, "param");
|
||||
assertEquals(3, values.length);
|
||||
for (int i = 0; i < array.length; i++) {
|
||||
assertEquals(array[i], values[i], 0);
|
||||
}
|
||||
|
||||
try {
|
||||
ServletRequestUtils.getRequiredFloatParameters(request, "param2");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDoubleParameter() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param1", "5.5");
|
||||
request.addParameter("param2", "e");
|
||||
request.addParameter("paramEmpty", "");
|
||||
|
||||
assertTrue(ServletRequestUtils.getDoubleParameter(request, "param1").equals(new Double(5.5)));
|
||||
assertTrue(ServletRequestUtils.getDoubleParameter(request, "param1", 6.5) == 5.5);
|
||||
assertTrue(ServletRequestUtils.getRequiredDoubleParameter(request, "param1") == 5.5);
|
||||
|
||||
assertTrue(ServletRequestUtils.getDoubleParameter(request, "param2", 6.5) == 6.5);
|
||||
try {
|
||||
ServletRequestUtils.getRequiredDoubleParameter(request, "param2");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
assertTrue(ServletRequestUtils.getDoubleParameter(request, "param3") == null);
|
||||
assertTrue(ServletRequestUtils.getDoubleParameter(request, "param3", 6.5) == 6.5);
|
||||
try {
|
||||
ServletRequestUtils.getRequiredDoubleParameter(request, "param3");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
try {
|
||||
ServletRequestUtils.getRequiredDoubleParameter(request, "paramEmpty");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDoubleParameters() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param", new String[] {"1.5", "2.5", "3"});
|
||||
|
||||
request.addParameter("param2", "1.5");
|
||||
request.addParameter("param2", "2");
|
||||
request.addParameter("param2", "bogus");
|
||||
|
||||
double[] array = new double[] {1.5, 2.5, 3};
|
||||
double[] values = ServletRequestUtils.getRequiredDoubleParameters(request, "param");
|
||||
assertEquals(3, values.length);
|
||||
for (int i = 0; i < array.length; i++) {
|
||||
assertEquals(array[i], values[i], 0);
|
||||
}
|
||||
|
||||
try {
|
||||
ServletRequestUtils.getRequiredDoubleParameters(request, "param2");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBooleanParameter() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param1", "true");
|
||||
request.addParameter("param2", "e");
|
||||
request.addParameter("param4", "yes");
|
||||
request.addParameter("param5", "1");
|
||||
request.addParameter("paramEmpty", "");
|
||||
|
||||
assertTrue(ServletRequestUtils.getBooleanParameter(request, "param1").equals(Boolean.TRUE));
|
||||
assertTrue(ServletRequestUtils.getBooleanParameter(request, "param1", false));
|
||||
assertTrue(ServletRequestUtils.getRequiredBooleanParameter(request, "param1"));
|
||||
|
||||
assertFalse(ServletRequestUtils.getBooleanParameter(request, "param2", true));
|
||||
assertFalse(ServletRequestUtils.getRequiredBooleanParameter(request, "param2"));
|
||||
|
||||
assertTrue(ServletRequestUtils.getBooleanParameter(request, "param3") == null);
|
||||
assertTrue(ServletRequestUtils.getBooleanParameter(request, "param3", true));
|
||||
try {
|
||||
ServletRequestUtils.getRequiredBooleanParameter(request, "param3");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
assertTrue(ServletRequestUtils.getBooleanParameter(request, "param4", false));
|
||||
assertTrue(ServletRequestUtils.getRequiredBooleanParameter(request, "param4"));
|
||||
|
||||
assertTrue(ServletRequestUtils.getBooleanParameter(request, "param5", false));
|
||||
assertTrue(ServletRequestUtils.getRequiredBooleanParameter(request, "param5"));
|
||||
assertFalse(ServletRequestUtils.getRequiredBooleanParameter(request, "paramEmpty"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBooleanParameters() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param", new String[] {"true", "yes", "off", "1", "bogus"});
|
||||
|
||||
request.addParameter("param2", "false");
|
||||
request.addParameter("param2", "true");
|
||||
request.addParameter("param2", "");
|
||||
|
||||
boolean[] array = new boolean[] {true, true, false, true, false};
|
||||
boolean[] values = ServletRequestUtils.getRequiredBooleanParameters(request, "param");
|
||||
assertEquals(array.length, values.length);
|
||||
for (int i = 0; i < array.length; i++) {
|
||||
assertEquals(array[i], values[i]);
|
||||
}
|
||||
|
||||
array = new boolean[] {false, true, false};
|
||||
values = ServletRequestUtils.getRequiredBooleanParameters(request, "param2");
|
||||
assertEquals(array.length, values.length);
|
||||
for (int i = 0; i < array.length; i++) {
|
||||
assertEquals(array[i], values[i]);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStringParameter() throws ServletRequestBindingException {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.addParameter("param1", "str");
|
||||
request.addParameter("paramEmpty", "");
|
||||
|
||||
assertEquals("str", ServletRequestUtils.getStringParameter(request, "param1"));
|
||||
assertEquals("str", ServletRequestUtils.getStringParameter(request, "param1", "string"));
|
||||
assertEquals("str", ServletRequestUtils.getRequiredStringParameter(request, "param1"));
|
||||
|
||||
assertEquals(null, ServletRequestUtils.getStringParameter(request, "param3"));
|
||||
assertEquals("string", ServletRequestUtils.getStringParameter(request, "param3", "string"));
|
||||
assertNull(ServletRequestUtils.getStringParameter(request, "param3", null));
|
||||
try {
|
||||
ServletRequestUtils.getRequiredStringParameter(request, "param3");
|
||||
fail("Should have thrown ServletRequestBindingException");
|
||||
}
|
||||
catch (ServletRequestBindingException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
assertEquals("", ServletRequestUtils.getStringParameter(request, "paramEmpty"));
|
||||
assertEquals("", ServletRequestUtils.getRequiredStringParameter(request, "paramEmpty"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetIntParameterWithDefaultValueHandlingIsFastEnough() {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
StopWatch sw = new StopWatch();
|
||||
sw.start();
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
ServletRequestUtils.getIntParameter(request, "nonExistingParam", 0);
|
||||
}
|
||||
sw.stop();
|
||||
System.out.println(sw.getTotalTimeMillis());
|
||||
assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetLongParameterWithDefaultValueHandlingIsFastEnough() {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
StopWatch sw = new StopWatch();
|
||||
sw.start();
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
ServletRequestUtils.getLongParameter(request, "nonExistingParam", 0);
|
||||
}
|
||||
sw.stop();
|
||||
System.out.println(sw.getTotalTimeMillis());
|
||||
assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetFloatParameterWithDefaultValueHandlingIsFastEnough() {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
StopWatch sw = new StopWatch();
|
||||
sw.start();
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
ServletRequestUtils.getFloatParameter(request, "nonExistingParam", 0f);
|
||||
}
|
||||
sw.stop();
|
||||
System.out.println(sw.getTotalTimeMillis());
|
||||
assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDoubleParameterWithDefaultValueHandlingIsFastEnough() {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
StopWatch sw = new StopWatch();
|
||||
sw.start();
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
ServletRequestUtils.getDoubleParameter(request, "nonExistingParam", 0d);
|
||||
}
|
||||
sw.stop();
|
||||
System.out.println(sw.getTotalTimeMillis());
|
||||
assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetBooleanParameterWithDefaultValueHandlingIsFastEnough() {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
StopWatch sw = new StopWatch();
|
||||
sw.start();
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
ServletRequestUtils.getBooleanParameter(request, "nonExistingParam", false);
|
||||
}
|
||||
sw.stop();
|
||||
System.out.println(sw.getTotalTimeMillis());
|
||||
assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetStringParameterWithDefaultValueHandlingIsFastEnough() {
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
StopWatch sw = new StopWatch();
|
||||
sw.start();
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
ServletRequestUtils.getStringParameter(request, "nonExistingParam", "defaultValue");
|
||||
}
|
||||
sw.stop();
|
||||
System.out.println(sw.getTotalTimeMillis());
|
||||
assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,485 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2008 the original author or authors.
|
||||
*
|
||||
* Licensed 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.
|
||||
*/
|
||||
|
||||
package org.springframework.web.multipart.commons;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Enumeration;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import javax.servlet.FilterChain;
|
||||
import javax.servlet.ServletException;
|
||||
import javax.servlet.ServletRequest;
|
||||
import javax.servlet.ServletResponse;
|
||||
import javax.servlet.http.HttpServletRequest;
|
||||
import javax.servlet.http.HttpServletResponse;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
import org.apache.commons.fileupload.FileItem;
|
||||
import org.apache.commons.fileupload.FileItemFactory;
|
||||
import org.apache.commons.fileupload.FileUpload;
|
||||
import org.apache.commons.fileupload.servlet.ServletFileUpload;
|
||||
|
||||
import org.springframework.beans.MutablePropertyValues;
|
||||
import org.springframework.mock.web.MockFilterConfig;
|
||||
import org.springframework.mock.web.MockHttpServletRequest;
|
||||
import org.springframework.mock.web.MockHttpServletResponse;
|
||||
import org.springframework.mock.web.MockServletContext;
|
||||
import org.springframework.mock.web.PassThroughFilterChain;
|
||||
import org.springframework.web.bind.ServletRequestDataBinder;
|
||||
import org.springframework.web.context.WebApplicationContext;
|
||||
import org.springframework.web.context.support.StaticWebApplicationContext;
|
||||
import org.springframework.web.multipart.MultipartFile;
|
||||
import org.springframework.web.multipart.MultipartHttpServletRequest;
|
||||
import org.springframework.web.multipart.support.ByteArrayMultipartFileEditor;
|
||||
import org.springframework.web.multipart.support.MultipartFilter;
|
||||
import org.springframework.web.multipart.support.StringMultipartFileEditor;
|
||||
import org.springframework.web.util.WebUtils;
|
||||
|
||||
/**
|
||||
* @author Juergen Hoeller
|
||||
* @since 08.10.2003
|
||||
*/
|
||||
public class CommonsMultipartResolverTests extends TestCase {
|
||||
|
||||
public void testWithApplicationContext() throws Exception {
|
||||
doTestWithApplicationContext(false);
|
||||
}
|
||||
|
||||
public void testWithApplicationContextAndLazyResolution() throws Exception {
|
||||
doTestWithApplicationContext(true);
|
||||
}
|
||||
|
||||
private void doTestWithApplicationContext(boolean lazy) throws Exception {
|
||||
StaticWebApplicationContext wac = new StaticWebApplicationContext();
|
||||
wac.setServletContext(new MockServletContext());
|
||||
wac.getServletContext().setAttribute(WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE, new File("mytemp"));
|
||||
wac.refresh();
|
||||
MockCommonsMultipartResolver resolver = new MockCommonsMultipartResolver();
|
||||
resolver.setMaxUploadSize(1000);
|
||||
resolver.setMaxInMemorySize(100);
|
||||
resolver.setDefaultEncoding("enc");
|
||||
if (lazy) {
|
||||
resolver.setResolveLazily(false);
|
||||
}
|
||||
resolver.setServletContext(wac.getServletContext());
|
||||
assertEquals(1000, resolver.getFileUpload().getSizeMax());
|
||||
assertEquals(100, resolver.getFileItemFactory().getSizeThreshold());
|
||||
assertEquals("enc", resolver.getFileUpload().getHeaderEncoding());
|
||||
assertTrue(resolver.getFileItemFactory().getRepository().getAbsolutePath().endsWith("mytemp"));
|
||||
|
||||
MockHttpServletRequest originalRequest = new MockHttpServletRequest();
|
||||
originalRequest.setMethod("POST");
|
||||
originalRequest.setContentType("multipart/form-data");
|
||||
originalRequest.addHeader("Content-type", "multipart/form-data");
|
||||
originalRequest.addParameter("getField", "getValue");
|
||||
assertTrue(resolver.isMultipart(originalRequest));
|
||||
MultipartHttpServletRequest request = resolver.resolveMultipart(originalRequest);
|
||||
|
||||
Set parameterNames = new HashSet();
|
||||
Enumeration parameterEnum = request.getParameterNames();
|
||||
while (parameterEnum.hasMoreElements()) {
|
||||
parameterNames.add(parameterEnum.nextElement());
|
||||
}
|
||||
assertEquals(3, parameterNames.size());
|
||||
assertTrue(parameterNames.contains("field3"));
|
||||
assertTrue(parameterNames.contains("field4"));
|
||||
assertTrue(parameterNames.contains("getField"));
|
||||
assertEquals("value3", request.getParameter("field3"));
|
||||
List parameterValues = Arrays.asList(request.getParameterValues("field3"));
|
||||
assertEquals(1, parameterValues.size());
|
||||
assertTrue(parameterValues.contains("value3"));
|
||||
assertEquals("value4", request.getParameter("field4"));
|
||||
parameterValues = Arrays.asList(request.getParameterValues("field4"));
|
||||
assertEquals(2, parameterValues.size());
|
||||
assertTrue(parameterValues.contains("value4"));
|
||||
assertTrue(parameterValues.contains("value5"));
|
||||
assertEquals("value4", request.getParameter("field4"));
|
||||
assertEquals("getValue", request.getParameter("getField"));
|
||||
|
||||
List parameterMapKeys = new ArrayList();
|
||||
List parameterMapValues = new ArrayList();
|
||||
for (Iterator parameterMapIter = request.getParameterMap().keySet().iterator(); parameterMapIter.hasNext();) {
|
||||
String key = (String) parameterMapIter.next();
|
||||
parameterMapKeys.add(key);
|
||||
parameterMapValues.add(request.getParameterMap().get(key));
|
||||
}
|
||||
assertEquals(3, parameterMapKeys.size());
|
||||
assertEquals(3, parameterMapValues.size());
|
||||
int field3Index = parameterMapKeys.indexOf("field3");
|
||||
int field4Index = parameterMapKeys.indexOf("field4");
|
||||
int getFieldIndex = parameterMapKeys.indexOf("getField");
|
||||
assertTrue(field3Index != -1);
|
||||
assertTrue(field4Index != -1);
|
||||
assertTrue(getFieldIndex != -1);
|
||||
parameterValues = Arrays.asList((String[]) parameterMapValues.get(field3Index));
|
||||
assertEquals(1, parameterValues.size());
|
||||
assertTrue(parameterValues.contains("value3"));
|
||||
parameterValues = Arrays.asList((String[]) parameterMapValues.get(field4Index));
|
||||
assertEquals(2, parameterValues.size());
|
||||
assertTrue(parameterValues.contains("value4"));
|
||||
assertTrue(parameterValues.contains("value5"));
|
||||
parameterValues = Arrays.asList((String[]) parameterMapValues.get(getFieldIndex));
|
||||
assertEquals(1, parameterValues.size());
|
||||
assertTrue(parameterValues.contains("getValue"));
|
||||
|
||||
Set fileNames = new HashSet();
|
||||
Iterator fileIter = request.getFileNames();
|
||||
while (fileIter.hasNext()) {
|
||||
fileNames.add(fileIter.next());
|
||||
}
|
||||
assertEquals(3, fileNames.size());
|
||||
assertTrue(fileNames.contains("field1"));
|
||||
assertTrue(fileNames.contains("field2"));
|
||||
assertTrue(fileNames.contains("field2x"));
|
||||
CommonsMultipartFile file1 = (CommonsMultipartFile) request.getFile("field1");
|
||||
CommonsMultipartFile file2 = (CommonsMultipartFile) request.getFile("field2");
|
||||
CommonsMultipartFile file2x = (CommonsMultipartFile) request.getFile("field2x");
|
||||
Map fileMap = request.getFileMap();
|
||||
assertEquals(3, fileMap.size());
|
||||
assertTrue(fileMap.containsKey("field1"));
|
||||
assertTrue(fileMap.containsKey("field2"));
|
||||
assertTrue(fileMap.containsKey("field2x"));
|
||||
assertEquals(file1, fileMap.get("field1"));
|
||||
assertEquals(file2, fileMap.get("field2"));
|
||||
assertEquals(file2x, fileMap.get("field2x"));
|
||||
|
||||
assertEquals("type1", file1.getContentType());
|
||||
assertEquals("type2", file2.getContentType());
|
||||
assertEquals("type2", file2x.getContentType());
|
||||
assertEquals("field1.txt", file1.getOriginalFilename());
|
||||
assertEquals("field2.txt", file2.getOriginalFilename());
|
||||
assertEquals("field2x.txt", file2x.getOriginalFilename());
|
||||
assertEquals("text1", new String(file1.getBytes()));
|
||||
assertEquals("text2", new String(file2.getBytes()));
|
||||
assertEquals(5, file1.getSize());
|
||||
assertEquals(5, file2.getSize());
|
||||
assertTrue(file1.getInputStream() instanceof ByteArrayInputStream);
|
||||
assertTrue(file2.getInputStream() instanceof ByteArrayInputStream);
|
||||
File transfer1 = new File("C:/transfer1");
|
||||
File transfer2 = new File("C:/transfer2");
|
||||
file1.transferTo(transfer1);
|
||||
file2.transferTo(transfer2);
|
||||
assertEquals(transfer1, ((MockFileItem) file1.getFileItem()).writtenFile);
|
||||
assertEquals(transfer2, ((MockFileItem) file2.getFileItem()).writtenFile);
|
||||
|
||||
MultipartTestBean1 mtb1 = new MultipartTestBean1();
|
||||
assertEquals(null, mtb1.getField1());
|
||||
assertEquals(null, mtb1.getField2());
|
||||
ServletRequestDataBinder binder = new ServletRequestDataBinder(mtb1, "mybean");
|
||||
binder.registerCustomEditor(byte[].class, new ByteArrayMultipartFileEditor());
|
||||
binder.bind(request);
|
||||
assertEquals(file1, mtb1.getField1());
|
||||
assertEquals(new String(file2.getBytes()), new String(mtb1.getField2()));
|
||||
|
||||
MultipartTestBean2 mtb2 = new MultipartTestBean2();
|
||||
assertEquals(null, mtb2.getField1());
|
||||
assertEquals(null, mtb2.getField2());
|
||||
binder = new ServletRequestDataBinder(mtb2, "mybean");
|
||||
binder.registerCustomEditor(String.class, "field1", new StringMultipartFileEditor());
|
||||
binder.registerCustomEditor(String.class, "field2", new StringMultipartFileEditor("UTF-16"));
|
||||
binder.bind(request);
|
||||
assertEquals(new String(file1.getBytes()), mtb2.getField1());
|
||||
assertEquals(new String(file2.getBytes(), "UTF-16"), mtb2.getField2());
|
||||
|
||||
resolver.cleanupMultipart(request);
|
||||
assertTrue(((MockFileItem) file1.getFileItem()).deleted);
|
||||
assertTrue(((MockFileItem) file2.getFileItem()).deleted);
|
||||
|
||||
resolver.setEmpty(true);
|
||||
request = resolver.resolveMultipart(originalRequest);
|
||||
binder.setBindEmptyMultipartFiles(false);
|
||||
String firstBound = mtb2.getField1();
|
||||
binder.bind(request);
|
||||
assertTrue(mtb2.getField1().length() > 0);
|
||||
assertEquals(firstBound, mtb2.getField1());
|
||||
|
||||
request = resolver.resolveMultipart(originalRequest);
|
||||
binder.setBindEmptyMultipartFiles(true);
|
||||
binder.bind(request);
|
||||
assertTrue(mtb2.getField1().length() == 0);
|
||||
}
|
||||
|
||||
public void testWithServletContextAndFilter() throws Exception {
|
||||
StaticWebApplicationContext wac = new StaticWebApplicationContext();
|
||||
wac.setServletContext(new MockServletContext());
|
||||
wac.registerSingleton("filterMultipartResolver", MockCommonsMultipartResolver.class, new MutablePropertyValues());
|
||||
wac.getServletContext().setAttribute(WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE, new File("mytemp"));
|
||||
wac.refresh();
|
||||
wac.getServletContext().setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);
|
||||
CommonsMultipartResolver resolver = new CommonsMultipartResolver(wac.getServletContext());
|
||||
assertTrue(resolver.getFileItemFactory().getRepository().getAbsolutePath().endsWith("mytemp"));
|
||||
|
||||
MockFilterConfig filterConfig = new MockFilterConfig(wac.getServletContext(), "filter");
|
||||
filterConfig.addInitParameter("class", "notWritable");
|
||||
filterConfig.addInitParameter("unknownParam", "someValue");
|
||||
final MultipartFilter filter = new MultipartFilter();
|
||||
filter.init(filterConfig);
|
||||
|
||||
final List files = new ArrayList();
|
||||
final FilterChain filterChain = new FilterChain() {
|
||||
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) {
|
||||
MultipartHttpServletRequest request = (MultipartHttpServletRequest) servletRequest;
|
||||
files.addAll(request.getFileMap().values());
|
||||
}
|
||||
};
|
||||
|
||||
FilterChain filterChain2 = new PassThroughFilterChain(filter, filterChain);
|
||||
|
||||
MockHttpServletRequest originalRequest = new MockHttpServletRequest();
|
||||
MockHttpServletResponse response = new MockHttpServletResponse();
|
||||
originalRequest.setMethod("POST");
|
||||
originalRequest.setContentType("multipart/form-data");
|
||||
originalRequest.addHeader("Content-type", "multipart/form-data");
|
||||
filter.doFilter(originalRequest, response, filterChain2);
|
||||
|
||||
CommonsMultipartFile file1 = (CommonsMultipartFile) files.get(0);
|
||||
CommonsMultipartFile file2 = (CommonsMultipartFile) files.get(1);
|
||||
assertTrue(((MockFileItem) file1.getFileItem()).deleted);
|
||||
assertTrue(((MockFileItem) file2.getFileItem()).deleted);
|
||||
}
|
||||
|
||||
public void testWithServletContextAndFilterWithCustomBeanName() throws Exception {
|
||||
StaticWebApplicationContext wac = new StaticWebApplicationContext();
|
||||
wac.setServletContext(new MockServletContext());
|
||||
wac.refresh();
|
||||
wac.registerSingleton("myMultipartResolver", MockCommonsMultipartResolver.class, new MutablePropertyValues());
|
||||
wac.getServletContext().setAttribute(WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE, new File("mytemp"));
|
||||
wac.getServletContext().setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);
|
||||
CommonsMultipartResolver resolver = new CommonsMultipartResolver(wac.getServletContext());
|
||||
assertTrue(resolver.getFileItemFactory().getRepository().getAbsolutePath().endsWith("mytemp"));
|
||||
|
||||
MockFilterConfig filterConfig = new MockFilterConfig(wac.getServletContext(), "filter");
|
||||
filterConfig.addInitParameter("multipartResolverBeanName", "myMultipartResolver");
|
||||
|
||||
final List files = new ArrayList();
|
||||
FilterChain filterChain = new FilterChain() {
|
||||
public void doFilter(ServletRequest originalRequest, ServletResponse response) {
|
||||
if (originalRequest instanceof MultipartHttpServletRequest) {
|
||||
MultipartHttpServletRequest request = (MultipartHttpServletRequest) originalRequest;
|
||||
files.addAll(request.getFileMap().values());
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
MultipartFilter filter = new MultipartFilter() {
|
||||
private boolean invoked = false;
|
||||
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
|
||||
FilterChain filterChain) throws ServletException, IOException {
|
||||
super.doFilterInternal(request, response, filterChain);
|
||||
super.doFilterInternal(request, response, filterChain);
|
||||
if (invoked) {
|
||||
throw new ServletException("Should not have been invoked twice");
|
||||
}
|
||||
invoked = true;
|
||||
}
|
||||
};
|
||||
filter.init(filterConfig);
|
||||
|
||||
MockHttpServletRequest originalRequest = new MockHttpServletRequest();
|
||||
originalRequest.setMethod("POST");
|
||||
originalRequest.setContentType("multipart/form-data");
|
||||
originalRequest.addHeader("Content-type", "multipart/form-data");
|
||||
HttpServletResponse response = new MockHttpServletResponse();
|
||||
filter.doFilter(originalRequest, response, filterChain);
|
||||
CommonsMultipartFile file1 = (CommonsMultipartFile) files.get(0);
|
||||
CommonsMultipartFile file2 = (CommonsMultipartFile) files.get(1);
|
||||
assertTrue(((MockFileItem) file1.getFileItem()).deleted);
|
||||
assertTrue(((MockFileItem) file2.getFileItem()).deleted);
|
||||
}
|
||||
|
||||
|
||||
public static class MockCommonsMultipartResolver extends CommonsMultipartResolver {
|
||||
|
||||
private boolean empty;
|
||||
|
||||
protected void setEmpty(boolean empty) {
|
||||
this.empty = empty;
|
||||
}
|
||||
|
||||
protected FileUpload newFileUpload(FileItemFactory fileItemFactory) {
|
||||
return new ServletFileUpload() {
|
||||
public List parseRequest(HttpServletRequest request) {
|
||||
if (request instanceof MultipartHttpServletRequest) {
|
||||
throw new IllegalStateException("Already a multipart request");
|
||||
}
|
||||
List fileItems = new ArrayList();
|
||||
MockFileItem fileItem1 = new MockFileItem(
|
||||
"field1", "type1", empty ? "" : "field1.txt", empty ? "" : "text1");
|
||||
MockFileItem fileItem2 = new MockFileItem(
|
||||
"field2", "type2", empty ? "" : "C:/field2.txt", empty ? "" : "text2");
|
||||
MockFileItem fileItem2x = new MockFileItem(
|
||||
"field2x", "type2", empty ? "" : "C:\\field2x.txt", empty ? "" : "text2");
|
||||
MockFileItem fileItem3 = new MockFileItem("field3", null, null, "value3");
|
||||
MockFileItem fileItem4 = new MockFileItem("field4", null, null, "value4");
|
||||
MockFileItem fileItem5 = new MockFileItem("field4", null, null, "value5");
|
||||
fileItems.add(fileItem1);
|
||||
fileItems.add(fileItem2);
|
||||
fileItems.add(fileItem2x);
|
||||
fileItems.add(fileItem3);
|
||||
fileItems.add(fileItem4);
|
||||
fileItems.add(fileItem5);
|
||||
return fileItems;
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private static class MockFileItem implements FileItem {
|
||||
|
||||
private String fieldName;
|
||||
private String contentType;
|
||||
private String name;
|
||||
private String value;
|
||||
|
||||
private File writtenFile;
|
||||
private boolean deleted;
|
||||
|
||||
public MockFileItem(String fieldName, String contentType, String name, String value) {
|
||||
this.fieldName = fieldName;
|
||||
this.contentType = contentType;
|
||||
this.name = name;
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
public InputStream getInputStream() throws IOException {
|
||||
return new ByteArrayInputStream(value.getBytes());
|
||||
}
|
||||
|
||||
public String getContentType() {
|
||||
return contentType;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public boolean isInMemory() {
|
||||
return true;
|
||||
}
|
||||
|
||||
public long getSize() {
|
||||
return value.length();
|
||||
}
|
||||
|
||||
public byte[] get() {
|
||||
return value.getBytes();
|
||||
}
|
||||
|
||||
public String getString(String encoding) throws UnsupportedEncodingException {
|
||||
return new String(get(), encoding);
|
||||
}
|
||||
|
||||
public String getString() {
|
||||
return value;
|
||||
}
|
||||
|
||||
public void write(File file) throws Exception {
|
||||
this.writtenFile = file;
|
||||
}
|
||||
|
||||
public File getWrittenFile() {
|
||||
return writtenFile;
|
||||
}
|
||||
|
||||
public void delete() {
|
||||
this.deleted = true;
|
||||
}
|
||||
|
||||
public boolean isDeleted() {
|
||||
return deleted;
|
||||
}
|
||||
|
||||
public String getFieldName() {
|
||||
return fieldName;
|
||||
}
|
||||
|
||||
public void setFieldName(String s) {
|
||||
this.fieldName = s;
|
||||
}
|
||||
|
||||
public boolean isFormField() {
|
||||
return (this.name == null);
|
||||
}
|
||||
|
||||
public void setFormField(boolean b) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
public OutputStream getOutputStream() throws IOException {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public class MultipartTestBean1 {
|
||||
|
||||
private MultipartFile field1;
|
||||
private byte[] field2;
|
||||
|
||||
public void setField1(MultipartFile field1) {
|
||||
this.field1 = field1;
|
||||
}
|
||||
|
||||
public MultipartFile getField1() {
|
||||
return field1;
|
||||
}
|
||||
|
||||
public void setField2(byte[] field2) {
|
||||
this.field2 = field2;
|
||||
}
|
||||
|
||||
public byte[] getField2() {
|
||||
return field2;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public class MultipartTestBean2 {
|
||||
|
||||
private String field1;
|
||||
private String field2;
|
||||
|
||||
public void setField1(String field1) {
|
||||
this.field1 = field1;
|
||||
}
|
||||
|
||||
public String getField1() {
|
||||
return field1;
|
||||
}
|
||||
|
||||
public void setField2(String field2) {
|
||||
this.field2 = field2;
|
||||
}
|
||||
|
||||
public String getField2() {
|
||||
return field2;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2006 the original author or authors.
|
||||
*
|
||||
* Licensed 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.
|
||||
*/
|
||||
|
||||
package org.springframework.web.multipart.support;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
import org.easymock.MockControl;
|
||||
|
||||
import org.springframework.web.multipart.MultipartFile;
|
||||
|
||||
/**
|
||||
* @author Rick Evans
|
||||
*/
|
||||
public final class ByteArrayMultipartFileEditorTests extends TestCase {
|
||||
|
||||
public void testSetValueAsByteArray() throws Exception {
|
||||
ByteArrayMultipartFileEditor editor = new ByteArrayMultipartFileEditor();
|
||||
String expectedValue = "Shumwere, shumhow, a shuck ish washing you. - Drunken Far Side";
|
||||
editor.setValue(expectedValue.getBytes());
|
||||
assertEquals(expectedValue, editor.getAsText());
|
||||
}
|
||||
|
||||
public void testSetValueAsString() throws Exception {
|
||||
ByteArrayMultipartFileEditor editor = new ByteArrayMultipartFileEditor();
|
||||
String expectedValue = "'Green Wing' - classic British comedy";
|
||||
editor.setValue(expectedValue);
|
||||
assertEquals(expectedValue, editor.getAsText());
|
||||
}
|
||||
|
||||
public void testSetValueAsCustomObjectInvokesToString() throws Exception {
|
||||
ByteArrayMultipartFileEditor editor = new ByteArrayMultipartFileEditor();
|
||||
final String expectedValue = "'Green Wing' - classic British comedy";
|
||||
Object object = new Object() {
|
||||
public String toString() {
|
||||
return expectedValue;
|
||||
}
|
||||
};
|
||||
editor.setValue(object);
|
||||
assertEquals(expectedValue, editor.getAsText());
|
||||
}
|
||||
|
||||
public void testSetValueAsNullGetsBackEmptyString() throws Exception {
|
||||
ByteArrayMultipartFileEditor editor = new ByteArrayMultipartFileEditor();
|
||||
editor.setValue(null);
|
||||
assertEquals("", editor.getAsText());
|
||||
}
|
||||
|
||||
public void testSetValueAsMultipartFile() throws Exception {
|
||||
String expectedValue = "That is comforting to know";
|
||||
ByteArrayMultipartFileEditor editor = new ByteArrayMultipartFileEditor();
|
||||
MockControl mock = MockControl.createControl(MultipartFile.class);
|
||||
MultipartFile file = (MultipartFile) mock.getMock();
|
||||
file.getBytes();
|
||||
mock.setReturnValue(expectedValue.getBytes());
|
||||
mock.replay();
|
||||
editor.setValue(file);
|
||||
assertEquals(expectedValue, editor.getAsText());
|
||||
mock.verify();
|
||||
}
|
||||
|
||||
public void testSetValueAsMultipartFileWithBadBytes() throws Exception {
|
||||
ByteArrayMultipartFileEditor editor = new ByteArrayMultipartFileEditor();
|
||||
MockControl mock = MockControl.createControl(MultipartFile.class);
|
||||
MultipartFile file = (MultipartFile) mock.getMock();
|
||||
file.getBytes();
|
||||
mock.setThrowable(new IOException());
|
||||
mock.replay();
|
||||
try {
|
||||
editor.setValue(file);
|
||||
fail("Must have thrown an IllegalArgumentException: IOException thrown when reading MultipartFile bytes");
|
||||
}
|
||||
catch (IllegalArgumentException expected) {
|
||||
}
|
||||
mock.verify();
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user