private boolean checkForwardUrlMapping()

in grails-testing-support-web/src/main/groovy/grails/testing/web/UrlMappingsUnitTest.groovy [234:339]
94 lines of code
31 McCabe index (conditional complexity)

    private boolean checkForwardUrlMapping(Map<String, Object> assertions, Object url, Closure paramAssertions, boolean throwEx) {

        UrlMappingsHolder mappingsHolder = getUrlMappingsHolder()
        if (assertions.action && !assertions.controller) {
            throw new IllegalArgumentException("Cannot assert action for url mapping without asserting controller")
        }

        if (assertions.controller) {
            if (!checkController((String)assertions.controller, throwEx)) {
                return false
            }
        }
        if (assertions.action) {
            if (!checkAction((String)assertions.controller, (String)assertions.action, throwEx)) {
                return false
            }
        }
        if (assertions.view) {
            if (!checkView((String) assertions.controller, (String) assertions.view, throwEx)) {
                return false
            }
        }

        List<UrlMappingInfo> mappingInfos
        if (url instanceof Integer) {
            mappingInfos = []
            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 {
            mappingInfos = mappingsHolder.matchAll((String)url, request.method).toList()
        }

        if (mappingInfos.size() == 0) {
            if (throwEx) {
                throw new AssertionFailedError("url '$url' did not match any mappings")
            }   else {
                return false
            }
        }

        boolean returnVal = true

        def mappingMatched = mappingInfos.any {mapping ->
            mapping.configure(webRequest)
            for (key in assertionKeys) {
                if (assertions.containsKey(key)) {
                    String expected = (String)assertions[key]
                    String actual = mapping."${key}Name"

                    switch (key) {
                        case "controller":
                            if (actual && !getControllerClass(actual)) return false
                            break
                        case "view":
                            if (actual[0] == "/") actual = actual.substring(1)
                            if (expected[0] == "/") expected = expected.substring(1)
                            break
                        case "action":
                            if (key == "action" && actual == null) {
                                final controllerClass = getControllerClass(assertions.controller)
                                actual = controllerClass?.defaultAction
                            }
                            break
                    }

                    if (expected != actual) {
                        if (throwEx) {
                            throw new ComparisonFailure("Url mapping $key assertion for '$url' failed".toString(), expected, actual)
                        } else {
                            returnVal = false
                        }
                    }
                }
            }
            if (paramAssertions) {
                def params = [:]
                paramAssertions.delegate = params
                paramAssertions.resolveStrategy = Closure.DELEGATE_ONLY
                paramAssertions.call()
                params.each {name, value ->
                    String actual = mapping.parameters[name]
                    String expected = value

                    if (expected != actual) {
                        if (throwEx) {
                            throw new ComparisonFailure("Url mapping $name assertion for '$url' failed".toString(), expected, actual)
                        } else {
                            returnVal = false
                        }
                    }
                }
            }

            return true
        }

        if (!mappingMatched) throw new IllegalArgumentException("url '$url' did not match any mappings")

        returnVal
    }