Another spock Mock is not injected than the one defined in a Spring Boot Test - spring-boot

Question

I have written a Spring Boot Test in Spock, where the injected dependency needs to do something in the constructor of a bean.
I have created a mock and annotated it with #SpringBean in my spec and defined some behavior for the mock, and then I expected it to be injected into the bean, which is dependent on the mocked class. Some mocked instance is injected into the bean however I can not define the behavior, which I expected.
I can see from (https://spockframework.org/spock/docs/1.3/module_spring.html):
Spock’s #SpringBean actually creates a proxy in the ApplicationContext which forwards everything to the current mock instance. The type of the proxy is determined by the type of the annotated field.
The proxy attaches itself to the current mock in the setup phase, that is why the mock must be created when the field is initialized
It seems like that instance is not the same, which I guess the quote in the documentation says, but I expected to be able to define the behavior, and have that in the bean, but the methods do only return the default values, which suggest that the mock injected has not has it behavior redefined.
I can see from another extended test I have implemented, that it works as I expected i.e. one can define behavior in the spec and injected as expected, but for the purpose of the example I have isolated the issue.
A workaround is that to create the class explicitly and inject the dependency, but in the test where this issue occurs the dependency has to be injected in a dependency quite deep in the dependency hierarchy.
can anybody pinpoint what I am missing?
The test is as follows:
package com.test.springmockspock
import org.spockframework.spring.SpringBean
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import spock.lang.Specification
#SpringBootTest
class SpringspockmockApplicationSpec extends Specification {
#Autowired
SpringspockmockApplication sut
#SpringBean
Factory factory = Mock() {
getInt() >> 99
}
#Autowired
Factory autowiredFactory
void 'hello'() {
when:
def insideSUTFactory = sut.factory
then:
factory.getInt() == 99
// sut.intFromFactory == 42 // this should have been 99
autowiredFactory == insideSUTFactory // true
factory == insideSUTFactory // false (but should have been true)
}
}
The Factory class is:
package com.test.springmockspock;
import org.springframework.stereotype.Component;
#Component
public class Factory {
public Producer get() {
return new Producer();
}
public int getInt() {
return 45;
}
}
package com.test.springmockspock;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
#ComponentScan("com.test.springmockspock")
#SpringBootApplication
public class SpringspockmockApplication implements CommandLineRunner {
private final Factory factory;
private final Producer producer;
public SpringspockmockApplication(Factory factory) {
this.factory = factory;
this.producer = factory.get();
return;
}
public static void main(String[] args) {
SpringApplication.run(SpringspockmockApplication.class, args);
}
public Factory getFactory() {
return factory;
}
#Override
public void run(String... args) throws Exception {
System.out.println("Hello world");
}
public int getIntFromFactory() {
return factory.getInt();
}
}
The build.gradle.kts
plugins {
groovy
application
id("org.springframework.boot") version "2.5.0"
id("io.spring.dependency-management") version "1.0.11.RELEASE"
}
repositories {
mavenCentral()
}
dependencies {
// Use the latest Groovy version for Spock testing
testImplementation("org.codehaus.groovy:groovy:3.0.7")
// Use the awesome Spock testing and specification framework even with Java
testImplementation("org.springframework.boot:spring-boot-starter-test")
testImplementation("org.spockframework:spock-spring:2.0-M4-groovy-3.0")
testImplementation("org.spockframework:spock-core:2.0-M4-groovy-3.0")
testImplementation("junit:junit:4.13.1")
testRuntimeOnly("net.bytebuddy:byte-buddy:1.11.0") // allows mocking of classes (in addition to interfaces)
testRuntimeOnly("org.objenesis:objenesis:3.2") // allows mocking of classes without default constructor (together with ByteBuddy or CGLIB)
// This dependency is used by the application.
implementation("com.google.guava:guava:30.0-jre")
implementation("org.springframework.boot:spring-boot-starter")
}
application {
mainClass.set("com.test.springmockspock.App")
}

Answer 1

You have already quoted the exact issue. The #SpringBean will create a proxy, that is later attached to the specification, as in the Spock world, the interactions are managed by the specification not the individual mocks.
Now, the spring context will be initialized before the mock is attached to the specification, so you only get the proxy instance without any interactions. Then this proxy is injected into the constructor, where it will answer with it's default behavior (returning null or 0). After the context is initialized, the mocks will be attached to the specification and can now handle interactions.