While not one of its unique selling points, because EasyMock allows you to do basically the same, here’s an example of partially mocking a class in PowerMock.

Given class CustomerService:

class CustomerService {

	public void add(Customer customer) {
		if (someCondition) {
			subscribeToNewsletter(customer);
		}
	}

	void subscribeToNewsletter(Customer customer) {
		// ...subscribing stuff
	}
}

So you want to test the add() method for actually invoking subscribeToNewsletter() and do NOT want to execute the logic from subscribeToNewsletter() in this test – e.g. since you’re already unit testing subscribeToNewsletter() somewhere else.

Then you create a PARTIAL mock of CustomerService, giving a list of methods you want to mock.

CustomerService customerService = PowerMock.createPartialMock(CustomerService.class, "subscribeToNewsletter");
customerService.subscribeToNewsletter(anyObject(Customer.class));

replayAll();

customerService.add(createMock(Customer.class));

So add() within the CustomerService mock is the REAL thing you want to test and for the method subscribeToNewsletter() you now can write an expectation as usual.

Disclaimer:

• Mocking partially like this only works with PUBLIC or DEFAULT methods. So for this one, I actually had to change subscribeToNewsletter() from PRIVATE to DEFAULT visibility to make it testable – which possible might not be desirable in all cases.
• Using a string “subscribeToNewsletter” which matches an actual method name is not very refactoring safe. Preferable you should at least a constant to discriminate from being any ordinary string. Anyway, your unit test will break sooner or later anyway if this method changes name – and you’ll know

For further reading, where PowerMock really excels is mocking of static methods and private methods.

The Blog-Health-o-Meter™ reads Fresher than ever.

Crunchy numbers

A Boeing 747-400 passenger jet can hold 416 passengers. This blog was viewed about 6,300 times in 2010. That’s about 15 full 747s.

In 2010, there were 7 new posts, growing the total archive of this blog to 19 posts. There were 18 pictures uploaded, taking up a total of 4mb. That’s about 2 pictures per month.

The busiest day of the year was July 1st with 139 views. The most popular post that day was GORM and Hibernate’s session factory.

Where did they come from?

The top referring sites in 2010 were grailstutorials.com, dzone.com, grails.org, observatoriodegrails.com, and pedrocorreia.net.

Some visitors came searching, mostly for handen en voeten geven, eclipse repository registry initialization, david hasselhoff, grails form validation, and initializing java tooling.

Attractions in 2010

These are the posts and pages that got the most views in 2010.

GORM and Hibernate’s session factory July 2010
4 comments

Grails remote jQuery form validation March 2010
2 comments

Eclipse “Initializing Java Tooling” hangs June 2010

Separating and securing Grails controllers June 2010
1 comment

The Do-It-Yourself Posable Paper of David Hasselhoff May 2009

@BeforeMethod
public void setUp() {
	DatabaseFiller.fillTable("UserAccounts", "useraccounts.txt");
}

@AfterMethod
public void tearDown() {
	DatabaseFiller.clearTable("UserAccounts");
}

It bugged a little bit, that in this testcase e.g. we’re testing operations on the User entity (e.g. User.class) – which for database specific reasons was mapped to a “UserAccounts” table – but we still have to find the actual table name for ourselves. There are many reasons to map explicitly to a certain table name: prevent database reserved keywords (“user” is often reserved), enforce a naming convention (“tbl_user”), etc. If no specifics have been set for Hibernate it will take its own naming convention, else one could indicate the desired name through the javax.persistence.Table annotation – if using JPA.

Our User entity is described like this:

