Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SPR-8214 review unit tests

Browse Source
This commit is contained in:
Rossen Stoyanchev
2011-04-15 18:42:58 +00:00
parent 83ce399c47
commit 9c65973b33
42 changed files with 1189 additions and 1083 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodArgumentResolverComposite.java
View File

@@ -43,7 +43,7 @@ public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgu
private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>();
/**
* Whether the given {@linkplain MethodParameter method parameter} is supported by any registered
* {@link HandlerMethodArgumentResolver}.
@@ -93,10 +93,21 @@ public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgu
}
/**
* Register the given {@link HandlerMethodArgumentResolver}.
* Add the given {@link HandlerMethodArgumentResolver}.
*/
public void registerArgumentResolver(HandlerMethodArgumentResolver argumentResolver) {
public void addResolver(HandlerMethodArgumentResolver argumentResolver) {
this.argumentResolvers.add(argumentResolver);
}
/**
* Add the given {@link HandlerMethodArgumentResolver}s.
*/
public void addResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
if (argumentResolvers != null) {
for (HandlerMethodArgumentResolver resolver : argumentResolvers) {
this.argumentResolvers.add(resolver);
}
}
}
}

15
org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerComposite.java
View File

@@ -92,10 +92,21 @@ public class HandlerMethodReturnValueHandlerComposite implements HandlerMethodRe
}
/**
* Register the given {@link HandlerMethodReturnValueHandler}.
* Add the given {@link HandlerMethodReturnValueHandler}.
*/
public void registerReturnValueHandler(HandlerMethodReturnValueHandler returnValuehandler) {
public void addHandler(HandlerMethodReturnValueHandler returnValuehandler) {
returnValueHandlers.add(returnValuehandler);
}
/**
* Add the given {@link HandlerMethodReturnValueHandler}s.
*/
public void addHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
if (returnValueHandlers != null) {
for (HandlerMethodReturnValueHandler handler : returnValueHandlers) {
this.returnValueHandlers.add(handler);
}
}
}
}

91
org.springframework.web/src/test/java/org/springframework/web/method/annotation/HandlerSessionAttributeStoreTests.java
View File

@@ -23,7 +23,6 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
@@ -31,96 +30,96 @@ import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.TestBean;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.bind.support.DefaultSessionAttributeStore;
import org.springframework.web.bind.support.SessionAttributeStore;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.method.annotation.SessionAttributesHandler;
/**
* Test fixture for {@link SessionAttributesHandler} unit tests.
* Test fixture with {@link SessionAttributesHandler}.
*
* @author Rossen Stoyanchev
*/
public class HandlerSessionAttributeStoreTests {
private DefaultSessionAttributeStore sessionAttributes;
private SessionAttributesHandler handlerSessionAttributes;
private Class<?> handlerType = SessionAttributeHandler.class;
private SessionAttributesHandler sessionAttributesHandler;
private SessionAttributeStore sessionAttributeStore;
private NativeWebRequest request;
@Before
public void setUp() {
this.sessionAttributes = new DefaultSessionAttributeStore();
this.handlerSessionAttributes = new SessionAttributesHandler(handlerType, sessionAttributes);
this.sessionAttributeStore = new DefaultSessionAttributeStore();
this.sessionAttributesHandler = new SessionAttributesHandler(handlerType, sessionAttributeStore);
this.request = new ServletWebRequest(new MockHttpServletRequest());
}
@Test
public void isSessionAttribute() throws Exception {
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("attr1", null));
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("attr2", null));
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("simple", TestBean.class));
assertFalse("Attribute name not known", handlerSessionAttributes.isHandlerSessionAttribute("simple", null));
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("attr1", null));
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("attr2", null));
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("simple", TestBean.class));
assertFalse(sessionAttributesHandler.isHandlerSessionAttribute("simple", null));
}
@Test
public void retrieveAttributes() throws Exception {
sessionAttributes.storeAttribute(request, "attr1", "value1");
sessionAttributes.storeAttribute(request, "attr2", "value2");
sessionAttributes.storeAttribute(request, "attr3", new TestBean());
sessionAttributeStore.storeAttribute(request, "attr1", "value1");
sessionAttributeStore.storeAttribute(request, "attr2", "value2");
sessionAttributeStore.storeAttribute(request, "attr3", new TestBean());
// Query attributes to associate them with the handler type
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("attr1", null));
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("attr3", TestBean.class));
// Resolve successfully handler session attributes once
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("attr1", null));
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("attr3", TestBean.class));
Map<String, ?> attributes = handlerSessionAttributes.retrieveHandlerSessionAttributes(request);
Map<String, ?> attributes = sessionAttributesHandler.retrieveHandlerSessionAttributes(request);
assertEquals(new HashSet<String>(asList("attr1", "attr3")), attributes.keySet());
}
@Test
public void cleanupAttribute() throws Exception {
sessionAttributes.storeAttribute(request, "attr1", "value1");
sessionAttributes.storeAttribute(request, "attr2", "value2");
sessionAttributes.storeAttribute(request, "attr3", new TestBean());
public void cleanupAttributes() throws Exception {
sessionAttributeStore.storeAttribute(request, "attr1", "value1");
sessionAttributeStore.storeAttribute(request, "attr2", "value2");
sessionAttributeStore.storeAttribute(request, "attr3", new TestBean());
// Query attribute to associate it with the handler type
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("attr1", null));
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("attr3", TestBean.class));
// Resolve successfully handler session attributes once
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("attr1", null));
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("attr3", TestBean.class));
handlerSessionAttributes.cleanupHandlerSessionAttributes(request);
sessionAttributesHandler.cleanupHandlerSessionAttributes(request);
assertNull(sessionAttributes.retrieveAttribute(request, "attr1"));
assertNotNull(sessionAttributes.retrieveAttribute(request, "attr2"));
assertNull(sessionAttributes.retrieveAttribute(request, "attr3"));
assertNull(sessionAttributeStore.retrieveAttribute(request, "attr1"));
assertNotNull(sessionAttributeStore.retrieveAttribute(request, "attr2"));
assertNull(sessionAttributeStore.retrieveAttribute(request, "attr3"));
}
@Test
public void storeAttributes() throws Exception {
Map<String, Object> attributes = new HashMap<String, Object>();
attributes.put("attr1", "value1");
attributes.put("attr2", "value2");
attributes.put("attr3", new TestBean());
ModelMap model = new ModelMap();
model.put("attr1", "value1");
model.put("attr2", "value2");
model.put("attr3", new TestBean());
// Query attribute to associate it with the handler type
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("attr1", null));
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("attr2", null));
assertTrue(handlerSessionAttributes.isHandlerSessionAttribute("attr3", TestBean.class));
// Resolve successfully handler session attributes once
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("attr1", null));
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("attr2", null));
assertTrue(sessionAttributesHandler.isHandlerSessionAttribute("attr3", TestBean.class));
handlerSessionAttributes.storeHandlerSessionAttributes(request, attributes);
sessionAttributesHandler.storeHandlerSessionAttributes(request, model);
assertEquals("value1", sessionAttributes.retrieveAttribute(request, "attr1"));
assertEquals("value2", sessionAttributes.retrieveAttribute(request, "attr2"));
assertTrue(sessionAttributes.retrieveAttribute(request, "attr3") instanceof TestBean);
assertEquals("value1", sessionAttributeStore.retrieveAttribute(request, "attr1"));
assertEquals("value2", sessionAttributeStore.retrieveAttribute(request, "attr2"));
assertTrue(sessionAttributeStore.retrieveAttribute(request, "attr3") instanceof TestBean);
}
@SessionAttributes(value = { "attr1", "attr2" }, types = { TestBean.class })
private static class SessionAttributeHandler {
}
}
}

59
org.springframework.web/src/test/java/org/springframework/web/method/annotation/InitBinderMethodDataBinderFactoryTests.java
View File

