Mockito: Injete objetos reais em campos privados @Autowired

Estou usando o Mockito @Mocke as @InjectMocksanotações para injetar dependências em campos particulares anotados no Spring @Autowired:

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

    @InjectMocks
    private Demo demo;

    /* ... */
}

e

public class Demo {

    @Autowired
    private SomeService service;

    /* ... */
}

Agora eu também gostaria de injetar objetos reais em @Autowiredcampos privados (sem setters). Isso é possível ou o mecanismo está limitado apenas à injeção de Mocks?

Usar @Spyanotação

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

    @InjectMocks
    private Demo demo;

    /* ... */
}

O Mockito considerará todos os campos que possuem @Mockou @Spyanotação como candidatos potenciais a serem injetados na instância anotada com @InjectMocksanotação. No caso acima, a 'RealServiceImpl'instância será injetada na 'demo'

Para mais detalhes consulte

Mockito-home

@Espião

@Zombar

Além da resposta @Dev Blanked, se você quiser usar um bean existente criado pelo Spring, o código poderá ser modificado 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);
    }

    /* ... */
}

Dessa forma, você não precisa alterar seu código (adicione outro construtor) apenas para fazer os testes funcionarem.

Mockito não é uma estrutura DI e até mesmo estruturas DI incentivam injeções de construtores sobre injeções de campo.
Então você apenas declara um construtor para definir dependências da classe em teste:

@Mock
private SomeService serviceMock;

private Demo demo;

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

Usar o Mockito spypara o caso geral é um péssimo conselho. Isso torna a classe de teste quebradiça, não direta e propensa a erros: o que é realmente ridicularizado? O que é realmente testado?
@InjectMockse @Spytambém prejudica o design geral, pois incentiva classes inchadas e responsabilidades mistas nas classes.
Por favor, leia o spy()javadoc antes de usá-lo cegamente (a ênfase não é minha):

Cria um espião do objeto real. O espião chama métodos reais , a menos que sejam roubados. Espiões de verdade devem ser usados ​​com cuidado e ocasionalmente , por exemplo, ao lidar com código legado.

Como de costume, você lerá partial mock warning: A programação orientada a objetos aborda a complexidade, dividindo a complexidade em objetos SRPy específicos e separados. Como o mock parcial se encaixa nesse paradigma? Bem, simplesmente não ... Simulação parcial geralmente significa que a complexidade foi movida para um método diferente no mesmo objeto. Na maioria dos casos, não é dessa maneira que você deseja projetar seu aplicativo.

No entanto, existem casos raros em que zombarias parciais são úteis: lidar com código que você não pode alterar facilmente (interfaces de terceiros, refatoração provisória de código herdado etc.) No entanto, eu não usaria zombarias parciais para novos, orientados a testes e bem- código projetado.

Na primavera, há um utilitário dedicado chamado ReflectionTestUtilspara esse fim. Pegue a instância específica e injete no campo.

@Spy
..
@Mock
..

@InjectMock
Foo foo;

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

Sei que essa é uma pergunta antiga, mas fomos confrontados com o mesmo problema ao tentar injetar Strings. Por isso, inventamos uma extensão JUnit5 / Mockito que faz exatamente o que você deseja: 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();
 }