root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

SPR-8214 review unit tests 

git-svn-id: https://src.springframework.org/svn/spring-framework/trunk@4227 50f2f4bb-b051-0410-bef5-90022cba6387
This commit is contained in:
Rossen Stoyanchev 2011-04-15 18:42:58 +00:00
parent 6f8fa24e59
commit aae28ee298
42 changed files with 1189 additions and 1083 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapter.java
View File

@ -121,13 +121,11 @@ import org.springframework.web.util.WebUtils;
public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware,
InitializingBean {
private final List<HandlerMethodArgumentResolver> customArgumentResolvers =
new ArrayList<HandlerMethodArgumentResolver>();
private List<HandlerMethodArgumentResolver> customArgumentResolvers;
private final List<HandlerMethodReturnValueHandler> customReturnValueHandlers =
new ArrayList<HandlerMethodReturnValueHandler>();
private List<HandlerMethodReturnValueHandler> customReturnValueHandlers;
private final List<ModelAndViewResolver> modelAndViewResolvers = new ArrayList<ModelAndViewResolver>();
private List<ModelAndViewResolver> modelAndViewResolvers;
private List<HttpMessageConverter<?>> messageConverters;
@ -179,9 +177,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda
* or preferably converted to a {@link HandlerMethodArgumentResolver} instead.
*/
public void setCustomArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
if (argumentResolvers != null) {
this.customArgumentResolvers.addAll(argumentResolvers);
}
this.customArgumentResolvers = argumentResolvers;
}
/**
@ -193,7 +189,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda
public void setArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
if (argumentResolvers != null) {
this.argumentResolvers = new HandlerMethodArgumentResolverComposite();
registerArgumentResolvers(argumentResolvers);
this.argumentResolvers.addResolvers(argumentResolvers);
}
}
@ -206,7 +202,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda
public void setInitBinderArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
if (argumentResolvers != null) {
this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite();
registerInitBinderArgumentResolvers(argumentResolvers);
this.initBinderArgumentResolvers.addResolvers(argumentResolvers);
}
}
@ -217,9 +213,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda
* @param returnValueHandlers custom return value handlers for {@link RequestMapping} methods
*/
public void setCustomReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
if (returnValueHandlers != null) {
this.customReturnValueHandlers.addAll(returnValueHandlers);
}
this.customReturnValueHandlers = returnValueHandlers;
}
/**
@ -231,7 +225,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda
public void setReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
if (returnValueHandlers != null) {
this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite();
registerReturnValueHandlers(returnValueHandlers);
this.returnValueHandlers.addHandlers(returnValueHandlers);
}
}
@ -244,9 +238,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda
* {@link HandlerMethodReturnValueHandler} and {@link #setCustomReturnValueHandlers(List)} instead.
*/
public void setModelAndViewResolvers(List<ModelAndViewResolver> modelAndViewResolvers) {
if (modelAndViewResolvers != null) {
this.modelAndViewResolvers.addAll(modelAndViewResolvers);
}
this.modelAndViewResolvers = modelAndViewResolvers;
}
/**
@ -334,36 +326,20 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda
public void afterPropertiesSet() throws Exception {
if (argumentResolvers == null) {
argumentResolvers = new HandlerMethodArgumentResolverComposite();
registerArgumentResolvers(customArgumentResolvers);
registerArgumentResolvers(getDefaultArgumentResolvers(messageConverters, beanFactory));
argumentResolvers.addResolvers(customArgumentResolvers);
argumentResolvers.addResolvers(getDefaultArgumentResolvers(messageConverters, beanFactory));
}
if (returnValueHandlers == null) {
returnValueHandlers = new HandlerMethodReturnValueHandlerComposite();
registerReturnValueHandlers(customReturnValueHandlers);
registerReturnValueHandlers(getDefaultReturnValueHandlers(messageConverters, modelAndViewResolvers));
returnValueHandlers.addHandlers(customReturnValueHandlers);
returnValueHandlers.addHandlers(getDefaultReturnValueHandlers(messageConverters, modelAndViewResolvers));
}
if (initBinderArgumentResolvers == null) {
initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite();
registerInitBinderArgumentResolvers(customArgumentResolvers);
registerInitBinderArgumentResolvers(getDefaultInitBinderArgumentResolvers(beanFactory));
}
}
private void registerArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
for (HandlerMethodArgumentResolver resolver : argumentResolvers) {
this.argumentResolvers.registerArgumentResolver(resolver);
}
}
private void registerInitBinderArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
for (HandlerMethodArgumentResolver resolver : argumentResolvers) {
this.initBinderArgumentResolvers.registerArgumentResolver(resolver);
}
}
private void registerReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
for (HandlerMethodReturnValueHandler handler : returnValueHandlers) {
this.returnValueHandlers.registerReturnValueHandler(handler);
initBinderArgumentResolvers.addResolvers(customArgumentResolvers);
initBinderArgumentResolvers.addResolvers(getDefaultInitBinderArgumentResolvers(beanFactory));
}
}
@ -372,6 +348,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda
List<HandlerMethodArgumentResolver> resolvers = new ArrayList<HandlerMethodArgumentResolver>();
// Annotation-based resolvers
resolvers.add(new RequestParamMethodArgumentResolver(beanFactory, false));
resolvers.add(new RequestParamMapMethodArgumentResolver());
resolvers.add(new PathVariableMethodArgumentResolver());

38
org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolver.java
View File

@ -82,11 +82,9 @@ import org.springframework.web.servlet.mvc.method.annotation.support.ViewMethodR
public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandlerMethodExceptionResolver implements
InitializingBean {
private final List<HandlerMethodArgumentResolver> customArgumentResolvers =
new ArrayList<HandlerMethodArgumentResolver>();
private List<HandlerMethodArgumentResolver> customArgumentResolvers;
private final List<HandlerMethodReturnValueHandler> customReturnValueHandlers =
new ArrayList<HandlerMethodReturnValueHandler>();
private List<HandlerMethodReturnValueHandler> customReturnValueHandlers;
private List<HttpMessageConverter<?>> messageConverters;
@ -119,9 +117,7 @@ public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandle
* or preferably converted to a {@link HandlerMethodArgumentResolver} instead.
*/
public void setCustomArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
if (argumentResolvers != null) {
this.customArgumentResolvers.addAll(argumentResolvers);
}
this.customArgumentResolvers= argumentResolvers;
}
/**
@ -133,7 +129,7 @@ public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandle
public void setArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
if (argumentResolvers != null) {
this.argumentResolvers = new HandlerMethodArgumentResolverComposite();
registerArgumentResolvers(argumentResolvers);
this.argumentResolvers.addResolvers(argumentResolvers);
}
}
@ -144,9 +140,7 @@ public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandle
* @param returnValueHandlers custom return value handlers for {@link ExceptionHandler} methods
*/
public void setCustomReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
if (returnValueHandlers != null) {
this.customReturnValueHandlers.addAll(returnValueHandlers);
}
this.customReturnValueHandlers = returnValueHandlers;
}
/**
@ -158,7 +152,7 @@ public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandle
public void setReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
if (returnValueHandlers != null) {
this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite();
registerReturnValueHandlers(returnValueHandlers);
this.returnValueHandlers.addHandlers(returnValueHandlers);
}
}
@ -173,25 +167,13 @@ public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandle
public void afterPropertiesSet() throws Exception {
if (argumentResolvers == null) {
argumentResolvers = new HandlerMethodArgumentResolverComposite();
registerArgumentResolvers(customArgumentResolvers);
registerArgumentResolvers(getDefaultArgumentResolvers());
argumentResolvers.addResolvers(customArgumentResolvers);
argumentResolvers.addResolvers(getDefaultArgumentResolvers());
}
if (returnValueHandlers == null) {
returnValueHandlers = new HandlerMethodReturnValueHandlerComposite();
registerReturnValueHandlers(customReturnValueHandlers);
registerReturnValueHandlers(getDefaultReturnValueHandlers(messageConverters));
}
}
private void registerArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
for (HandlerMethodArgumentResolver resolver : argumentResolvers) {
this.argumentResolvers.registerArgumentResolver(resolver);
}
}
private void registerReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
for (HandlerMethodReturnValueHandler handler : returnValueHandlers) {
this.returnValueHandlers.registerReturnValueHandler(handler);
returnValueHandlers.addHandlers(customReturnValueHandlers);
returnValueHandlers.addHandlers(getDefaultReturnValueHandlers(messageConverters));
}
}

34
org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandler.java
View File

@ -52,7 +52,7 @@ import org.springframework.web.servlet.mvc.annotation.ModelAndViewResolver;
*/
public class DefaultMethodReturnValueHandler implements HandlerMethodReturnValueHandler {
private final List<ModelAndViewResolver> modelAndViewResolvers = new ArrayList<ModelAndViewResolver>();
private final List<ModelAndViewResolver> mavResolvers;
/**
* Create a {@link DefaultMethodReturnValueHandler} instance without {@link ModelAndViewResolver}s.
@ -64,10 +64,8 @@ public class DefaultMethodReturnValueHandler implements HandlerMethodReturnValue
/**
* Create a {@link DefaultMethodReturnValueHandler} with a list of {@link ModelAndViewResolver}s.
*/
public DefaultMethodReturnValueHandler(List<ModelAndViewResolver> modelAndViewResolvers) {
if (modelAndViewResolvers != null) {
this.modelAndViewResolvers.addAll(modelAndViewResolvers);
}
public DefaultMethodReturnValueHandler(List<ModelAndViewResolver> mavResolvers) {
this.mavResolvers = mavResolvers;
}
public boolean supportsReturnType(MethodParameter returnType) {
@ -77,18 +75,20 @@ public class DefaultMethodReturnValueHandler implements HandlerMethodReturnValue
public void handleReturnValue(Object returnValue,
MethodParameter returnType,
ModelAndViewContainer mavContainer,
NativeWebRequest webRequest) throws Exception {
NativeWebRequest request) throws Exception {
for (ModelAndViewResolver resolver : modelAndViewResolvers) {
Class<?> handlerType = returnType.getDeclaringClass();
Method method = returnType.getMethod();
ExtendedModelMap extModel = (ExtendedModelMap) mavContainer.getModel();
ModelAndView mav = resolver.resolveModelAndView(method, handlerType, returnValue, extModel, webRequest);
if (mav != ModelAndViewResolver.UNRESOLVED) {
mavContainer.setView(mav.getView());
mavContainer.setViewName(mav.getViewName());
mavContainer.addAllAttributes(mav.getModel());
return;
if (mavResolvers != null) {
for (ModelAndViewResolver resolver : mavResolvers) {
Class<?> handlerType = returnType.getDeclaringClass();
Method method = returnType.getMethod();
ExtendedModelMap model = (ExtendedModelMap) mavContainer.getModel();
ModelAndView mav = resolver.resolveModelAndView(method, handlerType, returnValue, model, request);
if (mav != ModelAndViewResolver.UNRESOLVED) {
mavContainer.setView(mav.getView());
mavContainer.setViewName(mav.getViewName());
mavContainer.addAllAttributes(mav.getModel());
return;
}
}
}
@ -106,4 +106,4 @@ public class DefaultMethodReturnValueHandler implements HandlerMethodReturnValue
}
}
}
}

2
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/MvcAnnotationDrivenFeatureTests.java
View File

@ -36,9 +36,7 @@ import org.springframework.validation.MessageCodesResolver;
import org.springframework.validation.Validator;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
import org.springframework.web.bind.support.WebArgumentResolver;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMethodAdapter;
import org.springframework.web.servlet.mvc.method.annotation.support.ServletWebArgumentResolverAdapter;

2
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/handler/HandlerMethodMappingTests.java
View File

@ -131,4 +131,4 @@ public class HandlerMethodMappingTests {
public void handlerMethod2() {
}
}
}
}

