Merge branch '3.1.x' into 3.2.x

Author: graemerocher

grails-plugin-testing/src/main/groovy/grails/test/mixin/web/UrlMappingsUnitTestMixin.groovy

@@ -39,6 +39,7 @@ import org.grails.gsp.GroovyPagesTemplateEngine
  */
 class UrlMappingsUnitTestMixin extends ControllerUnitTestMixin {
 
+    public static final String KEY_EXCEPTION = 'exception'
     private assertionKeys = ["controller", "action", "view"]
 
     /**
@@ -193,7 +194,12 @@ class UrlMappingsUnitTestMixin extends ControllerUnitTestMixin {
         def mappingInfos
         if (url instanceof Integer) {
             mappingInfos = []
-            def mapping = mappingsHolder.matchStatusCode(url)
+            def mapping
+            if (assertions."$KEY_EXCEPTION") {
+                mapping = mappingsHolder.matchStatusCode(url, assertions."$KEY_EXCEPTION" as Throwable)
+            } else {
+                mapping = mappingsHolder.matchStatusCode(url)
+            }
             if (mapping) mappingInfos << mapping
         }
         else {

grails-test-suite-uber/src/test/groovy/grails/test/mixin/UrlMappingsTestMixinTests.groovy

@@ -166,6 +166,17 @@ class UrlMappingsTestMixinTests {
         assertUrlMapping('/users/timmy', controller: 'user', action: 'update', method: 'put') { name = 'timmy' }
     }
 
+    @Test
+    @Issue('https://github.com/grails/grails-core/issues/10226')
+    void testExceptionUrlMapping() {
+        mockController(ExceptionTestErrorsController)
+        mockUrlMappings(ExceptionTestUrlMappings)
+
+        assertForwardUrlMapping(500, controller: 'exceptionTestErrors', action: 'handleNullPointer', exception: new NullPointerException())
+        assertForwardUrlMapping(500, controller: 'exceptionTestErrors', action: 'handleIllegalArgument', exception: new IllegalArgumentException())
+        assertForwardUrlMapping(500, controller: 'exceptionTestErrors', action: 'handleDefault')
+    }
+
     @Test
     @Issue('https://github.com/grails/grails-core/issues/9065')
     void testResourcesUrlMapping() {
@@ -282,3 +293,18 @@ class ResourceTestUrlMappings {
         '/person'(resources: 'person')
     }
 }
+
+@Artefact("Controller")
+class ExceptionTestErrorsController {
+    def handleNullPointer() {}
+    def handleIllegalArgument() {}
+    def handleDefault() {}
+}
+
+class ExceptionTestUrlMappings {
+    static mappings = {
+        '500'(controller: 'exceptionTestErrors', action: 'handleNullPointer', exception: NullPointerException)
+        '500'(controller: 'exceptionTestErrors', action: 'handleIllegalArgument', exception: IllegalArgumentException)
+        '500'(controller: 'exceptionTestErrors', action: 'handleDefault')
+    }
+}

grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/DefaultUrlMappingsHolder.java

@@ -46,6 +46,8 @@
 import org.apache.commons.logging.LogFactory;
 import org.springframework.core.style.ToStringCreator;
 import org.springframework.http.HttpMethod;
+import org.springframework.util.AntPathMatcher;
+import org.springframework.util.PathMatcher;
 import org.springframework.web.context.WebApplicationContext;
 
 import com.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
@@ -66,6 +68,7 @@ public class DefaultUrlMappingsHolder implements UrlMappings {
 
     private static final transient Log LOG = LogFactory.getLog(DefaultUrlMappingsHolder.class);
     private static final int DEFAULT_MAX_WEIGHTED_CAPACITY = 5000;
+    public static final UrlMappingInfo[] EMPTY_RESULTS = new UrlMappingInfo[0];
 
     private int maxWeightedCacheCapacity = DEFAULT_MAX_WEIGHTED_CAPACITY;
     private Map<String, UrlMappingInfo> cachedMatches;
@@ -79,20 +82,21 @@ public int weightOf(List<UrlMappingInfo> values) {
         }
     }
 
-    private List<UrlMapping> urlMappings = new ArrayList<UrlMapping>();
+    private List<UrlMapping> urlMappings = new ArrayList<>();
     private UrlMapping[] mappings;
-    private List excludePatterns;
-    private Map<UrlMappingKey, UrlMapping> mappingsLookup = new HashMap<UrlMappingKey, UrlMapping>();
-    private Map<String, UrlMapping> namedMappings = new HashMap<String, UrlMapping>();
-    private UrlMappingsList mappingsListLookup = new UrlMappingsList();
-    private Set<String> DEFAULT_NAMESPACE_PARAMS = CollectionUtils.newSet(
-            UrlMapping.NAMESPACE, UrlMapping.CONTROLLER, UrlMapping.ACTION);
-    private Set<String> DEFAULT_CONTROLLER_PARAMS = CollectionUtils.newSet(
-          UrlMapping.CONTROLLER, UrlMapping.ACTION);
-    private Set<String> DEFAULT_ACTION_PARAMS = CollectionUtils.newSet(UrlMapping.ACTION);
     private UrlCreatorCache urlCreatorCache;
     // capacity of the UrlCreatoreCache is the estimated number of char's stored in cached objects
     private int urlCreatorMaxWeightedCacheCapacity = 160000;
+    private final List excludePatterns;
+    private final Map<UrlMappingKey, UrlMapping> mappingsLookup = new HashMap<>();
+    private final Map<String, UrlMapping> namedMappings = new HashMap<>();
+    private final UrlMappingsList mappingsListLookup = new UrlMappingsList();
+    private final Set<String> DEFAULT_NAMESPACE_PARAMS = CollectionUtils.newSet(
+            UrlMapping.NAMESPACE, UrlMapping.CONTROLLER, UrlMapping.ACTION);
+    private final Set<String> DEFAULT_CONTROLLER_PARAMS = CollectionUtils.newSet(
+          UrlMapping.CONTROLLER, UrlMapping.ACTION);
+    private final Set<String> DEFAULT_ACTION_PARAMS = CollectionUtils.newSet(UrlMapping.ACTION);
+    private final PathMatcher pathMatcher = new AntPathMatcher();
 
     public DefaultUrlMappingsHolder(List<UrlMapping> mappings) {
         this(mappings, null, false);
@@ -359,7 +363,7 @@ private UrlCreator resolveUrlCreator(final String controller,
             }
         }
         if (mapping == null || (mapping instanceof ResponseCodeUrlMapping)) {
-            Set<String> lookupParams = new HashSet<String>(DEFAULT_NAMESPACE_PARAMS);
+            Set<String> lookupParams = new HashSet<>(DEFAULT_NAMESPACE_PARAMS);
             Set<String> paramKeys = new HashSet<String>(params.keySet());
             paramKeys.removeAll(lookupParams);
             lookupParams.addAll(paramKeys);
@@ -478,6 +482,8 @@ public UrlMappingInfo[] matchAll(String uri) {
     }
 
     public UrlMappingInfo[] matchAll(String uri, String httpMethod) {
+        if (isExcluded(uri)) return EMPTY_RESULTS;
+
         boolean anyHttpMethod = httpMethod != null && httpMethod.equalsIgnoreCase(UrlMapping.ANY_HTTP_METHOD);
         List<UrlMappingInfo> matchingUrls = new ArrayList<UrlMappingInfo>();
         UriToUrlMappingKey cacheKey = new UriToUrlMappingKey(uri, httpMethod, UrlMapping.ANY_VERSION);
@@ -506,7 +512,20 @@ public UrlMappingInfo[] matchAll(String uri, String httpMethod) {
         return matchingUrls.toArray(new UrlMappingInfo[matchingUrls.size()]);
     }
 
+    private boolean isExcluded(String uri) {
+        if(excludePatterns != null) {
+            for (Object excludePattern : excludePatterns) {
+                if(pathMatcher.match(excludePattern.toString(), uri)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     public UrlMappingInfo[] matchAll(String uri, String httpMethod, String version) {
+        if (isExcluded(uri)) return EMPTY_RESULTS;
+
         List<UrlMappingInfo> matchingUrls;
         UriToUrlMappingKey cacheKey = new UriToUrlMappingKey(uri, httpMethod, version);
         if (cachedListMatches.containsKey(cacheKey)) {

grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/mvc/AbstractGrailsControllerUrlMappings.groovy

@@ -179,8 +179,10 @@ abstract class AbstractGrailsControllerUrlMappings implements UrlMappings{
             if(info.redirectInfo) {
                 return info
             }
-            webRequest.resetParams()
-            info.configure(webRequest)
+            if(webRequest != null) {
+                webRequest.resetParams()
+                info.configure(webRequest)
+            }
             def controllerKey = new ControllerKey(info.namespace, info.controllerName, info.actionName, info.pluginName)
             GrailsControllerClass controllerClass = info ? mappingsToGrailsControllerMap.get(controllerKey) : null
             if(controllerClass) {

grails-web-url-mappings/src/test/groovy/org/grails/web/mapping/UrlMappingsHolderFactoryBeanSpec.groovy

@@ -0,0 +1,46 @@
+package org.grails.web.mapping
+
+import grails.core.DefaultGrailsApplication
+import grails.core.GrailsApplication
+import grails.plugins.DefaultGrailsPluginManager
+import grails.plugins.GrailsPluginManager
+import grails.web.mapping.UrlMappingsHolder
+import org.springframework.context.support.GenericApplicationContext
+import spock.lang.Specification
+
+/**
+ * Created by graemerocher on 17/10/16.
+ */
+class UrlMappingsHolderFactoryBeanSpec extends Specification {
+
+    void "test url mappings holder factory bean excludes"() {
+        given:
+        UrlMappingsHolderFactoryBean factoryBean = new UrlMappingsHolderFactoryBean()
+        def context = new GenericApplicationContext()
+        context.refresh()
+        def app = new DefaultGrailsApplication(ExcludeUrlMappings)
+        def pm = new DefaultGrailsPluginManager(app)
+        context.beanFactory.registerSingleton(GrailsApplication.APPLICATION_ID, app)
+        context.beanFactory.registerSingleton(GrailsPluginManager.BEAN_NAME, pm)
+        app.initialise()
+        factoryBean.setApplicationContext(context)
+
+        when:"The URL mappings holder is created"
+        factoryBean.afterPropertiesSet()
+        UrlMappingsHolder holder = factoryBean.getObject()
+
+        then:"The excludes are correct"
+        holder.excludePatterns == ["/stomp/", "/stomp/*", "/topic/*"]
+        holder.matchAll("/stomp/foo").size() == 0
+    }
+}
+class ExcludeUrlMappings {
+
+    static excludes = ["/stomp/", "/stomp/*", "/topic/*"]
+
+    static mappings = {
+        '/**'(controller:"index")
+        "500"(view:'/error')
+        "404"(view:'/notFound')
+    }
+}