{"id":10565,"date":"2012-09-15T17:59:00","date_gmt":"2012-09-15T16:59:00","guid":{"rendered":"http:\/\/touk.pl\/blog\/?guid=4487c8802be7c090371cc8fa9c5b4c63"},"modified":"2022-08-02T11:34:40","modified_gmt":"2022-08-02T09:34:40","slug":"how-to-automate-tests-with-groovy-2-0-spock-and-gradle","status":"publish","type":"post","link":"https:\/\/touk.pl\/blog\/2012\/09\/15\/how-to-automate-tests-with-groovy-2-0-spock-and-gradle\/","title":{"rendered":"How to automate tests with Groovy 2.0, Spock and Gradle"},"content":{"rendered":"

This is the launch of the 1st blog in my life, so cheers and have a nice reading!<\/p>\n

y u no test?<\/h2>\n

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<\/i> was easily spotted in test sources.<\/p>\n

Some goodies at hand<\/h2>\n

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>… I’m talking about the Spock Framework<\/a><\/i>. 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.<\/p>\n

An obstacle<\/h2>\n

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

What now?<\/h2>\n

Well, in a matter of fact there is such a version. It’s still under development though. It can be obtained from this Maven<\/i> repository<\/a>. We can of course use the Maven<\/i> 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<\/a><\/i>.<\/p>\n

The build file<\/h2>\n

Update:<\/u> at the end of the post is updated version of the build file.<\/p>\n

apply plugin: 'groovy'\r\napply plugin: 'idea'\r\n\r\ndef langLevel = 1.7\r\n\r\nsourceCompatibility = langLevel\r\ntargetCompatibility = langLevel\r\n\r\ngroup = 'com.tamashumi.example.testwithspock'\r\nversion = '0.1'\r\n\r\nrepositories {\r\n    mavenLocal()\r\n    mavenCentral()\r\n    maven { url 'http:\/\/oss.sonatype.org\/content\/repositories\/snapshots\/' }\r\n}\r\n\r\ndependencies {\r\n    groovy 'org.codehaus.groovy:groovy-all:2.0.1'\r\n    testCompile 'org.spockframework:spock-core:0.7-groovy-2.0-SNAPSHOT'\r\n}\r\n\r\nidea {\r\n    project {\r\n        jdkName = langLevel\r\n        languageLevel = langLevel\r\n    }\r\n}<\/pre>\n
 <\/p>\n
As you can see the build.gradle<\/i> 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.<\/p>\n
Project structure and execution<\/h2>\n
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:<\/p>\n
<project root>\r\n\u2502\r\n\u251c\u2500\u2500 build.gradle\r\n\u2514\u2500\u2500 src\r\n    \u251c\u2500\u2500 main\r\n    \u2502   \u2514\u2500\u2500 groovy\r\n    \u2514\u2500\u2500 test\r\n        \u2514\u2500\u2500 groovy<\/pre>\n
To build a project now you can type command gradle build<\/span> or gradle test<\/span> to only run tests.<\/p>\n
How about Java?<\/h2>\n
You can test native Java code with Spock.<\/b> Just add src\/main\/java<\/span> directory and a following line to the build.gradle<\/i>:<\/p>\n
apply plugin: ‘java’<\/p>\n
apply plugin: 'java'<\/pre>\n
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.<\/p>\n
A silly-simple example<\/h2>\n
Just to show that it works, here you go with a basic example.<\/p>\n
Java simple example class:<\/h4>\n
public class SimpleJavaClass {\r\n\r\n    public int sumAll(int...args) {\r\n        int sum = 0;\r\n        for (int arg: args) {\r\n            sum += arg;\r\n        }\r\n        return sum;\r\n    }\r\n}<\/pre>\n
Groovy simple example class:<\/h4>\n
class SimpleGroovyClass {\r\n\r\n    String concatenateAll(char separator, String...args) {\r\n        args.join(separator as String)\r\n    }\r\n}<\/pre>\n
The test, uhm… I mean the Specification<\/i>:<\/h4>\n
class JustASpecification extends Specification {\r\n\r\n    @Unroll('Sums integers #integers into: #expectedResult')\r\n    def \"Can sum different amount of integers\"() {\r\n        given:\r\n            def instance = new SimpleJavaClass()\r\n        when:\r\n            def result = instance.sumAll( * integers)\r\n        then:\r\n            result == expectedResult\r\n\r\n        where:\r\n            expectedResult | integers\r\n\r\n        11 | [3, 3, 5]\r\n        8 | [3, 5]\r\n        254 | [2, 4, 8, 16, 32, 64, 128]\r\n        22 | [7, 5, 6, 2, 2]\r\n    }\r\n\r\n    @Unroll('Concatenates strings #strings with separator \"#separator\" into: #expectedResult')\r\n    def \"Can concatenate different amount of integers with a specified separator\"() {\r\n        given:\r\n            def instance = new SimpleGroovyClass()\r\n\r\n        when:\r\n            def result = instance.concatenateAll(separator, * strings)\r\n\r\n        then:\r\n            result == expectedResult\r\n        where:\r\n            expectedResult | separator | strings\r\n\r\n        'Whasup dude?' | ' '\r\n        as char | ['Whasup', 'dude?']\r\n        '2012\/09\/15' | '\/'\r\n        as char | ['2012', '09', '15']\r\n        'nice-to-meet-you' | '-'\r\n        as char | ['nice', 'to', 'meet', 'you']\r\n    }\r\n}<\/pre>\n
 <\/p>\n
To run tests with Gradle<\/i> simply execute command gradle test<\/span>. Test reports can be found at <project root>\/build\/reports\/tests\/index.html<\/span> and look kind a like this.<\/p>\n
<\/a><\/div>\n
Please note that, thanks to @Unroll<\/span> annotation, test is executed once per each parameters row in the ‘table’ at specification’s where: block<\/span>. This isn’t a Java label, but a AST transformation magic.<\/p>\n
IDE integration<\/h2>\n
Gradle’s plugin for Iintellij Idea<\/h4>\n
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<\/span><\/span> There are available Eclipse and Netbeans plugins too, however I haven’t tested them. Idea’s one works well.<\/p>\n
Intellij Idea’s plugins for Gradle<\/h4>\n
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.<\/p>\n
Running tests under IDE<\/h4>\n
Jest to add something sweet this is how Specification looks when run with jUnit\u00a0 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.<\/p>\n
<\/a><\/div>\n
Building web application<\/h2>\n
If you need to build Java web application and bundle it as war<\/i> archive just add plugin by typing the line<\/p>\n
apply plugin: 'war'<\/pre>\n
in the build.gradle<\/i> file and create a directory src\/main\/webapp<\/span>.<\/p>\n
Want to know more?<\/h2>\n
If you haven’t heard about Spock or Gradle before or just curious, check the following links:<\/p>\n