Mockito: iniettare oggetti reali nei campi privati ​​@Autowired

Sto usando Mockito @Mocke @InjectMocksannotazioni per iniettare dipendenze in campi privati ​​che sono annotati con quelli di Spring @Autowired:

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

    @InjectMocks
    private Demo demo;

    /* ... */
}

e

public class Demo {

    @Autowired
    private SomeService service;

    /* ... */
}

Ora vorrei anche iniettare oggetti reali in @Autowiredcampi privati (senza setter). È possibile o il meccanismo si limita all'iniezione di Mock?

Usa @Spyannotazione

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

    @InjectMocks
    private Demo demo;

    /* ... */
}

Mockito considererà tutti i campi che hanno @Mocko @Spyannotazioni come potenziali candidati da iniettare nell'istanza annotata con @InjectMocksannotazione. Nel caso sopra'RealServiceImpl' istanza verrà iniettata nella 'demo'

Per maggiori dettagli fare riferimento

Mockito-casa

@Spiare

@Mock

In aggiunta alla risposta @Dev Blanked, se si desidera utilizzare un bean esistente creato da Spring, il codice può essere modificato in:

@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);
    }

    /* ... */
}

In questo modo non è necessario modificare il codice (aggiungere un altro costruttore) solo per far funzionare i test.

Mockito non è un framework DI e persino i framework DI incoraggiano le iniezioni del costruttore rispetto alle iniezioni sul campo.
Quindi devi semplicemente dichiarare un costruttore per impostare le dipendenze della classe sotto test:

@Mock
private SomeService serviceMock;

private Demo demo;

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

L'uso di Mockito spynel caso generale è un consiglio terribile. Rende la classe di test fragile, non diritta e soggetta a errori: cosa è veramente deriso? Cosa è veramente testato?
@InjectMockse @Spydanneggia anche il design generale poiché incoraggia le classi gonfie e le responsabilità miste nelle classi.
Si prega di leggere il spy()javadoc prima di usarlo alla cieca (l'enfasi non è mia):

Crea una spia dell'oggetto reale. La spia chiama metodi reali a meno che non vengano stubati. Le vere spie dovrebbero essere usate con attenzione e occasionalmente , ad esempio quando si tratta di codice legacy.

Come al solito leggerai il partial mock warning : La programmazione orientata agli oggetti affronta la complessità dividendola in oggetti separati, specifici, SRPy. Come si inserisce la derisione parziale in questo paradigma? Bene, semplicemente non ... La derisione parziale di solito significa che la complessità è stata spostata in un metodo diverso sullo stesso oggetto. Nella maggior parte dei casi, non è questo il modo in cui si desidera progettare l'applicazione.

Tuttavia, ci sono rari casi in cui le simulazioni parziali sono utili: gestire il codice che non è possibile modificare facilmente (interfacce di terze parti, refactoring provvisorio di codice legacy, ecc.) Tuttavia, non utilizzerei le simulazioni parziali per nuove, guidate dai test e ben- codice progettato.

In primavera c'è un'utilità dedicata chiamata ReflectionTestUtilsper questo scopo. Prendi l'istanza specifica e immetti nel campo.

@Spy
..
@Mock
..

@InjectMock
Foo foo;

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

So che questa è una vecchia domanda, ma abbiamo dovuto affrontare lo stesso problema quando provavamo a iniettare stringhe. Quindi abbiamo inventato un'estensione JUnit5 / Mockito che fa esattamente quello che vuoi: https://github.com/exabrial/mockito-object-injection

MODIFICARE:

@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();
 }