Yksikkötestaus JUnitilla ja Mockitolla
Kirjoittakaa tehokkaita yksikkötestejä palvelukerroksen komponenteille JUnit 5:n ja riippuvuuksien simulointiin tarkoitetun Mockiton avulla.
Yksikkötestaus JUnitilla ja Mockitolla on ilmainen Spring Boot 4:n kattava opas-oppitunti CoddyKitissä. Tämä on oppitunti 1/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Spring Boot 4:n kattava opas-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Spring Boot 4:n kattava opas-kurssilla on yhteensä 4 oppituntia.
Tervetuloa yksikkötestaukseen!
Tällä oppitunnilla opit kirjoittamaan tehokkaita yksikkötestejä Spring Boot -sovelluksille keskittyen erityisesti palvelukerrokseen.
Yksikkötestit ovat tärkeitä, koska ne varmistavat koodin toiminnan odotetulla tavalla ja auttavat havaitsemaan virheet varhaisessa kehitysvaiheessa. Käytämme JUnit 5- ja Mockito-kirjastoja.
Mitä yksikkötestaus on?
Yksikkötestauksella tarkoitetaan pienimmän mahdollisen koodiosan, niin sanotun yksikön, testaamista erillään muusta järjestelmästä. Javassa yksikkö on yleensä yksittäinen metodi tai luokka.
- Eristys: Testit suoritetaan toisistaan riippumatta ja ilman ulkoisia riippuvuuksia.
- Nopeus: Testit suoritetaan hyvin nopeasti, joten niitä voidaan ajaa usein.
- Varhainen havaitseminen: Virheet löydetään ennen kuin ne kasvavat suuremmiksi ongelmiksi.
JUnit 5:n esittely
JUnit 5 on Javan suosituin testauskehys. Se tarjoaa annotaatioita ja väitteitä, joiden avulla voit kirjoittaa jäsenneltyjä ja helppolukuisia testejä.
Katsotaan testiluokan perusrakennetta. Huomaa, että @Test-annotaatio merkitsee metodin testitapaukseksi.
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
class SimpleCalculator {
int add(int a, int b) {
return a + b;
}
}
// This is a JUnit 5 test class
class SimpleCalculatorTest {
@Test
void testAddition() {
SimpleCalculator calc = new SimpleCalculator();
int result = calc.add(2, 3);
// An 'assertion' checks if the result is correct
assertEquals(5, result, "2 + 3 should be 5");
System.out.println("Addition test passed!");
}
public static void main(String[] args) {
// In a real project, JUnit runs tests automatically.
// Here, we simulate a call for demonstration.
System.out.println("--- Simulating JUnit Test ---");
new SimpleCalculatorTest().testAddition();
System.out.println("--- Simulation Complete ---");
}
}Palvelukerrokseen keskittyminen
Spring Bootissa palvelukerros sisältää yleensä sovelluksen liiketoimintalogiikan. Se koordinoi toimintoja ja on usein riippuvainen tietovarastoista.
Palveluiden yksikkötestaus on ihanteellista, koska ne:
- Sisältävät keskeisen logiikan.
- Ovat yleensä tavallisia Java-luokkia.
- Voidaan helposti eristää ulkoisista järjestelmistä, kuten tietokannoista.
Haaste: riippuvuudet
Palvelut ovat usein riippuvaisia muista komponenteista, kuten UserRepository-komponentista, jolla käyttäjätietoja haetaan. Kun testaamme palvelua yksikkötestillä, emme halua käyttää oikeaa tietokantaa.
Tässä mockaus tulee avuksi! Meidän on simuloitava nämä riippuvuudet, jotta voimme varmistaa testin olevan todella yksikkötesti eli eristetty.
Mockito mockausta varten
Mockito on suosittu Javan mockauskehys. Sen avulla voit luoda mock-olioita, jotka simuloivat oikeiden olioiden toimintaa.
Sen sijaan että oikea UserRepository keskustelisi tietokannan kanssa, määritämme Mockito-luodulle mock-tietovarastolle täsmälleen, mitä sen tulee palauttaa tiettyjä metodeja kutsuttaessa.
Mockien määrittäminen annotaatioilla
Mockito tarjoaa käteviä annotaatioita mockien luomisen ja injektoinnin yksinkertaistamiseksi:
@Mock: Luo mock-olion määritetystä tyypistä.@InjectMocks: Luo testattavan luokan ilmentymän ja injektoi@Mock-oliot siihen.
import org.mockito.Mock;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;
// Simple dependent class (e.g., a repository)
class DataRepository {
String findDataById(String id) {
throw new UnsupportedOperationException("Not implemented for real use!");
}
}
// Our service class under test
class MyService {
private final DataRepository repository;
MyService(DataRepository repository) {
this.repository = repository;
}
String processData(String id) {
return "Processed: " + repository.findDataById(id);
}
}
class MyServiceTestSetup {
@Mock
DataRepository mockRepository; // Mock of DataRepository
@InjectMocks
MyService myService; // Service where mocks are injected
MyServiceTestSetup() {
// This initializes the mocks
MockitoAnnotations.openMocks(this);
System.out.println("Mocks initialized for MyServiceTest!");
System.out.println("mockRepository is a Mockito mock: " + (mockRepository != null));
System.out.println("myService has mock injected: " + (myService != null));
}
public static void main(String[] args) {
System.out.println("--- Setting Up Mocks Demo ---");
new MyServiceTestSetup();
System.out.println("--- Demo Complete ---");
}
}Mockin toiminnan määrittäminen: when().thenReturn()
Kun sinulla on mock, sinun on määritettävä, miten sen tulee toimia. Määritä Mockito.when().thenReturn()-kutsulla, mitä mock-metodin tulee palauttaa tietyillä syötteillä.
Näin palvelusi voi suorittaa logiikkansa mockin tarjoamien valetietojen avulla ilman oikeaa tietokantaa tai ulkoista palvelua.
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.mockito.Mock;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;
import static org.mockito.Mockito.when;
// Re-using classes from previous example
class DataRepository {
String findDataById(String id) {
return "Real Data for " + id;
}
}
class MyService {
private final DataRepository repository;
MyService(DataRepository repository) {
this.repository = repository;
}
String processData(String id) {
return "Processed: " + repository.findDataById(id);
}
}
class MyServiceTestBehavior {
@Mock
DataRepository mockRepository;
@InjectMocks
MyService myService;
MyServiceTestBehavior() {
MockitoAnnotations.openMocks(this);
}
@Test
void testProcessDataWithMock() {
// 1. Define mock behavior: when findDataById("123") is called,
// return "Mocked Data".
when(mockRepository.findDataById("123")).thenReturn("Mocked Data");
// 2. Call the service method
String result = myService.processData("123");
// 3. Assert the result
assertEquals("Processed: Mocked Data", result);
System.out.println("Test passed! Result: " + result);
}
public static void main(String[] args) {
System.out.println("--- Mock Behavior Demo ---");
MyServiceTestBehavior test = new MyServiceTestBehavior();
test.testProcessDataWithMock();
System.out.println("--- Demo Complete ---");
}
}Kutsujen tarkistaminen verify()-metodilla
Joskus paluuarvon lisäksi haluat tietää, kutsuttiinko tiettyä mockin metodia ja millä argumenteilla.
Mockiton verify()-metodilla voit varmistaa, että mockeihin kohdistuneet kutsut tapahtuivat odotetusti. Tämä sopii erinomaisesti sivuvaikutusten tarkistamiseen.
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.mockito.Mock;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.times;
// Re-using classes from previous example
class DataRepository {
String findDataById(String id) {
return "Real Data for " + id;
}
}
class MyService {
private final DataRepository repository;
MyService(DataRepository repository) {
this.repository = repository;
}
String processData(String id) {
return "Processed: " + repository.findDataById(id);
}
void saveData(String id, String data) {
// Imagine this saves to DB via repository
repository.findDataById(id); // Example interaction
System.out.println("Saving data via mock...");
}
}
class MyServiceTestVerification {
@Mock
DataRepository mockRepository;
@InjectMocks
MyService myService;
MyServiceTestVerification() {
MockitoAnnotations.openMocks(this);
}
@Test
void testProcessDataAndVerify() {
// Define mock behavior
when(mockRepository.findDataById("456")).thenReturn("Verify Data");
// Call the service method
String result = myService.processData("456");
// Assert the result
assertEquals("Processed: Verify Data", result);
// Verify that findDataById was called exactly once with "456"
verify(mockRepository, times(1)).findDataById("456");
System.out.println("Test passed! Method interaction verified.");
}
public static void main(String[] args) {
System.out.println("--- Mock Verification Demo ---");
MyServiceTestVerification test = new MyServiceTestVerification();
test.testProcessDataAndVerify();
System.out.println("--- Demo Complete ---");
}
}Pikatarkistus: Mockiton rooli
Kun yksikkötestaat Spring-palvelua, joka on riippuvainen tietovarastosta, mikä on Mockiton ensisijainen tehtävä?
Kertaus: yksikkötestauksen hallinta
Onnittelut! Olet ottanut ensimmäiset askeleesi tehokkaassa yksikkötestauksessa Spring Bootilla.
- Yksikkötestit tarkistavat pienet koodiyksiköt eristettyinä.
- JUnit 5 on käyttämämme testauskehys, jossa käytetään
@Test-annotaatiota. - Keskitymme palvelukerrokseen, jossa liiketoimintalogiikka sijaitsee.
- Mockito auttaa luomaan riippuvuuksien mock-olioita.
- Määritä testit
@Mock- ja@InjectMocks-annotaatioilla. - Määritä mockin toiminta
when().thenReturn()-kutsulla. - Tarkista kutsut
verify()-kutsulla.
Jatka harjoittelua, niin koodisi on entistä vankempaa!
Opi Java tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 21
- Oppitunnit
- 84
Usein kysytyt kysymykset
Onko oppitunti ”Yksikkötestaus JUnitilla ja Mockitolla” ilmainen?
Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Spring Boot 4:n kattava opas-oppimispolun 3 oppituntia, myös oppitunnin “Yksikkötestaus JUnitilla ja Mockitolla”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Spring Boot 4:n kattava opas-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”Yksikkötestaus JUnitilla ja Mockitolla”?
Kirjoittakaa tehokkaita yksikkötestejä palvelukerroksen komponenteille JUnit 5:n ja riippuvuuksien simulointiin tarkoitetun Mockiton avulla. Harjoittelet Spring Boot 4:n kattava opas-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Spring Boot 4:n kattava opas-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Spring Boot 4:n kattava opas-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/4.
Kuinka kauan ”Yksikkötestaus JUnitilla ja Mockitolla”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Spring Boot 4:n kattava opas-oppitunnilla?
Kyllä. Jokainen Spring Boot 4:n kattava opas-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Yksikkötestaus JUnitilla ja Mockitolla
- Integraatiotestaus Spring Bootilla
- Viipaletestit ja TestContainers
- Web-ohjainten testaaminen MockMvc:llä