@Entity
@Table(name = "UserAccounts")
public class User {
...

which results in a “UserAccounts” table being used by the underlying provider – instead of the default naming convention.

The issue is that with a lot of entities a developer can not guess from the entity itself what table is being used actually. He can guess, due to clear company development guidelines, a table name based on the entity name, but he only knows for sure if looking at the code. In our example, clearing tables based on the table name can break if – for whatever reason – an entity is renamed and no specific table name was set. Ofcourse, renaming database tables can break a lot more than just the clearing of it in a unit test – it usually doesn’t happen very often and if it does, it needs to be done with care.

Next to that, it’s just an inconvenience for the developer having to look up the table name when he already knows the entity he wants to clear from the system. Woudn’t it be great to point to the entity itself? Hence, let us introduce a better solution using Hibernate metadata!

Hibernate metadata is all about the accessing the Hibernate runtime metamodel, including collections and entities. The ClassMetadata interface allows access to an entity’s identifier, name, properties and versioning information – which is thus perfectly capable of telling us the table name. This metadata is retrieved for an entity through Hibernate’s session factory, which for instance can be exposed like this in our Spring configuration:

<bean id="sessionFactory" factory-bean="entityManagerFactory" factory-method="getSessionFactory" />

Our earlier used Database class can be wired together with this session factory – if also loaded as a Spring bean and pointing to the session factory bean. Here’s an example – which for brevity omits the getters and setters.

public class DatabaseFiller {

    @PersistenceContext
    private EntityManager entityManager;

    private SessionFactory sessionFactory;

We can now modify it with a method which returns the table name for an entity class:

/**
 * Return the table name used by Hibernate for given <code>persistentClass</code>.
 *
 * @param persistentClass
 *            The class of the entity
 * @return the table name
 * @throws NullPointerException
 *             if the <code>persistentClass</code> is null
 * @throws IllegalArgumentException
 *             if the <code>persistentClass</code> has no class metadata to get the table name from
 */
public String getTableName(Class persistentClass) {
	if (persistentClass == null) {
		throw new NullPointerException("persistent class");
	}

	ClassMetadata classMetadata = sessionFactory.getClassMetadata(persistentClass);
	if (classMetadata == null) {
		throw new IllegalArgumentException("No class metadata.");
	}

	if (classMetadata instanceof AbstractEntityPersister) {
		return ((AbstractEntityPersister) classMetadata).getTableName();
	} else {
		throw new RuntimeException("Unknown implementation.");
	}
}

Ofcourse, you can do whatever you want if things fail, return null instead of an exception for instance. Using Spring it’s only more easy to hook up the required beans, but it’s not a prerequisite.

Now we can alter our DatabaseFiller.clearTable method to accept a class,  internally lookup the table name and perform the same logic it always does. The developer isn’t bothered anymore to lookup the table name him or herself which is basically the point of this excercise.

@AfterMethod
public void tearDown() {
	DatabaseFiller.clearTable(User.class);
}

To summarize, Hibernate’s metadata API is a very powerful aid in getting the runtime information you might possibly need on your datamodel.

Hibernate is a session-based ORM framework.

A session is retrieved from Hibernate’s SessionFactory (org.hibernate.SessionFactory) which implements a design pattern that ensures that only one instance of the session is used per thread. GORM uses this factory to get the session – and so should you if you ever need the true power of executing raw SQL in your Grails application!

An example of executing SQL yourself:

 	String sql = "some update SQL"
	Session session = sessionFactory.openSession()
 	Connection c = session.connection()
	try {
		try {
			Statement s = c.createStatement()
			s.executeUpdate sql
		}
		catch (all e) {
			log.warn "Error executing statement $sql ($e)"
		}
	}
	finally {
		session.close()
		c.close()
	}

Essential is to have the session factory auto-injected into your class, by putting the following somewhere on top:

    def sessionFactory

Initializing Java Tooling

Repository registry initialization

STS/Eclipse does not seem to respond to anything – the UI freezes and that’s it! I’ve had this on several occassions with no apparent cause on my part. Usually it has something to do with fiddling with (adding libraries to) the classpath and/or cleaning the project. Some users report Eclipse hangs at “Initializing Java Tooling” at 30% for 20-30 secs after which everything continues normally, but I don’t have that much luck

I’ve tried the most suggested actions in forum posts, such a starting STS/Eclipse with the -clean parameter which most of the times doesn’t work in my configuration. If you inspect the .log files under the workspace’s .metadata folder you might find something of interest, but quite often STS/Eclipse just hangs without anything written to the log in my case. The largeness of your project or the amount of projects quite often seem to be one of the causes. Here are a few workarounds and/or solutions that might prove succesful:

• Start a new workspace and import the project back in – which is just plain tedious and annoying although it quite often works
• Close all projects before you exit Eclipse after which Eclipse normally restarts.
• Some users have reported it does seem related to a configured Tomcat server instance. If you have this configured a possible workaround instead of reimporting your projects in a new workspace, is to rename the .project file in workspace/Servers, restarting, removing and adding the Server configuration again.
• The solution I found – which seems to work most of the times – is to remove or rename the .projects folder in .metadata/.plugins/org.eclipse.core.resources in the workspace folder. This doesn’t seem to affect any project and the .project folder will be recreated when Eclipse restarts.

Hopefully someone with this problem saves some time because of this. Ofcourse the real problem needs to be addressed by the guys and girls over at Eclipse.

I had to make a subset of my Grails 1.2.2 application controllers only available to a certain group of people. A few controllers made actions on the application possible which only Administrators were allowed to do.

Acegi what?

So, I think everybody recognizes the ever so popular Acegi way (using Spring Security) of securing things with a single com.app.controller.HelloController in SecurityConfig.groovy:

security {
	active = true

	useRequestMapDomainClass = false
	requestMapString = """
		CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
		PATTERN_TYPE_APACHE_ANT

		/hello/**=ROLE_USER
		/**=IS_AUTHENTICATED_ANONYMOUSLY
	"""
}

This way a login-screen will appear when a user tries to open the HelloController on /hello since ROLE_USER is required. Well, not really high-tech yet – a basic example you could find in the Acegi plugin’s documentation as well.

More…more controllers!

Let’s introduce several other controllers next to the com.app.controller.HelloController. Notice I myself made up the package name com.app.controller – just a habit to seperate Domain classes, Controllers and Services into com.app.domain, com.app.controller and com.app.services.

Anyway, see here a package structure with a few new controllers:

com.app.controller
 \ HelloController.groovy
 \ ImportController.groovy
 \ BackupController.groovy
com.app.domain
 \ User.groovy
 \ Role.groovy

Now, it isn’t surprising that ImportController and BackupController might be used for several system administration functions, such as importing of backing up data – not to be messed with by regular users! In SecurityConfig we would have to adjust the settings in order to only allow Administrators to do execute these kind of backend-controllers.

security {
	active = true

	useRequestMapDomainClass = false
	requestMapString = """
		CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
		PATTERN_TYPE_APACHE_ANT

		/import/**=ROLE_ADMIN
		/backup/**=ROLE_ADMIN
		/hello/**=ROLE_USER
		/**=IS_AUTHENTICATED_ANONYMOUSLY
	"""
}

The problem I had in my development team, was that any developer might be developing some kind of backend or ‘administration’ controller – without adding the appropratiate changes in SecurityConfig. Next of all, when the list grows to…

/scrub/**=ROLE_ADMIN
/settings/remove**=ROLE_ADMIN
/settings/delete**=ROLE_ADMIN
/run/**=ROLE_ADMIN
/export2/**=ROLE_ADMIN
/another/**=ROLE_ADMIN
/schedule/**=ROLE_ADMIN
/export/**=ROLE_ADMIN
/import/**=ROLE_ADMIN
/backup/**=ROLE_ADMIN

…you’ll need something more centralized

I could either use annotations for each controller at the action or class-level, such as @Secured(['ROLE_ADMIN']), but then each developer had to remember to add these constructs to each backend-controller instead of adding a requestmap entry in SecurityConfig.

Depending on your needs annotations just might be your preferred way of doing this, but I choose to take a less intrusive (and in my opinion more fail-safe) way to separate these controllers from the rest. Here’s the summary:

• Move the backend-controllers into a separate package
• Have url mappings and SecurityConfig do the crunch work!

Seperate package

Move the backend controllers to a seperate subpackage e.g. com.app.controller.admin.

com.app.controller
 \ HelloController.groovy
com.app.controller.admin
 \ ImportController.groovy
 \ BackupController.groovy
com.app.domain
 \ User.groovy
 \ Role.groovy

Note that the controllers are still accessible on the original url’s – no matter their changed packages! One could still execute domain.com/import to access the ImportController.

Change url mapping

In UrlMappings.groovy we have to add a few bits – mainly I want the backend controllers to be accessible under the /admin url and disallow access on the original ones.

First we make a convenience method inside UrlMappings to locate and list controllers with a certain package name.

/**
 * Returns a list of controller names starting with specified package name.
 *
 * @param packageName The name the controller package should start with
 * @return the names of the controllers
 */
private static def findControllersInPackage(String packageName) {
	def controllers = []
	ApplicationHolder.application.controllerClasses.findAll{ c -> c.packageName.startsWith( packageName ) }.each { c ->
		controllers.add(c.logicalPropertyName)
	}
	return controllers
}

…and second we iterate over these controllers and make them work on our new url and disable them on the original url.

class UrlMappings {
	static mappings = {

		// collect controllers
		def secureControllers = findControllersInPackage("com.app.controller.admin")

		// disallow secured controllers on normal url
		"/$controller/$action?/$id?"{
			constraints {
				controller(validator: {
					   return !secureControllers.contains(it)
				})
			}
		}

		// allow secured controllers on secured url
		secureControllers.each { controllerName ->
			"/admin/${controllerName}/$action?/$id?" {
				controller = controllerName
			}

		}

		// errors
		"500"(view:'/error')
	}

