如何在Spock测试套件中全局初始化与清理资源

Hey there, let's work through your problem step by step. You’ve got a JUnit Suite that handles one-time container startup/shutdown for your integration tests, and you’re hitting snags transitioning to Spock:

1. Spock’s setupSpec() runs once per Specification class, not once for all tests
2. Adding Spock Specifications to your JUnit Suite causes @RunWith conflicts (since Spock uses Sputnik under the hood), leading to skipped tests

Here are two reliable solutions to fix this:

方案一：用Spock全局扩展实现一次性初始化（推荐） #

Spock’s extension model lets you hook into the global test lifecycle, which is the cleanest way to handle one-time setup/teardown for all your Spock tests.

Step 1: Implement a Global Extension #

Create a Groovy class that implements Spock’s IGlobalExtension interface. This will run once before any tests start, and once after all tests finish:

import org.spockframework.runtime.extension.IGlobalExtension
import org.spockframework.runtime.model.SpecInfo

class ContainerGlobalExtension implements IGlobalExtension {
    private static boolean containerStarted = false

    @Override
    void start() {
        // Only start the container once, even if multiple specs run
        if (!containerStarted) {
            Container.start()
            containerStarted = true
        }
    }

    @Override
    void stop() {
        // Clean up after all tests are done
        if (containerStarted) {
            Container.stop()
            containerStarted = false
        }
    }

    @Override
    void visitSpec(SpecInfo spec) {
        // No per-spec logic needed here, but you could add it if needed
    }
}

Step 2: Register the Extension #

Spock discovers global extensions via a service file. Create this file in your test resources:
src/test/resources/META-INF/services/org.spockframework.runtime.extension.IGlobalExtension

Add a single line with the fully qualified name of your extension class:

com.your.package.ContainerGlobalExtension

Replace com.your.package with the actual package where your extension lives.

Now, no matter how many Spock Specifications you run, the container will start once before all tests and stop once after all tests—exactly what you need.

方案二：让JUnit Suite兼容Spock Tests（保留Suite结构） #

If you want to keep using your JUnit Suite structure, you can work around the @RunWith conflict by ensuring the Suite properly recognizes and executes Spock tests.

Fix the Suite Class #

Instead of directly listing Spock specs in @SuiteClasses (which causes the @RunWith clash), you can initialize the Suite programmatically. Here’s a straightforward approach:

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.model.InitializationError;

@RunWith(Suite.class)
public class MyIntegrationSuite {
    // One-time container startup when the Suite loads
    static {
        try {
            Container.start();
        } catch (Exception e) {
            throw new RuntimeException("Failed to start container", e);
        }
    }

    // Initialize the Suite with all your test classes (Java + Spock)
    public MyIntegrationSuite() throws InitializationError {
        super(new Class<?>[]{
            MyJavaTest.class,
            MyAnotherJavaTest.class,
            MySpockSpec.class // Add your Spock Specification here
        });
    }

    // One-time container shutdown after all tests finish
    @org.junit.AfterClass
    public static void afterTests() throws Exception {
        Container.stop();
    }
}

Verify Your Maven Config #

Your existing build-helper-maven-plugin and gmavenplus-plugin setup is already correct—it adds Groovy test sources and compiles them properly. This ensures the JUnit Suite can find and execute your Spock specs without issues.

Final Notes #

• Go with Option 1 if you’re fully transitioning to Spock—it’s the most idiomatic approach and keeps your codebase aligned with Spock’s design.
• Use Option 2 if you need to maintain your existing JUnit Suite structure while adding Spock tests.

内容的提问来源于stack exchange，提问作者Shadov