How to automate tests with Groovy 2.0, Spock and Gradle

This is the launch of the 1st blog in my life, so cheers and have a nice reading! y u no test? Couple of years ago I wasn’t a big fan of unit testing. It was obvious to me that well prepared unit tests are crucial though. I didn’t known why exactly crucial yet then. I just felt they are important. My disliking to write automation tests was mostly related to the effort necessary to prepare them. Also a spaghetti code was easily spotted in test sources. Some goodies at hand Now I know! Test are crucial to get a better design and a confidence. Confidence to improve without a hesitation. Moreover, now I have the tool to make test automation easy as Sunday morning… I’m talking about the Spock Framework. If you got here probably already know what the Spock is, so I won’t introduce it. Enough to say that Spock is an awesome unit testing tool which, thanks to Groovy AST Transformation, simplifies creation of tests greatly. An obstacle The point is, since a new major version of Groovy has been released (2.0), there is no matching version of Spock available yet. What now? Well, in a matter of fact there is such a version. It’s still under development though. It can be obtained from this Maven repository. We can of course use the Maven to build a project and run tests. But why not to go even more “groovy” way? XML is not for humans, is it? Lets use Gradle. The build file Update: at the end of the post is updated version of the build file. apply plugin: 'groovy' apply plugin: 'idea' def langLevel = 1.7 sourceCompatibility = langLevel targetCompatibility = langLevel group = 'com.tamashumi.example.testwithspock' version = '0.1' repositories { mavenLocal() mavenCentral() maven { url 'http://oss.sonatype.org/content/repositories/snapshots/' } } dependencies { groovy 'org.codehaus.groovy:groovy-all:2.0.1' testCompile 'org.spockframework:spock-core:0.7-groovy-2.0-SNAPSHOT' } idea { project { jdkName = langLevel languageLevel = langLevel } } As you can see the build.gradle file is almost self-explanatory. Groovy plugin is applied to compile groovy code. It needs groovy-all.jar – declared in version 2.0 at dependencies block just next to Spock in version 0.7. What’s most important, mentioned Maven repository URL is added at repositories block. Project structure and execution Gradle’s default project directory structure is similar to Maven’s one. Unfortunately there is no ‘create project’ task and you have to create it by hand. It’s not a big obstacle though. The structure you will create will more or less look as follows: <project root> │ ├── build.gradle └── src ├── main │ ├── groovy └── test └── groovy To build a project now you can type command gradle build or gradle test to only run tests. How about Java? You can test native Java code with Spock. Just add src/main/java directory and a following line to the build.gradle: apply plugin: 'java' This way if you don’t want or just can’t deploy Groovy compiled stuff into your production JVM for any reason, still whole goodness of testing with Spock and Groovy is at your hand. A silly-simple example Just to show that it works, here you go with a basic example. Java simple example class: public class SimpleJavaClass { public int sumAll(int... args) { int sum = 0; for (int arg : args){ sum += arg; } return sum; } } Groovy simple example class: class SimpleGroovyClass { String concatenateAll(char separator, String... args) { args.join(separator as String) } } The test, uhm… I mean the Specification: class JustASpecification extends Specification { @Unroll('Sums integers #integers into: #expectedResult') def "Can sum different amount of integers"() { given: def instance = new SimpleJavaClass() when: def result = instance.sumAll(* integers) then: result == expectedResult where: expectedResult | integers 11 | [3, 3, 5] 8 | [3, 5] 254 | [2, 4, 8, 16, 32, 64, 128] 22 | [7, 5, 6, 2, 2] } @Unroll('Concatenates strings #strings with separator "#separator" into: #expectedResult') def "Can concatenate different amount of integers with a specified separator"() { given: def instance = new SimpleGroovyClass() when: def result = instance.concatenateAll(separator, * strings) then: result == expectedResult where: expectedResult | separator | strings 'Whasup dude?' | ' ' as char | ['Whasup', 'dude?'] '2012/09/15' | '/' as char | ['2012', '09', '15'] 'nice-to-meet-you' | '-' as char | ['nice', 'to', 'meet', 'you'] } } To run tests with Gradle simply execute command gradle test. Test reports can be found at <project root>/build/reports/tests/index.html and look kind a like this. Please note that, thanks to @Unroll annotation, test is executed once per each parameters row in the ‘table’ at specification’s where: block. This isn’t a Java label, but a AST transformation magic. IDE integration Gradle’s plugin for Iintellij Idea I’ve added also Intellij Idea plugin for IDE project generation and some configuration for it (IDE’s JDK name). To generate Idea’s project files just run command: gradle idea There are available Eclipse and Netbeans plugins too, however I haven’t tested them. Idea’s one works well. Intellij Idea’s plugins for Gradle Idea itself has a light Gradle support built-in on its own. To not get confused: Gradle has plugin for Idea and Idea has plugin for Gradle. To get even more ‘pluginated’, there is also JetGradle plugin within Idea. However I haven’t found good reason for it’s existence – well, maybe excluding one. It shows dependency tree. There is a bug though – JetGradle work’s fine only for lang level 1.6. Strangely all the plugins together do not conflict each other. They even give complementary, quite useful tool set. Running tests under IDE Jest to add something sweet this is how Specification looks when run with jUnit  runner under Intellij Idea (right mouse button on JustASpecification class or whole folder of specification extending classes and select “Run …”. You’ll see a nice view like this. Building web application If you need to build Java web application and bundle it as war archive just add plugin by typing the line apply plugin: 'war' in the build.gradle file and create a directory src/main/webapp. Want to know more? If you haven’t heard about Spock or Gradle before or just curious, check the following links: Spock wiki (most important info is under SpockBasics and Interactions) Gradle user guide  What next? The last thing left is to write the real production code you are about to test. No matter will it be Groovy or Java, I leave this to your need and invention. Of course, you are welcome to post a comments here. I’ll answer or even write some more posts about the subject. Important update Spock version 0.7 has been released, so the above build file doesn’t work anymore. It’s easy to fix it though. Just remove last dash and a word SNAPSHOT from Spock dependency declaration. Other important thing is that now spock-core depends on groovy-all-2.0.5, so to avoid dependency conflict groovy dependency should be changed from version 2.0.1 to 2.0.5. Besides oss.sonata.org snapshots maven repository can be removed. No obstacles any more and the build file now looks as follows: apply plugin: 'groovy' apply plugin: 'idea' def langLevel = 1.7 sourceCompatibility = langLevel targetCompatibility = langLevel group = 'com.tamashumi.example.testwithspock' version = '0.1' repositories { mavenLocal() mavenCentral() } dependencies { groovy 'org.codehaus.groovy:groovy-all:2.0.5' testCompile 'org.spockframework:spock-core:0.7-groovy-2.0' } idea { project { jdkName = langLevel languageLevel = langLevel } }

This is the launch of the 1st blog in my life, so cheers and have a nice reading!

y u no test?

Couple of years ago I wasn’t a big fan of unit testing. It was obvious to me that well prepared unit tests are crucial though. I didn’t known why exactly crucial yet then. I just felt they are important. My disliking to write automation tests was mostly related to the effort necessary to prepare them. Also a spaghetti code was easily spotted in test sources.

Some goodies at hand

Now I know! Test are crucial to get a better design and a confidence. Confidence to improve without a hesitation. Moreover, now I have the tool to make test automation easy as Sunday morning… I’m talking about the Spock Framework. If you got here probably already know what the Spock is, so I won’t introduce it. Enough to say that Spock is an awesome unit testing tool which, thanks to Groovy AST Transformation, simplifies creation of tests greatly.

An obstacle

The point is, since a new major version of Groovy has been released (2.0), there is no matching version of Spock available yet.

What now?

Well, in a matter of fact there is such a version. It’s still under development though. It can be obtained from this Maven repository. We can of course use the Maven to build a project and run tests. But why not to go even more “groovy” way? XML is not for humans, is it? Lets use Gradle.

The build file

Update: at the end of the post is updated version of the build file.

apply plugin: 'groovy'
apply plugin: 'idea'

def langLevel = 1.7

sourceCompatibility = langLevel
targetCompatibility = langLevel

group = 'com.tamashumi.example.testwithspock'
version = '0.1'

repositories {
    mavenLocal()
    mavenCentral()
    maven { url 'http://oss.sonatype.org/content/repositories/snapshots/' }
}

dependencies {
    groovy 'org.codehaus.groovy:groovy-all:2.0.1'
    testCompile 'org.spockframework:spock-core:0.7-groovy-2.0-SNAPSHOT'
}

idea {
    project {
        jdkName = langLevel
        languageLevel = langLevel
    }
}

 

As you can see the build.gradle file is almost self-explanatory. Groovy plugin is applied to compile groovy code. It needs groovy-all.jar – declared in version 2.0 at dependencies block just next to Spock in version 0.7. What’s most important, mentioned Maven repository URL is added at repositories block.

Project structure and execution

Gradle’s default project directory structure is similar to Maven’s one. Unfortunately there is no ‘create project’ task and you have to create it by hand. It’s not a big obstacle though. The structure you will create will more or less look as follows:

<project root>
│
├── build.gradle
└── src
    ├── main
    │   └── groovy
    └── test
        └── groovy

To build a project now you can type command gradle build or gradle test to only run tests.

How about Java?

You can test native Java code with Spock. Just add src/main/java directory and a following line to the build.gradle:

apply plugin: ‘java’

apply plugin: 'java'

This way if you don’t want or just can’t deploy Groovy compiled stuff into your production JVM for any reason, still whole goodness of testing with Spock and Groovy is at your hand.

A silly-simple example

Just to show that it works, here you go with a basic example.

Java simple example class:

public class SimpleJavaClass {

    public int sumAll(int...args) {
        int sum = 0;
        for (int arg: args) {
            sum += arg;
        }
        return sum;
    }
}

Groovy simple example class:

class SimpleGroovyClass {

    String concatenateAll(char separator, String...args) {
        args.join(separator as String)
    }
}

The test, uhm… I mean the Specification:

class JustASpecification extends Specification {

    @Unroll('Sums integers #integers into: #expectedResult')
    def "Can sum different amount of integers"() {
        given:
            def instance = new SimpleJavaClass()
        when:
            def result = instance.sumAll( * integers)
        then:
            result == expectedResult

        where:
            expectedResult | integers

        11 | [3, 3, 5]
        8 | [3, 5]
        254 | [2, 4, 8, 16, 32, 64, 128]
        22 | [7, 5, 6, 2, 2]
    }

    @Unroll('Concatenates strings #strings with separator "#separator" into: #expectedResult')
    def "Can concatenate different amount of integers with a specified separator"() {
        given:
            def instance = new SimpleGroovyClass()

        when:
            def result = instance.concatenateAll(separator, * strings)

        then:
            result == expectedResult
        where:
            expectedResult | separator | strings

        'Whasup dude?' | ' '
        as char | ['Whasup', 'dude?']
        '2012/09/15' | '/'
        as char | ['2012', '09', '15']
        'nice-to-meet-you' | '-'
        as char | ['nice', 'to', 'meet', 'you']
    }
}

 

To run tests with Gradle simply execute command gradle test. Test reports can be found at <project root>/build/reports/tests/index.html and look kind a like this.

Please note that, thanks to @Unroll annotation, test is executed once per each parameters row in the ‘table’ at specification’s where: block. This isn’t a Java label, but a AST transformation magic.

IDE integration

Gradle’s plugin for Iintellij Idea

I’ve added also Intellij Idea plugin for IDE project generation and some configuration for it (IDE’s JDK name). To generate Idea’s project files just run command: gradle idea There are available Eclipse and Netbeans plugins too, however I haven’t tested them. Idea’s one works well.

Intellij Idea’s plugins for Gradle

Idea itself has a light Gradle support built-in on its own. To not get confused: Gradle has plugin for Idea and Idea has plugin for Gradle. To get even more ‘pluginated’, there is also JetGradle plugin within Idea. However I haven’t found good reason for it’s existence – well, maybe excluding one. It shows dependency tree. There is a bug though – JetGradle work’s fine only for lang level 1.6. Strangely all the plugins together do not conflict each other. They even give complementary, quite useful tool set.

Running tests under IDE

Jest to add something sweet this is how Specification looks when run with jUnit  runner under Intellij Idea (right mouse button on JustASpecification class or whole folder of specification extending classes and select “Run …”. You’ll see a nice view like this.

Building web application

If you need to build Java web application and bundle it as war archive just add plugin by typing the line

apply plugin: 'war'

in the build.gradle file and create a directory src/main/webapp.

Want to know more?

If you haven’t heard about Spock or Gradle before or just curious, check the following links:

What next?

The last thing left is to write the real production code you are about to test. No matter will it be Groovy or Java, I leave this to your need and invention. Of course, you are welcome to post a comments here. I’ll answer or even write some more posts about the subject.

Important update

Spock version 0.7 has been released, so the above build file doesn’t work anymore. It’s easy to fix it though. Just remove last dash and a word SNAPSHOT from Spock dependency declaration. Other important thing is that now spock-core depends on groovy-all-2.0.5, so to avoid dependency conflict groovy dependency should be changed from version 2.0.1 to 2.0.5.
Besides oss.sonata.org snapshots maven repository can be removed. No obstacles any more and the build file now looks as follows:

apply plugin: 'groovy'

apply plugin: 'idea'

def langLevel = 1.7

sourceCompatibility = langLevel

targetCompatibility = langLevel

group = 'com.tamashumi.example.testwithspock'

version = '0.1'

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    groovy 'org.codehaus.groovy:groovy-all:2.0.5'
    testCompile 'org.spockframework:spock-core:0.7-groovy-2.0'
}

idea {
    project {
        jdkName = langLevel
        languageLevel = langLevel

    }
}

 

You May Also Like

Multi module Gradle project with IDE support

This article is a short how-to about multi-module project setup with usage of the Gradle automation build tool.

Here's how Rich Seller, a StackOverflow user, describes Gradle:
Gradle promises to hit the sweet spot between Ant and Maven. It uses Ivy's approach for dependency resolution. It allows for convention over configuration but also includes Ant tasks as first class citizens. It also wisely allows you to use existing Maven/Ivy repositories.
So why would one use yet another JVM build tool such as Gradle? The answer is simple: to avoid frustration involved by Ant or Maven.

Short story

I was fooling around with some fresh proof of concept and needed a build tool. I'm pretty familiar with Maven so created project from an artifact, and opened the build file, pom.xml for further tuning.
I had been using Grails with its own build system (similar to Gradle, btw) already for some time up then, so after quite a time without Maven, I looked on the pom.xml and found it to be really repulsive.

Once again I felt clearly: XML is not for humans.

After quick googling I found Gradle. It was still in beta (0.8 version) back then, but it's configured with Groovy DSL and that's what a human likes :)

