Prabhu Sunderaraman

Continuing with the series of posts on Spock framework for Groovy, let’s discuss testing the exceptions for the Calculator class. The Calculator class with two methods add and divide are given below.

//Calculator.groovy
class Calculator {
	def add(num1,num2){
		num1 + num2
	}
	def divide(num1,num2){
		if(num2 == 0)
			throw new Exception("Invalid argument. Cannot be zero")
		num1/num2
	}
}

Say you want to test the divide function in the CalculatorSpec.groovy. Spock provides two functions that thrown and notThrown that can be used to test the exception rules. Let’s write a feature to check if the exception is thrown and another feature to check if the exception is not thrown. The code is given below.

class CalculatorSpec extends Specification{
	Calculator calc
	def setup(){
		calc = new Calculator()
	}
	def cleanup(){
		calc = null;
	}
       def "divide by zero"(){
		when:
			calc.divide(12, 0)
		then:
			Exception e = thrown(Exception)	
			e.message == "Invalid argument. Cannot be zero"
	}
	def "divide"(){
		when:
			calc.divide(12, 10)
		then:
			notThrown(Exception)
	}
}

In the code above we have two feature methods “divide by zero” that tests if the exception is thrown and also the error message, “divide” that can be used to test if the exception is not thrown in case of valid arguments.

In the last three posts we’ve discussed using various features of Spock framework. In the next post we’ll discuss mocking behavior with Spock.

The DSL capability of Groovy is a well known fact. When it comes to writing test cases for Groovy/Grails applications the API has always been not a very pleasant one. People talk about the unit tests being the best documentation for the code you write, but the assert methods and the lines of preparatory code before these assert conditions make the test cases poorly readable. Enter Spock.

Spock is a testing and specification framework. The USP of Spock is the expressive syntax, harnessing the power of DSL. You can write specifications( or specs) in Spock and run it using JUnit.

To begin with, you can create a Groovy project and add spock library and JUnit libraries to your build path. In my project I have spock-core-0.6-groovy-1.8.jar added to the classpath. The groovy compiler version is 1.8.
You can create a simple Calculator class with add method as shown below.

//Calculator.groovy
class Calculator {
	def add(num1,num2){
		num1 + num2
	}
}

We would anyday prefer building the Calculator class using TDD, but that’s not the intention of this post. Let’s create a specification called CalculatorSpec and describe what we want to do using Spock. The CalculatorSpec would extend Specification class. A spec is composed of features. Each feature is implemented as a simple method that’s made up of blocks.
To keep it simple, the features are like the test methods inside a testcase. The CalculatorSpec with a feature is shown below.

//CalculatorSpec.groovy
import spock.lang.Specification;

class CalculatorSpec extends Specification{
	Calculator calc
	def "addition of 2 numbers"(){
		given:
			calc = new Calculator()
		expect:
			31 == calc.add(15,16)	
	}
}

The CalculatorSpec has a feature called “addition of 2 numbers”. You can compare this with the traditional test method such as def testAdditionOf2Numbers(). The feature method has the given and expect blocks. You can compare the expect block with the traditional assertTrue method. Running this spec as a JUnit test case gives you the expected results.

We’ve just scratched the surface of Spock. In the next few articles let’s build this CalculatorSpec to witness the real power of Spock.