Support for unit testing URL Mappings

I have looked through how url mappings work, doesn't seem like it would be too hard to add testing support.

One thing I don't know though is how to get hold of the grailsUrlMappingsHolderBean in a test scenario. Perhaps there should be a 'GrailsIntegrationTest' class that somehow either gets beans injected via spring, or has access to those beans somehow.

Here is an example of how I am testing url mappings. It's still missing a few things that I will add to on Monday but it's a place to start.

Glenn

Here are my thoughts.

class UrlMappingTests extends GrailsUrlMappingTestCase {
def mappings = UrlMappings

/* tests */
}

or

class UrlMappingTests extends GrailsUrlMappingTestCase {
def mappings = [UrlMappings, OtherUrlMappings]

/* tests */
}

and if `mappings` is omitted then all mappings are loaded, considering that I think this would be the most common case.

I am also trying choose between the following...

void testMapping() {
"/module/list"(controller: "module", action: "list")
}

and...

void testMapping() {
assertUrlMapping("/module/list", controller: "module", action: "list")
}

Also trying to decide the best approach to asserting params.

With mappings like...

mappings = {
"/$groovy/$module/ivy.xml"(controller:"module", action: "ivy")
}

We could do...

void testMapping() {
assertUrlMapping("/1.5.4/someModule/ivy.xml", controller: "module", action: "ivy", groovy: "1.5.4", module: "someModule")
}

Or something like...

void testMapping() {
assertUrlMapping("/1.5.4/someModule/ivy.xml", controller: "module", action: "ivy")

}

Which is the most concise, but probably not the most intuitive.

Here are my thoughts.

class UrlMappingTests extends GrailsUrlMappingTestCase {
def mappings = UrlMappings
}

or

class UrlMappingTests extends GrailsUrlMappingTestCase {
def mappings = [UrlMappings, OtherUrlMappings]
}

and if `mappings` is omitted then all mappings are loaded, considering that I think this would be the most common case.

I am also trying choose between the following...

void testMapping() {
	"/module/list"(controller: "module", action: "list")
}

and...

void testMapping() {
	assertUrlMapping("/module/list", controller: "module", action: "list")
}

Also trying to decide the best approach to asserting params.

With mappings like...

mappings = {
	"/$groovy/$module/ivy.xml"(controller:"module", action: "ivy")
}	

We could do...

void testMapping() {
	assertUrlMapping("/1.5.4/someModule/ivy.xml", controller: "module", action: "ivy", groovy: "1.5.4", module: "someModule")
}

Or something like...

void testMapping() {
	assertUrlMapping("/1.5.4/someModule/ivy.xml", controller: "module", action: "ivy") {
		groovy = "1.5.4"
		module = "someModule"
	}
}

Or...

void testMapping() {
	assertUrlMapping("/1.5.4/someModule/ivy.xml", controller: "module", action: "ivy") {
		assertEquals("1.5.4", groovy)
		assertEquals("someModule", module)
	}
}

I am personally leaning towards...

void testMapping() {
	"/1.5.4/someModule/ivy.xml"(controller: "module", action: "ivy") {
		groovy =  "1.5.4"
		module = "someModule"
	}
}

Which is the most concise, but probably not the most intuitive.

Another question is whether we be strict about controllers and views that don't exist. Maybe this should be an option...

class UrlMappingsTests extends GrailsUrlMappingsTestCase {
    testMappings() {
        "/someController/someAction"(controller: "someController", action: "someAction")
    }
}

Assuming `someController` doesn't exist, this would fail. But this would pass in the same situation...

class UrlMappingsTests extends GrailsUrlMappingsTestCase {
    def strict = false 
    testMappings() {
        "/someController/someAction"(controller: "someController", action: "someAction")
    }
}

Attaching GrailsUrlMappingTestCase and GrailsUrlMappingTestCaseTests.

As far as I am aware this is feature complete.

Added some more tests for param assertions.

So how this is working at the moment.

It introduces three assertion methods (but each has a closure variant)

• assertForwardUrlMapping()
• assertReverseUrlMapping()
• assertUrlMapping()

assertUrlMapping() calls the forward assertion, and if it makes sense calls the reverse assertion.

With a mapping like...

"/$param1/$param2"(controlller: "c", action: "a")

you test like this...

assertUrlMapping("/value1/value2", controller: "c", action: "a") {
    param1 = "value1"
    param2 = "value2"
}

All the assert*UrlMapping methods have the same signature.

By default, all of the url mappings in your application will be loaded for testing. However, in your test case you can specify a mappings property that can be; a list of UrlMapping classes, a single UrlMapping class, or a closure defining some mappings.

It is also noteworthy that these tests actually match against the controllers, actions and views in the grails app. So if the mapping assertion is actually correct, but it specifies a controller, action or view that doesn't exist, the assertion will fail. This way, url mappings that lead to 404's will be caught.

Should I just commit this to the testing plugin?

I have another suggestion before you do What do you think of using "==" instead of "=" in the closure? In other words:

assertUrlMapping("/value1/value2", controller: "c", action: "a") {
    param1 == "value1"
    param2 == "value2"
}

That matches better with the normal semantics of "==" and "=", plus you could use other comparators:

assertUrlMapping("/value1/value2", controller: "c", action: "a") {
    param1 =~ "value\\d"
    param2 =~ "value\\d"
}

BTW, thanks for all the work on this. Looks good!

I thought about this, it would be quite tricky to pull off. Thinking about this more, if the documentation is worded right, then assignment actually makes more sense. It is also more orthogonal with how the controller and action params work.

If the closure is documented as a "DSL" for specifying the parameter values which will then be asserted for equality, then it kind of makes sense. This is opposed to thinking about the closure as code to be executed. Also, the user doesn't do any comparison of the controller or action params, they just specify them, which using the current approach is the same for params.

However, I do see how this is a bit weird until you get used to the idea. The only other idea I have is to just use another map key

assertUrlMapping("/value1/value2", controller: "c", action: "a", params: [param1: "value1", param2: "value2"])

That has a certain charm to it, but it's not as readable in my opinion.

The map approach is readable with appropriate indentation But I'm more than happy to go with the current approach - to be honest "==" would look a little strange. Feel free to commit it if you haven't done so already.

Committed, where should I write the documentation?

If you're ready to write it, add it to a "Testing Plugin" page on the Grails website. I'll transfer that documentation across to the reference guide for 1.1 at some point.

Documentation @ http://www.grails.org/Testing+URL+Mappings.

As far as I am aware, this ticket is now resolved.

Thanks for implementing this Luke.

Bulk closing bunch of resolved issues