From mobile apps to microservices, from small startups to big enterprises, Gradle helps teams build, automate and deliver better software, faster.

Gradle Community

I think it is not a good idea sharing data between tests, they should be independent, even in a single module build.

They dont share data.. but message broker :)

What you mean with resources? The build is overloaded due multiple tests running in parallel?

Module `A` produces events on a broker. My integration tests in module `A` inspect the broker and assert that the correct things are published.

module `B` consumes these events. My integration tests in `B` publishes faked events on the broker and assert that the correct side-effects occur, given the event.

If `A` and `B` run in parallel, the events from tests in `A`  would cause unexpected side-effects to happen when(if) `B` is running at the same time

I am not sure, can’t you avoid that by doing everything in the same test in a module C which depends on A and B? The other option would be using fakes, which has no sense in integration tests.

Tests can run in parallel even in the same module, so the same test should produce and consume.

You need to use a shared Build Service (representing the resource, even if it's absolutely empty), and limit its concurrency

You cannot enforce order, but you will enforce that they don't run in parallel

Thanks. I stumbled upon a ticket mentioning build services :slightly_smiling_face: I'll dig deeper in that direction

But what would happens if B runs before A?

Wouldn't matter. B:s tests send the events which we want to consume

Then a shared build service with concurrency 1 would indeed be the way to make the tasks mutally exclusive

The docs for using build services never seem to mention them from a regular build script  (`build.gradle.kts` ). Can it be done?

But as you want the same build service in two different projects, you probably should put it into `buildSrc` or an included build anyway, unless you do highly discouraged bad-practice cross-project configuration. :slightly_smiling_face:

But within one project, you can simply do it like
```interface Foo : BuildService&lt;BuildServiceParameters.None&gt;
val foo = gradle.sharedServices.registerIfAbsent("foo", Foo::class) {
    maxParallelUsages.set(1)
}
tasks.test {
    usesService(foo)
}```

I am using an included build. I'll try putting something like that there. TYVM!