	private static def findControllersInPackage(String packageName) {
		//...
	}
}

The way we collect the appropriate controllers allows me to even have controllers in sub sub subpackages under com.app.controller.admin. You’ll find that /import no longer works, but now you can find it under /admin/import – because of the url mappings disallow the original mappings, even generated or scaffolded GSP’s pages (with their createLink()‘s) keep working.

Secure url

Well, the only thing left to do, is shorten our SecurityConfig – securing everything under /admin will make things work nicely for us:

security {
	active = true

	useRequestMapDomainClass = false
	requestMapString = """
		CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
		PATTERN_TYPE_APACHE_ANT

		/admin/**=ROLE_ADMIN
		/hello/**=ROLE_USER
		/**=IS_AUTHENTICATED_ANONYMOUSLY
	"""
}

Just instruct your fellow team members to put the appropriate controllers under the right package and they are instantaneously secured

The password specified was incorrect. Please enter the correct password for the postgres windows user account.

Having followed several forum posts, suggesting to restart the PostgreSQL Service or changing the postgres password in the Computer Management MMC, all didn’t work – I didn’t install Postgres yet so there was no service to be found.

To make sure there really was no user present I executed the following at the command line:

net user postgres /delete

The first time the command returned as succesfully and the 2nd time it stated it couldn’t find the ‘postgres’ user – meaning the 1st time it was present – and succesfully deleted. I started the installer again and all went like clockwork!

Below a simple example HTML snippet to validate a postal code field:

<script type="text/javascript">
$(function (){
	$("#form").validate({
		rules: {
			'address.postalCode': {
				required: true
			},
		},
		messages: {
			'address.postalCode': {
				required: "Please enter a postal code."
			}
		}
	});
});
</script>
<g:form method="post" action="register" name="form">
	<input type="text" name="address.postalCode" id="postalCode" />
	<input type="submit" value="Proceed" />
</g:form>

As you can see: a simple ‘required’ rule is specified for field with name address.postalCode and errormessage to go with it. Notice that special field names e.g. with a dot requires a notation with quotes around it.

Now, let’s say we need to validate the postal code on the server side for validity and still need to have the form validation performed by jQuery – and not inside the controller and returing some kind of error- or flash message. Use the remote rule!

As the documentation states:

The serverside resource is called via $.ajax (XMLHttpRequest) and gets a key/value pair, corresponding to the name of the validated element and its value as a GET parameter. The response is evaluated as JSON and must be true for valid elements, and can be any false, undefined or null for invalid elements, using the default message; or a string, eg. “That name is already taken, try peter123 instead” to display as the error message.

We create a controller which does such a thing: check the submitted postal code, verify it against some kind of backend service or database table and return the expected JSON return values.

E.g. let’s expand our form HTML with the following:

<script type="text/javascript">
	$(function (){
		$("#form").validate({
			rules: {
				'address.postalCode': {
					required: true,
					remote: {
						url: "${createLink(controller:'postalCode', action:'validate')}",
						type: "post",
						data: {
							postalCode: function() {
								return $("#postalCode").val();
						  }
						}
					  }
				},
			},
			messages: {
				'address.postalCode': {
					required: "Please enter a postal code.",
					remote: "Please enter a valid postal code."
				}
			}
		});
	});
</script>
<g:form method="post" action="register" name="form">
	<input type="text" name="address.postalCode" id="postalCode" />
	<input type="submit" value="Proceed" />
</g:form>

As you can see, the remote rule specifies a resource which is one of our controllers and a specified action. As data for our Grails action we pass along the current value of the post code field – using the ‘data’ block with a function.

Our PostalCodeController may have the following validate action:

class PostalCodeController {

