diff --git a/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapter.java b/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapter.java index 363d0a5e4e..e5679f1b7c 100644 --- a/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapter.java +++ b/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapter.java @@ -121,13 +121,11 @@ import org.springframework.web.util.WebUtils; public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware, InitializingBean { - private final List customArgumentResolvers = - new ArrayList(); + private List customArgumentResolvers; - private final List customReturnValueHandlers = - new ArrayList(); + private List customReturnValueHandlers; - private final List modelAndViewResolvers = new ArrayList(); + private List modelAndViewResolvers; private List> messageConverters; @@ -179,9 +177,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda * or preferably converted to a {@link HandlerMethodArgumentResolver} instead. */ public void setCustomArgumentResolvers(List argumentResolvers) { - if (argumentResolvers != null) { - this.customArgumentResolvers.addAll(argumentResolvers); - } + this.customArgumentResolvers = argumentResolvers; } /** @@ -193,7 +189,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda public void setArgumentResolvers(List 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 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 returnValueHandlers) { - if (returnValueHandlers != null) { - this.customReturnValueHandlers.addAll(returnValueHandlers); - } + this.customReturnValueHandlers = returnValueHandlers; } /** @@ -231,7 +225,7 @@ public class RequestMappingHandlerMethodAdapter extends AbstractHandlerMethodAda public void setReturnValueHandlers(List 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 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 argumentResolvers) { - for (HandlerMethodArgumentResolver resolver : argumentResolvers) { - this.argumentResolvers.registerArgumentResolver(resolver); - } - } - - private void registerInitBinderArgumentResolvers(List argumentResolvers) { - for (HandlerMethodArgumentResolver resolver : argumentResolvers) { - this.initBinderArgumentResolvers.registerArgumentResolver(resolver); - } - } - - private void registerReturnValueHandlers(List 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 resolvers = new ArrayList(); + // Annotation-based resolvers resolvers.add(new RequestParamMethodArgumentResolver(beanFactory, false)); resolvers.add(new RequestParamMapMethodArgumentResolver()); resolvers.add(new PathVariableMethodArgumentResolver()); diff --git a/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolver.java b/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolver.java index 426760eb9f..683da2a81e 100644 --- a/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolver.java +++ b/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolver.java @@ -82,11 +82,9 @@ import org.springframework.web.servlet.mvc.method.annotation.support.ViewMethodR public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandlerMethodExceptionResolver implements InitializingBean { - private final List customArgumentResolvers = - new ArrayList(); + private List customArgumentResolvers; - private final List customReturnValueHandlers = - new ArrayList(); + private List customReturnValueHandlers; private List> messageConverters; @@ -119,9 +117,7 @@ public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandle * or preferably converted to a {@link HandlerMethodArgumentResolver} instead. */ public void setCustomArgumentResolvers(List argumentResolvers) { - if (argumentResolvers != null) { - this.customArgumentResolvers.addAll(argumentResolvers); - } + this.customArgumentResolvers= argumentResolvers; } /** @@ -133,7 +129,7 @@ public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandle public void setArgumentResolvers(List 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 returnValueHandlers) { - if (returnValueHandlers != null) { - this.customReturnValueHandlers.addAll(returnValueHandlers); - } + this.customReturnValueHandlers = returnValueHandlers; } /** @@ -158,7 +152,7 @@ public class RequestMappingHandlerMethodExceptionResolver extends AbstractHandle public void setReturnValueHandlers(List 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 argumentResolvers) { - for (HandlerMethodArgumentResolver resolver : argumentResolvers) { - this.argumentResolvers.registerArgumentResolver(resolver); - } - } - - private void registerReturnValueHandlers(List returnValueHandlers) { - for (HandlerMethodReturnValueHandler handler : returnValueHandlers) { - this.returnValueHandlers.registerReturnValueHandler(handler); + returnValueHandlers.addHandlers(customReturnValueHandlers); + returnValueHandlers.addHandlers(getDefaultReturnValueHandlers(messageConverters)); } } diff --git a/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandler.java b/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandler.java index 304126364d..4297751f74 100644 --- a/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandler.java +++ b/org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandler.java @@ -52,7 +52,7 @@ import org.springframework.web.servlet.mvc.annotation.ModelAndViewResolver; */ public class DefaultMethodReturnValueHandler implements HandlerMethodReturnValueHandler { - private final List modelAndViewResolvers = new ArrayList(); + private final List 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 modelAndViewResolvers) { - if (modelAndViewResolvers != null) { - this.modelAndViewResolvers.addAll(modelAndViewResolvers); - } + public DefaultMethodReturnValueHandler(List 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 } } -} +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/MvcAnnotationDrivenFeatureTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/MvcAnnotationDrivenFeatureTests.java index 13e8abd271..21fb0ae64f 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/MvcAnnotationDrivenFeatureTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/MvcAnnotationDrivenFeatureTests.java @@ -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; diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/handler/HandlerMethodMappingTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/handler/HandlerMethodMappingTests.java index 35011ed822..e8128ae9d5 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/handler/HandlerMethodMappingTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/handler/HandlerMethodMappingTests.java @@ -131,4 +131,4 @@ public class HandlerMethodMappingTests { public void handlerMethod2() { } } -} +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ControllerMethodAnnotationDetectionTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HandlerMethodAdapterAnnotationDetectionTests.java similarity index 95% rename from org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ControllerMethodAnnotationDetectionTests.java rename to org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HandlerMethodAdapterAnnotationDetectionTests.java index 9ff6236aaa..595c30818a 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ControllerMethodAnnotationDetectionTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HandlerMethodAdapterAnnotationDetectionTests.java @@ -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 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 methods = HandlerMethodSelector.selectMethods(handlerType, REQUEST_MAPPING_METHODS); diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodDetectionTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HandlerMethodMappingAnnotationDetectionTests.java similarity index 86% rename from org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodDetectionTests.java rename to org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HandlerMethodMappingAnnotationDetectionTests.java index f9638a5560..c89a8614f3 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodDetectionTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HandlerMethodMappingAnnotationDetectionTests.java @@ -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 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 diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyComparatorTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyComparatorTests.java index 8147319b3e..6c91865eae 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyComparatorTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyComparatorTests.java @@ -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); } -} + +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyTests.java index 946ba9f7c2..18f39a3e09 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestKeyTests.java @@ -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); } -} +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterIntegrationTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterIntegrationTests.java index b425782b02..524ed59be2 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterIntegrationTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterIntegrationTests.java @@ -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. * - *

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. - * - *

