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

SPR-8214 review unit tests

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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