Where are we

In the time Ant can be met but among IT guerrillas, Maven is still on top and couple of others like for example Ivy conquer for the best position, Gradle smoothly went into its mature age. It's now available in 1.3 version, released at 20th of November 2012. I'm glad to recommend it to anyone looking for relief from XML configured tools, or for anyone just looking for simple, elastic and powerful build tool.

Lets build

I have already written about basic project structure so I skip this one, reminding only the basic project structure:
<project root>

├── build.gradle
└── src
├── main
│ ├── java
│ └── groovy

└── test
├── java
└── groovy
Have I just referred myself for the 1st time? Achievement unlocked! ;)

Gradle as most build tools is run from a command line with parameters. The main parameter for Gradle is a 'task name', for example we can run a command: gradle build.
There is no 'create project' task, so the directory structure has to be created by hand. This isn't a hassle though.
Java and groovy sub-folders aren't always mandatory. They depend on what compile plugin is used.

Parent project

Consider an example project 'the-app' of three modules, let say:
  1. database communication layer
  2. domain model and services layer
  3. web presentation layer
Our project directory tree will look like:
the-app

├── dao-layer
│ └── src

├── domain-model
│ └── src

├── web-frontend
│ └── src

├── build.gradle
└── settings.gradle
the-app itself has no src sub-folder as its purpose is only to contain sub-projects and build configuration. If needed it could've been provided with own src though.

