Spock Framework Documentation

Spock is built with Gradle. To develop locally, you must have both JDK 11 and JDK 17 installed. The build process itself runs on JDK 17, but requires JDK 11 to be available via Gradle toolchains.

1. Clone the repository.
2. Ensure JDK 11 and 17 are installed.
3. If Gradle cannot find JDK 11, set the JDK11 environment variable to its location.
4. Verify toolchains by running ./gradlew javaToolchains.
5. Run the build using the Gradle Wrapper: ./gradlew build.

To integrate the Guice IoC container with Spock, add the spock-guice dependency.

With Spock 1.2+, detached mocks are automatically attached to the Specification if they are injected using the @Inject annotation.

To enable integration with the Spring TestContext Framework (including support for @ContextConfiguration, @ContextHierarchy, @BootstrapWith, @SpringBootTest, and @WebMvcTest), add the following dependency to your project:

org.spockframework:spock-spring

To create a local extension driven by annotations, implement the IAnnotationDrivenExtension interface.

Requirements for your annotation class:

1. Must have @Retention(RUNTIME).
2. Must have @Target set to FIELD, METHOD, or TYPE (depending on usage).
3. Must be annotated with @ExtensionAnnotation(YourExtensionClass.class).

Note on Spock 2.4+: If your extension is thread-safe and does not need to store Specification-specific state, implement IStatelessAnnotationDrivenExtension instead.

Repeatable Annotations: Since Spock 2.0, annotations can be @Repeatable. Use the visit...Annotations(List<T> annotations, ...) methods to handle multiple instances applied to the same target.

Since Spock 2.4, extensions can target method parameters directly.

1. Define an annotation with @Target({ElementType.PARAMETER}).
2. Implement IAnnotationDrivenExtension.visitParameterAnnotation(T annotation, ParameterInfo parameter).
3. Register a custom interceptor or use the built-in ParameterResolver.Interceptor to handle the injection.

Manual Injection (Pre-2.4 or Advanced): You can manually inject values by modifying invocation.arguments. For Spock 2.0+, the arguments array size matches the method parameter count. If you need to expand it, you must create a new array, copy existing elements, and assign the new array to invocation.arguments.

In Spock 0.6 and later, the initialization order for inherited specifications changed to a more conventional order: field initializers are executed by class level (Base fields, then Derived fields) before any setup() methods are called.

This means you cannot rely on a base class setup() method to initialize a field that a derived class uses in its field initializer.

Broken Pattern:

class Base extends Specification {
    def base

    def setup() { base = "base" }
}

class Derived extends Base {
    def derived = base + "derived" // base is not yet set
}

Solutions:

1. Use a field initializer for base in the Base class.
2. Move the assignment of derived into a setup() method in the Derived class.