Grails Testing Plugin Log Mocking

I’m a big fan of the famous Grails Testing Plugin, which is used to mock domain classes, controllers and many more things usually needed in my unit tests for Grails.  Here’s a quick example from its documentation:

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!

Handen en voeten geven

Iets “handjes en voetjes geven” is een uitdrukking welke vaak voor komt in het lijstje taal-ergenisssen. In feite betekent het gewoon “uitwerken”. Die ideeën zou ik graag handen en voeten geven. = Die ideeën zou ik graag uitwerken.

Beeldspraak, zoals iets handen en voeten geven, wordt veelal gebruikt om iets aan te duiden wat anderzins met teveel woorden uitgelegd moet worden (zoals een plaatje meer kan zeggen dan 1000 woorden) of simpelweg om iets interessanter te maken dan dat het is. Zeker in de vele managementlagen die we rijk zijn wordt het maar al te vaak gebruikt om vooraal vaag te blijven. Meer technisch: beeldspraak is een taalvorm waarbij een gedachte of een begrip indirect tot uiting wordt gebracht in beeldende vorm. Iets wordt vergeleken met (of vervangen door)  iets anders.

Beeldspraak gebruiken we tijdens alledaagse gesprekken zonder dat we er erg in hebben, maar bepaalde uitdrukkingen halen het bloed onder je nagels vandaan.  Sommigen zijn geen eens beeldspraak, maar een verhaspeling of verkeerd ingestoken zinsconstructie die simpelweg lekker bekt.

Hoe gaan we dit stukje inregelgebeuren aanvliegen? Zoals Vaagtaal.nl al aangeeft: “een stukje taart is okee, een stukje kwaliteitszorg niet”. Verder hebben we inregelen; is dit opzetten, aanpassen, configureren of allemaal? Als je uberhaupt nog een zelfstandig naamwoord tekort komt, is gebeuren your best friend. Waar een object “een ding” kan zijn, wordt een handeling of een gebeurtenis een “gebeuren”. Als laatste wordt je als piloot van een vliegtuig gevraagd de juiste route aan te vliegen, ofwel een juiste richting te kiezen, ofwel de correcte manier te bepalen om dit in te steken.

Vele uitspraken zijn nog niet eens zo fris: we moeten dat in het snotje houden (in de gaten houden) en  Henk moet er zijn plasje over doen (hij heeft er een mening over en moet dat nog laten weten, ookwel; jezelf laten gelden zoals hondjes ook hun territorium afbakenen).  Hans van Mierlo, Nederlands minister van Buitenlandse Zaken in 1994, zei toen dat Den Haag in het vervolg meer “in de oksel van de Frans-Duitse as zou moeten leunen.” (De betekenis hiervan is left as an exercise for the reader :D )

A Brief, Incomplete, and Mostly Wrong History of Programming Languages

A great overview of how it really, really happened. Especially about these novelties.

1996 – James Gosling invents Java. Java is a relatively verbose, garbage collected, class based, statically typed, single dispatch, object oriented language with single implementation inheritance and multiple interface inheritance. Sun loudly heralds Java’s novelty.

2001 – Anders Hejlsberg invents C#. C# is a relatively verbose, garbage collected, class based, statically typed, single dispatch, object oriented language with single implementation inheritance and multiple interface inheritance. Microsoft loudly heralds C#’s novelty.

More at James’ blog.