To glue modules we need to fill settings.gradle file under the-app directory with a single line of content specifying module names:
include 'dao-layer', 'domain-model', 'web-frontend'
Now the gradle projects command can be executed to obtain such a result:
:projects

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'the-app'
+--- Project ':dao-layer'
+--- Project ':domain-model'
\--- Project ':web-frontend'
...so we know that Gradle noticed the modules. However gradle build command won't run successful yet because build.gradle file is still empty.

Sub project

As in Maven we can create separate build config file per each module. Let say we starting from DAO layer.
Thus we create a new file the-app/dao-layer/build.gradle with a line of basic build info (notice the new build.gradle was created under sub-project directory):
apply plugin: 'java'
This single line of config for any of modules is enough to execute gradle build command under the-app directory with following result:
:dao-layer:compileJava
:dao-layer:processResources UP-TO-DATE
:dao-layer:classes
:dao-layer:jar
:dao-layer:assemble
:dao-layer:compileTestJava UP-TO-DATE
:dao-layer:processTestResources UP-TO-DATE
:dao-layer:testClasses UP-TO-DATE
:dao-layer:test
:dao-layer:check
:dao-layer:build

BUILD SUCCESSFUL

Total time: 3.256 secs
To use Groovy plugin slightly more configuration is needed:
apply plugin: 'groovy'

