Iniettare i mock con @Mock e @InjectMocks
Usi le annotazioni Mockito per collegare le dipendenze simulate alla classe sotto test, riducendo il codice ripetitivo di configurazione.
Iniettare i mock con @Mock e @InjectMocks è una lezione Testing Mastery: JUnit, Mockito & Integration Tests gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Testing Mastery: JUnit, Mockito & Integration Tests, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Testing Mastery: JUnit, Mockito & Integration Tests include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Why Annotations?
Creating mocks manually with mock(Type.class) works, but for classes with several dependencies it becomes repetitive. Mockito offers annotations that declare and wire mocks for you.
@Mockdeclares a mock field@InjectMocksbuilds the real object and injects the mocks
The Class Under Test
Imagine an OrderService that depends on a PaymentGateway. We want to test the service while controlling the gateway.
class OrderService {
private final PaymentGateway gateway;
OrderService(PaymentGateway gateway) { this.gateway = gateway; }
boolean checkout(double amount) {
return gateway.charge(amount);
}
}Declaring a @Mock
Annotate a field with @Mock and Mockito creates a mock instance for it automatically once the annotations are processed.
@Mock
PaymentGateway gateway;Using @InjectMocks
@InjectMocks tells Mockito to instantiate the target and inject any @Mock fields into it, via constructor, setter, or field injection.
@Mock PaymentGateway gateway;
@InjectMocks OrderService service;Activating the Annotations
Annotations do nothing on their own. With JUnit 5 you enable them using @ExtendWith(MockitoExtension.class) on the test class.
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
@Mock PaymentGateway gateway;
@InjectMocks OrderService service;
}The Older openMocks Approach
Without the extension you can call MockitoAnnotations.openMocks(this) in a @BeforeEach method. Prefer the extension when you can.
@BeforeEach
void setUp() {
MockitoAnnotations.openMocks(this);
}Writing the Test
Now stub the injected mock and exercise the service. The service already holds the mocked gateway, so no manual wiring is needed.
@Test
void checkoutSucceeds() {
when(gateway.charge(100.0)).thenReturn(true);
assertTrue(service.checkout(100.0));
}Injection Strategies
Mockito tries injection in this order:
- Constructor injection (preferred)
- Setter injection
- Field injection
Constructor injection is the safest because it works with final fields.
Multiple Dependencies
A class with several collaborators just gets several @Mock fields. Mockito matches each by type during injection.
@Mock PaymentGateway gateway;
@Mock InventoryRepo inventory;
@InjectMocks OrderService service;When Injection Fails Silently
If a dependency cannot be matched, the field stays null rather than throwing. A NullPointerException at test time often means injection did not happen as expected. Verify types and constructor signatures.
Cleaner Tests
Annotations remove repetitive mock(...) and new Service(...) calls, keeping each test focused on behavior instead of wiring.
Quick Check
Which annotation builds the real object and injects mocks into it?
Recap
You learned to wire mocks declaratively:
@Mockdeclares a mock field@InjectMocksbuilds the target and injects mocks- Enable with
@ExtendWith(MockitoExtension.class) - Constructor injection is preferred and supports final fields
Impara Testing Mastery: JUnit, Mockito & Integration Tests con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 12
- Lezioni
- 48
Domande Frequenti
La lezione «Iniettare i mock con @Mock e @InjectMocks» è gratuita?
Sì — il testo completo di «Iniettare i mock con @Mock e @InjectMocks» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Testing Mastery: JUnit, Mockito & Integration Tests, passa a CoddyKit PRO. Il corso Testing Mastery: JUnit, Mockito & Integration Tests include 4 lezioni in totale.
Cosa imparerò in «Iniettare i mock con @Mock e @InjectMocks»?
Usi le annotazioni Mockito per collegare le dipendenze simulate alla classe sotto test, riducendo il codice ripetitivo di configurazione. Eserciti Testing Mastery: JUnit, Mockito & Integration Tests con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Testing Mastery: JUnit, Mockito & Integration Tests?
Non è richiesta alcuna esperienza precedente. Testing Mastery: JUnit, Mockito & Integration Tests su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Iniettare i mock con @Mock e @InjectMocks»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Testing Mastery: JUnit, Mockito & Integration Tests?
Sì. Ogni lezione Testing Mastery: JUnit, Mockito & Integration Tests include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Mock, stub e fake
- Creare mock con Mockito
- Verificare le interazioni dei mock
- Iniettare i mock con @Mock e @InjectMocks