Testlivscykel och ordning
Styr körordningen för tester och hantera testförberedelser och nedmontering med avancerade livscykelannoteringar.
Testlivscykel och ordning är en gratis lektion i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Testning på avancerad nivå: JUnit, Mockito och integrationstester, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.
Introduktion till JUnit-testers livscykel
Välkommen! I den här lektionen går vi igenom avancerade funktioner i JUnit 5 för att styra hur dina tester körs. Att förstå testlivscykeln är viktigt för att hantera resurser och säkerställa korrekta förberedelser och korrekt rensning av tester.
Livscykeln definierar den ordning av åtgärder som JUnit utför före och efter dina testmetoder och klasser.
Förberedelser på klassnivå: @BeforeAll
Ibland behöver du utföra förberedelser endast en gång för alla tester i en viss testklass. Annoteringen @BeforeAll markerar en metod som ska köras före alla testmetoder i klassen.
Som standard måste metoder med @BeforeAll vara static. Snart ser du hur detta kan ändras!
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class BeforeAllDemo {
private static StringBuilder log = new StringBuilder();
@BeforeAll
static void setupOnce() {
log.append("-> @BeforeAll: Setup done once.\n");
System.out.println("Setup for all tests.");
}
@Test
void testA() {
log.append(" -> @Test: Running testA.\n");
System.out.println(" Running testA.");
assertTrue(true);
}
@Test
void testB() {
log.append(" -> @Test: Running testB.\n");
System.out.println(" Running testB.");
assertTrue(true);
}
// The log output would typically be verified in @AfterAll or debugger.
}Nedmontering på klassnivå: @AfterAll
På liknande sätt kan du behöva rensa upp resurser en gång efter att alla tester i en klass har slutförts. Annoteringen @AfterAll markerar en metod som ska köras efter alla testmetoder i klassen.
Precis som @BeforeAll måste den som standard vara static.
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class AfterAllDemo {
private static StringBuilder log = new StringBuilder();
@BeforeAll
static void setup() {
log.append("-> @BeforeAll: Setup for AfterAllDemo.\n");
}
@Test
void testOne() {
log.append(" -> @Test: Running testOne.\n");
assertTrue(true);
}
@Test
void testTwo() {
log.append(" -> @Test: Running testTwo.\n");
assertTrue(true);
}
@AfterAll
static void teardown() {
log.append("-> @AfterAll: Teardown for AfterAllDemo.\n");
System.out.println("--- Execution Log ---");
System.out.println(log.toString()); // See the full order
System.out.println("--- End Log ---");
}
}@TestInstance: livscykeln PER_CLASS
Som standard skapar JUnit en ny instans av testklassen för varje testmetod (Lifecycle.PER_METHOD). Detta säkerställer testisolering.
Om du behöver att metoder med @BeforeAll och @AfterAll inte ska vara statiska, eller om du vill dela tillstånd mellan alla tester i en klass, kan du ändra testinstansens livscykel till Lifecycle.PER_CLASS.
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.TestInstance.Lifecycle;
import static org.junit.jupiter.api.Assertions.assertEquals;
@TestInstance(Lifecycle.PER_CLASS) // Allows non-static @BeforeAll/@AfterAll
public class PerClassLifecycleDemo {
private int counter = 0; // Instance variable, shared across tests
@BeforeAll // No longer needs to be static!
void setupPerClass() {
counter = 10;
System.out.println("-> @BeforeAll (PER_CLASS). Counter: " + counter);
}
@Test
void testIncrementOne() {
counter++;
System.out.println(" -> @Test 1. Counter: " + counter);
assertEquals(11, counter); // Shared state is modified
}
@Test
void testIncrementTwo() {
counter++;
System.out.println(" -> @Test 2. Counter: " + counter);
assertEquals(12, counter); // Counter continues from previous test
}
@AfterAll // No longer needs to be static!
void teardownPerClass() {
System.out.println("-> @AfterAll (PER_CLASS). Final Counter: " + counter);
}
}Testordning: när ska den användas?
Helst ska JUnit-tester vara oberoende och fungera korrekt oavsett ordning. Om du förlitar dig på en viss ordning kan testerna bli sköra och svårare att underhålla.
Det finns dock vissa situationer där en uttrycklig ordning kan vara användbar:
- Testning av ett komplext arbetsflöde med tydliga steg i följd.
- Optimering av prestanda genom att gruppera snabba tester eller tester med gemensamma, kostsamma förberedelser.
- Arbete med äldre system som kräver en viss ordning på interaktionerna.
Annoteringen @TestMethodOrder
För att definiera en körningsordning för testmetoder i en klass använder du annoteringen @TestMethodOrder på klassnivå. Den tar emot en implementation av MethodOrderer som argument.
JUnit 5 innehåller flera inbyggda strategier:
Alphanumeric.class: Ordnar efter metodnamnet i alfabetisk ordning.OrderAnnotation.class: Använder annoteringen@Order.Random.class: Slumpar ordningen.DisplayName.class: Ordnar efter metodernas visningsnamn.
Alfanumerisk metodordning
Vi ser MethodOrderer.Alphanumeric.class i praktiken. JUnit sorterar helt enkelt testmetoderna efter deras namn i alfabetisk ordning.
Detta är ett enkelt sätt att få en förutsägbar ordning om metodnamnen naturligt följer en sekvens.
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.MethodOrderer.Alphanumeric;
import static org.junit.jupiter.api.Assertions.assertTrue;
@TestMethodOrder(Alphanumeric.class) // Tests run A, B, C
public class AlphanumericOrderDemo {
@Test
void testA_First() {
System.out.println("-> Running testA_First");
assertTrue(true);
}
@Test
void testC_Third() {
System.out.println("-> Running testC_Third");
assertTrue(true);
}
@Test
void testB_Second() {
System.out.println("-> Running testB_Second");
assertTrue(true);
}
}Anpassad ordning med @Order
För detaljerad kontroll kombinerar du @TestMethodOrder(MethodOrderer.OrderAnnotation.class) med annoteringen @Order(value) på enskilda testmetoder. Lägre tal för value innebär tidigare körning.
På så sätt kan du definiera en exakt, anpassad ordning för dina tester.
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import static org.junit.jupiter.api.Assertions.assertTrue;
@TestMethodOrder(OrderAnnotation.class) // Activate @Order annotation
public class CustomOrderDemo {
@Test
@Order(2) // This test runs second
void processStepTwo() {
System.out.println("-> Running processStepTwo");
assertTrue(true);
}
@Test
@Order(1) // This test runs first
void initializeSystem() {
System.out.println("-> Running initializeSystem");
assertTrue(true);
}
@Test
@Order(3) // This test runs third
void finalizeReport() {
System.out.println("-> Running finalizeReport");
assertTrue(true);
}
}Bästa praxis för ordning
Även om uttrycklig testordning är kraftfull bör den användas med försiktighet:
- Prioritera oberoende: Varje test bör helst kunna köras på egen hand.
- Begriplighet: För mycket ordning kan göra tester svårare att förstå och underhålla.
- Underhållsarbete: Ändringar i systemet kan kräva att ordningsvärdena omvärderas och uppdateras.
Använd endast ordning när det finns ett starkt och välgrundat skäl, och föredra @Order för att tydligt uttrycka avsikten.
Kontroll av livscykel och ordning
Betrakta följande JUnit 5-testklass:
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.assertEquals;
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class QuizTest {
private int sharedValue = 0;
@BeforeAll
void setup() {
sharedValue = 10;
System.out.println("BeforeAll: sharedValue = " + sharedValue);
}
@Test
@Order(2)
void testB() {
sharedValue += 2;
System.out.println(" TestB: sharedValue = " + sharedValue);
assertEquals(13, sharedValue);
}
@Test
@Order(1)
void testA() {
sharedValue += 1;
System.out.println(" TestA: sharedValue = " + sharedValue);
assertEquals(11, sharedValue);
}
@AfterAll
void teardown() {
System.out.println("AfterAll: sharedValue = " + sharedValue);
}
}Vilket slutvärde för sharedValue skrivs ut i metoden @AfterAll?
Sammanfattning: Livscykel och ordning
I den här lektionen har du lärt dig avancerade funktioner i JUnit 5 för att styra testkörningen:
- Livscykel på klassnivå:
@BeforeAlloch@AfterAllför förberedelser och nedmontering som sker en gång. - Instansens livscykel:
@TestInstance(Lifecycle.PER_CLASS)för att möjliggöra delat tillstånd och icke-statiska hook-metoder på klassnivå. - Ordning för testmetoder:
@TestMethodOrder(med strategier somAlphanumericellerOrderAnnotation) för att definiera körningsordningen. - Anpassad ordning:
@Orderför exakt kontroll över metodernas ordningsföljd.
Kom ihåg att använda uttrycklig ordning med omdöme och prioritera oberoende och robusta tester!
Lär dig Testning på avancerad nivå: JUnit, Mockito och integrationstester med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Testlivscykel och ordning” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Testning på avancerad nivå: JUnit, Mockito och integrationstester, inklusive ”Testlivscykel och ordning”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.
Vad lär jag mig i ”Testlivscykel och ordning”?
Styr körordningen för tester och hantera testförberedelser och nedmontering med avancerade livscykelannoteringar. Ni övar på Testning på avancerad nivå: JUnit, Mockito och integrationstester med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Testning på avancerad nivå: JUnit, Mockito och integrationstester?
Du behöver inga förkunskaper. Utbildningen i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Testlivscykel och ordning”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektionen?
Ja. Varje Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Testlivscykel och ordning
- Parameteriserade och dynamiska tester
- Testning av undantag och tidsgränser
- Villkorliga tester och antaganden