repositories {
mavenLocal()
mavenCentral()
}

dependencies {
groovy 'org.codehaus.groovy:groovy-all:2.0.5'
}
At lines 3 to 6 Maven repositories are set. At line 9 dependency with groovy library version is specified. Of course plugin as 'java', 'groovy' and many more can be mixed each other.

If we have settings.gradle file and a build.gradle file for each module, there is no need for parent the-app/build.gradle file at all. Sure that's true but we can go another, better way.

One file to rule them all

Instead of creating many build.gradle config files, one per each module, we can use only the parent's one and make it a bit more juicy. So let us move the the-app/dao-layer/build.gradle a level up to the-app/build-gradle and fill it with new statements to achieve full project configuration:
def langLevel = 1.7

allprojects {

apply plugin: 'idea'

group = 'com.tamashumi'
version = '0.1'
}

subprojects {

apply plugin: 'groovy'

sourceCompatibility = langLevel
targetCompatibility = langLevel

repositories {
mavenLocal()
mavenCentral()
}

dependencies {
groovy 'org.codehaus.groovy:groovy-all:2.0.5'
testCompile 'org.spockframework:spock-core:0.7-groovy-2.0'
}
}

project(':dao-layer') {

dependencies {
compile 'org.hibernate:hibernate-core:4.1.7.Final'
}
}

