Setting up and Using Spock With Gradle

1. Overview

The Spock Framework is a testing and specification framework for Java and Groovy applications. Gradle is a popular build tool and a Maven alternative.

In this tutorial, we’ll show how to set up a project using Gradle and add Spock test dependencies. We’ll also quickly look and move gradually to fully integrating Spock with Spring, still using the Gradle build process.

2. Using Spock With Gradle

We’ll need to create a Gradle project and add Spock dependencies.

2.1. Setup a Gradle Project

First, let’s install Gradle on our system. A Gradle project can then be initialized using the gradle init command. Different options exist for creating, for example, an application or a library using Java or Kotlin.

In any case, a Gradle project will always get the configuration from:

• build.gradle. It contains info about the build process, such as the Java version or the libraries used for implementation or testing. We’ll refer to it as the build file.
• settings.gradle. It adds project-wise info, such as the project name or the submodule structure. We’ll refer to it as the settings file.

Gradle uses JVM plugins for a project’s compilation, testing, and bundling capabilities.

If we go for Java, we’ll keep it simple by using the ‘java‘ plugin because this is what it will eventually be extended.

Let’s check out a simple build skeleton for a Java 17 project:

plugins {
    id 'java'
}
repositories {
    mavenCentral()
}
dependencies {
    // test dependencies
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}
test {
    useJUnitPlatform()
    testLogging {
        events "started", "passed", "skipped", "failed"
    }
}

This file is the core component and defines the tasks necessary to build the project.

We added the JUnit5 test dependency:

testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'

We’ll need the useJUnitPlatform() specification in the test task to run the tests. We are also adding some properties for test logging so we have an output while the task is running:

test {
    useJUnitPlatform()
    testLogging {
        events "started", "passed", "skipped", "failed"
    }
}

We also see how our project will download the dependencies using, for example, the mavenCentral() repository:

repositories {
    mavenCentral()
}

Notably, some may find that the configuration is more readable than a Maven project with the XML-based pom.xml build configuration.

Finally, let’s also have a look at the settings file:

rootProject.name = 'spring-boot-testing-spock'

This is pretty straightforward and only configures the project name. However, it can contain relevant information, such as sub-module inclusion or plugin definition.

We can check the Gradle DSL reference for more info about the build or settings scripting.

2.2. Add Spock Dependencies

We need two simple steps to add Spock to our Gradle project:

• Add the ‘groovy’ plugin
• Add the Spock to the test dependencies

Let’s look at the build file:

plugins {
    id 'java'
    id 'groovy'
}
repositories {
    mavenCentral()
}
dependencies {
    // Spock test dependencies
    testImplementation 'org.spockframework:spock-core:2.4-M1-groovy-4.0'
    // Junit dependencies
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}
test {
    useJUnitPlatform()
    testLogging {
        events "started", "passed", "skipped", "failed"
    }
}

We must update our dependencies by adding the org.spockframework:spock-core test dependency:

testImplementation 'org.spockframework:spock-core:2.4-M1-groovy-4.0'

Notably, we don’t need to configure the GMavenPlus plugin as we would have to for a Maven project.

2.3. Run Tests

There are different types of tests we can do with Spock. Let’s have a look at a simple test case:

class SpockTest extends Specification {
    def "one plus one should equal two"() {
        expect:
        1 + 1 == 2
    }
}

Every test must extend the Specification class. Furthermore, the tests are defined as functions with the Groovy def syntax.

If we are used to programming in Java, we need to remember that Spock tests are, by default, in a different package and have another class extension. We must put our tests in the test/groovy folder if not otherwise specified. Furthermore, the class will have the .groovy extension, for example, SpockTest.groovy.

To run the tests, we need to execute the test task with our IDE or at the command line:

gradle test

Let’s check some example output:

Starting a Gradle Daemon (subsequent builds will be faster)
> Task :test
SpockTest > one plus one should equal two STARTED
SpockTest > one plus one should equal two PASSED
BUILD SUCCESSFUL in 15s
7 actionable tasks: 7 executed

Gradle uses a caching system and will only re-run tests that have changed since the last execution.

3. Using Spock, Gradle, and Spring

We may want to add Spock to a Spring project. Spock has a specific module for that.

Let’s have a look at Spock with a basic Spring configuration. Later on, we’ll also look at a Spring Boot setup. From now on, we are omitting the java and the test sections in the build file for brevity because they won’t change.

3.1. Spock and Spring

Suppose we have a Spring project and want to switch or adopt testing with Spock.

The dependency structure is getting more complex now in the build file, so let’s comment out every part properly:

