Using a Stub in global setup in Spock

I am trying to prepare some abstract setup for a tested object and I am stuck when it comes to using a Stub there. Basically what I am trying to achieve - I have a Facade looking like this:

@AllArgsConstructor
public class Facade {
private final EventBus events;
Mono<String> doSomething() {
return just("someId").doOnNext(id -> events.push(new ExpectedEvent(id)));
}
/** And many other methods required to initialize the facade in the mentioned test **/
}

with EventBus like:

public interface EventBus {
void push(Event event);
}

and sample Event:

@Value
public class ExpectedEvent implements Event {
String id;
}

I have different test classes for different use cases - in most of the tests I don't need to interact with the eventBus, so I would like it to be a simple implementation like

event -> just("No event bus configured")

But I would also like to have a possibility to check if proper events were published there so I would like also to be able to inject a Stub if needed. Another aspect of it is that I need some code in setupSpec method to properly set up the facade before the tests and I would like to avoid doing it in setup method.

How I would see it:

abstract class AbstractSpec extends Specification {
@Shared
Facade facade = new Facade(
eventBus())
def setupSpec() {
/** run different methods on the facade to prepare it for the tests **/
}
EventBus eventBus() {
return { event -> just("No event bus configured") }
}

Then all the "regular" tests would simple inherit from the AbstractSpec and just call the initialized facade. Whereas in the class where I would like to verify EventBus calls I would have something like this:

class DerivedSpec extends AbstractSpec {
EventBus eventBus = Mock()
def "check if proper event was emited"() {
given:
ExpectedEvent publishedEvent
when:
def someId = facade.doSomething().block()
then:
1 * eventBus.push(_ as ExpectedEvent) >> { ExpectedEvent event -> publishedEvent = event }
publishedEvent.id() == someId
}
EventBus eventBus() {
return eventBus
}
}

Is it somehow achievable? The code above got this problem that I am unable to use Mock with @Shared object. I would like to have common initialization of the facade in most of the tests but override the initialization in some, using mock of EventBus to verify the interactions with it.

Are the Spock extensions helpful in such case? I guess the simplest solution would be to resign from extending the AbstractSpec in this particular test and just reuse the setupSpec code in setup for this single class but I am curious if there is another way to solve it.

I am not really sure if your kind of setup is the ideal way to solve this, it looks quite contrived and difficult to understand and maintain. I would probably choose a different test design. Anyway, I want to limit myself to strictly answering your question by applying minimal changes to your specification.

You are having a bootstrapping problem here: In AbstractSpec you use a @Shared member, which in many cases is an anti pattern already because it means there is one variable carrying state in between feature methods, i.e. your tests could be sensitive to execution order, which is bad. Assuming that you have multiple subclasses for this abstract parent class, there could even be side effects between different test specifications (classes), which is even worse. But be it as it may, let me take your shared variable as a given.

Now this shared variable is almost like a static variable, i.e. Spock will initialise it before any normal instance variables. Hence, trying to assign it a value by calling an method overridden by a subclass and that method trying to assign a value which will only be initialised later makes the shared variable get the value null, which later causes a NullPointerException when trying to call methods upon the object.

So what you need to do is make the mock object in the subclass static. But then you have the next problem: Spock Mock() calls only work in a non-static context. Therefore, you are having the next hen vs. egg problem here. The way to work around it is to create a detached mock and then manually attach it to the specification instance during test execution (@AutoAttach does not work in this case). Detached mocks were mostly introduced in order to be used by DI frameworks such as Spring or Guice, but can be used independently too.

For me your test runs like this:

<!-- language: lang-groovy -->

package de.scrum_master.stackoverflow.q63652119
import org.spockframework.mock.MockUtil
import spock.mock.DetachedMockFactory
class DerivedSpec extends AbstractSpec {
static mockFactory = new DetachedMockFactory()
static EventBus eventBus = mockFactory.Mock(EventBus)
def "check if proper event was emited"() {
given:
ExpectedEvent publishedEvent
new MockUtil().attachMock(eventBus, this)
when:
def someId = facade.doSomething().block()
then:
1 * eventBus.push(_ as ExpectedEvent) >> { ExpectedEvent event -> publishedEvent = event }
publishedEvent.id == someId
}
EventBus eventBus() {
return eventBus
}
}