In this series of articles, I am presenting selected BDD frameworks. In this part, I will talk about Spock – a unit testing framework.
Writing unit tests with Spock framework
Spock is a framework in which the test are written with a language called Groovy. Here the natural language layer is not separated from the logic that is responsible for the test activity, but possesses the keywords given
, when
, and then
, which can help you understand the test.
Test definition in Spock
In the Spock framework, a testing class must inherit from the Specification class:
class CalculateAreaTest extends Specification {
}
The test begins with the phrase def
:
def "Testing methods area of circle"() {
given: "init"
def calculateArea = new CalculateArea()
def radius = 2
def expectedValue = 12.566370614359172
when: "Calculation of the circle"
def result = calculateArea.areaOfCircle(radius)
then: "Check result"
result == expectedValue
}
Data Table – testing several values
An interesting option we can use here is the Data Table. Input and output of the test can be provided in the table. So that we can simultaneously check several values in one test.
def "Testing methods area of circle - Data Tables"(int radius, double expectedValue) {
given: "init"
def calculateArea = new CalculateArea()
expect: "Checking the value from the table"
calculateArea.areaOfCircle(radius) == expectedValue
where: "Values for the variables"
radius | expectedValue
1 | 3.141592653589793
7 | 153.93804002589985
0 | 0
}
Testing the calling of a method
Another useful feature of Spock is to test whether a particular method has been performed. This function may be useful to us when the method we are testing comes from some interface and we have to check if it has been called a certain number of times.
def "Testing methods area of square"() {
given: "init"
def calculateArea = new CalculateArea()
def valueX = 2
def valueY = 2
def listener = Mock(OnSquareListener)
def expectedValue = 4
when: "Calculation of the square"
calculateArea.areaOfSquare(valueX, valueY, listener)
then: "Verify that appropriate methods are called"
1 * listener.onSuccess(expectedValue)
0 * listener.onFailed()
}
In the code "quantity"
determines how many times a given method should be called: quantity * object.method().
Additional elements
Sometimes we need additional Android elements. Such as context, for testing. For such needs, we can use additional annotations:
@UseActivity(MyActivity)
@UseApplication(MyApplication)
@WithContext
Example use of annotations:
class ContextTest extends Specification {
@WithContext
def context
def "Test context"() {
expect:
context != null
}
}
It should be remembered that when we want to use Android elements, a test needs to be placed in the directory: app/src/androidTest/groovy.
However, when we do not need these elements, we put the files in the directory: app/src/test/groovy. All files have the extension .groovy
.
The installation of the Android elements proceeds as follows:
buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.2.2'
classpath 'org.codehaus.groovy:groovy-android-gradle-plugin:1.1.0'
}
}
Next:
apply plugin: 'com.android.application'
apply plugin: 'groovyx.android'
android {
defaultConfig {
...
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
packagingOptions {
exclude 'META-INF/services/org.codehaus.groovy.transform.ASTTransformation'
exclude 'LICENSE.txt'
}
}
dependencies {
//spock without components Android
testCompile 'org.spockframework:spock-core:1.0-groovy-2.4'
//spock with elements of Android
androidTestCompile 'org.codehaus.groovy:groovy:2.4.4:grooid'
androidTestCompile('org.spockframework:spock-core:1.0-groovy-2.4') {
exclude group: 'org.codehaus.groovy'
exclude group: 'junit'
}
androidTestCompile 'com.andrewreitz:spock-android:1.2.2'
androidTestCompile 'com.crittercism.dexmaker:dexmaker:1.4'
}
BDD frameworks
Behavior-Driven Development is a useful process for testing application functionality.
Thanks to BDD testing tools like Calabash used with the Cucumber framework or Green Coffee based on Gherkin, everyone involved in the project can easily verify the views of the Android app being designed. And check if the functionalities fulfill the criteria for acceptance that were stated in the requirements.
The Spock framework helps Unit testing be performed efficiently. Now the communication between programmer, manager and customer will be clear, and automated software testing will end in success!
Check our previous article: BDD frameworks (part 2).
You can find the source code on my GitHub.
Popular posts

From Hype to Hard Hats: Practical Use Cases for AI chatbots in Construction and Proptech.
Remember the multimedia craze in the early 2000s? It was everywhere, but did it truly revolutionize our lives? Probably not. Today, it feels like every piece of software is labeled "AI-powered." It's easy to dismiss AI chatbots in construction as just another tech fad.
Read more
Fears surrounding external support. How to address concerns about outsourcing software development?
Whether you’ve had bad experiences in the past or no experience at all, there will always be fears underlying your decision to outsource software development.
Read more
What do you actually seek from external support? Identify what’s preventing you from completing a project on time and within budget
Let’s make it clear: if the capabilities are there, a project is best delivered internally. Sometimes, however, we are missing certain capabilities that are required to deliver said project in a realistic timeline. These may be related to skills (e.g. technical expertise, domain experience), budget (hiring locally is too expensive) or just capacity (not enough manpower). What are good reasons for outsourcing software development?
Read more