10
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ControllerMethodAnnotationDetectionTests.java → org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HandlerMethodAdapterAnnotationDetectionTests.java
View File

@ -68,7 +68,7 @@ import org.springframework.web.servlet.mvc.method.annotation.support.DefaultMeth
* @author Rossen Stoyanchev
*/
@RunWith(Parameterized.class)
public class ControllerMethodAnnotationDetectionTests {
public class HandlerMethodAdapterAnnotationDetectionTests {
@Parameters
public static Collection<Object[]> handlerTypes() {
@ -87,7 +87,7 @@ public class ControllerMethodAnnotationDetectionTests {
private boolean useAutoProxy;
public ControllerMethodAnnotationDetectionTests(Object handler, boolean useAutoProxy) {
public HandlerMethodAdapterAnnotationDetectionTests(Object handler, boolean useAutoProxy) {
this.handler = handler;
this.useAutoProxy = useAutoProxy;
}
@ -117,11 +117,11 @@ public class ControllerMethodAnnotationDetectionTests {
handler = getProxyBean(handler);
}
HandlerMethodArgumentResolverComposite argResolvers = new HandlerMethodArgumentResolverComposite();
argResolvers.registerArgumentResolver(new ModelAttributeMethodProcessor(false));
argResolvers.addResolver(new ModelAttributeMethodProcessor(false));
HandlerMethodReturnValueHandlerComposite handlers = new HandlerMethodReturnValueHandlerComposite();
handlers.registerReturnValueHandler(new ModelAttributeMethodProcessor(false));
handlers.registerReturnValueHandler(new DefaultMethodReturnValueHandler(null));
handlers.addHandler(new ModelAttributeMethodProcessor(false));
handlers.addHandler(new DefaultMethodReturnValueHandler(null));
Class<?> handlerType = ClassUtils.getUserClass(handler.getClass());
Set<Method> methods = HandlerMethodSelector.selectMethods(handlerType, REQUEST_MAPPING_METHODS);

22
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodDetectionTests.java → org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HandlerMethodMappingAnnotationDetectionTests.java
View File

@ -21,8 +21,6 @@ import static org.junit.Assert.assertNotNull;
import java.util.Arrays;
import java.util.Collection;
import javax.servlet.http.HttpServletRequest;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@ -38,7 +36,6 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.support.GenericWebApplicationContext;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMethodMapping;
/**
* Test various scenarios for detecting handler methods depending on where @RequestMapping annotations
@ -55,7 +52,7 @@ import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandl
* @author Rossen Stoyanchev
*/
@RunWith(Parameterized.class)
public class RequestMappingHandlerMethodDetectionTests {
public class HandlerMethodMappingAnnotationDetectionTests {
@Parameters
public static Collection<Object[]> handlerTypes() {
@ -74,7 +71,7 @@ public class RequestMappingHandlerMethodDetectionTests {
private boolean useAutoProxy;
public RequestMappingHandlerMethodDetectionTests(Object handler, boolean useAutoProxy) {
public HandlerMethodMappingAnnotationDetectionTests(Object handler, boolean useAutoProxy) {
this.handler = handler;
this.useAutoProxy = useAutoProxy;
}
@ -83,13 +80,13 @@ public class RequestMappingHandlerMethodDetectionTests {
public void detectAndMapHandlerMethod() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/type/handle");
TestRequestMappingHandlerMethodMapping mapping = createHandlerMapping(handler.getClass(), useAutoProxy);
HandlerMethod handlerMethod = mapping.getHandlerInternal(request);
RequestMappingHandlerMethodMapping mapping = createHandlerMapping(handler.getClass(), useAutoProxy);
HandlerMethod handlerMethod = (HandlerMethod) mapping.getHandler(request).getHandler();
assertNotNull("Failed to detect and map @RequestMapping handler method", handlerMethod);
}
private TestRequestMappingHandlerMethodMapping createHandlerMapping(Class<?> controllerType, boolean useAutoProxy) {
private RequestMappingHandlerMethodMapping createHandlerMapping(Class<?> controllerType, boolean useAutoProxy) {
GenericWebApplicationContext wac = new GenericWebApplicationContext();
wac.registerBeanDefinition("controller", new RootBeanDefinition(controllerType));
if (useAutoProxy) {
@ -99,18 +96,11 @@ public class RequestMappingHandlerMethodDetectionTests {
wac.getBeanFactory().registerSingleton("advsr", new DefaultPointcutAdvisor(new SimpleTraceInterceptor()));
}
TestRequestMappingHandlerMethodMapping mapping = new TestRequestMappingHandlerMethodMapping();
RequestMappingHandlerMethodMapping mapping = new RequestMappingHandlerMethodMapping();
mapping.setApplicationContext(wac);
return mapping;
}
public static class TestRequestMappingHandlerMethodMapping extends RequestMappingHandlerMethodMapping {
public HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
return super.getHandlerInternal(request);
}
}
/* Annotation on interface method */
@Controller

5
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyComparatorTests.java
View File

@ -32,6 +32,8 @@ import static java.util.Arrays.*;
import static org.junit.Assert.*;
/**
* Test fixture with {@link RequestMappingHandlerMethodMapping} testing its {@link RequestKey} comparator.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
@ -143,4 +145,5 @@ public class RequestKeyComparatorTests {
assertTrue(comparator.compare(html, xml) > 0);
assertTrue(comparator.compare(xml, html) < 0);
}
}
}

4
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyTests.java
View File

@ -31,6 +31,8 @@ import static org.junit.Assert.*;
import static org.springframework.web.bind.annotation.RequestMethod.*;
/**
* Test fixture for {@link RequestKey} tests.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
@ -232,4 +234,4 @@ public class RequestKeyTests {
return new RequestKey(asList(patterns), null);
}
}
}

108
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterIntegrationTests.java
View File

@ -52,7 +52,6 @@ import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BindingResult;
@ -83,24 +82,23 @@ import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.method.annotation.support.ServletWebArgumentResolverAdapter;
/**
* A test fixture for higher-level {@link RequestMappingHandlerMethodAdapter} tests.
* Serves as a sandbox to invoke all types of controller methods using all features except for the kitchen sink.
* Once a problem has been debugged and understood, tests demonstrating the issue are preferably added to the
* appropriate, more fine-grained test fixture.
*
* <p>The aim here is not to test {@link RequestMappingHandlerMethodAdapter} itself nor to exercise
* every {@link Controller @Controller} method feature but to have a place to try any feature
* related to {@link Controller @Controller} invocations. Preferably actual tests should be
* added to the components that provide that respective functionality.
*
* <p>The following integration tests for detecting annotations on super types, parameterized
* methods, and proxies may also be of interest:
* <p>If you wish to add high-level tests, consider the following other "integration"-style tests:
* <ul>
* <li>{@link RequestMappingHandlerMethodDetectionTests}
* <li>{@link ControllerMethodAnnotationDetectionTests}
* <li>{@link HandlerMethodAdapterAnnotationDetectionTests}
* <li>{@link HandlerMethodMappingAnnotationDetectionTests}
* <li>{@link ServletHandlerMethodTests}
* </ul>
*
* @author Rossen Stoyanchev
*/
public class RequestMappingHandlerMethodAdapterIntegrationTests {
private final Object handler = new Handler();
private RequestMappingHandlerMethodAdapter handlerAdapter;
private MockHttpServletRequest request;
@ -114,20 +112,19 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests {
List<HandlerMethodArgumentResolver> customResolvers = new ArrayList<HandlerMethodArgumentResolver>();
customResolvers.add(new ServletWebArgumentResolverAdapter(new ColorArgumentResolver()));
this.handlerAdapter = new RequestMappingHandlerMethodAdapter();
this.handlerAdapter.setWebBindingInitializer(bindingInitializer);
this.handlerAdapter.setCustomArgumentResolvers(customResolvers);
GenericWebApplicationContext context = new GenericWebApplicationContext();
context.refresh();
this.handlerAdapter.setApplicationContext(context);
this.handlerAdapter.setBeanFactory(context.getBeanFactory());
this.handlerAdapter.afterPropertiesSet();
this.request = new MockHttpServletRequest();
this.response = new MockHttpServletResponse();
handlerAdapter = new RequestMappingHandlerMethodAdapter();
handlerAdapter.setWebBindingInitializer(bindingInitializer);
handlerAdapter.setCustomArgumentResolvers(customResolvers);
handlerAdapter.setApplicationContext(context);
handlerAdapter.setBeanFactory(context.getBeanFactory());
handlerAdapter.afterPropertiesSet();
request = new MockHttpServletRequest();
response = new MockHttpServletResponse();
// Expose request to the current thread (for SpEL expressions)
RequestContextHolder.setRequestAttributes(new ServletWebRequest(request));
@ -140,36 +137,36 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests {
@Test
public void handleMvc() throws Exception {
Class<?>[] paramTypes = new Class<?>[] { int.class, String.class, String.class, String.class, Map.class,
Class<?>[] parameterTypes = new Class<?>[] { int.class, String.class, String.class, String.class, Map.class,
Date.class, Map.class, String.class, String.class, TestBean.class, Errors.class, TestBean.class,
Color.class, HttpServletRequest.class, HttpServletResponse.class, User.class, OtherUser.class,
Model.class };
/* URI template vars (see RequestMappingHandlerMethodMapping) */
String datePattern = "yyyy.MM.dd";
String formattedDate = "2011.03.16";
Date date = new GregorianCalendar(2011, Calendar.MARCH, 16).getTime();
request.addHeader("Content-Type", "text/plain; charset=utf-8");
request.addHeader("header", "headerValue");
request.addHeader("anotherHeader", "anotherHeaderValue");
request.addParameter("datePattern", datePattern);
request.addParameter("dateParam", formattedDate);
request.addParameter("paramByConvention", "paramByConventionValue");
request.addParameter("age", "25");
request.setCookies(new Cookie("cookie", "99"));
request.setContent("Hello World".getBytes("UTF-8"));
request.setUserPrincipal(new User());
request.setContextPath("/contextPath");
System.setProperty("systemHeader", "systemHeaderValue");
/* Set up path variables as RequestMappingHandlerMethodMapping would... */
Map<String, String> uriTemplateVars = new HashMap<String, String>();
uriTemplateVars.put("pathvar", "pathvarValue");
request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);
Date date = new GregorianCalendar(2011, Calendar.MARCH, 16).getTime();
String formattedDate = "2011.03.16";
System.setProperty("systemHeader", "systemHeaderValue");
request.setCookies(new Cookie("cookie", "99"));
request.addHeader("header", "headerValue");
request.addHeader("anotherHeader", "anotherHeaderValue");
request.addParameter("datePattern", "yyyy.MM.dd");
request.addParameter("dateParam", formattedDate);
request.addParameter("paramByConvention", "paramByConventionValue");
request.addParameter("age", "25");
request.setContextPath("/contextPath");
request.addHeader("Content-Type", "text/plain; charset=utf-8");
request.setContent("Hello World".getBytes("UTF-8"));
request.setUserPrincipal(new User());
HandlerMethod handlerMethod = handlerMethod(new RequestMappingHandler(), "handleMvc", paramTypes);
HandlerMethod handlerMethod = handlerMethod("handleMvc", parameterTypes);
ModelAndView mav = handlerAdapter.handle(request, response, handlerMethod);
ModelMap model = mav.getModelMap();
@ -215,12 +212,13 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests {
@Test
public void handleRequestBody() throws Exception {
Class<?>[] paramTypes = new Class<?>[] { byte[].class };
Class<?>[] parameterTypes = new Class<?>[] { byte[].class };
request.addHeader("Content-Type", "text/plain; charset=utf-8");
request.setContent("Hello Server".getBytes("UTF-8"));
HandlerMethod handlerMethod = handlerMethod(new RequestMappingHandler(), "handleRequestBody", paramTypes);
HandlerMethod handlerMethod = handlerMethod("handleRequestBody", parameterTypes);
ModelAndView mav = handlerAdapter.handle(request, response, handlerMethod);
@ -231,12 +229,13 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests {
@Test
public void handleHttpEntity() throws Exception {
Class<?>[] paramTypes = new Class<?>[] { HttpEntity.class };
Class<?>[] parameterTypes = new Class<?>[] { HttpEntity.class };
request.addHeader("Content-Type", "text/plain; charset=utf-8");
request.setContent("Hello Server".getBytes("UTF-8"));
HandlerMethod handlerMethod = handlerMethod(new RequestMappingHandler(), "handleHttpEntity", paramTypes);
HandlerMethod handlerMethod = handlerMethod("handleHttpEntity", parameterTypes);
ModelAndView mav = handlerAdapter.handle(request, response, handlerMethod);
@ -246,22 +245,21 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests {
assertEquals("headerValue", response.getHeader("header"));
}
private HandlerMethod handlerMethod(Object handler, String methodName, Class<?>... paramTypes) throws Exception {
private HandlerMethod handlerMethod(String methodName, Class<?>... paramTypes) throws Exception {
Method method = handler.getClass().getDeclaredMethod(methodName, paramTypes);
return new InvocableHandlerMethod(handler, method);
}
@SuppressWarnings("unused")
@SessionAttributes(types=TestBean.class)
private static class RequestMappingHandler {
private static class Handler {
@SuppressWarnings("unused")
@InitBinder("dateParam")
public void initBinder(WebDataBinder dataBinder, @RequestParam("datePattern") String datePattern) {
SimpleDateFormat dateFormat = new SimpleDateFormat(datePattern);
dataBinder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));
}
@SuppressWarnings("unused")
@ModelAttribute
public void model(Model model) {
TestBean modelAttr = new TestBean();
@ -275,7 +273,6 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests {
model.addAttribute(new OtherUser());
}
@SuppressWarnings("unused")
public String handleMvc(
@CookieValue("cookie") int cookie,
@PathVariable("pathvar") String pathvar,
@ -308,7 +305,6 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests {
return "viewName";
}
@SuppressWarnings("unused")
@ResponseStatus(value=HttpStatus.ACCEPTED)
@ResponseBody
public String handleRequestBody(@RequestBody byte[] bytes) throws Exception {
@ -316,7 +312,6 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests {
return "Handled requestBody=[" + requestBody + "]";
}
@SuppressWarnings("unused")
public ResponseEntity<String> handleHttpEntity(HttpEntity<byte[]> httpEntity) throws Exception {
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.set("header", "headerValue");
@ -352,4 +347,5 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests {
return "other user";
}
}
}
}

16
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterTests.java
View File

@ -25,19 +25,20 @@ import org.junit.Before;
import org.junit.Test;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.context.support.GenericWebApplicationContext;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.method.support.InvocableHandlerMethod;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMethodAdapter;
/**
* Test fixture for {@link RequestMappingHandlerMethodAdapter} unit tests.
* Fine-grained {@link RequestMappingHandlerMethodAdapter} unit tests.
*
* The tests in this class focus on {@link RequestMappingHandlerMethodAdapter} functionality exclusively.
* Also see {@link RequestMappingHandlerMethodAdapterIntegrationTests} for higher-level tests invoking
* {@link Controller @Controller} methods.
* <p>For higher-level adapter tests see:
* <ul>
* <li>{@link ServletHandlerMethodTests}
* <li>{@link RequestMappingHandlerMethodAdapterIntegrationTests}
* <li>{@link HandlerMethodAdapterAnnotationDetectionTests}
* </ul>
*
* @author Rossen Stoyanchev
*/
@ -94,4 +95,5 @@ public class RequestMappingHandlerMethodAdapterTests {
public void handle() {
}
}
}
}

4
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolverTests.java
View File

@ -46,7 +46,7 @@ import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMethodExceptionResolver;
/**
* Test fixture for {@link RequestMappingHandlerMethodExceptionResolver} unit tests.
* Test fixture with {@link RequestMappingHandlerMethodExceptionResolver}.
*
* @author Rossen Stoyanchev
* @author Arjen Poutsma
@ -236,4 +236,4 @@ public class RequestMappingHandlerMethodExceptionResolverTests {
}
}
}
}

74
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodMappingTests.java
View File

@ -16,13 +16,19 @@
package org.springframework.web.servlet.mvc.method.annotation;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.fail;
import java.util.Arrays;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.springframework.context.support.StaticApplicationContext;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.stereotype.Controller;
@ -36,50 +42,67 @@ import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import org.springframework.web.servlet.handler.MappedInterceptor;
import static org.junit.Assert.*;
/**
* Test fixture with {@link RequestMappingHandlerMethodMapping}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class RequestMappingHandlerMethodMappingTests {
private MyRequestMappingHandlerMethodMapping mapping;
private RequestMappingHandlerMethodMapping mapping;
private MyHandler handler;
private Handler handler;
private HandlerMethod fooMethod;
private HandlerMethod fooParamMethod;
private HandlerMethod barMethod;
@Before
public void setUp() throws Exception {
handler = new MyHandler();
handler = new Handler();
fooMethod = new HandlerMethod(handler, "foo");
fooParamMethod = new HandlerMethod(handler, "fooParam");
barMethod = new HandlerMethod(handler, "bar");
StaticApplicationContext context = new StaticApplicationContext();
context.registerSingleton("handler", handler.getClass());
mapping = new MyRequestMappingHandlerMethodMapping();
mapping = new RequestMappingHandlerMethodMapping();
mapping.setApplicationContext(context);
}
@Test
public void directMatch() throws Exception {
HandlerMethod result = mapping.getHandlerInternal(new MockHttpServletRequest("GET", "/foo"));
assertEquals(fooMethod.getMethod(), result.getMethod());
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/foo");
HandlerMethod hm = (HandlerMethod) mapping.getHandler(request).getHandler();
assertEquals(fooMethod.getMethod(), hm.getMethod());
}
@Test
public void globMatch() throws Exception {
HandlerMethod result = mapping.getHandlerInternal(new MockHttpServletRequest("GET", "/bar"));
assertEquals(barMethod.getMethod(), result.getMethod());
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/bar");
HandlerMethod hm = (HandlerMethod) mapping.getHandler(request).getHandler();
assertEquals(barMethod.getMethod(), hm.getMethod());
}
// TODO: SPR-8247
@Ignore
@Test
public void bestMatch() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/foo");
request.setParameter("p", "anything");
HandlerMethod hm = (HandlerMethod) mapping.getHandler(request).getHandler();
assertEquals(fooParamMethod.getMethod(), hm.getMethod());
}
@Test
public void methodNotAllowed() throws Exception {
try {
mapping.getHandlerInternal(new MockHttpServletRequest("POST", "/bar"));
MockHttpServletRequest request = new MockHttpServletRequest("POST", "/bar");
mapping.getHandler(request);
fail("HttpRequestMethodNotSupportedException expected");
}
catch (HttpRequestMethodNotSupportedException ex) {
@ -109,7 +132,6 @@ public class RequestMappingHandlerMethodMappingTests {
HandlerInterceptor interceptor = new HandlerInterceptorAdapter() {};
MappedInterceptor mappedInterceptor = new MappedInterceptor(new String[] {path}, interceptor);
MyRequestMappingHandlerMethodMapping mapping = new MyRequestMappingHandlerMethodMapping();
mapping.setMappedInterceptors(new MappedInterceptor[] { mappedInterceptor });
HandlerExecutionChain chain = mapping.getHandlerExecutionChain(handler, new MockHttpServletRequest("GET", path));
@ -120,27 +142,21 @@ public class RequestMappingHandlerMethodMappingTests {
assertNull(chain.getInterceptors());
}
private static class MyRequestMappingHandlerMethodMapping extends RequestMappingHandlerMethodMapping {
@Override
public HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
return super.getHandlerInternal(request);
}
}
@SuppressWarnings("unused")
@Controller
private static class MyHandler {
private static class Handler {
@SuppressWarnings("unused")
@RequestMapping(value = "/foo", method = RequestMethod.GET)
public void foo() {
}
@RequestMapping(value = "/foo", method = RequestMethod.GET, params="p")
public void fooParam() {
}
@SuppressWarnings("unused")
@RequestMapping(value = "/ba*", method = { RequestMethod.GET, RequestMethod.HEAD })
public void bar() {
}
}
}
}

91
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ServletInvocableHandlerMethodTests.java
View File

@ -17,57 +17,124 @@
package org.springframework.web.servlet.mvc.method.annotation;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import java.lang.reflect.Method;
import javax.servlet.http.HttpServletResponse;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpStatus;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolverComposite;
import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
import org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite;
import org.springframework.web.method.support.ModelAndViewContainer;
import org.springframework.web.servlet.mvc.method.annotation.support.DefaultMethodReturnValueHandler;
import org.springframework.web.servlet.mvc.method.annotation.support.ServletResponseMethodArgumentResolver;
/**
* Test fixture for {@link ServletInvocableHandlerMethod} unit tests.
* Test fixture with {@link ServletInvocableHandlerMethod}.
*
* @author Rossen Stoyanchev
*/
public class ServletInvocableHandlerMethodTests {
private final Object handler = new Handler();
private HandlerMethodArgumentResolverComposite argumentResolvers;
private HandlerMethodReturnValueHandlerComposite returnValueHandlers;
private ModelAndViewContainer mavContainer;
private ServletWebRequest webRequest;
private MockHttpServletResponse response;
@Before
public void setUp() throws Exception {
returnValueHandlers = new HandlerMethodReturnValueHandlerComposite();
argumentResolvers = new HandlerMethodArgumentResolverComposite();
mavContainer = new ModelAndViewContainer();
response = new MockHttpServletResponse();
this.webRequest = new ServletWebRequest(new MockHttpServletRequest(), response);
webRequest = new ServletWebRequest(new MockHttpServletRequest(), response);
}
@Test
public void setResponseStatus() throws Exception {
HandlerMethodReturnValueHandlerComposite handlers = new HandlerMethodReturnValueHandlerComposite();
handlers.registerReturnValueHandler(new DefaultMethodReturnValueHandler(null));
returnValueHandlers.addHandler(new ExceptionThrowingReturnValueHandler());
handlerMethod("responseStatus").invokeAndHandle(webRequest, mavContainer);
Method method = Handler.class.getDeclaredMethod("responseStatus");
ServletInvocableHandlerMethod handlerMethod = new ServletInvocableHandlerMethod(new Handler(), method);
handlerMethod.setHandlerMethodReturnValueHandlers(handlers);
handlerMethod.invokeAndHandle(webRequest, new ModelAndViewContainer());
assertFalse("Null return value with an @ResponseStatus should result in 'no view resolution'",
mavContainer.isResolveView());
assertEquals(HttpStatus.BAD_REQUEST.value(), response.getStatus());
assertEquals("400 Bad Request", response.getErrorMessage());
}
@Test
public void checkNoViewResolutionWithHttpServletResponse() throws Exception {
argumentResolvers.addResolver(new ServletResponseMethodArgumentResolver());
returnValueHandlers.addHandler(new ExceptionThrowingReturnValueHandler());
handlerMethod("httpServletResponse", HttpServletResponse.class).invokeAndHandle(webRequest, mavContainer);
assertFalse("Null return value with an HttpServletResponse argument should result in 'no view resolution'",
mavContainer.isResolveView());
}
@Test
public void checkNoViewResolutionWithRequestNotModified() throws Exception {
returnValueHandlers.addHandler(new ExceptionThrowingReturnValueHandler());
webRequest.getNativeRequest(MockHttpServletRequest.class).addHeader("If-Modified-Since", 10 * 1000 * 1000);
int lastModifiedTimestamp = 1000 * 1000;
webRequest.checkNotModified(lastModifiedTimestamp);
handlerMethod("notModified").invokeAndHandle(webRequest, mavContainer);
assertFalse("Null return value with a 'not modified' request should result in 'no view resolution'",
mavContainer.isResolveView());
}
private ServletInvocableHandlerMethod handlerMethod(String methodName, Class<?>...paramTypes)
throws NoSuchMethodException {
Method method = handler.getClass().getDeclaredMethod(methodName, paramTypes);
ServletInvocableHandlerMethod handlerMethod = new ServletInvocableHandlerMethod(handler, method);
handlerMethod.setHandlerMethodArgumentResolvers(argumentResolvers);
handlerMethod.setHandlerMethodReturnValueHandlers(returnValueHandlers);
return handlerMethod;
}
private static class ExceptionThrowingReturnValueHandler implements HandlerMethodReturnValueHandler {
public boolean supportsReturnType(MethodParameter returnType) {
return true;
}
public void handleReturnValue(Object returnValue, MethodParameter returnType,
ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
throw new IllegalStateException("Should never be invoked");
}
}
@SuppressWarnings("unused")
private static class Handler {
@SuppressWarnings("unused")
@ResponseStatus(value = HttpStatus.BAD_REQUEST, reason = "400 Bad Request")
public void responseStatus() {
}
public void httpServletResponse(HttpServletResponse response) {
}
public void notModified() {
}
}
}
}

96
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandlerTests.java
View File

@ -16,10 +16,14 @@
package org.springframework.web.servlet.mvc.method.annotation.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
@ -27,11 +31,14 @@ import org.springframework.beans.TestBean;
import org.springframework.core.MethodParameter;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.ui.ExtendedModelMap;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.method.support.ModelAndViewContainer;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.annotation.ModelAndViewResolver;
/**
* Test fixture for {@link DefaultMethodReturnValueHandler} unit tests.
* Test fixture with {@link DefaultMethodReturnValueHandler}.
*
* @author Rossen Stoyanchev
*/
@ -39,53 +46,90 @@ public class DefaultMethodReturnValueHandlerTests {
private DefaultMethodReturnValueHandler handler;
private ServletWebRequest webRequest;
private List<ModelAndViewResolver> mavResolvers;
private ModelAndViewContainer mavContainer;
private ServletWebRequest request;
@Before
public void setUp() {
this.handler = new DefaultMethodReturnValueHandler(null);
this.mavContainer = new ModelAndViewContainer(new ExtendedModelMap());
this.webRequest = new ServletWebRequest(new MockHttpServletRequest());
}
@Test(expected=UnsupportedOperationException.class)
public void returnSimpleType() throws Exception {
handler.handleReturnValue(55, createMethodParam("simpleType"), mavContainer, webRequest);
mavResolvers = new ArrayList<ModelAndViewResolver>();
handler = new DefaultMethodReturnValueHandler(mavResolvers);
mavContainer = new ModelAndViewContainer(new ExtendedModelMap());
request = new ServletWebRequest(new MockHttpServletRequest());
}
@Test
public void returnVoid() throws Exception {
handler.handleReturnValue(null, null, mavContainer, webRequest);
public void modelAndViewResolver() throws Exception {
MethodParameter testBeanType = new MethodParameter(getClass().getDeclaredMethod("testBeanReturnValue"), -1);
mavResolvers.add(new TestModelAndViewResolver(TestBean.class));
TestBean testBean = new TestBean("name");
handler.handleReturnValue(testBean, testBeanType, mavContainer, request);
assertEquals("viewName", mavContainer.getViewName());
assertSame(testBean, mavContainer.getAttribute("modelAttrName"));
assertTrue(mavContainer.isResolveView());
}
@Test(expected=UnsupportedOperationException.class)
public void modelAndViewResolverUnresolved() throws Exception {
MethodParameter testBeanType = new MethodParameter(getClass().getDeclaredMethod("testBeanReturnValue"), -1);
mavResolvers.add(new TestModelAndViewResolver(TestBean.class));
handler.handleReturnValue(99, testBeanType, mavContainer, request);
}
@Test
public void handleNull() throws Exception {
handler.handleReturnValue(null, null, mavContainer, request);
assertNull(mavContainer.getView());
assertNull(mavContainer.getViewName());
assertTrue(mavContainer.getModel().isEmpty());
}
@Test(expected=UnsupportedOperationException.class)
public void handleSimpleType() throws Exception {
MethodParameter intType = new MethodParameter(getClass().getDeclaredMethod("intReturnValue"), -1);
handler.handleReturnValue(55, intType, mavContainer, request);
}
@Test
public void returnSingleModelAttribute() throws Exception{
handler.handleReturnValue(new TestBean(), createMethodParam("singleModelAttribute"), mavContainer, webRequest);
public void handleNonSimpleType() throws Exception{
MethodParameter testBeanType = new MethodParameter(getClass().getDeclaredMethod("testBeanReturnValue"), -1);
handler.handleReturnValue(new TestBean(), testBeanType, mavContainer, request);
assertTrue(mavContainer.containsAttribute("testBean"));
}
private MethodParameter createMethodParam(String methodName) throws Exception {
Method method = getClass().getDeclaredMethod(methodName);
return new MethodParameter(method, -1);
}
@SuppressWarnings("unused")
private int simpleType() {
private int intReturnValue() {
return 0;
}
@SuppressWarnings("unused")
private void voidReturnValue() {
}
@SuppressWarnings("unused")
private TestBean singleModelAttribute() {
private TestBean testBeanReturnValue() {
return null;
}
}
private static class TestModelAndViewResolver implements ModelAndViewResolver {
private Class<?> returnValueType;
public TestModelAndViewResolver(Class<?> returnValueType) {
this.returnValueType = returnValueType;
}
@SuppressWarnings("rawtypes")
public ModelAndView resolveModelAndView(Method method, Class handlerType, Object returnValue,
ExtendedModelMap model, NativeWebRequest request) {
if (returnValue != null && returnValue.getClass().equals(returnValueType)) {
return new ModelAndView("viewName", "modelAttrName", returnValue);
}
else {
return ModelAndViewResolver.UNRESOLVED;
}
}
}
}

141
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/HttpEntityMethodProcessorTests.java
View File

@ -16,6 +16,7 @@
package org.springframework.web.servlet.mvc.method.annotation.support;
import static org.easymock.EasyMock.capture;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.eq;
import static org.easymock.EasyMock.expect;
@ -25,12 +26,14 @@ import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.easymock.Capture;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.MethodParameter;
@ -42,17 +45,18 @@ import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.method.support.ModelAndViewContainer;
import org.springframework.web.servlet.mvc.method.annotation.support.HttpEntityMethodProcessor;
/**
* Test fixture with {@link HttpEntityMethodProcessor} and mock {@link HttpMessageConverter}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class HttpEntityMethodProcessorTests {
@ -60,26 +64,21 @@ public class HttpEntityMethodProcessorTests {
private HttpMessageConverter<String> messageConverter;
private MethodParameter httpEntityParam;
private MethodParameter responseEntityReturnValue;
private MethodParameter responseEntityParameter;
private MethodParameter intReturnValue;
private MethodParameter httpEntityReturnValue;
private MethodParameter intParameter;
private MethodParameter paramHttpEntity;
private MethodParameter paramResponseEntity;
private MethodParameter paramInt;
private MethodParameter returnTypeResponseEntity;
private MethodParameter returnTypeHttpEntity;
private MethodParameter returnTypeInt;
private ModelAndViewContainer mavContainer;
private ServletWebRequest request;
private MockHttpServletRequest servletRequest;
private ServletWebRequest webRequest;
private MockHttpServletResponse servletResponse;
private MockHttpServletRequest servletRequest;
@SuppressWarnings("unchecked")
@Before
public void setUp() throws Exception {
@ -90,95 +89,87 @@ public class HttpEntityMethodProcessorTests {
processor = new HttpEntityMethodProcessor(messageConverters);
Method handle1 = getClass().getMethod("handle1", HttpEntity.class, ResponseEntity.class, Integer.TYPE);
httpEntityParam = new MethodParameter(handle1, 0);
responseEntityParameter = new MethodParameter(handle1, 1);
intParameter = new MethodParameter(handle1, 2);
responseEntityReturnValue = new MethodParameter(handle1, -1);
paramHttpEntity = new MethodParameter(handle1, 0);
paramResponseEntity = new MethodParameter(handle1, 1);
paramInt = new MethodParameter(handle1, 2);
returnTypeResponseEntity = new MethodParameter(handle1, -1);
Method handle2 = getClass().getMethod("handle2", HttpEntity.class);
httpEntityReturnValue = new MethodParameter(handle2, -1);
Method other = getClass().getMethod("otherMethod");
intReturnValue = new MethodParameter(other, -1);
returnTypeHttpEntity = new MethodParameter(getClass().getMethod("handle2", HttpEntity.class), -1);
returnTypeInt = new MethodParameter(getClass().getMethod("handle3"), -1);
mavContainer = new ModelAndViewContainer();
servletRequest = new MockHttpServletRequest();
servletResponse = new MockHttpServletResponse();
request = new ServletWebRequest(servletRequest, servletResponse);
webRequest = new ServletWebRequest(servletRequest, servletResponse);
}
@Test
public void supportsParameter() {
assertTrue("HttpEntity parameter not supported", processor.supportsParameter(httpEntityParam));
assertFalse("ResponseEntity parameter supported", processor.supportsParameter(responseEntityParameter));
assertFalse("non-entity parameter supported", processor.supportsParameter(intParameter));
assertTrue("HttpEntity parameter not supported", processor.supportsParameter(paramHttpEntity));
assertFalse("ResponseEntity parameter supported", processor.supportsParameter(paramResponseEntity));
assertFalse("non-entity parameter supported", processor.supportsParameter(paramInt));
}
@Test
public void supportsReturnType() {
assertTrue("ResponseEntity return type not supported", processor.supportsReturnType(responseEntityReturnValue));
assertTrue("HttpEntity return type not supported", processor.supportsReturnType(httpEntityReturnValue));
assertFalse("non-ResponseBody return type supported", processor.supportsReturnType(intReturnValue));
assertTrue("ResponseEntity return type not supported", processor.supportsReturnType(returnTypeResponseEntity));
assertTrue("HttpEntity return type not supported", processor.supportsReturnType(returnTypeHttpEntity));
assertFalse("non-ResponseBody return type supported", processor.supportsReturnType(returnTypeInt));
}
@Test
@SuppressWarnings("unchecked")
public void resolveArgument() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
String expected = "Foo";
servletRequest.addHeader("Content-Type", contentType.toString());
String body = "Foo";
expect(messageConverter.getSupportedMediaTypes()).andReturn(Arrays.asList(contentType));
expect(messageConverter.canRead(String.class, contentType)).andReturn(true);
expect(messageConverter.read(eq(String.class), isA(HttpInputMessage.class))).andReturn(expected);
expect(messageConverter.read(eq(String.class), isA(HttpInputMessage.class))).andReturn(body);
replay(messageConverter);
HttpEntity<?> result = (HttpEntity<String>) processor.resolveArgument(httpEntityParam, mavContainer, request, null);
Object result = processor.resolveArgument(paramHttpEntity, mavContainer, webRequest, null);
assertTrue(result instanceof HttpEntity);
assertTrue("The ResolveView flag shouldn't change", mavContainer.isResolveView());
assertEquals("Invalid argument", expected, result.getBody());
assertEquals("Invalid argument", body, ((HttpEntity<?>) result).getBody());
verify(messageConverter);
}
@Test(expected = HttpMediaTypeNotSupportedException.class)
public void resolveArgumentNotReadable() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
expect(messageConverter.getSupportedMediaTypes()).andReturn(Arrays.asList(contentType));
expect(messageConverter.canRead(String.class, contentType)).andReturn(false);
replay(messageConverter);
processor.resolveArgument(httpEntityParam, mavContainer, request, null);
processor.resolveArgument(paramHttpEntity, mavContainer, webRequest, null);
assertTrue("The ResolveView flag shouldn't change", mavContainer.isResolveView());
verify(messageConverter);
fail("Expected exception");
}
@Test(expected = HttpMediaTypeNotSupportedException.class)
public void resolveArgumentNoContentType() throws Exception {
processor.resolveArgument(httpEntityParam, mavContainer, request, null);
processor.resolveArgument(paramHttpEntity, mavContainer, webRequest, null);
fail("Expected exception");
}
@Test
public void handleReturnValue() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
String s = "Foo";
ResponseEntity<String> returnValue = new ResponseEntity<String>(s, HttpStatus.OK);
String body = "Foo";
ResponseEntity<String> returnValue = new ResponseEntity<String>(body, HttpStatus.OK);
MediaType accepted = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
expect(messageConverter.canWrite(String.class, accepted)).andReturn(true);
messageConverter.write(eq(s), eq(accepted), isA(HttpOutputMessage.class));
messageConverter.write(eq(body), eq(accepted), isA(HttpOutputMessage.class));
replay(messageConverter);
processor.handleReturnValue(returnValue, responseEntityReturnValue, mavContainer, request);
processor.handleReturnValue(returnValue, returnTypeResponseEntity, mavContainer, webRequest);
assertFalse(mavContainer.isResolveView());
verify(messageConverter);
@ -186,36 +177,31 @@ public class HttpEntityMethodProcessorTests {
@Test(expected = HttpMediaTypeNotAcceptableException.class)
public void handleReturnValueNotAcceptable() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
String s = "Foo";
ResponseEntity<String> returnValue = new ResponseEntity<String>(s, HttpStatus.OK);
String body = "Foo";
ResponseEntity<String> returnValue = new ResponseEntity<String>(body, HttpStatus.OK);
MediaType accepted = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
expect(messageConverter.canWrite(String.class, accepted)).andReturn(false);
expect(messageConverter.getSupportedMediaTypes()).andReturn(Arrays.asList(MediaType.APPLICATION_OCTET_STREAM));
replay(messageConverter);
processor.handleReturnValue(returnValue, responseEntityReturnValue, mavContainer, request);
processor.handleReturnValue(returnValue, returnTypeResponseEntity, mavContainer, webRequest);
assertFalse(mavContainer.isResolveView());
verify(messageConverter);
fail("Expected exception");
}
@Test
public void responseHeaderNoBody() throws Exception {
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.set("header", "headerValue");
ResponseEntity<String> returnValue = new ResponseEntity<String>(responseHeaders, HttpStatus.ACCEPTED);
HttpHeaders headers = new HttpHeaders();
headers.set("headerName", "headerValue");
ResponseEntity<String> returnValue = new ResponseEntity<String>(headers, HttpStatus.ACCEPTED);
List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
messageConverters.add(new StringHttpMessageConverter());
HttpEntityMethodProcessor processor = new HttpEntityMethodProcessor(messageConverters);
processor.handleReturnValue(returnValue, responseEntityReturnValue, mavContainer, request);
processor.handleReturnValue(returnValue, returnTypeResponseEntity, mavContainer, webRequest);
assertFalse(mavContainer.isResolveView());
assertEquals("headerValue", servletResponse.getHeader("header"));
assertEquals("headerValue", servletResponse.getHeader("headerName"));
}
@Test
@ -224,13 +210,16 @@ public class HttpEntityMethodProcessorTests {
responseHeaders.set("header", "headerValue");
ResponseEntity<String> returnValue = new ResponseEntity<String>("body", responseHeaders, HttpStatus.ACCEPTED);
List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
messageConverters.add(new StringHttpMessageConverter());
HttpEntityMethodProcessor processor = new HttpEntityMethodProcessor(messageConverters);
processor.handleReturnValue(returnValue, responseEntityReturnValue, mavContainer, request);
Capture<HttpOutputMessage> outputMessage = new Capture<HttpOutputMessage>();
expect(messageConverter.canWrite(String.class, MediaType.ALL)).andReturn(true);
messageConverter.write(eq("body"), eq(MediaType.ALL), capture(outputMessage));
replay(messageConverter);
processor.handleReturnValue(returnValue, returnTypeResponseEntity, mavContainer, webRequest);
assertFalse(mavContainer.isResolveView());
assertEquals("headerValue", servletResponse.getHeader("header"));
assertEquals("headerValue", outputMessage.getValue().getHeaders().get("header").get(0));
verify(messageConverter);
}
public ResponseEntity<String> handle1(HttpEntity<String> httpEntity, ResponseEntity<String> responseEntity, int i) {
@ -241,14 +230,8 @@ public class HttpEntityMethodProcessorTests {
return entity;
}
public HttpEntity<?> handle3() {
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.set("header", "headerValue");
return new ResponseEntity<String>(responseHeaders, HttpStatus.OK);
}
public int otherMethod() {
public int handle3() {
return 42;
}
}
}

42
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/PathVariableMethodArgumentResolverTests.java
View File

@ -36,57 +36,57 @@ import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.servlet.mvc.method.annotation.support.PathVariableMethodArgumentResolver;
/**
* Test fixture with {@link PathVariableMethodArgumentResolver}.
*
* @author Rossen Stoyanchev
*/
public class PathVariableMethodArgumentResolverTests {
private PathVariableMethodArgumentResolver resolver;
private MethodParameter pathVarParam;
private MethodParameter paramNamedString;
private MethodParameter stringParam;
private MockHttpServletRequest servletRequest;
private MethodParameter paramString;
private ServletWebRequest webRequest;
private MockHttpServletRequest request;
@Before
public void setUp() throws Exception {
resolver = new PathVariableMethodArgumentResolver();
Method method = getClass().getMethod("handle", String.class, String.class);
pathVarParam = new MethodParameter(method, 0);
stringParam = new MethodParameter(method, 1);
servletRequest = new MockHttpServletRequest();
MockHttpServletResponse servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
Method method = getClass().getMethod("handle", String.class, String.class);
paramNamedString = new MethodParameter(method, 0);
paramString = new MethodParameter(method, 1);
request = new MockHttpServletRequest();
webRequest = new ServletWebRequest(request, new MockHttpServletResponse());
}
@Test
public void supportsParameter() {
assertTrue("Parameter with @PathVariable annotation", resolver.supportsParameter(pathVarParam));
assertFalse("Parameter without @PathVariable annotation", resolver.supportsParameter(stringParam));
assertTrue("Parameter with @PathVariable annotation", resolver.supportsParameter(paramNamedString));
assertFalse("Parameter without @PathVariable annotation", resolver.supportsParameter(paramString));
}
@Test
public void resolveStringArgument() throws Exception {
String expected = "foo";
Map<String, String> uriTemplateVars = new HashMap<String, String>();
uriTemplateVars.put("name", expected);
servletRequest.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);
uriTemplateVars.put("name", "value");
request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);
String result = (String) resolver.resolveArgument(pathVarParam, null, webRequest, null);
assertEquals(expected, result);
String result = (String) resolver.resolveArgument(paramNamedString, null, webRequest, null);
assertEquals("value", result);
}
@Test(expected = IllegalStateException.class)
public void handleMissingValue() throws Exception {
resolver.resolveArgument(pathVarParam, null, webRequest, null);
resolver.resolveArgument(paramNamedString, null, webRequest, null);
fail("Unresolved path variable should lead to exception.");
}
public void handle(@PathVariable(value = "name") String param1, String param2) {
}
}
}

79
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/RequestResponseBodyMethodProcessorTests.java
View File

@ -25,6 +25,7 @@ import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.lang.reflect.Method;
import java.util.ArrayList;
@ -49,7 +50,10 @@ import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.method.support.ModelAndViewContainer;
/**
* Test fixture with {@link RequestResponseBodyMethodProcessor} and mock {@link HttpMessageConverter}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class RequestResponseBodyMethodProcessorTests {
@ -57,13 +61,10 @@ public class RequestResponseBodyMethodProcessorTests {
private HttpMessageConverter<String> messageConverter;
private MethodParameter stringParameter;
private MethodParameter stringReturnValue;
private MethodParameter intParameter;
private MethodParameter intReturnValue;
private MethodParameter paramRequestBodyString;
private MethodParameter paramInt;
private MethodParameter returnTypeString;
private MethodParameter returnTypeInt;
private ModelAndViewContainer mavContainer;
@ -80,88 +81,80 @@ public class RequestResponseBodyMethodProcessorTests {
messageConverters.add(messageConverter);
processor = new RequestResponseBodyMethodProcessor(messageConverters);
Method handle = getClass().getMethod("handle", String.class, Integer.TYPE);
stringParameter = new MethodParameter(handle, 0);
intParameter = new MethodParameter(handle, 1);
stringReturnValue = new MethodParameter(handle, -1);
Method other = getClass().getMethod("otherMethod");
intReturnValue = new MethodParameter(other, -1);
Method handle = getClass().getMethod("handle1", String.class, Integer.TYPE);
paramRequestBodyString = new MethodParameter(handle, 0);
paramInt = new MethodParameter(handle, 1);
returnTypeString = new MethodParameter(handle, -1);
returnTypeInt = new MethodParameter(getClass().getMethod("handle2"), -1);
mavContainer = new ModelAndViewContainer();
servletRequest = new MockHttpServletRequest();
MockHttpServletResponse servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
webRequest = new ServletWebRequest(servletRequest, new MockHttpServletResponse());
}
@Test
public void supportsParameter() {
assertTrue("RequestBody parameter not supported", processor.supportsParameter(stringParameter));
assertFalse("non-RequestBody parameter supported", processor.supportsParameter(intParameter));
assertTrue("RequestBody parameter not supported", processor.supportsParameter(paramRequestBodyString));
assertFalse("non-RequestBody parameter supported", processor.supportsParameter(paramInt));
}
@Test
public void supportsReturnType() {
assertTrue("ResponseBody return type not supported", processor.supportsReturnType(stringReturnValue));
assertFalse("non-ResponseBody return type supported", processor.supportsReturnType(intReturnValue));
assertTrue("ResponseBody return type not supported", processor.supportsReturnType(returnTypeString));
assertFalse("non-ResponseBody return type supported", processor.supportsReturnType(returnTypeInt));
}
@Test
public void resolveArgument() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
String expected = "Foo";
servletRequest.addHeader("Content-Type", contentType.toString());
String body = "Foo";
expect(messageConverter.getSupportedMediaTypes()).andReturn(Arrays.asList(contentType));
expect(messageConverter.canRead(String.class, contentType)).andReturn(true);
expect(messageConverter.read(eq(String.class), isA(HttpInputMessage.class))).andReturn(expected);
expect(messageConverter.read(eq(String.class), isA(HttpInputMessage.class))).andReturn(body);
replay(messageConverter);
Object result = processor.resolveArgument(stringParameter, mavContainer, webRequest, null);
Object result = processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
assertEquals("Invalid argument", expected, result);
assertEquals("Invalid argument", body, result);
assertTrue("The ResolveView flag shouldn't change", mavContainer.isResolveView());
verify(messageConverter);
}
@Test(expected = HttpMediaTypeNotSupportedException.class)
public void resolveArgumentNotReadable() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
expect(messageConverter.getSupportedMediaTypes()).andReturn(Arrays.asList(contentType));
expect(messageConverter.canRead(String.class, contentType)).andReturn(false);
replay(messageConverter);
processor.resolveArgument(stringParameter, mavContainer, webRequest, null);
processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
assertTrue("The ResolveView flag shouldn't change", mavContainer.isResolveView());
verify(messageConverter);
fail("Expected exception");
}
@Test(expected = HttpMediaTypeNotSupportedException.class)
public void resolveArgumentNoContentType() throws Exception {
processor.resolveArgument(stringParameter, mavContainer, webRequest, null);
processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
fail("Expected exception");
}
@Test
public void handleReturnValue() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
String returnValue = "Foo";
servletRequest.addHeader("Accept", accepted.toString());
String body = "Foo";
expect(messageConverter.canWrite(String.class, accepted)).andReturn(true);
messageConverter.write(eq(returnValue), eq(accepted), isA(HttpOutputMessage.class));
messageConverter.write(eq(body), eq(accepted), isA(HttpOutputMessage.class));
replay(messageConverter);
processor.handleReturnValue(returnValue, stringReturnValue, mavContainer, webRequest);
processor.handleReturnValue(body, returnTypeString, mavContainer, webRequest);
assertFalse("The ResolveView flag wasn't turned off", mavContainer.isResolveView());
verify(messageConverter);
@ -170,28 +163,24 @@ public class RequestResponseBodyMethodProcessorTests {
@Test(expected = HttpMediaTypeNotAcceptableException.class)
public void handleReturnValueNotAcceptable() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
String returnValue = "Foo";
servletRequest.addHeader("Accept", accepted.toString());
expect(messageConverter.canWrite(String.class, accepted)).andReturn(false);
expect(messageConverter.getSupportedMediaTypes()).andReturn(Arrays.asList(MediaType.APPLICATION_OCTET_STREAM));
replay(messageConverter);
processor.handleReturnValue(returnValue, stringReturnValue, mavContainer, webRequest);
processor.handleReturnValue("Foo", returnTypeString, mavContainer, webRequest);
assertFalse("The ResolveView flag wasn't turned off", mavContainer.isResolveView());
verify(messageConverter);
fail("Expected exception");
}
@ResponseBody
public String handle(@RequestBody String s, int i) {
public String handle1(@RequestBody String s, int i) {
return s;
}
public int otherMethod() {
public int handle2() {
return 42;
}
}
}

53
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletCookieValueMethodArgumentResolverTests.java
View File

@ -17,8 +17,6 @@
package org.springframework.web.servlet.mvc.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;
@ -31,11 +29,12 @@ 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.ServletWebRequest;
import org.springframework.web.method.annotation.support.AbstractCookieValueMethodArgumentResolver;
import org.springframework.web.servlet.mvc.method.annotation.support.ServletCookieValueMethodArgumentResolver;
/**
* Test fixture with {@link ServletCookieValueMethodArgumentResolver}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class ServletCookieValueMethodArgumentResolverTests {
@ -45,37 +44,26 @@ public class ServletCookieValueMethodArgumentResolverTests {
private MethodParameter cookieStringParameter;
private MethodParameter otherParameter;
private MockHttpServletRequest servletRequest;
private ServletWebRequest webRequest;
private MockHttpServletRequest request;
@Before
public void setUp() throws Exception {
resolver = new ServletCookieValueMethodArgumentResolver(null);
Method method = getClass().getMethod("params", Cookie.class, String.class, String.class);
Method method = getClass().getMethod("params", Cookie.class, String.class);
cookieParameter = new MethodParameter(method, 0);
cookieStringParameter = new MethodParameter(method, 1);
otherParameter = new MethodParameter(method, 2);
servletRequest = new MockHttpServletRequest();
MockHttpServletResponse servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
}
@Test
public void supportsParameter() {
assertTrue("Cookie parameter not supported", resolver.supportsParameter(cookieParameter));
assertTrue("Cookie string parameter not supported", resolver.supportsParameter(cookieStringParameter));
assertFalse("non-@CookieValue parameter supported", resolver.supportsParameter(otherParameter));
request = new MockHttpServletRequest();
webRequest = new ServletWebRequest(request, new MockHttpServletResponse());
}
@Test
public void resolveCookieArgument() throws Exception {
Cookie expected = new Cookie("name", "foo");
servletRequest.setCookies(expected);
request.setCookies(expected);
Cookie result = (Cookie) resolver.resolveArgument(cookieParameter, null, webRequest, null);
assertEquals("Invalid result", expected, result);
@ -84,29 +72,14 @@ public class ServletCookieValueMethodArgumentResolverTests {
@Test
public void resolveCookieStringArgument() throws Exception {
Cookie cookie = new Cookie("name", "foo");
servletRequest.setCookies(cookie);
request.setCookies(cookie);
String result = (String) resolver.resolveArgument(cookieStringParameter, null, webRequest, null);
assertEquals("Invalid result", cookie.getValue(), result);
}
@Test
public void resolveCookieDefaultValue() throws Exception {
String result = (String) resolver.resolveArgument(cookieStringParameter, null, webRequest, null);
assertEquals("Invalid result", "bar", result);
}
@Test(expected = IllegalStateException.class)
public void notFound() throws Exception {
String result = (String) resolver.resolveArgument(cookieParameter, null, webRequest, null);
assertEquals("Invalid result", "bar", result);
}
public void params(@CookieValue("name") Cookie cookie,
@CookieValue(value = "name", defaultValue = "bar") String cookieString,
String unsupported) {
@CookieValue(value = "name", defaultValue = "bar") String cookieString) {
}
}
}

29
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletRequestMethodArgumentResolverTests.java
View File

@ -40,13 +40,16 @@ import org.springframework.web.servlet.mvc.method.annotation.support.ServletRequ
import static org.junit.Assert.*;
/**
* Test fixture with {@link ServletRequestMethodArgumentResolver}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public class ServletRequestMethodArgumentResolverTests {
private ServletRequestMethodArgumentResolver resolver;
private final ServletRequestMethodArgumentResolver resolver = new ServletRequestMethodArgumentResolver();
private Method supportedParams;
private Method method;
private ModelAndViewContainer mavContainer;
@ -56,10 +59,8 @@ public class ServletRequestMethodArgumentResolverTests {
@Before
public void setUp() throws Exception {
resolver = new ServletRequestMethodArgumentResolver();
supportedParams = getClass()
.getMethod("supportedParams", ServletRequest.class, MultipartRequest.class, HttpSession.class,
Principal.class, Locale.class, InputStream.class, Reader.class, WebRequest.class);
method = getClass().getMethod("supportedParams", ServletRequest.class, MultipartRequest.class,
HttpSession.class, Principal.class, Locale.class, InputStream.class, Reader.class, WebRequest.class);
mavContainer = new ModelAndViewContainer();
servletRequest = new MockHttpServletRequest();
webRequest = new ServletWebRequest(servletRequest, new MockHttpServletResponse());
@ -67,7 +68,7 @@ public class ServletRequestMethodArgumentResolverTests {
@Test
public void servletRequest() throws Exception {
MethodParameter servletRequestParameter = new MethodParameter(supportedParams, 0);
MethodParameter servletRequestParameter = new MethodParameter(method, 0);
boolean isSupported = resolver.supportsParameter(servletRequestParameter);
Object result = resolver.resolveArgument(servletRequestParameter, mavContainer, webRequest, null);
@ -81,7 +82,7 @@ public class ServletRequestMethodArgumentResolverTests {
public void session() throws Exception {
MockHttpSession session = new MockHttpSession();
servletRequest.setSession(session);
MethodParameter sessionParameter = new MethodParameter(supportedParams, 2);
MethodParameter sessionParameter = new MethodParameter(method, 2);
boolean isSupported = resolver.supportsParameter(sessionParameter);
Object result = resolver.resolveArgument(sessionParameter, mavContainer, webRequest, null);
@ -99,7 +100,7 @@ public class ServletRequestMethodArgumentResolverTests {
}
};
servletRequest.setUserPrincipal(principal);
MethodParameter principalParameter = new MethodParameter(supportedParams, 3);
MethodParameter principalParameter = new MethodParameter(method, 3);
assertTrue("Principal not supported", resolver.supportsParameter(principalParameter));
@ -111,7 +112,7 @@ public class ServletRequestMethodArgumentResolverTests {
public void locale() throws Exception {
Locale locale = Locale.ENGLISH;
servletRequest.addPreferredLocale(locale);
MethodParameter localeParameter = new MethodParameter(supportedParams, 4);
MethodParameter localeParameter = new MethodParameter(method, 4);
assertTrue("Locale not supported", resolver.supportsParameter(localeParameter));
@ -121,7 +122,7 @@ public class ServletRequestMethodArgumentResolverTests {
@Test
public void inputStream() throws Exception {
MethodParameter inputStreamParameter = new MethodParameter(supportedParams, 5);
MethodParameter inputStreamParameter = new MethodParameter(method, 5);
assertTrue("InputStream not supported", resolver.supportsParameter(inputStreamParameter));
@ -131,7 +132,7 @@ public class ServletRequestMethodArgumentResolverTests {
@Test
public void reader() throws Exception {
MethodParameter readerParameter = new MethodParameter(supportedParams, 6);
MethodParameter readerParameter = new MethodParameter(method, 6);
assertTrue("Reader not supported", resolver.supportsParameter(readerParameter));
@ -141,7 +142,7 @@ public class ServletRequestMethodArgumentResolverTests {
@Test
public void webRequest() throws Exception {
MethodParameter webRequestParameter = new MethodParameter(supportedParams, 7);
MethodParameter webRequestParameter = new MethodParameter(method, 7);
assertTrue("WebRequest not supported", resolver.supportsParameter(webRequestParameter));
@ -159,4 +160,4 @@ public class ServletRequestMethodArgumentResolverTests {
WebRequest p7) {
}
}
}

18
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletResponseMethodArgumentResolverTests.java
View File

@ -34,24 +34,26 @@ import org.springframework.web.servlet.mvc.method.annotation.support.ServletResp
import static org.junit.Assert.*;
/**
* Test fixture with {@link ServletRequestMethodArgumentResolver}.
*
* @author Arjen Poutsma
*/
public class ServletResponseMethodArgumentResolverTests {
private ServletResponseMethodArgumentResolver resolver;
private Method supportedParams;
private Method method;
private ModelAndViewContainer mavContainer;
private ServletWebRequest webRequest;
private MockHttpServletResponse servletResponse;
private ModelAndViewContainer mavContainer;
@Before
public void setUp() throws Exception {
resolver = new ServletResponseMethodArgumentResolver();
supportedParams = getClass().getMethod("supportedParams", ServletResponse.class, OutputStream.class, Writer.class);
method = getClass().getMethod("supportedParams", ServletResponse.class, OutputStream.class, Writer.class);
servletResponse = new MockHttpServletResponse();
mavContainer = new ModelAndViewContainer();
webRequest = new ServletWebRequest(new MockHttpServletRequest(), servletResponse);
@ -59,7 +61,7 @@ public class ServletResponseMethodArgumentResolverTests {
@Test
public void servletResponse() throws Exception {
MethodParameter servletResponseParameter = new MethodParameter(supportedParams, 0);
MethodParameter servletResponseParameter = new MethodParameter(method, 0);
assertTrue("ServletResponse not supported", resolver.supportsParameter(servletResponseParameter));
@ -70,7 +72,7 @@ public class ServletResponseMethodArgumentResolverTests {
@Test
public void outputStream() throws Exception {
MethodParameter outputStreamParameter = new MethodParameter(supportedParams, 1);
MethodParameter outputStreamParameter = new MethodParameter(method, 1);
assertTrue("OutputStream not supported", resolver.supportsParameter(outputStreamParameter));
@ -81,7 +83,7 @@ public class ServletResponseMethodArgumentResolverTests {
@Test
public void writer() throws Exception {
MethodParameter writerParameter = new MethodParameter(supportedParams, 2);
MethodParameter writerParameter = new MethodParameter(method, 2);
assertTrue("Writer not supported", resolver.supportsParameter(writerParameter));
@ -93,4 +95,4 @@ public class ServletResponseMethodArgumentResolverTests {
public void supportedParams(ServletResponse p0, OutputStream p1, Writer p2) {
}
}
}

14
org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ViewMethodReturnValueHandlerTests.java
View File

@ -35,7 +35,7 @@ import org.springframework.web.servlet.mvc.method.annotation.support.ViewMethodR
import org.springframework.web.servlet.view.InternalResourceView;
/**
* Test fixture for {@link DefaultMethodReturnValueHandler} unit tests.
* Test fixture with {@link DefaultMethodReturnValueHandler}.
*
* @author Rossen Stoyanchev
*/
@ -43,15 +43,15 @@ public class ViewMethodReturnValueHandlerTests {
private ViewMethodReturnValueHandler handler;
private ServletWebRequest webRequest;
private ModelAndViewContainer mavContainer;
private ServletWebRequest webRequest;
@Before
public void setUp() {
this.handler = new ViewMethodReturnValueHandler();
this.mavContainer = new ModelAndViewContainer(new ExtendedModelMap());
this.webRequest = new ServletWebRequest(new MockHttpServletRequest());
handler = new ViewMethodReturnValueHandler();
mavContainer = new ModelAndViewContainer(new ExtendedModelMap());
webRequest = new ServletWebRequest(new MockHttpServletRequest());
}
@Test
@ -88,4 +88,4 @@ public class ViewMethodReturnValueHandlerTests {
return null;
}
}
}

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;
}
}