Is there any way to control how many of a type of test run at the same time?

[efenderbosch-atg]

We have so many integration tests that use the database that MySQL is rejecting connections. I've changed Hikari to only have a "pool" of one connection which should help. Each test was creating a pool of 10. But I was wondering if there's way to control spec/feature eligibility to be scheduled? Instead of an ExclusiveResource with READ_WRITE or READ access mode, something like a semaphore. This way I could say that 10 tests that use the database could run in parallel, but no more.

[Vampire]

You could configure the parallelism overall.
That will be effective for all tests though and still more tests can run in parallel due to work-stealing.

In situations like you described I usually recommend exactly that.
If you want the limit for all tests, have a global Spock extension that creates a Semaphore with 10 permits, then acquire it in an according interceptor before calling proceed() and release it in a finally block.

If you want to limit only specific tests or have several independent pools, make an annotation-driven local Spock extension so that only annotated tests are affected and you could configure a pool identifier and have one semaphore per pool

[efenderbosch-atg]

Let me see if I'm understanding

• create a IGlobalExtension
• in visitSpec check if the spec inherits from the base database spec. If not, do nothing, if it does, continue
• for each feature in the spec, addInterceptor to MethodInfo
• the IMethodInterceptor intercept method should call acquire then proceed and in the finally block release

Something like:

class SemaphoreMethodInterceptor implements IMethodInterceptor {

    private static final Semaphore SEMAPHORE = new Semaphore(10)

    @Override
    void intercept(IMethodInvocation invocation) throws Throwable {
        SEMAPHORE.acquire()
        try {
            invocation.proceed()
        } finally {
            SEMAPHORE.release()
        }
    }

}

class SemaphoreGlobalExtension implements IGlobalExtension {

    private static final SemaphoreMethodInterceptor INTERCEPTOR = new SemaphoreMethodInterceptor()

    @Override
    void visitSpec(SpecInfo spec) {
        // Skip specs marked as isolated as that is more restrictive
        if (spec.isAnnotationPresent(Isolated)) {
            return
        }
        boolean isRepoSpec = BaseRepoIntegrationSpec.isAssignableFrom(spec.reflection)
        if (!isRepoSpec) {
            return
        }
        spec.features.each { feature ->
            feature.featureMethod.addInterceptor(INTERCEPTOR)
        }
    }
}

[Vampire]

in visitSpec check if the spec inherits from the base database spec. If not, do nothing, if it does, continue

This point hints at not using a global extension, but an annotation-based local extension and then annotate the base database spec with that annotation.

But other than that, yes.
If the feature method execution is the entity to protect.
If you do DB things in a setup method for example, that would not be sufficient.