	def postalCodeService

	def validate = {
		String pc = params.postalCode

		String result = "false"
		if (postalCodeService.checkPostalCode(pc)) {
			result = "true"
		}

		response.setContentType("text/json;charset=UTF-8");
		render result
	}
}

Voila! We validate our data (which we simply read from the params) en return a string “true” if it’s valid else “false”.

Upon form submission our action is called and the outcome is used by jQuery to validate the user data! I couldn’t get my response rendered via the usual Grails JSON builder which seems to have trouble with single values (such as “true” or “false”), but set the content type directly. You might want to send additional caching headers along with the JSON response to prevent browser caching, but that’s all left as an excercise for the reader.

class BookTests extends GrailsUnitTestCase {
 void testConstraints() {
 def existingBook = new Book(title: "Misery", author: "Stephen King")
 mockForConstraintsTests(Book, [ existingBook ])

 // Validation should fail if both properties are null.
 def book = new Book()
 assertFalse book.validate()
 assertEquals "nullable", book.errors["title"]
 assertEquals "nullable", book.errors["author"]

 // So let's demonstrate the unique and minSize constraints.
 book = new Book(title: "Misery", author: "JK")
 assertFalse book.validate()
 assertEquals "unique", book.errors["title"]
 assertEquals "minSize", book.errors["author"]

 // Validation should pass!
 book = new Book(title: "The Shining", author: "Stephen King")
 assertTrue book.validate()
 }
}

Recently in a Grails 1.0.5 project I had to unit test a service method. Because of several “log” statements, I had the dreaded

groovy.lang.MissingPropertyException:
No such property: log for class:  SubscriptionService

Fortunately, the testing framework has the excellent mock Logging() method in place for that, which provides a mock implementation of the “log” property for the given class, in my case SubscriptionService. Here’s how I created my setUp() method:

void setUp() {
 mockLogging(SubscriptionService.class, true)
}

This resulted in

java.lang.NullPointerException:
Cannot invoke method containsKey() on null object

It was a NPE on the following part inside GrailsUnitTestCase.groovy:

protected void registerMetaClass(Class clazz) {
 // If the class has already been registered, then there's
 // nothing to do.
 if (savedMetaClasses.containsKey(clazz)) return
...

After some digging around, it almost seemed to trivial to fix thix. Just add called the super’s setUp() first.

void setUp() {
 super.setUp()
 mockLogging(SubscriptionService.class, true)
}

Happy mocking!