@@ -43,28 +43,28 @@ import org.springframework.web.method.support.InvocableHandlerMethod;
import org.springframework.web.method.support.HandlerMethodArgumentResolverComposite;
/**
* Test fixture for {@link InitBinderMethodDataBinderFactory} unit tests.
* Test fixture with {@link InitBinderMethodDataBinderFactory}.
*
* @author Rossen Stoyanchev
*/
public class InitBinderMethodDataBinderFactoryTests {
private MockHttpServletRequest request;
private ConfigurableWebBindingInitializer bindingInitializer;
private HandlerMethodArgumentResolverComposite argumentResolvers;
private NativeWebRequest webRequest;
private ConfigurableWebBindingInitializer bindingInitializer;
@Before
public void setUp() throws Exception {
this.request = new MockHttpServletRequest();
this.webRequest = new ServletWebRequest(request);
this.bindingInitializer = new ConfigurableWebBindingInitializer();
bindingInitializer = new ConfigurableWebBindingInitializer();
argumentResolvers = new HandlerMethodArgumentResolverComposite();
webRequest = new ServletWebRequest(new MockHttpServletRequest());
}
@Test
public void createBinder() throws Exception {
InitBinderMethodDataBinderFactory factory = createFactory("initBinder", WebDataBinder.class);
WebDataBinderFactory factory = createBinderFactory("initBinder", WebDataBinder.class);
WebDataBinder dataBinder = factory.createBinder(webRequest, null, null);
assertNotNull(dataBinder.getDisallowedFields());
@@ -76,7 +76,7 @@ public class InitBinderMethodDataBinderFactoryTests {
ConversionService conversionService = new DefaultFormattingConversionService();
bindingInitializer.setConversionService(conversionService );
InitBinderMethodDataBinderFactory factory = createFactory("initBinder", WebDataBinder.class);
WebDataBinderFactory factory = createBinderFactory("initBinder", WebDataBinder.class);
WebDataBinder dataBinder = factory.createBinder(webRequest, null, null);
assertSame(conversionService, dataBinder.getConversionService());
@@ -84,7 +84,7 @@ public class InitBinderMethodDataBinderFactoryTests {
@Test
public void createBinderWithAttrName() throws Exception {
InitBinderMethodDataBinderFactory factory = createFactory("initBinderWithAttributeName", WebDataBinder.class);
WebDataBinderFactory factory = createBinderFactory("initBinderWithAttributeName", WebDataBinder.class);
WebDataBinder dataBinder = factory.createBinder(webRequest, null, "foo");
assertNotNull(dataBinder.getDisallowedFields());
@@ -93,7 +93,7 @@ public class InitBinderMethodDataBinderFactoryTests {
@Test
public void createBinderWithAttrNameNoMatch() throws Exception {
WebDataBinderFactory factory = createFactory("initBinderWithAttributeName", WebDataBinder.class);
WebDataBinderFactory factory = createBinderFactory("initBinderWithAttributeName", WebDataBinder.class);
WebDataBinder dataBinder = factory.createBinder(webRequest, null, "invalidName");
assertNull(dataBinder.getDisallowedFields());
@@ -101,41 +101,34 @@ public class InitBinderMethodDataBinderFactoryTests {
@Test(expected=IllegalStateException.class)
public void returnValueNotExpected() throws Exception {
WebDataBinderFactory factory = createFactory("initBinderReturnValue", WebDataBinder.class);
WebDataBinderFactory factory = createBinderFactory("initBinderReturnValue", WebDataBinder.class);
factory.createBinder(webRequest, null, "invalidName");
}
@Test
public void createBinderTypeConversion() throws Exception {
request.setParameter("requestParam", "22");
webRequest.getNativeRequest(MockHttpServletRequest.class).setParameter("requestParam", "22");
argumentResolvers.addResolver(new RequestParamMethodArgumentResolver(null, false));
HandlerMethodArgumentResolverComposite argResolvers = new HandlerMethodArgumentResolverComposite();
argResolvers.registerArgumentResolver(new RequestParamMethodArgumentResolver(null, false));
String methodName = "initBinderTypeConversion";
WebDataBinderFactory factory = createFactory(argResolvers, methodName, WebDataBinder.class, int.class);
WebDataBinderFactory factory = createBinderFactory("initBinderTypeConversion", WebDataBinder.class, int.class);
WebDataBinder dataBinder = factory.createBinder(webRequest, null, "foo");
assertNotNull(dataBinder.getDisallowedFields());
assertEquals("requestParam-22", dataBinder.getDisallowedFields()[0]);
}
private InitBinderMethodDataBinderFactory createFactory(String methodName, Class<?>... parameterTypes)
throws Exception {
return createFactory(new HandlerMethodArgumentResolverComposite(), methodName, parameterTypes);
}
private InitBinderMethodDataBinderFactory createFactory(HandlerMethodArgumentResolverComposite argResolvers,
String methodName, Class<?>... parameterTypes) throws Exception {
Object handler = new InitBinderHandler();
Method method = InitBinderHandler.class.getMethod(methodName, parameterTypes);
private WebDataBinderFactory createBinderFactory(String methodName, Class<?>... parameterTypes)
throws Exception {
InvocableHandlerMethod controllerMethod = new InvocableHandlerMethod(handler, method);
controllerMethod.setHandlerMethodArgumentResolvers(argResolvers);
controllerMethod.setDataBinderFactory(new DefaultDataBinderFactory(null));
controllerMethod.setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());
Object handler = new InitBinderHandler();
Method method = handler.getClass().getMethod(methodName, parameterTypes);
InvocableHandlerMethod handlerMethod = new InvocableHandlerMethod(handler, method);
handlerMethod.setHandlerMethodArgumentResolvers(argumentResolvers);
handlerMethod.setDataBinderFactory(new DefaultDataBinderFactory(null));
handlerMethod.setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());
return new InitBinderMethodDataBinderFactory(Arrays.asList(controllerMethod), bindingInitializer);
return new InitBinderMethodDataBinderFactory(Arrays.asList(handlerMethod), bindingInitializer);
}
private static class InitBinderHandler {
@@ -165,4 +158,4 @@ public class InitBinderMethodDataBinderFactoryTests {
}
}
}
}

86
org.springframework.web/src/test/java/org/springframework/web/method/annotation/ModelFactoryTests.java
View File

@@ -49,87 +49,91 @@ import org.springframework.web.method.support.InvocableHandlerMethod;
import org.springframework.web.method.support.ModelAndViewContainer;
/**
* Text fixture for {@link ModelFactory} unit tests.
* Text fixture for {@link ModelFactory} tests.
*
* @author Rossen Stoyanchev
*/
public class ModelFactoryTests {
private NativeWebRequest webRequest;
private SessionAttributeStore sessionAttributeStore;
private Object handler = new ModelHandler();
private InvocableHandlerMethod handleMethod;
private SessionAttributesHandler handlerSessionAttributeStore;
private InvocableHandlerMethod requestMethod;
private SessionAttributeStore sessionAttributeStore;
private ModelAndViewContainer mavContainer;
private NativeWebRequest webRequest;
@Before
public void setUp() throws Exception {
Object handler = new ModelHandler();
Method method = handler.getClass().getDeclaredMethod("handle");
this.requestMethod = new InvocableHandlerMethod(handler, method);
this.sessionAttributeStore = new DefaultSessionAttributeStore();
this.handlerSessionAttributeStore = new SessionAttributesHandler(handler.getClass(), sessionAttributeStore);
this.mavContainer = new ModelAndViewContainer();
this.webRequest = new ServletWebRequest(new MockHttpServletRequest());
handleMethod = new InvocableHandlerMethod(handler, handler.getClass().getDeclaredMethod("handle"));
sessionAttributeStore = new DefaultSessionAttributeStore();
handlerSessionAttributeStore = new SessionAttributesHandler(handler.getClass(), sessionAttributeStore);
mavContainer = new ModelAndViewContainer();
webRequest = new ServletWebRequest(new MockHttpServletRequest());
}
@Test
public void createModel() throws Exception {
createFactory(new ModelHandler(), "model", Model.class).initModel(webRequest, mavContainer, requestMethod);
ModelFactory modelFactory = createModelFactory("model", Model.class);
modelFactory.initModel(webRequest, mavContainer, handleMethod);
assertEquals(Boolean.TRUE, mavContainer.getAttribute("model"));
}
@Test
public void createModelWithName() throws Exception {
createFactory(new ModelHandler(), "modelWithName").initModel(webRequest, mavContainer, requestMethod);
ModelFactory modelFactory = createModelFactory("modelWithName");
modelFactory.initModel(webRequest, mavContainer, handleMethod);
assertEquals(Boolean.TRUE, mavContainer.getAttribute("name"));
}
@Test
public void createModelWithDefaultName() throws Exception {
createFactory(new ModelHandler(), "modelWithDefaultName").initModel(webRequest, mavContainer, requestMethod);
ModelFactory modelFactory = createModelFactory("modelWithDefaultName");
modelFactory.initModel(webRequest, mavContainer, handleMethod);
assertEquals(Boolean.TRUE, mavContainer.getAttribute("boolean"));
}
@Test
public void createModelWithExistingName() throws Exception {
createFactory(new ModelHandler(), "modelWithName").initModel(webRequest, mavContainer, requestMethod);
ModelFactory modelFactory = createModelFactory("modelWithName");
modelFactory.initModel(webRequest, mavContainer, handleMethod);
assertEquals(Boolean.TRUE, mavContainer.getAttribute("name"));
}
@Test
public void createModelWithNullAttribute() throws Exception {
createFactory(new ModelHandler(), "modelWithNullAttribute").initModel(webRequest, mavContainer, requestMethod);
ModelFactory modelFactory = createModelFactory("modelWithNullAttribute");
modelFactory.initModel(webRequest, mavContainer, handleMethod);
assertTrue(mavContainer.containsAttribute("name"));
assertNull(mavContainer.getAttribute("name"));
}
@Test
public void createModelExistingSessionAttributes() throws Exception {
sessionAttributeStore.storeAttribute(webRequest, "sessionAttr", "sessionAttrValue");
sessionAttributeStore.storeAttribute(webRequest, "sessAttr", "sessAttrValue");
// Query attribute to associate it with the handler type
assertTrue(handlerSessionAttributeStore.isHandlerSessionAttribute("sessionAttr", null));
// Resolve successfully handler session attribute once
assertTrue(handlerSessionAttributeStore.isHandlerSessionAttribute("sessAttr", null));
createFactory(new ModelHandler(), "model", Model.class).initModel(webRequest, mavContainer, requestMethod);
assertEquals("sessionAttrValue", mavContainer.getAttribute("sessionAttr"));
ModelFactory modelFactory = createModelFactory("model", Model.class);
modelFactory.initModel(webRequest, mavContainer, handleMethod);
assertEquals("sessAttrValue", mavContainer.getAttribute("sessAttr"));
}
@Test
public void updateBindingResult() throws Exception {
Object handler = new ModelHandler();
SessionAttributeStore store = new DefaultSessionAttributeStore();
SessionAttributesHandler sessionAttributeStore = new SessionAttributesHandler(handler.getClass(), store);
String attrName = "attr1";
Object attrValue = new Object();
mavContainer.addAttribute(attrName, attrValue);
WebDataBinder dataBinder = new WebDataBinder(attrValue, attrName);
@@ -138,7 +142,7 @@ public class ModelFactoryTests {
expect(binderFactory.createBinder(webRequest, attrValue, attrName)).andReturn(dataBinder);
replay(binderFactory);
ModelFactory modelFactory = new ModelFactory(null, binderFactory, sessionAttributeStore);
ModelFactory modelFactory = new ModelFactory(null, binderFactory, handlerSessionAttributeStore);
modelFactory.updateModel(webRequest, mavContainer, new SimpleSessionStatus());
assertEquals(attrValue, mavContainer.getModel().remove(attrName));
@@ -152,21 +156,21 @@ public class ModelFactoryTests {
return BindingResult.MODEL_KEY_PREFIX + key;
}
private ModelFactory createFactory(Object handler, String methodName, Class<?>... parameterTypes) throws Exception{
private ModelFactory createModelFactory(String methodName, Class<?>... parameterTypes) throws Exception{
Method method = ModelHandler.class.getMethod(methodName, parameterTypes);
HandlerMethodArgumentResolverComposite argResolvers = new HandlerMethodArgumentResolverComposite();
argResolvers.registerArgumentResolver(new ModelMethodProcessor());
argResolvers.addResolver(new ModelMethodProcessor());
InvocableHandlerMethod controllerMethod = new InvocableHandlerMethod(handler, method);
controllerMethod.setHandlerMethodArgumentResolvers(argResolvers);
controllerMethod.setDataBinderFactory(null);
controllerMethod.setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());
InvocableHandlerMethod handlerMethod = new InvocableHandlerMethod(handler, method);
handlerMethod.setHandlerMethodArgumentResolvers(argResolvers);
handlerMethod.setDataBinderFactory(null);
handlerMethod.setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());
return new ModelFactory(Arrays.asList(controllerMethod), null, handlerSessionAttributeStore);
return new ModelFactory(Arrays.asList(handlerMethod), null, handlerSessionAttributeStore);
}
@SessionAttributes("sessionAttr")
@SessionAttributes("sessAttr")
private static class ModelHandler {
@SuppressWarnings("unused")

109
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/CookieValueMethodArgumentResolverTests.java Normal file
View File

@@ -0,0 +1,109 @@
/*
* Copyright 2002-2011 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.method.annotation.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.lang.reflect.Method;
import javax.servlet.http.Cookie;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.MethodParameter;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
/**
* Test fixture with {@link AbstractCookieValueMethodArgumentResolver}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class CookieValueMethodArgumentResolverTests {
private AbstractCookieValueMethodArgumentResolver resolver;
private MethodParameter paramNamedCookie;
private MethodParameter paramNamedDefaultValueString;
private MethodParameter paramString;
private ServletWebRequest webRequest;
private MockHttpServletRequest request;
@Before
public void setUp() throws Exception {
resolver = new TestCookieValueMethodArgumentResolver();
Method method = getClass().getMethod("params", Cookie.class, String.class, String.class);
paramNamedCookie = new MethodParameter(method, 0);
paramNamedDefaultValueString = new MethodParameter(method, 1);
paramString = new MethodParameter(method, 2);
request = new MockHttpServletRequest();
webRequest = new ServletWebRequest(request, new MockHttpServletResponse());
}
@Test
public void supportsParameter() {
assertTrue("Cookie parameter not supported", resolver.supportsParameter(paramNamedCookie));
assertTrue("Cookie string parameter not supported", resolver.supportsParameter(paramNamedDefaultValueString));
assertFalse("non-@CookieValue parameter supported", resolver.supportsParameter(paramString));
}
@Test
public void resolveCookieDefaultValue() throws Exception {
Object result = resolver.resolveArgument(paramNamedDefaultValueString, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("Invalid result", "bar", result);
}
@Test(expected = IllegalStateException.class)
public void notFound() throws Exception {
Object result = resolver.resolveArgument(paramNamedCookie, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("Invalid result", "bar", result);
}
private static class TestCookieValueMethodArgumentResolver extends AbstractCookieValueMethodArgumentResolver {
public TestCookieValueMethodArgumentResolver() {
super(null);
}
@Override
protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
return null;
}
}
public void params(@CookieValue("name") Cookie param1,
@CookieValue(value = "name", defaultValue = "bar") String param2,
String param3) {
}
}

63
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ErrorsMethodHandlerArgumentResolverTests.java
View File

@@ -18,8 +18,6 @@ package org.springframework.web.method.annotation.support;
import static org.junit.Assert.assertSame;
import java.lang.reflect.Method;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.MethodParameter;
@@ -32,92 +30,63 @@ import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.method.support.ModelAndViewContainer;
/**
* Test fixture for {@link ErrorsMethodArgumentResolver} unit tests.
* Test fixture with {@link ErrorsMethodArgumentResolver}.
*
* @author Rossen Stoyanchev
*/
public class ErrorsMethodHandlerArgumentResolverTests {
private final ErrorsMethodArgumentResolver resolver = new ErrorsMethodArgumentResolver();
private BindingResult bindingResult;
private MethodParameter paramErrors;
private NativeWebRequest webRequest;
private ErrorsMethodArgumentResolver resolver;
private MethodParameter errorsParam;
@Before
public void setUp() throws Exception {
this.webRequest = new ServletWebRequest(new MockHttpServletRequest());
this.resolver = new ErrorsMethodArgumentResolver();
Method method = this.getClass().getDeclaredMethod("handle", Errors.class);
this.errorsParam = new MethodParameter(method, 0);
paramErrors = new MethodParameter(getClass().getDeclaredMethod("handle", Errors.class), 0);
bindingResult = new WebDataBinder(new Object(), "attr").getBindingResult();
webRequest = new ServletWebRequest(new MockHttpServletRequest());
}
@Test
public void supports() throws Exception {
resolver.supportsParameter(errorsParam);
resolver.supportsParameter(paramErrors);
}
@Test
public void bindingResult() throws Exception {
WebDataBinder dataBinder = new WebDataBinder(new Object(), "attr");
BindingResult bindingResult = dataBinder.getBindingResult();
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
mavContainer.addAttribute("ignore1", "value1");
mavContainer.addAttribute("ignore2", "value2");
mavContainer.addAttribute("ignore3", "value3");
mavContainer.addAttribute("ignore4", "value4");
mavContainer.addAttribute("ignore5", "value5");
mavContainer.addAllAttributes(bindingResult.getModel()); // Predictable iteration order of model keys important!
mavContainer.addAllAttributes(bindingResult.getModel());
Object actual = resolver.resolveArgument(errorsParam, mavContainer, webRequest, null);
Object actual = resolver.resolveArgument(paramErrors, mavContainer, webRequest, null);
assertSame(actual, bindingResult);
}
@Test
public void bindingResultExistingModelAttribute() throws Exception {
Object target1 = new Object();
WebDataBinder binder1 = new WebDataBinder(target1, "attr1");
BindingResult bindingResult1 = binder1.getBindingResult();
Object target2 = new Object();
WebDataBinder binder2 = new WebDataBinder(target1, "attr2");
BindingResult bindingResult2 = binder2.getBindingResult();
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
mavContainer.addAttribute("attr1", target1);
mavContainer.addAttribute("attr2", target2);
mavContainer.addAttribute("filler", "fillerValue");
mavContainer.addAllAttributes(bindingResult1.getModel());
mavContainer.addAllAttributes(bindingResult2.getModel());
Object actual = resolver.resolveArgument(errorsParam, mavContainer, webRequest, null);
assertSame("Should resolve to the latest BindingResult added", actual, bindingResult2);
}
@Test(expected=IllegalStateException.class)
public void bindingResultNotFound() throws Exception {
WebDataBinder dataBinder = new WebDataBinder(new Object(), "attr");
BindingResult bindingResult = dataBinder.getBindingResult();
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
mavContainer.addAllAttributes(bindingResult.getModel());
mavContainer.addAttribute("ignore1", "value1");
resolver.resolveArgument(errorsParam, mavContainer, webRequest, null);
resolver.resolveArgument(paramErrors, mavContainer, webRequest, null);
}
@Test(expected=IllegalStateException.class)
public void noBindingResult() throws Exception {
resolver.resolveArgument(errorsParam, new ModelAndViewContainer(), webRequest, null);
resolver.resolveArgument(paramErrors, new ModelAndViewContainer(), webRequest, null);
}
@SuppressWarnings("unused")
private void handle(Errors errors) {
}
}
}

44
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ExpressionValueMethodArgumentResolverTests.java
View File

@@ -36,7 +36,7 @@ import org.springframework.web.context.support.GenericWebApplicationContext;
import org.springframework.web.method.annotation.support.ExpressionValueMethodArgumentResolver;
/**
* Test fixture for {@link ExpressionValueMethodArgumentResolver} unit tests.
* Test fixture with {@link ExpressionValueMethodArgumentResolver}.
*
* @author Rossen Stoyanchev
*/
@@ -44,13 +44,11 @@ public class ExpressionValueMethodArgumentResolverTests {
private ExpressionValueMethodArgumentResolver resolver;
private MethodParameter systemParameter;
private MethodParameter paramSystemProperty;
private MethodParameter requestParameter;
private MethodParameter paramContextPath;
private MethodParameter unsupported;
private MockHttpServletRequest servletRequest;
private MethodParameter paramNotSupported;
private NativeWebRequest webRequest;
@@ -58,16 +56,14 @@ public class ExpressionValueMethodArgumentResolverTests {
public void setUp() throws Exception {
GenericWebApplicationContext context = new GenericWebApplicationContext();
context.refresh();
resolver = new ExpressionValueMethodArgumentResolver(context.getBeanFactory());
Method method = getClass().getMethod("params", int.class, String.class, String.class);
systemParameter = new MethodParameter(method, 0);
requestParameter = new MethodParameter(method, 1);
unsupported = new MethodParameter(method, 2);
paramSystemProperty = new MethodParameter(method, 0);
paramContextPath = new MethodParameter(method, 1);
paramNotSupported = new MethodParameter(method, 2);
servletRequest = new MockHttpServletRequest();
webRequest = new ServletWebRequest(servletRequest, new MockHttpServletResponse());
webRequest = new ServletWebRequest(new MockHttpServletRequest(), new MockHttpServletResponse());
// Expose request to the current thread (for SpEL expressions)
RequestContextHolder.setRequestAttributes(webRequest);
@@ -80,31 +76,31 @@ public class ExpressionValueMethodArgumentResolverTests {
@Test
public void supportsParameter() throws Exception {
assertTrue(resolver.supportsParameter(systemParameter));
assertTrue(resolver.supportsParameter(requestParameter));
assertFalse(resolver.supportsParameter(unsupported));
assertTrue(resolver.supportsParameter(paramSystemProperty));
assertTrue(resolver.supportsParameter(paramContextPath));
assertFalse(resolver.supportsParameter(paramNotSupported));
}
@Test
public void resolveSystemProperty() throws Exception {
System.setProperty("systemIntValue", "22");
Object value = resolver.resolveArgument(systemParameter, null, webRequest, null);
System.setProperty("systemProperty", "22");
Object value = resolver.resolveArgument(paramSystemProperty, null, webRequest, null);
System.clearProperty("systemProperty");
assertEquals("22", value);
}
@Test
public void resolveRequestProperty() throws Exception {
servletRequest.setContextPath("/contextPath");
Object value = resolver.resolveArgument(requestParameter, null, webRequest, null);
public void resolveContextPath() throws Exception {
webRequest.getNativeRequest(MockHttpServletRequest.class).setContextPath("/contextPath");
Object value = resolver.resolveArgument(paramContextPath, null, webRequest, null);
assertEquals("/contextPath", value);
}
public void params(@Value("#{systemProperties.systemIntValue}") int param1,
public void params(@Value("#{systemProperties.systemProperty}") int param1,
@Value("#{request.contextPath}") String param2,
String unsupported) {
String notSupported) {
}
}
}

151
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelAttributeMethodProcessorTests.java
View File

@@ -55,7 +55,7 @@ import org.springframework.web.context.request.WebRequest;
import org.springframework.web.method.support.ModelAndViewContainer;
/**
* Test fixture for {@link ModelAttributeMethodProcessor} unit tests.
* Test fixture with {@link ModelAttributeMethodProcessor}.
*
* @author Rossen Stoyanchev
*/
@@ -63,17 +63,19 @@ public class ModelAttributeMethodProcessorTests {
private ModelAttributeMethodProcessor processor;
private MethodParameter annotatedParam;
private MethodParameter paramNamedValidModelAttr;
private MethodParameter integerParam;
private MethodParameter paramErrors;
private MethodParameter defaultNameParam;
private MethodParameter paramInt;
private MethodParameter notAnnotatedParam;
private MethodParameter paramModelAttr;
private MethodParameter paramNonSimpleType;
private MethodParameter annotatedReturnParam;
private MethodParameter returnParamNamedModelAttr;
private MethodParameter notAnnotatedReturnParam;
private MethodParameter returnParamNonSimpleType;
private ModelAndViewContainer mavContainer;
@@ -81,66 +83,77 @@ public class ModelAttributeMethodProcessorTests {
@Before
public void setUp() throws Exception {
this.processor = new ModelAttributeMethodProcessor(true);
processor = new ModelAttributeMethodProcessor(true);
Class<?> handlerType = ModelAttributeHandler.class;
Method method = handlerType.getDeclaredMethod("modelAttribute", TestBean.class, Errors.class, int.class,
TestBean.class, TestBean.class);
Method method = ModelAttributeHandler.class.getDeclaredMethod("modelAttribute",
TestBean.class, Errors.class, int.class, TestBean.class, TestBean.class);
this.annotatedParam = new MethodParameter(method, 0);
this.integerParam = new MethodParameter(method, 2);
this.defaultNameParam = new MethodParameter(method, 3);
this.notAnnotatedParam = new MethodParameter(method, 4);
paramNamedValidModelAttr = new MethodParameter(method, 0);
paramErrors = new MethodParameter(method, 1);
paramInt = new MethodParameter(method, 2);
paramModelAttr = new MethodParameter(method, 3);
paramNonSimpleType = new MethodParameter(method, 4);
this.annotatedReturnParam = new MethodParameter(getClass().getDeclaredMethod("annotatedReturnValue"), -1);
this.notAnnotatedReturnParam = new MethodParameter(getClass().getDeclaredMethod("notAnnotatedReturnValue"), -1);
returnParamNamedModelAttr = new MethodParameter(getClass().getDeclaredMethod("annotatedReturnValue"), -1);
returnParamNonSimpleType = new MethodParameter(getClass().getDeclaredMethod("notAnnotatedReturnValue"), -1);
mavContainer = new ModelAndViewContainer();
this.webRequest = new ServletWebRequest(new MockHttpServletRequest());
webRequest = new ServletWebRequest(new MockHttpServletRequest());
}
@Test
public void supportParameter() throws Exception {
assertTrue(processor.supportsParameter(annotatedParam));
assertFalse(processor.supportsParameter(integerParam));
assertTrue(processor.supportsParameter(notAnnotatedParam));
processor = new ModelAttributeMethodProcessor(true);
assertTrue(processor.supportsParameter(paramNamedValidModelAttr));
assertTrue(processor.supportsParameter(paramErrors));
assertFalse(processor.supportsParameter(paramInt));
assertTrue(processor.supportsParameter(paramModelAttr));
assertTrue(processor.supportsParameter(paramNonSimpleType));
this.processor = new ModelAttributeMethodProcessor(false);
assertFalse(processor.supportsParameter(notAnnotatedParam));
processor = new ModelAttributeMethodProcessor(false);
assertTrue(processor.supportsParameter(paramNamedValidModelAttr));
assertFalse(processor.supportsParameter(paramErrors));
assertFalse(processor.supportsParameter(paramInt));
assertTrue(processor.supportsParameter(paramModelAttr));
assertFalse(processor.supportsParameter(paramNonSimpleType));
}
@Test
public void supportsReturnType() throws Exception {
assertTrue(processor.supportsReturnType(annotatedReturnParam));
assertFalse(processor.supportsReturnType(notAnnotatedReturnParam));
processor = new ModelAttributeMethodProcessor(true);
assertTrue(processor.supportsReturnType(returnParamNamedModelAttr));
assertFalse(processor.supportsReturnType(returnParamNonSimpleType));
processor = new ModelAttributeMethodProcessor(false);
assertTrue(processor.supportsReturnType(returnParamNamedModelAttr));
assertFalse(processor.supportsReturnType(returnParamNonSimpleType));
}
@Test
public void shouldValidate() throws Exception {
assertTrue(processor.shouldValidate(annotatedParam));
assertFalse(processor.shouldValidate(notAnnotatedParam));
assertTrue(processor.shouldValidate(paramNamedValidModelAttr));
assertFalse(processor.shouldValidate(paramNonSimpleType));
}
@Test
public void failOnError() throws Exception {
assertFalse(processor.failOnError(annotatedParam));
assertTrue(processor.failOnError(notAnnotatedParam));
assertFalse("Shouldn't failOnError with BindingResult", processor.failOnError(paramNamedValidModelAttr));
assertTrue("Should failOnError without BindingResult", processor.failOnError(paramNonSimpleType));
}
@Test
public void createBinderFromModelAttribute() throws Exception {
createBinderFromModelAttr("attrName", annotatedParam);
createBinderFromModelAttr("testBean", defaultNameParam);
createBinderFromModelAttr("testBean", notAnnotatedParam);
createBinderFromModelAttr("attrName", paramNamedValidModelAttr);
createBinderFromModelAttr("testBean", paramModelAttr);
createBinderFromModelAttr("testBean", paramNonSimpleType);
}
private void createBinderFromModelAttr(String expectedAttrName, MethodParameter param) throws Exception {
Object target = new TestBean();
mavContainer.addAttribute(expectedAttrName, target);
WebDataBinder dataBinder = new WebRequestDataBinder(null);
WebDataBinder dataBinder = new WebRequestDataBinder(target);
WebDataBinderFactory binderFactory = createMock(WebDataBinderFactory.class);
expect(binderFactory.createBinder(webRequest, target, expectedAttrName)).andReturn(dataBinder);
replay(binderFactory);
@@ -158,7 +171,7 @@ public class ModelAttributeMethodProcessorTests {
expect(factory.createBinder((NativeWebRequest) anyObject(), notNull(), eq("attrName"))).andReturn(dataBinder);
replay(factory);
processor.resolveArgument(annotatedParam, mavContainer, webRequest, factory);
processor.resolveArgument(paramNamedValidModelAttr, mavContainer, webRequest, factory);
verify(factory);
}
@@ -167,13 +180,13 @@ public class ModelAttributeMethodProcessorTests {
public void bindAndValidate() throws Exception {
Object target = new TestBean();
mavContainer.addAttribute("attrName", target);
StubRequestDataBinder dataBinder = new StubRequestDataBinder(target);
WebDataBinderFactory binderFactory = createMock(WebDataBinderFactory.class);
expect(binderFactory.createBinder(webRequest, target, "attrName")).andReturn(dataBinder);
replay(binderFactory);
processor.resolveArgument(annotatedParam, mavContainer, webRequest, binderFactory);
processor.resolveArgument(paramNamedValidModelAttr, mavContainer, webRequest, binderFactory);
assertTrue(dataBinder.isBindInvoked());
assertTrue(dataBinder.isValidateInvoked());
@@ -183,6 +196,7 @@ public class ModelAttributeMethodProcessorTests {
public void bindAndFail() throws Exception {
Object target = new TestBean();
mavContainer.getModel().addAttribute(target);
StubRequestDataBinder dataBinder = new StubRequestDataBinder(target);
dataBinder.getBindingResult().reject("error");
@@ -190,50 +204,23 @@ public class ModelAttributeMethodProcessorTests {
expect(binderFactory.createBinder(webRequest, target, "testBean")).andReturn(dataBinder);
replay(binderFactory);
processor.resolveArgument(notAnnotatedParam, mavContainer, webRequest, binderFactory);
processor.resolveArgument(paramNonSimpleType, mavContainer, webRequest, binderFactory);
}
@Test
public void handleAnnotatedReturnValue() throws Exception {
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
processor.handleReturnValue("expected", annotatedReturnParam, mavContainer, webRequest);
processor.handleReturnValue("expected", returnParamNamedModelAttr, mavContainer, webRequest);
assertEquals("expected", mavContainer.getModel().get("modelAttrName"));
}
@Test
public void handleNotAnnotatedReturnValue() throws Exception {
TestBean testBean = new TestBean("expected");
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
processor.handleReturnValue(testBean, notAnnotatedReturnParam, mavContainer, webRequest);
processor.handleReturnValue(testBean, returnParamNonSimpleType, mavContainer, webRequest);
assertSame(testBean, mavContainer.getModel().get("testBean"));
}
@SessionAttributes(types=TestBean.class)
private static class ModelAttributeHandler {
@SuppressWarnings("unused")
public void modelAttribute(@ModelAttribute("attrName") @Valid TestBean annotatedAttr,
Errors errors,
int intArg,
@ModelAttribute TestBean defaultNameAttr,
TestBean notAnnotatedAttr) {
}
}
@SuppressWarnings("unused")
@ModelAttribute("modelAttrName")
private String annotatedReturnValue() {
return null;
}
@SuppressWarnings("unused")
private TestBean notAnnotatedReturnValue() {
return null;
}
private static class StubRequestDataBinder extends WebRequestDataBinder {
private boolean bindInvoked;
@@ -252,14 +239,12 @@ public class ModelAttributeMethodProcessorTests {
return validateInvoked;
}
@Override
public void bind(WebRequest request) {
this.bindInvoked = true;
bindInvoked = true;
}
@Override
public void validate() {
this.validateInvoked = true;
validateInvoked = true;
}
}
@@ -267,5 +252,27 @@ public class ModelAttributeMethodProcessorTests {
@Retention(RUNTIME)
public @interface Valid {
}
@SessionAttributes(types=TestBean.class)
private static class ModelAttributeHandler {
@SuppressWarnings("unused")
public void modelAttribute(@ModelAttribute("attrName") @Valid TestBean annotatedAttr,
Errors errors,
int intArg,
@ModelAttribute TestBean defaultNameAttr,
TestBean notAnnotatedAttr) {
}
}
@SuppressWarnings("unused")
@ModelAttribute("modelAttrName")
private String annotatedReturnValue() {
return null;
}
@SuppressWarnings("unused")
private TestBean notAnnotatedReturnValue() {
return null;
}
}
}

80
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelMethodProcessorTests.java
View File

@@ -27,7 +27,6 @@ import org.junit.Before;
import org.junit.Test;
import org.springframework.core.MethodParameter;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.ui.ExtendedModelMap;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.context.request.NativeWebRequest;
@@ -35,81 +34,83 @@ import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.method.support.ModelAndViewContainer;
/**
* Test fixture for {@link ModelMethodProcessor} unit tests.
* Test fixture with {@link ModelMethodProcessor}.
*
* @author Rossen Stoyanchev
*/
public class ModelMethodProcessorTests {
private ModelMethodProcessor resolver;
private ModelMethodProcessor processor;
private MethodParameter modelParameter;
private ModelAndViewContainer mavContainer;
private MethodParameter paramModel;
private MethodParameter modelReturnType;
private MethodParameter returnParamModel;
private MethodParameter mapParameter;
private MethodParameter paramMap;
private MethodParameter mapReturnType;
private MethodParameter returnParamMap;
private NativeWebRequest webRequest;
@Before
public void setUp() throws Exception {
this.resolver = new ModelMethodProcessor();
processor = new ModelMethodProcessor();
mavContainer = new ModelAndViewContainer();
Method modelMethod = getClass().getDeclaredMethod("model", Model.class);
this.modelParameter = new MethodParameter(modelMethod, 0);
this.modelReturnType = new MethodParameter(modelMethod, -1);
Method method = getClass().getDeclaredMethod("model", Model.class);
paramModel = new MethodParameter(method, 0);
returnParamModel = new MethodParameter(method, -1);
Method mapMethod = getClass().getDeclaredMethod("map", Map.class);
this.mapParameter = new MethodParameter(mapMethod, 0);
this.mapReturnType = new MethodParameter(mapMethod, 0);
method = getClass().getDeclaredMethod("map", Map.class);
paramMap = new MethodParameter(method, 0);
returnParamMap = new MethodParameter(method, 0);
this.webRequest = new ServletWebRequest(new MockHttpServletRequest());
webRequest = new ServletWebRequest(new MockHttpServletRequest());
}
@Test
public void supportsParameter() {
assertTrue(resolver.supportsParameter(modelParameter));
assertTrue(resolver.supportsParameter(mapParameter));
assertTrue(processor.supportsParameter(paramModel));
assertTrue(processor.supportsParameter(paramMap));
}
@Test
public void supportsReturnType() {
assertTrue(resolver.supportsReturnType(modelReturnType));
assertTrue(resolver.supportsReturnType(mapReturnType));
assertTrue(processor.supportsReturnType(returnParamModel));
assertTrue(processor.supportsReturnType(returnParamMap));
}
@Test
public void resolveArgumentValue() throws Exception {
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
Object result = resolver.resolveArgument(modelParameter, mavContainer, webRequest, null);
Object result = processor.resolveArgument(paramModel, mavContainer, webRequest, null);
assertSame(mavContainer.getModel(), result);
result = resolver.resolveArgument(mapParameter, mavContainer, webRequest, null);
result = processor.resolveArgument(paramMap, mavContainer, webRequest, null);
assertSame(mavContainer.getModel(), result);
}
@Test
public void handleReturnValue() throws Exception {
ExtendedModelMap implicitModel = new ExtendedModelMap();
implicitModel.put("attr1", "value1");
public void handleModelReturnValue() throws Exception {
mavContainer.addAttribute("attr1", "value1");
ModelMap returnValue = new ModelMap("attr2", "value2");
ExtendedModelMap returnValue = new ExtendedModelMap();
returnValue.put("attr2", "value2");
processor.handleReturnValue(returnValue , returnParamModel, mavContainer, webRequest);
ModelAndViewContainer mavContainer = new ModelAndViewContainer(implicitModel);
resolver.handleReturnValue(returnValue , modelReturnType, mavContainer, webRequest);
ModelMap actualModel = mavContainer.getModel();
assertEquals("value1", actualModel.get("attr1"));
assertEquals("value2", actualModel.get("attr2"));
assertEquals("value1", mavContainer.getModel().get("attr1"));
assertEquals("value2", mavContainer.getModel().get("attr2"));
}
@Test
public void handleMapReturnValue() throws Exception {
mavContainer.addAttribute("attr1", "value1");
Map<String, Object> returnValue = new ModelMap("attr2", "value2");
mavContainer = new ModelAndViewContainer(implicitModel);
resolver.handleReturnValue(returnValue , mapReturnType, mavContainer, webRequest);
actualModel = mavContainer.getModel();
assertEquals("value1", actualModel.get("attr1"));
assertEquals("value2", actualModel.get("attr2"));
processor.handleReturnValue(returnValue , returnParamMap, mavContainer, webRequest);
assertEquals("value1", mavContainer.getModel().get("attr1"));
assertEquals("value2", mavContainer.getModel().get("attr2"));
}
@SuppressWarnings("unused")
@@ -121,4 +122,5 @@ public class ModelMethodProcessorTests {
private Map<String, Object> map(Map<String, Object> map) {
return null;
}
}
}

104
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMapMethodArgumentResolverTests.java
View File

@@ -37,89 +37,97 @@ import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
/**
* Text fixture with {@link RequestHeaderMapMethodArgumentResolver}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class RequestHeaderMapMethodArgumentResolverTests {
private RequestHeaderMapMethodArgumentResolver resolver;
private MethodParameter mapParameter;
private MethodParameter paramMap;
private MethodParameter multiValueMapParameter;
private MethodParameter paramMultiValueMap;
private MethodParameter httpHeadersParameter;
private MethodParameter paramHttpHeaders;
private MockHttpServletRequest servletRequest;
private MethodParameter unsupportedParameter;
private MethodParameter paramUnsupported;
private NativeWebRequest webRequest;
private MockHttpServletRequest request;
@Before
public void setUp() throws Exception {
resolver = new RequestHeaderMapMethodArgumentResolver();
Method method = getClass()
.getMethod("params", Map.class, MultiValueMap.class, HttpHeaders.class, Map.class);
mapParameter = new MethodParameter(method, 0);
multiValueMapParameter = new MethodParameter(method, 1);
httpHeadersParameter = new MethodParameter(method, 2);
unsupportedParameter = new MethodParameter(method, 3);
servletRequest = new MockHttpServletRequest();
MockHttpServletResponse servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
Method method = getClass().getMethod("params", Map.class, MultiValueMap.class, HttpHeaders.class, Map.class);
paramMap = new MethodParameter(method, 0);
paramMultiValueMap = new MethodParameter(method, 1);
paramHttpHeaders = new MethodParameter(method, 2);
paramUnsupported = new MethodParameter(method, 3);
request = new MockHttpServletRequest();
webRequest = new ServletWebRequest(request, new MockHttpServletResponse());
}
@Test
public void supportsParameter() {
assertTrue("Map parameter not supported", resolver.supportsParameter(mapParameter));
assertTrue("MultiValueMap parameter not supported", resolver.supportsParameter(multiValueMapParameter));
assertTrue("HttpHeaders parameter not supported", resolver.supportsParameter(httpHeadersParameter));
assertFalse("non-@RequestParam map supported", resolver.supportsParameter(unsupportedParameter));
assertTrue("Map parameter not supported", resolver.supportsParameter(paramMap));
assertTrue("MultiValueMap parameter not supported", resolver.supportsParameter(paramMultiValueMap));
assertTrue("HttpHeaders parameter not supported", resolver.supportsParameter(paramHttpHeaders));
assertFalse("non-@RequestParam map supported", resolver.supportsParameter(paramUnsupported));
}
@Test
@SuppressWarnings("unchecked")
public void resolveMapArgument() throws Exception {
String headerName = "foo";
String headerValue = "bar";
Map<String, String> expected = Collections.singletonMap(headerName, headerValue);
servletRequest.addHeader(headerName, headerValue);
String name = "foo";
String value = "bar";
Map<String, String> expected = Collections.singletonMap(name, value);
request.addHeader(name, value);
Map<String, String> result = (Map<String, String>) resolver.resolveArgument(mapParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramMap, null, webRequest, null);
assertTrue(result instanceof Map);
assertEquals("Invalid result", expected, result);
}
@Test
@SuppressWarnings("unchecked")
public void resolveMultiValueMapArgument() throws Exception {
String headerName = "foo";
String headerValue1 = "bar";
String headerValue2 = "baz";
MultiValueMap<String, String> expected = new LinkedMultiValueMap<String, String>(1);
expected.add(headerName, headerValue1);
expected.add(headerName, headerValue2);
servletRequest.addHeader(headerName, headerValue1);
servletRequest.addHeader(headerName, headerValue2);
String name = "foo";
String value1 = "bar";
String value2 = "baz";
MultiValueMap<String, String> result =
(MultiValueMap<String, String>) resolver.resolveArgument(multiValueMapParameter, null, webRequest, null);
request.addHeader(name, value1);
request.addHeader(name, value2);
MultiValueMap<String, String> expected = new LinkedMultiValueMap<String, String>(1);
expected.add(name, value1);
expected.add(name, value2);
Object result = resolver.resolveArgument(paramMultiValueMap, null, webRequest, null);
assertTrue(result instanceof MultiValueMap);
assertEquals("Invalid result", expected, result);
}
@Test
public void resolveHttpHeadersArgument() throws Exception {
String headerName = "foo";
String headerValue1 = "bar";
String headerValue2 = "baz";
HttpHeaders expected = new HttpHeaders();
expected.add(headerName, headerValue1);
expected.add(headerName, headerValue2);
servletRequest.addHeader(headerName, headerValue1);
servletRequest.addHeader(headerName, headerValue2);
String name = "foo";
String value1 = "bar";
String value2 = "baz";
HttpHeaders result = (HttpHeaders) resolver.resolveArgument(httpHeadersParameter, null, webRequest, null);
request.addHeader(name, value1);
request.addHeader(name, value2);
HttpHeaders expected = new HttpHeaders();
expected.add(name, value1);
expected.add(name, value2);
Object result = resolver.resolveArgument(paramHttpHeaders, null, webRequest, null);
assertTrue(result instanceof HttpHeaders);
assertEquals("Invalid result", expected, result);
}
@@ -127,8 +135,6 @@ public class RequestHeaderMapMethodArgumentResolverTests {
@RequestHeader MultiValueMap<?, ?> param2,
@RequestHeader HttpHeaders param3,
Map<?,?> unsupported) {
}
}
}

66
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMethodArgumentResolverTests.java
View File

@@ -37,6 +37,8 @@ import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.context.support.GenericWebApplicationContext;
/**
* Test fixture with {@link RequestHeaderMethodArgumentResolver}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
@@ -44,15 +46,11 @@ public class RequestHeaderMethodArgumentResolverTests {
private RequestHeaderMethodArgumentResolver resolver;
private MethodParameter stringParameter;
private MethodParameter stringArrayParameter;
private MethodParameter systemPropertyParameter;
private MethodParameter contextPathParameter;
private MethodParameter otherParameter;
private MethodParameter paramNamedDefaultValueStringHeader;
private MethodParameter paramNamedValueStringArray;
private MethodParameter paramSystemProperty;
private MethodParameter paramContextPath;
private MethodParameter paramNamedValueMap;
private MockHttpServletRequest servletRequest;
@@ -62,15 +60,14 @@ public class RequestHeaderMethodArgumentResolverTests {
public void setUp() throws Exception {
GenericWebApplicationContext context = new GenericWebApplicationContext();
context.refresh();
resolver = new RequestHeaderMethodArgumentResolver(context.getBeanFactory());
Method method = getClass().getMethod("params", String.class, String[].class, String.class, String.class, Map.class);
stringParameter = new MethodParameter(method, 0);
stringArrayParameter = new MethodParameter(method, 1);
systemPropertyParameter = new MethodParameter(method, 2);
contextPathParameter = new MethodParameter(method, 3);
otherParameter = new MethodParameter(method, 4);
paramNamedDefaultValueStringHeader = new MethodParameter(method, 0);
paramNamedValueStringArray = new MethodParameter(method, 1);
paramSystemProperty = new MethodParameter(method, 2);
paramContextPath = new MethodParameter(method, 3);
paramNamedValueMap = new MethodParameter(method, 4);
servletRequest = new MockHttpServletRequest();
webRequest = new ServletWebRequest(servletRequest, new MockHttpServletResponse());
@@ -86,9 +83,9 @@ public class RequestHeaderMethodArgumentResolverTests {
@Test
public void supportsParameter() {
assertTrue("String parameter not supported", resolver.supportsParameter(stringParameter));
assertTrue("String array parameter not supported", resolver.supportsParameter(stringArrayParameter));
assertFalse("non-@RequestParam parameter supported", resolver.supportsParameter(otherParameter));
assertTrue("String parameter not supported", resolver.supportsParameter(paramNamedDefaultValueStringHeader));
assertTrue("String array parameter not supported", resolver.supportsParameter(paramNamedValueStringArray));
assertFalse("non-@RequestParam parameter supported", resolver.supportsParameter(paramNamedValueMap));
}
@Test
@@ -96,7 +93,9 @@ public class RequestHeaderMethodArgumentResolverTests {
String expected = "foo";
servletRequest.addHeader("name", expected);
String result = (String) resolver.resolveArgument(stringParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramNamedDefaultValueStringHeader, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("Invalid result", expected, result);
}
@@ -105,41 +104,52 @@ public class RequestHeaderMethodArgumentResolverTests {
String[] expected = new String[]{"foo", "bar"};
servletRequest.addHeader("name", expected);
String[] result = (String[]) resolver.resolveArgument(stringArrayParameter, null, webRequest, null);
assertArrayEquals("Invalid result", expected, result);
Object result = resolver.resolveArgument(paramNamedValueStringArray, null, webRequest, null);
assertTrue(result instanceof String[]);
assertArrayEquals("Invalid result", expected, (String[]) result);
}
@Test
public void resolveDefaultValue() throws Exception {
String result = (String) resolver.resolveArgument(stringParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramNamedDefaultValueStringHeader, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("Invalid result", "bar", result);
}
@Test
public void resolveDefaultValueFromSystemProperty() throws Exception {
System.setProperty("header", "bar");
String result = (String) resolver.resolveArgument(systemPropertyParameter, null, webRequest, null);
System.setProperty("systemProperty", "bar");
Object result = resolver.resolveArgument(paramSystemProperty, null, webRequest, null);
System.clearProperty("systemProperty");
assertTrue(result instanceof String);
assertEquals("bar", result);
}
@Test
public void resolveDefaultValueFromRequest() throws Exception {
servletRequest.setContextPath("/bar");
String result = (String) resolver.resolveArgument(contextPathParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramContextPath, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("/bar", result);
}
@Test(expected = IllegalStateException.class)
public void notFound() throws Exception {
String result = (String) resolver.resolveArgument(stringArrayParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramNamedValueStringArray, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("Invalid result", "bar", result);
}
public void params(@RequestHeader(value = "name", defaultValue = "bar") String param1,
@RequestHeader("name") String[] param2,
@RequestHeader(value = "name", defaultValue="#{systemProperties.header}") String param3,
@RequestHeader(value = "name", defaultValue="#{systemProperties.systemProperty}") String param3,
@RequestHeader(value = "name", defaultValue="#{request.contextPath}") String param4,
@RequestHeader("name") Map<?, ?> unsupported) {
}
}
}

76
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMapMethodArgumentResolverTests.java
View File

@@ -36,77 +36,83 @@ import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
/**
* Test fixture with {@link RequestParamMapMethodArgumentResolver}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class RequestParamMapMethodArgumentResolverTests {
private RequestParamMapMethodArgumentResolver resolver;
private MethodParameter mapParameter;
private MethodParameter paramMap;
private MethodParameter multiValueMapParameter;
private MethodParameter paramMultiValueMap;
private MockHttpServletRequest servletRequest;
private MethodParameter paramNamedMap;
private MethodParameter paramMapWithoutAnnot;
private NativeWebRequest webRequest;
private MethodParameter unsupportedParameter;
private MockHttpServletRequest request;
@Before
public void setUp() throws Exception {
resolver = new RequestParamMapMethodArgumentResolver();
Method method = getClass()
.getMethod("params", Map.class, MultiValueMap.class, Map.class);
mapParameter = new MethodParameter(method, 0);
multiValueMapParameter = new MethodParameter(method, 1);
unsupportedParameter = new MethodParameter(method, 2);
servletRequest = new MockHttpServletRequest();
MockHttpServletResponse servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
Method method = getClass().getMethod("params", Map.class, MultiValueMap.class, Map.class, Map.class);
paramMap = new MethodParameter(method, 0);
paramMultiValueMap = new MethodParameter(method, 1);
paramNamedMap = new MethodParameter(method, 2);
paramMapWithoutAnnot = new MethodParameter(method, 3);
request = new MockHttpServletRequest();
webRequest = new ServletWebRequest(request, new MockHttpServletResponse());
}
@Test
public void supportsParameter() {
assertTrue("Map parameter not supported", resolver.supportsParameter(mapParameter));
assertTrue("MultiValueMap parameter not supported", resolver.supportsParameter(multiValueMapParameter));
assertFalse("non-@RequestParam map supported", resolver.supportsParameter(unsupportedParameter));
assertTrue("Map parameter not supported", resolver.supportsParameter(paramMap));
assertTrue("MultiValueMap parameter not supported", resolver.supportsParameter(paramMultiValueMap));
assertFalse("Map with name supported", resolver.supportsParameter(paramNamedMap));
assertFalse("non-@RequestParam map supported", resolver.supportsParameter(paramMapWithoutAnnot));
}
@Test
@SuppressWarnings("unchecked")
public void resolveMapArgument() throws Exception {
String headerName = "foo";
String headerValue = "bar";
Map<String, String> expected = Collections.singletonMap(headerName, headerValue);
servletRequest.addParameter(headerName, headerValue);
String name = "foo";
String value = "bar";
request.addParameter(name, value);
Map<String, String> expected = Collections.singletonMap(name, value);
Map<String, String> result = (Map<String, String>) resolver.resolveArgument(mapParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramMap, null, webRequest, null);
assertTrue(result instanceof Map);
assertEquals("Invalid result", expected, result);
}
@Test
@SuppressWarnings("unchecked")
public void resolveMultiValueMapArgument() throws Exception {
String headerName = "foo";
String headerValue1 = "bar";
String headerValue2 = "baz";
String name = "foo";
String value1 = "bar";
String value2 = "baz";
request.addParameter(name, new String[]{value1, value2});
MultiValueMap<String, String> expected = new LinkedMultiValueMap<String, String>(1);
expected.add(headerName, headerValue1);
expected.add(headerName, headerValue2);
servletRequest.addParameter(headerName, new String[]{headerValue1, headerValue2});
expected.add(name, value1);
expected.add(name, value2);
MultiValueMap<String, String> result =
(MultiValueMap<String, String>) resolver.resolveArgument(multiValueMapParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramMultiValueMap, null, webRequest, null);
assertTrue(result instanceof MultiValueMap);
assertEquals("Invalid result", expected, result);
}
public void params(@RequestParam Map<?, ?> param1,
@RequestParam MultiValueMap<?, ?> param2,
Map<?, ?> unsupported) {
@RequestParam("name") Map<?, ?> param3,
Map<?, ?> param4) {
}
}
}

106
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMethodArgumentResolverTests.java
View File

@@ -39,115 +39,125 @@ import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.multipart.MultipartFile;
/**
* Test fixture with {@link RequestParamMethodArgumentResolver}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class RequestParamMethodArgumentResolverTests {
private RequestParamMethodArgumentResolver resolver;
private MethodParameter stringParameter;
private MethodParameter stringArrayParameter;
private MethodParameter mapParameter;
private MethodParameter fileParameter;
private MethodParameter otherParameter;
private MockHttpServletRequest servletRequest;
private MethodParameter paramNamedDefaultValueString;
private MethodParameter paramNamedStringArray;
private MethodParameter paramNamedMap;
private MethodParameter paramMultiPartFile;
private MethodParameter paramMap;
private MethodParameter paramStringNotAnnot;
private NativeWebRequest webRequest;
private MethodParameter plainParameter;
private MockHttpServletRequest request;
@Before
public void setUp() throws Exception {
resolver = new RequestParamMethodArgumentResolver(null, true);
Method method = getClass()
.getMethod("params", String.class, String[].class, Map.class, MultipartFile.class, Map.class, String.class);
stringParameter = new MethodParameter(method, 0);
stringArrayParameter = new MethodParameter(method, 1);
mapParameter = new MethodParameter(method, 2);
fileParameter = new MethodParameter(method, 3);
otherParameter = new MethodParameter(method, 4);
plainParameter = new MethodParameter(method, 5);
plainParameter.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
servletRequest = new MockHttpServletRequest();
MockHttpServletResponse servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
Method method = getClass().getMethod("params",
String.class, String[].class, Map.class, MultipartFile.class, Map.class, String.class);
paramNamedDefaultValueString = new MethodParameter(method, 0);
paramNamedStringArray = new MethodParameter(method, 1);
paramNamedMap = new MethodParameter(method, 2);
paramMultiPartFile = new MethodParameter(method, 3);
paramMap = new MethodParameter(method, 4);
paramStringNotAnnot = new MethodParameter(method, 5);
paramStringNotAnnot.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
request = new MockHttpServletRequest();
webRequest = new ServletWebRequest(request, new MockHttpServletResponse());
}
@Test
public void supportsParameter() {
assertTrue("String parameter not supported", resolver.supportsParameter(stringParameter));
assertTrue("String array parameter not supported", resolver.supportsParameter(stringArrayParameter));
assertTrue("Named map not parameter supported", resolver.supportsParameter(mapParameter));
assertTrue("MultipartFile parameter not supported", resolver.supportsParameter(fileParameter));
assertFalse("non-@RequestParam parameter supported", resolver.supportsParameter(otherParameter));
assertTrue("Simple type params supported w/o annotations", resolver.supportsParameter(plainParameter));
resolver = new RequestParamMethodArgumentResolver(null, true);
assertTrue("String parameter not supported", resolver.supportsParameter(paramNamedDefaultValueString));
assertTrue("String array parameter not supported", resolver.supportsParameter(paramNamedStringArray));
assertTrue("Named map not parameter supported", resolver.supportsParameter(paramNamedMap));
assertTrue("MultipartFile parameter not supported", resolver.supportsParameter(paramMultiPartFile));
assertFalse("non-@RequestParam parameter supported", resolver.supportsParameter(paramMap));
assertTrue("Simple type params supported w/o annotations", resolver.supportsParameter(paramStringNotAnnot));
resolver = new RequestParamMethodArgumentResolver(null, false);
assertFalse(resolver.supportsParameter(plainParameter));
assertFalse(resolver.supportsParameter(paramStringNotAnnot));
}
@Test
public void resolveStringArgument() throws Exception {
String expected = "foo";
servletRequest.addParameter("name", expected);
request.addParameter("name", expected);
String result = (String) resolver.resolveArgument(stringParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramNamedDefaultValueString, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("Invalid result", expected, result);
}
@Test
public void resolveStringArrayArgument() throws Exception {
String[] expected = new String[]{"foo", "bar"};
servletRequest.addParameter("name", expected);
request.addParameter("name", expected);
String[] result = (String[]) resolver.resolveArgument(stringArrayParameter, null, webRequest, null);
assertArrayEquals("Invalid result", expected, result);
Object result = resolver.resolveArgument(paramNamedStringArray, null, webRequest, null);
assertTrue(result instanceof String[]);
assertArrayEquals("Invalid result", expected, (String[]) result);
}
@Test
public void resolveMultipartFileArgument() throws Exception {
MockMultipartHttpServletRequest servletRequest = new MockMultipartHttpServletRequest();
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
MultipartFile expected = new MockMultipartFile("file", "Hello World".getBytes());
servletRequest.addFile(expected);
webRequest = new ServletWebRequest(servletRequest);
request.addFile(expected);
webRequest = new ServletWebRequest(request);
MultipartFile result = (MultipartFile) resolver.resolveArgument(fileParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramMultiPartFile, null, webRequest, null);
assertTrue(result instanceof MultipartFile);
assertEquals("Invalid result", expected, result);
}
@Test
public void resolveDefaultValue() throws Exception {
String result = (String) resolver.resolveArgument(stringParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramNamedDefaultValueString, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("Invalid result", "bar", result);
}
@Test(expected = MissingServletRequestParameterException.class)
public void notFound() throws Exception {
String result = (String) resolver.resolveArgument(stringArrayParameter, null, webRequest, null);
Object result = resolver.resolveArgument(paramNamedStringArray, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("Invalid result", "bar", result);
}
@Test
public void resolveSimpleTypeParam() throws Exception {
servletRequest.setParameter("plainParam", "plainValue");
String result = (String) resolver.resolveArgument(plainParameter, null, webRequest, null);
request.setParameter("paramStringNotAnnot", "plainValue");
Object result = resolver.resolveArgument(paramStringNotAnnot, null, webRequest, null);
assertTrue(result instanceof String);
assertEquals("plainValue", result);
}
public void params(@RequestParam(value = "name", defaultValue = "bar") String param1,
@RequestParam("name") String[] param2,
@RequestParam("name") Map<?, ?> param3,
@RequestParam(value = "file") MultipartFile file,
@RequestParam Map<?, ?> unsupported,
String plainParam) {
@RequestParam(value = "file") MultipartFile param4,
@RequestParam Map<?, ?> param5,
String paramStringNotAnnot) {
}
}

34
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/WebArgumentResolverAdapterTests.java
View File

@@ -35,14 +35,17 @@ import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletWebRequest;
/**
* Test fixture with {@link WebArgumentResolverAdapterTests}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class WebArgumentResolverAdapterTests {
private WebArgumentResolver adaptee;
private TestWebArgumentResolverAdapter adapter;
private WebArgumentResolver adaptee;
private MethodParameter parameter;
private NativeWebRequest webRequest;
@@ -51,10 +54,10 @@ public class WebArgumentResolverAdapterTests {
public void setUp() throws Exception {
adaptee = createMock(WebArgumentResolver.class);
adapter = new TestWebArgumentResolverAdapter(adaptee);
parameter = new MethodParameter(getClass().getMethod("handle", Integer.TYPE), 0);
webRequest = new ServletWebRequest(new MockHttpServletRequest());
// Expose request to the current thread (for SpEL expressions)
RequestContextHolder.setRequestAttributes(webRequest);
}
@@ -66,11 +69,9 @@ public class WebArgumentResolverAdapterTests {
@Test
public void supportsParameter() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn(42);
replay(adaptee);
boolean result = adapter.supportsParameter(parameter);
assertTrue("Parameter not supported", result);
assertTrue("Parameter not supported", adapter.supportsParameter(parameter));
verify(adaptee);
}
@@ -78,11 +79,9 @@ public class WebArgumentResolverAdapterTests {
@Test
public void supportsParameterUnresolved() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn(WebArgumentResolver.UNRESOLVED);
replay(adaptee);
boolean result = adapter.supportsParameter(parameter);
assertFalse("Parameter supported", result);
assertFalse("Parameter supported", adapter.supportsParameter(parameter));
verify(adaptee);
}
@@ -90,11 +89,9 @@ public class WebArgumentResolverAdapterTests {
@Test
public void supportsParameterWrongType() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn("Foo");
replay(adaptee);
boolean result = adapter.supportsParameter(parameter);
assertFalse("Parameter supported", result);
assertFalse("Parameter supported", adapter.supportsParameter(parameter));
verify(adaptee);
}
@@ -102,11 +99,9 @@ public class WebArgumentResolverAdapterTests {
@Test
public void supportsParameterThrowsException() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andThrow(new Exception());
replay(adaptee);
boolean result = adapter.supportsParameter(parameter);
assertFalse("Parameter supported", result);
assertFalse("Parameter supported", adapter.supportsParameter(parameter));
verify(adaptee);
}
@@ -115,7 +110,6 @@ public class WebArgumentResolverAdapterTests {
public void resolveArgument() throws Exception {
int expected = 42;
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn(expected);
replay(adaptee);
Object result = adapter.resolveArgument(parameter, null, webRequest, null);
@@ -128,7 +122,6 @@ public class WebArgumentResolverAdapterTests {
@Test(expected = IllegalStateException.class)
public void resolveArgumentUnresolved() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn(WebArgumentResolver.UNRESOLVED);
replay(adaptee);
adapter.resolveArgument(parameter, null, webRequest, null);
@@ -139,7 +132,6 @@ public class WebArgumentResolverAdapterTests {
@Test(expected = IllegalStateException.class)
public void resolveArgumentWrongType() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn("Foo");
replay(adaptee);
adapter.resolveArgument(parameter, null, webRequest, null);
@@ -150,7 +142,6 @@ public class WebArgumentResolverAdapterTests {
@Test(expected = Exception.class)
public void resolveArgumentThrowsException() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andThrow(new Exception());
replay(adaptee);
adapter.resolveArgument(parameter, null, webRequest, null);
@@ -159,7 +150,6 @@ public class WebArgumentResolverAdapterTests {
}
public void handle(int param) {
}
private class TestWebArgumentResolverAdapter extends AbstractWebArgumentResolverAdapter {
@@ -174,4 +164,4 @@ public class WebArgumentResolverAdapterTests {
}
}
}
}

44
org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodArgumentResolverCompositeTests.java
View File

@@ -27,60 +27,60 @@ import org.junit.Test;
import org.springframework.core.MethodParameter;
/**
* Test fixture for {@link HandlerMethodArgumentResolverComposite} unit tests.
* Test fixture with {@link HandlerMethodArgumentResolverComposite}.
*
* @author Rossen Stoyanchev
*/
public class HandlerMethodArgumentResolverCompositeTests {
private HandlerMethodArgumentResolverComposite composite;
private HandlerMethodArgumentResolverComposite resolvers;
private MethodParameter paramInteger;
private MethodParameter paramInt;
private MethodParameter paramString;
private MethodParameter paramStr;
@Before
public void setUp() throws Exception {
this.composite = new HandlerMethodArgumentResolverComposite();
resolvers = new HandlerMethodArgumentResolverComposite();
Method method = getClass().getDeclaredMethod("handle", Integer.class, String.class);
this.paramInteger = new MethodParameter(method, 0);
this.paramString = new MethodParameter(method, 1);
paramInt = new MethodParameter(method, 0);
paramStr = new MethodParameter(method, 1);
}
@Test
public void supportsParameter() throws Exception {
registerResolver(Integer.class, null, false);
registerResolver(Integer.class, null);
assertTrue(this.composite.supportsParameter(paramInteger));
assertFalse(this.composite.supportsParameter(paramString));
assertTrue(this.resolvers.supportsParameter(paramInt));
assertFalse(this.resolvers.supportsParameter(paramStr));
}
@Test
public void resolveArgument() throws Exception {
registerResolver(Integer.class, Integer.valueOf(55), false);
Object resolvedValue = this.composite.resolveArgument(paramInteger, null, null, null);
registerResolver(Integer.class, Integer.valueOf(55));
Object resolvedValue = this.resolvers.resolveArgument(paramInt, null, null, null);
assertEquals(Integer.valueOf(55), resolvedValue);
}
@Test
public void resolveArgumentMultipleResolvers() throws Exception {
registerResolver(Integer.class, Integer.valueOf(1), false);
registerResolver(Integer.class, Integer.valueOf(2), false);
Object resolvedValue = this.composite.resolveArgument(paramInteger, null, null, null);
public void checkArgumentResolverOrder() throws Exception {
registerResolver(Integer.class, Integer.valueOf(1));
registerResolver(Integer.class, Integer.valueOf(2));
Object resolvedValue = this.resolvers.resolveArgument(paramInt, null, null, null);
assertEquals("Didn't use the first registered resolver", Integer.valueOf(1), resolvedValue);
}
@Test(expected=IllegalStateException.class)
public void noSuitableArgumentResolver() throws Exception {
this.composite.resolveArgument(paramString, null, null, null);
this.resolvers.resolveArgument(paramStr, null, null, null);
}
protected StubArgumentResolver registerResolver(Class<?> supportedType, Object stubValue, boolean usesResponse) {
StubArgumentResolver resolver = new StubArgumentResolver(supportedType, stubValue, usesResponse);
this.composite.registerArgumentResolver(resolver);
protected StubArgumentResolver registerResolver(Class<?> supportedType, Object stubValue) {
StubArgumentResolver resolver = new StubArgumentResolver(supportedType, stubValue);
this.resolvers.addResolver(resolver);
return resolver;
}
@@ -88,4 +88,4 @@ public class HandlerMethodArgumentResolverCompositeTests {
private void handle(Integer arg1, String arg2) {
}
}
}

52
org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerCompositeTests.java
View File

@@ -26,65 +26,63 @@ import org.junit.Test;
import org.springframework.core.MethodParameter;
/**
* Test fixture for {@link HandlerMethodReturnValueHandlerComposite} unit tests.
* Test fixture with {@link HandlerMethodReturnValueHandlerComposite}.
*
* @author Rossen Stoyanchev
*/
public class HandlerMethodReturnValueHandlerCompositeTests {
private HandlerMethodReturnValueHandlerComposite composite;
private HandlerMethodReturnValueHandlerComposite handlers;
ModelAndViewContainer mavContainer;
private MethodParameter paramInteger;
private MethodParameter paramInt;
private MethodParameter paramString;
private MethodParameter paramStr;
@Before
public void setUp() throws Exception {
this.composite = new HandlerMethodReturnValueHandlerComposite();
this.paramInteger = new MethodParameter(getClass().getDeclaredMethod("handleInteger"), -1);
this.paramString = new MethodParameter(getClass().getDeclaredMethod("handleString"), -1);
handlers = new HandlerMethodReturnValueHandlerComposite();
mavContainer = new ModelAndViewContainer();
paramInt = new MethodParameter(getClass().getDeclaredMethod("handleInteger"), -1);
paramStr = new MethodParameter(getClass().getDeclaredMethod("handleString"), -1);
}
@Test
public void supportsReturnType() throws Exception {
registerReturnValueHandler(Integer.class, false);
assertTrue(this.composite.supportsReturnType(paramInteger));
assertFalse(this.composite.supportsReturnType(paramString));
registerHandler(Integer.class);
assertTrue(this.handlers.supportsReturnType(paramInt));
assertFalse(this.handlers.supportsReturnType(paramStr));
}
@Test
public void handleReturnValue() throws Exception {
StubReturnValueHandler handler = registerReturnValueHandler(Integer.class, false);
this.composite.handleReturnValue(Integer.valueOf(55), paramInteger, mavContainer, null);
StubReturnValueHandler handler = registerHandler(Integer.class);
this.handlers.handleReturnValue(Integer.valueOf(55), paramInt, mavContainer, null);
assertEquals(Integer.valueOf(55), handler.getUnhandledReturnValue());
assertEquals(Integer.valueOf(55), handler.getReturnValue());
}
@Test
public void handleReturnValueMultipleHandlers() throws Exception {
StubReturnValueHandler handler1 = registerReturnValueHandler(Integer.class, false);
StubReturnValueHandler handler2 = registerReturnValueHandler(Integer.class, false);
this.composite.handleReturnValue(Integer.valueOf(55), paramInteger, mavContainer, null);
StubReturnValueHandler h1 = registerHandler(Integer.class);
StubReturnValueHandler h2 = registerHandler(Integer.class);
this.handlers.handleReturnValue(Integer.valueOf(55), paramInt, mavContainer, null);
assertEquals("Didn't use the 1st registered handler", Integer.valueOf(55), handler1.getUnhandledReturnValue());
assertNull("Shouldn't have use the 2nd registered handler", handler2.getUnhandledReturnValue());
assertEquals("Didn't use the 1st registered handler", Integer.valueOf(55), h1.getReturnValue());
assertNull("Shouldn't have use the 2nd registered handler", h2.getReturnValue());
}
@Test(expected=IllegalStateException.class)
public void noSuitableReturnValueHandler() throws Exception {
registerReturnValueHandler(Integer.class, false);
this.composite.handleReturnValue("value", paramString, null, null);
registerHandler(Integer.class);
this.handlers.handleReturnValue("value", paramStr, null, null);
}
protected StubReturnValueHandler registerReturnValueHandler(Class<?> returnType, boolean usesResponse) {
StubReturnValueHandler handler = new StubReturnValueHandler(returnType, usesResponse);
this.composite.registerReturnValueHandler(handler);
private StubReturnValueHandler registerHandler(Class<?> returnType) {
StubReturnValueHandler handler = new StubReturnValueHandler(returnType);
handlers.addHandler(handler);
return handler;
}
@@ -98,4 +96,4 @@ public class HandlerMethodReturnValueHandlerCompositeTests {
return null;
}
}
}

71
org.springframework.web/src/test/java/org/springframework/web/method/support/InvocableHandlerMethodTests.java
View File

@@ -22,51 +22,44 @@ import java.lang.reflect.Method;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.HttpStatus;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
/**
* Test fixture for {@link InvocableHandlerMethod} unit tests.
* Test fixture with {@link InvocableHandlerMethod}.
*
* @author Rossen Stoyanchev
*/
public class InvocableHandlerMethodTests {
private HandlerMethodArgumentResolverComposite argResolvers;
private HandlerMethodArgumentResolverComposite argumentResolvers;
private NativeWebRequest webRequest;
private MockHttpServletResponse response;
@Before
public void setUp() throws Exception {
argResolvers = new HandlerMethodArgumentResolverComposite();
response = new MockHttpServletResponse();
this.webRequest = new ServletWebRequest(new MockHttpServletRequest(), response);
argumentResolvers = new HandlerMethodArgumentResolverComposite();
this.webRequest = new ServletWebRequest(new MockHttpServletRequest(), new MockHttpServletResponse());
}
@Test
public void argResolutionAndReturnValueHandling() throws Exception {
StubArgumentResolver resolver0 = registerResolver(Integer.class, 99, false);
StubArgumentResolver resolver1 = registerResolver(String.class, "value", false);
InvocableHandlerMethod method = handlerMethod(new Handler(), "handle", Integer.class, String.class);
public void resolveArgument() throws Exception {
StubArgumentResolver intResolver = addResolver(Integer.class, 99);
StubArgumentResolver strResolver = addResolver(String.class, "value");
InvocableHandlerMethod method = invocableHandlerMethod("handle", Integer.class, String.class);
Object returnValue = method.invokeForRequest(webRequest, null);
assertEquals("Integer resolver not invoked", 1, resolver0.getResolvedParameterNames().size());
assertEquals("String resolver not invoked", 1, resolver1.getResolvedParameterNames().size());
assertEquals("Integer resolver not invoked", 1, intResolver.getResolvedParameters().size());
assertEquals("String resolver not invoked", 1, strResolver.getResolvedParameters().size());
assertEquals("Invalid return value", "99-value", returnValue);
}
@Test
public void providedArgResolution() throws Exception {
InvocableHandlerMethod method = handlerMethod(new Handler(), "handle", Integer.class, String.class);
public void resolveProvidedArgument() throws Exception {
InvocableHandlerMethod method = invocableHandlerMethod("handle", Integer.class, String.class);
Object returnValue = method.invokeForRequest(webRequest, null, 99, "value");
assertEquals("Expected raw return value with no handlers registered", String.class, returnValue.getClass());
@@ -74,27 +67,26 @@ public class InvocableHandlerMethodTests {
}
@Test
public void parameterNameDiscovery() throws Exception {
StubArgumentResolver resolver = registerResolver(Integer.class, 99, false);
InvocableHandlerMethod method = handlerMethod(new Handler(), "parameterNameDiscovery", Integer.class);
public void discoverParameterName() throws Exception {
StubArgumentResolver resolver = addResolver(Integer.class, 99);
InvocableHandlerMethod method = invocableHandlerMethod("parameterNameDiscovery", Integer.class);
method.invokeForRequest(webRequest, null);
assertEquals("intArg", resolver.getResolvedParameterNames().get(0).getParameterName());
assertEquals("intArg", resolver.getResolvedParameters().get(0).getParameterName());
}
private InvocableHandlerMethod handlerMethod(Object handler, String methodName, Class<?>... paramTypes)
throws Exception {
Method method = handler.getClass().getDeclaredMethod(methodName, paramTypes);
InvocableHandlerMethod handlerMethod = new InvocableHandlerMethod(handler, method);
handlerMethod.setHandlerMethodArgumentResolvers(argResolvers);
return handlerMethod;
private StubArgumentResolver addResolver(Class<?> parameterType, Object stubValue) {
StubArgumentResolver resolver = new StubArgumentResolver(parameterType, stubValue);
argumentResolvers.addResolver(resolver);
return resolver;
}
private StubArgumentResolver registerResolver(Class<?> supportedType, Object stubValue, boolean usesResponse) {
StubArgumentResolver resolver = new StubArgumentResolver(supportedType, stubValue, usesResponse);
argResolvers.registerArgumentResolver(resolver);
return resolver;
private InvocableHandlerMethod invocableHandlerMethod(String methodName, Class<?>... paramTypes)
throws Exception {
Method method = Handler.class.getDeclaredMethod(methodName, paramTypes);
InvocableHandlerMethod handlerMethod = new InvocableHandlerMethod(new Handler(), method);
handlerMethod.setHandlerMethodArgumentResolvers(argumentResolvers);
return handlerMethod;
}
private static class Handler {
@@ -108,15 +100,6 @@ public class InvocableHandlerMethodTests {
@RequestMapping
public void parameterNameDiscovery(Integer intArg) {
}
@SuppressWarnings("unused")
@ResponseStatus(value = HttpStatus.BAD_REQUEST, reason = "400 Bad Request")
public void responseStatus() {
}
@SuppressWarnings("unused")
public String usesResponse(int arg) {
return "";
}
}
}

28
org.springframework.web/src/test/java/org/springframework/web/method/support/StubArgumentResolver.java
View File

@@ -24,44 +24,34 @@ import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
/**
* Resolves a method argument from a stub value. Records all resolved parameters.
* Resolves a method argument using a stub value and records resolved parameters.
*
* @author Rossen Stoyanchev
*/
public class StubArgumentResolver implements HandlerMethodArgumentResolver {
private final Class<?> supportedType;
private final Class<?> parameterType;
private final Object stubValue;
private final boolean usesResponse;
private List<MethodParameter> resolvedParameters = new ArrayList<MethodParameter>();
public StubArgumentResolver(Class<?> supportedType, Object stubValue, boolean usesResponse) {
this.supportedType = supportedType;
public StubArgumentResolver(Class<?> parameterType, Object stubValue) {
this.parameterType = parameterType;
this.stubValue = stubValue;
this.usesResponse = usesResponse;
}
public List<MethodParameter> getResolvedParameterNames() {
public List<MethodParameter> getResolvedParameters() {
return resolvedParameters;
}
public boolean usesResponseArgument(MethodParameter parameter) {
return this.usesResponse;
}
public boolean supportsParameter(MethodParameter parameter) {
return parameter.getParameterType().equals(this.supportedType);
return parameter.getParameterType().equals(this.parameterType);
}
public Object resolveArgument(MethodParameter parameter,
ModelAndViewContainer mavContainer,
NativeWebRequest webRequest,
WebDataBinderFactory binderFactory) throws Exception {
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
this.resolvedParameters.add(parameter);
return this.stubValue;
}
}
}

35
org.springframework.web/src/test/java/org/springframework/web/method/support/StubReturnValueHandler.java
View File

@@ -16,48 +16,35 @@
package org.springframework.web.method.support;
import org.springframework.core.Conventions;
import org.springframework.core.MethodParameter;
import org.springframework.web.context.request.NativeWebRequest;
/**
* Handles a return value by adding it as a model attribute with a default name.
* Records the raw return value (before handling).
* Supports a fixed return value type. Records the last handled return value.
*
* @author Rossen Stoyanchev
*/
public class StubReturnValueHandler implements HandlerMethodReturnValueHandler {
private final Class<?> supportedReturnType;
private final Class<?> returnType;
private final boolean usesResponse;
private Object unhandledReturnValue;
private Object returnValue;
public StubReturnValueHandler(Class<?> supportedReturnType, boolean usesResponse) {
this.supportedReturnType = supportedReturnType;
this.usesResponse = usesResponse;
public StubReturnValueHandler(Class<?> returnType) {
this.returnType = returnType;
}
public Object getUnhandledReturnValue() {
return this.unhandledReturnValue;
public Object getReturnValue() {
return this.returnValue;
}
public boolean supportsReturnType(MethodParameter returnType) {
return returnType.getParameterType().equals(this.supportedReturnType);
return returnType.getParameterType().equals(this.returnType);
}
public void handleReturnValue(Object returnValue,
MethodParameter returnType,
ModelAndViewContainer mavContainer,
NativeWebRequest webRequest) throws Exception {
this.unhandledReturnValue = returnValue;
if (returnValue != null) {
mavContainer.addAttribute(Conventions.getVariableName(returnValue), returnValue);
}
public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest) throws Exception {
this.returnValue = returnValue;
}
public boolean usesResponseArgument(MethodParameter parameter) {
return this.usesResponse;
}
}