Narrowing properties returned from Grails Criteria

These snippets show a nice feature that I think could be better documented in Grails docs: the use of projections closure to narrow properties returned from criteria.

	package org.unnoware
	class Author {
	static hasMany = ['books':Book]
	String name
	Integer age
	String address
	static constraints = {
	}
	}

view raw Author.groovy hosted with ❤ by GitHub

	package org.unnoware
	import grails.plugin.spock.IntegrationSpec
	class AuthorSpec extends IntegrationSpec {
	def "select a subset of Author properties"() {
	setup:
	(1..3).collect { Author.build(name : "author #$it", age : 30 + it) }
	when: "querying for author name and age"
	def results = Author.withCriteria{
	projections{
	property 'name', 'authorName'
	property 'age', 'authorAge'
	}
	gt 'authorAge', 31
	}
	then: "only authors with age > 31 are returned"
	results.size() == 2
	and: "returned only name and age properties"
	results[i].size() == 2
	and:
	results[i][0] == name
	results[i][1] == age
	where:
	i | name | age
	0 | 'author #2' | 32
	1 | 'author #3' | 33
	}
	}

view raw AuthorSpec.groovy hosted with ❤ by GitHub

And it works with associations too:

	package org.unnoware
	class Book {
	static belongsTo = ['author': Author]
	String title
	Integer pages
	BigDecimal price
	static constraints = {
	}
	}

view raw Book.groovy hosted with ❤ by GitHub

	package org.unnoware
	import grails.plugin.spock.IntegrationSpec
	class BookSpec extends IntegrationSpec {
	def "select a subset of Book and Author properties"() {
	setup:
	(1..3).collect { authorIdx ->
	def author = Author.build(name : "author #$authorIdx", age : 30 + authorIdx)
	(1..authorIdx).collect{ bookIdx ->
	Book.build(author : author, title : "Book #$bookIdx from ${author.name}", pages : bookIdx * 100, price : bookIdx * 1000.0)
	}
	}
	when: "querying for author name and age "
	def results = Book.withCriteria{
	projections{
	author{
	property 'name', 'authorName'
	property 'age', 'authorAge'
	}
	property 'title', 'title'
	property 'price', 'price'
	}
	gt 'authorAge', 31
	le 'price', 2000.0
	}
	then: "only the authors with age > 31 with books priced 2000 or less"
	results.size() == 4
	and: "returned author name and age with book title and price properties"
	results[i].size() == 4
	and:
	results[i][0] == name
	results[i][1] == age
	results[i][2] == title
	results[i][3] == price
	where:
	i | name | age | title | price
	0 | 'author #2' | 32 | "Book #1 from author #2" | 1000.0
	1 | 'author #2' | 32 | "Book #2 from author #2" | 2000.0
	2 | 'author #3' | 33 | "Book #1 from author #3" | 1000.0
	3 | 'author #3' | 33 | "Book #2 from author #3" | 2000.0
	}
	}

view raw BookSpec.groovy hosted with ❤ by GitHub

SpringCache custom cache resolver & Acegi plugin

Today's snippet is derived from excellent SpringCache plugin documentation, I had to resolve my cache against a property of currently logged user in a sort of multitenancy, so I had to define a custom CacheResolver in src/groovy:

import grails.plugin.springcache.CacheResolver

class CustomCacheResolver implements CacheResolver {
 def authenticateService
 
  String resolveCacheName(String baseName) {
   def user = authenticateService.principal().domainClass
   user = User.get(user.id)
   def bancheIds = user.banche*.getId().sort().join("_")
   "${baseName}-banche-${bancheIds}"
  }
}

and then wire authenticateService in resources.groovy:

customCacheResolver(CustomCacheResolver) {
  authenticateService = ref("authenticateService")
 }

now it can be referenced from SpringCache annotations:

@CacheFlush(caches = "categorieCache", cacheResolver = "customCacheResolver")

and every tenant (defined by banche collection identifiers) has its cache.

Note that I used Acegi plugin, which now is discontinued, but I think the same could be obtained with SpringSecurity plugin also. Just wire springSecurityService and resolve current logged user from it with getCurrentUser().

Having a Jenkins Grails build agains a war and code coverage reports

Recently I've read Luke Daley's post about testing Grails apps against a war and Christian Oestreich's post regarding Jenkins builds and code reports, so I tried to merge their knowledge and get a Jenkins build with tests against war AND code reports.

After struggling with various configurations (and erroneously blaming geb for not having my functional tests working) it turned out that you can't have code coverage if its target is a war: cobertura jar must be included in your war file or you'll encounter a ClassNotFoundException.

Having cobertura jars in production builds is not an acceptable solution, so I've ended including the dependency inside an environment check in project's BuildConfig.groovy:

// Including cobertura jar (testing against a war, special case)  
  if (grailsSettings.grailsEnv == "test"){
    def args = System.getProperty("grails.cli.args")
    if (args.tokenize().containsAll(['-war','-coverage'])){
      compile('net.sourceforge.cobertura:cobertura:1.9.4.1'){
        excludes "asm", "log4j"
      }
    }
  }

Note that cobertura jar is included only if the '-war' and '-coverage' switches are passed together in the command line and environment is 'test'.

Now I can run all of my tests from Jenkins against a war build and having all code reports I need, Chuck Norris is happy, and I can go back to meditate.