Mockito: inyecta objetos reales en campos privados @Autowired

Estoy usando Mockito @Mocky @InjectMocksanotaciones para inyectar dependencias en campos privados que están anotados con Spring @Autowired:

@RunWith(MockitoJUnitRunner.class)
public class DemoTest {
    @Mock
    private SomeService service;

    @InjectMocks
    private Demo demo;

    /* ... */
}

y

public class Demo {

    @Autowired
    private SomeService service;

    /* ... */
}

Ahora me gustaría también inyectar objetos reales en @Autowiredcampos privados (sin setters). ¿Es esto posible o el mecanismo se limita a inyectar simulacros solamente?

Usa @Spyanotaciones

@RunWith(MockitoJUnitRunner.class)
public class DemoTest {
    @Spy
    private SomeService service = new RealServiceImpl();

    @InjectMocks
    private Demo demo;

    /* ... */
}

Mockito considerará todos los campos que tengan @Mocko @Spyanotación como candidatos potenciales para ser inyectados en la instancia anotada con @InjectMocksanotación. En el caso anterior, la 'RealServiceImpl'instancia se inyectará en la 'demostración'

Para más detalles consulte

Mockito-home

@Espiar

@Burlarse de

Además de la respuesta @Dev Blanked, si desea utilizar un bean existente creado por Spring, el código puede modificarse para:

@RunWith(MockitoJUnitRunner.class)
public class DemoTest {

    @Inject
    private ApplicationContext ctx;

    @Spy
    private SomeService service;

    @InjectMocks
    private Demo demo;

    @Before
    public void setUp(){
        service = ctx.getBean(SomeService.class);
    }

    /* ... */
}

De esta manera, no necesita cambiar su código (agregar otro constructor) solo para que las pruebas funcionen.

Mockito no es un marco DI e incluso los marcos DI alientan las inyecciones de constructor sobre las inyecciones de campo.
Entonces solo declaras un constructor para establecer dependencias de la clase bajo prueba:

@Mock
private SomeService serviceMock;

private Demo demo;

/* ... */
@BeforeEach
public void beforeEach(){
   demo = new Demo(serviceMock);
}

Usar Mockito spypara el caso general es un consejo terrible. Hace que la clase de prueba sea frágil, no recta y propensa a errores: ¿qué se burla realmente? ¿Qué se prueba realmente?
@InjectMocksy @Spytambién perjudica el diseño general, ya que fomenta las clases hinchadas y las responsabilidades mixtas en las clases.
Por favor leer el spy()javadoc antes de usar que ciegamente (el subrayado no es mío):

Crea un espía del objeto real. El espía llama métodos reales a menos que estén tropezados. Los espías reales deben usarse con cuidado y ocasionalmente , por ejemplo, cuando se trata de código heredado.

Como de costumbre, leerá partial mock warning: La programación orientada a objetos aborda la complejidad dividiendo la complejidad en objetos SRPy específicos y separados. ¿Cómo encaja la simulación parcial en este paradigma? Bueno, simplemente no ... El simulacro parcial generalmente significa que la complejidad se ha movido a un método diferente en el mismo objeto. En la mayoría de los casos, esta no es la forma en que desea diseñar su aplicación.

Sin embargo, hay casos raros en que los simulacros parciales son útiles: lidiar con código que no puede cambiar fácilmente (interfaces de terceros, refactorización provisional de código heredado, etc.) Sin embargo, no usaría simulacros parciales para nuevos, basados ​​en pruebas y bien- código diseñado

En Spring hay una utilidad dedicada llamada ReflectionTestUtilspara este propósito. Tome la instancia específica e inyecte en el campo.

@Spy
..
@Mock
..

@InjectMock
Foo foo;

@BeforeEach
void _before(){
   ReflectionTestUtils.setField(foo,"bar", new BarImpl());// `bar` is private field
}

Sé que esta es una vieja pregunta, pero nos encontramos con el mismo problema al intentar inyectar cadenas. Entonces inventamos una extensión JUnit5 / Mockito que hace exactamente lo que quieres: https://github.com/exabrial/mockito-object-injection

EDITAR:

@InjectionMap
 private Map<String, Object> injectionMap = new HashMap<>();

 @BeforeEach
 public void beforeEach() throws Exception {
  injectionMap.put("securityEnabled", Boolean.TRUE);
 }

 @AfterEach
 public void afterEach() throws Exception {
  injectionMap.clear();
 }