plugins {
    id 'java'
    id 'groovy'
}
repositories {
    mavenCentral()
}
dependencies {
    // Spring implementation dependencies
    implementation 'org.springframework:spring-web:6.1.0'
    // Spring test dependencies
    testImplementation 'org.springframework:spring-test:6.1.0'
    // Spring Spock test dependencies
    testImplementation 'org.spockframework:spock-spring:2.4-M1-groovy-4.0'
    // Spock Core test dependencies
    testImplementation 'org.spockframework:spock-core:2.4-M1-groovy-4.0'
    // Junit Test dependencies
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

We add org.springframework:spring-web to demonstrate a simple Spring dependency. Furthermore, if we want to use the Spring test features, we must add the org.springframework:spring-test test dependency:

// Spring implementation dependencies
implementation 'org.springframework:spring-web:6.1.0'
// Spring test dependencies
testImplementation 'org.springframework:spring-test:6.1.0'

Finally, let’s add the org.spockframework:spock-spring dependency. This is the only dependency we need to integrate Spock and Spring:

// Spring Spock test dependencies
testImplementation 'org.spockframework:spock-spring:2.4-M1-groovy-4.0'

3.2. Spock and Spring Boot

We only need to replace the previous Spring’s basic dependencies with the Spring Boot ones.

Let’s look at the build file:

plugins {
    id 'java'
    id 'groovy'
}
repositories {
    mavenCentral()
}
dependencies {
    // Spring implementation dependencies
    implementation 'org.springframework.boot:spring-boot-starter-web:3.0.0'
    // Spring Test dependencies
    testImplementation 'org.springframework.boot:spring-boot-starter-test:3.0.0'
    // Spring Spock Test dependencies
    testImplementation 'org.spockframework:spock-spring:2.4-M1-groovy-4.0'
    // Spring Core Test dependencies
    testImplementation 'org.spockframework:spock-core:2.4-M1-groovy-4.0'
    // Junit Test dependencies
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

Notably, we are adding the Spring Boot dependencies:

// Spring implementation dependencies
implementation 'org.springframework.boot:spring-boot-starter-web:3.0.0'
// Spring Test dependencies
testImplementation 'org.springframework.boot:spring-boot-starter-test:3.0.0'

3.3. Spring and Gradle Dependency Management

Let’s finalize our setup using the Spring dependency management to make our configuration more compact and maintainable. This way, we adopt a BOM or “Bill Of Materials” oriented style similar to the Maven projects and only declare the version in a single place.

There are a couple of ways we can achieve this.

Let’s have a look at the first option:

plugins {
    id 'java'
    id 'groovy'
    id "org.springframework.boot" version "3.0.0"
    id 'io.spring.dependency-management' version '1.0.14.RELEASE'
}
repositories {
    mavenCentral()
}
dependencies {
    // Spring implementation dependencies
    implementation 'org.springframework.boot:spring-boot-starter-web'
    // Spring Test dependencies
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    // Spring Spock Test dependencies
    testImplementation 'org.spockframework:spock-spring:2.4-M1-groovy-4.0'
    // Spring Core Test dependencies
    testImplementation 'org.spockframework:spock-core:2.4-M1-groovy-4.0'
}

In this case, we are just adding the following plugins:

id "org.springframework.boot" version "3.2.1"
id 'io.spring.dependency-management' version '1.0.14.RELEASE'

Notably, JUnit5 dependencies are now pulled by Spring Boot without specifying them.

Finally, If we want to update the Spring Boot version, we only need to replace it in the org.springframework.boot plugin.

Let’s have a look at the second option:

plugins {
    id 'java'
    id 'groovy'
    id 'io.spring.dependency-management' version '1.1.4'
}
repositories {
    mavenCentral()
}
dependencyManagement {
    imports {
        mavenBom 'org.springframework.boot:spring-boot-dependencies:3.2.1'
    }
}
dependencies {
    // Spring implementation dependencies
    implementation 'org.springframework.boot:spring-boot-starter-web'
    // Test implementation
    testImplementation(
        'junit:junit',
        'org.spockframework:spock-core:2.4-M1-groovy-4.0',
        'org.spockframework:spock-spring:2.4-M1-groovy-4.0',
        'org.springframework.boot:spring-boot-starter-test',
    )
}

We have now replaced the org.springframework.boot plugin with the dependecyManagent section as a single entry point of our dependencies:

dependencyManagement {
    imports {
        mavenBom 'org.springframework.boot:spring-boot-dependencies:3.2.1'
    }
}

Notably, we collapse the testImplementation in one input and add the JUnit4 dependency in case our project still uses it or has a mix with JUnit5:

// Test implementation
testImplementation(
    'junit:junit',
    'org.spockframework:spock-core:2.4-M1-groovy-4.0',
    'org.spockframework:spock-spring:2.4-M1-groovy-4.0',
    'org.springframework.boot:spring-boot-starter-test',
)

4. Conclusion

In this tutorial, we have seen how to set up a Java project using Spock and Gradle. We have also seen how to add Spring and Spring Boot dependencies. Gradle offers great build support and less verbosity in our project scripting setup. Likewise, Spock is a great testing tool for its ease of setup and specification oriented to data-driven testing and interaction-based rather than the assertion-like form of JUnit.

      

Related Stories

• Using Groovy in Spring
• How to Remove a Prefix From Strings in Groovy
• Groovy Variable Scope