SPR-8454 Introduce Registration style objects, rename several Spring MVC *Configurer helpers to *Registry, add more tests

2011-06-15 08:06:42 +00:00
parent 889f8886f6
commit ab033086f9
23 changed files with 1101 additions and 767 deletions
--- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/AnnotationDrivenBeanDefinitionParserTests.java
+++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/AnnotationDrivenBeanDefinitionParserTests.java
@@ -62,7 +62,7 @@ public class AnnotationDrivenBeanDefinitionParserTests {
 		loadBeanDefinitions("mvc-config-message-codes-resolver.xml");
 		RequestMappingHandlerAdapter adapter = appContext.getBean(RequestMappingHandlerAdapter.class);
 		assertNotNull(adapter);
-		Object initializer = new DirectFieldAccessor(adapter).getPropertyValue("webBindingInitializer");
+		Object initializer = adapter.getWebBindingInitializer();
 		assertNotNull(initializer);
 		MessageCodesResolver resolver = ((ConfigurableWebBindingInitializer) initializer).getMessageCodesResolver();
 		assertNotNull(resolver);
--- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/DefaultServletHandlerConfigurerTests.java
+++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/DefaultServletHandlerConfigurerTests.java
@@ -18,7 +18,7 @@ package org.springframework.web.servlet.config.annotation;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertNull;

 import javax.servlet.RequestDispatcher;

@@ -53,13 +53,14 @@ public class DefaultServletHandlerConfigurerTests {

 	@Test
 	public void notEnabled() {
-		assertTrue(configurer.getHandlerMapping().getUrlMap().isEmpty());
+		assertNull(configurer.getHandlerMapping());
 	}

 	@Test
 	public void enable() throws Exception {
 		configurer.enable();
-		SimpleUrlHandlerMapping handlerMapping = configurer.getHandlerMapping();
+		SimpleUrlHandlerMapping getHandlerMapping = getHandlerMapping();
+		SimpleUrlHandlerMapping handlerMapping = getHandlerMapping;
 		DefaultServletHttpRequestHandler handler = (DefaultServletHttpRequestHandler) handlerMapping.getUrlMap().get("/**");

 		assertNotNull(handler);
@@ -75,7 +76,7 @@ public class DefaultServletHandlerConfigurerTests {
 	@Test
 	public void enableWithServletName() throws Exception {
 		configurer.enable("defaultServlet");
-		SimpleUrlHandlerMapping handlerMapping = configurer.getHandlerMapping();
+		SimpleUrlHandlerMapping handlerMapping = getHandlerMapping();
 		DefaultServletHttpRequestHandler handler = (DefaultServletHttpRequestHandler) handlerMapping.getUrlMap().get("/**");

 		assertNotNull(handler);
@@ -99,4 +100,8 @@ public class DefaultServletHandlerConfigurerTests {
 		}
 	}

+	private SimpleUrlHandlerMapping getHandlerMapping() {
+		return (SimpleUrlHandlerMapping) configurer.getHandlerMapping();
+	}
+
 }
--- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/DelegatingWebMvcConfigurationTests.java
+++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/DelegatingWebMvcConfigurationTests.java
@@ -18,11 +18,9 @@ package org.springframework.web.servlet.config.annotation;

 import static org.easymock.EasyMock.capture;
 import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.isA;
 import static org.easymock.EasyMock.replay;
 import static org.easymock.EasyMock.verify;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;

@@ -30,8 +28,6 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

-import javax.servlet.http.HttpServletRequest;
-
 import org.easymock.Capture;
 import org.easymock.EasyMock;
 import org.junit.Before;
@@ -39,29 +35,23 @@ import org.junit.Test;
 import org.springframework.format.support.FormattingConversionService;
 import org.springframework.http.converter.HttpMessageConverter;
 import org.springframework.http.converter.StringHttpMessageConverter;
-import org.springframework.mock.web.MockHttpServletRequest;
-import org.springframework.stereotype.Controller;
 import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
-import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
-import org.springframework.web.context.support.StaticWebApplicationContext;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
 import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
 import org.springframework.web.servlet.HandlerExceptionResolver;
-import org.springframework.web.servlet.HandlerExecutionChain;
 import org.springframework.web.servlet.handler.HandlerExceptionResolverComposite;
 import org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver;
 import org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver;
 import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
-import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
 import org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver;

 /**
- * A test fixture for WebMvcConfiguration tests.
+ * A test fixture for {@link DelegatingWebMvcConfiguration} tests.
 *
 * @author Rossen Stoyanchev
 */
-public class WebMvcConfigurationTests {
+public class DelegatingWebMvcConfigurationTests {

 	private DelegatingWebMvcConfiguration mvcConfiguration;

@@ -74,7 +64,7 @@ public class WebMvcConfigurationTests {
 	}

 	@Test
-	public void annotationHandlerAdapter() throws Exception {
+	public void requestMappingHandlerAdapter() throws Exception {
 		Capture<List<HttpMessageConverter<?>>> converters = new Capture<List<HttpMessageConverter<?>>>();
 		Capture<FormattingConversionService> conversionService = new Capture<FormattingConversionService>();
 		Capture<List<HandlerMethodArgumentResolver>> resolvers = new Capture<List<HandlerMethodArgumentResolver>>();
@@ -96,7 +86,6 @@ public class WebMvcConfigurationTests {

 		assertEquals(0, resolvers.getValue().size());
 		assertEquals(0, handlers.getValue().size());
-		assertTrue(converters.getValue().size() > 0);
 		assertEquals(converters.getValue(), adapter.getMessageConverters());

 		verify(configurer);
@@ -104,9 +93,6 @@ public class WebMvcConfigurationTests {

 	@Test 
 	public void configureMessageConverters() {
-		RequestMappingHandlerAdapter adapter = mvcConfiguration.requestMappingHandlerAdapter();
-		assertTrue("There should be at least two default converters ", adapter.getMessageConverters().size() > 1);
-
 		List<WebMvcConfigurer> configurers = new ArrayList<WebMvcConfigurer>();
 		configurers.add(new WebMvcConfigurerAdapter() {
 			@Override
@@ -117,7 +103,7 @@ public class WebMvcConfigurationTests {
 		mvcConfiguration = new DelegatingWebMvcConfiguration();
 		mvcConfiguration.setConfigurers(configurers);
 		
-		adapter = mvcConfiguration.requestMappingHandlerAdapter();
+		RequestMappingHandlerAdapter adapter = mvcConfiguration.requestMappingHandlerAdapter();
 		assertEquals("Only one custom converter should be registered", 1, adapter.getMessageConverters().size());
 	}
 	
@@ -132,17 +118,6 @@ public class WebMvcConfigurationTests {
 		verify(configurer);
 	}

-	@Test
-	public void configureValidator() {
-		expect(configurer.getValidator()).andReturn(null);
-		replay(configurer);
-
-		mvcConfiguration.setConfigurers(Arrays.asList(configurer));
-		mvcConfiguration.mvcValidator();
-
-		verify(configurer);
-	}
-
 	@Test
 	public void handlerExceptionResolver() throws Exception {
 		Capture<List<HttpMessageConverter<?>>> converters = new Capture<List<HttpMessageConverter<?>>>();
@@ -166,11 +141,6 @@ public class WebMvcConfigurationTests {

 	@Test 
 	public void configureExceptionResolvers() throws Exception {
-		HandlerExceptionResolverComposite composite;
-		
-		composite = (HandlerExceptionResolverComposite) mvcConfiguration.handlerExceptionResolver();
-		assertTrue("Expected more than one exception resolver by default", composite.getExceptionResolvers().size() > 1);
-		
 		List<WebMvcConfigurer> configurers = new ArrayList<WebMvcConfigurer>();
 		configurers.add(new WebMvcConfigurerAdapter() {
 			@Override
@@ -180,32 +150,9 @@ public class WebMvcConfigurationTests {
 		});
 		mvcConfiguration.setConfigurers(configurers);
 		
-		composite = (HandlerExceptionResolverComposite) mvcConfiguration.handlerExceptionResolver();
+		HandlerExceptionResolverComposite composite = 
+			(HandlerExceptionResolverComposite) mvcConfiguration.handlerExceptionResolver();
 		assertEquals("Only one custom converter is expected", 1, composite.getExceptionResolvers().size());
 	}
 	
-	@Test
-	public void configureInterceptors() throws Exception {
-		HttpServletRequest request = new MockHttpServletRequest("GET", "/");
-		
-		StaticWebApplicationContext context = new StaticWebApplicationContext();
-		context.registerSingleton("controller", TestHandler.class);
-		
-		RequestMappingHandlerMapping hm = mvcConfiguration.requestMappingHandlerMapping();
-		hm.setApplicationContext(context);
-		HandlerExecutionChain chain = hm.getHandler(request);
-		assertNotNull("No chain returned", chain);
-		assertNotNull("Expected at least one default converter", chain.getInterceptors());
-	}
-	
-	@Controller
-	private static class TestHandler {
-		
-		@SuppressWarnings("unused")
-		@RequestMapping("/")
-		public void handle() {
-		}
-		
-	}
-	
 }
--- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/InterceptorConfigurerTests.java
+++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/InterceptorConfigurerTests.java
@@ -40,14 +40,14 @@ import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
 import org.springframework.web.servlet.theme.ThemeChangeInterceptor;

 /**
- * Test fixture with a {@link InterceptorConfigurer}, two {@link HandlerInterceptor}s and two
+ * Test fixture with a {@link InterceptorRegistry}, two {@link HandlerInterceptor}s and two
 * {@link WebRequestInterceptor}s.
 *
 * @author Rossen Stoyanchev
 */
-public class InterceptorConfigurerTests {
+public class InterceptorRegistryTests {

-	private InterceptorConfigurer configurer;
+	private InterceptorRegistry registry;

 	private final HandlerInterceptor interceptor1 = new LocaleChangeInterceptor();

@@ -63,54 +63,50 @@ public class InterceptorConfigurerTests {

 	@Before
 	public void setUp() {
-		configurer = new InterceptorConfigurer();
+		registry = new InterceptorRegistry();
 		webRequestInterceptor1 = new TestWebRequestInterceptor();
 		webRequestInterceptor2 = new TestWebRequestInterceptor();
 	}

 	@Test
 	public void addInterceptor() {
-		configurer.addInterceptor(interceptor1);
+		registry.addInterceptor(interceptor1);
 		List<HandlerInterceptor> interceptors = getInterceptorsForPath(null);
+		
 		assertEquals(Arrays.asList(interceptor1), interceptors);
 	}

 	@Test
-	public void addInterceptors() {
-		configurer.addInterceptors(interceptor1, interceptor2);
+	public void addTwoInterceptors() {
+		registry.addInterceptor(interceptor1);
+		registry.addInterceptor(interceptor2);
 		List<HandlerInterceptor> interceptors = getInterceptorsForPath(null);
+		
 		assertEquals(Arrays.asList(interceptor1, interceptor2), interceptors);
 	}

 	@Test
-	public void mapInterceptor() {
-		configurer.mapInterceptor(new String[] {"/path1"}, interceptor1);
-		configurer.mapInterceptor(new String[] {"/path2"}, interceptor2);
-
+	public void addInterceptorsWithUrlPatterns() {
+		registry.addInterceptor(interceptor1).addPathPatterns("/path1");
+		registry.addInterceptor(interceptor2).addPathPatterns("/path2");
+		
 		assertEquals(Arrays.asList(interceptor1), getInterceptorsForPath("/path1"));
 		assertEquals(Arrays.asList(interceptor2), getInterceptorsForPath("/path2"));
 	}

-	@Test
-	public void mapInterceptors() {
-		configurer.mapInterceptors(new String[] {"/path1"}, interceptor1, interceptor2);
-
-		assertEquals(Arrays.asList(interceptor1, interceptor2), getInterceptorsForPath("/path1"));
-		assertEquals(Arrays.asList(), getInterceptorsForPath("/path2"));
-	}
-
 	@Test
 	public void addWebRequestInterceptor() throws Exception {
-		configurer.addInterceptor(webRequestInterceptor1);
+		registry.addWebRequestInterceptor(webRequestInterceptor1);
 		List<HandlerInterceptor> interceptors = getInterceptorsForPath(null);
-
+		
 		assertEquals(1, interceptors.size());
 		verifyAdaptedInterceptor(interceptors.get(0), webRequestInterceptor1);
 	}

 	@Test
 	public void addWebRequestInterceptors() throws Exception {
-		configurer.addInterceptors(webRequestInterceptor1, webRequestInterceptor2);
+		registry.addWebRequestInterceptor(webRequestInterceptor1);
+		registry.addWebRequestInterceptor(webRequestInterceptor2);
 		List<HandlerInterceptor> interceptors = getInterceptorsForPath(null);

 		assertEquals(2, interceptors.size());
@@ -119,9 +115,9 @@ public class InterceptorConfigurerTests {
 	}

 	@Test
-	public void mapWebRequestInterceptor() throws Exception {
-		configurer.mapInterceptor(new String[] {"/path1"}, webRequestInterceptor1);
-		configurer.mapInterceptor(new String[] {"/path2"}, webRequestInterceptor2);
+	public void addWebRequestInterceptorsWithUrlPatterns() throws Exception {
+		registry.addWebRequestInterceptor(webRequestInterceptor1).addPathPatterns("/path1");
+		registry.addWebRequestInterceptor(webRequestInterceptor2).addPathPatterns("/path2");

 		List<HandlerInterceptor> interceptors = getInterceptorsForPath("/path1");
 		assertEquals(1, interceptors.size());
@@ -132,22 +128,10 @@ public class InterceptorConfigurerTests {
 		verifyAdaptedInterceptor(interceptors.get(0), webRequestInterceptor2);
 	}

-	@Test
-	public void mapWebRequestInterceptor2() throws Exception {
-		configurer.mapInterceptors(new String[] {"/path1"}, webRequestInterceptor1, webRequestInterceptor2);
-
-		List<HandlerInterceptor> interceptors = getInterceptorsForPath("/path1");
-		assertEquals(2, interceptors.size());
-		verifyAdaptedInterceptor(interceptors.get(0), webRequestInterceptor1);
-		verifyAdaptedInterceptor(interceptors.get(1), webRequestInterceptor2);
-
-		assertEquals(0, getInterceptorsForPath("/path2").size());
-	}
-
 	private List<HandlerInterceptor> getInterceptorsForPath(String lookupPath) {
 		PathMatcher pathMatcher = new AntPathMatcher();
 		List<HandlerInterceptor> result = new ArrayList<HandlerInterceptor>();
-		for (Object i : configurer.getInterceptors()) {
+		for (Object i : registry.getInterceptors()) {
 			if (i instanceof MappedInterceptor) {
 				MappedInterceptor mappedInterceptor = (MappedInterceptor) i;
 				if (mappedInterceptor.matches(lookupPath, pathMatcher)) {
--- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/ResourceHandlerRegistryTests.java
+++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/ResourceHandlerRegistryTests.java
@@ -17,7 +17,7 @@
 package org.springframework.web.servlet.config.annotation;

 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertNull;

 import org.junit.Before;
 import org.junit.Test;
@@ -26,32 +26,34 @@ import org.springframework.mock.web.MockHttpServletResponse;
 import org.springframework.mock.web.MockServletContext;
 import org.springframework.web.context.support.GenericWebApplicationContext;
 import org.springframework.web.servlet.HandlerMapping;
+import org.springframework.web.servlet.handler.SimpleUrlHandlerMapping;
 import org.springframework.web.servlet.resource.ResourceHttpRequestHandler;

 /**
- * Test fixture with a {@link ResourceConfigurer}.
+ * Test fixture with a {@link ResourceHandlerRegistry}.
 *
 * @author Rossen Stoyanchev
 */
-public class ResourceConfigurerTests {
+public class ResourceHandlerRegistryTests {

-	private ResourceConfigurer configurer;
+	private ResourceHandlerRegistry registry;
+	
+	private ResourceHandlerRegistration registration;

 	private MockHttpServletResponse response;

 	@Before
 	public void setUp() {
-		configurer = new ResourceConfigurer(new GenericWebApplicationContext(), new MockServletContext());
-		configurer.addPathMapping("/resources/**");
-		configurer.addResourceLocation("classpath:org/springframework/web/servlet/config/annotation/");
-
+		registry = new ResourceHandlerRegistry(new GenericWebApplicationContext(), new MockServletContext());
+		registration = registry.addResourceHandler("/resources/**");
+		registration.addResourceLocations("classpath:org/springframework/web/servlet/config/annotation/");
 		response = new MockHttpServletResponse();
 	}

 	@Test
-	public void noMappings() throws Exception {
-		configurer = new ResourceConfigurer(new GenericWebApplicationContext(), new MockServletContext());
-		assertTrue(configurer.getHandlerMapping().getUrlMap().isEmpty());
+	public void noResourceHandlers() throws Exception {
+		registry = new ResourceHandlerRegistry(new GenericWebApplicationContext(), new MockServletContext());
+		assertNull(registry.getHandlerMapping());
 	}

 	@Test
@@ -60,7 +62,7 @@ public class ResourceConfigurerTests {
 		request.setMethod("GET");
 		request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, "/testStylesheet.css");

-		ResourceHttpRequestHandler handler = getResourceHandler("/resources/**");
+		ResourceHttpRequestHandler handler = getHandler("/resources/**");
 		handler.handleRequest(request, response);

 		assertEquals("test stylesheet content", response.getContentAsString());
@@ -68,22 +70,23 @@ public class ResourceConfigurerTests {

 	@Test
 	public void cachePeriod() {
-		assertEquals(-1, getResourceHandler("/resources/**").getCacheSeconds());
+		assertEquals(-1, getHandler("/resources/**").getCacheSeconds());

-		configurer.setCachePeriod(0);
-		assertEquals(0, getResourceHandler("/resources/**").getCacheSeconds());
+		registration.setCachePeriod(0);
+		assertEquals(0, getHandler("/resources/**").getCacheSeconds());
 	}

 	@Test
 	public void order() {
-		assertEquals(Integer.MAX_VALUE -1, configurer.getHandlerMapping().getOrder());
+		assertEquals(Integer.MAX_VALUE -1, registry.getHandlerMapping().getOrder());

-		configurer.setOrder(0);
-		assertEquals(0, configurer.getHandlerMapping().getOrder());
+		registry.setOrder(0);
+		assertEquals(0, registry.getHandlerMapping().getOrder());
 	}

-	private ResourceHttpRequestHandler getResourceHandler(String pathPattern) {
-		return (ResourceHttpRequestHandler) configurer.getHandlerMapping().getUrlMap().get(pathPattern);
+	private ResourceHttpRequestHandler getHandler(String pathPattern) {
+		SimpleUrlHandlerMapping handlerMapping = (SimpleUrlHandlerMapping) registry.getHandlerMapping();
+		return (ResourceHttpRequestHandler) handlerMapping.getUrlMap().get(pathPattern);
 	}

 }
--- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/ViewControllerConfigurerTests.java
+++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/ViewControllerConfigurerTests.java
@@ -16,7 +16,9 @@

 package org.springframework.web.servlet.config.annotation;

-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;

 import java.util.Map;

@@ -26,50 +28,55 @@ import org.springframework.web.servlet.handler.SimpleUrlHandlerMapping;
 import org.springframework.web.servlet.mvc.ParameterizableViewController;

 /**
- * Test fixture with a {@link ViewControllerConfigurer}.
+ * Test fixture with a {@link ViewControllerRegistry}.
 *
 * @author Rossen Stoyanchev
 */
-public class ViewControllerConfigurerTests {
+public class ViewControllerRegistryTests {

-	private ViewControllerConfigurer configurer;
+	private ViewControllerRegistry registry;

 	@Before
 	public void setUp() {
-		configurer = new ViewControllerConfigurer();
+		registry = new ViewControllerRegistry();
 	}

 	@Test
-	public void noMappings() throws Exception {
-		Map<String, ?> urlMap = configurer.getHandlerMapping().getUrlMap();
-		assertTrue(urlMap.isEmpty());
+	public void noViewControllers() throws Exception {
+		assertNull(registry.getHandlerMapping());
 	}

 	@Test
-	public void mapViewName() {
-		configurer.mapViewName("/path", "viewName");
-		Map<String, ?> urlMap = configurer.getHandlerMapping().getUrlMap();
-		ParameterizableViewController controller = (ParameterizableViewController) urlMap.get("/path");
-		assertNotNull(controller);
-		assertEquals("viewName", controller.getViewName());
-	}
-
-	@Test
-	public void mapViewNameByConvention() {
-		configurer.mapViewNameByConvention("/path");
-		Map<String, ?> urlMap = configurer.getHandlerMapping().getUrlMap();
+	public void addViewController() {
+		registry.addViewController("/path");
+		Map<String, ?> urlMap = getHandlerMapping().getUrlMap();
 		ParameterizableViewController controller = (ParameterizableViewController) urlMap.get("/path");
 		assertNotNull(controller);
 		assertNull(controller.getViewName());
 	}

+	@Test
+	public void addViewControllerWithViewName() {
+		registry.addViewController("/path").setViewName("viewName");
+		Map<String, ?> urlMap = getHandlerMapping().getUrlMap();
+		ParameterizableViewController controller = (ParameterizableViewController) urlMap.get("/path");
+		assertNotNull(controller);
+		assertEquals("viewName", controller.getViewName());
+	}
+	
 	@Test
 	public void order() {
-		SimpleUrlHandlerMapping handlerMapping = configurer.getHandlerMapping();
+		registry.addViewController("/path");
+		SimpleUrlHandlerMapping handlerMapping = getHandlerMapping();
 		assertEquals(1, handlerMapping.getOrder());

-		configurer.setOrder(2);
-		handlerMapping = configurer.getHandlerMapping();
+		registry.setOrder(2);
+		handlerMapping = getHandlerMapping();
 		assertEquals(2, handlerMapping.getOrder());
 	}
+
+	private SimpleUrlHandlerMapping getHandlerMapping() {
+		return (SimpleUrlHandlerMapping) registry.getHandlerMapping();
+	}
+
 }
--- a/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/WebMvcConfigurationSupportTests.java
+++ b/org.springframework.web.servlet/src/test/java/org/springframework/web/servlet/config/annotation/WebMvcConfigurationSupportTests.java
@@ -0,0 +1,315 @@
+/*
+ * 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.servlet.config.annotation;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.beans.DirectFieldAccessor;
+import org.springframework.beans.TestBean;
+import org.springframework.core.convert.ConversionService;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.core.io.FileSystemResourceLoader;
+import org.springframework.format.FormatterRegistry;
+import org.springframework.format.support.FormattingConversionService;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.http.converter.json.MappingJacksonHttpMessageConverter;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockServletContext;
+import org.springframework.stereotype.Controller;
+import org.springframework.validation.BeanPropertyBindingResult;
+import org.springframework.validation.Errors;
+import org.springframework.validation.Validator;
+import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
+import org.springframework.web.context.support.StaticWebApplicationContext;
+import org.springframework.web.method.annotation.support.ModelAttributeMethodProcessor;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.HandlerExecutionChain;
+import org.springframework.web.servlet.handler.AbstractHandlerMapping;
+import org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping;
+import org.springframework.web.servlet.handler.ConversionServiceExposingInterceptor;
+import org.springframework.web.servlet.handler.HandlerExceptionResolverComposite;
+import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
+import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
+import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
+import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
+import org.springframework.web.servlet.mvc.method.annotation.support.DefaultMethodReturnValueHandler;
+
+/**
+ * A test fixture for {@link WebMvcConfigurationSupport}.
+ *
+ * @author Rossen Stoyanchev
+ */
+public class WebMvcConfigurationSupportTests {
+
+	private TestWebMvcConfiguration mvcConfiguration;
+
+	@Before
+	public void setUp() {
+		mvcConfiguration = new TestWebMvcConfiguration();
+	}
+	
+	@Test
+	public void requestMappingHandlerMapping() throws Exception {
+		StaticWebApplicationContext cxt = new StaticWebApplicationContext();
+		cxt.registerSingleton("controller", TestController.class);
+		
+		RequestMappingHandlerMapping handlerMapping = mvcConfiguration.requestMappingHandlerMapping();
+		assertEquals(0, handlerMapping.getOrder());
+
+		handlerMapping.setApplicationContext(cxt);
+		HandlerExecutionChain chain = handlerMapping.getHandler(new MockHttpServletRequest("GET", "/"));
+		assertNotNull(chain.getInterceptors());
+		assertEquals(ConversionServiceExposingInterceptor.class, chain.getInterceptors()[0].getClass());
+	}
+
+	@Test
+	public void emptyViewControllerHandlerMapping() {
+		AbstractHandlerMapping handlerMapping = (AbstractHandlerMapping) mvcConfiguration.viewControllerHandlerMapping();
+		assertNotNull(handlerMapping);
+		assertEquals(Integer.MAX_VALUE, handlerMapping.getOrder());
+		assertTrue(handlerMapping.getClass().getName().endsWith("EmptyHandlerMapping"));
+	}
+	
+	@Test
+	public void beanNameHandlerMapping() throws Exception {
+		StaticWebApplicationContext cxt = new StaticWebApplicationContext();
+		cxt.registerSingleton("/controller", TestController.class);
+
+		HttpServletRequest request = new MockHttpServletRequest("GET", "/controller");
+
+		BeanNameUrlHandlerMapping handlerMapping = mvcConfiguration.beanNameHandlerMapping();
+		assertEquals(2, handlerMapping.getOrder());
+
+		handlerMapping.setApplicationContext(cxt);
+		HandlerExecutionChain chain = handlerMapping.getHandler(request);
+		assertNotNull(chain.getInterceptors());
+		assertEquals(2, chain.getInterceptors().length);
+		assertEquals(ConversionServiceExposingInterceptor.class, chain.getInterceptors()[1].getClass());
+	}
+	
+	@Test
+	public void emptyResourceHandlerMapping() {
+		mvcConfiguration.setApplicationContext(new StaticWebApplicationContext());
+		AbstractHandlerMapping handlerMapping = (AbstractHandlerMapping) mvcConfiguration.resourceHandlerMapping();
+		assertNotNull(handlerMapping);
+		assertEquals(Integer.MAX_VALUE, handlerMapping.getOrder());
+		assertTrue(handlerMapping.getClass().getName().endsWith("EmptyHandlerMapping"));
+	}
+	
+	@Test
+	public void emptyDefaultServletHandlerMapping() {
+		mvcConfiguration.setServletContext(new MockServletContext());
+		AbstractHandlerMapping handlerMapping = (AbstractHandlerMapping) mvcConfiguration.defaultServletHandlerMapping();
+		assertNotNull(handlerMapping);
+		assertEquals(Integer.MAX_VALUE, handlerMapping.getOrder());
+		assertTrue(handlerMapping.getClass().getName().endsWith("EmptyHandlerMapping"));
+	}
+	
+	@Test
+	public void requestMappingHandlerAdapter() throws Exception {
+		RequestMappingHandlerAdapter adapter = mvcConfiguration.requestMappingHandlerAdapter();
+
+		List<HttpMessageConverter<?>> expectedConverters = new ArrayList<HttpMessageConverter<?>>();
+		mvcConfiguration.addDefaultHttpMessageConverters(expectedConverters);
+		assertEquals(expectedConverters.size(), adapter.getMessageConverters().size());
+
+		ConfigurableWebBindingInitializer initializer = (ConfigurableWebBindingInitializer) adapter.getWebBindingInitializer();
+		assertNotNull(initializer);
+
+		ConversionService conversionService = initializer.getConversionService();
+		assertNotNull(conversionService);
+		assertTrue(conversionService instanceof FormattingConversionService);
+		
+		Validator validator = initializer.getValidator();
+		assertNotNull(validator);
+		assertTrue(validator instanceof LocalValidatorFactoryBean);
+	}
+	
+	@Test
+	public void handlerExceptionResolver() throws Exception {
+		HandlerExceptionResolverComposite compositeResolver = 
+			(HandlerExceptionResolverComposite) mvcConfiguration.handlerExceptionResolver();
+		
+		assertEquals(0, compositeResolver.getOrder());
+
+		List<HandlerExceptionResolver> expectedResolvers = new ArrayList<HandlerExceptionResolver>();
+		mvcConfiguration.addDefaultHandlerExceptionResolvers(expectedResolvers);
+		assertEquals(expectedResolvers.size(), compositeResolver.getExceptionResolvers().size());
+	}
+	
+	@Test 
+	public void webMvcConfigurerExtensionHooks() throws Exception {
+		
+		StaticWebApplicationContext appCxt = new StaticWebApplicationContext();
+		appCxt.setServletContext(new MockServletContext(new FileSystemResourceLoader()));
+		appCxt.registerSingleton("controller", TestController.class);
+
+		WebConfig webConfig = new WebConfig();
+		webConfig.setApplicationContext(appCxt);
+		webConfig.setServletContext(appCxt.getServletContext());
+		
+		String actual = webConfig.mvcConversionService().convert(new TestBean(), String.class);
+		assertEquals("converted", actual);
+
+		RequestMappingHandlerAdapter adapter = webConfig.requestMappingHandlerAdapter();
+		assertEquals(1, adapter.getMessageConverters().size());
+		
+		ConfigurableWebBindingInitializer initializer = (ConfigurableWebBindingInitializer) adapter.getWebBindingInitializer();
+		assertNotNull(initializer);
+		
+		BeanPropertyBindingResult bindingResult = new BeanPropertyBindingResult(null, "");
+		initializer.getValidator().validate(null, bindingResult);
+		assertEquals("invalid", bindingResult.getAllErrors().get(0).getCode());
+
+		@SuppressWarnings("unchecked")
+		List<HandlerMethodArgumentResolver> argResolvers= (List<HandlerMethodArgumentResolver>) 
+			new DirectFieldAccessor(adapter).getPropertyValue("customArgumentResolvers");
+		assertEquals(1, argResolvers.size());
+
+		@SuppressWarnings("unchecked")
+		List<HandlerMethodReturnValueHandler> handlers = (List<HandlerMethodReturnValueHandler>) 
+			new DirectFieldAccessor(adapter).getPropertyValue("customReturnValueHandlers");
+		assertEquals(1, handlers.size());
+		
+		HandlerExceptionResolverComposite composite = (HandlerExceptionResolverComposite) webConfig.handlerExceptionResolver();
+		assertEquals(1, composite.getExceptionResolvers().size());
+		
+		RequestMappingHandlerMapping rmHandlerMapping = webConfig.requestMappingHandlerMapping();
+		rmHandlerMapping.setApplicationContext(appCxt);
+		HandlerExecutionChain chain = rmHandlerMapping.getHandler(new MockHttpServletRequest("GET", "/"));
+		assertNotNull(chain.getInterceptors());
+		assertEquals(2, chain.getInterceptors().length);
+		assertEquals(LocaleChangeInterceptor.class, chain.getInterceptors()[0].getClass());
+		assertEquals(ConversionServiceExposingInterceptor.class, chain.getInterceptors()[1].getClass());
+
+		AbstractHandlerMapping handlerMapping = (AbstractHandlerMapping) webConfig.viewControllerHandlerMapping();
+		handlerMapping.setApplicationContext(appCxt);
+		assertNotNull(handlerMapping);
+		assertEquals(1, handlerMapping.getOrder());
+		HandlerExecutionChain handler = handlerMapping.getHandler(new MockHttpServletRequest("GET", "/path"));
+		assertNotNull(handler.getHandler());
+
+		handlerMapping = (AbstractHandlerMapping) webConfig.resourceHandlerMapping();
+		handlerMapping.setApplicationContext(appCxt);
+		assertNotNull(handlerMapping);
+		assertEquals(Integer.MAX_VALUE-1, handlerMapping.getOrder());
+		handler = handlerMapping.getHandler(new MockHttpServletRequest("GET", "/resources/foo.gif"));
+		assertNotNull(handler.getHandler());
+
+		handlerMapping = (AbstractHandlerMapping) webConfig.defaultServletHandlerMapping();
+		handlerMapping.setApplicationContext(appCxt);
+		assertNotNull(handlerMapping);
+		assertEquals(Integer.MAX_VALUE, handlerMapping.getOrder());
+		handler = handlerMapping.getHandler(new MockHttpServletRequest("GET", "/anyPath"));
+		assertNotNull(handler.getHandler());
+	}
+
+	@Controller
+	private static class TestController {
+		
+		@SuppressWarnings("unused")
+		@RequestMapping("/")
+		public void handle() {
+		}
+	}
+
+	private static class TestWebMvcConfiguration extends WebMvcConfigurationSupport {
+		
+	}
+	
+	/**
+	 * The purpose of this class is to test that an implementation of a {@link WebMvcConfigurer} 
+	 * can also apply customizations by extension from {@link WebMvcConfigurationSupport}.
+	 */
+	private class WebConfig extends WebMvcConfigurationSupport implements WebMvcConfigurer {
+		
+		@Override
+		public void addFormatters(FormatterRegistry registry) {
+			registry.addConverter(new Converter<TestBean, String>() {
+				public String convert(TestBean source) {
+					return "converted";
+				}
+			});
+		}
+
+		@Override
+		public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
+			converters.add(new MappingJacksonHttpMessageConverter());
+		}
+
+		@Override
+		public Validator getValidator() {
+			return new Validator() {
+				public void validate(Object target, Errors errors) {
+					errors.reject("invalid");
+				}
+				public boolean supports(Class<?> clazz) {
+					return true;
+				}
+			};
+		}
+
+		@Override
+		public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
+			argumentResolvers.add(new ModelAttributeMethodProcessor(true));
+		}
+
+		@Override
+		public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
+			returnValueHandlers.add(new DefaultMethodReturnValueHandler());
+		}
+
+		@Override
+		public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
+			exceptionResolvers.add(new SimpleMappingExceptionResolver());
+		}
+
+		@Override
+		public void addInterceptors(InterceptorRegistry registry) {
+			registry.addInterceptor(new LocaleChangeInterceptor());
+		}
+
+		@Override
+		public void addViewControllers(ViewControllerRegistry registry) {
+			registry.addViewController("/path");
+		}
+
+		@Override
+		public void addResourceHandlers(ResourceHandlerRegistry registry) {
+			registry.addResourceHandler("/resources/**").addResourceLocations("src/test/java");
+		}
+
+		@Override
+		public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
+			configurer.enable("default");
+		}
+	}
+	
+}