project(':domain-model') {

dependencies {
compile project(':dao-layer')
}
}

project(':web-frontend') {

apply plugin: 'war'

dependencies {
compile project(':domain-model')
compile 'org.springframework:spring-webmvc:3.1.2.RELEASE'
}
}

idea {
project {
jdkName = langLevel
languageLevel = langLevel
}
}
At the beginning simple variable langLevel is declared. It's worth knowing that we can use almost any Groovy code inside build.gradle file, statements like for example if conditions, for/while loops, closures, switch-case, etc... Quite an advantage over inflexible XML, isn't it?

Next the allProjects block. Any configuration placed in it will influence - what a surprise - all projects, so the parent itself and sub-projects (modules). Inside of the block we have the IDE (Intellij Idea) plugin applied which I wrote more about in previous article (look under "IDE Integration" heading). Enough to say that with this plugin applied here, command gradle idea will generate Idea's project files with modules structure and dependencies. This works really well and plugins for other IDEs are available too.
Remaining two lines at this block define group and version for the project, similar as this is done by Maven.

After that subProjects block appears. It's related to all modules but not the parent project. So here the Groovy language plugin is applied, as all modules are assumed to be written in Groovy.
Below source and target language level are set.
After that come references to standard Maven repositories.
At the end of the block dependencies to groovy version and test library - Spock framework.

Following blocks, project(':module-name'), are responsible for each module configuration. They may be omitted unless allProjects or subProjects configure what's necessary for a specific module. In the example per module configuration goes as follow:
  • Dao-layer module has dependency to an ORM library - Hibernate
  • Domain-model module relies on dao-layer as a dependency. Keyword project is used here again for a reference to other module.
  • Web-frontend applies 'war' plugin which build this module into java web archive. Besides it referes to domain-model module and also use Spring MVC framework dependency.

At the end in idea block is basic info for IDE plugin. Those are parameters corresponding to the Idea's project general settings visible on the following screen shot.


jdkName should match the IDE's SDK name otherwise it has to be set manually under IDE on each Idea's project files (re)generation with gradle idea command.

Is that it?

In the matter of simplicity - yes. That's enough to automate modular application build with custom configuration per module. Not a rocket science, huh? Think about Maven's XML. It would take more effort to setup the same and still achieve less expressible configuration quite far from user-friendly.

Check the online user guide for a lot of configuration possibilities or better download Gradle and see the sample projects.
As a tasty bait take a look for this short choice of available plugins:
  • java
  • groovy
  • scala
  • cpp
  • eclipse
  • netbeans
  • ida
  • maven
  • osgi
  • war
  • ear
  • sonar
  • project-report
  • signing
and more, 3rd party plugins...