Introduction to the Spock Testing Framework for Java and Groovy

Spock is an open‑source testing framework whose design is inspired by JUnit, Mockito and Groovy. It can be used to write unit tests for Java and Groovy applications.

A brief comparison of common testing and mocking tools shows that JUnit is suitable for simple classes without external dependencies, while mock‑based frameworks (JMock, Mockito, PowerMock, Spock) help isolate external services. PowerMock can mock static, private and constructor methods but may interfere with code‑coverage tools. Spock combines the simplicity of JMock/Mockito with data‑driven testing capabilities.

Key advantages of Spock include a concise DSL, the ability to run a single test method with multiple data sets using the where block, direct assignment to object fields without reflection, and clear separation of given , expect and where sections.

Spock environment configuration

Add the following Maven dependencies to your pom.xml :

<dependency>
  <groupId>org.codehaus.groovy</groupId>
  <artifactId>groovy-all-tests</artifactId>
  <version>2.0.0-rc-3</version>
</dependency>
<dependency>
  <groupId>org.spockframework</groupId>
  <artifactId>spock-core</artifactId>
  <version>1.3-groovy-2.4</version>
</dependency>
<dependency>
  <groupId>org.spockframework</groupId>
  <artifactId>spock-spring</artifactId>
  <version>1.3-groovy-2.4</version>
  <scope>test</scope>
</dependency>

Configure the Groovy Maven plugin:

<plugin>
  <groupId>org.codehaus.gmavenplus</groupId>
  <artifactId>gmavenplus-plugin</artifactId>
  <version>1.4</version>
  <extensions>true</extensions>
  <executions>
    <execution>
      <goals>
        <goal>compile</goal>
        <goal>testCompile</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <testSources>
      <testSource>
        <directory>${project.basedir}/src/test/java</directory>
        <includes><include>**/*.groovy</include></includes>
      </testSource>
      <testSource>
        <directory>${project.basedir}/src/test/groovy</directory>
        <includes><include>**/*.groovy</include></includes>
      </testSource>
    </testSources>
  </configuration>
</plugin>

Spock usage pattern

The typical structure is given‑expect‑where . The given block prepares test data or mocks, expect contains assertions, and where supplies one or more rows of input data and expected results.

Example for the TaskService.getTask() method using a data‑driven Spock test:

@Unroll
class TaskServiceSpockTest extends Specification {
    ITaskRepository taskRepository = Mock()
    TaskService taskService = new TaskService(taskRepository: taskRepository)

    def "testGetTask env=#env, keyword=#keyWord, result=#result"() {
        given: "set env"
        taskService.env = env
        and: "mock repository"
        Task task = new Task()
        task.setInput(EnvEnum.PRODUCT.name())
        taskRepository.getTask(_) >> task
        when: "invoke service"
        Result
taskResult = taskService.getTask()
        then: "assert result"
        result == taskResult.getData().getInput().contains(keyWord)
        where:
        env                      | keyWord                | result
        EnvEnum.DAILY.getVal()   | EnvEnum.DAILY.name()   | true
        EnvEnum.PRE.getVal()     | EnvEnum.PRE.name()     | true
        EnvEnum.PRODUCT.getVal() | EnvEnum.PRODUCT.name() | true
    }
}

For comparison, the equivalent Mockito test requires three separate test methods, each setting the env field via reflection and mocking the repository call:

public class TaskServiceTest {
    @InjectMocks
    private TaskService taskService = new TaskService();
    @Mock
    private ITaskRepository taskRepository;

    @Test
    public void testGetTaskDaily() throws Exception {
        Field f = TaskService.class.getDeclaredField("env");
        f.setAccessible(true);
        f.set(taskService, EnvEnum.DAILY.getVal());
        Result
r = taskService.getTask();
        Assert.assertTrue(r.getData().getInput().contains(EnvEnum.DAILY.name()));
    }
    // similar methods for PRE and PRODUCT environments
}

Other Spock features demonstrated in the article include:

given‑when‑then for single‑data‑set tests.

Mocking methods that throw exceptions to cover catch branches.

Returning different values on successive mock calls (useful for loops).

Spying on the class under test to mock its own methods.

Combining Spock with PowerMock to mock static methods.

Example of mocking a static method with PowerMock:

@RunWith(PowerMockRunner.class)
@PowerMockRunnerDelegate(Sputnik.class)
@PrepareForTest([StringCheckUtil.class])
class StudentServiceSpockTest extends Specification {
    StudentService studentService = new StudentService()
    def setup() { PowerMockito.mockStatic(StringCheckUtil.class) }
    @Unroll
    def "testGetStudentNameLength"() {
        given:
        PowerMockito.when(StringCheckUtil.getLength(Mockito.any())).thenReturn(6)
        when:
        int length = studentService.getStudentNameLength("小明")
        then:
        length == 2
    }
}

Conclusion

Spock provides a concise DSL, powerful data‑driven testing, easy property injection, and seamless integration with PowerMock for static‑method mocking, making it a strong choice for backend unit testing in Java/Groovy projects.