The following integration tests for detecting annotations on super types, parameterized - * methods, and proxies may also be of interest: + *

If you wish to add high-level tests, consider the following other "integration"-style tests: *

    - *
  • {@link RequestMappingHandlerMethodDetectionTests} - *
  • {@link ControllerMethodAnnotationDetectionTests} + *
  • {@link HandlerMethodAdapterAnnotationDetectionTests} + *
  • {@link HandlerMethodMappingAnnotationDetectionTests} + *
  • {@link ServletHandlerMethodTests} *
* * @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 customResolvers = new ArrayList(); 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 uriTemplateVars = new HashMap(); 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 handleHttpEntity(HttpEntity httpEntity) throws Exception { HttpHeaders responseHeaders = new HttpHeaders(); responseHeaders.set("header", "headerValue"); @@ -352,4 +347,5 @@ public class RequestMappingHandlerMethodAdapterIntegrationTests { return "other user"; } } -} + +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterTests.java index 7f506f5f01..1e07e21983 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodAdapterTests.java @@ -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. + *

For higher-level adapter tests see: + *

    + *
  • {@link ServletHandlerMethodTests} + *
  • {@link RequestMappingHandlerMethodAdapterIntegrationTests} + *
  • {@link HandlerMethodAdapterAnnotationDetectionTests} + *
* * @author Rossen Stoyanchev */ @@ -94,4 +95,5 @@ public class RequestMappingHandlerMethodAdapterTests { public void handle() { } } -} + +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolverTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolverTests.java index 76a27042a5..435785d401 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolverTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodExceptionResolverTests.java @@ -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 { } } -} +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodMappingTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodMappingTests.java index eccb29afe1..2fcbd3f455 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodMappingTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerMethodMappingTests.java @@ -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() { } - } - -} + +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ServletInvocableHandlerMethodTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ServletInvocableHandlerMethodTests.java index cc716c093d..ff22e8bf78 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ServletInvocableHandlerMethodTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ServletInvocableHandlerMethodTests.java @@ -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() { + } } -} + +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandlerTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandlerTests.java index 5237bf88f5..8cc2386719 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandlerTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/DefaultMethodReturnValueHandlerTests.java @@ -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 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(); + 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; + } + } + } +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/HttpEntityMethodProcessorTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/HttpEntityMethodProcessorTests.java index cdfb90c8a7..c781b65fb7 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/HttpEntityMethodProcessorTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/HttpEntityMethodProcessorTests.java @@ -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 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) 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 returnValue = new ResponseEntity(s, HttpStatus.OK); + String body = "Foo"; + ResponseEntity returnValue = new ResponseEntity(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 returnValue = new ResponseEntity(s, HttpStatus.OK); + String body = "Foo"; + ResponseEntity returnValue = new ResponseEntity(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 returnValue = new ResponseEntity(responseHeaders, HttpStatus.ACCEPTED); + HttpHeaders headers = new HttpHeaders(); + headers.set("headerName", "headerValue"); + ResponseEntity returnValue = new ResponseEntity(headers, HttpStatus.ACCEPTED); - List> messageConverters = new ArrayList>(); - 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 returnValue = new ResponseEntity("body", responseHeaders, HttpStatus.ACCEPTED); - List> messageConverters = new ArrayList>(); - messageConverters.add(new StringHttpMessageConverter()); - HttpEntityMethodProcessor processor = new HttpEntityMethodProcessor(messageConverters); - processor.handleReturnValue(returnValue, responseEntityReturnValue, mavContainer, request); + Capture outputMessage = new Capture(); + 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 handle1(HttpEntity httpEntity, ResponseEntity 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(responseHeaders, HttpStatus.OK); - } - - public int otherMethod() { + public int handle3() { return 42; } -} +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/PathVariableMethodArgumentResolverTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/PathVariableMethodArgumentResolverTests.java index bf6a06d373..f5679e160a 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/PathVariableMethodArgumentResolverTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/PathVariableMethodArgumentResolverTests.java @@ -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 uriTemplateVars = new HashMap(); - 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) { } - -} + +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/RequestResponseBodyMethodProcessorTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/RequestResponseBodyMethodProcessorTests.java index 4c770f6539..f050b7f929 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/RequestResponseBodyMethodProcessorTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/RequestResponseBodyMethodProcessorTests.java @@ -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 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; } -} +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletCookieValueMethodArgumentResolverTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletCookieValueMethodArgumentResolverTests.java index 9a07b80ff0..a672b4567e 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletCookieValueMethodArgumentResolverTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletCookieValueMethodArgumentResolverTests.java @@ -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) { } - -} +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletRequestMethodArgumentResolverTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletRequestMethodArgumentResolverTests.java index ebdadb211e..4bc0352ce2 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletRequestMethodArgumentResolverTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletRequestMethodArgumentResolverTests.java @@ -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) { } -} +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletResponseMethodArgumentResolverTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletResponseMethodArgumentResolverTests.java index 059f6d6833..f53ad820f0 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletResponseMethodArgumentResolverTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ServletResponseMethodArgumentResolverTests.java @@ -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) { } -} +} \ No newline at end of file diff --git a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ViewMethodReturnValueHandlerTests.java b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ViewMethodReturnValueHandlerTests.java index 2ff7d7c6ce..088e3e9810 100644 --- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ViewMethodReturnValueHandlerTests.java +++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/mvc/method/annotation/support/ViewMethodReturnValueHandlerTests.java @@ -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; } -} +} \ No newline at end of file diff --git a/org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodArgumentResolverComposite.java b/org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodArgumentResolverComposite.java index 4b1797eaae..4cd0531996 100644 --- a/org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodArgumentResolverComposite.java +++ b/org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodArgumentResolverComposite.java @@ -43,7 +43,7 @@ public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgu private final Map argumentResolverCache = new ConcurrentHashMap(); - + /** * 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 argumentResolvers) { + if (argumentResolvers != null) { + for (HandlerMethodArgumentResolver resolver : argumentResolvers) { + this.argumentResolvers.add(resolver); + } + } + } + } \ No newline at end of file diff --git a/org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerComposite.java b/org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerComposite.java index ea0f4b7775..bc813a1c82 100644 --- a/org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerComposite.java +++ b/org.springframework.web/src/main/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerComposite.java @@ -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 returnValueHandlers) { + if (returnValueHandlers != null) { + for (HandlerMethodReturnValueHandler handler : returnValueHandlers) { + this.returnValueHandlers.add(handler); + } + } + } + } \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/HandlerSessionAttributeStoreTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/HandlerSessionAttributeStoreTests.java index d7f953c276..5dfba5a935 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/HandlerSessionAttributeStoreTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/HandlerSessionAttributeStoreTests.java @@ -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 attributes = handlerSessionAttributes.retrieveHandlerSessionAttributes(request); + Map attributes = sessionAttributesHandler.retrieveHandlerSessionAttributes(request); assertEquals(new HashSet(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 attributes = new HashMap(); - 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 { } -} + +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/InitBinderMethodDataBinderFactoryTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/InitBinderMethodDataBinderFactoryTests.java index d14ab061fd..0876d9e0c2 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/InitBinderMethodDataBinderFactoryTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/InitBinderMethodDataBinderFactoryTests.java @@ -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 { } } -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/ModelFactoryTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/ModelFactoryTests.java index a0570a4b92..7ab27f0540 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/ModelFactoryTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/ModelFactoryTests.java @@ -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") diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/CookieValueMethodArgumentResolverTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/CookieValueMethodArgumentResolverTests.java new file mode 100644 index 0000000000..9080322188 --- /dev/null +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/CookieValueMethodArgumentResolverTests.java @@ -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) { + } + +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ErrorsMethodHandlerArgumentResolverTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ErrorsMethodHandlerArgumentResolverTests.java index 33b437fa6b..496e521ec1 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ErrorsMethodHandlerArgumentResolverTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ErrorsMethodHandlerArgumentResolverTests.java @@ -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) { } -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ExpressionValueMethodArgumentResolverTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ExpressionValueMethodArgumentResolverTests.java index 256a09d823..f32c6c2940 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ExpressionValueMethodArgumentResolverTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ExpressionValueMethodArgumentResolverTests.java @@ -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) { } -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelAttributeMethodProcessorTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelAttributeMethodProcessorTests.java index 622017ee9f..02eb152ae7 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelAttributeMethodProcessorTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelAttributeMethodProcessorTests.java @@ -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; + } -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelMethodProcessorTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelMethodProcessorTests.java index d904c528fa..fa830f1057 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelMethodProcessorTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelMethodProcessorTests.java @@ -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 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 map(Map map) { return null; } -} + +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMapMethodArgumentResolverTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMapMethodArgumentResolverTests.java index 48fd3e7784..2d96566617 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMapMethodArgumentResolverTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMapMethodArgumentResolverTests.java @@ -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 expected = Collections.singletonMap(headerName, headerValue); - servletRequest.addHeader(headerName, headerValue); + String name = "foo"; + String value = "bar"; + Map expected = Collections.singletonMap(name, value); + request.addHeader(name, value); - Map result = (Map) 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 expected = new LinkedMultiValueMap(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 result = - (MultiValueMap) resolver.resolveArgument(multiValueMapParameter, null, webRequest, null); + request.addHeader(name, value1); + request.addHeader(name, value2); + + MultiValueMap expected = new LinkedMultiValueMap(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) { - } - -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMethodArgumentResolverTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMethodArgumentResolverTests.java index 23ec0101cc..015ec38ac5 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMethodArgumentResolverTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestHeaderMethodArgumentResolverTests.java @@ -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) { } -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMapMethodArgumentResolverTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMapMethodArgumentResolverTests.java index c77f532244..9dce83f453 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMapMethodArgumentResolverTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMapMethodArgumentResolverTests.java @@ -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 expected = Collections.singletonMap(headerName, headerValue); - servletRequest.addParameter(headerName, headerValue); + String name = "foo"; + String value = "bar"; + request.addParameter(name, value); + Map expected = Collections.singletonMap(name, value); - Map result = (Map) 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 expected = new LinkedMultiValueMap(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 result = - (MultiValueMap) 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) { } - -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMethodArgumentResolverTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMethodArgumentResolverTests.java index cd0bd5b703..94368d00c1 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMethodArgumentResolverTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/RequestParamMethodArgumentResolverTests.java @@ -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) { } } diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/WebArgumentResolverAdapterTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/WebArgumentResolverAdapterTests.java index ec90e88bef..23fe296ab9 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/WebArgumentResolverAdapterTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/WebArgumentResolverAdapterTests.java @@ -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 { } } -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodArgumentResolverCompositeTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodArgumentResolverCompositeTests.java index 5e397f2ba7..22940cab17 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodArgumentResolverCompositeTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodArgumentResolverCompositeTests.java @@ -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) { } -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerCompositeTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerCompositeTests.java index 11308f3ea0..ac1a6d6a04 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerCompositeTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/support/HandlerMethodReturnValueHandlerCompositeTests.java @@ -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; } -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/support/InvocableHandlerMethodTests.java b/org.springframework.web/src/test/java/org/springframework/web/method/support/InvocableHandlerMethodTests.java index d3c73ae1b0..97b11b8dc0 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/support/InvocableHandlerMethodTests.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/support/InvocableHandlerMethodTests.java @@ -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 ""; - } } + } diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/support/StubArgumentResolver.java b/org.springframework.web/src/test/java/org/springframework/web/method/support/StubArgumentResolver.java index ebf282ee9f..c3c6a1904d 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/support/StubArgumentResolver.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/support/StubArgumentResolver.java @@ -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 resolvedParameters = new ArrayList(); - 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 getResolvedParameterNames() { + public List 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; } - -} +} \ No newline at end of file diff --git a/org.springframework.web/src/test/java/org/springframework/web/method/support/StubReturnValueHandler.java b/org.springframework.web/src/test/java/org/springframework/web/method/support/StubReturnValueHandler.java index 2ae5ce4836..61717c659a 100644 --- a/org.springframework.web/src/test/java/org/springframework/web/method/support/StubReturnValueHandler.java +++ b/org.springframework.web/src/test/java/org/springframework/web/method/support/StubReturnValueHandler.java @@ -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; - } }